1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
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 #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
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 *******************************************************************************/
19 /********************************************************************20**
25 Desc: This file contain the hash definations for RLC
29 *********************************************************************21*/
31 @brief RLC Hash definitions
36 #include "rl_interface.h"
37 #include "rl_common.h"
40 #define RLCLAYERNAME "LTE RLC" /* Layer Name */
48 /* RLC-SPLIT Activity */
55 #define RLC_2K_BYTE 2048
57 /* RLC RB flag bits */
58 #define RLC_RB_REESTABLISH_DL RLC_BIT0
59 #define RLC_RB_REESTABLISH_UL RLC_BIT1
60 #define RLC_RB_DELETE_DL RLC_BIT2
61 #define RLC_RB_DELETE_UL RLC_BIT3
64 #define RLC_MOD_1024 0x3FF /* used for MOD 1024 */
68 /************************************************************************
70 ************************************************************************/
72 #define RLC_SAP_NOT_CFG 0 /*!< SAP Not Configured */
73 #define RLC_SAP_CFG 1 /*!< SAP Configured but not not bound */
74 #define RLC_SAP_BND 2 /*!< SAP Bound */
75 #define RLC_SAP_BINDING 3 /*!< SAP Bind initiated */
76 #define RLC_SAP_UBND 4 /*!< SAP Unbind */
78 #define RLC_MAX_SAP_BND_RETRY 3 /*!< Maximum SAP Bin Retries */
80 #define RLC_MAX_UE 0xffffffff /*!< Maximum number of UEs. */
82 /* Maximum number of Saps */
83 #define RLC_MAX_UDXSAPS 1 /*!< Maximum number of UDX Saps */
84 #define RLC_MAX_KWUSAPS 2 /*!< Maximum number of KWU Saps. */
85 #define RLC_MAX_CKWSAPS 1 /*!< Maximum number of CKW Saps. */
87 #define RLC_MAX_RGUSAPS 4//5 /*!< Maximum number of RGU Saps. */
89 #define RLC_MAX_RGUSAP_TMR 1 /*!< Maximum number of RGU SAP Timers. */
91 #define RLC_UI_RRC 0 /*!< Upper interface RRC sap Id. */
92 #define RLC_UI_PDCP 1 /*!< Upper interface PDCP sap Id. */
95 /* TODO. This works for FDD only. For TDD the array dimension
96 * should be changed according to the number of Harq Procs */
97 #define RLC_MAX_TB_PER_UE 64 /*!< Maximum number of tbCb for UE */
98 #define RLC_INVALID_TBID RLC_MAX_TB_PER_UE
100 /*******************************************************************************
101 * Memory related Defines
102 ******************************************************************************/
104 /* Allocate function */
105 #define RLC_ALLOC(_cb,_buf, _size) \
107 SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, \
109 memset((_buf), 0, _size); \
112 #define RLC_RMV_SDU(_cb,_sduQ,_sdu) \
114 SPutMsg(_sdu->mBuf); \
115 cmLListDelFrm(_sduQ,&_sdu->lstEnt); \
116 RLC_FREE(_cb,_sdu, sizeof(RlcSdu)); \
119 #define RLC_FREE(_cb,_buf, _size) \
121 (Void) SPutSBuf(_cb->init.region, _cb->init.pool, \
122 (Data *) _buf, (Size) _size); \
128 #define RLC_FREE_SHRABL_BUF(_region, _pool,_buf, _size) \
132 (Void) SPutStaticBuffer(_region, _pool, \
133 (Data *) _buf, (Size) _size, 0); \
138 #define RLC_FREE_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
140 (Void) SPutStaticBuffer(_region, _pool, \
141 (Data *) _buf, (Size) _size, 0); \
145 #define RLC_ALLOC_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
147 SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
151 #define RLC_ALLOC_SHRABL_BUF(_region, _pool,_buf, _size) \
153 if (SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
154 (Size) _size, 0) == ROK) \
156 memset((_buf), 0, _size); \
163 /* Allocate function */
164 #define RLC_ALLOC(_cb,_buf, _size) \
166 if (SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, \
167 (Size) _size) == ROK) \
169 memset((_buf), 0, _size); \
177 #define RLC_ALLOC_WC(_cb,_buf, _size) \
178 SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, (Size) _size)
180 #define RLC_RMV_SDU(_cb,_sduQ,_sdu) \
184 SPutMsg(_sdu->mBuf); \
186 cmLListDelFrm(_sduQ,&_sdu->lstEnt); \
187 RLC_FREE(_cb,_sdu, sizeof(RlcSdu)); \
190 #define RLC_FREE(_cb,_buf, _size) \
194 (Void) SPutSBuf(_cb->init.region, _cb->init.pool, \
195 (Data *) _buf, (Size) _size); \
202 /* kw002.201 Freeing from region of pst */
203 #define RLC_PST_FREE(_region, _pool, _buf, _size) \
207 (Void) SPutSBuf(_region, _pool, \
208 (Data *) _buf, (Size) _size); \
213 #ifdef XEON_SPECIFIC_CHANGES
214 #ifdef SS_LOCKLESS_MEMORY
215 #define RLC_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
219 (Void) SPutStaticBuffer(_region, _pool, \
220 (Data *) _buf, (Size) _size, 0); \
225 #define RLC_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
227 SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
233 #define RLC_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
237 (Void) SPutSBuf(_region, _pool, \
238 (Data *) _buf, (Size) _size); \
243 #define RLC_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
245 SGetSBuf(_region, _pool, (Data **)&_buf, \
248 #endif /* SS_LOCKLESS_MEMORY */
252 #define RLC_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
256 (Void) SPutStaticBuffer(_region, _pool, \
257 (Data *) _buf, (Size) _size, 0); \
262 #define RLC_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
264 SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
269 #define RLC_MEM_CPY(_dst, _src, _size) memcpy(_dst, _src, _size);
271 #define RLC_MEM_ZERO(_buf, _size) memset((_buf), 0, _size);
273 #define RLC_GET_MEM_REGION(_cb) (_cb->init.region)
275 #define RLC_GET_MEM_POOL(_cb) (_cb->init.pool)
277 #define RLC_GET_MEM_POOL_ADDRESS(_cb) (&_cb->init.pool)
279 /* Memset to value */
280 #define RLC_MEM_SET(_arg, _val, _size) memset(_arg, _val, _size);
283 /* Send an alarm for sapId events */
284 /* kw005.201 added support for L2 Measurement */
286 #define RLC_GETSDUIDX(_sduIdx) \
288 _sduIdx = (((_sduIdx)+1) % RLC_L2MEAS_MAX_OUTSTNGSDU);\
290 #define RLC_SEND_SAPID_ALARM(_cb,_sapId, _evnt, _cause) \
292 rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, _sapId, 0, 0); \
294 #define RLC_SEND_UEID_ALARM(_cb,_ueId, _qci, _evnt, _cause) \
296 rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, 0, _ueId, _qci); \
298 #else /* LTE_L2_MEAS */
299 #define RLC_SEND_SAPID_ALARM(_cb,_sapId, _evnt, _cause) \
301 rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, _sapId, 0); \
303 #define RLC_SEND_UEID_ALARM(_cb,_ueId, _evnt, _cause) \
305 rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, 0, _ueId); \
307 #endif /* LTE_L2_MEAS */
309 /*******************************************************************************
311 ******************************************************************************/
313 /* RLC Configuration parameters */
314 #define RLC_MAX_UL_LI (2 * RLC_MAX_LI)
315 /*macro RLC_MAX_DL_LI is moved to kw_env.h file */
316 #define RLC_MAX_DAT RLC_MAXIMUM_DAT
317 /*macro RLC_MAX_PDU is moved to kw_env.h file */
318 #define RLC_MAX_RB_PER_CELL 10
319 #define RLC_MAX_SRB_PER_UE 3
320 #define RLC_MAX_DRB_PER_UE 32
321 #define RLC_MAX_LCH_PER_UE 12
322 #define RLC_MAX_LCH_PER_CELL 6
323 #define RLC_MAX_NUM_RB 24
324 #define RLC_MAX_UE 0xffffffff
325 #define RLC_UE_LIST_BUCKET_SIZE 128
326 #define RLC_CELL_LIST_BUCKET_SIZE 10
327 #define RLC_TRANS_ID_LST_BKT_SIZE 10
328 #define RLC_MAX_RB 32
330 /* RLC Mode defines */
331 #define RLC_MODE_TM 1
332 #define RLC_MODE_UM 2
333 #define RLC_MODE_AM 3
335 /* Direction defines */
336 #define RLC_DIR_UL 1 /*!< Unlink direction */
337 #define RLC_DIR_DL 2 /*!< Downlink direction */
338 #define RLC_DIR_BOTH 3 /*!< Both Downlink and Unlink */
340 #define RLC_DEF_SEQ_NUM 0 /**< Sequence number to pick in case of duplicate
341 entries in hash list searches*/
346 * Macro to find the miniumum of two numbers
348 * @param[in] x First number
349 * @param[in] y Second number
352 #define RLC_MIN(x,y) (x) < (y) ? (x) : (y)
357 * Macro to the RLC instance
359 * @param[in] _inst Instance Id
362 #define RLC_GET_RLCCB(_inst) rlcCb[_inst]
364 #define RLC_ADD_SDU 1 /*!< Add SDU. */
365 #define RLC_DEL_SDU 2 /*!< Delete SDU. */
367 #define RLC_CFM_NOK 0 /*!< Do not send DatCfm */
368 #define RLC_CFM_OK 1 /*!< Send DatCfm */
370 /* Set the unsolictated Status flag */
371 #define RLC_SET_USTA_FLAG(_rlcCb, _value) \
373 _rlcCb->init.usta = _value; \
376 /* Macros to get the init parameters */
377 #define RLC_GET_DBG_MASK(_rlcCb) (_rlcCb->init.dbgMask)
378 #define RLC_GET_LMPST_MEM_POOL(_rlcCb) (_rlcCb->init.lmPst.pool)
379 #define RLC_GET_LMPST_MEM_REGION(_rlcCb) (_rlcCb->init.lmPst.region)
381 /* Macros for configuration module */
382 #define RLC_CFG_FILL_CFG_CFM(_entCfm, _rbId, _rbType, _status, _reason) \
384 _entCfm->rbId = _rbId; \
385 _entCfm->rbType = _rbType; \
386 _entCfm->status.status = _status; \
387 _entCfm->status.reason = _reason; \
391 * @def RLC_VALIDATE_UE_RBID
393 * This macro validates whether the _rbId passed is valid or not. It checks
394 * if the _rbId is within the maximum value depending on the _rbType.
395 * Returns TRUE if valid else FALSE
397 * @param[in] _rbType Type of the Radio Bearer; SRB or DRB
398 * @param[in] _rbId RB Id of the RB to be validated
401 #define RLC_VALIDATE_UE_RBID(_rbType, _rbId) \
402 ((_rbType == CM_LTE_SRB && _rbId < RLC_MAX_SRB_PER_UE) || \
403 (_rbType == CM_LTE_DRB && _rbId < RLC_MAX_DRB_PER_UE))
405 /*******************************************************************************
407 ******************************************************************************/
408 #if (ERRCLASS & ERRCLS_INT_PAR)
409 #define RLC_VALDATE_SAP(_cb,_chkSpId, _sap, _ret) \
411 if (_chkSpId != _sap->spId) \
413 RLCLOGERROR(_cb,ERRCLS_DEBUG, EKWxxx, (ErrVal) RFAILED, \
414 "Sap Id Validation Failed."); \
417 /* SAP state validation */ \
418 if(_sap->state != RLC_SAP_BND) \
420 RLCLOGERROR(_cb,ERRCLS_INT_PAR, EKWXXX, (ErrVal) RFAILED, \
421 "Sap State Invalid."); \
422 RLC_SEND_SAPID_ALARM(_cb,0, LCM_EVENT_UI_INV_EVT, LCM_CAUSE_INV_STATE); \
426 #else /* ERRCLASS & ERRCLS_INT_PAR */
427 #define RLC_VALDATE_SAP(_cb,_chkSpId, _sap, _ret) \
429 /* SAP state validation */ \
430 if(_sap->state != RLC_SAP_BND) \
432 RLCLOGERROR(_cb,ERRCLS_INT_PAR, EKWXXX, (ErrVal) RFAILED, \
433 "Sap State Invalid."); \
434 RLC_SEND_SAPID_ALARM(_cb,0, LCM_EVENT_UI_INV_EVT, LCM_CAUSE_INV_STATE); \
438 #endif /* ERRCLASS & ERRCLS_INT_PAR */
440 /*******************************************************************************
442 ******************************************************************************/
443 #define RLC_TMR_LEN 10
444 #define RLC_MAX_UM_TMR 1
445 #define RLC_MAX_AM_TMR 3
448 #define EVENT_RLC_UMUL_REASSEMBLE_TMR 1
449 #define EVENT_RLC_AMUL_REORD_TMR 2
450 #define EVENT_RLC_AMUL_STA_PROH_TMR 3
451 #define EVENT_RLC_AMDL_POLL_RETX_TMR 4
452 #define EVENT_RLC_WAIT_BNDCFM 5
453 /* kw005.201 added support for L2 Measurement */
455 #define EVENT_RLC_L2_TMR 6
456 #endif /* LTE_L2_MEAS */
458 /*******************************************************************************
460 ******************************************************************************/
462 * @def RLC_DBM_GET_RBCB_FROM_UECB
464 * This macro makes _rbCb point to the RB in _ueCb based on the passed
465 * _rbId and _rbType. _rbCb can point to NULLP
467 * @param[in] _rbId RB Id of the RB to be fetched
468 * @param[in] _rbType Type of the RB, SRB or DRB
469 * @param[in] _ueCb Pointer to the UECb for which to get the RB
470 * @param[out] _rbCb Pointer to the found RbCb
473 #define RLC_DBM_GET_RBCB_FROM_UECB(_rbId, _rbType, _ueCb, _rbCb) \
474 (_rbCb) = ((_rbType) == CM_LTE_SRB) ? (_ueCb)->srbCb[(_rbId)] : \
475 (_ueCb)->drbCb[(_rbId)];
477 * @def RLC_DBM_GET_CELL_RBCB
479 * This macro makes _rbCb point to the RB in the _rbCbLst.
480 * _rbCb can point to NULLP
482 * @param[in] _rbId RB Id of the RB to be fetched
483 * @param[in] _rbCbLst Pointer to array of RBCbs
484 * @param[out] _rbCb Pointer to the found RbCb
487 #define RLC_DBM_GET_CELL_RBCB(_rbId, _rbCbLst, _rbCb) \
488 (_rbCb) = (_rbCbLst)[(_rbId)];
490 /*******************************************************************************
492 ******************************************************************************/
493 #define RLC_UMDL rbCb->m.umDl
494 #define RLC_UMUL rbCb->m.umUl
496 /* Sequence Number length defines */
497 #define RLC_UM_CFG_6BIT_SN_LEN 1 /**< UM 6-bit Sequence number length
499 #define RLC_UM_CFG_12BIT_SN_LEN 2 /**< UM 12-bit Sequence number length
502 /* Sequence Number length defines */
503 #define RLC_AM_CFG_12BIT_SN_LEN 1 /**< AM 12-bit Sequence number length
505 #define RLC_AM_CFG_18BIT_SN_LEN 2 /**< AM 18-bit Sequence number length
509 * @def RLC_RMV_MAC_HDR_SZ
511 * If PDU size is greater than 127, MAC header would be 3 bytes else 2 bytes
513 * @param[in,out] _pduSz Size of the pdu
516 #define RLC_RMV_MAC_HDR_SZ(_pduSz) (_pduSz) -= ((_pduSz) > 127) ? 3 : 2;
519 * @def RLC_UM_GET_VALUE
521 * This macro is used to calculate the value of UM state variables used
522 * in comparisons. VR(UH) - UM Window Size is taken as the base modulus.
523 * Returns the modifed value
525 * @param[in] _val Value of the state variable
526 * @param[in] _kwUmUl Um Uplink control block
529 #define RLC_UM_GET_VALUE(_val,_kwUmUl) \
530 (((_val) - ((_kwUmUl).vrUh - (_kwUmUl).umWinSz)) & ((_kwUmUl).modBitMask))
532 /*******************************************************************************
534 ******************************************************************************/
535 #define RLC_AMDL rbCb->m.amDl
536 #define RLC_AMUL rbCb->m.amUl
539 #define RLC_DATA_PDU 1
540 #define RLC_CNTRL_PDU 0
542 #define RLC_FI_FIRST_SEG 0x02
543 #define RLC_FI_LAST_SEG 0x01
544 #define RLC_SI_FIRST_SEG 0x01
545 #define RLC_SI_LAST_SEG 0x02
546 #define RLC_SI_MID_SEG 0x03
548 #define RLC_POLL_SET 0x40 /* 01000000 */
549 #define RLC_POLL_UNSET 0xbf /* 10111111 */
550 #define RLC_MAX_NACK_CNT 100
551 /*RLC_MAX_CNTRL_FIELDS (Maximum size of Status Pdu)
552 * = MAX_NACK_CNT * sizeof(NACK_SN,E1,E2,E3,soStart,soEnd, nackRange)
553 * for 18 bit SN + Fixed Header*/
554 #define RLC_MAX_CNTRL_FIELDS ((RLC_MAX_NACK_CNT * 8) + 3)
556 /* Each LI(Length Indicator) holds approx 1+1/2 byte and some other fields thus keeping Header Size equal to twice of MAX LI */
557 /* 5GNR_RLC: Need to change value of HDRSZ as per number of PDUs going in one datReq */
558 #define RLC_MIN_HDRSZ 1
559 #define RLC_MAX_HDRSZ 5
560 #define RLC_AM_PDU_FIXED_HDRSZ 2
561 #define RLC_AM_PDU_12BIT_SN_HDRSZ 2
562 #define RLC_AM_PDU_18BIT_SN_HDRSZ 3
563 #define RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ 4
564 #define RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ 5
565 #define RLC_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ 2
566 #define RLC_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ 3
567 #define RLC_EXTN_HDRSZ 2
568 #define RLC_CNTRL_PDU_FIXED_HDRSZ 3
569 #define RLC_MAC_HDR_SZ2 2
570 #define RLC_MAC_HDR_SZ3 3
571 #define RLC_BYTE_LEN 8
572 #define RLC_2BYTE_LEN 16
574 #define RLC_NACK_E1E2_LEN 12
575 #define RLC_SO_LEN 15
577 #define RLC_CPT_LEN 3
583 #define RLC_SN_LEN 10
584 #define RLC_SN_LEN_12BITS 12
585 #define RLC_SN_LEN_18BITS 18
586 #define RLC_LSF_LEN 1
587 #define RLC_LI_LEN 11
588 #define RLC_STA_PDU_R_BITS_ACKSN_12BITS 7 /* 5GNR : Num Reserved bits in STATUS PDU */
589 #define RLC_STA_PDU_R_BITS_ACKSN_18BITS 1
590 #define RLC_STA_PDU_R_BITS_NACKSN_12BITS 1
591 #define RLC_STA_PDU_R_BITS_NACKSN_18BITS 3
592 #define RLC_NACK_RANGE_LEN 8
593 #define RLC_SO_LEN_5GNR 16
595 #define RLC_DC_POS 0x80
597 #define RLC_POLL_POS 0x40 /* 5GNR */
598 #define RLC_POLL_SHT 6 /* 5GNR */
599 #define RLC_SI_POS 0x30 /* 5GNR */
600 #define RLC_SI_SHT 4 /* 5GNR */
601 #define RLC_SN_POS_12BIT 0x0F
602 #define RLC_SN_POS_18BIT 0x03
603 #define RLC_AM_GET_WIN_SZ(_snLen) ((RLC_AM_CFG_12BIT_SN_LEN == (_snLen)) ? (2048) : (131072)) /* 5GNR */
604 #define RLC_RCV_BUF_BIN_SIZE 512 /* receive buffer size */
605 #define RLC_TX_BUF_BIN_SIZE 512 /* receive buffer size */
607 #define RLC_SDU_LST 1
608 #define RLC_SEG_LST 2
609 #define RLC_RETX_LST 3
610 #define RLC_ALL_BYTES_MISSING 0xffff
612 #define RLC_MAX_PDU_MAP 30 /*!< Maximum PDU Map. */
614 #define RLC_LLIST_FIRST_SDU(lstCp, nod) \
617 /*CM_LLIST_FIRST_NODE(&(lstCp), tmpNode);*/ \
618 /*if (tmpNode != NULLP)*/ \
619 if((tmpNode=cmLListFirst(&lstCp))) \
620 nod = (RlcSdu *)tmpNode->node; \
626 #define RLC_LLIST_FIRST_SEG(lstCp, nod) \
629 /*CM_LLIST_FIRST_NODE(&(lstCp), tmpNode);*/ \
630 /*if (tmpNode != NULLP)*/ \
631 if((tmpNode=cmLListFirst(&lstCp))) \
632 nod = (RlcSeg *)tmpNode->node; \
637 #define RLC_LLIST_FIRST_RETX(lstCp, nod) \
640 /*CM_LLIST_FIRST_NODE(&(lstCp), tmpNode);*/ \
641 /*if (tmpNode != NULLP)*/ \
642 if((tmpNode=cmLListFirst(&lstCp))) \
643 nod = (RlcRetx *)tmpNode->node; \
648 #define RLC_LLIST_NEXT_SDU(lstCp, nod) \
651 /*CM_LLIST_NEXT_NODE(&(lstCp), tmpNode);*/ \
652 /*if (tmpNode != NULLP) */ \
653 if((tmpNode = cmLListNext(&lstCp))) \
654 nod = (RlcSdu *)tmpNode->node; \
660 #define RLC_LLIST_NEXT_SEG(lstCp, nod) \
663 (lstCp).crnt = &((nod)->lstEnt); \
664 /*CM_LLIST_NEXT_NODE(&(lstCp), tmpNode);*/ \
665 /*if (tmpNode != NULLP)*/ \
666 if((tmpNode = cmLListNext(&lstCp))) \
667 nod = (RlcSeg *)tmpNode->node; \
673 #define RLC_LLIST_NEXT_RETX(lstCp, nod) \
676 /*CM_LLIST_NEXT_NODE(&(lstCp), tmpNode);*/ \
677 /*if (tmpNode != NULLP) */ \
678 if ((tmpNode = cmLListNext(&lstCp))) \
679 nod = (RlcRetx *)tmpNode->node; \
685 #define RLC_LLIST_LAST_RETX(lstCp, nod) \
687 CmLList *tempNode = NULLP; \
688 cmLListLast(&lstCp); \
689 tempNode = cmLListCrnt(&lstCp); \
690 if (tempNode != NULLP) \
691 nod = (RlcRetx *)tempNode->node; \
696 #define RLC_LLIST_LAST_SEG(lstCp, nod) \
698 CmLList *tempNode = NULLP; \
699 cmLListLast(&lstCp); \
700 tempNode = cmLListCrnt(&lstCp); \
701 if (tempNode != NULLP) \
702 nod = (RlcSeg *)tempNode->node; \
707 #define RLC_LLIST_LAST_SDU(lstCp, nod) \
709 CmLList *tempNode = NULLP; \
710 cmLListLast(&lstCp); \
711 tempNode = cmLListCrnt(&lstCp); \
712 if (tempNode != NULLP) \
713 nod = (RlcSdu *)tempNode->node; \
718 #define CM_LLIST_INS_AFT_CRNT(lstCp, nod) \
720 CmLList *nodeToIns = &nod->lstEnt;\
721 nodeToIns->node = (PTR) nod;\
722 cmLListInsAfterCrnt(&lstCp, nodeToIns); \
725 #define CM_LLIST_INS_BEF_CRNT(lstCp, nod) \
727 CmLList *nodeToIns = &nod->lstEnt; \
728 nodeToIns->node = (PTR) nod; \
729 cmLListInsCrnt(&lstCp, nodeToIns); \
732 #define RLC_LLIST_DEL_RECBUF(_recBuf) \
734 RlcSeg *_seg = NULLP; \
735 RLC_LLIST_FIRST_SEG(_recBuf->segLst, _seg); \
738 cmLListDelFrm(&_recBuf->segLst, &_seg->lstEnt); \
739 RLC_FREE(_seg, sizeof(RlcSeg)); \
740 RLC_LLIST_NEXT_SEG(_recBuf->segLst, _seg); \
744 #define RLC_UMM_LLIST_FIRST_SEG(lstCp, nod) \
747 if((tmpNode=cmLListFirst(&lstCp))) \
748 nod = (RlcUmSeg *)tmpNode->node; \
751 } /*!< um mode first segment of linked list*/
753 #define RLC_UMM_LLIST_NEXT_SEG(lstCp, nod) \
756 (lstCp).crnt = &((nod)->lstEnt); \
757 if((tmpNode = cmLListNext(&lstCp))) \
758 nod = (RlcUmSeg *)tmpNode->node; \
761 }/*!< next segment in um mode linked list*/
763 #define MODAMT(x, y, z,_snModMask) \
765 y = (x - z) & _snModMask; \
768 #define MODAMR(x, y, z , _snModMask) \
770 y = (x - z) & (_snModMask); \
774 * @def RLC_AM_IS_TRANS_WIN_STALLED
776 * This macro is used to check if the AM transmit window is stalled or not.
777 * The tramist window is stalled when the distance between txNext and txNextAck
778 * is greater than equal to Window Size. Actually it should never be greater
780 * Returns TRUE if the window is stalled else FALSE
782 * @param[in] _amDl AM Downlink control block
785 #define RLC_AM_IS_TRANS_WIN_STALLED(_amDl) \
786 ((((_amDl)->txNext - (_amDl)->txNextAck) & _amDl->snModMask) >= (RLC_AM_GET_WIN_SZ(_amDl->snLen)))
789 #define RLC_AM_TRANS_WIN_SIZE(_amDl) \
790 (((_amDl)->txNext - (_amDl)->txNextAck) & _amDl->snModMask)
793 #define RLC_AM_IS_POLL_BIT_SET(_amDl) \
794 (RLC_AMDL.pollSn == ((RLC_AMDL.txNext - 1) & RLC_AMDL.snModMask))
796 #define RLC_FILL_CNTRL_INFO(cntrlInfo, _val, _len, _idx, _eb)\
798 cntrlInfo.val = _val; \
799 cntrlInfo.len = _len; \
800 cntrlInfo.idx = _idx; \
801 cntrlInfo.emtBits = _eb; \
803 #define RLC_FILL_PREV_IDX(cntrlInfo, _e1Idx, _e1eb, _idx, _eb) \
805 _e1Idx = cntrlInfo.e1Idx; \
806 _e1eb = cntrlInfo.e1eb; \
807 _idx = cntrlInfo.idx; \
808 _eb = cntrlInfo.emtBits; \
811 #define RLC_FILL_HDR_ARGS(hdrInfo, _val, _len) \
813 hdrInfo.val = _val; \
814 hdrInfo.len = _len; \
817 /* kw003.201 - This macro provides the header size other than the */
818 /* fixed header of 2 bytes for each AMD PDU or 4 bytes*/
819 /* for an AM PDU segment */
820 #define RLC_AM_EXTN_HDRSZ(_numLi, _eHdrSz) \
822 if ((_numLi - 1) % 2) \
824 _eHdrSz = ((3 * (_numLi - 2)) >> 1) + 2; \
828 _eHdrSz = (3 * (_numLi - 1)) >> 1; \
832 /* Update poll bit in the buffer */
833 #define RLC_UPD_POLL_BIT(_gCb, _retx, _poll) \
837 if (_poll != _retx->amHdr.p) \
839 /* Get the first byte of the buffer */ \
840 SRemPreMsg((Data *)&fHdr, _retx->seg); \
843 fHdr = fHdr | RLC_POLL_SET; \
847 fHdr = fHdr & RLC_POLL_UNSET; \
849 /* Concatenated updated hdr to the mBuf */ \
850 SAddPreMsg ((Data)fHdr, _retx->seg); \
852 /* Update poll bit in the hdrInfo */ \
853 _retx->amHdr.p = _poll; \
856 #define RLC_AM_ELIMINATE_EXTN_HDR(_pduSz, _sduSz, _numLi) \
858 if ( (_pduSz > _sduSz) && (_sduSz < 2048) ) \
860 _pduSz -= (_numLi % 2) ? 1 : 2; \
864 * @def RLC_AM_CHK_SN_WITHIN_RECV_WINDOW
866 * This macro is used to check if a Sequence Number falls within the AM
867 * reception window or not.
868 * The condition is VR(R) <= SN < VR(MR), which are subtracting the base
869 * modulus becomes 0 <= (SN - VR(R)) % SNLen < (VR(MR) - VR(R)) % SnLen
870 * NOTE: Careful with the parantheses
872 * Returns TRUE if within the window; FALSE otherwise
874 * @param[in] _sn The sequence number to be checked
875 * @param[in] _amUl AM Uplink control block
878 #define RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(_sn, _amUl) \
879 ((((_sn) - (_amUl->rxNext)) & (_amUl->snModMask)) < (((_amUl->vrMr) - (_amUl->rxNext)) & (_amUl->snModMask)))
881 #define RLC_POWER(x, y) x << (y-1);
884 #define rlcCpyMsg(_cb,x, y) \
885 (SAddMsgRef((x), RLC_GET_MEM_REGION(_cb), RLC_GET_MEM_POOL(_cb), (y)))
887 /* L2 optimization for mUe/Tti: Removing dup buf*/
888 #define rlcCpyMsg(_cb,x, y) \
889 (SIncMsgRef((x), RLC_GET_MEM_REGION(_cb), RLC_GET_MEM_POOL(_cb), (y)))
892 // printf("Copy Msg %x \n",x);
894 /*******************************************************************************
896 ******************************************************************************/
897 #define RLC_DBG_SUB_MASK DBGMASK_MI /**< Use for sub-mask */
898 #define RLC_DBGMASK_DETAIL (RLC_DBG_SUB_MASK << 0) /**< Parameters, It will give
900 #define RLC_DBGMASK_BRIEF (RLC_DBG_SUB_MASK << 1) /**< Info, It will give info at
901 entry and exit places along
902 with certain state changes */
903 #define RLC_DBGMASK_ERROR (RLC_DBG_SUB_MASK << 2) /**< Error information */
904 #define RLC_DBGMASK_FATAL (RLC_DBG_SUB_MASK << 3) /**< FATAL errors like memory
905 resource failure etc., */
907 #define RLC_DBG_MDL_MASK (RLC_DBG_SUB_MASK << 4)
909 #define RLC_DBGMASK_TM (RLC_DBG_MDL_MASK << 0) /**< TM */
910 #define RLC_DBGMASK_UM (RLC_DBG_MDL_MASK << 1) /**< UM */
911 #define RLC_DBGMASK_AM (RLC_DBG_MDL_MASK << 2) /**< AM */
912 #define RLC_DBGMASK_DL (RLC_DBG_MDL_MASK << 3) /**< DL */
913 #define RLC_DBGMASK_UL (RLC_DBG_MDL_MASK << 4) /**< UL */
914 #define RLC_DBGMASK_CFG (RLC_DBG_MDL_MASK << 5) /**< CFG */
915 #define RLC_DBGMASK_LMM (RLC_DBG_MDL_MASK << 6) /**< LMM */
916 #define RLC_DBGMASK_INF (RLC_DBG_MDL_MASK << 7) /**< UI, LI */
917 #define RLC_DBGMASK_DUT (RLC_DBG_MDL_MASK << 8) /**< DBM, UTL, TMR */
918 #define RLC_DBGMASK_MBUF_PRNT (RLC_DBG_MDL_MASK << 9) /**< MBUF, useful in
921 #define RLC_DBGMASK_MEM_INFO (RLC_DBG_MDL_MASK << 10) /**< Print SSI memory
923 #define RLC_DBGMASK_UDX (RLC_DBG_MDL_MASK << 11) /**< UDX interface */
926 #define RLC_PRNT_BORDER \
929 RLC_PRNT((_kwPBuf, "\n==========================\n")); \
932 #define RLC_PRNT_HLINE(_cb,_pMsg) \
934 sprintf((_cb)->init.prntBuf, "[RLC_LAYER: %s:%d]::", __FILE__, __LINE__); \
935 SPrint((_cb)->init.prntBuf); \
936 RLC_PRNT_TSTAMP(_cb); \
937 sprintf((_cb)->init.prntBuf, _pMsg); \
938 SPrint((_cb)->init.prntBuf); \
941 #define RLC_PRNT(_cb,_prntbuf) \
944 SPrint(_cb->init.prntBuf); \
947 #define RLC_PRINT_TO_BUFFER(_cb,...) \
949 snprintf((_cb)->init.prntBuf, PRNTSZE, "[%s]::", __func__); \
950 SPrint((_cb)->init.prntBuf); \
951 snprintf(_cb->init.prntBuf, PRNTSZE,__VA_ARGS__); \
952 SPrint(_cb->init.prntBuf); \
955 #define RLC_PRNT_TSTAMP(_cb) \
959 memset((&dt), 0, sizeof(DateTime)); \
961 sprintf(_buf, "date: %02d/%02d/%04d time: %02d:%02d:%02d", \
962 (int)dt.month,(int)dt.day,(int)dt.year + 1900, \
963 (int)dt.hour,(int)dt.min,(int)dt.sec); \
964 RLC_PRNT(_cb,(_cb->init.prntBuf,("[%s]", _buf))); \
967 #define RLC_PRNT_MBUF(_cb,_mBufPtr) \
970 if(_cb->init.dbgMask & (RLC_DBGMASK_MBUF_PRNT)) \
972 RLC_PRNT_HLINE(_cb,("\nMessage Buffer Contents:\n")); \
973 SPrntMsg ((Buffer *)_mBufPtr, 0, 0); \
977 #define RLC_PRNT_MEMINFO(_cb) \
981 if(_cb->init.dbgMask & (RLC_DBGMASK_MEM_INFO)) \
983 RLC_PRNT_HLINE(_cb,("\nMemory Information:\n")); \
984 SRegInfoShow(0, &_memInfo); \
988 #define RLCDBGP_INTERNAL(_cb,_mask,...) \
991 if (!((_cb->init.dbgMask & _mask) ^ _mask)) \
993 RLC_PRINT_TO_BUFFER(_cb, __VA_ARGS__); \
997 #define RLCDBGP_ERROR(_cb, ...) \
998 RLCDBGP_INTERNAL(_cb,(RLC_DBGMASK_ERROR | RLC_MODULE),__VA_ARGS__)
1000 #define RLCDBGP_DETAIL(_cb, ...) \
1001 RLCDBGP_INTERNAL(_cb,(RLC_DBGMASK_DETAIL | RLC_MODULE),__VA_ARGS__)
1003 #define RLCDBGP_BRIEF(_cb, ...) \
1004 RLCDBGP_INTERNAL(_cb,(RLC_DBGMASK_BRIEF | RLC_MODULE),__VA_ARGS__)
1007 #define RLC_PRNT_HLINE(_cb,_pMsg)
1008 #define RLC_PRNT(_cb,_prntbuf)
1009 #define RLC_PRNT_TSTAMP(_cb)
1010 #define RLC_PRNT_MBUF(_cb,_mBufPtr)
1011 #define RLC_PRNT_MEMINFO(_cb)
1012 #define RLCDBGP(_cb,_mask, _arg)
1013 #define RLCDBGP_ERROR(_cb, ...)
1014 #define RLCDBGP_DETAIL(_cb, ...)
1015 #define RLCDBGP_BRIEF(_cb, ...)
1018 /*******************************************************************************
1020 ******************************************************************************/
1021 #define RLC_LMM_RB_STS_INC(_cb) (_cb)->genSts.numOfRb++;
1023 #define RLC_LMM_RB_STS_DEC(_cb) (_cb)->genSts.numOfRb--;
1025 #if defined(SS_MULTICORE_SUPPORT) && defined(SS_M_PROTO_REGION)
1026 #define RLC_FILL_SAP_HELPER(_Sap, _cfg, _gCb)\
1028 _Sap->pst.selector = _cfg->selector; \
1029 _Sap->pst.route = _cfg->route; \
1030 _Sap->pst.prior = _cfg->priority; \
1031 _Sap->pst.region = _gCb->init.region;\
1032 _Sap->pst.pool = _gCb->init.pool;\
1033 _Sap->pst.dstProcId = _cfg->procId; \
1034 _Sap->pst.dstEnt = _cfg->ent; \
1035 _Sap->pst.dstInst = _cfg->inst; \
1036 _Sap->pst.srcProcId = _gCb->init.procId; \
1037 _Sap->pst.srcEnt = _gCb->init.ent; \
1038 _Sap->pst.srcInst = _gCb->init.inst; \
1039 _Sap->pst.event = EVTNONE; \
1040 _Sap->spId = _cfg->sapId; \
1041 _Sap->state = RLC_SAP_CFG; \
1043 #else /* defined(SS_MULTICORE_SUPPORT) && defined(SS_M_PROTO_REGION) */
1044 #define RLC_FILL_SAP_HELPER(_Sap, _cfg, _gCb)\
1046 _Sap->pst.selector = _cfg->selector; \
1047 _Sap->pst.route = _cfg->route; \
1048 _Sap->pst.prior = _cfg->priority; \
1049 _Sap->pst.region = _cfg->mem.region;\
1050 _Sap->pst.pool = _cfg->mem.pool;\
1051 _Sap->pst.dstProcId = _cfg->procId;\
1052 _Sap->pst.dstEnt = _cfg->ent;\
1053 _Sap->pst.dstInst = _cfg->inst;\
1054 _Sap->pst.srcProcId = _gCb->init.procId;\
1055 _Sap->pst.srcEnt = _gCb->init.ent;\
1056 _Sap->pst.srcInst = _gCb->init.inst;\
1057 _Sap->pst.event = EVTNONE;\
1058 _Sap->spId = _cfg->sapId;\
1059 _Sap->state = RLC_SAP_CFG;\
1063 /*******************************************************************************
1065 ******************************************************************************/
1066 #define RLC_GET_DL_SAPCB(_cb, _rbCb) (_cb->u.dlCb->udxDlSap + _rbCb->udxSapId)
1067 #define RLC_GET_UDX_SAP(_cb) (_cb->u.ulCb->udxUlSap)
1069 /* kw005.201 added support for L2 Measurement */
1071 #define RLC_L2_MAX_TIMERS 1
1072 #define RLC_QCI_LIST_BUCKET_SIZE 10
1073 #define RLC_TB_LIST_BUCKET_SIZE 10
1074 #define RLC_MAX_L2MEAS_EVT 10
1075 /* L2 Measurement index to be used in rbCb to store measData */
1076 #define RLC_L2MEAS_ACT_UE 0
1077 #define RLC_L2MEAS_DL_DELAY 1
1078 #define RLC_L2MEAS_DL_DISC 2
1079 #define RLC_L2MEAS_UU_LOSS 3
1080 #define RLC_L2MEAS_DL_IP 4
1081 #define RLC_L2MEAS_UL_IP 5
1082 #endif /* LTE_L2_MEAS */
1084 #define RLC_RDWR_LOCK(_lockPtr)
1085 #define RLC_RDWR_UNLOCK(_lockPtr)
1086 #define RLC_TIME_DIFF(t1,t2) \
1087 (t1<t2 ? ((0xffffffff - t2) + t1 ): (t1 - t2))
1089 #endif /* __KWH__ */
1091 /********************************************************************30**
1094 **********************************************************************/