DuMacUeCreateRspFunc DuMacUeCreateRspOpts[] =
{
packDuMacUeCreateRsp, /* packing for loosely coupled */
- duHandleMacUeCreateRsp, /* packing for tightly coupled */
+ DuHandleMacUeCreateRsp, /* packing for tightly coupled */
packDuMacUeCreateRsp, /* packing for light weight loosly coupled */
};
******************************************************************************/
#ifdef MCCABE_COV
/* Allocate function */
-#define KW_ALLOC(_cb,_buf, _size) \
+#define RLC_ALLOC(_cb,_buf, _size) \
{ \
SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, \
(Size) _size); \
{ \
SPutMsg(_sdu->mBuf); \
cmLListDelFrm(_sduQ,&_sdu->lstEnt); \
- KW_FREE_WC(_cb,_sdu, sizeof(KwSdu)); \
+ RLC_FREE_WC(_cb,_sdu, sizeof(KwSdu)); \
}
-#define KW_FREE(_cb,_buf, _size) \
+#define RLC_FREE(_cb,_buf, _size) \
{ \
(Void) SPutSBuf(_cb->init.region, _cb->init.pool, \
(Data *) _buf, (Size) _size); \
_buf = NULLP; \
}
-#define KW_FREE_BUF(_buf) \
+#define RLC_FREE_BUF(_buf) \
{ \
SPutMsg(_buf); \
_buf = NULLP; \
#else
-#define KW_FREE_SHRABL_BUF(_region, _pool,_buf, _size) \
+#define RLC_FREE_SHRABL_BUF(_region, _pool,_buf, _size) \
{ \
if (_buf != NULLP) \
{ \
} \
}
-#define KW_FREE_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
+#define RLC_FREE_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
{ \
(Void) SPutStaticBuffer(_region, _pool, \
(Data *) _buf, (Size) _size, 0); \
_buf = NULLP; \
}
-#define KW_ALLOC_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
+#define RLC_ALLOC_SHRABL_BUF_WC(_region, _pool,_buf, _size) \
{ \
SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
(Size) _size, 0); \
}
-#define KW_ALLOC_SHRABL_BUF(_region, _pool,_buf, _size) \
+#define RLC_ALLOC_SHRABL_BUF(_region, _pool,_buf, _size) \
{ \
if (SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
(Size) _size, 0) == ROK) \
} \
}
/* Allocate function */
-#define KW_ALLOC(_cb,_buf, _size) \
+#define RLC_ALLOC(_cb,_buf, _size) \
{ \
if (SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, \
(Size) _size) == ROK) \
} \
}
-#define KW_ALLOC_WC(_cb,_buf, _size) \
+#define RLC_ALLOC_WC(_cb,_buf, _size) \
SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, (Size) _size)
#define KW_RMV_SDU(_cb,_sduQ,_sdu) \
SPutMsg(_sdu->mBuf); \
} \
cmLListDelFrm(_sduQ,&_sdu->lstEnt); \
- KW_FREE(_cb,_sdu, sizeof(KwSdu)); \
+ RLC_FREE(_cb,_sdu, sizeof(KwSdu)); \
}
-#define KW_FREE(_cb,_buf, _size) \
+#define RLC_FREE(_cb,_buf, _size) \
{ \
if (_buf != NULLP) \
{ \
} \
}
-#define KW_FREE_BUF(_buf) \
+#define RLC_FREE_BUF(_buf) \
{ \
if (_buf != NULLP) \
{ \
-#define KW_FREE_WC(_cb,_buf, _size) \
+#define RLC_FREE_WC(_cb,_buf, _size) \
{ \
(Void) SPutSBuf(_cb->init.region, _cb->init.pool, \
(Data *) _buf, (Size) _size); \
}
/* kw002.201 Freeing from region of pst */
-#define KW_PST_FREE(_region, _pool, _buf, _size) \
+#define RLC_PST_FREE(_region, _pool, _buf, _size) \
{ \
if (_buf != NULLP) \
{ \
#ifdef XEON_SPECIFIC_CHANGES
#ifdef SS_LOCKLESS_MEMORY
-#define KW_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
+#define RLC_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
{ \
if (_buf != NULLP) \
{ \
} \
}
-#define KW_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
+#define RLC_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
{ \
SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
(Size) _size, 0); \
#else
-#define KW_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
+#define RLC_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
{ \
if (_buf != NULLP) \
{ \
} \
}
-#define KW_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
+#define RLC_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
{ \
SGetSBuf(_region, _pool, (Data **)&_buf, \
(Size) _size); \
#else
-#define KW_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
+#define RLC_SHRABL_STATIC_BUF_FREE(_region, _pool, _buf, _size) \
{ \
if (_buf != NULLP) \
{ \
} \
}
-#define KW_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
+#define RLC_SHRABL_STATIC_BUF_ALLOC(_region, _pool, _buf, _size) \
{ \
SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
(Size) _size, 0); \
}
#endif
-#define KW_FREE_BUF_WC(_buf) SPutMsg((_buf));
+#define RLC_FREE_BUF_WC(_buf) SPutMsg((_buf));
#define KW_MEM_CPY(_dst, _src, _size) cmMemcpy((U8*)_dst, (U8 *)_src, _size);
#define KW_GET_MEM_POOL_ADDRESS(_cb) (&_cb->init.pool)
/* Memset to value */
-#define KW_MEM_SET(_arg, _val, _size) cmMemset((U8 *)_arg, (U8)_val, _size);
+#define RLC_MEM_SET(_arg, _val, _size) cmMemset((U8 *)_arg, (U8)_val, _size);
/* Alarms */
/* Send an alarm for sapId events */
#define KW_MIN(x,y) (x) < (y) ? (x) : (y)
/**
- * @def KW_GET_KWCB
+ * @def RLC_GET_RLCCB
*
* Macro to the RLC instance
*
* @param[in] _inst Instance Id
*
*/
-#define KW_GET_KWCB(_inst) kwCb[_inst]
+#define RLC_GET_RLCCB(_inst) rlcCb[_inst]
#define KW_ADD_SDU 1 /*!< Add SDU. */
#define KW_DEL_SDU 2 /*!< Delete SDU. */
#define KW_CFM_OK 1 /*!< Send DatCfm */
/* Set the unsolictated Status flag */
-#define KW_SET_USTA_FLAG(_kwCb, _value) \
+#define KW_SET_USTA_FLAG(_rlcCb, _value) \
{ \
- _kwCb->init.usta = _value; \
+ _rlcCb->init.usta = _value; \
}
/* Macros to get the init parameters */
-#define KW_GET_DBG_MASK(_kwCb) (_kwCb->init.dbgMask)
-#define KW_GET_LMPST_MEM_POOL(_kwCb) (_kwCb->init.lmPst.pool)
-#define KW_GET_LMPST_MEM_REGION(_kwCb) (_kwCb->init.lmPst.region)
+#define KW_GET_DBG_MASK(_rlcCb) (_rlcCb->init.dbgMask)
+#define KW_GET_LMPST_MEM_POOL(_rlcCb) (_rlcCb->init.lmPst.pool)
+#define KW_GET_LMPST_MEM_REGION(_rlcCb) (_rlcCb->init.lmPst.region)
/* Macros for configuration module */
#define KW_CFG_FILL_CFG_CFM(_entCfm, _rbId, _rbType, _status, _reason) \
while (_seg) \
{ \
cmLListDelFrm(&_recBuf->segLst, &_seg->lstEnt); \
- KW_FREE(_seg, sizeof(KwSeg)); \
+ RLC_FREE(_seg, sizeof(KwSeg)); \
KW_LLIST_NEXT_SEG(_recBuf->segLst, _seg); \
} \
}
* - reTxLst : Stores to be released AM Re TX PDU's
* - rbLst : List of AM DL RBs to be freed
*/
-typedef struct kwDlDataToBeFreed
+typedef struct rlcDlDataToBeFreed
{
CmLListCp sduLst; /*!< Queue of SDU's to be freed */
CmLListCp txLst; /*!< Stores to be released TX PDUs */
CmLListCp reTxLst; /*!< Stores to be released ReTX PDUs */
CmLListCp rbLst; /*!< List of AM DL RBs to be freed */
-}KwDlDataToBeFreed;
+}RlcDlDataToBeFreed;
/**
* @brief Structure to hold an information about DL RLC instance
* - shutdownReveived : Request for shutdown recevied or not
* - eventInQueue : Event for cleanup exists in queue or not
*/
-typedef struct _kwDlCb
+typedef struct rlcDlCb
{
U8 numKwuSaps; /*!< Number of RLC Data Saps */
U8 numUdxSaps; /*!< Number of RLC Data Saps */
KwRguSapCb *rguDlSap; /*!< RGU Sap Control Block */
CmHashListCp cellLstCp; /*!< Hashlist of CellCb */
CmHashListCp ueLstCp; /*!< Hashlist of UeCb */
- KwDlDataToBeFreed toBeFreed; /*!< Pointer to data to be freed */
+ RlcDlDataToBeFreed toBeFreed; /*!< Pointer to data to be freed */
Pst selfPst; /*!< Pst to post events to self */
Buffer *selfPstMBuf; /*!< Buffer used for self post */
Bool shutdownReceived; /*!< Request for shutdown recevied */
#ifdef LTE_L2_MEAS
KwL2Cb kwL2Cb; /*!< Control Block for L2 Measurements in RLC */
#endif /* LTE_L2_MEAS */
-}KwDlCb;
+}RlcDlCb;
/**
* @brief Structure to hold an information about UL RLC instance
* - ueLstCp : Hashlist of UeCb
* - transIdLstCp : Hashlist of cfg trans
*/
-typedef struct _kwUlCb
+typedef struct rlcUlCb
{
KwCkwSapCb ckwSap; /*!< CKW Sap Conrol Block */
U8 numKwuSaps; /*!< Number of RLC Data Saps */
#ifdef LTE_L2_MEAS
KwL2Cb kwL2Cb; /*!< Control Block for L2 Measurements in RLC */
#endif /* LTE_L2_MEAS */
-}KwUlCb;
+}RlcUlCb;
/**
* - ulCb : UL instance Control Block
* - dlCb : DL instance Control Block
*/
-typedef struct _kwCb
+typedef struct rlcCb
{
TskInit init; /*!< Task Initialization Info */
KwGenCfg genCfg; /*!< General Configuration Structure */
CmTqCp kwTqCp; /*!< Timer queue control point */
union
{
- KwUlCb *ulCb; /*!< Ul Control Block */
- KwDlCb *dlCb; /*!< Dl Control Block */
+ RlcUlCb *ulCb; /*!< Ul Control Block */
+ RlcDlCb *dlCb; /*!< Dl Control Block */
} u;
-}KwCb;
+}RlcCb;
-EXTERN KwCb *kwCb[KW_MAX_RLC_INSTANCES]; /*!< RLC global control block */
+EXTERN RlcCb *rlcCb[MAX_RLC_INSTANCES]; /*!< RLC global control block */
/****************************************************************************
* EXTERN Declarations
EXTERN Void kwTmrExpiry ARGS((PTR cb, S16 tmrEvnt));
-EXTERN S16 kwLmmSendTrc ARGS ((KwCb *gCb, Event event, Buffer *mBuf));
+EXTERN S16 kwLmmSendTrc ARGS ((RlcCb *gCb, Event event, Buffer *mBuf));
-EXTERN Void kwStartTmr ARGS((KwCb *gCb, PTR cb, S16 tmrEvnt));
+EXTERN Void kwStartTmr ARGS((RlcCb *gCb, PTR cb, S16 tmrEvnt));
-EXTERN Void kwStopTmr ARGS((KwCb *gCb, PTR cb, U8 tmrType));
+EXTERN Void kwStopTmr ARGS((RlcCb *gCb, PTR cb, U8 tmrType));
-EXTERN Bool kwChkTmr ARGS((KwCb *gCb,PTR cb, S16 tmrEvnt));
+EXTERN Bool kwChkTmr ARGS((RlcCb *gCb,PTR cb, S16 tmrEvnt));
#ifdef LTE_L2_MEAS
-EXTERN Void kwLmmSendAlarm ARGS (( KwCb *gCb,
+EXTERN Void kwLmmSendAlarm ARGS (( RlcCb *gCb,
U16 category,
U16 event,
U16 cause,
U32 ueId,
U8 qci));
-EXTERN S16 KwMiLkwDlL2MeasReq ARGS (( Pst *pst, KwL2MeasReqEvt *measReqEvt ));
-EXTERN S16 KwMiLkwDlL2MeasSendReq ARGS((Pst *pst,U8 measType));
-EXTERN S16 KwMiLkwDlL2MeasStopReq ARGS((Pst *pst,U8 measType));
-EXTERN S16 KwMiLkwUlL2MeasReq ARGS (( Pst *pst, KwL2MeasReqEvt *measReqEvt ));
-EXTERN S16 KwMiLkwUlL2MeasSendReq ARGS((Pst *pst,U8 measType));
-EXTERN S16 KwMiLkwUlL2MeasStopReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 KwMiRlcDlL2MeasReq ARGS (( Pst *pst, KwL2MeasReqEvt *measReqEvt ));
+EXTERN S16 KwMiRlcDlL2MeasSendReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 KwMiRlcDlL2MeasStopReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 KwMiRlcUlL2MeasReq ARGS (( Pst *pst, KwL2MeasReqEvt *measReqEvt ));
+EXTERN S16 KwMiRlcUlL2MeasSendReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 KwMiRlcUlL2MeasStopReq ARGS((Pst *pst,U8 measType));
EXTERN Void kwUtlPlcMeasDatInL2Sts ARGS((KwL2Cntr *measData,
KwL2MeasRbCb *rbL2Cb,
U8 measType));
#else /* LTE_L2_MEAS */
-EXTERN Void kwLmmSendAlarm ARGS ((KwCb *gCb,
+EXTERN Void kwLmmSendAlarm ARGS ((RlcCb *gCb,
U16 category,
U16 event,
U16 cause,
/* local externs */
/* forward references */
-EXTERN Void kwAmmDlHndlStatusPdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+EXTERN Void kwAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwUdxStaPdu *pStaPdu));
/* public variable declarations */
{\
Buffer *_pduInfo; \
SSegMsg((_retx)->seg, (_retx)->hdrSz, &_pduInfo); \
- KW_FREE_BUF((_retx)->seg); \
+ RLC_FREE_BUF((_retx)->seg); \
(_retx)->seg = _pduInfo; \
}\
(_rbCb)->m.amDl.estHdrSz -= retx->hdrSz;\
/* private function declarations */
-PRIVATE Void kwResegRetxPdus ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwResegRetxPdus ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwDatReq *kwDatReq));
-PRIVATE Void kwRemRetxPdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwRemRetxPdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwRetx *retx));
-PRIVATE Void kwAmmCreateStatusPdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAmmCreateStatusPdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwDatReq *kwDatReq));
-PRIVATE Void kwAmmDlMarkPduForReTx ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAmmDlMarkPduForReTx ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwRetx *retx));
-PRIVATE Void kwAmmDlProcessSuccessfulTxPdu ARGS((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwSn sn,
KwuDatCfmInfo **datCfm));
PRIVATE Void kwAmmDlSetTxNextAck ARGS((KwAmDl *amDl, KwSn sn));
-PRIVATE Void kwAmmDlCheckAndStopPollTmr ARGS((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwSn mAckSn));
-PRIVATE Void kwAssembleSdus ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAssembleSdus ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwDatReq *kwDatReq));
-PRIVATE Bool kwAmmDlCheckAndSetPoll ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Bool kwAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
Bool newPdu,
MsgLen bufSz));
-PRIVATE Void kwAmmCreatePdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAmmCreatePdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwAmHdr *amHdr,
- KwDlPduInfo *pduInfo,
+ RlcDlPduInfo *pduInfo,
Buffer *pdu));
-PRIVATE Void kwAmmSndStaInd ARGS ((KwCb *gCb,KwDlRbCb *rbCb, KwRetx *retx));
+PRIVATE Void kwAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, KwRetx *retx));
-PRIVATE Void kwGetNxtRetx ARGS ((KwCb *gCb, KwRetx **retx));
+PRIVATE Void kwGetNxtRetx ARGS ((RlcCb *gCb, KwRetx **retx));
PRIVATE Void kwConstructAmHdr ARGS ((KwAmHdr *amHdr,
U8 *hdr,
U8 snLen,
U16 *idx));
-PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwSn mAckSn,
CmLList *retx,
KwuDatCfmInfo **datCfm));
-PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer ARGS ((KwCb *gCb,
+PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb,
KwAmDl *amDl,
KwRetx **retx,
KwSn sn));
-PRIVATE Void kwAmmDlCheckIsSDUDelivered ARGS((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwSduMap *sduMap,
KwuDatCfmInfo **datCfm));
PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS(
(
-KwCb *gCb,
+RlcCb *gCb,
KwAmDl *amDl,
KwRetx **retx,
-KwDlPduInfo *pduInfo
+RlcDlPduInfo *pduInfo
));
PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf ARGS(
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwNackInfo *nackSnInfo,
KwRetx **retx,
KwuDatCfmInfo **datCfm
PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn ARGS(
(
- KwCb *gCb,
- KwDlRbCb *rbCb,
+ RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwNackInfo *nackSnInfo,
CmLList **retxNode,
KwuDatCfmInfo **datCfm
));
-PRIVATE Void KwDlAmmGetNackSnInfoFrmNackRangeIdx ARGS(
+PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ARGS(
(
KwAmDl *amDl,
KwNackInfo *nackInfo,
PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS(
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwSn sn,
KwSn mNackSn,
CmLList **retxNode,
- kwAssembleSdus
- kwAmmDlCheckAndSetPoll
- kwAmmProcessPdus
- - kwDlmHndlStaRsp
+ - rlcDlmHndlStaRsp
- kwTriggerStatus
- kwReassembleSdus
#ifdef ANSI
PUBLIC Void kwAmmSendDStaRsp
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwAmDl *amDl
)
#else
PUBLIC Void kwAmmSendDStaRsp(gCb, rbCb, amDl)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwAmDl *amDl;
#endif
{
#ifdef ANSI
PRIVATE Void kwAmmDlCheckAndStopPollTmr
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwSn mAckSn
)
#else
PRIVATE Void kwAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwSn mAckSn;
#endif
{
#ifdef ANSI
PRIVATE Void kwAmmDlProcessSuccessfulReTx
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwRetx *retx,
KwuDatCfmInfo **datCfm
)
#else
PRIVATE Void kwAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwRetx *retx;
KwuDatCfmInfo **datCfm;
#endif
* @details
* This function is used to move the PDU from the txBuf to re-transmit buffer
*
- * @param[in]KwCb *gCb RLC instance control block
+ * @param[in]RlcCb *gCb RLC instance control block
* @param[in]KwAmDl *amDl AM Downlink Control Block
* @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by
* this function
- * @param[in]KwDlPduInfo *pduInfo TX PDU which needs to be moved
+ * @param[in]RlcDlPduInfo *pduInfo TX PDU which needs to be moved
*
* @return Void
*
#ifdef ANSI
PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer
(
-KwCb *gCb,
+RlcCb *gCb,
KwAmDl *amDl,
KwRetx **retx,
-KwDlPduInfo *pduInfo
+RlcDlPduInfo *pduInfo
)
#else
PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo)
-KwCb *gCb;
+RlcCb *gCb;
KwAmDl *amDl;
KwRetx **retx;
-KwDlPduInfo *pduInfo;
+RlcDlPduInfo *pduInfo;
#endif
{
TRC2(kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer);
- KW_ALLOC_WC(gCb,*retx, sizeof(KwRetx));
+ RLC_ALLOC_WC(gCb,*retx, sizeof(KwRetx));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
* @details
* This function is used to move the PDU from the txBuf to re-transmit buffer
*
- * @param[in]KwCb *gCb RLC instance control block
- * @param[in]KwDlRbCb *rbCb AM Downlink Control Block
+ * @param[in]RlcCb *gCb RLC instance control block
+ * @param[in]RlcDlRbCb *rbCb AM Downlink Control Block
* @param[in]KwNackInfo *nackSnInfo Nack Information of a NACK_SN
* @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by
* this function
#ifdef ANSI
PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwNackInfo *nackSnInfo,
KwRetx **retx,
KwuDatCfmInfo ** datCfm
#else
PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm)
(
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwNackInfo *nackSnInfo;
KwRetx **retx;
KwuDatCfmInfo **datCfm;
lnk = txBuf->pduLst.first;
while(lnk)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(lnk->node);
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(lnk->node);
KwSn pduSoEnd = (pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1);
/* If So of Sdu byte segment(pduInfo/seg) is < status pdu
nextLnk = lnk->next;
/* Delete node from the txBuf Pdu lst */
cmLListDelFrm(&txBuf->pduLst, lnk);
- KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo));
+ RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
lnk = nextLnk;
}
if(!txBuf->pduLst.count)
* @details
* This function is used to move the PDU from the txBuf to re-transmit buffer
*
- * @param[in]KwCb *gCb RLC instance control block
- * @param[in]KwDlRbCb *rbCb AM Downlink Control Block
+ * @param[in]RlcCb *gCb RLC instance control block
+ * @param[in]RlcDlRbCb *rbCb AM Downlink Control Block
* @param[in]KwNackInfo *nackSnInfo Nack Information of a NACK_SN
* @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by
* this function
#ifdef ANSI
PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn
(
- KwCb *gCb,
- KwDlRbCb *rbCb,
+ RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwNackInfo *nackSnInfo,
CmLList **retxNode,
KwuDatCfmInfo **datCfm
#else
PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm)
(
- KwCb *gCb;
- KwDlRbCb *rbCb;
+ RlcCb *gCb;
+ RlcDlRbCb *rbCb;
KwNackInfo *nackSnInfo;
CmLList **retxNode;
KwuDatCfmInfo **datCfm;
*
*/
#ifdef ANSI
-PRIVATE Void KwDlAmmGetNackSnInfoFrmNackRangeIdx
+PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx
(
KwAmDl *amDl,
KwNackInfo *nackInfo,
U8 idx
)
#else
-PRIVATE Void KwDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
+PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
(
KwAmDl *amDl;
KwNackInfo *nackInfo;
KwRetx *retx;
CmLList *node;
- TRC2(KwDlAmmGetNackSnInfoFrmNackRangeIdx)
+ TRC2(RlcDlAmmGetNackSnInfoFrmNackRangeIdx)
nackSnInfo->isSegment = FALSE;
node = txBuf->pduLst.first;
while(node)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(node->node);
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(node->node);
U16 pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1;
if((!idx) && (pduInfo->amHdr.so == nackInfo->soStart))
{
#ifdef ANSI
PUBLIC Void kwAmmDlHndlStatusPdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwUdxStaPdu *pStaPdu
)
#else
PUBLIC Void kwAmmDlHndlStatusPdu(gCb, rbCb, pStaPdu)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwUdxStaPdu *pStaPdu;
#endif
{
oldRetxBo = AMDL.retxBo;
/* Allocate memory for datCfm Info */
- KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (datCfm == NULLP)
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
RETVOID;
}
#endif /* ERRCLASS & ERRCLS_RES */
AMDL.txNextAck,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
-/* KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */
- KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+/* RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */
+ RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
RETVOID;
}
"Status Pdu is not correct UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
RETVOID;
}
* nack sn*/
do
{
- KwDlAmmGetNackSnInfoFrmNackRangeIdx(&AMDL, &pStaPdu->nackInfo[idx],
+ RlcDlAmmGetNackSnInfoFrmNackRangeIdx(&AMDL, &pStaPdu->nackInfo[idx],
retxNode, &nackSnInfo, idx1);
kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo,
}
else
{
- KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
}
/* Fix for memory corruption */
#ifdef ANSI
PUBLIC Void kwAmmQSdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
Buffer *mBuf,
KwuDatReqInfo *datReq
)
#else
PUBLIC Void kwAmmQSdu(gCb, rbCb, mBuf, datReq)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
Buffer *mBuf;
KwuDatReqInfo *datReq;
#endif
TRC2(kwAmmQSdu)
/* Allocate sdu */
- KW_ALLOC_WC(gCb,sdu, sizeof(KwSdu));
+ RLC_ALLOC_WC(gCb,sdu, sizeof(KwSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (sdu == NULLP)
}
#endif
- if(!kwDlUtlIsReestInProgress(rbCb))
+ if(!rlcDlUtlIsReestInProgress(rbCb))
{
kwAmmSendDStaRsp(gCb, rbCb, &AMDL);
}
#ifdef ANSI
PRIVATE Void kwAmmDlAssembleCntrlInfo
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwDatReq *kwDatReq
)
#else
PRIVATE Void kwAmmDlAssembleCntrlInfo(gCb, rbCb, kwDatReq)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwDatReq *kwDatReq;
#endif
{
kwAmmCreateStatusPdu(gCb,rbCb,kwDatReq);
sapCb = KW_GET_DL_SAPCB(gCb, rbCb);
- KwDlUdxStaProhTmrStart(&(gCb->u.dlCb->udxDlSap->pst),
+ rlcDlUdxStaProhTmrStart(&(gCb->u.dlCb->udxDlSap->pst),
sapCb->suId, &(rbCb->rlcId));
/* Update number of pdus in pduInfo */
kwDatReq->pduInfo.numPdu++;
gRlcStats.amRlcStats.numDLStaPduSent++;
- KW_FREE_SHRABL_BUF(gCb->u.dlCb->udxDlSap->pst.region,
+ RLC_FREE_SHRABL_BUF(gCb->u.dlCb->udxDlSap->pst.region,
gCb->u.dlCb->udxDlSap->pst.pool,
AMDL.pStaPdu,
sizeof(KwUdxDlStaPdu));
#ifdef ANSI
PUBLIC Void kwAmmProcessSdus
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwDatReq *kwDatReq,
Bool fillCtrlPdu
)
#else
PUBLIC Void kwAmmProcessSdus(gCb, rbCb, kwDatReq,fillCtrlPdu)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwDatReq *kwDatReq;
Bool fillCtrlPdu;
#endif
#ifdef ANSI
PRIVATE Void kwSplitPdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwRetx *crnt,
KwRetx *next,
U16 size
)
#else
PRIVATE Void kwSplitPdu(gCb, rbCb, crnt, next, size)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwRetx *crnt;
KwRetx *next;
U16 size;
#ifdef ANSI
PRIVATE Void kwResegRetxPdus
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwDatReq *kwDatReq
)
#else
PRIVATE Void kwResegRetxPdus(gCb, rbCb, kwDatReq)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwDatReq *kwDatReq;
#endif
{
}
/* Allocate memory for tracking a new segment */
- KW_ALLOC_WC(gCb,tNode, sizeof(KwRetx));
+ RLC_ALLOC_WC(gCb,tNode, sizeof(KwRetx));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tNode == NULLP)
{
#ifdef ANSI
PRIVATE Void kwAssembleSdus
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwDatReq *kwDatReq
)
#else
PRIVATE Void kwAssembleSdus (gCb, rbCb, kwDatReq)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwDatReq *kwDatReq;
#endif
{
U32 fixedHdrSz;
U32 pduSz;
KwAmHdr *amHdr = NULLP;
- KwDlPduInfo *pduInfo = NULLP;
+ RlcDlPduInfo *pduInfo = NULLP;
TRC2(kwAssembleSdus)
#endif
/* Discard new changes starts */
/* Allocate memory for discSdu Info */
- KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
+ RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
kwuSap->pst.pool,
discSduInfo,
sizeof(KwuDiscSduInfo));
if (!sdu->mode.am.isSegmented)
{
/* Update txBuf */
- KW_ALLOC_WC(gCb,txBuf, sizeof(KwTx));
+ RLC_ALLOC_WC(gCb,txBuf, sizeof(KwTx));
cmLListInit(&txBuf->pduLst);
txBuf = kwUtlGetTxBuf(amDl->txBufLst, amDl->txNext);
}
- KW_ALLOC_WC(gCb,pduInfo, sizeof(KwDlPduInfo));
+ RLC_ALLOC_WC(gCb,pduInfo, sizeof(RlcDlPduInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (pduInfo == NULLP)
{
}
else
{
- KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo));
}
#ifdef ANSI
PRIVATE Bool kwAmmDlCheckAndSetPoll
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
Bool newPdu,
MsgLen bufSz
)
#else
PRIVATE Bool kwAmmDlCheckAndSetPoll(gCb, rbCb, newPdu, bufSz)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
Bool newPdu;
MsgLen bufSz;
#endif
* @param[in] gCB RLC instance control block
* @param[in] rbCb Downlink RB control block
* @param[in] amHdr AM header
- * @param[in] KwDlPduInfo Pointer to PduInfo
+ * @param[in] RlcDlPduInfo Pointer to PduInfo
* @param[in] pdu PDU buffer
*
* @return Void
#ifdef ANSI
PRIVATE Void kwAmmCreatePdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwAmHdr *amHdr,
-KwDlPduInfo *pduInfo,
+RlcDlPduInfo *pduInfo,
Buffer *pdu
)
#else
PRIVATE Void kwAmmCreatePdu(gCb, rbCb, pduInfo, amHdr, pdu)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwAmHdr *amHdr;
-KwDlPduInfo *pduInfo;
+RlcDlPduInfo *pduInfo;
Buffer *pdu;
#endif
{
#ifdef ANSI
PRIVATE Void kwRemRetxPdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwRetx *retx
)
#else
PRIVATE Void kwRemRetxPdu(gCb, rbCb, retx)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwRetx *retx;
#endif
{
#ifdef ANSI
PRIVATE Void kwAmmDlMarkPduForReTx
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwRetx *retx
)
#else
PRIVATE Void kwAmmDlMarkPduForReTx(*gCb, rbCb, retx)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwRetx *retx;
#endif
{
#ifdef ANSI
PRIVATE Void kwAmmDlCheckIsSDUDelivered
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwSduMap *sduMap,
KwuDatCfmInfo **datCfm
)
#else
PRIVATE Void kwAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwSduMap *sduMap;
KwuDatCfmInfo **datCfm;
#endif
kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
KwUiKwuDatCfm(&kwuSap->pst, kwuSap->suId, *datCfm);
- KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, *datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, *datCfm, sizeof(KwuDatCfmInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*datCfm == NULLP)
#ifdef ANSI
PRIVATE Void kwAmmDlProcessSuccessfulTxPdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwSn sn,
KwuDatCfmInfo **datCfm
)
#else
PRIVATE Void kwAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwSn sn;
KwuDatCfmInfo **datCfm;
#endif
pduNode = txBuf->pduLst.first;
while(pduNode)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(pduNode->node);
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pduNode->node);
kwAmmDlCheckIsSDUDelivered(gCb,
rbCb,
&(pduInfo->sduMap),
#ifdef ANSI
PRIVATE Void kwAmmSndStaInd
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwRetx *retx
)
#else
PRIVATE Void kwAmmSndStaInd(gCb, rbCb, retx)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwRetx *retx;
#endif
{
kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
/* Allocate memory for staInd Info */
- KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, staInd, sizeof(KwuStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, staInd, sizeof(KwuStaIndInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (staInd == NULLP)
#ifdef ANSI
PRIVATE Void kwGetNxtRetx
(
-KwCb *gCb,
+RlcCb *gCb,
KwRetx **retx
)
#else
PRIVATE Void kwGetNxtRetx(gCb, retx)
-KwCb *gCb;
+RlcCb *gCb;
KwRetx **retx;
#endif
{
#ifdef ANSI
PUBLIC Void kwAmmDlReEstablish
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRlcId rlcId,
-KwDlRbCb *rbCb
+RlcDlRbCb *rbCb
)
#else
PUBLIC Void kwAmmDlReEstablish(gCb, rlcId, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRlcId rlcId;
-KwDlRbCb *rbCb;
+RlcDlRbCb *rbCb;
#endif
{
/* create a new AM DL RB, reset it and replace in the UeCb*/
- KwDlUeCb *ueCb;
- KwDlRbCb *resetRb;
+ RlcDlUeCb *ueCb;
+ RlcDlRbCb *resetRb;
KwAmDl* newAmDl;
KwAmDl* oldAmDl;
- KW_ALLOC(gCb, resetRb, sizeof(KwDlRbCb));
+ RLC_ALLOC(gCb, resetRb, sizeof(RlcDlRbCb));
/* ccpu00135170 Removing KLOCK warning */
if(resetRb == NULLP)
RETVOID;
}
- KW_MEM_CPY(resetRb, rbCb, sizeof(KwDlRbCb));
- KW_MEM_SET(&resetRb->m.amDl, 0 , sizeof(KwAmDl));
+ KW_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb));
+ RLC_MEM_SET(&resetRb->m.amDl, 0 , sizeof(KwAmDl));
/* AGHOSH changes start */
/* restore the old AM values */
&&(resetRb->rlcId.rbId == 1))
{
/* To stop the traffic on SRB2 and other DRBs*/
- kwDlUtlSetReestInProgressForAllRBs(gCb, ueCb);
+ rlcDlUtlSetReestInProgressForAllRBs(gCb, ueCb);
}
else
{
- kwDlUtlSetReestInProgressForRB(gCb, resetRb);
+ rlcDlUtlSetReestInProgressForRB(gCb, resetRb);
}
/* allocate the TX array again */
#ifndef LTE_TDD
U32 hashIndex;
- KW_ALLOC(gCb,
+ RLC_ALLOC(gCb,
resetRb->m.amDl.txBufLst,
(KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
for(hashIndex = 0; hashIndex < KW_TX_BUF_BIN_SIZE; hashIndex++)
There should be a proper intreface to resume the RBs */
if(rlcId.rbType == CM_LTE_SRB)
{
- kwDlUtlResetReestInProgress(ueCb->srbCb[rlcId.rbId]);
+ rlcDlUtlResetReestInProgress(ueCb->srbCb[rlcId.rbId]);
}
else
{
- kwDlUtlResetReestInProgress(ueCb->drbCb[rlcId.rbId]);
+ rlcDlUtlResetReestInProgress(ueCb->drbCb[rlcId.rbId]);
}
RETVOID;
#ifdef ANSI
PUBLIC S16 kwAmmDiscSdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
U32 sduId
)
#else
PUBLIC S16 kwAmmDiscSdu(gCb, rbCb, sduId)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
U32 sduId;
#endif
{
#ifdef ANSI
PUBLIC Void kwAmmPollRetxTmrExp
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
PUBLIC Void kwAmmPollRetxTmrExp(gCb, rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
KwRetx *retx;
#ifdef ANSI
PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwSn mAckSn,
CmLList *retxNode,
KwuDatCfmInfo **datCfm
)
#else
PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwSn mAckSn;
CmLList *retxNode;
KwuDatCfmInfo **datCfm;
#ifdef ANSI
PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwSn sn,
KwSn mNackSn,
CmLList **retxNode,
)
#else
PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwSn sn;
KwSn mNackSn;
CmLList **retxNode;
#ifdef ANSI
PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer
(
-KwCb *gCb,
+RlcCb *gCb,
KwAmDl *amDl,
KwRetx **retx,
KwSn sn
)
#else
PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn)
-KwCb *gCb;
+RlcCb *gCb;
KwAmDl *amDl;
KwRetx **retx;
KwSn sn;
}
while(txBuf->pduLst.first)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(txBuf->pduLst.first->node);
- KW_ALLOC_WC(gCb,*retx, sizeof(KwRetx));
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node);
+ RLC_ALLOC_WC(gCb,*retx, sizeof(KwRetx));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
/* Delete node from the txBuf Pdu lst */
cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
- KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo));
+ RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
/* Remove PDU from txBuf */
kwUtlDelTxBuf(amDl->txBufLst, txBuf,gCb);
#ifdef ANSI
PUBLIC Void kwAmmFreeDlRbCb
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
PUBLIC Void kwAmmFreeDlRbCb(gCb,rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
/* stop the re-transmission timer */
#ifdef ANSI
PRIVATE Void kwAmmCreateStatusPdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwDatReq *kwDatReq
)
#else
PRIVATE Void kwAmmCreateStatusPdu(gCb, rbCb, kwDatReq)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwDatReq *kwDatReq;
#endif
{
#ifdef ANSI
PRIVATE Void rgAmmExtractElmnt
(
-KwCb *gCb,
+RlcCb *gCb,
Buffer *pdu,
KwExtHdr *hdrInfo
)
#else
PRIVATE Void rgAmmExtractElmnt(gCb, pdu, hdrInfo)
-KwCb *gCb;
+RlcCb *gCb;
Buffer *pdu;
KwExtHdr *hdrInfo;
#endif
(
Pst *udxPst,
SuId suId,
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
Buffer *cntrlPdu,
U8 *fByte
)
PRIVATE Void rgAmmUlHndlStatusPdu(udxPst,suId,gCb, rbCb, cntrlPdu, fByte)
Pst *udxPst;
SuId suId;
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
Buffer *cntrlPdu;
U8 *fByte;
#endif
RETVOID;
}
- KW_ALLOC_SHRABL_BUF(udxPst->region,
+ RLC_ALLOC_SHRABL_BUF(udxPst->region,
udxPst->pool,
pStaPdu,
sizeof(KwUdxStaPdu));
/* Parse & send Status PDU to RLC-DL */
- //KwUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
- KwUlUdxStaUpdReq(udxPst, suId, &rbCb->rlcId, pStaPdu);
+ //rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
+ rlcUlUdxStaUpdReq(udxPst, suId, &rbCb->rlcId, pStaPdu);
RETVOID;
}
PUBLIC S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId,
CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu)
{
- KwDlRbCb *rbCb = NULLP;
- KwDlUeCb *ueCb = NULLP;
+ RlcDlRbCb *rbCb = NULLP;
+ RlcDlUeCb *ueCb = NULLP;
U8 fByte;
U8 temp;
S16 retVal = RFAILED;
- KwCb *gCb;
+ RlcCb *gCb;
Pst dlRlcPst = *udxPst;
- gCb = KW_GET_KWCB(1); /* DL RLC instance */
+ gCb = RLC_GET_RLCCB(1); /* DL RLC instance */
if( ROK != kwDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb)))
{
/* private function declarations */
-PRIVATE Void kwAmmUlAssembleCntrlInfo ARGS ((KwCb *gCb, KwUlRbCb *rbCb));
+PRIVATE Void kwAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
-PRIVATE S16 kwAmmExtractHdr ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE S16 kwAmmExtractHdr ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
Buffer *pdu,
KwAmHdr *amHdr,
U8 *fByte));
-PRIVATE Bool kwAmmUlPlacePduInRecBuf ARGS ((KwCb *gCb,
+PRIVATE Bool kwAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
Buffer *pdu,
- KwUlRbCb *rbCb,
+ RlcUlRbCb *rbCb,
KwAmHdr *amHdr));
-PRIVATE Void kwAmmTriggerStatus ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE Void kwAmmTriggerStatus ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwSn sn,
Bool discFlg));
-PRIVATE S16 kwAmmUlReassembleSdus ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE S16 kwAmmUlReassembleSdus ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwAmRecBuf *recBuf));
-PRIVATE Void kwAmmProcPduOrSeg ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE Void kwAmmProcPduOrSeg ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwAmHdr *amHdr,
Buffer *pdu));
-PRIVATE Void kwAmmUpdExpByteSeg ARGS ((KwCb *gCb,KwAmUl *amUl, KwSeg* newSeg));
+PRIVATE Void kwAmmUpdExpByteSeg ARGS ((RlcCb *gCb,KwAmUl *amUl, KwSeg* newSeg));
-PRIVATE Void kwAmmExtractElmnt ARGS ((KwCb *gCb, Buffer *pdu, KwExtHdr *hdrInfo));
+PRIVATE Void kwAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, KwExtHdr *hdrInfo));
-PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
Buffer *cntrlPdu,
U8 *fByte));
#ifdef ANSI
PRIVATE S16 kwAmmUlSetNackInfo
(
-KwUlRbCb *rbCb,
+RlcUlRbCb *rbCb,
KwSn sn,
Bool isSegment,
U16 soStart,
)
#else
PRIVATE S16 kwAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn)
-KwUlRbCb *rbCb;
+RlcUlRbCb *rbCb;
KwSn sn;
Bool isSegment;
U16 soStart;
#ifdef ANSI
PRIVATE Void kwAmmUlAssembleCntrlInfo
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PRIVATE Void kwAmmUlAssembleCntrlInfo(gCb, rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwUdxDlStaPdu *pStatusPdu;
sapCb = KW_GET_UDX_SAP(gCb);
- KW_ALLOC_SHRABL_BUF(sapCb->pst.region,
+ RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
sizeof(KwUdxDlStaPdu));
AMUL.gatherStaPduInfo = FALSE;
- if (KwUlUdxStaPduReq(&sapCb->pst,
+ if (rlcUlUdxStaPduReq(&sapCb->pst,
sapCb->spId,
&rbCb->rlcId,
pStatusPdu) != ROK)
"Failed to Send Sta Pdu UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_SHRABL_BUF_WC(sapCb->pst.region,
+ RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
sizeof(KwUdxDlStaPdu));
#ifdef ANSI
PUBLIC Void kwAmmProcessPdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
U32 ttiCnt
)
#else
PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
U32 ttiCnt;
#endif
#ifdef ANSI
PUBLIC Void kwAmmProcessPdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwPduInfo *pduInfo
)
#else
PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
#endif
#endif
"Header Extraction Failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
gCb->genSts.errorPdusRecv++;
continue;
}
if (amHdr.dc == 0)
{
kwAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
if((amHdr.si == KW_SI_LAST_SEG) && (!amHdr.so))
amHdr.sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
#ifndef RGL_SPECIFIC_CHANGES
#ifndef TENB_T2K3K_SPECIFIC_CHANGES
#ifndef LTE_PAL_ENB
/* Changed the condition to TRUE from ROK */
- if(isMemThreshReached(kwCb[0]->init.region) == TRUE)
+ if(isMemThreshReached(rlcCb[0]->init.region) == TRUE)
{
extern U32 rlculdrop;
rlculdrop++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
#endif
#else
#ifndef LTE_PAL_ENB
/*ccpu00142274 - UL memory based flow control*/
- if(isMemThreshReached(kwCb[0]->init.region) != ROK)
+ if(isMemThreshReached(rlcCb[0]->init.region) != ROK)
{
extern U32 rlculdrop;
rlculdrop++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
#endif
{
if(rbCb->rlcId.rbType == CM_LTE_DRB)
{
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
}
#ifdef ANSI
PRIVATE S16 kwAmmExtractHdr
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *pdu,
KwAmHdr *amHdr,
U8 *fByte
)
#else
PRIVATE S16 kwAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *pdu;
KwAmHdr *amHdr;
U8 *fByte;
#ifdef ANSI
PRIVATE S16 kwAmmExtractHdrOld
(
-KwCb *gCb,
+RlcCb *gCb,
Buffer *pdu,
KwAmHdr *amHdr,
U8 *fByte
)
#else
PRIVATE S16 kwAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
-KwCb *gCb;
+RlcCb *gCb;
Buffer *pdu;
KwAmHdr *amHdr;
U8 *fByte;
#ifdef ANSI
PRIVATE Void kwAmmUlHndlStatusPdu
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *cntrlPdu,
U8 *fByte
)
#else
PRIVATE Void kwAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *cntrlPdu;
U8 *fByte;
#endif
sapCb = KW_GET_UDX_SAP(gCb);
- KW_ALLOC_SHRABL_BUF(sapCb->pst.region,
+ RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStaPdu,
sizeof(KwUdxStaPdu));
/* Parse & send Status PDU to RLC-DL */
- KwUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
+ rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
RETVOID;
}
#ifdef ANSI
PRIVATE Void kwAmmUlRlsAllSegs
(
-KwCb *gCb,
+RlcCb *gCb,
KwAmRecBuf *recBuf
)
#else
PRIVATE Void kwAmmUlRlsAllSegs(gCb,recBuf)
-KwCb *gCb;
+RlcCb *gCb;
KwAmRecBuf *recBuf;
#endif
{
KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
while (seg != NULLP)
{
- KW_FREE_BUF_WC(seg->seg);
+ RLC_FREE_BUF_WC(seg->seg);
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- KW_FREE_WC(gCb,seg, sizeof(KwSeg));
+ RLC_FREE_WC(gCb,seg, sizeof(KwSeg));
KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
#ifdef ANSI
PRIVATE Bool kwAmmAddRcvdSeg
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwAmHdr *amHdr,
Buffer *pdu,
U16 pduSz
)
#else
PRIVATE Bool kwAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwAmHdr *amHdr;
Buffer *pdu;
U16 pduSz;
if (NULLP == recBuf)
{
- KW_ALLOC(gCb,recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb,recBuf, sizeof(KwAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
{
if (recBuf->allRcvd == TRUE)
{
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
}
{
/* This is a duplicate segment */
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
{
/* This is a duplicate segment */
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
/* If we have come this far, we have to add this segment to the */
/* reception buffer as we either have eliminated duplicates or */
/* have found none. */
- KW_ALLOC_WC(gCb,tseg, sizeof(KwSeg));
+ RLC_ALLOC_WC(gCb,tseg, sizeof(KwSeg));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tseg == NULLP)
{
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
#ifdef ANSI
PRIVATE Bool kwAmmUlPlacePduInRecBuf
(
-KwCb *gCb,
+RlcCb *gCb,
Buffer *pdu,
-KwUlRbCb *rbCb,
+RlcUlRbCb *rbCb,
KwAmHdr *amHdr
)
#else
PRIVATE Bool kwAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr)
-KwCb *gCb;
+RlcCb *gCb;
Buffer *pdu;
-KwUlRbCb *rbCb;
+RlcUlRbCb *rbCb;
KwAmHdr *amHdr;
#endif
{
rbCb->rlcId.cellId);
gCb->genSts.unexpPdusRecv++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
/* store the received PDU in the reception buffer */
if (NULLP == recBuf)
{
- KW_ALLOC(gCb, recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb, recBuf, sizeof(KwAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
{
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
gCb->genSts.unexpPdusRecv++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
RETVALUE(FALSE);
}
recBuf->isDelvUpperLayer = FALSE;
#ifdef ANSI
PRIVATE Void kwAmmTriggerStatus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwSn sn,
Bool discFlg
)
#else
PRIVATE Void kwAmmTriggerStatus(gCb,rbCb, sn, discFlg)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwSn sn;
Bool discFlg;
#endif
#ifdef ANSI
PRIVATE Void kwAmmProcPduOrSeg
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwAmHdr *amHdr,
Buffer *pdu
)
#else
PRIVATE Void kwAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwAmHdr *amHdr;
Buffer *pdu;
#endif
/* Release the existing partial SDU as we have PDUs or */
/* segments that are out of sequence */
rbCb->m.amUl.isOutOfSeq = TRUE;
- KW_FREE_BUF(AMUL.partialSdu);
+ RLC_FREE_BUF(AMUL.partialSdu);
}
//if (amHdr->fi & KW_FI_FIRST_SEG)
{/* first Segment of the SDU */
if (AMUL.partialSdu != NULLP)
{ /* Some old SDU may be present */
- KW_FREE_BUF_WC(AMUL.partialSdu);
+ RLC_FREE_BUF_WC(AMUL.partialSdu);
}
AMUL.partialSdu = pdu;
pdu = NULLP;
else if(amHdr->si == 0x03)
{/* Middle or last segment of the SUD */
SCatMsg(AMUL.partialSdu,pdu, M1M2);
- KW_FREE_BUF_WC(pdu);
+ RLC_FREE_BUF_WC(pdu);
pdu = NULLP;
}
else if (amHdr->si == 0x02)
{
SCatMsg(pdu,AMUL.partialSdu,M2M1);
- KW_FREE_BUF_WC(AMUL.partialSdu);
+ RLC_FREE_BUF_WC(AMUL.partialSdu);
}
if (pdu != NULLP)
#ifdef ANSI
PRIVATE S16 kwAmmUlReassembleSdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwAmRecBuf *recBuf
)
#else
PRIVATE S16 kwAmmUlReassembleSdus(gCb, rbCb, recBuf)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwAmRecBuf *recBuf;
#endif
{
AMUL.expSo = seg->soEnd + 1;
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- KW_FREE_WC(gCb, seg, sizeof(KwSeg));
+ RLC_FREE_WC(gCb, seg, sizeof(KwSeg));
KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
#ifdef ANSI
PUBLIC Void kwAmmUlReEstablish
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRlcId rlcId,
Bool sendReEst,
-KwUlRbCb *rbCb
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRlcId rlcId;
Bool sendReEst;
-KwUlRbCb *rbCb;
+RlcUlRbCb *rbCb;
#endif
{
KwSn sn;
/* Remove PDU and segments */
if(recBuf->pdu)
{
- KW_FREE_BUF_WC(recBuf->pdu);
+ RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments*/
kwAmmUlRlsAllSegs(gCb,recBuf);
AMUL.expSo = 0;
if (AMUL.partialSdu != NULLP)
{
- KW_FREE_BUF(AMUL.partialSdu);
+ RLC_FREE_BUF(AMUL.partialSdu);
}
kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP;
#ifdef ANSI
PUBLIC Void kwAmmReOrdTmrExp
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmReOrdTmrExp(rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwAmUl *amUl = &(rbCb->m.amUl);
#ifdef ANSI
PUBLIC Void kwAmmStaProTmrExp
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmStaProTmrExp(gCb, rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwAmUl *amUl = &(rbCb->m.amUl);
#ifdef ANSI
PRIVATE Void kwAmmExtractElmnt
(
-KwCb *gCb,
+RlcCb *gCb,
Buffer *pdu,
KwExtHdr *hdrInfo
)
#else
PRIVATE Void kwAmmExtractElmnt(gCb, pdu, hdrInfo)
-KwCb *gCb;
+RlcCb *gCb;
Buffer *pdu;
KwExtHdr *hdrInfo;
#endif
#ifdef ANSI
PRIVATE Void kwAmmUpdExpByteSeg
(
-KwCb *gCb,
+RlcCb *gCb,
KwAmUl *amUl,
KwSeg *seg
)
#else
PRIVATE Void kwAmmUpdExpByteSeg(gCb, amUl, seg)
-KwCb *gCb;
+RlcCb *gCb;
KwAmUl *amUl;
KwSeg *seg;
#endif
#ifdef ANSI
PUBLIC Void kwAmmFreeUlRbCb
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmFreeUlRbCb(gCb,rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwSn curSn = 0; /* Sequence number of PDU */
{
if (recBuf->pdu != NULLP)
{
- KW_FREE_BUF_WC(recBuf->pdu);
+ RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments */
kwAmmUlRlsAllSegs(gCb,recBuf);
}while ( curSn < windSz );
#ifndef LTE_TDD
- KW_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
rbCb->m.amUl.recBufLst = NULLP;
#endif
if(rbCb->m.amUl.partialSdu != NULLP)
{
- KW_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
+ RLC_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
}
RETVOID;
} /* kwAmmFreeUlRbCb */
Desc: It contains the following configuraiton primtives
for different actions
- -- kwCfgValdtEntCfg
- -- kwCfgFillRbCb
- -- kwCfgRbInit
- -- kwCfgAddRb
- -- kwCfgReCfgRb
- -- kwCfgDelRb
- -- kwCfgReEstRb
- -- kwCfgDelUe
+ -- rlcCfgValdtEntCfg
+ -- rlcCfgFillRbCb
+ -- rlcCfgRbInit
+ -- rlcCfgAddRb
+ -- rlcCfgReCfgRb
+ -- rlcCfgDelRb
+ -- rlcCfgReEstRb
+ -- rlcCfgDelUe
File: kw_cfg_dl.c
* -# RFAILED
*
*/
-PRIVATE S16 kwHdlMeasDlUeIdChg(KwCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
+PRIVATE S16 kwHdlMeasDlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
{
KwL2MeasEvtCb *measEvtCb = NULLP;
KwL2MeasCb *measCb = NULLP;
* -# RFAILED
*
*/
-PRIVATE S16 kwDelFrmDlL2Meas(KwCb *gCb, U8 cellId,U8 ueId)
+PRIVATE S16 kwDelFrmDlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
{
KwL2MeasEvtCb *measEvtCb = NULLP;
KwL2MeasCb *measCb = NULLP;
}
-PRIVATE S16 kwAddToDlL2Meas(KwCb *gCb, KwDlRbCb *kwRbCb,U8 cellId,U8 ueId)
+PRIVATE S16 kwAddToDlL2Meas(RlcCb *gCb, RlcDlRbCb *kwRbCb,U8 cellId,U8 ueId)
{
KwL2MeasEvtCb *measEvtCb = NULLP;
KwL2MeasCb *measCb = NULLP;
* -#RFAILED
*/
#ifdef ANSI
-PRIVATE S16 kwCfgFillDlRbCb
+PRIVATE S16 rlcCfgFillDlRbCb
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
-KwDlUeCb *ueCb,
-CkwEntCfgInfo *entCfg
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
+RlcDlUeCb *ueCb,
+RlcEntCfgInfo *entCfg
)
#else
-PRIVATE S16 kwCfgFillDlRbCb(gCb,rbCb,entCfg)
-KwCb *gCb;
-KwDlRbCb *rbCb;
-KwDlUeCb *ueCb;
-CkwEntCfgInfo *entCfg;
+PRIVATE S16 rlcCfgFillDlRbCb(gCb,rbCb,entCfg)
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
+RlcDlUeCb *ueCb;
+RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(kwCfgFillDlRbCb)
+ TRC3(rlcCfgFillDlRbCb)
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
- "kwCfgFillRbCb(ueId(%d),cellId(%d) rbType(%d))",
+ "rlcCfgFillRbCb(ueId(%d),cellId(%d) rbType(%d))",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId,
entCfg->rbType);
#ifndef LTE_TDD
U32 hashIndex;
- KW_ALLOC(gCb,
+ RLC_ALLOC(gCb,
rbCb->m.amDl.txBufLst,
(KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
for(hashIndex = 0; hashIndex < KW_TX_BUF_BIN_SIZE; hashIndex++)
* -#RFAILED
*/
#ifdef ANSI
-PRIVATE S16 kwCfgUpdateDlRb
+PRIVATE S16 rlcCfgUpdateDlRb
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
void *ptr,
-CkwEntCfgInfo *entCfg
+RlcEntCfgInfo *entCfg
)
#else
-PRIVATE S16 kwCfgUpdateDlRb(gCb,rbCb, ptr, entCfg)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+PRIVATE S16 rlcCfgUpdateDlRb(gCb,rbCb, ptr, entCfg)
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
void *ptr;
-CkwEntCfgInfo *entCfg;
+RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(kwCfgUpdateDlRb)
+ TRC3(rlcCfgUpdateDlRb)
if (rbCb->mode != entCfg->entMode)
{
{
case CM_LTE_MODE_TM:
{
- KwDlCellCb *cellCb = (KwDlCellCb *)ptr;
+ RlcDlCellCb *cellCb = (RlcDlCellCb *)ptr;
rbCb->dir = entCfg->dir;
rbCb->lch.lChId = entCfg->lCh[0].lChId;
case CM_LTE_MODE_UM:
{
- KwDlUeCb *ueCb = (KwDlUeCb *)ptr;
+ RlcDlUeCb *ueCb = (RlcDlUeCb *)ptr;
if (entCfg->lCh[0].type == CM_LTE_LCH_DCCH)
{
case CM_LTE_MODE_AM:
{
- KwDlUeCb *ueCb = (KwDlUeCb *)ptr;
+ RlcDlUeCb *ueCb = (RlcDlUeCb *)ptr;
ueCb->lCh[rbCb->lch.lChId - 1].dlRbCb = NULLP;
ueCb->lCh[entCfg->lCh[1].lChId - 1].dlRbCb = rbCb;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgAddDlRb
+PUBLIC S16 rlcCfgAddDlRb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-CkwEntCfgInfo *entCfg,
-CkwEntCfgCfmInfo *entCfm
+RlcEntCfgInfo *entCfg,
+RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 kwCfgAddDlRb(gCb,ueId, cellId, entCfg, entCfm)
-KwCb *gCb;
+PUBLIC S16 rlcCfgAddDlRb(gCb,ueId, cellId, entCfg, entCfm)
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-CkwEntCfgInfo *entCfg;
-CkwEntCfgCfmInfo *entCfm;
+RlcEntCfgInfo *entCfg;
+RlcEntCfgCfmInfo *entCfm;
#endif
{
- KwDlUeCb *ueCb = NULLP; /* UE Control Block */
- KwDlCellCb *cellCb; /* Cell Control Block */
- KwDlRbCb *kwRbCb; /* KW RB Control Block */
+ RlcDlUeCb *ueCb = NULLP; /* UE Control Block */
+ RlcDlCellCb *cellCb; /* Cell Control Block */
+ RlcDlRbCb *kwRbCb; /* KW RB Control Block */
U8 reason; /* Rb Identifier */
- TRC3(kwCfgAddDlRb)
+ TRC3(rlcCfgAddDlRb)
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
- "kwCfgAddRb(cellId(%d),UEID:%d cfgType(%d))",
+ "rlcCfgAddRb(cellId(%d),UEID:%d cfgType(%d))",
cellId,
ueId,
entCfg->cfgType);
}
if ((entCfg->rguSapId >= gCb->genCfg.maxRguSaps) || (entCfg->rguSapId < 0))
{
- KWDBGP_ERROR(gCb, "kwCfgAddDlRb(ueId(%u), cellId(%u), Invalid rguSapId (%d)\n",
+ KWDBGP_ERROR(gCb, "rlcCfgAddDlRb(ueId(%u), cellId(%u), Invalid rguSapId (%d)\n",
ueId, cellId, entCfg->rguSapId);
RETVALUE(RFAILED);
}
}
/* Create RB CB */
- KW_ALLOC(gCb,kwRbCb, sizeof (KwDlRbCb));
+ RLC_ALLOC(gCb,kwRbCb, sizeof (RlcDlRbCb));
if (!kwRbCb)
{
RLOG_ARG2(L_FATAL,DBG_UEID,ueId,
}
/* Create RB CB */
- KW_ALLOC(gCb,kwRbCb, sizeof (KwDlRbCb));
+ RLC_ALLOC(gCb,kwRbCb, sizeof (RlcDlRbCb));
if (kwRbCb == NULL)
{
/* Fill entCfm structure */
/* Fill RB CB */
- if (kwCfgFillDlRbCb(gCb,kwRbCb, ueCb, entCfg) != ROK)
+ if (rlcCfgFillDlRbCb(gCb,kwRbCb, ueCb, entCfg) != ROK)
{
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_CREAT_FAIL);
/* Delete RB CB created */
- KW_FREE(gCb,kwRbCb, sizeof(KwDlRbCb));
+ RLC_FREE(gCb,kwRbCb, sizeof(RlcDlRbCb));
RLOG_ARG2(L_ERROR,DBG_RBID, entCfg->rbId,
"Filling of RbCb failed UEID:%d CELLID:%d",
ueId,
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgReCfgDlRb
+PUBLIC S16 rlcCfgReCfgDlRb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-CkwEntCfgInfo *entCfg,
-CkwEntCfgCfmInfo *entCfm
+RlcEntCfgInfo *entCfg,
+RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 kwCfgReCfgDlRb(gCb,ueId, cellId, entCfg, entCfm)
-KwCb *gCb;
+PUBLIC S16 rlcCfgReCfgDlRb(gCb,ueId, cellId, entCfg, entCfm)
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-CkwEntCfgInfo *entCfg;
-CkwEntCfgCfmInfo *entCfm;
+RlcEntCfgInfo *entCfg;
+RlcEntCfgCfmInfo *entCfm;
#endif
{
- KwDlRbCb *rbCb; /* RB Control Block */
- KwDlRbCb tRbCb; /* KW RB Control Block */
- KwDlCellCb *cellCb; /* Cell Control Block */
- KwDlUeCb *ueCb; /* Ue Control Block */
+ RlcDlRbCb *rbCb; /* RB Control Block */
+ RlcDlRbCb tRbCb; /* KW RB Control Block */
+ RlcDlCellCb *cellCb; /* Cell Control Block */
+ RlcDlUeCb *ueCb; /* Ue Control Block */
U8 ret;
- TRC3(kwCfgReCfgDlRb)
+ TRC3(rlcCfgReCfgDlRb)
RLOG_ARG3(L_DEBUG,DBG_UEID,ueId,
- "kwCfgReCfgRb(cellId(%d), cfgType(%d)) RBID:%d",
+ "rlcCfgReCfgRb(cellId(%d), cfgType(%d)) RBID:%d",
cellId, entCfg->cfgType,entCfg->rbId);
/* Take backup of rbCb before updating.
* Because in failure case restore original rbCb
*/
- cmMemcpy((U8 *)&tRbCb, (U8 *)rbCb, sizeof(KwDlRbCb));
+ cmMemcpy((U8 *)&tRbCb, (U8 *)rbCb, sizeof(RlcDlRbCb));
/* Update rbCb */
- ret = kwCfgUpdateDlRb(gCb,rbCb, cellCb,entCfg);
+ ret = rlcCfgUpdateDlRb(gCb,rbCb, cellCb,entCfg);
if (ret != ROK)
{
/* Fill entCfm structure */
"CELLID:%u RBID:%d updation failed",
cellId,
entCfg->rbId);
- cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(KwDlRbCb));
+ cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(RlcDlRbCb));
RETVALUE(ret);
}
/* Take backup of rbCb before updating.
* Because in failure case restore original rbCb
*/
- cmMemcpy((U8 *)&tRbCb, (U8 *)rbCb, sizeof(KwDlRbCb));
+ cmMemcpy((U8 *)&tRbCb, (U8 *)rbCb, sizeof(RlcDlRbCb));
/* Update rbCb */
- ret = kwCfgUpdateDlRb(gCb,rbCb,ueCb, entCfg);
+ ret = rlcCfgUpdateDlRb(gCb,rbCb,ueCb, entCfg);
if (ret != CKW_CFG_REAS_NONE)
{
/* Fill entCfm structure */
"CELLID:%d RBID:%d updation failed",
cellId,
entCfg->rbId);
- cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(KwDlRbCb));
+ cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(RlcDlRbCb));
RETVALUE(ret);
}
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgDelDlRb
+PUBLIC S16 rlcCfgDelDlRb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-CkwEntCfgInfo *entCfg,
-CkwEntCfgCfmInfo *entCfm
+RlcEntCfgInfo *entCfg,
+RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 kwCfgDelRb(gCb,ueId, cellId, entCfg, entCfm)
-KwCb *gCb;
+PUBLIC S16 rlcCfgDelRb(gCb,ueId, cellId, entCfg, entCfm)
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-CkwEntCfgInfo *entCfg;
-CkwEntCfgCfmInfo *entCfm;
+RlcEntCfgInfo *entCfg;
+RlcEntCfgCfmInfo *entCfm;
#endif
{
S16 ret; /* Return Value */
- KwDlUeCb *ueCb; /* UE Control Block */
- KwDlCellCb *cellCb; /* UE Control Block */
- KwDlRbCb *kwRbCb; /* KW RB Control Block */
+ RlcDlUeCb *ueCb; /* UE Control Block */
+ RlcDlCellCb *cellCb; /* UE Control Block */
+ RlcDlRbCb *kwRbCb; /* KW RB Control Block */
- TRC3(kwCfgDelDlRb)
+ TRC3(rlcCfgDelDlRb)
RLOG_ARG3(L_DEBUG,DBG_UEID,ueId,
- "kwCfgDelRb(RBID(%d), cellId(%d), cfgType(%d))",
+ "rlcCfgDelRb(RBID(%d), cellId(%d), cfgType(%d))",
entCfg->rbId,
cellId,
entCfg->cfgType);
/* Assign NULLP to dlRbCb/ulRbCb.
* Delete Hashlist allocated for it if any */
cellCb->lCh[kwRbCb->lch.lChId - 1].dlRbCb = NULLP;
- KW_FREE(gCb,kwRbCb, sizeof(KwDlRbCb)); /*Vartika: Mem leak fix */
+ RLC_FREE(gCb,kwRbCb, sizeof(RlcDlRbCb)); /*Vartika: Mem leak fix */
}
/* Get ueCb and delete rbCb from it */
else
{
kwUmmFreeDlRbCb(gCb,kwRbCb);
/* Delete RbCb */
- KW_FREE(gCb,kwRbCb, sizeof(KwDlRbCb));
+ RLC_FREE(gCb,kwRbCb, sizeof(RlcDlRbCb));
}
else if( CM_LTE_MODE_AM == kwRbCb->mode)
{
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgReEstDlRb
+PUBLIC S16 rlcCfgReEstDlRb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
Bool sndReEstInd,
-CkwEntCfgInfo *entCfg,
-CkwEntCfgCfmInfo *entCfm
+RlcEntCfgInfo *entCfg,
+RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 kwCfgReEstDlRb(gCb,ueId, cellId,sndReEstInd,entCfg, entCfm)
-KwCb *gCb;
+PUBLIC S16 rlcCfgReEstDlRb(gCb,ueId, cellId,sndReEstInd,entCfg, entCfm)
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
Bool sndReEstInd;
-CkwEntCfgInfo *entCfg;
-CkwEntCfgCfmInfo *entCfm;
+RlcEntCfgInfo *entCfg;
+RlcEntCfgCfmInfo *entCfm;
#endif
{
- KwDlRbCb *rbCb; /* RB Control Block */
+ RlcDlRbCb *rbCb; /* RB Control Block */
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(kwCfgReEstDlRb)
+ TRC3(rlcCfgReEstDlRb)
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
- "kwCfgReEstDlRb(ueId(%d), cellId(%d), cfgType(%d))",
+ "rlcCfgReEstDlRb(ueId(%d), cellId(%d), cfgType(%d))",
ueId,
cellId,
entCfg->cfgType);
{
case CM_LTE_MODE_TM:
{
- kwDlTmmReEstablish(gCb,rbCb);
+ rlcDlTmmReEstablish(gCb,rbCb);
break;
}
case CM_LTE_MODE_UM:
{
- kwDlUmmReEstablish(gCb,rlcId,sndReEstInd,rbCb);
+ rlcDlUmmReEstablish(gCb,rlcId,sndReEstInd,rbCb);
break;
}
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgDelDlUe
+PUBLIC S16 rlcCfgDelDlUe
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-CkwEntCfgInfo *entCfg,
-CkwEntCfgCfmInfo *entCfm
+RlcEntCfgInfo *entCfg,
+RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 kwCfgDelDlUe(ueId, cellId, entCfg, entCfm)
-KwCb *gCb;
+PUBLIC S16 rlcCfgDelDlUe(ueId, cellId, entCfg, entCfm)
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-CkwEntCfgInfo *entCfg;
-CkwEntCfgCfmInfo *entCfm;
+RlcEntCfgInfo *entCfg;
+RlcEntCfgCfmInfo *entCfm;
#endif
{
S16 ret; /* Return Value */
- KwDlUeCb *ueCb; /* UE Control Block */
+ RlcDlUeCb *ueCb; /* UE Control Block */
- TRC3(kwCfgDelUe)
+ TRC3(rlcCfgDelUe)
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
- "kwCfgDelUe(ueId(%d), cellId(%d), cfgType(%d))",
+ "rlcCfgDelUe(ueId(%d), cellId(%d), cfgType(%d))",
ueId,
cellId,
entCfg->cfgType);
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgDelDlCell
+PUBLIC S16 rlcCfgDelDlCell
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteCellId cellId,
-CkwEntCfgInfo *entCfg,
-CkwEntCfgCfmInfo *entCfm
+RlcEntCfgInfo *entCfg,
+RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 kwCfgDelCell(gCb,cellId, entCfg, entCfm)
-KwCb *gCb;
+PUBLIC S16 rlcCfgDelCell(gCb,cellId, entCfg, entCfm)
+RlcCb *gCb;
CmLteCellId cellId;
-CkwEntCfgInfo *entCfg;
-CkwEntCfgCfmInfo *entCfm;
+RlcEntCfgInfo *entCfg;
+RlcEntCfgCfmInfo *entCfm;
#endif
{
- KwDlCellCb *cellCb; /* UE Control Block */
+ RlcDlCellCb *cellCb; /* UE Control Block */
U8 rbId; /* RB Identifier */
- TRC3(kwCfgDelCell)
+ TRC3(rlcCfgDelCell)
RLOG_ARG2(L_DEBUG,DBG_RBID,entCfg->rbId,
- "kwCfgDelCell( cellId(%d), cfgType(%d)",
+ "rlcCfgDelCell( cellId(%d), cfgType(%d)",
cellId,
entCfg->cfgType);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgDlUeIdChng
+PUBLIC S16 rlcCfgDlUeIdChng
(
-KwCb *gCb,
+RlcCb *gCb,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo,
CmStatus *status
)
#else
-PUBLIC S16 kwCfgDlUeIdChng(gCb,ueInfo,newUeInfo,status)
-KwCb *gCb;
+PUBLIC S16 rlcCfgDlUeIdChng(gCb,ueInfo,newUeInfo,status)
+RlcCb *gCb;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
CmStatus *status;
#endif
{
- KwDlUeCb *ueCb;
+ RlcDlUeCb *ueCb;
/*kw004.201 Adding of Missing Trace in LTE RLC PDCP*/
- TRC3(kwCfgUeIdChng)
+ TRC3(rlcCfgUeIdChng)
if ( (ueInfo->ueId == newUeInfo->ueId) &&
(ueInfo->cellId == newUeInfo->cellId))
Desc: It contains the following configuraiton primtives
for different actions
- -- kwCfgValdtEntCfg
- -- kwCfgFillRbCb
- -- kwCfgRbInit
+ -- rlcCfgValdtEntCfg
+ -- rlcCfgFillRbCb
+ -- rlcCfgRbInit
File: kw_cfg_ul.c
#include "l2_tenb_stats.x" /* Total EnodeB Stats declarations */
#endif
#endif
-PUBLIC S16 kwValidateRbCfgParams (KwCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
- CkwEntCfgInfo *cfgToValidate, CmStatus *status);
+PUBLIC S16 kwValidateRbCfgParams (RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
+ RlcEntCfgInfo *cfgToValidate, CmStatus *status);
#define KW_MODULE KW_DBGMASK_CFG
#ifdef LTE_L2_MEAS
/**
* -# RFAILED
*
*/
-PRIVATE S16 kwHdlMeasUlUeIdChg(KwCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
+PRIVATE S16 kwHdlMeasUlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
{
KwL2MeasCb *measCb = NULLP;
U16 cntr;
* -# RFAILED
*
*/
-PRIVATE S16 kwDelFrmUlL2Meas(KwCb *gCb, U8 cellId,U8 ueId)
+PRIVATE S16 kwDelFrmUlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
{
KwL2MeasCb *measCb = NULLP;
U16 cntr;
{
U32 myIdx =0;
S16 ret; /* Return value */
- KwUlUeCb *ueCb = NULL;
+ RlcUlUeCb *ueCb = NULL;
for (myIdx = 0; myIdx < measCb->val.ipThMeas.numUes; myIdx++)
{
}
-PRIVATE S16 kwAddToUlL2Meas(KwCb *gCb, KwUlRbCb *kwRbCb,U8 cellId,U8 ueId)
+PRIVATE S16 kwAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *kwRbCb,U8 cellId,U8 ueId)
{
KwL2MeasCb *measCb = NULLP;
U16 cntr;
* -#RFAILED
*/
#ifdef ANSI
-PRIVATE S16 kwCfgFillUlRbCb
+PRIVATE S16 rlcCfgFillUlRbCb
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
-KwUlUeCb *ueCb,
-CkwEntCfgInfo *entCfg
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
+RlcUlUeCb *ueCb,
+RlcEntCfgInfo *entCfg
)
#else
-PRIVATE S16 kwCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg)
-KwCb *gCb;
-KwUlRbCb *rbCb;
-KwUlUeCb *ueCb;
-CkwEntCfgInfo *entCfg;
+PRIVATE S16 rlcCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg)
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
+RlcUlUeCb *ueCb;
+RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(kwCfgFillUlRbCb)
+ TRC3(rlcCfgFillUlRbCb)
RLOG_ARG3(L_DEBUG,DBG_UEID,rbCb->rlcId.ueId,
- "kwCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
+ "rlcCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
rbCb->rlcId.cellId,
entCfg->rbId,
entCfg->rbType);
* -#RFAILED
*/
#ifdef ANSI
-PRIVATE S16 kwCfgUpdateUlRb
+PRIVATE S16 rlcCfgUpdateUlRb
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
void *ptr,
-CkwEntCfgInfo *entCfg
+RlcEntCfgInfo *entCfg
)
#else
-PRIVATE S16 kwCfgUpdateUlRb(gCb,rbCb, ptr, entCfg)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+PRIVATE S16 rlcCfgUpdateUlRb(gCb,rbCb, ptr, entCfg)
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
void *ptr;
-CkwEntCfgInfo *entCfg;
+RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(kwCfgUpdateUlRb)
+ TRC3(rlcCfgUpdateUlRb)
switch (rbCb->mode)
{
case CM_LTE_MODE_TM:
{
- KwUlCellCb *cellCb = (KwUlCellCb *)ptr;
+ RlcUlCellCb *cellCb = (RlcUlCellCb *)ptr;
rbCb->dir = entCfg->dir;
rbCb->lch.lChId = entCfg->lCh[0].lChId;
rbCb->lch.lChType = entCfg->lCh[0].type;
}
case CM_LTE_MODE_UM:
{
- KwUlUeCb *ueCb = (KwUlUeCb *)ptr;
+ RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
- kwCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg);
+ rlcCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg);
break;
}
case CM_LTE_MODE_AM:
{
- KwUlUeCb *ueCb = (KwUlUeCb *)ptr;
+ RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
ueCb->lCh[entCfg->lCh[1].lChId - 1].ulRbCb = rbCb;
#ifdef ANSI
PUBLIC S16 kwValidateRbCfgParams
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-CkwEntCfgInfo *cfgToValidate,
+RlcEntCfgInfo *cfgToValidate,
CmStatus *status
)
#else
PUBLIC S16 kwValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-CkwEntCfgInfo *cfgToValidate;
+RlcEntCfgInfo *cfgToValidate;
CmStatus *status;
#endif
{
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgValidateUlRb
+PUBLIC S16 rlcCfgValidateUlRb
(
-KwCb *gCb,
-CkwEntCfgInfo *cfgToValidate,
-KwUlEntTmpData *cfgEntData,
-KwUlCfgTmpData *cfgTmpData
+RlcCb *gCb,
+RlcEntCfgInfo *cfgToValidate,
+RlcUlEntTmpData *cfgEntData,
+RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 kwCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
-KwCb *gCb;
-CkwEntCfgInfo *cfgToValidate;
-KwUlEntTmpData *cfgEntData;
-KwUlCfgTmpData *cfgTmpData;
+PUBLIC S16 rlcCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
+RlcCb *gCb;
+RlcEntCfgInfo *cfgToValidate;
+RlcUlEntTmpData *cfgEntData;
+RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(kwCfgValidateUlRb)
+ TRC3(rlcCfgValidateUlRb)
RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
"cellId(%d), cfgType(%d)",
if(!cfgTmpData->cellCb)
{
/* cell cb does not exist we need to create a new one */
- KW_ALLOC(gCb,cfgTmpData->cellCb, sizeof(KwUlCellCb));
+ RLC_ALLOC(gCb,cfgTmpData->cellCb, sizeof(RlcUlCellCb));
if(!cfgTmpData->cellCb)
{
RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId,
}
}
- KW_ALLOC(gCb,cfgEntData->rbCb, sizeof (KwUlRbCb));
+ RLC_ALLOC(gCb,cfgEntData->rbCb, sizeof (RlcUlRbCb));
if (!cfgEntData->rbCb)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
if(!cfgTmpData->ueCb)
{
- KW_ALLOC(gCb,cfgTmpData->ueCb, sizeof(KwUlUeCb));
+ RLC_ALLOC(gCb,cfgTmpData->ueCb, sizeof(RlcUlUeCb));
if(!cfgTmpData->ueCb)
{
RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId,
RETVALUE(RFAILED);
}
}
- KW_ALLOC(gCb,cfgEntData->rbCb, sizeof (KwUlRbCb));
+ RLC_ALLOC(gCb,cfgEntData->rbCb, sizeof (RlcUlRbCb));
if (!cfgEntData->rbCb)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
cfgEntData->rbCb->m.umUl.umWinSz = KW_POWER(2,
((cfgToValidate->m.umInfo.ul.snLen *5)-1));
winLen = cfgEntData->rbCb->m.umUl.umWinSz << 1;
- KW_ALLOC(gCb,
+ RLC_ALLOC(gCb,
cfgEntData->rbCb->m.umUl.recBuf,
(winLen * sizeof(KwUmRecBuf*)));
}
{
#ifndef LTE_TDD
U32 hashIndex;
- KW_ALLOC(gCb,
+ RLC_ALLOC(gCb,
cfgEntData->rbCb->m.amUl.recBufLst,
(KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
for(hashIndex = 0; hashIndex < KW_RCV_BUF_BIN_SIZE; hashIndex++)
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgRollBackUlRb
+PUBLIC S16 rlcCfgRollBackUlRb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
-CkwEntCfgInfo *cfg,
-KwUlEntTmpData *cfgEntData
+RlcEntCfgInfo *cfg,
+RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC S16 kwCfgRollBackUlRb(gCb, cfg, cfgEntData)
+PUBLIC S16 rlcCfgRollBackUlRb(gCb, cfg, cfgEntData)
(
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
-CkwEntCfgInfo *cfg;
-KwUlEntTmpData *cfgEntData;
+RlcEntCfgInfo *cfg;
+RlcUlEntTmpData *cfgEntData;
)
#endif
{
- TRC3(kwCfgRollBackUlRb)
+ TRC3(rlcCfgRollBackUlRb)
if(CKW_CFG_ADD == cfg->cfgType)
{
if(CM_LTE_MODE_UM == cfg->entMode)
{
- KW_FREE(gCb,
+ RLC_FREE(gCb,
cfgEntData->rbCb->m.umUl.recBuf,
(cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(KwUmRecBuf*));
}
else if(CM_LTE_MODE_AM == cfg->entMode)
{
#ifndef LTE_TDD
- KW_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
#endif
}
- KW_FREE(gCb,cfgEntData->rbCb, sizeof(KwUlRbCb));
+ RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
}
RETVALUE(ROK);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Void kwCfgApplyUlRb
+PUBLIC Void rlcCfgApplyUlRb
(
-KwCb *gCb,
-CkwEntCfgInfo *cfgToAply,
-KwUlEntTmpData *cfgEntData,
-KwUlCfgTmpData *cfgTmpData
+RlcCb *gCb,
+RlcEntCfgInfo *cfgToAply,
+RlcUlEntTmpData *cfgEntData,
+RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void kwCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
+PUBLIC Void rlcCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
(
-KwCb *gCb;
-CkwEntCfgInfo *cfgToAply;
-KwUlEntTmpData *cfgEntData;
-KwUlCfgTmpData *cfgTmpData;
+RlcCb *gCb;
+RlcEntCfgInfo *cfgToAply;
+RlcUlEntTmpData *cfgEntData;
+RlcUlCfgTmpData *cfgTmpData;
)
#endif
{
- TRC3(kwCfgApplyUlRb)
+ TRC3(rlcCfgApplyUlRb)
switch(cfgToAply->cfgType)
{
cfgEntData->rbCb->inst = gCb->init.inst;
/* Fill RB CB */
- kwCfgFillUlRbCb(gCb,
+ rlcCfgFillUlRbCb(gCb,
cfgEntData->rbCb,
cfgTmpData->ueCb,
cfgToAply);
{
if(cfgTmpData->ueId == 0)
{
- kwCfgUpdateUlRb(gCb,
+ rlcCfgUpdateUlRb(gCb,
cfgEntData->rbCb,
(void *)cfgTmpData->cellCb,
cfgToAply);
}
else
{
- kwCfgUpdateUlRb(gCb,
+ rlcCfgUpdateUlRb(gCb,
cfgEntData->rbCb,
(void*)cfgTmpData->ueCb,
cfgToAply);
}
}
/* Delete RbCb */
- KW_FREE(gCb,cfgEntData->rbCb, sizeof(KwUlRbCb));
+ RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
KW_LMM_RB_STS_DEC(gCb);
break;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgValidateDelUlUe
+PUBLIC S16 rlcCfgValidateDelUlUe
(
-KwCb *gCb,
-CkwEntCfgInfo *cfgToValidate,
-KwUlEntTmpData *cfgEntData,
-KwUlCfgTmpData *cfgTmpData
+RlcCb *gCb,
+RlcEntCfgInfo *cfgToValidate,
+RlcUlEntTmpData *cfgEntData,
+RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 kwCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
-KwCb *gCb;
-CkwEntCfgInfo *cfgToValidate;
-KwUlEntTmpData *cfgEntData;
-KwUlCfgTmpData *cfgTmpData;
+PUBLIC S16 rlcCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
+RlcCb *gCb;
+RlcEntCfgInfo *cfgToValidate;
+RlcUlEntTmpData *cfgEntData;
+RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(kwCfgValidateDelUlUe)
+ TRC3(rlcCfgValidateDelUlUe)
RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
"cellId(%d), cfgType(%d)",
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void kwCfgApplyDelUlUe
+PUBLIC Void rlcCfgApplyDelUlUe
(
-KwCb *gCb,
-KwUlCfgTmpData *cfgTmpData
+RlcCb *gCb,
+RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void kwCfgApplyDelUlUe(gCb, cfgTmpData)
+PUBLIC Void rlcCfgApplyDelUlUe(gCb, cfgTmpData)
(
-KwCb *gCb;
-KwUlCfgTmpData *cfgTmpData;
+RlcCb *gCb;
+RlcUlCfgTmpData *cfgTmpData;
)
#endif
{
- TRC3(kwCfgApplyDelUlUe)
+ TRC3(rlcCfgApplyDelUlUe)
#ifdef LTE_L2_MEAS
kwDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgValidateDelUlCell
+PUBLIC S16 rlcCfgValidateDelUlCell
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteCellId cellId,
-CkwEntCfgInfo *cfgToValidate,
-KwUlEntTmpData *cfgEntData,
-KwUlCfgTmpData *cfgTmpData
+RlcEntCfgInfo *cfgToValidate,
+RlcUlEntTmpData *cfgEntData,
+RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 kwCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
-KwCb *gCb;
+PUBLIC S16 rlcCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
+RlcCb *gCb;
CmLteCellId cellId;
-CkwEntCfgInfo *cfgToValidate;
-KwUlEntTmpData *cfgEntData;
-KwUlCfgTmpData *cfgTmpData;
+RlcEntCfgInfo *cfgToValidate;
+RlcUlEntTmpData *cfgEntData;
+RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(kwCfgValidateDelUlCell)
+ TRC3(rlcCfgValidateDelUlCell)
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellId ,"cfgType(%d)",
cfgToValidate->cfgType);
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void kwCfgApplyDelUlCell
+PUBLIC Void rlcCfgApplyDelUlCell
(
-KwCb *gCb,
-KwUlCfgTmpData *cfgInfo
+RlcCb *gCb,
+RlcUlCfgTmpData *cfgInfo
)
#else
-PUBLIC Void kwCfgApplyDelUlCell(gCb, cfgEntData)
+PUBLIC Void rlcCfgApplyDelUlCell(gCb, cfgEntData)
(
-KwCb *gCb;
-KwUlCfgTmpData *cfgInfo;
+RlcCb *gCb;
+RlcUlCfgTmpData *cfgInfo;
)
#endif
{
- TRC3(kwCfgApplyDelUlCell)
+ TRC3(rlcCfgApplyDelUlCell)
kwDbmDelUlCellCb(gCb,cfgInfo->cellCb);
RETVOID;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgValidateReEstRb
+PUBLIC S16 rlcCfgValidateReEstRb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-CkwEntCfgInfo *cfgToValidate,
-KwUlEntTmpData *cfgEntData
+RlcEntCfgInfo *cfgToValidate,
+RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC S16 kwCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
-KwCb *gCb;
+PUBLIC S16 rlcCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-CkwEntCfgInfo *cfgToValidate;
-KwUlEntTmpData *cfgEntData;
+RlcEntCfgInfo *cfgToValidate;
+RlcUlEntTmpData *cfgEntData;
#endif
{
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(kwCfgValidateReEstRb)
+ TRC3(rlcCfgValidateReEstRb)
RLOG_ARG2(L_DEBUG, DBG_UEID,ueId,
"cellId(%d) RBID:%d",
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void kwCfgApplyReEstUlRb
+PUBLIC Void rlcCfgApplyReEstUlRb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
Bool sndReEstInd,
-KwUlEntTmpData *cfgEntData
+RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC Void kwCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
+PUBLIC Void rlcCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
(
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
Bool sndReEstInd;
-KwUlEntTmpData *cfgEntData;
+RlcUlEntTmpData *cfgEntData;
)
#endif
{
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(kwCfgApplyReEstUlRb)
+ TRC3(rlcCfgApplyReEstUlRb)
rlcId.ueId = ueId;
rlcId.cellId = cellId;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwCfgValidateUeIdChng
+PUBLIC S16 rlcCfgValidateUeIdChng
(
-KwCb *gCb,
+RlcCb *gCb,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo,
-KwUlCfgTmpData *cfgTmpData
+RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 kwCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
-KwCb *gCb;
+PUBLIC S16 rlcCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
+RlcCb *gCb;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
-KwUlCfgTmpData *cfgTmpData;
+RlcUlCfgTmpData *cfgTmpData;
#endif
{
- KwUlUeCb *ueCb;
- TRC3(kwCfgValidateUeIdChng)
+ RlcUlUeCb *ueCb;
+ TRC3(rlcCfgValidateUeIdChng)
#define CFM_STATUS cfgTmpData->cfgEntData[0].entUlCfgCfm.status
if ( (ueInfo->ueId == newUeInfo->ueId) &&
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void kwCfgApplyUlUeIdChng
+PUBLIC Void rlcCfgApplyUlUeIdChng
(
-KwCb *gCb,
+RlcCb *gCb,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo,
-KwUlCfgTmpData *cfgTmpData
+RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void kwCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
+PUBLIC Void rlcCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
(
-KwCb *gCb;
+RlcCb *gCb;
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo,
-KwUlCfgTmpData *cfgTmpData;
+RlcUlCfgTmpData *cfgTmpData;
)
#endif
{
- TRC3(kwCfgApplyUlUeIdChng)
+ TRC3(rlcCfgApplyUlUeIdChng)
#ifdef LTE_L2_MEAS
kwHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
#ifdef ANSI
PUBLIC S16 kwDbmDlInit
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC S16 kwDbmDlInit(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
TRC3(kwDbmDlInit)
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
/* Initialize qcI Hash List */
- if(ROK != cmHashListInit(&(kwCb.kwL2Cb.qciHlCp),
+ if(ROK != cmHashListInit(&(rlcCb.kwL2Cb.qciHlCp),
(U16) KW_QCI_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) TRUE,
(U16) CM_HASH_KEYTYPE_DEF,
- kwCb.init.region,
- kwCb.init.pool))
+ rlcCb.init.region,
+ rlcCb.init.pool))
{
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
- RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for kwCb.qciHlCp");
+ RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for rlcCb.qciHlCp");
RETVALUE(RFAILED);
}
/* Initialize tbHlCp Hash List */
- if(ROK != cmHashListInit(&(kwCb.kwL2Cb.tbHlCp),
+ if(ROK != cmHashListInit(&(rlcCb.kwL2Cb.tbHlCp),
(U16) KW_TB_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) FALSE,
(U16) CM_HASH_KEYTYPE_DEF,
- kwCb.init.region,
- kwCb.init.pool))
+ rlcCb.init.region,
+ rlcCb.init.pool))
{
- cmHashListDeinit(&kwCb.kwL2Cb.qciHlCp);
+ cmHashListDeinit(&rlcCb.kwL2Cb.qciHlCp);
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
- RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for kwCb.tbHlCp");
+ RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for rlcCb.tbHlCp");
RETVALUE(RFAILED);
}
#endif /* LTE_L2_MEAS */
#ifdef ANSI
PUBLIC Void kwDbmDlDeInit
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwDbmDlDeInit(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
TRC3(kwDbmDlDeInit);
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
/* De Initialize qciCb Hash List */
- cmHashListDeinit(&(kwCb.kwL2Cb.qciHlCp));
+ cmHashListDeinit(&(rlcCb.kwL2Cb.qciHlCp));
/* De Initialize tbHlCp Hash List */
- cmHashListDeinit(&(kwCb.kwL2Cb.tbHlCp));
+ cmHashListDeinit(&(rlcCb.kwL2Cb.tbHlCp));
#endif /* LTE_L2_MEAS */
#ifdef ANSI
PUBLIC Void kwDbmFetchDlRbCbByRbId
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRlcId *rlcId,
-KwDlRbCb **rbCb
+RlcDlRbCb **rbCb
)
#else
PUBLIC Void kwDbmFetchDlRbCbByRbId(gCb, rlcId, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRlcId *rlcId;
-KwDlRbCb **rbCb;
+RlcDlRbCb **rbCb;
#endif
{
TRC3(kwDbmFetchDlRbCbByRbId)
/* Check for UE CB or CELL CB */
if (rlcId->ueId == 0)
{
- KwDlCellCb *cellCb;
+ RlcDlCellCb *cellCb;
if(rlcId->rbId >= KW_MAX_RB_PER_CELL)
{
}
else
{
- KwDlUeCb *ueCb;
+ RlcDlUeCb *ueCb;
if (!(KW_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
{
RLOG_ARG3(L_ERROR,DBG_RBID, rlcId->rbId,
#ifdef ANSI
PUBLIC Void kwDbmFetchDlRbCbFromLchId
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
CmLteLcId lcId,
-KwDlRbCb **rbCb
+RlcDlRbCb **rbCb
)
#else
PUBLIC Void kwDbmFetchDlRbCbFromLchId(gCb, ueId, cellId, lcId, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
CmLteLcId lcId;
-KwDlRbCb **rbCb;
+RlcDlRbCb **rbCb;
#endif
{
- KwDlUeCb *ueCb;
+ RlcDlUeCb *ueCb;
TRC3(kwDbmFetchDlRbCbFromLchId)
/* Check for UE CB or CELL CB */
if (ueId == 0)
{
- KwDlCellCb *cellCb;
+ RlcDlCellCb *cellCb;
kwDbmFetchDlCellCb(gCb, cellId, &cellCb);
if(!cellCb)
#ifdef ANSI
PUBLIC Void kwDbmDelAllDlRb
(
-KwCb *gCb,
-KwDlRbCb **rbCbLst,
+RlcCb *gCb,
+RlcDlRbCb **rbCbLst,
U8 numRbCb
)
#else
PUBLIC Void kwDbmDelAllDlRb(gCb, rbCbLst, numRbCb)
-KwCb *gCb;
-KwDlRbCb **rbCbLst;
+RlcCb *gCb;
+RlcDlRbCb **rbCbLst;
U8 numRbCb;
#endif
{
{
kwUmmFreeDlRbCb(gCb,rbCbLst[idx]);
- KW_FREE (gCb,rbCbLst[idx], sizeof (KwDlRbCb));
+ RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcDlRbCb));
}
else if( CM_LTE_MODE_AM == rbCbLst[idx]->mode)
{
else if(CM_LTE_MODE_TM == rbCbLst[idx]->mode)
{
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCbLst[idx]->m.tm.sduQ));
- KW_FREE (gCb,rbCbLst[idx], sizeof (KwDlRbCb));
+ RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcDlRbCb));
}
}
*
* @details
* This function is invoked by CFG to create UeCb and insert into the
- * Ue hashlist of KwCb.
+ * Ue hashlist of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] ueId UE Identifier
#ifdef ANSI
PUBLIC S16 kwDbmCreateDlUeCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-KwDlUeCb **ueCb
+RlcDlUeCb **ueCb
)
#else
PUBLIC S16 kwDbmCreateDlUeCb(gCb,ueId, cellId, ueCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-KwDlUeCb **ueCb;
+RlcDlUeCb **ueCb;
#endif
{
- KwDlUeCb *tUeCb;
+ RlcDlUeCb *tUeCb;
TRC3(kwDbmCreateDlUeCb)
- KW_ALLOC(gCb,*ueCb, sizeof(KwDlUeCb));
+ RLC_ALLOC(gCb,*ueCb, sizeof(RlcDlUeCb));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*ueCb == NULLP)
*
* @details
* This function is invoked by CFG to fetch UeCb from the Ue hashlist
- * of KwCb.
+ * of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] ueId UE Identifier
#ifdef ANSI
PUBLIC S16 kwDbmFetchDlUeCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-KwDlUeCb **ueCb
+RlcDlUeCb **ueCb
)
#else
PUBLIC S16 kwDbmFetchDlUeCb(gCb,ueId, cellId, ueCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-KwDlUeCb **ueCb;
+RlcDlUeCb **ueCb;
#endif
{
*
* @details
* This function is invoked by CFG to delete UeCb from the Ue hashlist
- * of KwCb.
+ * of RlcCb.
*
*
* @param[in] gCb RLC Instance Control Block
#ifdef ANSI
PUBLIC Void kwDbmDelDlUeCb
(
-KwCb *gCb,
-KwDlUeCb *ueCb,
+RlcCb *gCb,
+RlcDlUeCb *ueCb,
Bool abortFlag
)
#else
PUBLIC Void kwDbmDelDlUeCb(gCb,eCb, abortFlag)
-KwCb *gCb;
-KwDlUeCb *ueCb;
+RlcCb *gCb;
+RlcDlUeCb *ueCb;
Bool abortFlag;
#endif
{
defined(PJ_CMP_ASYNC)))*/
/* Delete all logical channels */
- KW_MEM_ZERO(ueCb->lCh,sizeof(KwDlLch) * KW_MAX_LCH_PER_UE);
+ KW_MEM_ZERO(ueCb->lCh,sizeof(RlcDlLch) * KW_MAX_LCH_PER_UE);
/* Delete all SRB RbCbs in UeCb */
kwDbmDelAllDlRb(gCb,ueCb->srbCb, KW_MAX_SRB_PER_UE);
gCb->genSts.numUe--;
/* Deallocate ueCb */
- KW_FREE(gCb,ueCb, sizeof(KwDlUeCb));
+ RLC_FREE(gCb,ueCb, sizeof(RlcDlUeCb));
RETVOID;
} /* kwDbmDelUeCb */
*
* @details
* This function is invoked by CFG to delete all UeCbs from the Ue
- * hashlist of KwCb.
+ * hashlist of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
*
#ifdef ANSI
PUBLIC Void kwDbmDelAllDlUe
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwDbmDelAllDlUe(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
- KwDlUeCb *ueCb = NULLP;
+ RlcDlUeCb *ueCb = NULLP;
TRC3(kwDbmDelAllDlUe)
#ifdef ANSI
PUBLIC Void kwDbmDelAllDlL2MeasTbFrmUe
(
-KwCb *gCb,
-KwDlUeCb *ueCb
+RlcCb *gCb,
+RlcDlUeCb *ueCb
)
#else
PUBLIC Void kwDbmDelAllDlL2MeasTbFrmUe(gCb,ueCb)
-KwCb *gCb;
-KwDlUeCb *ueCb;
+RlcCb *gCb;
+RlcDlUeCb *ueCb;
#endif
{
U8 tbIdx;
l2MeasTb = ueCb->l2MeasTbCb[tbIdx];
if(l2MeasTb != NULLP)
{
- KW_FREE(gCb,l2MeasTb, sizeof(KwL2MeasTb));
+ RLC_FREE(gCb,l2MeasTb, sizeof(KwL2MeasTb));
ueCb->l2MeasTbCb[tbIdx] = NULLP;
}
}
*
* @details
* This function is invoked by CFG to create CellCb and insert into
- * the Cell hashlist of KwCb.
+ * the Cell hashlist of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] cellId Cell Identifier
#ifdef ANSI
PUBLIC S16 kwDbmCreateDlCellCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteCellId cellId,
-KwDlCellCb **cellCb
+RlcDlCellCb **cellCb
)
#else
PUBLIC S16 kwDbmCreateDlCellCb(gCb,cellId, cellCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteCellId cellId;
-KwDlCellCb **cellCb;
+RlcDlCellCb **cellCb;
#endif
{
- KwDlCellCb *tCellCb;
+ RlcDlCellCb *tCellCb;
TRC3(kwDbmCreateDlCellCb)
- KW_ALLOC(gCb,*cellCb, sizeof(KwDlCellCb));
+ RLC_ALLOC(gCb,*cellCb, sizeof(RlcDlCellCb));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*cellCb == NULLP)
{
*
* @details
* This function is invoked by CFG to fetch UeCb from the Ue hashlist
- * of KwCb.
+ * of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] cellId Cell Identifier
#ifdef ANSI
PUBLIC S16 kwDbmFetchDlCellCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteCellId cellId,
-KwDlCellCb **cellCb
+RlcDlCellCb **cellCb
)
#else
PUBLIC S16 kwDbmFetchDlCellCb(gCb,cellId, cellCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteCellId cellId;
-KwDlCellCb **cellCb;
+RlcDlCellCb **cellCb;
#endif
{
TRC3(kwDbmFetchDlCellCb)
*
* @details
* This function is invoked by CFG to delete CellCb from the Cell hashlist
- * of KwCb.
+ * of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] cellCb Cell Control Block
#ifdef ANSI
PUBLIC Void kwDbmDelDlCellCb
(
-KwCb *gCb,
-KwDlCellCb *cellCb
+RlcCb *gCb,
+RlcDlCellCb *cellCb
)
#else
PUBLIC Void kwDbmDelDlCellCb(gCb,cellCb)
-KwCb *gCb;
-KwDlCellCb *cellCb;
+RlcCb *gCb;
+RlcDlCellCb *cellCb;
#endif
{
TRC3(kwDbmDelDlCellCb)
}
/* Deallocate cellCb */
- KW_FREE(gCb, cellCb, sizeof(KwDlCellCb));
+ RLC_FREE(gCb, cellCb, sizeof(RlcDlCellCb));
RETVOID;
} /* kwDbmDelCellCb */
*
* @details
* This function is invoked by CFG to delete all UeCbs from the Ue
- * hashlist of KwCb.
+ * hashlist of RlcCb.
* @param[in] gCb RLC Instance Control Block
*
* @return Void
#ifdef ANSI
PUBLIC Void kwDbmDelAllDlCell
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwDbmDelAllDlCell(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
- KwDlCellCb *cellCb = NULLP;
+ RlcDlCellCb *cellCb = NULLP;
TRC3(kwDbmDelAllDlCell)
*
* @details
* This function is invoked by LMM to delete all UeCbs from the Ue
- * hashlist of KwCb and cellCbs from the Cell hashlist of kwCb.
+ * hashlist of RlcCb and cellCbs from the Cell hashlist of rlcCb.
*
* @param[in] gCb RLC Instance Control Block
*
#ifdef ANSI
PUBLIC S16 kwDbmDlShutdown
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC S16 kwDbmDlShutdown(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
TRC3(kwDbmDlShutdown)
#ifdef ANSI
PUBLIC S16 kwDbmUlInit
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC S16 kwDbmUlInit(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
- TRC3(kwUlDbmInit)
+ TRC3(rlcUlDbmInit)
/* Initialize ueCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.ulCb->ueLstCp),
#ifdef ANSI
PUBLIC Void kwDbmUlDeInit
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwDbmUlDeInit(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
TRC3(kwDbmUlDeInit);
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
/* De Initialize qciCb Hash List */
- cmHashListDeinit(&(kwCb.kwL2Cb.qciHlCp));
+ cmHashListDeinit(&(rlcCb.kwL2Cb.qciHlCp));
#endif /* LTE_L2_MEAS */
RETVOID;
#ifdef ANSI
PUBLIC Void kwDbmFetchUlRbCbByRbId
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRlcId *rlcId,
-KwUlRbCb **rbCb
+RlcUlRbCb **rbCb
)
#else
PUBLIC Void kwDbmFetchUlRbCbByRbId(gCb, rlcId, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRlcId *rlcId;
-KwUlRbCb **rbCb;
+RlcUlRbCb **rbCb;
#endif
{
TRC3(kwDbmFetchUlRbCbByRbId)
/* Check for UE CB or CELL CB */
if (rlcId->ueId == 0)
{
- KwUlCellCb *cellCb;
+ RlcUlCellCb *cellCb;
if(rlcId->rbId >= KW_MAX_RB_PER_CELL)
{
}
else
{
- KwUlUeCb *ueCb;
+ RlcUlUeCb *ueCb;
if (!(KW_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
{
#ifdef ANSI
PUBLIC Void kwDbmFetchUlRbCbFromLchId
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
CmLteLcId lcId,
-KwUlRbCb **rbCb
+RlcUlRbCb **rbCb
)
#else
PUBLIC Void kwDbmFetchUlRbCbFromLchId(gCb, ueId, cellId, lcId, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
CmLteLcId lcId;
-KwUlRbCb **rbCb;
+RlcUlRbCb **rbCb;
#endif
{
- KwUlUeCb *ueCb;
+ RlcUlUeCb *ueCb;
TRC3(kwDbmFetchUlRbCbFromLchId)
/* Check for UE CB or CELL CB */
if (ueId == 0)
{
- KwUlCellCb *cellCb;
+ RlcUlCellCb *cellCb;
kwDbmFetchUlCellCb(gCb,cellId, &cellCb);
if(!cellCb)
#ifdef ANSI
PUBLIC Void kwDbmDelAllUlRb
(
-KwCb *gCb,
-KwUlRbCb **rbCbLst,
+RlcCb *gCb,
+RlcUlRbCb **rbCbLst,
U8 numRbCb
)
#else
PUBLIC Void kwDbmDelAllUlRb(gCb, rbCbLst, numRbCb)
-KwCb *gCb;
-KwUlRbCb **rbCbLst;
+RlcCb *gCb;
+RlcUlRbCb **rbCbLst;
U8 numRbCb;
#endif
{
kwAmmFreeUlRbCb(gCb,rbCbLst[idx]);
}
- KW_FREE (gCb,rbCbLst[idx], sizeof (KwUlRbCb));
+ RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcUlRbCb));
}
}
*
* @details
* This function is invoked by CFG to create UeCb and insert into the
- * Ue hashlist of KwCb.
+ * Ue hashlist of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] ueId UE Identifier
#ifdef ANSI
PUBLIC S16 kwDbmAddUlUeCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-KwUlUeCb *ueCb
+RlcUlUeCb *ueCb
)
#else
PUBLIC S16 kwDbmAddUlUeCb(gCb, ueId, cellId, ueCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-KwUlUeCb *ueCb;
+RlcUlUeCb *ueCb;
#endif
{
TRC3(kwDbmAddUlUeCb)
#ifdef ANSI
PUBLIC S16 kwDbmAddUlTransaction
(
-KwCb *gCb,
-KwUlCfgTmpData *cfg
+RlcCb *gCb,
+RlcUlCfgTmpData *cfg
)
#else
PUBLIC S16 kwDbmAddUlTransaction(gCb, cfg)
-KwCb *gCb;
-KwUlCfgTmpData *cfg;
+RlcCb *gCb;
+RlcUlCfgTmpData *cfg;
#endif
{
TRC3(kwDbmAddUlTransaction)
#ifdef ANSI
PUBLIC S16 kwDbmFindUlTransaction
(
-KwCb *gCb,
+RlcCb *gCb,
U32 transId,
-KwUlCfgTmpData **cfg
+RlcUlCfgTmpData **cfg
)
#else
PUBLIC S16 kwDbmFindUlTransaction(gCb, cfg)
-KwCb *gCb;
+RlcCb *gCb;
U32 transId;
-KwUlCfgTmpData **cfg;
+RlcUlCfgTmpData **cfg;
#endif
{
TRC3(kwDbmFindUlTransaction)
#ifdef ANSI
PUBLIC S16 kwDbmDelUlTransaction
(
-KwCb *gCb,
-KwUlCfgTmpData *cfg
+RlcCb *gCb,
+RlcUlCfgTmpData *cfg
)
#else
PUBLIC S16 kwDbmDelUlTransaction(gCb, cfg)
-KwCb *gCb;
-KwUlCfgTmpData *cfg;
+RlcCb *gCb;
+RlcUlCfgTmpData *cfg;
#endif
{
TRC3(kwDbmDelUlTransaction)
#ifdef ANSI
PUBLIC S16 kwDbmDelAllUlTransactions
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC S16 kwDbmDelAllUlTransactions(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
- KwUlCfgTmpData *cfg = NULL;
+ RlcUlCfgTmpData *cfg = NULL;
TRC3(kwDbmDelAllUlTransctions)
*
* @details
* This function is invoked by CFG to fetch UeCb from the Ue hashlist
- * of KwCb.
+ * of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] ueId UE Identifier
#ifdef ANSI
PUBLIC S16 kwDbmFetchUlUeCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
-KwUlUeCb **ueCb
+RlcUlUeCb **ueCb
)
#else
PUBLIC S16 kwDbmFetchUlUeCb(gCb,ueId, cellId, ueCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
-KwUlUeCb **ueCb;
+RlcUlUeCb **ueCb;
#endif
{
TRC3(kwDbmFetchUlUeCb)
*
* @details
* This function is invoked by CFG to delete UeCb from the Ue hashlist
- * of KwCb.
+ * of RlcCb.
*
*
* @param[in] gCb RLC Instance Control Block
#ifdef ANSI
PUBLIC Void kwDbmDelUlUeCb
(
-KwCb *gCb,
-KwUlUeCb *ueCb,
+RlcCb *gCb,
+RlcUlUeCb *ueCb,
Bool abortFlag
)
#else
PUBLIC Void kwDbmDelUlUeCb(gCb,eCb, abortFlag)
-KwCb *gCb;
-KwUlUeCb *ueCb;
+RlcCb *gCb;
+RlcUlUeCb *ueCb;
Bool abortFlag;
#endif
{
#endif /* (!defined(KW_PDCP) || ! (defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))*/
/* Delete all logical channels */
- KW_MEM_ZERO(ueCb->lCh,sizeof(KwUlLch) * KW_MAX_LCH_PER_UE);
+ KW_MEM_ZERO(ueCb->lCh,sizeof(RlcUlLch) * KW_MAX_LCH_PER_UE);
/* Delete all SRB RbCbs in UeCb */
kwDbmDelAllUlRb(gCb,ueCb->srbCb, KW_MAX_SRB_PER_UE);
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.numUe--;
/* Deallocate ueCb */
- KW_FREE(gCb,ueCb, sizeof(KwUlUeCb));
+ RLC_FREE(gCb,ueCb, sizeof(RlcUlUeCb));
RETVOID;
}
*
* @details
* This function is invoked by CFG to delete all UeCbs from the Ue
- * hashlist of KwCb.
+ * hashlist of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
*
#ifdef ANSI
PUBLIC Void kwDbmDelAllUlUe
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwDbmDelAllUlUe(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
- KwUlUeCb *ueCb = NULLP; /* UE Control Block */
+ RlcUlUeCb *ueCb = NULLP; /* UE Control Block */
TRC3(kwDbmDelAllUlUe)
*
* @details
* This function is invoked by CFG to create CellCb and insert into
- * the Cell hashlist of KwCb.
+ * the Cell hashlist of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] cellId Cell Identifier
#ifdef ANSI
PUBLIC S16 kwDbmAddUlCellCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteCellId cellId,
-KwUlCellCb *cellCb
+RlcUlCellCb *cellCb
)
#else
PUBLIC S16 kwDbmAddUlCellCb(gCb, cellId, cellCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteCellId cellId;
-KwUlCellCb *cellCb;
+RlcUlCellCb *cellCb;
#endif
{
- KwUlCellCb *tCellCb;
+ RlcUlCellCb *tCellCb;
TRC3(kwDbmAddUlCellCb)
*
* @details
* This function is invoked by CFG to fetch UeCb from the Ue hashlist
- * of KwCb.
+ * of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] cellId Cell Identifier
#ifdef ANSI
PUBLIC Void kwDbmFetchUlCellCb
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteCellId cellId,
-KwUlCellCb **cellCb
+RlcUlCellCb **cellCb
)
#else
PUBLIC Void kwDbmFetchUlCellCb(gCb, cellId, cellCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteCellId cellId;
-KwUlCellCb **cellCb;
+RlcUlCellCb **cellCb;
#endif
{
TRC3(kwDbmFetchUlCellCb)
*
* @details
* This function is invoked by CFG to delete CellCb from the Cell hashlist
- * of KwCb.
+ * of RlcCb.
*
* @param[in] gCb RLC Instance Control Block
* @param[in] cellCb Cell Control Block
#ifdef ANSI
PUBLIC Void kwDbmDelUlCellCb
(
-KwCb *gCb,
-KwUlCellCb *cellCb
+RlcCb *gCb,
+RlcUlCellCb *cellCb
)
#else
PUBLIC Void kwDbmDelUlCellCb(gCb, cellCb)
-KwCb *gCb;
-KwUlCellCb *cellCb;
+RlcCb *gCb;
+RlcUlCellCb *cellCb;
#endif
{
TRC3(kwDbmDelUlCellCb)
"HashList Deletion Failed");
}
/* Deallocate cellCb */
- KW_FREE(gCb, cellCb, sizeof(KwUlCellCb));
+ RLC_FREE(gCb, cellCb, sizeof(RlcUlCellCb));
RETVOID;
} /* kwDbmDelCellCb */
*
* @details
* This function is invoked by CFG to delete all UeCbs from the Ue
- * hashlist of KwCb.
+ * hashlist of RlcCb.
* @param[in] gCb RLC Instance Control Block
*
* @return Void
#ifdef ANSI
PUBLIC Void kwDbmDelAllUlCell
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwDbmDelAllUlCell(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
- KwUlCellCb *cellCb = NULLP; /* Cell Control Block */
+ RlcUlCellCb *cellCb = NULLP; /* Cell Control Block */
TRC3(kwDbmDelAllUlCell)
*
* @details
* This function is invoked by LMM to delete all UeCbs from the Ue
- * hashlist of KwCb and cellCbs from the Cell hashlist of kwCb.
+ * hashlist of RlcCb and cellCbs from the Cell hashlist of rlcCb.
*
* @param[in] gCb RLC Instance Control Block
*
#ifdef ANSI
PUBLIC Void kwDbmUlShutdown
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwDbmUlShutdown(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
TRC3(kwDbmUlShutdown)
#define KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(_gCb, _rbCb) \
((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
(_gCb->u.dlCb->kwL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_UU_LOSS))
-#define KW_UPD_PDCP_L2_DLDELAY_STS(_kwCb, _kwRbCb, _delay) \
+#define KW_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _kwRbCb, _delay) \
{ \
if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_kwCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DELAY)) \
+ ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DELAY)) \
{ \
(_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DELAY]->dlPjSduDelay.sduDelay += _delay; \
(_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DELAY]->dlPjSduDelay.numSdus++; \
} \
}
-#define KW_UPD_L2_UU_LOSS_PKTS(_kwCb, _kwRbCb, _val) \
+#define KW_UPD_L2_UU_LOSS_PKTS(_rlcCb, _kwRbCb, _val) \
{ \
if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_kwCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
+ ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
{ \
(_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_UU_LOSS]->uuLoss.dLoss += _val; \
} \
}
-#define KW_UPD_L2_UU_LOSS_POS_PKTS(_kwCb,_kwRbCb,_val) \
+#define KW_UPD_L2_UU_LOSS_POS_PKTS(_rlcCb,_kwRbCb,_val) \
{ \
if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_kwCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
+ ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
{ \
(_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_UU_LOSS]->uuLoss.posPkts += _val; \
} \
}
/* Discard new changes starts */
-#define KW_UPD_L2_DL_DISC_SDU_STS(_kwCb,_kwRbCb) \
+#define KW_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_kwRbCb) \
{ \
if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_kwCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
+ ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
{ \
(_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DISC]->dlDisc.discSdus++; \
} \
}
-#define KW_UPD_L2_DL_TOT_SDU_STS(_kwCb,_kwRbCb) \
+#define KW_UPD_L2_DL_TOT_SDU_STS(_rlcCb,_kwRbCb) \
{ \
if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_kwCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
+ ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
{ \
(_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DISC]->dlDisc.totSdus++; \
} \
}
-#define KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_kwCb, _kwRbCb) \
+#define KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _kwRbCb) \
{ \
if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_kwCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
+ ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
{ \
U32 idx1; \
for (idx1 = 0; idx1 < LKW_MAX_L2MEAS; idx1++) \
{ \
- if(_kwCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.measType & LKW_L2MEAS_DL_DISC) \
+ if(_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.measType & LKW_L2MEAS_DL_DISC) \
{ \
- if(_kwCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci > 0) \
+ if(_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci > 0) \
{ \
- _kwCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci--; \
- if (_kwCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci == 0) \
+ _rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci--; \
+ if (_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci == 0) \
{ \
- _kwCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.qci[(_kwRbCb)->qci] = 0; \
- cmMemset((U8 *)&_kwCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci], 0, \
- sizeof(_kwCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci])); \
+ _rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.qci[(_kwRbCb)->qci] = 0; \
+ cmMemset((U8 *)&_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci], 0, \
+ sizeof(_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci])); \
} \
} \
} \
} \
}
#else
-#define KW_UPD_PDCP_L2_DLDELAY_STS(_kwCb, _kwRbCb, _delay)
+#define KW_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _kwRbCb, _delay)
#define KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb)
#define KW_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb)
-#define KW_UPD_L2_DL_DISC_SDU_STS(_kwCb,_kwRbCb)
-#define KW_UPD_L2_DL_TOT_SDU_STS(_kwCb, _kwRbCb)
-#define KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_kwCb, _kwRbCb)
+#define KW_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_kwRbCb)
+#define KW_UPD_L2_DL_TOT_SDU_STS(_rlcCb, _kwRbCb)
+#define KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _kwRbCb)
#endif
#include "l2_tenb_stats.x"
#endif
#endif
-typedef struct kwDlUeCb KwDlUeCb;
+typedef struct rlcDlUeCb RlcDlUeCb;
/**
* @brief Structure to hold the SN of the PDU onto which a SDU is mapped
* - KwSduMap :SDU map info for this PDU
*
*/
-typedef struct kwDlPduInfo
+typedef struct rlcDlPduInfo
{
CmLList lstEnt; /*!< List entry for PDU list */
Buffer *pdu; /*!< Buffer of PDU */
KwAmHdr amHdr; /*!< AM header Info */
KwSduMap sduMap; /*!< SDU info for this PDU */
-}KwDlPduInfo;
+}RlcDlPduInfo;
/**
* @brief Structure to hold info about a PDU that has been transmitted
* - rlsLnk : Link list used to free the RbCb
* - cleanupStarted : Whether cleanup of RB is in progress or not
*/
-typedef struct _kwDlRbCb
+typedef struct _rlcDlRbCb
{
U8 qci; /*!< qci of the RB */
#ifdef LTE_L2_MEAS
- KwDlUeCb *ueCb; /*!< Pointer to UeCb */
+ RlcDlUeCb *ueCb; /*!< Pointer to UeCb */
KwL2MeasRbCb rbL2Cb; /*!< RB measurement L2 Cb */
CmLListCp sduSnMapQ; /*!< SDU SN map queue for UM */
Bool cleanupStarted; /*!< Whether cleanup of RB is in progress or not */
U32 lastRprtdBoToMac; /*!< Last Reported BO to MAC Layer */
U32 boUnRprtdCnt; /*!< Count to keep track of periodic BO Update */
-}KwDlRbCb;
+}RlcDlRbCb;
/**
* @brief Structure to hold mapping between logical channel and Radio Bearer
* @details
* - dlRbCb : Pointer to the downlink Radio Bearer
*/
-typedef struct kwDlLch
+typedef struct rlcDlLch
{
- KwDlRbCb *dlRbCb; /*!< Pointer to Downlink RbCb */
-}KwDlLch;
+ RlcDlRbCb *dlRbCb; /*!< Pointer to Downlink RbCb */
+}RlcDlLch;
/**
* @brief Structure to hold information about the Cells
* - rbCb : Radio Bearers in the cell
* - lCh : Logical Channels in the cell
*/
-typedef struct kwDlCellCb
+typedef struct rlcDlCellCb
{
CmHashListEnt cellHlEnt; /*!< Hash list entry for CellCb */
CmLteCellId cellId; /*!< Cell Id */
- KwDlRbCb *rbCb[KW_MAX_RB_PER_CELL]; /*!< RbCbs within a Cell */
- KwDlLch lCh[KW_MAX_LCH_PER_CELL]; /*!< Array of Logical channels */
-}KwDlCellCb;
+ RlcDlRbCb *rbCb[KW_MAX_RB_PER_CELL]; /*!< RbCbs within a Cell */
+ RlcDlLch lCh[KW_MAX_LCH_PER_CELL]; /*!< Array of Logical channels */
+}RlcDlCellCb;
#ifdef LTE_L2_MEAS
/** @struct KwContSduLst
* - drbCb : Data Radio Bearers configured for the UE
* - lCh : Logical Channels in the UE
*/
-struct kwDlUeCb
+struct rlcDlUeCb
{
CmHashListEnt ueHlEnt; /*!< Hash list entry for UeCb */
CmLteRnti ueId; /*!< UE Id */
CmLteCellId cellId; /*!< Cell Id */
- KwDlRbCb *srbCb[KW_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */
- KwDlRbCb *drbCb[KW_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */
- KwDlLch lCh[KW_MAX_LCH_PER_UE]; /*!< Array of Logical channels */
+ RlcDlRbCb *srbCb[KW_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */
+ RlcDlRbCb *drbCb[KW_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */
+ RlcDlLch lCh[KW_MAX_LCH_PER_UE]; /*!< Array of Logical channels */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
U16 numActRb[LKW_MAX_QCI]; /*!< number of RBs Active */
/****************************************************************************
* Configuration Functions
***************************************************************************/
-EXTERN S16 kwCfgAddDlRb ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgAddDlRb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- CkwEntCfgInfo *entCfg,
- CkwEntCfgCfmInfo *entCfm));
+ RlcEntCfgInfo *entCfg,
+ RlcEntCfgCfmInfo *entCfm));
-EXTERN S16 kwCfgReCfgDlRb ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgReCfgDlRb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- CkwEntCfgInfo *entCfg,
- CkwEntCfgCfmInfo *entCfm));
+ RlcEntCfgInfo *entCfg,
+ RlcEntCfgCfmInfo *entCfm));
-EXTERN S16 kwCfgDelDlRb ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgDelDlRb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- CkwEntCfgInfo *entCfg,
- CkwEntCfgCfmInfo *entCfm));
+ RlcEntCfgInfo *entCfg,
+ RlcEntCfgCfmInfo *entCfm));
-EXTERN S16 kwCfgDelDlUe ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgDelDlUe ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- CkwEntCfgInfo *entCfg,
- CkwEntCfgCfmInfo *entCfm));
+ RlcEntCfgInfo *entCfg,
+ RlcEntCfgCfmInfo *entCfm));
-EXTERN S16 kwCfgReEstDlRb ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgReEstDlRb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
Bool sndReEst,
- CkwEntCfgInfo *entCfg,
- CkwEntCfgCfmInfo *entCfm));
+ RlcEntCfgInfo *entCfg,
+ RlcEntCfgCfmInfo *entCfm));
-EXTERN S16 kwCfgDelDlCell ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgDelDlCell ARGS ((RlcCb *gCb,
CmLteCellId cellId,
- CkwEntCfgInfo *entCfg,
- CkwEntCfgCfmInfo *entCfm));
+ RlcEntCfgInfo *entCfg,
+ RlcEntCfgCfmInfo *entCfm));
-EXTERN S16 kwCfgDlUeIdChng ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgDlUeIdChng ARGS ((RlcCb *gCb,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo,
CmStatus *status));
/****************************************************************************
* DBM module Functions
***************************************************************************/
-EXTERN S16 kwDbmDlInit ARGS ((KwCb *gCb));
+EXTERN S16 kwDbmDlInit ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmDlDeInit ARGS ((KwCb *gCb));
+EXTERN Void kwDbmDlDeInit ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmCreateDlUeCb ARGS ((KwCb *gCb,
+EXTERN S16 kwDbmCreateDlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- KwDlUeCb **ueCb));
+ RlcDlUeCb **ueCb));
-EXTERN S16 kwDbmFetchDlUeCb ARGS ((KwCb *gCb,
+EXTERN S16 kwDbmFetchDlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- KwDlUeCb **ueCb));
+ RlcDlUeCb **ueCb));
-EXTERN Void kwDbmDelDlUeCb ARGS ((KwCb *gCb,
- KwDlUeCb *ueCb,
+EXTERN Void kwDbmDelDlUeCb ARGS ((RlcCb *gCb,
+ RlcDlUeCb *ueCb,
Bool abortFlag));
-EXTERN Void kwDbmDelAllDlUe ARGS ((KwCb *gCb));
+EXTERN Void kwDbmDelAllDlUe ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmCreateDlCellCb ARGS ((KwCb *gCb,
+EXTERN S16 kwDbmCreateDlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
- KwDlCellCb **cellCb));
+ RlcDlCellCb **cellCb));
-EXTERN S16 kwDbmFetchDlCellCb ARGS ((KwCb *gCb,
+EXTERN S16 kwDbmFetchDlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
- KwDlCellCb **cellCb));
+ RlcDlCellCb **cellCb));
-EXTERN Void kwDbmDelDlCellCb ARGS ((KwCb *gCb, KwDlCellCb *cellCb));
+EXTERN Void kwDbmDelDlCellCb ARGS ((RlcCb *gCb, RlcDlCellCb *cellCb));
-EXTERN Void kwDbmDelAllDlCell ARGS ((KwCb *gCb));
+EXTERN Void kwDbmDelAllDlCell ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmFetchDlRbCbByRbId ARGS ((KwCb *gCb,
+EXTERN Void kwDbmFetchDlRbCbByRbId ARGS ((RlcCb *gCb,
CmLteRlcId *rlcId,
- KwDlRbCb **rbCb));
+ RlcDlRbCb **rbCb));
-EXTERN Void kwDbmFetchDlRbCbFromLchId ARGS ((KwCb *gCb,
+EXTERN Void kwDbmFetchDlRbCbFromLchId ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
CmLteLcId lcId,
- KwDlRbCb **rbCb));
+ RlcDlRbCb **rbCb));
-EXTERN Void kwDbmDelAllDlRb ARGS ((KwCb *gCb, KwDlRbCb **rbCbLst, U8 numRbCb));
+EXTERN Void kwDbmDelAllDlRb ARGS ((RlcCb *gCb, RlcDlRbCb **rbCbLst, U8 numRbCb));
-EXTERN S16 kwDbmDlShutdown ARGS ((KwCb *gCb));
+EXTERN S16 kwDbmDlShutdown ARGS ((RlcCb *gCb));
EXTERN Void kwUtlGetCurrTime ARGS((U32 *time));
-EXTERN PUBLIC Void kwUtlTrigPdbFlowCntrl ARGS((KwCb *gCb, KwDlRbCb *rbCb, U32 pktAdmitCnt ));
+EXTERN PUBLIC Void kwUtlTrigPdbFlowCntrl ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 pktAdmitCnt ));
#ifdef LTE_L2_MEAS
-EXTERN Void kwDbmDelAllDlL2MeasTbFrmUe ARGS ((KwCb *gCb, KwDlUeCb *ueCb));
+EXTERN Void kwDbmDelAllDlL2MeasTbFrmUe ARGS ((RlcCb *gCb, RlcDlUeCb *ueCb));
#endif
/****************************************************************************
* Transparent Mode Functions
***************************************************************************/
-EXTERN Void kwTmmQSdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+EXTERN Void kwTmmQSdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwuDatReqInfo *datReqInfo,
Buffer *mBuf));
-EXTERN Void kwTmmSndToLi ARGS ((KwCb *gCb,
+EXTERN Void kwTmmSndToLi ARGS ((RlcCb *gCb,
SuId suId,
- KwDlRbCb *rbCb,
+ RlcDlRbCb *rbCb,
RguCStaIndInfo *staInd));
-EXTERN Void kwDlTmmReEstablish ARGS ((KwCb *gCb, KwDlRbCb *rbCb));
+EXTERN Void rlcDlTmmReEstablish ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
/****************************************************************************
* Unacknowledged Mode Functions
***************************************************************************/
-EXTERN Void kwUmmQSdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+EXTERN Void kwUmmQSdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwuDatReqInfo *datReq,
Buffer *mBuf));
-EXTERN Void kwUmmDiscSdu ARGS ((KwCb *gCb, KwDlRbCb *rbCb, U32 sduId));
+EXTERN Void kwUmmDiscSdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
-EXTERN Void kwDlUmmReEstablish ARGS ((KwCb *gCb,
+EXTERN Void rlcDlUmmReEstablish ARGS ((RlcCb *gCb,
CmLteRlcId rlcId,
Bool sndReEst,
- KwDlRbCb *rbCb));
+ RlcDlRbCb *rbCb));
-EXTERN Void kwUmmProcessSdus ARGS ((KwCb *gCb,KwDlRbCb *rbCb,KwDatReq *datReq));
+EXTERN Void kwUmmProcessSdus ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb,KwDatReq *datReq));
-EXTERN Void kwUmmFreeDlRbCb ARGS ((KwCb *gCb, KwDlRbCb *rbCb));
+EXTERN Void kwUmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
/****************************************************************************
* Acknowledged Mode Functions
EXTERN S32 kwAmmCalculateBo ARGS ((KwAmDl *amDl));
-EXTERN Void kwAmmSendDStaRsp ARGS ((KwCb *gCb, KwDlRbCb *rbCb, KwAmDl *amDl));
+EXTERN Void kwAmmSendDStaRsp ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, KwAmDl *amDl));
-EXTERN Void kwAmmQSdu ARGS((KwCb *gCb,
- KwDlRbCb *rbCb,
+EXTERN Void kwAmmQSdu ARGS((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
Buffer *mBuf,
KwuDatReqInfo *datReq));
-EXTERN Void kwAmmProcessSdus ARGS((KwCb *gCb,
- KwDlRbCb *rbCb,
+EXTERN Void kwAmmProcessSdus ARGS((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwDatReq *kwDatReq,
Bool staPduPres));
-EXTERN Void kwAmmDlReEstablish ARGS((KwCb *gCb,
+EXTERN Void kwAmmDlReEstablish ARGS((RlcCb *gCb,
CmLteRlcId rlcId,
- KwDlRbCb *rbCb));
+ RlcDlRbCb *rbCb));
-EXTERN Void kwAmmDlHndlStatusPdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+EXTERN Void kwAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
KwUdxStaPdu *pStaPdu));
-EXTERN S16 kwAmmDiscSdu ARGS((KwCb *gCb, KwDlRbCb *rbCb, U32 sduId));
+EXTERN S16 kwAmmDiscSdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
-EXTERN Void kwAmmPollRetxTmrExp ARGS((KwCb *gCB, KwDlRbCb *rbCb));
+EXTERN Void kwAmmPollRetxTmrExp ARGS((RlcCb *gCB, RlcDlRbCb *rbCb));
-EXTERN Void kwAmmFreeDlRbCb ARGS ((KwCb *gCb, KwDlRbCb *rbCb));
+EXTERN Void kwAmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
/****************************************************************************
* Utility Functions
));
EXTERN Void kwUtlDelTxBuf ARGS ((CmLListCp *txBufLst,
KwTx *txBuf,
- KwCb *gCb
+ RlcCb *gCb
));
EXTERN Void kwUtlRemovTxBuf ARGS ((CmLListCp *txBufLst,
KwTx *txBuf,
- KwCb *gCb
+ RlcCb *gCb
));
-EXTERN S16 kwUtlSndDStaRsp ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+EXTERN S16 kwUtlSndDStaRsp ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
S32 bo,
S32 estHdrSz,
Bool staPduPrsnt,
U32 staPduBo));
#ifdef LTE_L2_MEAS_RLC
-EXTERN Void kwUtlEmptySduQ ARGS ((KwCb *gCb, KwDlRbCb *rbCb, CmLListCp *sduQ));
+EXTERN Void kwUtlEmptySduQ ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, CmLListCp *sduQ));
#else /* LTE_L2_MEAS */
-EXTERN Void kwUtlEmptySduQ ARGS ((KwCb *gCb,CmLListCp *sduQ));
+EXTERN Void kwUtlEmptySduQ ARGS ((RlcCb *gCb,CmLListCp *sduQ));
#endif /* LTE_L2_MEAS */
-EXTERN Void kwUtlCalcLiForSdu ARGS ((KwCb *gCb,
+EXTERN Void kwUtlCalcLiForSdu ARGS ((RlcCb *gCb,
U16 numLi,
MsgLen msgLen,
S16 *pduSz));
-EXTERN S16 kwUtlSndToLi ARGS ((KwCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo));
+EXTERN S16 kwUtlSndToLi ARGS ((RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo));
EXTERN Void kwUtlIncrementKwuStsSduTx ARGS((KwKwuSapCb *kwuSap));
EXTERN Void kwUtlIncrementGenStsBytesAndPdusSent ARGS((KwGenSts *genSts,
Buffer *pdu));
-EXTERN Void kwUtlFreeDlMemory ARGS ((KwCb *gCb));
+EXTERN Void kwUtlFreeDlMemory ARGS ((RlcCb *gCb));
-EXTERN Void kwUtlInitToBeFreed ARGS ((KwCb *gCb, KwDlDataToBeFreed *toBeFreed));
+EXTERN Void kwUtlInitToBeFreed ARGS ((RlcCb *gCb, RlcDlDataToBeFreed *toBeFreed));
-EXTERN Void kwUtlInitializeSelfPst ARGS((KwCb *gCb));
+EXTERN Void kwUtlInitializeSelfPst ARGS((RlcCb *gCb));
-EXTERN Void kwUtlRaiseDlCleanupEvent ARGS((KwCb *gCb));
+EXTERN Void kwUtlRaiseDlCleanupEvent ARGS((RlcCb *gCb));
-EXTERN Void kwUtlAddSduToBeFreedQueue ARGS((KwCb *gCb, KwSdu *sdu));
+EXTERN Void kwUtlAddSduToBeFreedQueue ARGS((RlcCb *gCb, KwSdu *sdu));
-EXTERN Void kwUtlAddReTxPduToBeFreedQueue ARGS((KwCb *gCb, KwRetx *retx));
+EXTERN Void kwUtlAddReTxPduToBeFreedQueue ARGS((RlcCb *gCb, KwRetx *retx));
-EXTERN Void kwUtlAddTxPduToBeFreedQueue ARGS((KwCb *gCb, KwTx *pdu));
+EXTERN Void kwUtlAddTxPduToBeFreedQueue ARGS((RlcCb *gCb, KwTx *pdu));
#ifdef LTE_L2_MEAS
-EXTERN S16 kwUtlL2MeasDlInit ARGS((KwCb *gCb));
+EXTERN S16 kwUtlL2MeasDlInit ARGS((RlcCb *gCb));
#endif
/****************************************************************************
/****************************************************************************
* Activation Functions
***************************************************************************/
-EXTERN S16 kwDlActvInit ARGS ((Ent ent,Inst inst,Region region,Reason reason));
+EXTERN S16 rlcDlActvInit ARGS ((Ent ent,Inst inst,Region region,Reason reason));
-EXTERN S16 kwDlActvTsk ARGS ((Pst *pst, Buffer *mBuf));
+EXTERN S16 rlcDlActvTsk ARGS ((Pst *pst, Buffer *mBuf));
-EXTERN Bool kwDlUtlIsReestInProgress ARGS ((KwDlRbCb *rbCb));
+EXTERN Bool rlcDlUtlIsReestInProgress ARGS ((RlcDlRbCb *rbCb));
-EXTERN Void kwDlUtlResetReestInProgress ARGS ((KwDlRbCb *rbCb));
+EXTERN Void rlcDlUtlResetReestInProgress ARGS ((RlcDlRbCb *rbCb));
-EXTERN Void kwDlUtlResetReestInProgress ARGS (( KwDlRbCb *rbCb));
+EXTERN Void rlcDlUtlResetReestInProgress ARGS (( RlcDlRbCb *rbCb));
-EXTERN Void kwDlUtlSetReestInProgressForAllRBs ARGS ((KwCb *gCb, KwDlUeCb
+EXTERN Void rlcDlUtlSetReestInProgressForAllRBs ARGS ((RlcCb *gCb, RlcDlUeCb
*ueCb));
-EXTERN Void kwDlUtlSetReestInProgressForRB ARGS (( KwCb *gCb, KwDlRbCb *rbCb));
+EXTERN Void rlcDlUtlSetReestInProgressForRB ARGS (( RlcCb *gCb, RlcDlRbCb *rbCb));
#ifdef LTE_L2_MEAS
EXTERN Void kwUtlUpdateContainedSduLst ARGS ((
Bool newIdx
));
EXTERN Void kwUtlUpdateBurstSdus ARGS((
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwContSduLst *contSduLst,
S32 dataVol,
U32 schPduSz
));
EXTERN KwL2MeasTb * kwUtlGetCurMeasTb ARGS((
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
));
-EXTERN S16 kwUtlSndDlL2MeasNCfm ARGS((KwCb *gCb,
+EXTERN S16 kwUtlSndDlL2MeasNCfm ARGS((RlcCb *gCb,
KwL2MeasReqEvt *measReqEvt,
KwL2MeasCfmEvt *measCfmEvt));
-EXTERN S16 kwUtlSndDlL2MeasCfm ARGS ((KwCb *gCb, KwL2MeasEvtCb *measEvtCb));
+EXTERN S16 kwUtlSndDlL2MeasCfm ARGS ((RlcCb *gCb, KwL2MeasEvtCb *measEvtCb));
-EXTERN S16 kwUtlProcHarqInd ARGS (( KwCb *gCb, RguHarqStatusInd *staInd, KwDlUeCb *ueCb,
+EXTERN S16 kwUtlProcHarqInd ARGS (( RlcCb *gCb, RguHarqStatusInd *staInd, RlcDlUeCb *ueCb,
U8 tbIdx));
-EXTERN Void kwUtlResetDlL2MeasInKwRb ARGS ((KwCb *gCb,
+EXTERN Void kwUtlResetDlL2MeasInKwRb ARGS ((RlcCb *gCb,
KwL2MeasCb *measCb,
U8 measType));
#include "ctf.h"
PUBLIC S16 kwUtlDlBatchProcPkts(Void);
-PUBLIC S16 kwDlBatchProc(Void);
+PUBLIC S16 rlcDlBatchProc(Void);
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
U32 isDatReqProcessed;
PUBLIC void kwUtlDlBatchProcHqStaInd ARGS ((Void));
#endif
#if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
-EXTERN S16 kwDlBatchProcSplit ARGS((Void));
+EXTERN S16 rlcDlBatchProcSplit ARGS((Void));
#endif
//UDAY
#ifdef L2_OPTMZ
U32 kwAmmStaPduList[512] = {0};
EXTERN S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
#endif
-PUBLIC S16 kwDlInitExt ARGS (( Void ));
+PUBLIC S16 rlcDlInitExt ARGS (( Void ));
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwDlInitExt
+PUBLIC S16 rlcDlInitExt
(
)
#else
-PUBLIC S16 kwDlInitExt()
+PUBLIC S16 rlcDlInitExt()
#endif
{
- TRC2(kwDlInitExt);
+ TRC2(rlcDlInitExt);
RETVALUE(ROK);
} /* kwInitExt */
*
*/
#ifdef ANSI
-PUBLIC S16 kwDlActvInit
+PUBLIC S16 rlcDlActvInit
(
Ent ent, /* entity */
Inst inst, /* instance */
Reason reason /* reason */
)
#else
-PUBLIC S16 kwDlActvInit(ent, inst, region, reason)
+PUBLIC S16 rlcDlActvInit(ent, inst, region, reason)
Ent ent; /* entity */
Inst inst; /* instance */
Region region; /* region */
Reason reason; /* reason */
#endif
{
- KwCb *tKwCb;
- TRC3(kwDlActvInit)
+ RlcCb *tRlcCb;
+ TRC3(rlcDlActvInit)
- if (inst >= KW_MAX_RLC_INSTANCES)
+ if (inst >= MAX_RLC_INSTANCES)
{
/* intance greater than MAX instances */
RETVALUE(RFAILED);
}
- if (kwCb[inst] != NULLP)
+ if (rlcCb[inst] != NULLP)
{
RETVALUE (RFAILED);
}
- if (SGetSBuf(region, 0, (Data **)&tKwCb,
- (Size)sizeof (KwCb)) != ROK)
+ if (SGetSBuf(region, 0, (Data **)&tRlcCb,
+ (Size)sizeof (RlcCb)) != ROK)
{
RETVALUE(RFAILED);
}
- /* Initialize kwCb */
- KW_MEM_SET(tKwCb, 0, sizeof(KwCb));
+ /* Initialize rlcCb */
+ RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
/* Initialize task configuration parameters */
- tKwCb->init.ent = ent; /* entity */
- tKwCb->init.inst = inst; /* instance */
- tKwCb->init.region = region; /* static region */
- tKwCb->init.pool = 0; /* static pool */
- tKwCb->init.reason = reason; /* reason */
- tKwCb->init.cfgDone = FALSE; /* configuration done */
- tKwCb->init.acnt = TRUE; /* enable accounting */
- tKwCb->init.usta = TRUE; /* enable unsolicited status */
- tKwCb->init.trc = FALSE; /* enable trace */
- tKwCb->init.procId = SFndProcId();
-
- kwCb[inst] = tKwCb;
+ tRlcCb->init.ent = ent; /* entity */
+ tRlcCb->init.inst = inst; /* instance */
+ tRlcCb->init.region = region; /* static region */
+ tRlcCb->init.pool = 0; /* static pool */
+ tRlcCb->init.reason = reason; /* reason */
+ tRlcCb->init.cfgDone = FALSE; /* configuration done */
+ tRlcCb->init.acnt = TRUE; /* enable accounting */
+ tRlcCb->init.usta = TRUE; /* enable unsolicited status */
+ tRlcCb->init.trc = FALSE; /* enable trace */
+ tRlcCb->init.procId = SFndProcId();
+
+ rlcCb[inst] = tRlcCb;
//UDAY
#ifdef L2_OPTMZ
pthread_t gRlcTId = 0;
#endif
#ifdef ANSI
-PUBLIC S16 kwDlActvTsk
+PUBLIC S16 rlcDlActvTsk
(
Pst *pst, /* pst structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 kwDlActvTsk(pst, mBuf)
+PUBLIC S16 rlcDlActvTsk(pst, mBuf)
Pst *pst; /* pst structure */
Buffer *mBuf; /* message buffer */
#endif
{
S16 ret = ROK;
- TRC3(kwDlActvTsk);
+ TRC3(rlcDlActvTsk);
#ifdef RLC_FREE_RING_BUF
gRlcTId = pthread_self();
#endif
#ifdef LCLKW
case LKW_EVT_CFG_REQ:
{
- ret = cmUnpkLkwCfgReq(KwMiLkwCfgReq, pst, mBuf);
+ ret = unpackRlcConfigReq(KwMiRlcConfigReq, pst, mBuf);
break;
}
#endif /* LCKWU */
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from SM",
pst->event);
#ifdef LCUDX
case UDX_EVT_BND_REQ: /* Bind request */
{
- ret = cmUnpkUdxBndReq(KwDlUdxBndReq, pst, mBuf );
+ ret = cmUnpkUdxBndReq(rlcDlUdxBndReq, pst, mBuf );
break;
}
case UDX_EVT_UBND_REQ: /* Bind request */
{
- ret = cmUnpkUdxUbndReq(KwDlUdxUbndReq, pst, mBuf );
+ ret = cmUnpkUdxUbndReq(rlcDlUdxUbndReq, pst, mBuf );
break;
}
case UDX_EVT_CFG_REQ: /* Unbind request */
{
- ret = cmUnpkUdxCfgReq(KwDlUdxCfgReq, pst, mBuf );
+ ret = cmUnpkUdxCfgReq(rlcDlUdxCfgReq, pst, mBuf );
break;
}
case UDX_EVT_UEIDCHG_REQ: /* Configuration request */
{
- ret = cmUnpkUdxUeIdChgReq(KwDlUdxUeIdChgReq, pst, mBuf);
+ ret = cmUnpkUdxUeIdChgReq(rlcDlUdxUeIdChgReq, pst, mBuf);
break;
}
case UDX_EVT_STA_UPD_REQ: /* Configuration request */
{
- ret = cmUnpkUdxStaUpdReq(KwDlUdxStaUpdReq, pst, mBuf);
+ ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
break;
}
case UDX_EVT_STA_PDU_REQ: /* Configuration request */
{
- ret = cmUnpkUdxStaPduReq(KwDlUdxStaPduReq, pst, mBuf);
+ ret = cmUnpkUdxStaPduReq(rlcDlUdxStaPduReq, pst, mBuf);
break;
}
#ifdef LTE_L2_MEAS
case UDX_EVT_L2MEAS_REQ:
{
- ret = cmUnpkUdxL2MeasReq(KwDlUdxL2MeasReq, pst, mBuf);
+ ret = cmUnpkUdxL2MeasReq(rlcDlUdxL2MeasReq, pst, mBuf);
break;
}
case UDX_EVT_L2MEAS_SEND_REQ:
{
- ret = cmUnpkUdxL2MeasSendReq(KwDlUdxL2MeasSendReq, pst, mBuf);
+ ret = cmUnpkUdxL2MeasSendReq(rlcDlUdxL2MeasSendReq, pst, mBuf);
break;
}
case UDX_EVT_L2MEAS_STOP_REQ:
{
- ret = cmUnpkUdxL2MeasStopReq(KwDlUdxL2MeasStopReq, pst, mBuf);
+ ret = cmUnpkUdxL2MeasStopReq(rlcDlUdxL2MeasStopReq, pst, mBuf);
break;
}
#endif
#endif /* LCCKW */
case UDX_EVT_DL_CLEANUP_MEM:
{
- kwUtlFreeDlMemory(KW_GET_KWCB(pst->dstInst));
+ kwUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
break;
}
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
pst->event);
#endif /* LCKWU */
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
pst->event);
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
pst->event);
#ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
case UDX_EVT_STA_UPD_REQ: /* Configuration request */
{
- ret = cmUnpkUdxStaUpdReq(KwDlUdxStaUpdReq, pst, mBuf);
+ ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
break;
}
#endif
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
pst->event);
case KWU_EVT_TTI_IND:
{
#if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
- kwDlBatchProcSplit();
+ rlcDlBatchProcSplit();
#else
#if defined(PDCP_RLC_DL_RBUF)
- kwDlBatchProc();
+ rlcDlBatchProc();
#endif
#endif
#if (defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
- //KwDlHarqStaBatchProc();
+ //RlcDlHarqStaBatchProc();
kwUtlDlBatchProcHqStaInd();
#endif
#ifndef KWSELFPSTDLCLEAN
default:
{
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
- /*KwCb *tKwCb = KW_GET_KWCB(pst->dstInst);*/
+ /*RlcCb *tRlcCb = RLC_GET_RLCCB(pst->dstInst);*/
RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",
pst->event);
}
#ifndef __KWENVH__
#define __KWENVH__
-#define KW_MAX_RLC_INSTANCES 2
+#define MAX_RLC_INSTANCES 2
#define KW_MAX_LI KWU_MAX_STA_IND_SDU
#define KW_MAX_DL_LI 28
S16 _ret; \
_ret = RFAILED; \
_kwuSap = NULLP; \
- if((_spId < (S16) kwCb.genCfg.maxKwuSaps) && (_spId >= 0)) \
+ if((_spId < (S16) rlcCb.genCfg.maxKwuSaps) && (_spId >= 0)) \
{ \
- _kwuSap = kwCb.kwuSap + _spId; \
+ _kwuSap = rlcCb.kwuSap + _spId; \
if((_kwuSap != NULLP) && (_kwuSap->state == KW_SAP_BND)) \
{ \
_ret = ROK; \
}
#else
#define KW_GET_AND_VALIDATE_KWUSAP(_spId, _kwuSap, _errCode, _fn) \
- _kwuSap = kwCb.kwuSap + _spId;
+ _kwuSap = rlcCb.kwuSap + _spId;
#define KWLOGERROR(cb, errCls, errCode, errVal, errDesc)
#endif
U16 event; /* Event */
U16 cause; /* Cause */
KwRguSapCb *rguSap; /* RGU SAP Control Block */
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwLiRguBndCfm)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
RLOG2(L_DEBUG,"KwLiRguBndCfm(suId(%d), status(%d)", suId, status);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (tKwCb->init.cfgDone != TRUE)
+ if (tRlcCb->init.cfgDone != TRUE)
{
RLOG0(L_FATAL,"General configuration not done");
- KW_SEND_SAPID_ALARM(tKwCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
+ KW_SEND_SAPID_ALARM(tRlcCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
RETVALUE(RFAILED);
}
- if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0))
+ if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
{
RLOG0(L_ERROR, "Invalid suId");
- KW_SEND_SAPID_ALARM(tKwCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
+ KW_SEND_SAPID_ALARM(tRlcCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
RETVALUE(RFAILED);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- rguSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
- &(tKwCb->u.dlCb->rguDlSap[suId]) : &(tKwCb->u.ulCb->rguUlSap[suId]);
+ rguSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
+ &(tRlcCb->u.dlCb->rguDlSap[suId]) : &(tRlcCb->u.ulCb->rguUlSap[suId]);
RLOG1(L_DEBUG, "KwLiRguBndCfm: For RGU SAP state=%d", rguSap->state)
{
case KW_SAP_BINDING:
{
- kwStopTmr (tKwCb,(PTR)rguSap, KW_EVT_WAIT_BNDCFM);
+ kwStopTmr (tRlcCb,(PTR)rguSap, KW_EVT_WAIT_BNDCFM);
rguSap->retryCnt = 0;
}
/* Send an alarm with proper event and cause */
- KW_SEND_SAPID_ALARM(tKwCb, suId, event, cause);
+ KW_SEND_SAPID_ALARM(tRlcCb, suId, event, cause);
RETVALUE(ROK);
} /* KwLiRguBndCfm */
{
if(ulData->pduInfo[idx].commCh)
{
- KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchUlDat, sizeof(RguCDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchUlDat, sizeof(RguCDatIndInfo));
cmMemset((U8*)cLchUlDat, (U8)0, sizeof(RguCDatIndInfo));
cLchUlDat->cellId = ulData->cellId;
{
if(!dLchPduPres)
{
- KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchUlDat, sizeof(RguDDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchUlDat, sizeof(RguDDatIndInfo));
dLchPduPres = TRUE;
}
}
- KW_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcMacData));
+ RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcMacData));
RETVALUE(ROK);
}/* End of RlcMacProcUlData */
RguCDatIndInfo *datInd;
#endif
{
- KwUlRbCb *rbCb;
- KwCb *tKwCb;
+ RlcUlRbCb *rbCb;
+ RlcCb *tRlcCb;
rlcCDatIndRcvd++;
TRC3(KwLiRguCDatInd)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#if (ERRCLASS & ERRCLS_DEBUG)
- if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
+ if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
RETVALUE(RFAILED);
}
#endif
{
RLOG_ARG1(L_ERROR,DBG_LCID,datInd->lcId, "Invalid LcId, Max is [%d]",
KW_MAX_LCH_PER_CELL);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
RETVALUE(RFAILED);
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
/* Fetch RbCb from lcId */
- kwDbmFetchUlRbCbFromLchId(tKwCb, 0, datInd->cellId, datInd->lcId, &rbCb);
+ kwDbmFetchUlRbCbFromLchId(tRlcCb, 0, datInd->cellId, datInd->lcId, &rbCb);
if (!rbCb)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,datInd->cellId, "LcId [%d] not found",
datInd->lcId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
RETVALUE(RFAILED);
}
/* Dispatch to TM Module */
#ifdef CCPU_OPT
- kwTmmRcvFrmLi(tKwCb, rbCb, datInd->rnti, datInd->pdu);
+ kwTmmRcvFrmLi(tRlcCb, rbCb, datInd->rnti, datInd->pdu);
#else /* CCPU_OPT */
- kwTmmRcvFrmLi(tKwCb, rbCb, datInd->pdu);
+ kwTmmRcvFrmLi(tRlcCb, rbCb, datInd->pdu);
#endif /* CCPU_OPT */
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
RETVALUE(ROK);
} /* KwLiRguCDatInd */
rlcDDatIndRcvd++;
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
RETVALUE (RFAILED);
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
- if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL)
+ if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
RLOG1(L_DEBUG,"KwLiRguDDatInd(pst, suId(%d))recieved in DL Inst",suId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
RETVALUE(RFAILED);
}
#endif
- kwUtlRcvFrmLi(KW_GET_KWCB(pst->dstInst),datInd);
+ kwUtlRcvFrmLi(RLC_GET_RLCCB(pst->dstInst),datInd);
#ifndef SS_RBUF
#ifdef SS_LOCKLESS_MEMORY
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
#else
- KW_PST_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
+ RLC_PST_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
#endif
#endif
* and trigger the handler for each common lch separately */
if(schRep->lchSta[idx].commCh)
{
- KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchSchInfo, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchSchInfo, sizeof(RguCStaIndInfo));
cmMemset((U8*)cLchSchInfo, (U8)0, sizeof(RguCStaIndInfo));
cLchSchInfo->cellId = schRep->cellId;
* scheduling report is received */
if(nmbDLch == 0)
{
- KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchSchInfo, sizeof(RguDStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchSchInfo, sizeof(RguDStaIndInfo));
dLchSchInfo->cellId = schRep->cellId;
dLchSchInfo->nmbOfUeGrantPerTti = 1;
KwLiRguDStaInd(pst, suId, dLchSchInfo);
}
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRepInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRepInfo));
RETVALUE(ROK);
}
RguCStaIndInfo *staInd;
#endif
{
- KwDlRbCb *rbCb;
- KwCb *tKwCb;
+ RlcDlRbCb *rbCb;
+ RlcCb *tRlcCb;
TRC3(KwLiRguCStaInd)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0))
+ if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
{
- KWLOGERROR(tKwCb,
+ KWLOGERROR(tRlcCb,
ERRCLS_INT_PAR,
EKW040,
(ErrVal) suId,
"KwLiRguCStaInd: Invalid RGU suId\n");
RETVALUE(RFAILED);
}
- if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
+ if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
RLOG_ARG1(L_ERROR,DBG_LCID,staInd->lcId,
"Received in RLC UL CELLID:%d",
staInd->cellId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
RETVALUE(RFAILED);
}
#endif
"Invalid LcId, Max is [%d] CELLID:%d",
KW_MAX_LCH_PER_CELL,
staInd->cellId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
RETVALUE(RFAILED);
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
/* Fertch RbCb from lcId */
- kwDbmFetchDlRbCbFromLchId(tKwCb,0, staInd->cellId, staInd->lcId, &rbCb);
+ kwDbmFetchDlRbCbFromLchId(tRlcCb,0, staInd->cellId, staInd->lcId, &rbCb);
if(!rbCb)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,staInd->cellId,
"LcId [%d] not found CELLID:%d",
staInd->lcId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
RETVALUE(RFAILED);
}
rbCb->transId = staInd->transId;
/* ccpu00136940 */
/* If trace flag is enabled send the trace indication */
- if(tKwCb->init.trc == TRUE)
+ if(tRlcCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(tKwCb,EVTRGUCSTAIND, NULLP);
+ kwLmmSendTrc(tRlcCb,EVTRGUCSTAIND, NULLP);
}
- kwTmmSndToLi(tKwCb, suId, rbCb, staInd);
+ kwTmmSndToLi(tRlcCb, suId, rbCb, staInd);
#ifndef SS_RBUF
#ifdef SS_LOCKLESS_MEMORY
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
#else
- KW_PST_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_PST_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
#endif
#else
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
#endif
RETVALUE(ROK);
} /* KwLiRguCStaInd */
RguDStaIndInfo *staInd;
#endif
{
- KwCb *gCb;
+ RlcCb *gCb;
TRC3(KwLiRguDStaInd)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
RETVALUE (RFAILED);
}
#endif
- gCb = KW_GET_KWCB(pst->dstInst);
+ gCb = RLC_GET_RLCCB(pst->dstInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL)
+ if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"Received in RLC UL ");
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
RETVALUE(RFAILED);
}
if ((suId >= gCb->genCfg.maxRguSaps) || (suId < 0))
kwUtlSndToLi(gCb, suId, staInd);
/* kw002.201 :Freeing from proper region */
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
RETVALUE(ROK);
} /* KwLiRguDStaInd */
RguFlowCntrlInd *flowCntrlInd;
#endif
{
- KwCb *tKwCb;
- KwDlRbCb *rbCb = NULLP;
+ RlcCb *tRlcCb;
+ RlcDlRbCb *rbCb = NULLP;
U32 idx;
U32 lcIdx;
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
for (idx = 0; idx < flowCntrlInd->numUes; idx++)
{
for (lcIdx = 0; lcIdx < flowCntrlInd->ueFlowCntrlInfo[idx].numLcs; lcIdx++)
{
RguLcFlowCntrlInfo *lcInfo = &(flowCntrlInd->ueFlowCntrlInfo[idx].lcInfo[lcIdx]);
- kwDbmFetchDlRbCbFromLchId(tKwCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb);
+ kwDbmFetchDlRbCbFromLchId(tRlcCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb);
if (rbCb)
{
if (lcInfo->pktAdmitCnt == 0) /* Special case */
{
- kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt);
+ kwUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
continue;
}
if (rbCb->mode == CM_LTE_MODE_AM)
continue;
}
}
- kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt);
+ kwUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
}
}
}
KwUeKey ueKey;
S16 ret;
- KwDlUeCb *ueCb;
+ RlcDlUeCb *ueCb;
U8 tbIdx;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwLiRguHqStaInd)
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
ueKey.cellId = staInd->cellId;
ueKey.ueId = staInd->ueId;
- ret = kwDbmFetchDlUeCb(tKwCb, ueKey.ueId, ueKey.cellId, &ueCb);
+ ret = kwDbmFetchDlUeCb(tRlcCb, ueKey.ueId, ueKey.cellId, &ueCb);
if (ret != ROK )
{
RETVALUE(RFAILED);
/*Call kwUtlProcHarqInd as many times as number of Tbs present*/
for ( tbIdx = 0; tbIdx < staInd->numTbs; tbIdx++)
{
- kwUtlProcHarqInd(tKwCb, staInd, ueCb, tbIdx);
+ kwUtlProcHarqInd(tRlcCb, staInd, ueCb, tbIdx);
}
RETVALUE(ROK);
Desc: It contains the following common functions for processing
the all the external interfaces.
- -- KwMiLkwCfgReq
- -- KwMiLkwCfgCfm
+ -- KwMiRlcConfigReq
+ -- KwMiRlcConfigCfm
-- KwMiLkwCntrlReq
-- KwMiLkwCntrlCfm
-- KwMiLkwStaReq
/*********************************************************************
* Forward Declaration of LKW Porting Functions
********************************************************************/
-PUBLIC KwCb *kwCb[KW_MAX_RLC_INSTANCES];
+PUBLIC RlcCb *rlcCb[MAX_RLC_INSTANCES];
EXTERN S16 kwActvTmr ARGS ((Ent ent, Inst inst));
-PRIVATE Void kwLmmSendCfm ARGS ((KwCb *gCb,Pst *pst,KwMngmt *cfm,U8 type,
+PRIVATE Void kwLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,KwMngmt *cfm,U8 type,
Header *hdr));
-PRIVATE S16 kwLmmGenCfg ARGS ((KwCb *gCb, KwGenCfg *cfg));
-PRIVATE S16 kwLmmCfgKwuSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmCfgUdxSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmCfgCkwSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmCfgRguSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmGenCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
-PRIVATE S16 kwLmmUdxSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
-PRIVATE S16 kwLmmLSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
-PRIVATE S16 kwLmmGetKwuSapSta ARGS ((KwCb *gCb,KwKwuSapSta *sta));
-PRIVATE S16 kwLmmGetRguSapSta ARGS ((KwCb *gCb,KwRguSapSta *sta));
-PRIVATE S16 kwLmmGetCkwCntSapSta ARGS ((KwCb *gCb,KwCkwCntSapSta *sta));
-PRIVATE S16 kwLmmGetGenSts ARGS ((KwCb *gCb,KwGenSts *sts,Action action));
-PRIVATE S16 kwLmmGetSapSts ARGS ((KwCb *gCb,KwMngmt *sts,Elmnt elmnt,Action
+PRIVATE S16 kwLmmGenCfg ARGS ((RlcCb *gCb, KwGenCfg *cfg));
+PRIVATE S16 kwLmmCfgKwuSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
+PRIVATE S16 kwLmmCfgUdxSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
+PRIVATE S16 kwLmmCfgCkwSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
+PRIVATE S16 kwLmmCfgRguSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
+PRIVATE S16 kwLmmGenCntrl ARGS ((RlcCb *gCb,KwMngmt *cntrl));
+PRIVATE S16 kwLmmUdxSapCntrl ARGS ((RlcCb *gCb,KwMngmt *cntrl));
+PRIVATE S16 kwLmmLSapCntrl ARGS ((RlcCb *gCb,KwMngmt *cntrl));
+PRIVATE S16 kwLmmGetKwuSapSta ARGS ((RlcCb *gCb,KwKwuSapSta *sta));
+PRIVATE S16 kwLmmGetRguSapSta ARGS ((RlcCb *gCb,KwRguSapSta *sta));
+PRIVATE S16 kwLmmGetCkwCntSapSta ARGS ((RlcCb *gCb,KwCkwCntSapSta *sta));
+PRIVATE S16 kwLmmGetGenSts ARGS ((RlcCb *gCb,KwGenSts *sts,Action action));
+PRIVATE S16 kwLmmGetSapSts ARGS ((RlcCb *gCb,KwMngmt *sts,Elmnt elmnt,Action
action));
\f
#ifdef ANSI
PRIVATE S16 kwLmmGenCfg
(
-KwCb *gCb,
+RlcCb *gCb,
KwGenCfg *cfg
)
#else
PRIVATE S16 kwLmmGenCfg(gCB,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwGenCfg *cfg;
#endif
{
if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- KW_ALLOC(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_ALLOC(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
if (gCb->u.dlCb == NULLP)
{
RLOG0(L_FATAL,"Memory Allocation failed");
kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
(Size)sizeof(KwKwuSapCb));
- KW_ALLOC(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_ALLOC(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.dlCb->kwuDlSap == NULLP)
{
- KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
RETVALUE(LCM_REASON_MEM_NOAVAIL);
}
kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
(Size)sizeof(KwUdxDlSapCb));
- KW_ALLOC(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
+ RLC_ALLOC(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.dlCb->udxDlSap == NULLP)
{
- KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
RETVALUE(LCM_REASON_MEM_NOAVAIL);
}
rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
(Size)sizeof(KwRguSapCb));
- KW_ALLOC(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
+ RLC_ALLOC(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.dlCb->rguDlSap == NULLP)
{
- KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
"kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
ret = kwDbmDlInit(gCb);
if (ret != ROK)
{
- KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
- KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"RLC DL Initialization failed");
RETVALUE(LCM_REASON_MEM_NOAVAIL);
}
if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
kwActvTmr) != ROK)
{
- KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
- KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
- KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RETVALUE(LCM_REASON_REGTMR_FAIL);
}
gCb->init.pool,
&(gCb->u.dlCb->selfPstMBuf)) != ROK)
{
- KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
- KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RETVALUE(LCM_REASON_MEM_NOAVAIL);
}
else if(gCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
- KW_ALLOC(gCb,gCb->u.ulCb, sizeof (KwUlCb));
+ RLC_ALLOC(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
if (gCb->u.ulCb == NULLP)
{
RLOG0(L_FATAL,"Memory Allocation failed");
kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
(Size)sizeof(KwKwuSapCb));
- KW_ALLOC(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_ALLOC(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.ulCb->kwuUlSap == NULLP)
{
- KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
+ RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
RETVALUE(LCM_REASON_MEM_NOAVAIL);
}
kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
(Size)sizeof(KwUdxUlSapCb));
- KW_ALLOC(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
+ RLC_ALLOC(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.ulCb->kwuUlSap == NULLP)
{
- KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
+ RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
RETVALUE(LCM_REASON_MEM_NOAVAIL);
}
rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
(Size)sizeof(KwRguSapCb));
- KW_ALLOC(gCb,gCb->u.ulCb->rguUlSap, rguSapSize);
+ RLC_ALLOC(gCb,gCb->u.ulCb->rguUlSap, rguSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.ulCb->rguUlSap == NULLP)
{
- KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
+ RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
"kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
ret = kwDbmUlInit(gCb);
if (ret != ROK)
{
- KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
- KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
+ RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"RLC DL Initialization failed");
}
if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
kwActvTmr) != ROK)
{
- KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
- KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
- KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
+ RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RETVALUE(LCM_REASON_REGTMR_FAIL);
}
/**
* @brief
- * Sends confirmation message to LM Called by KwMiLkwCfgReq function
+ * Sends confirmation message to LM Called by KwMiRlcConfigReq function
*
* @param[in] gCb RLC Instance Control Block
* @param[in] pst Post structure
#ifdef ANSI
PRIVATE Void kwLmmSendCfm
(
-KwCb *gCb,
+RlcCb *gCb,
Pst *pst,
KwMngmt *cfm,
U8 type,
)
#else
PRIVATE Void kwLmmSendCfm(gCb,pst, cfm, type, hdr)
-KwCb gCb;
+RlcCb gCb;
Pst *pst;
KwMngmt *cfm;
U8 type;
TRC2(kwLmmSendCfm);
- KW_MEM_SET(&rPst, 0, sizeof(Pst));
+ RLC_MEM_SET(&rPst, 0, sizeof(Pst));
/* reply post structure for confirmation */
if (gCb)
switch(type)
{
case TCFG:
- KwMiLkwCfgCfm(&rPst,cfm);
+ KwMiRlcConfigCfm(&rPst,cfm);
break;
case TCNTRL:
SGetDateTime(&(cfm->t.cntrl.dt));
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwCfgReq
+PUBLIC S16 KwMiRlcConfigReq
(
Pst *pst,
KwMngmt *cfg
)
#else
-PUBLIC S16 KwMiLkwCfgReq (pst, cfg)
+PUBLIC S16 KwMiRlcConfigReq (pst, cfg)
Pst *pst;
KwMngmt *cfg;
#endif
{
Reason reason; /* failure reason */
- KwCb *tKwCb=NULLP;
+ RlcCb *tRlcCb=NULLP;
- TRC3(KwMiLkwCfgReq);
+ TRC3(KwMiRlcConfigReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- if (!tKwCb)
+ if (!tRlcCb)
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
RETVALUE(RFAILED);
}
/* check configuration is done or not */
- if ((tKwCb->init.cfgDone != TRUE) &&
+ if ((tRlcCb->init.cfgDone != TRUE) &&
(cfg->hdr.elmId.elmnt != STGEN))
{
/*
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
RETVALUE(RFAILED);
}
- RLOG1(L_DEBUG, "KwMiLkwCfgReq elmId(%d)", cfg->hdr.elmId.elmnt);
+ RLOG1(L_DEBUG, "KwMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
switch(cfg->hdr.elmId.elmnt)
{
case STGEN:
{
- reason = kwLmmGenCfg(tKwCb,&cfg->t.cfg.s.gen);
+ reason = kwLmmGenCfg(tRlcCb,&cfg->t.cfg.s.gen);
break;
}
case STKWUSAP:
{
- reason = kwLmmCfgKwuSap(tKwCb,&cfg->t.cfg.s.sap);
+ reason = kwLmmCfgKwuSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
case STCKWSAP:
{
- reason = kwLmmCfgCkwSap(tKwCb,&cfg->t.cfg.s.sap);
+ reason = kwLmmCfgCkwSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
case STRGUSAP:
{
- reason = kwLmmCfgRguSap(tKwCb,&cfg->t.cfg.s.sap);
+ reason = kwLmmCfgRguSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
case STUDXSAP:
{
- reason = kwLmmCfgUdxSap(tKwCb,&cfg->t.cfg.s.sap);
+ reason = kwLmmCfgUdxSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
default:
{
cfg->cfm.status = LCM_PRIM_OK;
cfg->cfm.reason = LCM_REASON_NOT_APPL;
- kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
RETVALUE(ROK);
}
else
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = reason;
- kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
RETVALUE(RFAILED);
}
}
#endif
{
Reason reason; /* failure reason */
- KwCb *tKwCb=NULLP;
+ RlcCb *tRlcCb=NULLP;
TRC3(KwMiLkwCntrlReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- if(!tKwCb)
+ if(!tRlcCb)
{
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
RETVALUE(RFAILED);
}
- if (!(tKwCb->init.cfgDone))
+ if (!(tRlcCb->init.cfgDone))
{
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
RETVALUE(RFAILED);
}
RLOG1(L_DEBUG, "KwMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
case STGEN:
{
/* general control */
- reason = kwLmmGenCntrl(tKwCb,cntrl);
+ reason = kwLmmGenCntrl(tRlcCb,cntrl);
break;
}
case STRGUSAP:
{
/* Lower SAP control */
- reason = kwLmmLSapCntrl(tKwCb,cntrl);
+ reason = kwLmmLSapCntrl(tRlcCb,cntrl);
break;
}
case STUDXSAP:
{
/* Udx Sap cntrl */
- reason = kwLmmUdxSapCntrl(tKwCb,cntrl);
+ reason = kwLmmUdxSapCntrl(tRlcCb,cntrl);
break;
}
default:
cntrl->cfm.reason = reason;
}
- kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
RETVALUE(ROK);
}
{
KwMngmt rSta; /* Status */
Reason reason; /* Failure reason */
- KwCb *tKwCb=NULLP;
+ RlcCb *tRlcCb=NULLP;
TRC3(KwMiLkwStaReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
sta->cfm.status = LCM_PRIM_NOK;
sta->cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
+ kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
- if (!tKwCb)
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
+ if (!tRlcCb)
{
sta->cfm.status = LCM_PRIM_NOK;
sta->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
+ kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
RETVALUE(RFAILED);
}
reason = LCM_REASON_NOT_APPL;
- KW_MEM_SET(&rSta, 0, sizeof(KwMngmt));
+ RLC_MEM_SET(&rSta, 0, sizeof(KwMngmt));
switch (sta->hdr.elmId.elmnt)
{
case STSID:
&sta->t.ssta.s.kwuSap,
sizeof (KwKwuSapSta));
- reason = kwLmmGetKwuSapSta (tKwCb,&rSta.t.ssta.s.kwuSap);
+ reason = kwLmmGetKwuSapSta (tRlcCb,&rSta.t.ssta.s.kwuSap);
break;
}
case STRGUSAP:
&sta->t.ssta.s.rguSap,
sizeof (KwRguSapSta));
- reason = kwLmmGetRguSapSta (tKwCb,&rSta.t.ssta.s.rguSap);
+ reason = kwLmmGetRguSapSta (tRlcCb,&rSta.t.ssta.s.rguSap);
break;
}
case STCKWSAP:
&sta->t.ssta.s.ckwSap,
sizeof (KwCkwCntSapSta));
- reason = kwLmmGetCkwCntSapSta (tKwCb,&rSta.t.ssta.s.ckwSap);
+ reason = kwLmmGetCkwCntSapSta (tRlcCb,&rSta.t.ssta.s.ckwSap);
break;
}
default:
rSta.cfm.status = LCM_PRIM_NOK;
rSta.cfm.reason = reason;
}
- kwLmmSendCfm(tKwCb,pst, &rSta, TSSTA, &sta->hdr);
+ kwLmmSendCfm(tRlcCb,pst, &rSta, TSSTA, &sta->hdr);
RETVALUE(ROK);
}
{
KwMngmt rSts; /* Statistics */
Reason reason; /* Reason for failure */
- KwCb *tKwCb=NULLP;
+ RlcCb *tRlcCb=NULLP;
TRC3(KwMiLkwStsReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
rSts.cfm.status = LCM_PRIM_NOK;
rSts.cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
+ kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
- if (!tKwCb)
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
+ if (!tRlcCb)
{
rSts.cfm.status = LCM_PRIM_NOK;
rSts.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
+ kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
RETVALUE(RFAILED);
}
action,
sts->hdr.elmId.elmnt);
- KW_MEM_SET(&rSts, 0, sizeof(KwMngmt));
+ RLC_MEM_SET(&rSts, 0, sizeof(KwMngmt));
switch (sts->hdr.elmId.elmnt)
{
case STGEN:
{
- reason = kwLmmGetGenSts(tKwCb,&rSts.t.sts.s.gen, action);
+ reason = kwLmmGetGenSts(tRlcCb,&rSts.t.sts.s.gen, action);
break;
}
case STKWUSAP:
/* kw005.201, modified the element of kwuSap from suId to spId */
rSts.t.sts.s.kwuSap.spId = sts->t.sts.s.kwuSap.spId;
}
- reason = kwLmmGetSapSts(tKwCb,&rSts, sts->hdr.elmId.elmnt, action);
+ reason = kwLmmGetSapSts(tRlcCb,&rSts, sts->hdr.elmId.elmnt, action);
break;
}
default:
rSts.cfm.status = LCM_PRIM_NOK;
rSts.cfm.reason = reason;
}
- kwLmmSendCfm(tKwCb,pst, &rSts, TSTS, &sts->hdr);
+ kwLmmSendCfm(tRlcCb,pst, &rSts, TSTS, &sts->hdr);
RETVALUE(ROK);
}
U8 measType;
KwL2MeasCfmEvt measCfmEvt;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwMiLkwL2MeasReq);
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* Initialize measCfmEvt */
KW_MEM_ZERO(&measCfmEvt, sizeof(KwL2MeasCfmEvt));
{
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- kwUtlSndUlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
- KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
+ kwUtlSndUlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
+ RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
RETVALUE(RFAILED);
}
}
measCfmEvt.measType = measType;
measCfmEvt.status.status = LCM_PRIM_NOK;
measCfmEvt.status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- kwUtlSndDlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
- KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
+ kwUtlSndDlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
+ RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
RETVALUE(ROK);
}
{
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tKwCb->u.ulCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
+ tRlcCb->u.ulCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
}
}
KwL2MeasReqEvt *measEvt;
Pst *udxPst;
- udxPst = &(KW_GET_UDX_SAP(tKwCb)->pst);
+ udxPst = &(KW_GET_UDX_SAP(tRlcCb)->pst);
- KW_ALLOC_SHRABL_BUF(udxPst->region,
+ RLC_ALLOC_SHRABL_BUF(udxPst->region,
udxPst->pool,
measEvt,
sizeof(KwL2MeasReqEvt));
DL to send the confirmation to LM*/
/* The interface for sending a confirmation back does not exist today;
it needs to be created when the need arises */
- KwUlUdxL2MeasReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measEvt);
+ rlcUlUdxL2MeasReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measEvt);
}
/* We need to copy the transId for sending back confirms later */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- KwL2MeasEvtCb* measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
+ KwL2MeasEvtCb* measEvtCb = &(tRlcCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
measEvtCb->transId= measReqEvt->transId;
}
}
- /*KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt));*/
+ /*RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt));*/
RETVALUE(ret);
} /* KwMiLkwL2MeasReq */
U16 cntr;
U8 status = ROK;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwMiLkwL2MeasStopReq);
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* reset the counter values for the measurement that is stopped */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
- kwUtlResetUlL2MeasInKwRb(tKwCb, &measEvtCb->measCb, measType);
+ kwUtlResetUlL2MeasInKwRb(tRlcCb, &measEvtCb->measCb, measType);
}
}
{
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tKwCb->u.ulCb->kwL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
+ tRlcCb->u.ulCb->kwL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
}
}
|| (measType & LKW_L2MEAS_DL_DELAY))
{
/*Redirect the request to DL task */
- KwUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
+ rlcUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measType);
/*RETVALUE(ROK);*/
}
/*cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
status = LCM_PRIM_OK;
- KwMiLkwL2MeasStopCfm(&tKwCb->genCfg.lmPst, measType,status);
+ KwMiLkwL2MeasStopCfm(&tRlcCb->genCfg.lmPst, measType,status);
RETVALUE(ret);
}
/*S16 ret = ROK;*/
KwL2MeasEvtCb *measEvtCb = NULLP;
U16 cntr;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwMiLkwL2MeasSendReq);
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* In case of addition of any new measType here ,appropriate handling
* has to be done in RLC DL (kwUtlSndDlL2MeasCfm)*/
| LKW_L2MEAS_UU_LOSS| LKW_L2MEAS_DL_IP))
{
/*Redirect the request to DL task */
- KwUlUdxL2MeasSendReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
+ rlcUlUdxL2MeasSendReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measType);
/* L2 MEAS AGHOSH */
/*RETVALUE(ROK);*/
}
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
/* L2 MEAS AGHOSH */
if(measEvtCb->measCb.measType & measType)
{
- kwUtlHdlL2TmrExp(tKwCb, measEvtCb);
+ kwUtlHdlL2TmrExp(tRlcCb, measEvtCb);
}
}
#ifdef ANSI
PRIVATE S16 kwLmmCfgKwuSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgKwuSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmCfgCkwSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgCkwSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmCfgUdxSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgUdxSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmCfgRguSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgRguSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
#ifdef ANSI
PRIVATE Void kwLmmCleanGblRsrcs
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PRIVATE Void kwLmmCleanGblRsrcs(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
Size kwSapSize;
kwUtlFreeDlMemory(gCb);
if (gCb->u.dlCb->kwuDlSap != NULLP)
{
- KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
}
if(gCb->u.dlCb->udxDlSap != NULLP)
{
- KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
}
if(gCb->u.dlCb->rguDlSap != NULLP)
{
- KW_FREE(gCb,gCb->u.dlCb->rguDlSap, gCb->genCfg.maxRguSaps);
+ RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, gCb->genCfg.maxRguSaps);
gCb->genCfg.maxRguSaps = 0;
}
if (gCb->u.dlCb->shutdownReceived)
{
SPutMsg(gCb->u.dlCb->selfPstMBuf);
}
- KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
+ RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
}
}
{
if (gCb->u.ulCb->kwuUlSap != NULLP)
{
- KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
}
if(gCb->u.ulCb->udxUlSap != NULLP)
{
- KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
}
if(gCb->u.ulCb->rguUlSap != NULLP)
{
- KW_FREE(gCb,gCb->u.ulCb->rguUlSap, gCb->genCfg.maxRguSaps);
+ RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, gCb->genCfg.maxRguSaps);
gCb->genCfg.maxRguSaps = 0;
}
- KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
+ RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
}
}
#ifdef ANSI
PRIVATE S16 kwLmmShutdown
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PRIVATE S16 kwLmmShutdown(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
KwRguSapCb *rguSap;
kwLmmCleanGblRsrcs(gCb);
- KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
+ RLC_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
RETVALUE(LCM_REASON_NOT_APPL);
}
#ifdef ANSI
PRIVATE S16 kwLmmGenCntrl
(
-KwCb *gCb,
+RlcCb *gCb,
KwMngmt *cntrl
)
#else
PRIVATE S16 kwLmmGenCntrl(gCb,cntrl)
-KwCb *gCb;
+RlcCb *gCb;
KwMngmt *cntrl;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmUdxSapCntrl
(
-KwCb *gCb,
+RlcCb *gCb,
KwMngmt *cntrl
)
#else
PRIVATE S16 kwLmmUdxSapCntrl(gCb,cntrl)
-KwCb *gCb;
+RlcCb *gCb;
KwMngmt *cntrl;
#endif
{
/* start timer to wait for bind confirm */
kwStartTmr(gCb,(PTR)(&UDX_SAP), KW_EVT_WAIT_BNDCFM);
UDX_SAP.state = KW_SAP_BINDING;
- KwUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
+ rlcUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
}
else
{
{
/* make the state of UDXSAP configured but not bound */
UDX_SAP.state = KW_SAP_CFG;
- KwUlUdxUbndReq(&(UDX_SAP.pst), UDX_SAP.spId, 0);
+ rlcUlUdxUbndReq(&(UDX_SAP.pst), UDX_SAP.spId, 0);
}
break;
default:
#ifdef ANSI
PRIVATE S16 kwLmmLSapCntrl
(
-KwCb *gCb,
+RlcCb *gCb,
KwMngmt *cntrl
)
#else
PRIVATE S16 kwLmmLSapCntrl(gCb,cntrl)
-KwCb *gCb;
+RlcCb *gCb;
KwMngmt *cntrl;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmGetKwuSapSta
(
-KwCb *gCb,
+RlcCb *gCb,
KwKwuSapSta *sta
)
#else
PRIVATE S16 kwLmmGetKwuSapSta(gCb,sta)
-KwCb *gCb;
+RlcCb *gCb;
KwKwuSapSta *sta;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmGetRguSapSta
(
-KwCb *gCb,
+RlcCb *gCb,
KwRguSapSta *sta
)
#else
PRIVATE S16 kwLmmGetRguSapSta(gCb,sta)
-KwCb *gCb;
+RlcCb *gCb;
KwRguSapSta *sta;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmGetCkwCntSapSta
(
-KwCb *gCb,
+RlcCb *gCb,
KwCkwCntSapSta *sta
)
#else
PRIVATE S16 kwLmmGetCkwCntSapSta(gCb,sta)
-kwCb *gCb,
+rlcCb *gCb,
KwCkwCntSapSta *sta;
#endif
{
#ifdef ANSI
PRIVATE S16 kwLmmGetGenSts
(
-KwCb *gCb,
+RlcCb *gCb,
KwGenSts *sts,
Action action
)
#else
PRIVATE S16 kwLmmGetGenSts(gCb,sts, action)
-KwCb *gCb;
+RlcCb *gCb;
KwGenSts *sts;
Action action;
#endif
if(action == LKW_ZEROSTS)
{
- KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
+ RLC_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
}
RETVALUE(LCM_REASON_NOT_APPL);
#ifdef ANSI
PRIVATE S16 kwLmmGetSapSts
(
-KwCb *gCb,
+RlcCb *gCb,
KwMngmt *sts,
Elmnt elmnt,
Action action
)
#else
PRIVATE S16 kwLmmGetSapSts(sts, elmnt, action)
-KwCb *gCb;
+RlcCb *gCb;
KwMngmt *sts;
Elmnt elmnt;
Action action;
if (action == LKW_ZEROSTS)
{
- KW_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
+ RLC_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
}
break;
}
if (action == LKW_ZEROSTS)
{
- KW_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (KwCkwCntSts));
+ RLC_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (KwCkwCntSts));
}
break;
}
#ifdef ANSI
PUBLIC Void kwLmmSendAlarm
(
-KwCb *gCb,
+RlcCb *gCb,
U16 category,
U16 event,
U16 cause,
)
#else
PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId, qci)
-KwCb *gCb;
+RlcCb *gCb;
U16 category;
U16 event;
U16 cause;
#ifdef ANSI
PUBLIC Void kwLmmSendAlarm
(
-KwCb *gCb,
+RlcCb *gCb,
U16 category,
U16 event,
U16 cause,
)
#else
PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId)
-KwCb *gCb;
+RlcCb *gCb;
U16 category;
U16 event;
U16 cause;
#ifdef ANSI
PUBLIC S16 kwLmmSendTrc
(
-KwCb *gCb,
+RlcCb *gCb,
Event event,
Buffer *mBuf
)
#else
PUBLIC S16 kwLmmSendTrc(gCb,event, mBuf)
-KwCb *gCb;
+RlcCb *gCb;
Event event;
Buffer *mBuf;
#endif
{
/* if the recvd buffer size is greater than request trace len */
/* Get a temporary buffer to store the msg */
- KW_ALLOC(gCb,tempBuf, gCb->trcLen);
+ RLC_ALLOC(gCb,tempBuf, gCb->trcLen);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(tempBuf == NULLP)
}
/* Free the memory allocated for tempBuf */
- KW_FREE(gCb,tempBuf, gCb->trcLen);
+ RLC_FREE(gCb,tempBuf, gCb->trcLen);
/* Send Trace Indication to Layer manager */
KwMiLkwTrcInd(&pst, &trc, dstMbuf);
}
Inst inst;
#endif
{
- KwCb *gCb;
+ RlcCb *gCb;
TRC2(kwActvTmr)
- if (inst >= KW_MAX_RLC_INSTANCES)
+ if (inst >= MAX_RLC_INSTANCES)
{
RETVALUE (RFAILED);
}
- gCb = KW_GET_KWCB(inst);
+ gCb = RLC_GET_RLCCB(inst);
cmPrcTmr(&(gCb->kwTqCp), gCb->kwTq, (PFV) kwTmrExpiry);
RETVALUE(ROK);
PUBLIC S16 kwLiRguStaRspRbuf(Pst *Post,SpId spId,Void *staRsp);
#endif
#if defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)
-EXTERN S16 KwDlHarqStaBatchProc (Void);
+EXTERN S16 RlcDlHarqStaBatchProc (Void);
#endif
\f
#ifdef MAC_RLC_UL_RBUF
-PUBLIC S16 kwUlBatchProc ARGS ((Void));
+PUBLIC S16 rlcUlBatchProc ARGS ((Void));
EXTERN Void kwUtlFreeUlRBuf ARGS((void));
#ifdef ANSI
-PUBLIC S16 kwUlBatchProc
+PUBLIC S16 rlcUlBatchProc
(
Void
)
#else
-PUBLIC S16 kwUlBatchProc()
+PUBLIC S16 rlcUlBatchProc()
Void;
#endif
{
{
if(datInd->lchData[numLch].pdu.mBuf[numPdu])
{
- KW_FREE_BUF_WC(datInd->lchData[numLch].pdu.mBuf[numPdu]);
+ RLC_FREE_BUF_WC(datInd->lchData[numLch].pdu.mBuf[numPdu]);
}
}
}
- KW_PST_FREE(0, 0, datInd, sizeof(RguDDatIndInfo));
+ RLC_PST_FREE(0, 0, datInd, sizeof(RguDDatIndInfo));
}
}
#endif
#ifdef PTKWLKW
/* portable functions */
-PRIVATE S16 PtMiLkwCfgCfm ARGS((Pst *pst, KwMngmt *cfm));
+PRIVATE S16 PtMiRlcConfigCfm ARGS((Pst *pst, KwMngmt *cfm));
PRIVATE S16 PtMiLkwCntrlCfm ARGS((Pst *pst, KwMngmt *cfm));
PRIVATE S16 PtMiLkwStaInd ARGS((Pst *pst, KwMngmt *usta));
********************************************************************/
/* Configuration confirmation primitive */
-PRIVATE LkwCfgCfm kwMiLkwCfgCfmMt[MAXKWMI] =
+PRIVATE RlcConfigCfm kwMiRlcConfigCfmMt[MAXKWMI] =
{
#ifdef LCKWMILKW
- cmPkLkwCfgCfm, /* 0 - loosely coupled - fc */
+ packRlcConfigCfm, /* 0 - loosely coupled - fc */
#else
- PtMiLkwCfgCfm, /* 0 - tightly coupled portable */
+ PtMiRlcConfigCfm, /* 0 - tightly coupled portable */
#endif /* LCRLMILKW */
#ifdef SM
- SmMiLkwCfgCfm, /* 1 - tightly coupled layer management*/
+ SmMiRlcConfigCfm, /* 1 - tightly coupled layer management*/
#else
- PtMiLkwCfgCfm, /* 1 - tightly coupled portable */
+ PtMiRlcConfigCfm, /* 1 - tightly coupled portable */
#endif /* SM */
};
***************************************************************************/
/**
@brief
- This function is called by the KwMiLkwCfgReq function for responding
+ This function is called by the KwMiRlcConfigReq function for responding
to configuration requests.The cfm field in the KwMngmt structure contains
the response value.
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwCfgCfm
+PUBLIC S16 KwMiRlcConfigCfm
(
Pst *pst, /* post structure */
KwMngmt *cfm /* Layer Management structure */
)
#else
-PUBLIC S16 KwMiLkwCfgCfm(pst, cfm)
+PUBLIC S16 KwMiRlcConfigCfm(pst, cfm)
Pst *pst; /* post structure */
KwMngmt *cfm; /* Layer Management structure */
#endif
{
- TRC3(KwMiLkwCfgCfm);
+ TRC3(KwMiRlcConfigCfm);
/* jump to specific primitive depending on configured selector */
- (*kwMiLkwCfgCfmMt[pst->selector])(pst, cfm);
+ (*kwMiRlcConfigCfmMt[pst->selector])(pst, cfm);
RETVALUE(ROK);
}
*/
#ifdef ANSI
-PUBLIC S16 PtMiLkwCfgCfm
+PUBLIC S16 PtMiRlcConfigCfm
(
Pst *pst, /* post structure */
KwMngmt *cfm /* Layer Management structure */
)
#else
-PUBLIC S16 PtMiLkwCfgCfm(pst, cfm)
+PUBLIC S16 PtMiRlcConfigCfm(pst, cfm)
Pst *pst; /* post structure */
KwMngmt *cfm; /* Layer Management structure */
#endif
{
- TRC3(PtMiLkwCfgCfm)
+ TRC3(PtMiRlcConfigCfm)
UNUSED(pst);
UNUSED(cfm);
- TRC2(PtMiLkwCfgCfm() : function is not implemented)
+ TRC2(PtMiRlcConfigCfm() : function is not implemented)
RETVALUE(ROK);
-} /* end of PtMiLkwCfgCfm */
+} /* end of PtMiRlcConfigCfm */
/*
*
* Forward Declartion for KWU Porting Functions
********************************************************************/
#if defined(PDCP_RLC_DL_RBUF) || defined(SS_RBUF)
-PUBLIC S16 kwDlBatchProc ARGS ((Void));
+PUBLIC S16 rlcDlBatchProc ARGS ((Void));
PUBLIC S16 kwUtlDlFreeRlcRBuf ARGS((Void));
EXTERN void kwUtlDlBatchProcHqStaInd ARGS ((Void));
EXTERN Void kwUtlFreeDlMem ARGS((Void));
#endif
#if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
-PUBLIC S16 kwDlBatchProcSplit ARGS((Void));
+PUBLIC S16 rlcDlBatchProcSplit ARGS((Void));
#endif
\f
/* CKW Configuration confirm primitive */
-PUBLIC CkwCfgCfm kwUiCkwCfgCfmMt[] =
+PUBLIC RlcCfgCfm kwUiRlcCfgCfmMt[] =
{
#ifdef LCKWUICKW
- cmPkCkwCfgCfm, /* 0 - loosely coupled */
+ cmPkRlcCfgCfm, /* 0 - loosely coupled */
#endif /* LCKWUICKW */
#ifdef NH
- NhLiCkwCfgCfm, /* 1 - tightly coupled, RRC */
+ NhLiRlcCfgCfm, /* 1 - tightly coupled, RRC */
#endif /* NH */
};
*
*/
#ifdef ANSI
-PUBLIC S16 KwUiCkwCfgCfm
+PUBLIC S16 KwUiRlcCfgCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-CkwCfgCfmInfo *cfmInfo /* Configuration Confirm */
+RlcCfgCfmInfo *cfmInfo /* Configuration Confirm */
)
#else
-PUBLIC S16 KwUiCkwCfgCfm(pst, suId, cfmInfo)
+PUBLIC S16 KwUiRlcCfgCfm(pst, suId, cfmInfo)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-CkwCfgCfmInfo *cfmInfo; /* Configuration Confirm */
+RlcCfgCfmInfo *cfmInfo; /* Configuration Confirm */
#endif
{
- TRC3(KwUiCkwCfgCfm)
+ TRC3(KwUiRlcCfgCfm)
/* jump to specific primitive depending on configured selector */
- (*kwUiCkwCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
+ (*kwUiRlcCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
RETVALUE(ROK);
-} /* end of KwUiCkwCfgCfm */
+} /* end of KwUiRlcCfgCfm */
\f
/**
RETVALUE(ROK);
-} /* end of KwUiCkwCfgCfm */
+} /* end of KwUiRlcCfgCfm */
#if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
*
* @brief
*
- * kwDlBatchProcSplit- process rbug messages
+ * rlcDlBatchProcSplit- process rbug messages
*
* @return S16
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 kwDlBatchProcSplit
+PUBLIC S16 rlcDlBatchProcSplit
(
Void
)
#else
-PUBLIC S16 kwDlBatchProcSplit()
+PUBLIC S16 rlcDlBatchProcSplit()
Void;
#endif
{
#if defined(PDCP_RLC_DL_RBUF) || defined(SS_RBUF)
#ifdef ANSI
-PUBLIC S16 kwDlBatchProc
+PUBLIC S16 rlcDlBatchProc
(
Void
)
#else
-PUBLIC S16 kwDlBatchProc()
+PUBLIC S16 rlcDlBatchProc()
Void;
#endif
{
Void;
#endif
{
- kwDlBatchProc();
+ rlcDlBatchProc();
#ifdef SS_RBUF
#ifdef LTE_L2_MEAS
kwUtlDlBatchProcHqStaInd();
#define KW_MODULE (KW_DBGMASK_TM | KW_DBGMASK_DL)
-PRIVATE Void kwTmmSndStaRsp ARGS((KwCb *gCb, KwDlRbCb *rbCb,
+PRIVATE Void kwTmmSndStaRsp ARGS((RlcCb *gCb, RlcDlRbCb *rbCb,
MsgLen bo, KwuDatReqInfo *datReqInfo));
extern U32 rgMacGT ;
/** @addtogroup tmmode */
#ifdef ANSI
PUBLIC Void kwTmmQSdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwuDatReqInfo *datReqInfo,
Buffer *mBuf
)
#else
PUBLIC Void kwTmmQSdu(gCb,rbCb,datReqInfo,mBuf)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwuDatReqInfo *datReqInfo;
Buffer *mBuf;
#endif
TRC2(kwTmmQSdu)
- KW_ALLOC(gCb,sdu,sizeof(KwSdu));
+ RLC_ALLOC(gCb,sdu,sizeof(KwSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
#ifdef ANSI
PUBLIC Void kwTmmSndToLi
(
-KwCb *gCb,
+RlcCb *gCb,
SuId suId,
-KwDlRbCb *rbCb,
+RlcDlRbCb *rbCb,
RguCStaIndInfo *staInd
)
#else
PUBLIC Void kwTmmSndToLi(gCb, suId, rbCb, staInd)
-KwCb *gCb;
+RlcCb *gCb;
SuId suId;
-KwDlRbCb *rbCb;
+RlcDlRbCb *rbCb;
RguCStaIndInfo *staInd;
#endif
{
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
- KW_FREE_BUF(sdu->mBuf);
- KW_FREE(gCb, sdu, sizeof(KwSdu));
+ RLC_FREE_BUF(sdu->mBuf);
+ RLC_FREE(gCb, sdu, sizeof(KwSdu));
}
else
{
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
- KW_FREE_BUF(sdu->mBuf);
- KW_FREE(gCb, sdu, sizeof(KwSdu));
+ RLC_FREE_BUF(sdu->mBuf);
+ RLC_FREE(gCb, sdu, sizeof(KwSdu));
continue;
}
}
sdu = (KwSdu *)node->node;
- KW_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap[suId].pst.region,
+ RLC_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap[suId].pst.region,
gCb->u.dlCb->rguDlSap[suId].pst.pool,
dlData,(Size)sizeof(RlcMacData));
#if (ERRCLASS & ERRCLS_ADD_RES)
sdu->mBuf = NULLP;
cmLListDelFrm(&(rbCb->m.tm.sduQ),
&sdu->lstEnt);
- KW_FREE(gCb,sdu, sizeof(KwSdu));
+ RLC_FREE(gCb,sdu, sizeof(KwSdu));
/* If trace flag is enabled send the trace indication */
if(gCb->init.trc == TRUE)
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void kwDlTmmReEstablish
+PUBLIC Void rlcDlTmmReEstablish
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwDlTmmReEstablish(gCb,rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+PUBLIC Void rlcDlTmmReEstablish(gCb,rbCb)
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwDlTmmReEstablish)
+ TRC2(rlcDlTmmReEstablish)
#ifdef LTE_L2_MEAS_RLC
#ifdef ANSI
PRIVATE Void kwTmmSndStaRsp
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
MsgLen bo,
KwuDatReqInfo *datReqInfo
)
#else
PRIVATE Void kwTmmSndStaRsp(rbCb,bo,datReqInfo)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
MsgLen bo;
KwuDatReqInfo *datReqInfo;
#endif
rguSap = &(gCb->u.dlCb->rguDlSap[rbCb->rguSapId]);
- KW_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap[rbCb->rguSapId].pst.region,
+ RLC_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap[rbCb->rguSapId].pst.region,
gCb->u.dlCb->rguDlSap[rbCb->rguSapId].pst.pool,
boStatus, sizeof(RguCStaRspInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
#ifdef ANSI
PUBLIC Void kwTmmRcvFrmLi
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
CmLteRnti tCrnti,
Buffer *pdu
)
#else
PUBLIC Void kwTmmRcvFrmLi(gCb,rbCb, tCrnti, pdu)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
CmLteRnti tCrnti;
Buffer *pdu;
#endif
#ifdef ANSI
PUBLIC Void kwTmmRcvFrmLi
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *pdu
)
#else
PUBLIC Void kwTmmRcvFrmLi(gCb,rbCb, pdu)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *pdu;
#endif
#endif
#ifdef ANSI
PUBLIC Void kwTmmUlReEstablish
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwTmmUlReEstablish(rbCb)
-KwCb *gCb;
+RlcCb *gCb;
KwRbCb *rbCb;
#endif
{
- TRC2(kwUlTmmReEstablish)
+ TRC2(rlcUlTmmReEstablish)
RLOG_ARG0(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,"do nothing for TMM for ReEstablish");
RETVOID;
#ifdef ANSI
PUBLIC Void kwStartTmr
(
-KwCb *gCb,
+RlcCb *gCb,
PTR cb,
S16 tmrEvnt
)
#else
PUBLIC Void kwStartTmr (gCb,cb, tmrEvnt)
-KwCb *gCb;
+RlcCb *gCb;
PTR cb;
S16 tmrEvnt;
#endif
{
case KW_EVT_UMUL_REORD_TMR:
{
- KwUmUl* umUl = &(((KwUlRbCb *)cb)->m.umUl);
+ KwUmUl* umUl = &(((RlcUlRbCb *)cb)->m.umUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
KW_TMR_CALCUATE_WAIT(arg.wait, umUl->reOrdTmrInt, gCb->genCfg.timeRes);
}
case KW_EVT_AMUL_REORD_TMR:
{
- KwAmUl* amUl = &(((KwUlRbCb *)cb)->m.amUl);
+ KwAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
KW_TMR_CALCUATE_WAIT(arg.wait, amUl->reOrdTmrInt, gCb->genCfg.timeRes);
}
case KW_EVT_AMUL_STA_PROH_TMR:
{
- KwAmUl* amUl = &(((KwUlRbCb *)cb)->m.amUl);
+ KwAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
KW_TMR_CALCUATE_WAIT(arg.wait,
amUl->staProhTmrInt,
}
case KW_EVT_AMDL_POLL_RETX_TMR:
{
- KwAmDl* amDl = &(((KwDlRbCb *)cb)->m.amDl);
+ KwAmDl* amDl = &(((RlcDlRbCb *)cb)->m.amDl);
/* kw005.201 Changed wait calculation ccpu00117634*/
KW_TMR_CALCUATE_WAIT(arg.wait,
amDl->pollRetxTmrInt,
#ifdef ANSI
PUBLIC Void kwStopTmr
(
-KwCb *gCb,
+RlcCb *gCb,
PTR cb,
U8 tmrType
)
#else
PUBLIC Void kwStopTmr (gCb, cb, tmrType)
-KwCb *gCb;
+RlcCb *gCb;
PTR cb;
U8 tmrType;
#endif
{
case KW_EVT_UMUL_REORD_TMR:
{
- arg.timers = &((KwUlRbCb *)cb)->m.umUl.reOrdTmr;
+ arg.timers = &((RlcUlRbCb *)cb)->m.umUl.reOrdTmr;
arg.max = KW_MAX_UM_TMR;
break;
}
case KW_EVT_AMUL_REORD_TMR:
{
- arg.timers = &((KwUlRbCb *)cb)->m.amUl.reOrdTmr;
+ arg.timers = &((RlcUlRbCb *)cb)->m.amUl.reOrdTmr;
arg.max = KW_MAX_AM_TMR;
break;
}
case KW_EVT_AMUL_STA_PROH_TMR:
{
- arg.timers = &((KwUlRbCb *)cb)->m.amUl.staProhTmr;
+ arg.timers = &((RlcUlRbCb *)cb)->m.amUl.staProhTmr;
arg.max = KW_MAX_AM_TMR;
break;
}
case KW_EVT_AMDL_POLL_RETX_TMR:
{
- arg.timers = &((KwDlRbCb *)cb)->m.amDl.pollRetxTmr;
+ arg.timers = &((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr;
arg.max = KW_MAX_AM_TMR;
break;
}
{
case KW_EVT_UMUL_REORD_TMR:
{
- KwUlRbCb *ulRbCb = (KwUlRbCb *)cb;
- kwUmmReOrdTmrExp(KW_GET_KWCB(ulRbCb->inst), ulRbCb);
+ RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
+ kwUmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
case KW_EVT_AMUL_REORD_TMR:
{
- KwUlRbCb *ulRbCb = (KwUlRbCb *)cb;
- kwAmmReOrdTmrExp(KW_GET_KWCB(ulRbCb->inst), ulRbCb);
+ RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
+ kwAmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
case KW_EVT_AMUL_STA_PROH_TMR:
{
- KwUlRbCb *ulRbCb = (KwUlRbCb *)cb;
- kwAmmStaProTmrExp(KW_GET_KWCB(ulRbCb->inst), ulRbCb);
+ RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
+ kwAmmStaProTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
case KW_EVT_AMDL_POLL_RETX_TMR:
{
- KwDlRbCb *dlRbCb = (KwDlRbCb *)cb;
- KwCb *gCb = KW_GET_KWCB(dlRbCb->inst);
+ RlcDlRbCb *dlRbCb = (RlcDlRbCb *)cb;
+ RlcCb *gCb = RLC_GET_RLCCB(dlRbCb->inst);
kwAmmPollRetxTmrExp(gCb, dlRbCb);
#ifdef ANSI
PUBLIC Bool kwChkTmr
(
-KwCb *gCb,
+RlcCb *gCb,
PTR cb,
S16 tmrEvnt
)
#else
PUBLIC Bool kwChkTmr(gCb,cb, tmrEvnt)
-KwCb *gCb;
+RlcCb *gCb;
PTR cb;
S16 tmrEvnt;
#endif
{
case KW_EVT_UMUL_REORD_TMR:
{
- return (((KwUlRbCb *)cb)->m.umUl.reOrdTmr.tmrEvnt ==
+ return (((RlcUlRbCb *)cb)->m.umUl.reOrdTmr.tmrEvnt ==
KW_EVT_UMUL_REORD_TMR);
}
case KW_EVT_AMUL_REORD_TMR:
{
- return (((KwUlRbCb *)cb)->m.amUl.reOrdTmr.tmrEvnt ==
+ return (((RlcUlRbCb *)cb)->m.amUl.reOrdTmr.tmrEvnt ==
KW_EVT_AMUL_REORD_TMR);
}
case KW_EVT_AMUL_STA_PROH_TMR:
{
- return (((KwUlRbCb *)cb)->m.amUl.staProhTmr.tmrEvnt ==
+ return (((RlcUlRbCb *)cb)->m.amUl.staProhTmr.tmrEvnt ==
KW_EVT_AMUL_STA_PROH_TMR);
}
case KW_EVT_AMDL_POLL_RETX_TMR:
{
- return (((KwDlRbCb *)cb)->m.amDl.pollRetxTmr.tmrEvnt ==
+ return (((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr.tmrEvnt ==
KW_EVT_AMDL_POLL_RETX_TMR);
}
case KW_EVT_WAIT_BNDCFM:
if (rguSapCb->retryCnt < KW_MAX_SAP_BND_RETRY)
{
/* start timer to wait for bind confirm */
- kwStartTmr(KW_GET_KWCB(rguSapCb->pst.srcInst),
+ kwStartTmr(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
(PTR)rguSapCb,
KW_EVT_WAIT_BNDCFM);
/* Send alarm to the layer manager */
#ifdef LTE_L2_MEAS
- kwLmmSendAlarm(KW_GET_KWCB(rguSapCb->pst.srcInst),
+ kwLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
LCM_CATEGORY_INTERFACE,
LCM_EVENT_BND_FAIL,
LCM_CAUSE_TMR_EXPIRED,
0,
0);
#else
- kwLmmSendAlarm(KW_GET_KWCB(rguSapCb->pst.srcInst),
+ kwLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
LCM_CATEGORY_INTERFACE,
LCM_EVENT_BND_FAIL,
LCM_CAUSE_TMR_EXPIRED,
(
Pst *pst,
SpId spId,
-CkwCfgInfo *cfgInfo
+RlcCfgInfo *cfgInfo
)
#else
PUBLIC S16 cmPkUdxCfgReq(pst, spId, cfgInfo)
Pst *pst;
SpId spId;
-CkwCfgInfo *cfgInfo;
+RlcCfgInfo *cfgInfo;
#endif
{
S16 ret1;
#ifdef LCUDX
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)cfgInfo, sizeof(CkwCfgInfo),mBuf);
+ cmPkUdxStruct((U8 *)cfgInfo, sizeof(RlcCfgInfo),mBuf);
/* Need Not free CfgInfo here as it is stored
in UL */
break;
(
Pst *pst,
SuId suId,
-CkwCfgCfmInfo *cfgCfmInfo
+RlcCfgCfmInfo *cfgCfmInfo
)
#else
PUBLIC S16 cmPkUdxCfgCfm(pst, suId, cfgCfmInfo)
Pst *pst;
SuId suId;
-CkwCfgCfmInfo *cfgCfmInfo;
+RlcCfgCfmInfo *cfgCfmInfo;
#endif
{
S16 ret1;
#ifdef LCUDX
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)cfgCfmInfo, sizeof(CkwCfgCfmInfo),mBuf);
+ cmPkUdxStruct((U8 *)cfgCfmInfo, sizeof(RlcCfgCfmInfo),mBuf);
/* Need to free the cfgCfmInfo here as it is allocated
buffer call SPutStaticBuffer */
SPutStaticBuffer(pst->region,pst->pool,(Data *) cfgCfmInfo,
- sizeof(CkwCfgCfmInfo),0);
+ sizeof(RlcCfgCfmInfo),0);
break;
}
case UDX_SEL_LWLC:
S16 ret1;
#endif /* ERRCLASS & ERRCLS_DEBUG */
SpId spId = 0;
- CkwCfgInfo tmpCfgInfo;
- CkwCfgInfo *cfgInfo; /*stack Variable because it is not freed */
+ RlcCfgInfo tmpCfgInfo;
+ RlcCfgInfo *cfgInfo; /*stack Variable because it is not freed */
TRC3(cmUnpkUdxCfgReq)
case UDX_SEL_LC:
{
#if(ERRCLASS & ERRCLS_DEBUG)
- ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(CkwCfgInfo));
+ ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(RlcCfgInfo));
if(ret1 != ROK)
{
SPutMsg(mBuf);
RETVALUE( ret1 );
}
#else
- cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(CkwCfgInfo));
+ cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(RlcCfgInfo));
#endif /* ERRCLASS & ERRCLS_DEBUG */
cfgInfo = &tmpCfgInfo;
break;
{
S16 ret1;
SuId suId = 0;
- CkwCfgCfmInfo *cfgCfmInfo = NULLP;
+ RlcCfgCfmInfo *cfgCfmInfo = NULLP;
TRC3(cmUnpkUdxCfgCfm)
case UDX_SEL_LC:
{
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
- sizeof(CkwCfgCfmInfo),0)) != ROK)
+ sizeof(RlcCfgCfmInfo),0)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
RETVALUE(ret1);
}
- ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)cfgCfmInfo, sizeof(CkwCfgCfmInfo));
+ ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)cfgCfmInfo, sizeof(RlcCfgCfmInfo));
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
{
typedef S16 (*UdxUbndReq) ARGS((Pst* pst, SuId suId,Reason reason));
-typedef S16 (*UdxCfgReq) ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
+typedef S16 (*UdxCfgReq) ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
-typedef S16 (*UdxCfgCfm) ARGS((Pst* pst,SuId suId,CkwCfgCfmInfo *cfmInfo));
+typedef S16 (*UdxCfgCfm) ARGS((Pst* pst,SuId suId,RlcCfgCfmInfo *cfmInfo));
typedef S16 (*UdxStaUpdReq) ARGS((Pst* pst,
SpId spId,
EXTERN S16 cmPkUdxBndCfm ARGS((Pst* pst, SuId suId,U8 status ));
EXTERN S16 cmPkUdxBndReq ARGS((Pst* pst, SuId suId,SpId spId ));
EXTERN S16 cmPkUdxUbndReq ARGS((Pst* pst, SuId suId,Reason reason));
-EXTERN S16 cmPkUdxCfgReq ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
-EXTERN S16 cmPkUdxCfgCfm ARGS(( Pst* pst,SuId suId,CkwCfgCfmInfo *cfmInfo));
+EXTERN S16 cmPkUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
+EXTERN S16 cmPkUdxCfgCfm ARGS(( Pst* pst,SuId suId,RlcCfgCfmInfo *cfmInfo));
EXTERN S16 cmPkUdxStaUpdReq ARGS((Pst* pst,SpId spId,CmLteRlcId *rlcId,
KwUdxStaPdu *pStaPdu ));
EXTERN S16 cmPkUdxUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
#endif
#ifdef KW
-EXTERN S16 KwUlUdxBndReq ARGS((Pst* pst, SuId suId, SpId spId));
+EXTERN S16 rlcUlUdxBndReq ARGS((Pst* pst, SuId suId, SpId spId));
-EXTERN S16 KwDlUdxBndReq ARGS((Pst* pst, SuId suId, SpId spId));
+EXTERN S16 rlcDlUdxBndReq ARGS((Pst* pst, SuId suId, SpId spId));
-EXTERN S16 KwDlUdxBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+EXTERN S16 rlcDlUdxBndCfm ARGS((Pst* pst, SuId suId, U8 status));
-EXTERN S16 KwUlUdxBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+EXTERN S16 rlcUlUdxBndCfm ARGS((Pst* pst, SuId suId, U8 status));
-EXTERN S16 KwDlUdxCfgCfm ARGS((Pst* pst, SuId suId, CkwCfgCfmInfo *cfmInfo));
+EXTERN S16 rlcDlUdxCfgCfm ARGS((Pst* pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
-EXTERN S16 KwUlUdxCfgCfm ARGS((Pst* pst, SuId suId, CkwCfgCfmInfo *cfmInfo));
+EXTERN S16 rlcUlUdxCfgCfm ARGS((Pst* pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
-EXTERN S16 KwDlUdxUeIdChgCfm ARGS((Pst *pst,
+EXTERN S16 rlcDlUdxUeIdChgCfm ARGS((Pst *pst,
SuId suId,
U32 transId,
CmStatus status));
-EXTERN S16 KwUlUdxUeIdChgCfm ARGS((Pst *pst,
+EXTERN S16 rlcUlUdxUeIdChgCfm ARGS((Pst *pst,
SuId suId,
U32 transId,
CmStatus status));
-EXTERN S16 KwUlUdxUbndReq ARGS((Pst* pst, SuId suId, Reason reason));
+EXTERN S16 rlcUlUdxUbndReq ARGS((Pst* pst, SuId suId, Reason reason));
-EXTERN S16 KwDlUdxUbndReq ARGS((Pst* pst, SuId suId, Reason reason));
+EXTERN S16 rlcDlUdxUbndReq ARGS((Pst* pst, SuId suId, Reason reason));
-EXTERN S16 KwUlUdxUeIdChgReq ARGS((Pst *pst,
+EXTERN S16 rlcUlUdxUeIdChgReq ARGS((Pst *pst,
SpId spId,
U32 transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo));
-EXTERN S16 KwUlUdxCfgReq ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
+EXTERN S16 rlcUlUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
-EXTERN S16 KwDlUdxCfgReq ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
+EXTERN S16 rlcDlUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
-EXTERN S16 KwUlUdxStaUpdReq ARGS((Pst* pst,
+EXTERN S16 rlcUlUdxStaUpdReq ARGS((Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
KwUdxStaPdu *pStaPdu));
-EXTERN S16 KwDlUdxStaUpdReq ARGS((Pst* pst,
+EXTERN S16 rlcDlUdxStaUpdReq ARGS((Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
KwUdxStaPdu *pStaPdu));
-EXTERN S16 KwDlUdxStaUpdCfm ARGS((Pst* pst,
+EXTERN S16 rlcDlUdxStaUpdCfm ARGS((Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
KwUdxBufLst *pBufLst));
-EXTERN S16 KwUlUdxStaUpdCfm ARGS((Pst* pst,
+EXTERN S16 rlcUlUdxStaUpdCfm ARGS((Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
KwUdxBufLst *pBufLst));
-EXTERN S16 KwUlUdxStaPduReq ARGS((Pst *pst,
+EXTERN S16 rlcUlUdxStaPduReq ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
KwUdxDlStaPdu *pStaPdu ));
-EXTERN S16 KwDlUdxStaPduReq ARGS((Pst *pst,
+EXTERN S16 rlcDlUdxStaPduReq ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
KwUdxDlStaPdu *pStaPdu));
-EXTERN S16 KwDlUdxUeIdChgReq ARGS((Pst *pst,
+EXTERN S16 rlcDlUdxUeIdChgReq ARGS((Pst *pst,
SpId spId,
U32 transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo));
-EXTERN S16 KwDlUdxCfgReq ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
+EXTERN S16 rlcDlUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
-EXTERN S16 KwUlUdxStaUpdCfm ARGS((Pst* pst,
+EXTERN S16 rlcUlUdxStaUpdCfm ARGS((Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
KwUdxBufLst *pBufLst));
-EXTERN S16 KwDlUdxStaPduReq ARGS((Pst *pst,
+EXTERN S16 rlcDlUdxStaPduReq ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
KwUdxDlStaPdu *pStaPdu));
-EXTERN S16 KwUlUdxStaProhTmrStart ARGS((Pst *pst,
+EXTERN S16 rlcUlUdxStaProhTmrStart ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId ));
-EXTERN S16 KwDlUdxStaProhTmrStart ARGS((Pst *pst,
+EXTERN S16 rlcDlUdxStaProhTmrStart ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId ));
#ifdef LTE_L2_MEAS
-EXTERN S16 KwDlUdxL2MeasReq ARGS((Pst *pst, KwL2MeasReqEvt *measReqEvt));
+EXTERN S16 rlcDlUdxL2MeasReq ARGS((Pst *pst, KwL2MeasReqEvt *measReqEvt));
-EXTERN S16 KwDlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
+EXTERN S16 rlcDlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
-EXTERN S16 KwDlUdxL2MeasStopReq ARGS((Pst *pst, U8 status));
+EXTERN S16 rlcDlUdxL2MeasStopReq ARGS((Pst *pst, U8 status));
-EXTERN S16 KwUlUdxL2MeasReq ARGS((Pst* pst, KwL2MeasReqEvt *measReqEvt));
+EXTERN S16 rlcUlUdxL2MeasReq ARGS((Pst* pst, KwL2MeasReqEvt *measReqEvt));
-EXTERN S16 KwUlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
+EXTERN S16 rlcUlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
-EXTERN S16 KwUlUdxL2MeasStopReq ARGS((Pst* pst, U8 measType));
+EXTERN S16 rlcUlUdxL2MeasStopReq ARGS((Pst* pst, U8 measType));
#endif
#endif
#define KW_MODULE KW_DBGMASK_UDX
/* local defines */
-EXTERN S16 kwDlmHndlStaRsp ARGS (( KwCb *gCb,KwDlRbCb *rbCb,
+EXTERN S16 rlcDlmHndlStaRsp ARGS (( RlcCb *gCb,RlcDlRbCb *rbCb,
KwUdxStaPdu *pStaPdu, KwUdxBufLst *rlsPduLst));
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxBndReq
+PUBLIC S16 rlcDlUdxBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 KwDlUdxBndReq (pst, suId, spId)
+PUBLIC S16 rlcDlUdxBndReq (pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
#endif
{
KwUdxDlSapCb *udxSap; /* pointer to session SAP */
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
- TRC3(KwDlUdxBndReq);
+ TRC3(rlcDlUdxBndReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KWDBGP_BRIEF(tKwCb, "KwDlUdxBndReq(spId(%d), suId(%d))\n",
+ KWDBGP_BRIEF(tRlcCb, "rlcDlUdxBndReq(spId(%d), suId(%d))\n",
spId, suId);
- udxSap = (tKwCb->u.dlCb->udxDlSap + spId);
+ udxSap = (tRlcCb->u.dlCb->udxDlSap + spId);
/* Verify CKW SAP State */
switch(udxSap->state)
|| udxSap->pst.dstInst != pst->srcInst
|| udxSap->suId != suId)
{
- KW_SEND_SAPID_ALARM(tKwCb, spId,
+ KW_SEND_SAPID_ALARM(tRlcCb, spId,
LKW_EVENT_UDX_BND_REQ, LCM_CAUSE_INV_PAR_VAL);
RLOG0(L_ERROR, "UDX SAP already Bound");
- KwDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
+ rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
}
break;
}
default:
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- KW_SEND_SAPID_ALARM(tKwCb,spId,
+ KW_SEND_SAPID_ALARM(tRlcCb,spId,
LKW_EVENT_CKW_BND_REQ, LCM_CAUSE_INV_STATE);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLOG0(L_ERROR, "Invalid UDX SAP State in Bind Req");
- KwDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
+ rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
break;
}
}
- KwDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_OK);
+ rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_OK);
RETVALUE(ROK);
}
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxUbndReq
+PUBLIC S16 rlcDlUdxUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 KwDlUdxUbndReq(pst, spId, reason)
+PUBLIC S16 rlcDlUdxUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
#endif
{
KwUdxDlSapCb *udxSap;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
- TRC3(KwDlUdxUbndReq)
+ TRC3(rlcDlUdxUbndReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
RLOG2(L_DEBUG,"Unbind Req for spId[%d], reason[%d]",
spId, reason);
UNUSED(reason);
/* disable upper sap (CKW) */
- udxSap = (tKwCb->u.dlCb->udxDlSap + spId);
+ udxSap = (tRlcCb->u.dlCb->udxDlSap + spId);
#if (ERRCLASS & ERRCLS_INT_PAR)
- KW_GET_AND_VALIDATE_UDXSAP(tKwCb,udxSap, EKW208, "KwUiDlUdxndReq");
+ KW_GET_AND_VALIDATE_UDXSAP(tRlcCb,udxSap, EKW208, "KwUiDlUdxndReq");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
udxSap->state = KW_SAP_CFG;
RETVALUE(ROK);
* @details
* This function is used by RRC to configure(add/delete/modify)
* one or more RLC entities.
- * - CKW_CFG_ADD => kwCfgAddRb
- * - CKW_CFG_MODIFY => kwCfgReCfgRb
- * - CKW_CFG_DELETE => kwCfgDelRb
- * - CKW_CFG_REESTABLISH => kwCfgReEstRb
- * - CKW_CFG_DELETE_UE => kwCfgDelUe
+ * - CKW_CFG_ADD => rlcCfgAddRb
+ * - CKW_CFG_MODIFY => rlcCfgReCfgRb
+ * - CKW_CFG_DELETE => rlcCfgDelRb
+ * - CKW_CFG_REESTABLISH => rlcCfgReEstRb
+ * - CKW_CFG_DELETE_UE => rlcCfgDelUe
*
* @param[in] pst - Post structure
* @param[in] spId - Serive Provider ID
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxCfgReq
+PUBLIC S16 rlcDlUdxCfgReq
(
Pst *pst,
SpId spId,
-CkwCfgInfo *cfg
+RlcCfgInfo *cfg
)
#else
-PUBLIC S16 KwDlUdxCfgReq(pst, spId, cfg)
+PUBLIC S16 rlcDlUdxCfgReq(pst, spId, cfg)
Pst *pst;
SpId spId;
-CkwCfgInfo *cfg;
+RlcCfgInfo *cfg;
#endif
{
- CkwCfgCfmInfo *cfgCfm;
+ RlcCfgCfmInfo *cfgCfm;
U8 idx;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
Pst *pstUdxCfm;
- TRC3(KwDlUdxCfgReq)
+ TRC3(rlcDlUdxCfgReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- pstUdxCfm = &(tKwCb->u.dlCb->udxDlSap[spId].pst);
- KWDBGP_BRIEF(tKwCb,"spId(%d)\n", spId);
+ pstUdxCfm = &(tRlcCb->u.dlCb->udxDlSap[spId].pst);
+ KWDBGP_BRIEF(tRlcCb,"spId(%d)\n", spId);
/* Allocate memory and memset to 0 for cfmInfo */
- KW_ALLOC_SHRABL_BUF_WC(pstUdxCfm->region,
+ RLC_ALLOC_SHRABL_BUF_WC(pstUdxCfm->region,
pstUdxCfm->pool,
cfgCfm,
- sizeof(CkwCfgCfmInfo));
+ sizeof(RlcCfgCfmInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (cfgCfm == NULLP)
{
RLOG0(L_FATAL,"Memory Allocation Failed.");
/* kw002.201 Freeing from proper region */
- /* KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo)); */
+ /* RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo)); */
RETVALUE(RFAILED);
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
/* For every entity configuration process by cfgType */
for (idx = 0; idx < cfg->numEnt; idx++)
{
- CkwEntCfgCfmInfo *entCfgCfm;
- CkwEntCfgInfo *entCfg;
+ RlcEntCfgCfmInfo *entCfgCfm;
+ RlcEntCfgInfo *entCfg;
- entCfg = (CkwEntCfgInfo *)&(cfg->entCfg[idx]);
- entCfgCfm = (CkwEntCfgCfmInfo *)&(cfgCfm->entCfgCfm[idx]);
+ entCfg = (RlcEntCfgInfo *)&(cfg->entCfg[idx]);
+ entCfgCfm = (RlcEntCfgCfmInfo *)&(cfgCfm->entCfgCfm[idx]);
switch (entCfg->cfgType)
{
if (entCfg->dir & KW_DIR_DL)
{
/* Add a new RB entity configuration */
- if (kwCfgAddDlRb(tKwCb,cfg->ueId, cfg->cellId,\
+ if (rlcCfgAddDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
entCfg, entCfgCfm) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_RBID,cfg->entCfg[idx].rbId,"Addition Failed due to[%d]",
if (entCfg->dir & KW_DIR_DL)
{
/* Re-configure the existing RB entity configuration */
- if (kwCfgReCfgDlRb(tKwCb,cfg->ueId, cfg->cellId,\
+ if (rlcCfgReCfgDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
entCfg, entCfgCfm) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_RBID,cfg->entCfg[idx].rbId,"ReCfg Failed due to[%d]",
if (entCfg->dir & KW_DIR_DL)
{
/* Delete the existing RB entity configuration */
- if (kwCfgDelDlRb(tKwCb,cfg->ueId, cfg->cellId,\
+ if (rlcCfgDelDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
entCfg, entCfgCfm) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_RBID,cfg->entCfg[idx].rbId,"Deletion Failed due to[%d]",
sndReEst = FALSE;
}
/* Re-establish the existing RB entity configuration */
- if (kwCfgReEstDlRb(tKwCb,cfg->ueId, cfg->cellId,
+ if (rlcCfgReEstDlRb(tRlcCb,cfg->ueId, cfg->cellId,
sndReEst,entCfg, entCfgCfm) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_RBID,cfg->entCfg[idx].rbId,"Reest Failed due to[%d]",
case CKW_CFG_DELETE_UE:
{
/* Delete all RB entity configuration under UE */
- if (kwCfgDelDlUe(tKwCb,cfg->ueId, cfg->cellId,
+ if (rlcCfgDelDlUe(tRlcCb,cfg->ueId, cfg->cellId,
entCfg, entCfgCfm) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_UEID,cfg->ueId,"deletion Failed due to[%d]",
}
case CKW_CFG_DELETE_CELL:
{
- if (kwCfgDelDlCell(tKwCb,cfg->cellId,entCfg,entCfgCfm)
+ if (rlcCfgDelDlCell(tRlcCb,cfg->cellId,entCfg,entCfgCfm)
!= ROK )
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cfg->cellId,"deletion Failed due to[%d]",
cfgCfm->numEnt = cfg->numEnt;
/* kw002.201 Freeing from proper region */
- /* KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo)); */
+ /* RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo)); */
/* Send Configuration confirm primitive */
- KwDlUdxCfgCfm(&(tKwCb->u.dlCb->udxDlSap[spId].pst),
- tKwCb->u.dlCb->udxDlSap[spId].suId,
+ rlcDlUdxCfgCfm(&(tRlcCb->u.dlCb->udxDlSap[spId].pst),
+ tRlcCb->u.dlCb->udxDlSap[spId].suId,
cfgCfm);
RETVALUE(ROK);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxUeIdChgReq
+PUBLIC S16 rlcDlUdxUeIdChgReq
(
Pst *pst,
SpId spId,
CkwUeInfo *newUeInfo
)
#else
-PUBLIC S16 KwDlUdxUeIdChgReq(pst,spId,transId,ueInfo,newUeInfo)
+PUBLIC S16 rlcDlUdxUeIdChgReq(pst,spId,transId,ueInfo,newUeInfo)
Pst *pst;
SpId spId;
U32 transId;
#endif
{
CmStatus status;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
- TRC3(KwDlUdxUeIdChgReq)
+ TRC3(rlcDlUdxUeIdChgReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#ifndef ALIGN_64BIT
- KWDBGP_BRIEF(tKwCb, "(spId(%d), transId(%ld))\n",
+ KWDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%ld))\n",
spId, transId);
#else
- KWDBGP_BRIEF(tKwCb, "(spId(%d), transId(%d))\n",
+ KWDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%d))\n",
spId, transId);
#endif
status.reason = CKW_CFG_REAS_NONE;
status.status = CKW_CFG_CFM_OK;
- if (kwCfgDlUeIdChng(tKwCb, ueInfo, newUeInfo, &status) != ROK)
+ if (rlcCfgDlUeIdChng(tRlcCb, ueInfo, newUeInfo, &status) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId,"Failure due to[%d]",
status.reason);
}
- KwDlUdxUeIdChgCfm(&(tKwCb->u.dlCb->udxDlSap[spId].pst),
- tKwCb->u.dlCb->udxDlSap[spId].suId,
+ rlcDlUdxUeIdChgCfm(&(tRlcCb->u.dlCb->udxDlSap[spId].pst),
+ tRlcCb->u.dlCb->udxDlSap[spId].suId,
transId,
status);
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 KwDlUdxStaPduReq
+PUBLIC S16 rlcDlUdxStaPduReq
(
Pst *pst,
SpId spId,
KwUdxDlStaPdu *pStaPdu
)
#else
-PUBLIC S16 KwDlUdxStaPduReq(pst, spId, rlcId, pStaPdu)
+PUBLIC S16 rlcDlUdxStaPduReq(pst, spId, rlcId, pStaPdu)
Pst *pst;
SpId spId;
CmLteRlcId *rlcId;
KwUdxDlStaPdu *pStaPdu;
#endif
{
- KwDlRbCb *rbCb;
- KwCb *tKwCb;
+ RlcDlRbCb *rbCb;
+ RlcCb *tRlcCb;
- tKwCb = KW_GET_KWCB (pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB (pst->dstInst);
- kwDbmFetchDlRbCbByRbId(tKwCb, rlcId, &rbCb); /* Fetch DBM RbCb */
+ kwDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb); /* Fetch DBM RbCb */
if (!rbCb)
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
rlcId->cellId,rlcId->rbId);
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
pStaPdu,
sizeof(KwUdxDlStaPdu));
into account */
if(AMDL.pStaPdu)
{
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
AMDL.pStaPdu,
sizeof(KwUdxDlStaPdu));
}
AMDL.pStaPdu = pStaPdu;
- kwAmmSendDStaRsp(tKwCb, rbCb, &AMDL);
+ kwAmmSendDStaRsp(tRlcCb, rbCb, &AMDL);
RETVALUE (ROK);
}
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 KwDlUdxStaUpdReq
+PUBLIC S16 rlcDlUdxStaUpdReq
(
Pst* pst,
SpId spId,
KwUdxStaPdu *pStaPdu
)
#else
-PUBLIC S16 KwDlUdxStaUpdReq(pst, spId, rlcId,pStaPdu)
+PUBLIC S16 rlcDlUdxStaUpdReq(pst, spId, rlcId,pStaPdu)
Pst* pst;
SpId spId;
CmLteRlcId *rlcId;
KwUdxStaPdu *pStaPdu;
#endif
{
- KwCb *tKwCb;
- KwDlRbCb *rbCb;
+ RlcCb *tRlcCb;
+ RlcDlRbCb *rbCb;
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- kwDbmFetchDlRbCbByRbId(tKwCb, rlcId, &rbCb);
+ kwDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb);
if (!rbCb)
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
RETVALUE(RFAILED);
}
- kwAmmDlHndlStatusPdu(tKwCb, rbCb, pStaPdu);
+ kwAmmDlHndlStatusPdu(tRlcCb, rbCb, pStaPdu);
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
pStaPdu,
sizeof(KwUdxStaPdu));
/**
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxL2MeasReq
+PUBLIC S16 rlcDlUdxL2MeasReq
(
Pst *pst,
KwL2MeasReqEvt *measReqEvt
)
#else
-PUBLIC S16 KwDlUdxL2MeasReq (pst, measReqEvt)
+PUBLIC S16 rlcDlUdxL2MeasReq (pst, measReqEvt)
Pst *pst;
KwL2MeasReqEvt *measReqEvt;
#endif
U32 cntr;
U8 measType;
VOLATILE U32 startTime = 0;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
- TRC3(KwDlUdxL2MeasReq);
+ TRC3(rlcDlUdxL2MeasReq);
/*starting Task*/
SStartTask(&startTime, PID_RLC_MEAS_START);
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* Initialize measCfmEvt */
/* if measurement is for DL IP enable for all QCI */
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tKwCb->u.dlCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_DL_IP;
+ tRlcCb->u.dlCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_DL_IP;
}
}
else
U32 i;
for(i = 0; i < LKW_MAX_QCI; i++)
{
- tKwCb->u.dlCb->kwL2Cb.measOn[i] |= measType;
+ tRlcCb->u.dlCb->kwL2Cb.measOn[i] |= measType;
}
}
/* We need to copy the transId for sending back confirms later */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- KwL2MeasEvtCb* measEvtCb = &(tKwCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
+ KwL2MeasEvtCb* measEvtCb = &(tRlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
measEvtCb->transId= measReqEvt->transId;
/*stopping Task*/
SStopTask(startTime, PID_RLC_MEAS_START);
RETVALUE(ROK);
-} /* KwDlUdxMeasReq */
+} /* rlcDlUdxMeasReq */
/**
@brief
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxL2MeasStopReq
+PUBLIC S16 rlcDlUdxL2MeasStopReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 KwDlUdxL2MeasStopReq (pst, measType)
+PUBLIC S16 rlcDlUdxL2MeasStopReq (pst, measType)
Pst *pst;
U8 measType;
#endif
U8 status = ROK;
/* KwL2MeasCfmEvt measCfmEvt; */
VOLATILE U32 startTime = 0;
- KwCb *tKwCb=NULLP;
- TRC3(KwDlUdxMeasStopReq);
+ RlcCb *tRlcCb=NULLP;
+ TRC3(rlcDlUdxMeasStopReq);
/*starting Task*/
SStartTask(&startTime, PID_RLC_MEAS_STOP);
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
/* reset the counters for the measurement type passed */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tKwCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
- kwUtlResetDlL2MeasInKwRb(tKwCb, &measEvtCb->measCb, measType);
+ kwUtlResetDlL2MeasInKwRb(tRlcCb, &measEvtCb->measCb, measType);
}
}
/* switch off the measurements for the type passed */
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tKwCb->u.dlCb->kwL2Cb.measOn[cntr] &= ~measType;
+ tRlcCb->u.dlCb->kwL2Cb.measOn[cntr] &= ~measType;
}
status = LCM_PRIM_OK;
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxL2MeasSendReq
+PUBLIC S16 rlcDlUdxL2MeasSendReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 KwDlUdxL2MeasSendReq (pst, measType)
+PUBLIC S16 rlcDlUdxL2MeasSendReq (pst, measType)
Pst *pst;
U8 measType;
#endif
U16 cntr;
VOLATILE U32 startTime = 0;
- KwCb *tKwCb;
- TRC3(KwDlUdxMeasSendReq);
+ RlcCb *tRlcCb;
+ TRC3(rlcDlUdxMeasSendReq);
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tKwCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
/*starting Task*/
SStartTask(&startTime, PID_RLC_MEAS_REPORT);
- kwUtlSndDlL2MeasCfm(tKwCb, measEvtCb);
+ kwUtlSndDlL2MeasCfm(tRlcCb, measEvtCb);
/*stopping Task*/
SStopTask(startTime, PID_RLC_MEAS_REPORT);
#ifndef LCKWULUDX
PRIVATE S16 PtDlUdxBndCfm ARGS(( Pst *pst,SuId suId,U8 status ));
-PRIVATE S16 PtDlUdxCfgCfm ARGS((Pst *pst, SuId suId, CkwCfgCfmInfo *cfmInfo));
+PRIVATE S16 PtDlUdxCfgCfm ARGS((Pst *pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
PRIVATE S16 PtDlUdxUeIdChgCfm ARGS(( Pst *pst, SuId suId,U32 transId,
CmStatus status));
PRIVATE S16 PtDlUdxStaUpdCfm ARGS(( Pst* pst,SuId suId,CmLteRlcId *rlcId,
RETVALUE(ROK);
-} /* end of KwDlUdxBndCfm */
+} /* end of rlcDlUdxBndCfm */
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-CkwCfgCfmInfo *cfmInfo /* Status */
+RlcCfgCfmInfo *cfmInfo /* Status */
)
#else
PRIVATE S16 PtDlUdxCfgCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-CkwCfgCfmInfo *cfmInfo; /* Status */
+RlcCfgCfmInfo *cfmInfo; /* Status */
#endif
{
TRC3(PtDlUdxCfgCfm)
RETVALUE(ROK);
-} /* end of KwDlUdxBndCfm */
+} /* end of rlcDlUdxBndCfm */
/**
*
RETVALUE(ROK);
-} /* end of KwDlUdxBndCfm */
+} /* end of rlcDlUdxBndCfm */
}
#endif
-PRIVATE UdxBndCfm kwDlUdxBndCfmMt[UDX_MAX_SEL] =
+PRIVATE UdxBndCfm rlcDlUdxBndCfmMt[UDX_MAX_SEL] =
{
#ifdef LCKWULUDX
cmPkUdxBndCfm, /* 0 - loosely coupled */
PtDlUdxBndCfm, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwUlUdxBndCfm, /* 2 - tightly coupled, RRC */
+ rlcUlUdxBndCfm, /* 2 - tightly coupled, RRC */
#else
PtDlUdxBndCfm, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PUBLIC UdxCfgCfm kwDlUdxCfgCfmMt[UDX_MAX_SEL] =
+PUBLIC UdxCfgCfm rlcDlUdxCfgCfmMt[UDX_MAX_SEL] =
{
#ifdef LCKWULUDX
cmPkUdxCfgCfm, /* 0 - loosely coupled */
PtDlUdxCfgCfm, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwUlUdxCfgCfm, /* 2 - tightly coupled, RRC */
+ rlcUlUdxCfgCfm, /* 2 - tightly coupled, RRC */
#else
PtDlUdxCfgCfm, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PUBLIC UdxUeIdChgCfm kwDlUdxUeIdChgCfmMt[UDX_MAX_SEL] =
+PUBLIC UdxUeIdChgCfm rlcDlUdxUeIdChgCfmMt[UDX_MAX_SEL] =
{
#ifdef LCKWULUDX
cmPkUdxUeIdChgCfm, /* 0 - loosely coupled */
PtDlUdxUeIdChgCfm, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwUlUdxUeIdChgCfm, /* 2 - tightly coupled, RRC */
+ rlcUlUdxUeIdChgCfm, /* 2 - tightly coupled, RRC */
#else
PtDlUdxUeIdChgCfm, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE CONSTANT UdxStaProhTmrStart KwDlUdxStaProhTmrStartMt[UDX_MAX_SEL] =
+PRIVATE CONSTANT UdxStaProhTmrStart rlcDlUdxStaProhTmrStartMt[UDX_MAX_SEL] =
{
#ifdef LCKWULUDX
cmPkUdxStaProhTmrStart,
PtDlUdxStaProhTmrStart, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwUlUdxStaProhTmrStart, /* 2 - tightly coupled, RRC */
+ rlcUlUdxStaProhTmrStart, /* 2 - tightly coupled, RRC */
#else
PtDlUdxStaProhTmrStart, /* 2 - tightly coupled, portable */
#endif /* KW */
*
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxBndCfm
+PUBLIC S16 rlcDlUdxBndCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
U8 status /* Status */
)
#else
-PUBLIC S16 KwDlUdxBndCfm(pst, suId, status)
+PUBLIC S16 rlcDlUdxBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
U8 status; /* Status */
#endif
{
- TRC3(KwDlUdxBndCfm)
+ TRC3(rlcDlUdxBndCfm)
/* jump to specific primitive depending on configured selector */
- (*kwDlUdxBndCfmMt[pst->selector])(pst, suId, status);
+ (*rlcDlUdxBndCfmMt[pst->selector])(pst, suId, status);
RETVALUE(ROK);
-} /* end of KwDlUdxBndCfm */
+} /* end of rlcDlUdxBndCfm */
*
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxCfgCfm
+PUBLIC S16 rlcDlUdxCfgCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-CkwCfgCfmInfo *cfmInfo /* Status */
+RlcCfgCfmInfo *cfmInfo /* Status */
)
#else
-PUBLIC S16 KwDlUdxCfgCfm(pst, suId, status)
+PUBLIC S16 rlcDlUdxCfgCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-CkwCfgCfmInfo *cfmInfo; /* Status */
+RlcCfgCfmInfo *cfmInfo; /* Status */
#endif
{
- TRC3(KwDlUdxCfgCfm)
+ TRC3(rlcDlUdxCfgCfm)
/* jump to specific primitive depending on configured selector */
- (*kwDlUdxCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
+ (*rlcDlUdxCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
RETVALUE(ROK);
-} /* end of KwDlUdxBndCfm */
+} /* end of rlcDlUdxBndCfm */
/**
*
*
*/
#ifdef ANSI
-PUBLIC S16 KwDlUdxUeIdChgCfm
+PUBLIC S16 rlcDlUdxUeIdChgCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
CmStatus status
)
#else
-PUBLIC S16 KwDlUdxUeIdChgCfm(pst, suId, status)
+PUBLIC S16 rlcDlUdxUeIdChgCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
U32 transId;
CmStatus status;
#endif
{
- TRC3(KwDlUdxUeIdChgCfm)
+ TRC3(rlcDlUdxUeIdChgCfm)
/* jump to specific primitive depending on configured selector */
- (*kwDlUdxUeIdChgCfmMt[pst->selector])(pst, suId,transId,status);
+ (*rlcDlUdxUeIdChgCfmMt[pst->selector])(pst, suId,transId,status);
RETVALUE(ROK);
-} /* end of KwDlUdxBndCfm */
+} /* end of rlcDlUdxBndCfm */
#ifdef ANSI
-PUBLIC S16 KwDlUdxStaProhTmrStart
+PUBLIC S16 rlcDlUdxStaProhTmrStart
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
CmLteRlcId *rlcId
)
#else
-PUBLIC S16 KwDlUdxStaProhTmrStart(pst, suId, rlcId)
+PUBLIC S16 rlcDlUdxStaProhTmrStart(pst, suId, rlcId)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
CmLteRlcId *rlcId;
#endif
{
- TRC3(KwDlUdxStaProhTmrStart)
+ TRC3(rlcDlUdxStaProhTmrStart)
/* jump to specific primitive depending on configured selector */
- (*KwDlUdxStaProhTmrStartMt[pst->selector])(pst, suId, rlcId);
+ (*rlcDlUdxStaProhTmrStartMt[pst->selector])(pst, suId, rlcId);
RETVALUE(ROK);
-} /* end of KwDlUdxBndCfm */
+} /* end of rlcDlUdxBndCfm */
/**********************************************************************
#ifndef LCKWULUDX
PRIVATE S16 PtUlUdxBndReq ARGS((Pst* pst, SuId suId,SpId spId ));
PRIVATE S16 PtUlUdxUbndReq ARGS((Pst* pst, SuId suId,Reason reason));
-PRIVATE S16 PtUlUdxCfgReq ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
+PRIVATE S16 PtUlUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
PRIVATE S16 PtUlUdxStaUpdReq ARGS((Pst* pst,SpId spId,CmLteRlcId *rlcId,
KwUdxStaPdu *pStaPdu ));
PRIVATE S16 PtUlUdxUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
RETVALUE(ROK);
-} /* end of KwDlUdxBndReq */
+} /* end of rlcDlUdxBndReq */
/**
*
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
-CkwCfgInfo *cfmInfo /* Config Info */
+RlcCfgInfo *cfmInfo /* Config Info */
)
#else
PRIVATE S16 PtUlUdxCfgReq(pst, spId, status)
Pst *pst; /* post structure */
SpId spId; /* Service User Id */
-CkwCfgInfo *cfmInfo; /* Config Info */
+RlcCfgInfo *cfmInfo; /* Config Info */
#endif
{
TRC3(PtUlUdxCfgReq)
RETVALUE(ROK);
-} /* end of KwDlUdxCfgReq */
+} /* end of rlcDlUdxCfgReq */
#ifdef ANSI
PRIVATE S16 PtUlUdxUeIdChgReq
RETVALUE(ROK);
-} /* end of KwDlUdxCfgReq */
+} /* end of rlcDlUdxCfgReq */
PRIVATE S16 PtUlUdxStaPduReq
TRC3(PtUlUdxStaUpdReq);
RETVALUE(ROK);
-} /* end of KwUlmDlmStaUpd*/
+} /* end of RlcUlmDlmStaUpd*/
#ifdef LTE_L2_MEAS
/**
#endif
#endif
-PRIVATE UdxBndReq kwUlUdxBndReqMt[] =
+PRIVATE UdxBndReq rlcUlUdxBndReqMt[] =
{
#ifdef LCKWULUDX
cmPkUdxBndReq, /* 0 - loosely coupled */
PtUlUdxBndReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxBndReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxBndReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxBndReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE UdxUbndReq kwUlUdxUbndReqMt[] =
+PRIVATE UdxUbndReq rlcUlUdxUbndReqMt[] =
{
#ifdef LCKWULUDX
cmPkUdxUbndReq, /* 0 - loosely coupled */
PtUlUdxUbndReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxUbndReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxUbndReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxUbndReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE UdxCfgReq kwUlUdxCfgReqMt[] =
+PRIVATE UdxCfgReq rlcUlUdxCfgReqMt[] =
{
#ifdef LCKWULUDX
cmPkUdxCfgReq, /* 0 - loosely coupled */
PtUlUdxCfgReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxCfgReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxCfgReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxCfgReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE UdxUeIdChgReq kwUlUdxUeIdChgReqMt[] =
+PRIVATE UdxUeIdChgReq rlcUlUdxUeIdChgReqMt[] =
{
#ifdef LCKWULUDX
cmPkUdxUeIdChgReq, /* 0 - loosely coupled */
PtUlUdxUeIdChgReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxUeIdChgReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxUeIdChgReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxUeIdChgReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE CONSTANT UdxStaUpdReq kwUlUdxStaUpdReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxStaUpdReq rlcUlUdxStaUpdReqMt[KW_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxStaUpdReq, /* 0 - loosely coupled */
PtUlUdxStaUpdReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxStaUpdReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxStaUpdReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxStaUpdReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE CONSTANT UdxStaPduReq kwUlUdxStaPduReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxStaPduReq rlcUlUdxStaPduReqMt[KW_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxStaPduReq, /* 0 - loosely coupled */
PtUlUdxStaPduReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxStaPduReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxStaPduReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxStaPduReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
#ifdef LTE_L2_MEAS
-PRIVATE CONSTANT UdxL2MeasReq kwUlUdxL2MeasReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxL2MeasReq rlcUlUdxL2MeasReqMt[KW_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxL2MeasReq, /* 0 - loosely coupled */
PtUlUdxL2MeasReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxL2MeasReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxL2MeasReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxL2MeasReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE CONSTANT UdxL2MeasSendReq kwUlUdxL2MeasSendReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxL2MeasSendReq rlcUlUdxL2MeasSendReqMt[KW_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxL2MeasSendReq, /* 0 - loosely coupled */
PtUlUdxL2MeasSendReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxL2MeasSendReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxL2MeasSendReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxL2MeasSendReq, /* 2 - tightly coupled, portable */
#endif /* KW */
};
-PRIVATE CONSTANT UdxL2MeasStopReq kwUlUdxL2MeasStopReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxL2MeasStopReq rlcUlUdxL2MeasStopReqMt[KW_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxL2MeasStopReq, /* 0 - loosely coupled */
PtUlUdxL2MeasStopReq, /* 1 - loosely coupled, portable */
#endif /* LCKWUIKWU */
#ifdef KW
- KwDlUdxL2MeasStopReq, /* 2 - tightly coupled, RRC */
+ rlcDlUdxL2MeasStopReq, /* 2 - tightly coupled, RRC */
#else
PtUlUdxL2MeasStopReq, /* 2 - tightly coupled, portable */
#endif /* KW */
*
*/
#ifdef ANSI
-PUBLIC S16 KwUlUdxBndReq
+PUBLIC S16 rlcUlUdxBndReq
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
SpId spId /* Status */
)
#else
-PUBLIC S16 KwUlUdxBndReq(pst, suId, status)
+PUBLIC S16 rlcUlUdxBndReq(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
SpId spId; /* Status */
#endif
{
- TRC3(KwUlUdxBndReq)
+ TRC3(rlcUlUdxBndReq)
/* jump to specific primitive depending on configured selector */
- (*kwUlUdxBndReqMt[pst->selector])(pst, suId, spId);
+ (*rlcUlUdxBndReqMt[pst->selector])(pst, suId, spId);
RETVALUE(ROK);
-} /* end of KwDlUdxBndReq */
+} /* end of rlcDlUdxBndReq */
/**
*
*
*/
#ifdef ANSI
-PUBLIC S16 KwUlUdxUbndReq
+PUBLIC S16 rlcUlUdxUbndReq
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
Reason reason /* Status */
)
#else
-PUBLIC S16 KwUlUdxUbndReq(pst, suId, status)
+PUBLIC S16 rlcUlUdxUbndReq(pst, suId, status)
Pst *pst; /* post structure */
SpId spId; /* Service User Id */
Reason Reason; /* Status */
#endif
{
- TRC3(KwUlUdxUbndReq)
+ TRC3(rlcUlUdxUbndReq)
/* jump to specific primitive depending on configured selector */
- (*kwUlUdxUbndReqMt[pst->selector])(pst, spId,reason );
+ (*rlcUlUdxUbndReqMt[pst->selector])(pst, spId,reason );
RETVALUE(ROK);
-} /* end of KwDlUdxBndReq */
+} /* end of rlcDlUdxBndReq */
#ifdef ANSI
-PUBLIC S16 KwUlUdxCfgReq
+PUBLIC S16 rlcUlUdxCfgReq
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
-CkwCfgInfo *cfmInfo /* Config Info */
+RlcCfgInfo *cfmInfo /* Config Info */
)
#else
-PUBLIC S16 KwUlUdxCfgReq(pst, suId, status)
+PUBLIC S16 rlcUlUdxCfgReq(pst, suId, status)
Pst *pst; /* post structure */
SuId spId; /* Service User Id */
-CkwCfgInfo *cfmInfo; /* Config Info */
+RlcCfgInfo *cfmInfo; /* Config Info */
#endif
{
- TRC3(KwUlUdxCfgReq)
+ TRC3(rlcUlUdxCfgReq)
/* jump to specific primitive depending on configured selector */
- (*kwUlUdxCfgReqMt[pst->selector])(pst, spId, cfmInfo);
+ (*rlcUlUdxCfgReqMt[pst->selector])(pst, spId, cfmInfo);
RETVALUE(ROK);
-} /* end of KwDlUdxCfgReq */
+} /* end of rlcDlUdxCfgReq */
#ifdef ANSI
-PUBLIC S16 KwUlUdxUeIdChgReq
+PUBLIC S16 rlcUlUdxUeIdChgReq
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
CkwUeInfo *newUeInfo /* Config Info */
)
#else
-PUBLIC S16 KwUlUdxUeIdChgReq(pst, spId,transId, ueInfo, newUeInfo)
+PUBLIC S16 rlcUlUdxUeIdChgReq(pst, spId,transId, ueInfo, newUeInfo)
Pst *pst; /* post structure */
SpId spId; /* Service User Id */
U32 transId; /* transaction Id */
CkwUeInfo *newUeInfo; /* Config Info */
#endif
{
- TRC3(KwUlUdxUeIdChgReq)
+ TRC3(rlcUlUdxUeIdChgReq)
/* jump to specific primitive depending on configured selector */
- (*kwUlUdxUeIdChgReqMt[pst->selector])(pst, spId,transId,ueInfo,newUeInfo);
+ (*rlcUlUdxUeIdChgReqMt[pst->selector])(pst, spId,transId,ueInfo,newUeInfo);
RETVALUE(ROK);
-} /* end of KwDlUdxCfgReq */
+} /* end of rlcDlUdxCfgReq */
-PUBLIC S16 KwUlUdxStaPduReq
+PUBLIC S16 rlcUlUdxStaPduReq
(
Pst* pst,
SpId spId,
KwUdxDlStaPdu *pStaPdu
)
{
- TRC3(KwUlUdxStaPduReq);
+ TRC3(rlcUlUdxStaPduReq);
- RETVALUE((*kwUlUdxStaPduReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
+ RETVALUE((*rlcUlUdxStaPduReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 KwUlUdxStaUpdReq
+PUBLIC S16 rlcUlUdxStaUpdReq
(
Pst* pst,
SpId spId,
KwUdxStaPdu *pStaPdu
)
#else
-PUBLIC S16 KwUlUdxStaUpdReq(pst, rlcId, pStaPdu)
+PUBLIC S16 rlcUlUdxStaUpdReq(pst, rlcId, pStaPdu)
Pst* pst;
SpId spId;
CmLteRlcId *rlcId;
#endif
{
- TRC3(KwUlUdxStaUpdReq);
+ TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*kwUlUdxStaUpdReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
-} /* end of KwUlmDlmStaUpd*/
+ RETVALUE((*rlcUlUdxStaUpdReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
+} /* end of RlcUlmDlmStaUpd*/
#ifdef LTE_L2_MEAS
/**
*
* @details
*
-* Function : KwUlUdxL2MeasReq
+* Function : rlcUlUdxL2MeasReq
*
* @param[in] Pst* pst
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 KwUlUdxL2MeasReq
+PUBLIC S16 rlcUlUdxL2MeasReq
(
Pst* pst,
KwL2MeasReqEvt *measReqEvt
)
#else
-PUBLIC S16 KwUlUdxL2MeasReq(pst,measReqEvt)
+PUBLIC S16 rlcUlUdxL2MeasReq(pst,measReqEvt)
Pst* pst;
KwL2MeasReqEvt *measReqEvt;
#endif
{
- TRC3(KwUlUdxStaUpdReq);
+ TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*kwUlUdxL2MeasReqMt[pst->selector])(pst,measReqEvt));
-} /* end of KwUlUdxL2MeasReq*/
+ RETVALUE((*rlcUlUdxL2MeasReqMt[pst->selector])(pst,measReqEvt));
+} /* end of rlcUlUdxL2MeasReq*/
/**
* @brief Request from ULM to DLM for MeasSendReq
*
* @details
*
-* Function : KwUlUdxMeasSendReq
+* Function : rlcUlUdxMeasSendReq
*
* @param[in] Pst* pst
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 KwUlUdxL2MeasSendReq
+PUBLIC S16 rlcUlUdxL2MeasSendReq
(
Pst* pst,
U8 measType
)
#else
-PUBLIC S16 KwUlUdxL2MeasSendReq(pst,measReqEvt)
+PUBLIC S16 rlcUlUdxL2MeasSendReq(pst,measReqEvt)
Pst* pst;
U8 measType;
#endif
{
- TRC3(KwUlUdxStaUpdReq);
+ TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*kwUlUdxL2MeasSendReqMt[pst->selector])(pst,measType));
-} /* end of KwUlUdxMesReq*/
+ RETVALUE((*rlcUlUdxL2MeasSendReqMt[pst->selector])(pst,measType));
+} /* end of rlcUlUdxMesReq*/
/**
* @brief Request from ULM to DLM for MeasStopReq
*
* @details
*
-* Function : KwUlUdxL2MeasStopReq
+* Function : rlcUlUdxL2MeasStopReq
*
* @param[in] Pst* pst
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 KwUlUdxL2MeasStopReq
+PUBLIC S16 rlcUlUdxL2MeasStopReq
(
Pst* pst,
U8 measType
)
#else
-PUBLIC S16 KwUlUdxL2MeasStopReq(pst,measReqEvt)
+PUBLIC S16 rlcUlUdxL2MeasStopReq(pst,measReqEvt)
Pst* pst;
U8 measType;
#endif
{
- TRC3(KwUlUdxStaUpdReq);
+ TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*kwUlUdxL2MeasStopReqMt[pst->selector])(pst,measType));
-} /* end of KwUlUdxMesReq*/
+ RETVALUE((*rlcUlUdxL2MeasStopReqMt[pst->selector])(pst,measType));
+} /* end of rlcUlUdxMesReq*/
#endif
/**********************************************************************
#include "kw_dl.x"
#include "kw_ul.x"
+#include "rlc.h"
+#include "du_app_rlc_inf.h"
+#include "rlc_mgr.h"
#define KW_MODULE KW_DBGMASK_UDX
/* local defines */
/* forward references */
/* public variable declarations */
-EXTERN S16 kwHdlCkwUlCfgReq ARGS((KwCb *gCb,KwUlCfgTmpData *cfgTmpData,
- CkwCfgCfmInfo *cfmInfo, CkwCfgCfmInfo *cfgCfm));
+EXTERN S16 kwHdlCrlcUlCfgReq ARGS((RlcCb *gCb,RlcUlCfgTmpData *cfgTmpData,
+ RlcCfgCfmInfo *cfmInfo, RlcCfgCfmInfo *cfgCfm));
/**
* @brief
*/
#ifdef ANSI
-PUBLIC S16 KwUlUdxBndCfm
+PUBLIC S16 rlcUlUdxBndCfm
(
Pst *pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 KwUlUdxBndCfm (pst, suId, status)
+PUBLIC S16 rlcUlUdxBndCfm (pst, suId, status)
Pst *pst;
SuId suId;
U8 status;
U16 event;
U16 cause;
KwUdxUlSapCb *udxSap; /* RGU SAP Control Block */
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
- TRC3(KwUlUdxBndCfm)
+ TRC3(rlcUlUdxBndCfm)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KWDBGP_BRIEF(tKwCb, "KwUlUdxBndCfm(post, suId(%d), status(%d)\n",
+ KWDBGP_BRIEF(tRlcCb, "rlcUlUdxBndCfm(post, suId(%d), status(%d)\n",
suId, status);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (tKwCb->init.cfgDone != TRUE)
+ if (tRlcCb->init.cfgDone != TRUE)
{
RLOG0(L_FATAL, "General configuration not done");
- KW_SEND_SAPID_ALARM(tKwCb,suId,
+ KW_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
RETVALUE(RFAILED);
if (suId < 0)
{
RLOG0(L_ERROR, "Invalid suId");
- KW_SEND_SAPID_ALARM(tKwCb,suId,
+ KW_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
RETVALUE(RFAILED);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- udxSap = tKwCb->u.ulCb->udxUlSap + suId;
+ udxSap = tRlcCb->u.ulCb->udxUlSap + suId;
- KWDBGP_DETAIL(tKwCb, "KwLiRguBndCfm: For RGU SAP state=%d\n",
+ KWDBGP_DETAIL(tRlcCb, "KwLiRguBndCfm: For RGU SAP state=%d\n",
udxSap->state);
/* Check rguSap state */
{
case KW_SAP_BINDING:
{
- if(TRUE == kwChkTmr(tKwCb,(PTR)udxSap,KW_EVT_WAIT_BNDCFM))
+ if(TRUE == kwChkTmr(tRlcCb,(PTR)udxSap,KW_EVT_WAIT_BNDCFM))
{
- kwStopTmr (tKwCb,(PTR)udxSap, KW_EVT_WAIT_BNDCFM);
+ kwStopTmr (tRlcCb,(PTR)udxSap, KW_EVT_WAIT_BNDCFM);
}
udxSap->retryCnt = 0;
break;
}
/* Send an alarm with proper event and cause */
- KW_SEND_SAPID_ALARM(tKwCb,suId, event, cause);
+ KW_SEND_SAPID_ALARM(tRlcCb,suId, event, cause);
RETVALUE(ROK);
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUlUdxCfgCfm
+PUBLIC S16 rlcUlUdxCfgCfm
(
Pst *pst,
SuId suId,
-CkwCfgCfmInfo *cfmInfo
+RlcCfgCfmInfo *cfmInfo
)
#else
-PUBLIC S16 KwUlUdxCfgCfm (pst, suId, cfmInfo)
+PUBLIC S16 rlcUlUdxCfgCfm (pst, suId, cfmInfo)
Pst *pst;
SuId suId;
-CkwCfgCfmInfo *cfmInfo;
+RlcCfgCfmInfo *cfmInfo;
#endif
{
- KwCb *tKwCb;
- CkwCfgCfmInfo *cfgCfm;
- KwUlCfgTmpData *cfgTmpData;
+ RlcCb *tRlcCb;
+ RlcCfgCfmInfo *cfgCfm;
+ RlcUlCfgTmpData *cfgTmpData;
+ Pst rspPst;
+ memset(&rspPst, 0, sizeof(Pst));
- TRC3(KwUlUdxCfgCfm)
+ TRC3(rlcUlUdxCfgCfm)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
- sizeof(CkwCfgCfmInfo));
+ sizeof(RlcCfgCfmInfo));
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
- KWDBGP_BRIEF(tKwCb, " suId(%d)\n", suId);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
+ KWDBGP_BRIEF(tRlcCb, " suId(%d)\n", suId);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (suId < 0)
{
RLOG0(L_ERROR, "Invalid suId");
- KW_SEND_SAPID_ALARM(tKwCb,suId,
+ KW_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
- sizeof(CkwCfgCfmInfo));
+ sizeof(RlcCfgCfmInfo));
RETVALUE(RFAILED);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- if(ROK != kwDbmFindUlTransaction(tKwCb,cfmInfo->transId, &cfgTmpData))
+ if(ROK != kwDbmFindUlTransaction(tRlcCb,cfmInfo->transId, &cfgTmpData))
{
RLOG0(L_ERROR, "Invalid transId");
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
- sizeof(CkwCfgCfmInfo));
+ sizeof(RlcCfgCfmInfo));
RETVALUE (RFAILED);
}
- if(ROK != kwDbmDelUlTransaction(tKwCb, cfgTmpData))
+ if(ROK != kwDbmDelUlTransaction(tRlcCb, cfgTmpData))
{
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
- sizeof(CkwCfgCfmInfo));
+ sizeof(RlcCfgCfmInfo));
RETVALUE(RFAILED);
}
/* Allocate memory and memset to 0 for cfmInfo */
- KW_ALLOC(tKwCb,cfgCfm, sizeof(CkwCfgCfmInfo));
+ RLC_ALLOC(tRlcCb,cfgCfm, sizeof(RlcCfgCfmInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (cfgCfm == NULLP)
{
RLOG0(L_FATAL, "Memory Allocation failed.");
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
- sizeof(CkwCfgCfmInfo));
+ sizeof(RlcCfgCfmInfo));
RETVALUE(RFAILED);
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- kwHdlCkwUlCfgReq(tKwCb,cfgTmpData, cfmInfo, cfgCfm);
- KwUiCkwCfgCfm(&(tKwCb->u.ulCb->ckwSap.pst),
- tKwCb->u.ulCb->ckwSap.suId , cfgCfm);
+ kwHdlCrlcUlCfgReq(tRlcCb,cfgTmpData, cfmInfo, cfgCfm);
+ FILL_PST_RLC_TO_DUAPP(rspPst, tRlcCb->genCfg.lmPst.dstProcId, RLC_UL_INST, EVENT_RLC_UL_UE_CREATE_RSP);
+ SendRlcUlUeCreateRspToDu(&rspPst, cfgCfm);
/* free the memory from DL */
- KW_FREE_SHRABL_BUF(pst->region,
+ RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
cfmInfo,
- sizeof(CkwCfgCfmInfo));
+ sizeof(RlcCfgCfmInfo));
/* free the cfgInfo that came from LM */
- KW_PST_FREE(pst->region, pst->pool, cfgTmpData->cfgInfo, sizeof(CkwCfgInfo));
- KW_FREE(tKwCb,cfgTmpData,sizeof(KwUlCfgTmpData));
+ RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->cfgInfo, sizeof(RlcCfgInfo));
+ RLC_FREE(tRlcCb,cfgTmpData,sizeof(RlcUlCfgTmpData));
RETVALUE(ROK);
}
*/
#ifdef ANSI
-PUBLIC S16 KwUlUdxUeIdChgCfm
+PUBLIC S16 rlcUlUdxUeIdChgCfm
(
Pst *pst,
SuId suId,
CmStatus status
)
#else
-PUBLIC S16 KwUlUdxUeIdChgCfm (pst, suId, cfmInfo)
+PUBLIC S16 rlcUlUdxUeIdChgCfm (pst, suId, cfmInfo)
Pst *pst;
SuId suId;
U32 transId;
CmStatus status;
#endif
{
- KwCb *tKwCb;
- KwUlCfgTmpData *cfgTmpData;
+ RlcCb *tRlcCb;
+ RlcUlCfgTmpData *cfgTmpData;
- TRC3(KwUlUdxUeIdChgCfm)
+ TRC3(rlcUlUdxUeIdChgCfm)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KWDBGP_BRIEF(tKwCb, " suId(%d) \n", suId);
+ KWDBGP_BRIEF(tRlcCb, " suId(%d) \n", suId);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (suId < 0)
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- if(ROK != kwDbmFindUlTransaction(tKwCb, transId, &cfgTmpData))
+ if(ROK != kwDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
{
RLOG0(L_ERROR, "Invalid transId");
RETVALUE (RFAILED);
}
- if(ROK != kwDbmDelUlTransaction(tKwCb, cfgTmpData))
+ if(ROK != kwDbmDelUlTransaction(tRlcCb, cfgTmpData))
{
RETVALUE(RFAILED);
}
{
if(cfgTmpData->ueCb != NULLP)
{
- kwCfgApplyUlUeIdChng(tKwCb, cfgTmpData->ueInfo, cfgTmpData->newUeInfo, cfgTmpData);
+ rlcCfgApplyUlUeIdChng(tRlcCb, cfgTmpData->ueInfo, cfgTmpData->newUeInfo, cfgTmpData);
}
}
- KwUiCkwUeIdChgCfm(&(tKwCb->u.ulCb->ckwSap.pst),
- tKwCb->u.ulCb->ckwSap.suId,
+ KwUiCkwUeIdChgCfm(&(tRlcCb->u.ulCb->ckwSap.pst),
+ tRlcCb->u.ulCb->ckwSap.suId,
transId,cfgTmpData->ueInfo,status);
/* only newUeInfo needs to be freed here, ueInfo would be freed at the
interface or by he receipient in case of tight coupling */
- KW_PST_FREE(pst->region, pst->pool, cfgTmpData->newUeInfo, sizeof(CkwUeInfo));
- KW_FREE_WC(tKwCb, cfgTmpData, sizeof (KwUlCfgTmpData));
+ RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->newUeInfo, sizeof(CkwUeInfo));
+ RLC_FREE_WC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
RETVALUE(ROK);
}
* -# ROK
* -# RFAILED
*/
-PUBLIC S16 KwUlUdxStaProhTmrStart
+PUBLIC S16 rlcUlUdxStaProhTmrStart
(
Pst* pst,
SuId suId,
CmLteRlcId *rlcId
)
{
- KwCb *tKwCb= NULLP;
- KwUlRbCb *rbCb;
+ RlcCb *tRlcCb= NULLP;
+ RlcUlRbCb *rbCb;
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- kwDbmFetchUlRbCbByRbId(tKwCb, rlcId, &rbCb);
+ kwDbmFetchUlRbCbByRbId(tRlcCb, rlcId, &rbCb);
if (rbCb == NULLP)
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
}
/* Start staProhTmr */
- kwStartTmr(tKwCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ kwStartTmr(tRlcCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
RETVALUE (ROK);
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwHdlCkwUlCfgReq
+PUBLIC S16 kwHdlCrlcUlCfgReq
(
-KwCb *gCb,
-KwUlCfgTmpData *cfgTmpData,
-CkwCfgCfmInfo *cfmInfo,
-CkwCfgCfmInfo *cfgCfm
+RlcCb *gCb,
+RlcUlCfgTmpData *cfgTmpData,
+RlcCfgCfmInfo *cfmInfo,
+RlcCfgCfmInfo *cfgCfm
)
#else
-PUBLIC S16 kwHdlCkwUlCfgReq(gCb,cfgTmpData,cfmInfo,cfmInfo)
-KwCb *gCb;
-KwUlCfgTmpData *cfgTmpData;
-CkwCfgCfmInfo *cfmInfo;
-CkwCfgCfmInfo *cfgCfm;
+PUBLIC S16 kwHdlCrlcUlCfgReq(gCb,cfgTmpData,cfmInfo,cfmInfo)
+RlcCb *gCb;
+RlcUlCfgTmpData *cfgTmpData;
+RlcCfgCfmInfo *cfmInfo;
+RlcCfgCfmInfo *cfgCfm;
#endif
{
- CkwCfgInfo *cfg;
+ RlcCfgInfo *cfg;
U32 idx;
U32 maxEnt;
for (idx = 0; idx < maxEnt; idx++)
{
- CkwEntCfgCfmInfo *entCfgCfm;
- CkwEntCfgCfmInfo *entDlCfgCfm;
- CkwEntCfgInfo *entCfg;
+ RlcEntCfgCfmInfo *entCfgCfm;
+ RlcEntCfgCfmInfo *entDlCfgCfm;
+ RlcEntCfgInfo *entCfg;
entCfg = &(cfg->entCfg[idx]);
entCfgCfm = &(cfgCfm->entCfgCfm[idx]);
{
KW_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
- sizeof(CkwEntCfgCfmInfo));
+ sizeof(RlcEntCfgCfmInfo));
}
else if (entCfg->dir == KW_DIR_DL)
{
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(CkwEntCfgCfmInfo));
+ KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
else if(entCfg->dir == KW_DIR_BOTH)
{
if (entDlCfgCfm->status.status != CKW_CFG_CFM_OK)
{
- kwCfgRollBackUlRb(gCb,
+ rlcCfgRollBackUlRb(gCb,
cfg->ueId,
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx]);
}
else
{
- kwCfgApplyUlRb(gCb,
+ rlcCfgApplyUlRb(gCb,
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx],
cfgTmpData);
}
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(CkwEntCfgCfmInfo));
+ KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
else
{
{
KW_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
- sizeof(CkwEntCfgCfmInfo));
+ sizeof(RlcEntCfgCfmInfo));
}
else if (entCfg->dir == KW_DIR_DL)
{
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(CkwEntCfgCfmInfo));
+ KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
else
{
/* Reestablish indication is sent from UL Instance only*/
if (entDlCfgCfm->status.status == CKW_CFG_CFM_OK)
{
- kwCfgApplyReEstUlRb (gCb, cfg->ueId,
+ rlcCfgApplyReEstUlRb (gCb, cfg->ueId,
cfg->cellId, TRUE,
&cfgTmpData->cfgEntData[idx]);
}
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(CkwEntCfgCfmInfo));
+ KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
}
break;
{
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
{
- kwCfgApplyDelUlUe(gCb, cfgTmpData);
+ rlcCfgApplyDelUlUe(gCb, cfgTmpData);
KW_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
- sizeof(CkwEntCfgCfmInfo));
+ sizeof(RlcEntCfgCfmInfo));
}
else
{
KW_MEM_CPY(entCfgCfm, entDlCfgCfm,
- sizeof(CkwEntCfgCfmInfo));
+ sizeof(RlcEntCfgCfmInfo));
}
break;
}
{
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
{
- kwCfgApplyDelUlCell(gCb, cfgTmpData);
+ rlcCfgApplyDelUlCell(gCb, cfgTmpData);
KW_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
- sizeof(CkwEntCfgCfmInfo));
+ sizeof(RlcEntCfgCfmInfo));
}
else
{
KW_MEM_CPY(entCfgCfm, entDlCfgCfm,
- sizeof(CkwEntCfgCfmInfo));
+ sizeof(RlcEntCfgCfmInfo));
}
break;
}
--KwUiCkwBndReq
--KwUiCkwUbndReq
- --KwUiCkwCfgReq
+ --RlcProcCfgReq
--KwUiKwuBndReq
--KwUiKwuUbndReq
#endif
{
KwCkwSapCb *ckwSap;
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwUiCkwBndReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
RLOG2(L_DEBUG, "spId(%d), suId(%d)", spId, suId);
- ckwSap = &(tKwCb->u.ulCb->ckwSap);
+ ckwSap = &(tRlcCb->u.ulCb->ckwSap);
/* Take action based on the current state of the SAP */
switch(ckwSap->state)
{
ckwSap->pst.dstInst != pst->srcInst ||
ckwSap->suId != suId)
{
- KW_SEND_SAPID_ALARM(tKwCb,
+ KW_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_CKW_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
{
#if (ERRCLASS & ERRCLS_INT_PAR)
RLOG0(L_ERROR, "Invalid CKW SAP State in Bind Req");
- KW_SEND_SAPID_ALARM(tKwCb,
+ KW_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_CKW_BND_REQ,
LCM_CAUSE_INV_STATE);
Reason reason;
#endif
{
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwUiCkwUbndReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE(RFAILED);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
RLOG2(L_DEBUG,"spId(%d), reason(%d)",
spId,
UNUSED(reason);
#if (ERRCLASS & ERRCLS_INT_PAR)
- KW_GET_AND_VALIDATE_CKWSAP(tKwCb,
- (&(tKwCb->u.ulCb->ckwSap)),
+ KW_GET_AND_VALIDATE_CKWSAP(tRlcCb,
+ (&(tRlcCb->u.ulCb->ckwSap)),
EKW208,
"KwUiCkwUbndReq");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* disable upper sap (CKW) */
- tKwCb->u.ulCb->ckwSap.state = KW_SAP_CFG;
+ tRlcCb->u.ulCb->ckwSap.state = KW_SAP_CFG;
RETVALUE(ROK);
}
-/*******************************************************************
- *
- * @brief Handler for UE create request
- *
- * @details
- *
- * Function : RlcDuappProcUeCreateReq
- *
- * Functionality:
- * Handler for UE create request
- *
- * @params[in] pst - Post Structure
- * cfg - Configuration information for one or more RLC entities
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-PUBLIC S16 RlcDuappProcUeCreateReq(Pst *pst, CkwCfgInfo *ueCfg)
-{
- U8 idx;
- S16 ret=ROK;
-
- ueCfg->transId = 1;
-
- for(idx = 0; idx < ueCfg->numEnt; idx++)
- {
- ueCfg->entCfg[idx].cfgType = CKW_CFG_ADD;
- }
-
- ret = KwUiCkwCfgReq(pst, ueCfg);
- return ret;
-
-} /* RlcDuappUeCreateReq */
-
-\f
/**
* @brief
* Handler for configuring RLC entities.
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiCkwCfgReq
+PUBLIC S16 RlcProcCfgReq
(
Pst *pst,
-//SpId spId,
-CkwCfgInfo *cfg
+RlcCfgInfo *cfg
)
#else
-//PUBLIC S16 KwUiCkwCfgReq(pst, spId, cfg)
-PUBLIC S16 KwUiCkwCfgReq(pst, cfg)
+PUBLIC S16 RlcProcCfgReq(pst, cfg)
Pst *pst;
-//SpId spId;
-CkwCfgInfo *cfg;
+RlcCfgInfo *cfg;
#endif
{
- KwCb *tKwCb;
- KwUlCfgTmpData *cfgTmpData;
+ RlcCb *tRlcCb;
+ RlcUlCfgTmpData *cfgTmpData;
static U32 transCount;
- TRC3(KwUiCkwCfgReq)
+ TRC3(RlcProcCfgReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo));
+ RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KW_ALLOC(tKwCb, cfgTmpData, sizeof (KwUlCfgTmpData));
+ RLC_ALLOC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
if (cfgTmpData == NULLP)
{
- KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo));
+ RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
RETVALUE(RFAILED);
}
-
-
+
cfgTmpData->uprLyrTransId = cfg->transId; /*Save User TransId*/
cfgTmpData->transId = ++transCount; /*Generate new TransId*/
cfg->transId = cfgTmpData->transId;
cfgTmpData->cfgInfo = cfg;
+
- if (kwDbmAddUlTransaction(tKwCb, cfgTmpData) != ROK)
+ if (kwDbmAddUlTransaction(tRlcCb, cfgTmpData) != ROK)
{
RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
- KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo));
+ RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
RETVALUE(RFAILED);
}
- kwHdlUiCkwUlCfgReq(tKwCb, cfgTmpData, cfg);
-
- KwUlUdxCfgReq(&(KW_GET_UDX_SAP(tKwCb)->pst),KW_GET_UDX_SAP(tKwCb)->spId,cfg);
+ rlcUlHdlCfgReq(tRlcCb, cfgTmpData, cfg);
+ rlcUlUdxCfgReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),KW_GET_UDX_SAP(tRlcCb)->spId,cfg);
RETVALUE(ROK);
}
#endif
{
S16 ret = ROK;
- KwCb *tKwCb;
- KwUlCfgTmpData *cfgTmpData = NULLP;
+ RlcCb *tRlcCb;
+ RlcUlCfgTmpData *cfgTmpData = NULLP;
TRC3(KwUiCkwUeIdChgReq)
do
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
ret = RFAILED;
break;
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#ifndef ALIGN_64BIT
RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId,
"KwUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))",
transId);
#endif
- KW_ALLOC(tKwCb, cfgTmpData, sizeof (KwUlCfgTmpData));
+ RLC_ALLOC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
if (!cfgTmpData)
{
ret = RFAILED;
cfgTmpData->ueInfo = ueInfo;
cfgTmpData->newUeInfo = newUeInfo;
- if (kwDbmAddUlTransaction(tKwCb, cfgTmpData))
+ if (kwDbmAddUlTransaction(tRlcCb, cfgTmpData))
{
RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
ret = RFAILED;
* that was passed and could have been allocated in this function
*/
/* Freeing from proper region */
- KW_PST_FREE(pst->region, pst->pool, newUeInfo, sizeof(CkwUeInfo));
- KW_PST_FREE(pst->region, pst->pool, ueInfo, sizeof(CkwUeInfo));
+ RLC_PST_FREE(pst->region, pst->pool, newUeInfo, sizeof(CkwUeInfo));
+ RLC_PST_FREE(pst->region, pst->pool, ueInfo, sizeof(CkwUeInfo));
if(cfgTmpData)
{
- KW_FREE(tKwCb, cfgTmpData, sizeof (KwUlCfgTmpData));
+ RLC_FREE(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
}
RETVALUE(RFAILED);
}
- if(ROK != kwCfgValidateUeIdChng(tKwCb,ueInfo,newUeInfo,cfgTmpData))
+ if(ROK != rlcCfgValidateUeIdChng(tRlcCb,ueInfo,newUeInfo,cfgTmpData))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cfgTmpData->ueInfo->cellId,
"Validation Failure for UeId change");
}
- KwUlUdxUeIdChgReq(&(KW_GET_UDX_SAP(tKwCb)->pst),
- KW_GET_UDX_SAP(tKwCb)->spId,
+ rlcUlUdxUeIdChgReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),
+ KW_GET_UDX_SAP(tRlcCb)->spId,
transId,
ueInfo,
newUeInfo);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Void kwHdlUiCkwUlCfgReq
+PUBLIC Void rlcUlHdlCfgReq
(
-KwCb *gCb,
-KwUlCfgTmpData *cfgTmpData,
-CkwCfgInfo *cfg
+RlcCb *gCb,
+RlcUlCfgTmpData *cfgTmpData,
+RlcCfgInfo *cfg
)
#else
-PUBLIC Void kwHdlUiCkwUlCfgReq(gCb, cfgTmpData, cfg)
-KwCb *gCb;
-KwUlCfgTmpData *cfgTmpData;
-CkwCfgInfo *cfg;
+PUBLIC Void rlcUlHdlCfgReq(gCb, cfgTmpData, cfg)
+RlcCb *gCb;
+RlcUlCfgTmpData *cfgTmpData;
+RlcCfgInfo *cfg;
#endif
{
U8 idx;
- TRC3(kwHdlUiCkwUlCfgReq)
+ TRC3(rlcUlHdlCfgReq)
cfgTmpData->ueId = cfg->ueId;
cfgTmpData->cellId = cfg->cellId;
if(cfg->entCfg[idx].dir & KW_DIR_UL)
{
/* Configuration is for UL , thus validating */
- if(ROK != kwCfgValidateUlRb(gCb,
+ if(ROK != rlcCfgValidateUlRb(gCb,
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
/*If the configuration is for UL only then apply it */
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
{
- kwCfgApplyUlRb(gCb,
+ rlcCfgApplyUlRb(gCb,
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx],
cfgTmpData);
{
if(cfg->entCfg[idx].dir & KW_DIR_UL)
{
- if(ROK != kwCfgValidateReEstRb(gCb,
+ if(ROK != rlcCfgValidateReEstRb(gCb,
cfg->ueId,
cfg->cellId,
&cfg->entCfg[idx],
/*If the configuration is for UL only then apply it */
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
{
- kwCfgApplyReEstUlRb(gCb,
+ rlcCfgApplyReEstUlRb(gCb,
cfg->ueId,
cfg->cellId,
TRUE,
}
case CKW_CFG_DELETE_UE :
{
- if(ROK != kwCfgValidateDelUlUe(gCb,
+ if(ROK != rlcCfgValidateDelUlUe(gCb,
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
}
case CKW_CFG_DELETE_CELL :
{
- if(ROK != kwCfgValidateDelUlCell(gCb,
+ if(ROK != rlcCfgValidateDelUlCell(gCb,
cfg->cellId,
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx],
#endif
{
KwKwuSapCb *kwuSap; /* SAP Config Block */
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwUiKwuBndReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
RLOG2(L_DEBUG, "KwUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
/* Validation of input parameters */
#if (ERRCLASS & ERRCLS_INT_PAR)
- if(!((spId < (S16) tKwCb->genCfg.maxKwuSaps) && (spId >=0)))
+ if(!((spId < (S16) tRlcCb->genCfg.maxKwuSaps) && (spId >=0)))
{
RLOG0(L_ERROR,"Invalid spId");
- KW_SEND_SAPID_ALARM(tKwCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
+ KW_SEND_SAPID_ALARM(tRlcCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
RETVALUE(RFAILED);
}
#endif
/* Get Sap control block */
- kwuSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
- (tKwCb->u.dlCb->kwuDlSap + spId):
- (tKwCb->u.ulCb->kwuUlSap + spId);
+ kwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
+ (tRlcCb->u.dlCb->kwuDlSap + spId):
+ (tRlcCb->u.ulCb->kwuUlSap + spId);
/* Take action based on the current state of the SAP */
switch(kwuSap->state)
kwuSap->pst.dstInst != pst->srcInst ||
kwuSap->suId != suId)
{
- KW_SEND_SAPID_ALARM(tKwCb,
+ KW_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_KWU_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
RLOG1(L_ERROR,"RLC Mode [%d] : KWU SAP already Bound",
- tKwCb->genCfg.rlcMode);
+ tRlcCb->genCfg.rlcMode);
KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_NOK);
RETVALUE(RFAILED);
}
{
#if (ERRCLASS & ERRCLS_INT_PAR)
RLOG1(L_ERROR,"RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
- tKwCb->genCfg.rlcMode);
- KW_SEND_SAPID_ALARM(tKwCb,
+ tRlcCb->genCfg.rlcMode);
+ KW_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_KWU_BND_REQ,
LCM_CAUSE_INV_STATE);
#endif
{
KwKwuSapCb *kwuSap; /* KWU SAP control block */
- KwCb *tKwCb;
+ RlcCb *tRlcCb;
TRC3(KwUiKwuUbndReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if ((pst->dstInst >= KW_MAX_RLC_INSTANCES) ||
- (spId >= (S16) kwCb[pst->dstInst]->genCfg.maxKwuSaps) ||
+ if ((pst->dstInst >= MAX_RLC_INSTANCES) ||
+ (spId >= (S16) rlcCb[pst->dstInst]->genCfg.maxKwuSaps) ||
(spId < 0))
{
RETVALUE (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
RLOG2(L_DEBUG, "spId(%d), reason(%d)",
spId,
reason);
/* Get Sap control block */
- kwuSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
- (tKwCb->u.dlCb->kwuDlSap + spId):
- (tKwCb->u.ulCb->kwuUlSap + spId);
+ kwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
+ (tRlcCb->u.dlCb->kwuDlSap + spId):
+ (tRlcCb->u.ulCb->kwuUlSap + spId);
kwuSap->state = KW_SAP_CFG;
#endif
{
S16 ret = ROK; /* Return Value */
- KwDlRbCb *rbCb; /* RB Control Block */
- KwCb *tKwCb;
+ RlcDlRbCb *rbCb; /* RB Control Block */
+ RlcCb *tRlcCb;
TRC3(KwUiKwuDatReq)
DU_LOG("\nRLC : Received DL Data");
#if (ERRCLASS & ERRCLS_INT_PAR)
- if(pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if(pst->dstInst >= MAX_RLC_INSTANCES)
{
SPutMsg(mBuf);
RETVALUE(RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* Fetch the RbCb */
- kwDbmFetchDlRbCbByRbId(tKwCb, &datReq->rlcId, &rbCb);
+ kwDbmFetchDlRbCbByRbId(tRlcCb, &datReq->rlcId, &rbCb);
if(!rbCb)
{
RLOG_ARG2(L_WARNING, DBG_UEID,datReq->rlcId.ueId, "CellId[%u]:DL RbId [%d] not found",
datReq->rlcId.cellId,datReq->rlcId.rbId);
- KW_FREE_BUF(mBuf);
+ RLC_FREE_BUF(mBuf);
RETVALUE(RFAILED);
}
if (pst->srcEnt != ENTNH)
{
/* kw002.201 Freeing from proper region */
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datReq,
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datReq,
sizeof(KwuDatReqInfo));
- KW_FREE_BUF(mBuf);
+ RLC_FREE_BUF(mBuf);
RETVALUE(RFAILED);
}
- kwTmmQSdu(tKwCb,rbCb, datReq, mBuf);
+ kwTmmQSdu(tRlcCb,rbCb, datReq, mBuf);
break;
}
case CM_LTE_MODE_UM:
{
- kwUmmQSdu(tKwCb,rbCb, datReq, mBuf);
+ kwUmmQSdu(tRlcCb,rbCb, datReq, mBuf);
break;
}
case CM_LTE_MODE_AM:
{
- kwAmmQSdu(tKwCb,rbCb, mBuf, datReq);
+ kwAmmQSdu(tRlcCb,rbCb, mBuf, datReq);
break;
}
default:
KwuDiscSduInfo *discSdu;
#endif
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, discSdu, sizeof(KwuDiscSduInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, discSdu, sizeof(KwuDiscSduInfo));
RETVALUE(ROK);
}
extern "C" {
#endif /* __cplusplus */
-typedef struct kwUlUeCb KwUlUeCb;
+typedef struct rlcUlUeCb RlcUlUeCb;
/** @defgroup um_uplink UM Uplink Module
*/
* - umDl : Unacknowledged Mode downlink information
* - amDl : Acknowledged Mode downlink information
*/
-typedef struct _kwUlRbCb
+typedef struct _rlcUlRbCb
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
KwL2MeasRbCb rbL2Cb; /**< RB measurement L2 Cb */
- KwUlUeCb *ueCb; /*!< Pointer to UeCb */
+ RlcUlUeCb *ueCb; /*!< Pointer to UeCb */
U8 qci; /**< qci of the RB */
KwL2MeasIpThruput l2MeasIpThruput; /**< Holds related parameter for
DL/Ul ip throughput>*/
KwUmUl umUl; /**< UM mode Ul elements */
KwAmUl amUl; /**< AM mode uplink elements */
}m; /**< RLC mode specific Info */
-}KwUlRbCb;
+}RlcUlRbCb;
/**
* @brief Structure to hold mapping between logical channel and Radio Bearer
* @details
* - ulRbCb : Pointer to the uplink Radio Bearer
*/
-typedef struct kwUlLch
+typedef struct rlcUlLch
{
- KwUlRbCb *ulRbCb; /**< Pointer to Uplink RbCb */
-}KwUlLch;
+ RlcUlRbCb *ulRbCb; /**< Pointer to Uplink RbCb */
+}RlcUlLch;
/**
* @brief Structure to hold uplink information about the Cells
* - lCh : Logical Channels in the cell
* - selfPstUl : Pst structure for sending messages to self
*/
-typedef struct kwUlCellCb
+typedef struct rlcUlCellCb
{
CmHashListEnt cellHlEnt; /**< Hash list entry for CellCb */
CmLteCellId cellId; /**< Cell Id */
- KwUlRbCb *rbCb[KW_MAX_RB_PER_CELL]; /**< RbCbs within a Cell */
- KwUlLch lCh[KW_MAX_LCH_PER_CELL]; /**< Logical channels in a cell */
+ RlcUlRbCb *rbCb[KW_MAX_RB_PER_CELL]; /**< RbCbs within a Cell */
+ RlcUlLch lCh[KW_MAX_LCH_PER_CELL]; /**< Logical channels in a cell */
Pst selfPstUl;
-}KwUlCellCb;
+}RlcUlCellCb;
/**
* @brief Structure to hold uplink information about the UEs
* - drbCb : Data Radio Bearers configured for the UE
* - lCh : Logical Channels in the UE
*/
-struct kwUlUeCb
+struct rlcUlUeCb
{
CmHashListEnt ueHlEnt; /**< Hash list entry for UeCb */
CmLteRnti ueId; /*!< UE Id */
CmLteCellId cellId; /*!< Cell Id */
- KwUlRbCb *srbCb[KW_MAX_SRB_PER_UE]; /**< SRB RbCbs within an UE */
- KwUlRbCb *drbCb[KW_MAX_DRB_PER_UE]; /**< DRB RbCbs within an UE */
- KwUlLch lCh[KW_MAX_LCH_PER_UE]; /**< Logical channels of an UE*/
+ RlcUlRbCb *srbCb[KW_MAX_SRB_PER_UE]; /**< SRB RbCbs within an UE */
+ RlcUlRbCb *drbCb[KW_MAX_DRB_PER_UE]; /**< DRB RbCbs within an UE */
+ RlcUlLch lCh[KW_MAX_LCH_PER_UE]; /**< Logical channels of an UE*/
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
U32 firstPacketTTI; /*!< is first packet of the burst */
* - entUlCfgCfm : Holds the UL configuration status
* - rbCb : Rb Block
*/
-typedef struct kwUlEntTmpData
+typedef struct rlcUlEntTmpData
{
- CkwEntCfgCfmInfo entUlCfgCfm; /**< Ul Configuration status*/
- KwUlRbCb *rbCb; /**< Rb Block */
-}KwUlEntTmpData;
+ RlcEntCfgCfmInfo entUlCfgCfm; /**< Ul Configuration status*/
+ RlcUlRbCb *rbCb; /**< Rb Block */
+}RlcUlEntTmpData;
/**
* @brief Structure to hold transaction information in configuration request
* - newUeInfo : New Ue Information
* - cfgTmpData : Temporary data per Configuration entity
*/
-typedef struct kwUlCfgTmpData
+typedef struct rlcUlCfgTmpData
{
CmHashListEnt transHlEnt; /**< List Entry of
Transaction*/
This is used while sending confirm to the User Layer */
CmLteCellId cellId; /**< Cell Id */
CmLteRnti ueId; /**< Ue Id */
- KwUlUeCb *ueCb; /**< Ue Block */
- KwUlCellCb *cellCb; /**< Cell Block */
- CkwCfgInfo *cfgInfo; /**< Config Information*/
+ RlcUlUeCb *ueCb; /**< Ue Block */
+ RlcUlCellCb *cellCb; /**< Cell Block */
+ RlcCfgInfo *cfgInfo; /**< Config Information*/
CkwUeInfo *ueInfo; /**< Ue Information */
CkwUeInfo *newUeInfo; /**< New Ue Information */
- KwUlEntTmpData cfgEntData[CKW_MAX_ENT_CFG]; /**< Entity Data */
-} KwUlCfgTmpData;
+ RlcUlEntTmpData cfgEntData[CKW_MAX_ENT_CFG]; /**< Entity Data */
+} RlcUlCfgTmpData;
/****************************************************************************
* EXTERN Declarations
***************************************************************************/
* Configuration Functions
***************************************************************************/
-EXTERN S16 kwValidateRbCfgParams ARGS ((KwCb *gCb,
+EXTERN S16 kwValidateRbCfgParams ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- CkwEntCfgInfo *cfgToValidate,
+ RlcEntCfgInfo *cfgToValidate,
CmStatus *status));
-EXTERN S16 kwCfgValidateUlRb ARGS (( KwCb *gCb,
- CkwEntCfgInfo *cfgToValidate,
- KwUlEntTmpData *cfgInfo,
- KwUlCfgTmpData *cfg));
+EXTERN S16 rlcCfgValidateUlRb ARGS (( RlcCb *gCb,
+ RlcEntCfgInfo *cfgToValidate,
+ RlcUlEntTmpData *cfgInfo,
+ RlcUlCfgTmpData *cfg));
-EXTERN S16 kwCfgRollBackUlRb ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgRollBackUlRb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
- CkwEntCfgInfo *cfgToValidate,
- KwUlEntTmpData *cfgTempData));
+ RlcEntCfgInfo *cfgToValidate,
+ RlcUlEntTmpData *cfgTempData));
-EXTERN Void kwCfgApplyUlRb ARGS ((KwCb *gCb,
- CkwEntCfgInfo *cfgToAply,
- KwUlEntTmpData *cfgTmpData,
- KwUlCfgTmpData *cfgTmpInfo));
+EXTERN Void rlcCfgApplyUlRb ARGS ((RlcCb *gCb,
+ RlcEntCfgInfo *cfgToAply,
+ RlcUlEntTmpData *cfgTmpData,
+ RlcUlCfgTmpData *cfgTmpInfo));
-EXTERN S16 kwCfgValidateReEstRb ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgValidateReEstRb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- CkwEntCfgInfo *cfgToValidate,
- KwUlEntTmpData *cfgTmpData));
+ RlcEntCfgInfo *cfgToValidate,
+ RlcUlEntTmpData *cfgTmpData));
-EXTERN Void kwCfgApplyReEstUlRb ARGS ((KwCb *gCb,
+EXTERN Void rlcCfgApplyReEstUlRb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
Bool sndReEstInd,
- KwUlEntTmpData *cfgTmpData));
+ RlcUlEntTmpData *cfgTmpData));
-EXTERN Void kwCfgApplyDelUlCell ARGS ((KwCb *gCb,
- KwUlCfgTmpData *cfgTmpData));
+EXTERN Void rlcCfgApplyDelUlCell ARGS ((RlcCb *gCb,
+ RlcUlCfgTmpData *cfgTmpData));
-EXTERN S16 kwCfgValidateDelUlCell ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgValidateDelUlCell ARGS ((RlcCb *gCb,
CmLteCellId cellId,
- CkwEntCfgInfo *cfgToValidate,
- KwUlEntTmpData *cfgTmpData,
- KwUlCfgTmpData *cfgInfo));
+ RlcEntCfgInfo *cfgToValidate,
+ RlcUlEntTmpData *cfgTmpData,
+ RlcUlCfgTmpData *cfgInfo));
-EXTERN S16 kwCfgValidateDelUlUe ARGS ((KwCb *gCb,
- CkwEntCfgInfo *cfgToValidate,
- KwUlEntTmpData *cfgTmpData,
- KwUlCfgTmpData *cfgInfo));
+EXTERN S16 rlcCfgValidateDelUlUe ARGS ((RlcCb *gCb,
+ RlcEntCfgInfo *cfgToValidate,
+ RlcUlEntTmpData *cfgTmpData,
+ RlcUlCfgTmpData *cfgInfo));
-EXTERN Void kwCfgApplyDelUlUe ARGS ((KwCb *gCb,
- KwUlCfgTmpData *cfgTmpData));
+EXTERN Void rlcCfgApplyDelUlUe ARGS ((RlcCb *gCb,
+ RlcUlCfgTmpData *cfgTmpData));
-EXTERN Void kwHdlUiCkwUlCfgReq ARGS ((KwCb *gCb,
- KwUlCfgTmpData *cfgInfo,
- CkwCfgInfo *cfg));
+EXTERN Void rlcUlHdlCfgReq ARGS ((RlcCb *gCb,
+ RlcUlCfgTmpData *cfgInfo,
+ RlcCfgInfo *cfg));
-EXTERN Void kwCfgApplyUlUeIdChng ARGS ((KwCb *gCb,
+EXTERN Void rlcCfgApplyUlUeIdChng ARGS ((RlcCb *gCb,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo,
- KwUlCfgTmpData *cfgTmpInfo));
+ RlcUlCfgTmpData *cfgTmpInfo));
-EXTERN S16 kwCfgValidateUeIdChng ARGS ((KwCb *gCb,
+EXTERN S16 rlcCfgValidateUeIdChng ARGS ((RlcCb *gCb,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo,
- KwUlCfgTmpData *cfgTmpInfo));
+ RlcUlCfgTmpData *cfgTmpInfo));
/****************************************************************************
* DBM module Functions
***************************************************************************/
-EXTERN S16 kwDbmUlInit ARGS ((KwCb *gCb));
+EXTERN S16 kwDbmUlInit ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmUlDeInit ARGS ((KwCb *gCb));
+EXTERN Void kwDbmUlDeInit ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmAddUlUeCb ARGS ((KwCb *gCb,
+EXTERN S16 kwDbmAddUlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- KwUlUeCb *ueCb));
+ RlcUlUeCb *ueCb));
-EXTERN S16 kwDbmFetchUlUeCb ARGS ((KwCb *gCb,
+EXTERN S16 kwDbmFetchUlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
- KwUlUeCb **ueCb));
+ RlcUlUeCb **ueCb));
-EXTERN Void kwDbmDelUlUeCb ARGS ((KwCb *gCb,
- KwUlUeCb *ueCb,
+EXTERN Void kwDbmDelUlUeCb ARGS ((RlcCb *gCb,
+ RlcUlUeCb *ueCb,
Bool abortFlag));
-EXTERN Void kwDbmDelAllUlUe ARGS ((KwCb *gCb));
+EXTERN Void kwDbmDelAllUlUe ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmAddUlCellCb ARGS ((KwCb *gCb,
+EXTERN S16 kwDbmAddUlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
- KwUlCellCb *cellCb));
+ RlcUlCellCb *cellCb));
-EXTERN Void kwDbmFetchUlCellCb ARGS ((KwCb *gCb,
+EXTERN Void kwDbmFetchUlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
- KwUlCellCb **cellCb));
+ RlcUlCellCb **cellCb));
-EXTERN Void kwDbmDelUlCellCb ARGS ((KwCb *gCb,
- KwUlCellCb *cellCb));
+EXTERN Void kwDbmDelUlCellCb ARGS ((RlcCb *gCb,
+ RlcUlCellCb *cellCb));
-EXTERN Void kwDbmDelAllUlCell ARGS ((KwCb *gCb));
+EXTERN Void kwDbmDelAllUlCell ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmFetchUlRbCbByRbId ARGS ((KwCb *gCb,
+EXTERN Void kwDbmFetchUlRbCbByRbId ARGS ((RlcCb *gCb,
CmLteRlcId *rlcId,
- KwUlRbCb **rbCb));
+ RlcUlRbCb **rbCb));
-EXTERN Void kwDbmFetchUlRbCbFromLchId ARGS ((KwCb *gCb,
+EXTERN Void kwDbmFetchUlRbCbFromLchId ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
CmLteLcId lcId,
- KwUlRbCb **rbCb));
+ RlcUlRbCb **rbCb));
-EXTERN Void kwDbmDelAllUlRb ARGS ((KwCb *gCb,
- KwUlRbCb **rbCbLst,
+EXTERN Void kwDbmDelAllUlRb ARGS ((RlcCb *gCb,
+ RlcUlRbCb **rbCbLst,
U8 numRbCb));
-EXTERN S16 kwDbmAddUlTransaction ARGS((KwCb *gCb, KwUlCfgTmpData *cfg));
+EXTERN S16 kwDbmAddUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
-EXTERN S16 kwDbmFindUlTransaction ARGS((KwCb *gCb,
+EXTERN S16 kwDbmFindUlTransaction ARGS((RlcCb *gCb,
U32 transId,
- KwUlCfgTmpData **cfg));
+ RlcUlCfgTmpData **cfg));
-EXTERN S16 kwDbmDelUlTransaction ARGS((KwCb *gCb, KwUlCfgTmpData *cfg));
+EXTERN S16 kwDbmDelUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
-EXTERN S16 kwDbmDelAllUlTransactions ARGS((KwCb *gCb));
+EXTERN S16 kwDbmDelAllUlTransactions ARGS((RlcCb *gCb));
-EXTERN Void kwDbmUlShutdown ARGS ((KwCb *gCb));
+EXTERN Void kwDbmUlShutdown ARGS ((RlcCb *gCb));
/****************************************************************************
* Transparent Mode Functions
***************************************************************************/
#ifdef CCPU_OPT
-EXTERN PUBLIC Void kwTmmRcvFrmLi ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN PUBLIC Void kwTmmRcvFrmLi ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
CmLteRnti tCrnti,
Buffer *pdu));
#else /* CCPU_OPT */
-EXTERN PUBLIC Void kwTmmRcvFrmLi ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN PUBLIC Void kwTmmRcvFrmLi ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
Buffer *pdu));
#endif /* CCPU_OPT */
-EXTERN Void kwTmmUlReEstablish ARGS ((KwCb *gCb, KwUlRbCb *rbCb));
+EXTERN Void kwTmmUlReEstablish ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
/****************************************************************************
* Unacknowledged Mode Functions
***************************************************************************/
#ifdef LTE_L2_MEAS
-EXTERN Void kwUmmProcessPdus ARGS((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN Void kwUmmProcessPdus ARGS((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
U32 ttiCnt));
#else
-EXTERN Void kwUmmProcessPdus ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN Void kwUmmProcessPdus ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwPduInfo *pduInfo));
#endif
-EXTERN Void kwUmmUlReEstablish ARGS ((KwCb *gCb,
+EXTERN Void kwUmmUlReEstablish ARGS ((RlcCb *gCb,
CmLteRlcId *rlcId,
- KwUlRbCb *rbCb));
+ RlcUlRbCb *rbCb));
-EXTERN Void kwUmmReOrdTmrExp ARGS((KwCb *gCb, KwUlRbCb *rbCb));
+EXTERN Void kwUmmReOrdTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
-EXTERN Void kwUmmFreeUlRbCb ARGS ((KwCb *gCb, KwUlRbCb *rbCb));
+EXTERN Void kwUmmFreeUlRbCb ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
/****************************************************************************
* Acknowledged Mode Functions
***************************************************************************/
-EXTERN Void kwAmmUlReEstablish ARGS((KwCb *gCb,
+EXTERN Void kwAmmUlReEstablish ARGS((RlcCb *gCb,
CmLteRlcId rlcId,
Bool sndReEst,
- KwUlRbCb *rbCb));
+ RlcUlRbCb *rbCb));
#ifdef LTE_L2_MEAS
-EXTERN Void kwAmmProcessPdus ARGS((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN Void kwAmmProcessPdus ARGS((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
U32 ttiCnt));
#else
-EXTERN Void kwAmmProcessPdus ARGS((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN Void kwAmmProcessPdus ARGS((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwPduInfo *pduInfo));
#endif
-EXTERN Void kwAmmReOrdTmrExp ARGS((KwCb *gCb, KwUlRbCb *rbCb));
+EXTERN Void kwAmmReOrdTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
-EXTERN Void kwAmmStaProTmrExp ARGS((KwCb *gCb, KwUlRbCb *rbCb));
+EXTERN Void kwAmmStaProTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
-EXTERN Void kwAmmFreeUlRbCb ARGS ((KwCb *gCb, KwUlRbCb *rbCb));
+EXTERN Void kwAmmFreeUlRbCb ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
/****************************************************************************
* Utility Functions
));
EXTERN Void kwUtlDelRecBuf ARGS ((CmLListCp *recBufLst,
KwAmRecBuf *recBuf,
- KwCb *gCb
+ RlcCb *gCb
));
-EXTERN S16 kwUtlRcvFrmLi ARGS ((KwCb *gCb, KwDatIndInfo *datIndInfo));
+EXTERN S16 kwUtlRcvFrmLi ARGS ((RlcCb *gCb, KwDatIndInfo *datIndInfo));
-EXTERN S16 kwUtlSndDatInd ARGS ((KwCb *gCb,KwUlRbCb *rbCb, Buffer *sdu));
+EXTERN S16 kwUtlSndDatInd ARGS ((RlcCb *gCb,RlcUlRbCb *rbCb, Buffer *sdu));
#ifdef LTE_L2_MEAS
-EXTERN S16 kwUtlHdlL2TmrExp ARGS (( KwCb *gCb, KwL2MeasEvtCb *measEvtCb));
+EXTERN S16 kwUtlHdlL2TmrExp ARGS (( RlcCb *gCb, KwL2MeasEvtCb *measEvtCb));
-EXTERN Void kwUtlCalUlIpThrPutIncTTI ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN Void kwUtlCalUlIpThrPutIncTTI ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
U32 ttiCnt));
-EXTERN Void kwUtlCalUlIpThrPut ARGS((KwCb *gCb,
- KwUlRbCb *rbCb,
+EXTERN Void kwUtlCalUlIpThrPut ARGS((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
Buffer *pdu,
U32 ttiCnt));
-EXTERN S16 kwUtlSndUlL2MeasCfm ARGS ((KwCb *gCb, KwL2MeasEvtCb *measEvtCb));
+EXTERN S16 kwUtlSndUlL2MeasCfm ARGS ((RlcCb *gCb, KwL2MeasEvtCb *measEvtCb));
-EXTERN S16 kwUtlSndUlL2MeasNCfm ARGS ((KwCb *gCb,
+EXTERN S16 kwUtlSndUlL2MeasNCfm ARGS ((RlcCb *gCb,
KwL2MeasReqEvt *measReqEvt,
KwL2MeasCfmEvt *measCfmEvt));
-EXTERN S16 kwUtlL2MeasUlInit ARGS((KwCb *gCb));
+EXTERN S16 kwUtlL2MeasUlInit ARGS((RlcCb *gCb));
-EXTERN Void kwUtlResetUlL2MeasInKwRb ARGS((KwCb *gCb,
+EXTERN Void kwUtlResetUlL2MeasInKwRb ARGS((RlcCb *gCb,
KwL2MeasCb *measCb,
U8 measType));
/****************************************************************************
* Activation Functions
***************************************************************************/
-EXTERN S16 kwUlActvInit ARGS ((Ent ent,
+EXTERN S16 rlcUlActvInit ARGS ((Ent ent,
Inst inst,
Region region,
Reason reason));
-EXTERN S16 kwUlActvTsk ARGS ((Pst *pst, Buffer *mBuf));
+EXTERN S16 rlcUlActvTsk ARGS ((Pst *pst, Buffer *mBuf));
/****************************************************************************
* Debug Functions
#include "kw.x"
#include "kw_ul.x"
#include "kw_udx.x"
+
+#include "du_app_rlc_inf.h"
+
#ifdef TENB_STATS
#include "l2_tenb_stats.x"
#endif
-PUBLIC S16 kwUlInitExt ARGS (( Void ));
+PUBLIC S16 rlcUlInitExt ARGS (( Void ));
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwUlInitExt
+PUBLIC S16 rlcUlInitExt
(
)
#else
-PUBLIC S16 kwUlInitExt()
+PUBLIC S16 rlcUlInitExt()
#endif
{
- TRC2(kwUlInitExt);
+ TRC2(rlcUlInitExt);
RETVALUE(ROK);
} /* kwInitExt */
*
*/
#ifdef ANSI
-PUBLIC S16 kwUlActvInit
+PUBLIC S16 rlcUlActvInit
(
Ent ent, /* entity */
Inst inst, /* instance */
Reason reason /* reason */
)
#else
-PUBLIC S16 kwUlActvInit(ent, inst, region, reason)
+PUBLIC S16 rlcUlActvInit(ent, inst, region, reason)
Ent ent; /* entity */
Inst inst; /* instance */
Region region; /* region */
Reason reason; /* reason */
#endif
{
- KwCb *tKwCb;
- TRC3(kwDlActvInit)
+ RlcCb *tRlcCb;
+ TRC3(rlcUlActvInit)
- if (inst >= KW_MAX_RLC_INSTANCES)
+ if (inst >= MAX_RLC_INSTANCES)
{
/* intance greater than MAX instances */
RETVALUE(RFAILED);
}
- if (kwCb[inst] != NULLP)
+ if (rlcCb[inst] != NULLP)
{
RETVALUE (RFAILED);
}
- if (SGetSBuf(region, 0, (Data **)&tKwCb,
- (Size)sizeof (KwCb)) != ROK)
+ if (SGetSBuf(region, 0, (Data **)&tRlcCb,
+ (Size)sizeof (RlcCb)) != ROK)
{
RETVALUE(RFAILED);
}
- /* Initialize kwCb */
- KW_MEM_SET(tKwCb, 0, sizeof(KwCb));
+ /* Initialize rlcCb */
+ RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
/* Initialize task configuration parameters */
- tKwCb->init.ent = ent; /* entity */
- tKwCb->init.inst = inst; /* instance */
- tKwCb->init.region = region; /* static region */
- tKwCb->init.pool = 0; /* static pool */
- tKwCb->init.reason = reason; /* reason */
- tKwCb->init.cfgDone = FALSE; /* configuration done */
- tKwCb->init.acnt = TRUE; /* enable accounting */
- tKwCb->init.usta = TRUE; /* enable unsolicited status */
- tKwCb->init.trc = FALSE; /* enable trace */
- tKwCb->init.procId = SFndProcId();
-
- kwCb[inst] = tKwCb;
+ tRlcCb->init.ent = ent; /* entity */
+ tRlcCb->init.inst = inst; /* instance */
+ tRlcCb->init.region = region; /* static region */
+ tRlcCb->init.pool = 0; /* static pool */
+ tRlcCb->init.reason = reason; /* reason */
+ tRlcCb->init.cfgDone = FALSE; /* configuration done */
+ tRlcCb->init.acnt = TRUE; /* enable accounting */
+ tRlcCb->init.usta = TRUE; /* enable unsolicited status */
+ tRlcCb->init.trc = FALSE; /* enable trace */
+ tRlcCb->init.procId = SFndProcId();
+
+ rlcCb[inst] = tRlcCb;
/* call external function for intialization */
/*
kwInitExt();
*/
#ifdef TENB_STATS
- TSL2AllocStatsMem(tKwCb->init.region, tKwCb->init.pool);
+ TSL2AllocStatsMem(tRlcCb->init.region, tRlcCb->init.pool);
#endif
RETVALUE(ROK);
-} /* kwActvInit */
+} /* rlcUlActvInit */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwUlActvTsk
+PUBLIC S16 rlcUlActvTsk
(
Pst *pst, /* pst structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 kwUlActvTsk(pst, mBuf)
+PUBLIC S16 rlcUlActvTsk(pst, mBuf)
Pst *pst; /* pst structure */
Buffer *mBuf; /* message buffer */
#endif
#ifdef LCLKW
case LKW_EVT_CFG_REQ:
{
- ret = cmUnpkLkwCfgReq(KwMiLkwCfgReq, pst, mBuf);
+ ret = unpackRlcConfigReq(KwMiRlcConfigReq, pst, mBuf);
break;
}
break;
}
- case RLC_EVT_UE_CREATE_REQ: /* UE Create Request */
+ case EVENT_RLC_UL_UE_CREATE_REQ: /* UE Create Request */
{
- ret = unpackUeCreateReq(RlcDuappProcUeCreateReq, pst, mBuf);
+ ret = unpackRlcUlUeCreateReq(RlcUlProcUeCreateReq, pst, mBuf);
break;
}
#endif /* LCLKW */
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_FATAL,"Received Invalid Event[%d] from SM",
pst->event);
#ifdef LCUDX
case UDX_EVT_BND_CFM: /* Bind request */
{
- ret = cmUnpkUdxBndCfm(KwUlUdxBndCfm, pst, mBuf );
+ ret = cmUnpkUdxBndCfm(rlcUlUdxBndCfm, pst, mBuf );
break;
}
case UDX_EVT_CFG_CFM: /* Unbind request */
{
- ret = cmUnpkUdxCfgCfm(KwUlUdxCfgCfm, pst, mBuf );
+ ret = cmUnpkUdxCfgCfm(rlcUlUdxCfgCfm, pst, mBuf );
break;
}
case UDX_EVT_UEIDCHG_CFM: /* Configuration request */
{
- ret = cmUnpkUdxUeIdChgCfm(KwUlUdxUeIdChgCfm, pst, mBuf);
+ ret = cmUnpkUdxUeIdChgCfm(rlcUlUdxUeIdChgCfm, pst, mBuf);
break;
}
case UDX_EVT_STA_PHBT_TMR_START: /* Status Prohibit Timer Start */
{
- ret = cmUnpkUdxStaProhTmrStart(KwUlUdxStaProhTmrStart, pst, mBuf);
+ ret = cmUnpkUdxStaProhTmrStart(rlcUlUdxStaProhTmrStart, pst, mBuf);
break;
}
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
pst->event);
#endif /* LCKWU */
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
pst->event);
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
pst->event);
default:
SPutMsg(mBuf);
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
pst->event);
{
case KWU_EVT_TTI_IND:
{
- kwUlBatchProc();
+ rlcUlBatchProc();
SPutMsg(mBuf);
break;
}
case TENBSTATSINIT:
{
- KwCb *tKwCb;
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ RlcCb *tRlcCb;
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- TSL2SendStatsToApp(&(tKwCb->genCfg.lmPst), 0);
+ TSL2SendStatsToApp(&(tRlcCb->genCfg.lmPst), 0);
SPutMsg(mBuf);
break;
}
#endif
default:
{
- if (pst->dstInst < KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",pst->event);
}
PRIVATE Void kwUmmEstHdrSz ARGS ((KwUmDl *umUl));
-PRIVATE Void kwUmmCreatePdu ARGS ((KwCb *gCb,
- KwDlRbCb *rbCb,
+PRIVATE Void kwUmmCreatePdu ARGS ((RlcCb *gCb,
+ RlcDlRbCb *rbCb,
Buffer *pdu,
U8 fi,
KwPduInfo *datReqPduInfo));
#ifdef ANSI
PUBLIC Void kwUmmQSdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwuDatReqInfo *datReq,
Buffer *mBuf
)
#else
PUBLIC Void kwUmmQSdu(gCb,rbCb,datReq,mBuf)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwuDatReqInfo *datReq;
Buffer *mBuf;
#endif
KW_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb);
- KW_ALLOC_WC(gCb, sdu, (Size)sizeof(KwSdu));
+ RLC_ALLOC_WC(gCb, sdu, (Size)sizeof(KwSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
kwUmmEstHdrSz(&rbCb->m.umDl);
- if(!kwDlUtlIsReestInProgress(rbCb))
+ if(!rlcDlUtlIsReestInProgress(rbCb))
{
kwUtlSndDStaRsp(gCb,rbCb,rbCb->m.umDl.bo,rbCb->m.umDl.estHdrSz,FALSE,0);
}
if((rbCb->rbL2Cb.measOn & LKW_L2MEAS_ACT_UE) &&
(rbCb->ueCb->numActRb[rbCb->qci]++ == 0))
{
- kwCb.kwL2Cb.numActUe[rbCb->qci]++;
+ rlcCb.kwL2Cb.numActUe[rbCb->qci]++;
}
#endif
#ifdef ANSI
PUBLIC Void kwUmmProcessSdus
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwDatReq *datReq
)
#else
PUBLIC Void kwUmmProcessSdus(gCb, rbCb, datReq)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwDatReq *datReq;
#endif
{
else
{
SCatMsg(pdu, sdu->mBuf, M1M2);
- KW_FREE_BUF_WC(sdu->mBuf);
+ RLC_FREE_BUF_WC(sdu->mBuf);
}
sdu->sduSz -= pduSz;
{
if(--(rbCb->ueCb->numActRb[rbCb->qci]) == 0)
{
- kwCb.kwL2Cb.numActUe[rbCb->qci]--;
+ rlcCb.kwL2Cb.numActUe[rbCb->qci]--;
}
}
#endif /* LTE_L2_MEAS */
}
else
{
- KW_FREE_BUF_WC(pdu);
+ RLC_FREE_BUF_WC(pdu);
}
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDlUmmReEstablish
+PUBLIC Void rlcDlUmmReEstablish
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRlcId rlcId,
Bool sendReEst,
-KwDlRbCb *rbCb
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwDlUmmReEstablish(gCb, rlcId, rbCb)
-KwCb *gCb;
+PUBLIC Void rlcDlUmmReEstablish(gCb, rlcId, rbCb)
+RlcCb *gCb;
CmLteRlcId rlcId;
Bool sendReEst;
-KwDlRbCb *rbCb;
+RlcDlRbCb *rbCb;
#endif
{
/* The re-establishment indication is sent from the UL only */
- TRC2(kwDlUmmReEstablish)
+ TRC2(rlcDlUmmReEstablish)
kwUmmFreeDlRbCb(gCb, rbCb);
/* this would have been set when re-establishment was triggered
for SRB 1 */
- kwDlUtlResetReestInProgress(rbCb);
+ rlcDlUtlResetReestInProgress(rbCb);
RETVOID;
}
#ifdef ANSI
PRIVATE Void kwUmmCreatePdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
Buffer *pdu,
U8 fi,
KwPduInfo *datReqPduInfo
)
#else
PRIVATE Void kwUmmCreatePdu(gCb, rbCb, pdu, fi, datReqPduInfo)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
Buffer *pdu;
U8 fi;
KwPduInfo *datReqPduInfo
#ifdef ANSI
PUBLIC Void kwUmmDiscSdu
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
U32 sduId
)
#else
PUBLIC Void kwUmmDiscSdu(gCb,rbCb,sduId)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
U32 sduId;
#endif
{
#ifdef ANSI
PUBLIC Void kwUmmFreeDlRbCb
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
PUBLIC Void kwUmmFreeDlRbCb(gCb,rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
TRC2(kwUmmFreeDlRbCb)
#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_UL)
-PRIVATE S16 kwUmmExtractHdr ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE S16 kwUmmExtractHdr ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
Buffer *pdu,
KwUmHdr *umHdr));
-PRIVATE Void kwUmmReAssembleSdus ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE Void kwUmmReAssembleSdus ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwUmRecBuf *umRecBuf));
#ifndef TENB_ACC
#ifdef ANSI
PUBLIC Void kwUmmProcessPdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb, /* Rb Control Block */
+RlcCb *gCb,
+RlcUlRbCb *rbCb, /* Rb Control Block */
KwPduInfo *pduInfo, /* Pdu data and related information */
U32 ttiCnt /* ttiCnt received from MAC */
)
#else
PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo,ttiCnt)
-KwCb *gCb;
-KwUlRbCb *rbCb; /* Rb Control Block */
+RlcCb *gCb;
+RlcUlRbCb *rbCb; /* Rb Control Block */
KwPduInfo *pduInfo; /* Pdu data and related information */
U32 ttiCnt; /* ttiCnt received from MAC */
#endif
#ifdef ANSI
PUBLIC Void kwUmmProcessPdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb, /* Rb Control Block */
+RlcCb *gCb,
+RlcUlRbCb *rbCb, /* Rb Control Block */
KwPduInfo *pduInfo /* Pdu data and related information */
)
#else
PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo)
-KwCb *gCb;
-KwUlRbCb *rbCb; /* Rb Control Block */
+RlcCb *gCb;
+RlcUlRbCb *rbCb; /* Rb Control Block */
KwPduInfo *pduInfo; /* Pdu data and related information */
#endif
#endif
#endif
#endif
/* create a buffer to be later inserted into the reception buffer */
- KW_ALLOC_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tmpRecBuf == NULLP)
{
#ifndef LTE_PAL_ENB
/* Changed the condition to TRUE from ROK */
#ifndef XEON_SPECIFIC_CHANGES
- if(isMemThreshReached(kwCb[0]->init.region) == TRUE)
+ if(isMemThreshReached(rlcCb[0]->init.region) == TRUE)
{
extern U32 rlculdrop;
rlculdrop++;
- KW_FREE_BUF(pdu);
- KW_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_BUF(pdu);
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
/*Fix for CR ccpu00144030: If threshhold is hit then also count
*should be incrmented */
count++;
/* Header extraction is a problem.
* log an error and free the allocated memory */
/* ccpu00136940 */
- KW_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
SPutMsg(pdu);
count++;
/* kw005.201 ccpu00117318, updating the statistics */
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
- KW_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_BUF(pdu);
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
count++;
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.unexpPdusRecv++;
if (recBuf[sn])
{
kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
- KW_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
recBuf[sn] = NULLP;
}
sn = (sn + 1) & KW_UMUL.modBitMask;
while (recBuf[sn] && tSn < tVrUr)
{
kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
- KW_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
recBuf[sn] = NULLP;
sn = (sn + 1) & KW_UMUL.modBitMask;
tSn = KW_UM_GET_VALUE(sn, KW_UMUL);
#ifdef ANSI
PRIVATE Void kwUmmReAssembleSdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwUmRecBuf *umRecBuf
)
#else
PRIVATE Void kwUmmReAssembleSdus(gCb,rbCb,umRecBuf)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwUmRecBuf *umRecBuf;
#endif
{
(sn == ((rbCb->m.umUl.sn + 1) & rbCb->m.umUl.modBitMask)))
{
SCatMsg(*partialSdu,sdu,M1M2);
- KW_FREE_BUF(sdu);
+ RLC_FREE_BUF(sdu);
if (liCount > 0 || !(fi & 1))
{
kwUtlSndDatInd(gCb,rbCb,*partialSdu);
/* Partial Sdu stored is not valid now.So free it */
if (*partialSdu)
{
- KW_FREE_BUF(*partialSdu);
+ RLC_FREE_BUF(*partialSdu);
*partialSdu = NULLP;
}
- KW_FREE_BUF(sdu);
+ RLC_FREE_BUF(sdu);
sdu = NULLP;
}
}
{
if (*partialSdu)
{
- KW_FREE_BUF(*partialSdu); /* RLC mem leak fix */
+ RLC_FREE_BUF(*partialSdu); /* RLC mem leak fix */
*partialSdu = NULLP;
}
#ifdef ANSI
PUBLIC Void kwUmmUlReEstablish
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRlcId *rlcId,
-KwUlRbCb *rbCb
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwUmmUlReEstablish(gCb, rlcId, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRlcId *rlcId;
-KwUlRbCb *rbCb;
+RlcUlRbCb *rbCb;
#endif
{
KwSn curSn;
if ( recBuf[curSn] != NULLP )
{
kwUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
- KW_FREE_WC(gCb,recBuf[curSn],sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb,recBuf[curSn],sizeof(KwUmRecBuf));
recBuf[curSn] = NULLP;
}
curSn = (curSn + 1) & rbCb->m.umUl.modBitMask;
#ifdef ANSI
PRIVATE S16 kwUmmExtractHdr
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *pdu,
KwUmHdr *umHdr
)
#else
PRIVATE S16 kwUmmExtractHdr(gCb, rbCb, pdu, umHdr)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *pdu;
KwUmHdr *umHdr;
#endif
#ifdef ANSI
PUBLIC Void kwUmmReOrdTmrExp
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwUmmReOrdTmrExp(gCb, rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwSn prevVrUr; /* prevVrUr */
kwUmmReAssembleSdus(gCb, rbCb, KW_UMUL.recBuf[prevVrUr]);
if(KW_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
{
- KW_FREE_BUF(KW_UMUL.recBuf[prevVrUr]->pdu);
+ RLC_FREE_BUF(KW_UMUL.recBuf[prevVrUr]->pdu);
}
- KW_FREE_WC(gCb, KW_UMUL.recBuf[prevVrUr], sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, KW_UMUL.recBuf[prevVrUr], sizeof(KwUmRecBuf));
KW_UMUL.recBuf[prevVrUr] = NULLP;
}
#ifdef ANSI
PUBLIC Void kwUmmFreeUlRbCb
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwUmmFreeUlRbCb(gCb,rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwSn curSn = 0; /* sequence number of PDU */
{
if (umRecBuf[curSn] != NULLP)
{
- KW_FREE_BUF_WC(umRecBuf[curSn]->pdu);
+ RLC_FREE_BUF_WC(umRecBuf[curSn]->pdu);
umRecBuf[curSn]->pdu = NULLP;
- KW_FREE_WC(gCb, umRecBuf[curSn], sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, umRecBuf[curSn], sizeof(KwUmRecBuf));
umRecBuf[curSn] = NULLP;
}
curSn++;
}
- KW_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(KwUmRecBuf*));
+ RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(KwUmRecBuf*));
rbCb->m.umUl.recBuf = NULLP;
RETVOID;
}
#endif
Void ResetRLCStats(Void)
{
- KwCb* dlInst = kwCb[1];
- KwCb* ulInst = kwCb[0];
+ RlcCb* dlInst = rlcCb[1];
+ RlcCb* ulInst = rlcCb[0];
cmMemset((U8*)&gRlcStats, 0, sizeof(RLCStats));
cmMemset((U8*)&dlInst->genSts,0,sizeof(KwGenSts));
cmMemset((U8*)&ulInst->genSts,0,sizeof(KwGenSts));
#ifndef ALIGN_64BIT
Void PrintRLCStats(Void)
{
- KwCb* dlInst = kwCb[1];
- KwCb* ulInst = kwCb[0];
+ RlcCb* dlInst = rlcCb[1];
+ RlcCb* ulInst = rlcCb[0];
RLOG4(L_ALWAYS,"RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
dlInst->genSts.pdusSent,
#else
Void PrintRLCStats(Void)
{
- KwCb* dlInst = kwCb[1];
- KwCb* ulInst = kwCb[0];
+ RlcCb* dlInst = rlcCb[1];
+ RlcCb* ulInst = rlcCb[0];
printf ("\n================================ RLC STATS ===========================\n");
RLOG4(L_ALWAYS,"RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
TRC3(KwLiRguDDatReq)
dlData = NULLP;
- KW_ALLOC_SHRABL_BUF(post->region, post->pool,
+ RLC_ALLOC_SHRABL_BUF(post->region, post->pool,
dlData, sizeof(RlcMacData));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( datReqInfo == NULLP )
/* Check if to be freed here */
- KW_FREE_SHRABL_BUF(post->region,
+ RLC_FREE_SHRABL_BUF(post->region,
post->pool,
datReqInfo, sizeof(RguDDatReqInfo));
#ifdef ANSI
PUBLIC S16 kwUtlSndToLi
(
-KwCb *gCb,
+RlcCb *gCb,
SuId suId,
KwDStaIndInfo *staIndInfo
)
#else
PUBLIC S16 kwUtlSndToLi(gCb, suId, staIndInfo)
-KwCb *gCb;
+RlcCb *gCb;
SuId suId;
KwDStaIndInfo *staIndInfo;
#endif
{
- KwDlUeCb *ueCb; /* UE control block */
+ RlcDlUeCb *ueCb; /* UE control block */
U32 count; /* Loop Counter */
U32 numTb; /* Number of Tbs */
- KwDlRbCb *rbCb; /* RB Control Block */
+ RlcDlRbCb *rbCb; /* RB Control Block */
KwDatReq datReq; /* PDUs Information */
RguDDatReqInfo *datReqInfo; /* Data Request Information */
KwRguSapCb *rguSap; /* MAC SAP CB */
datReqInfo = NULLP;
- KW_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap->pst.region,
+ RLC_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap->pst.region,
gCb->u.dlCb->rguDlSap->pst.pool,
datReqInfo,sizeof(RguDDatReqInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
rbCb = ueCb->lCh[staIndTb->lchStaInd[count].lcId - 1].dlRbCb;
- if (rbCb && (!kwDlUtlIsReestInProgress(rbCb)))
+ if (rbCb && (!rlcDlUtlIsReestInProgress(rbCb)))
{
//Debug
staIndSz += staIndTb->lchStaInd[count].totBufSize;
#ifdef LTE_L2_MEAS_LOSS_DELAY
if(tbSnMap->numSn == 0)
{
- KW_FREE(tbSnMap,sizeof(KwTbSnMap));
- KW_FREE(datReqTb->rguSnInfo,sizeof(RguSnMapInfo));
+ RLC_FREE(tbSnMap,sizeof(KwTbSnMap));
+ RLC_FREE(datReqTb->rguSnInfo,sizeof(RguSnMapInfo));
datReqTb->rguSnInfo = NULLP;
- kwCb.kwL2Cb.curTbSnMap = NULLP;
+ rlcCb.kwL2Cb.curTbSnMap = NULLP;
datReqTb->snMapPres = FALSE;
}
else
{
- cmHashListInsert(&(kwCb.kwL2Cb.tbHlCp),(PTR)tbSnMap,
+ cmHashListInsert(&(rlcCb.kwL2Cb.tbHlCp),(PTR)tbSnMap,
(U8 *) &(tbSnMap->tbId), (U16)sizeof(tbSnMap->tbId));
- kwCb.kwL2Cb.curTbSnMap = NULLP;
+ rlcCb.kwL2Cb.curTbSnMap = NULLP;
}
#endif /* LTE_L2_MEAS */
}
#ifdef ANSI
PUBLIC S16 kwUtlSndDStaRsp
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
S32 bo,
S32 estHdrSz,
Bool staPduPrsnt,
)
#else
PUBLIC S16 kwUtlSndDStaRsp(gCb,rbCb,bo,estHdrSz,staPduPrsnt,staPduBo)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
S32 bo;
S32 estHdrSz;
Bool staPduPrsnt;
#ifdef ANSI
PUBLIC Void kwUtlEmptySduQ
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
CmLListCp *sduQ
)
#else
PUBLIC Void kwUtlEmptySduQ(gCb,rbCb, sduQ)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
CmLListCp *sduQ;
#endif
#else
#ifdef ANSI
PUBLIC Void kwUtlEmptySduQ
(
-KwCb *gCb,
+RlcCb *gCb,
CmLListCp *sduQ
)
#else
PUBLIC Void kwUtlEmptySduQ(gCb,sduQ)
-KwCb *gCb;
+RlcCb *gCb;
CmLListCp *sduQ;
#endif
#endif
if(sduSnMap != NULLP)
{
cmLListDelFrm(&(rbCb->sduSnMapQ), &(sduSnMap->lstEnt));
- KW_FREE(sduSnMap, sizeof(KwSduSnMap));
+ RLC_FREE(sduSnMap, sizeof(KwSduSnMap));
CM_LLIST_FIRST_NODE(sduSnMapQ, firstSduSnMap);
}
else
#ifdef ANSI
PUBLIC Void kwUtlCalcLiForSdu
(
-KwCb *gCb,
+RlcCb *gCb,
U16 numLi,
MsgLen msgLen,
S16 *pduSz
)
#else
PUBLIC Void kwUtlCalcLiForSdu(gCb,numLi,msgLen,pduSz)
-KwCb *gCb;
+RlcCb *gCb;
U16 numLi;
MsgLen msgLen;
S16 *pduSz;
* @return void
*/
#ifdef ANSI
-PUBLIC Void kwDlUtlSetReestInProgressForRB
+PUBLIC Void rlcDlUtlSetReestInProgressForRB
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwDlUtlSetReestInProgressForRB(gCb,rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+PUBLIC Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwDlUtlSetReestInProgressForRB)
+ TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = TRUE;
* FALSE : Re-establishment is not in progress
*/
#ifdef ANSI
-PUBLIC Bool kwDlUtlIsReestInProgress
+PUBLIC Bool rlcDlUtlIsReestInProgress
(
-KwDlRbCb *rbCb
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Bool kwDlUtlIsReestInProgress(rbCb)
-KwDlRbCb *rbCb;
+PUBLIC Bool rlcDlUtlIsReestInProgress(rbCb)
+RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwDlUtlSetReestInProgressForRB)
+ TRC2(rlcDlUtlSetReestInProgressForRB)
RETVALUE(rbCb->reestInProgress);
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDlUtlResetReestInProgress
+PUBLIC Void rlcDlUtlResetReestInProgress
(
-KwDlRbCb *rbCb
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwDlUtlResetReestInProgress(rbCb)
-KwDlRbCb *rbCb;
+PUBLIC Void rlcDlUtlResetReestInProgress(rbCb)
+RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwDlUtlSetReestInProgressForRB)
+ TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = FALSE;
}
* @return void
*/
#ifdef ANSI
-PUBLIC Void kwDlUtlSetReestInProgressForAllRBs
+PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs
(
-KwCb *gCb,
-KwDlUeCb *ueCb
+RlcCb *gCb,
+RlcDlUeCb *ueCb
)
#else
-PUBLIC Void kwDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
-KwCb *gCb;
-KwDlUeCb *ueCb;
+PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
+RlcCb *gCb;
+RlcDlUeCb *ueCb;
#endif
{
U32 rbIdx;
- TRC2(kwDlUtlSetReestInProgressForAllRBs)
+ TRC2(rlcDlUtlSetReestInProgressForAllRBs)
for(rbIdx = 0;rbIdx < KW_MAX_SRB_PER_UE;rbIdx++)
{
{
if(ueCb->srbCb[rbIdx]->rlcId.rbId != 1)
{
- kwDlUtlSetReestInProgressForRB(gCb,ueCb->srbCb[rbIdx]);
+ rlcDlUtlSetReestInProgressForRB(gCb,ueCb->srbCb[rbIdx]);
}
else
{
{
if(ueCb->drbCb[rbIdx] != NULLP)
{
- kwDlUtlSetReestInProgressForRB(gCb,ueCb->drbCb[rbIdx]);
+ rlcDlUtlSetReestInProgressForRB(gCb,ueCb->drbCb[rbIdx]);
}
}
#ifdef ANSI
PUBLIC Void kwUtlInitToBeFreed
(
-KwCb *gCb,
-KwDlDataToBeFreed *toBeFreed
+RlcCb *gCb,
+RlcDlDataToBeFreed *toBeFreed
)
#else
PUBLIC Void kwUtlInitToBeFreed(gCb, toBeFreed)
-KwCb *gCb;
-KwDlDataToBeFreed *toBeFreed;
+RlcCb *gCb;
+RlcDlDataToBeFreed *toBeFreed;
#endif
{
cmLListInit(&(toBeFreed->sduLst));
#ifdef ANSI
PUBLIC Void kwUtlInitializeSelfPst
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlInitializeSelfPst(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
Pst *selfPst = &gCb->u.dlCb->selfPst;
- KW_MEM_SET(selfPst, 0, sizeof(Pst));
+ RLC_MEM_SET(selfPst, 0, sizeof(Pst));
selfPst->srcProcId = SFndProcId();
selfPst->dstProcId = SFndProcId();
selfPst->dstEnt = gCb->init.ent;
#ifdef ANSI
PUBLIC Void kwUtlRaiseDlCleanupEvent
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlRaiseDlCleanupEvent(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
#ifdef KWSELFPSTDLCLEAN
#ifdef ANSI
PUBLIC Void kwUtlAddSduToBeFreedQueue
(
-KwCb *gCb,
+RlcCb *gCb,
KwSdu *sdu
)
#else
PUBLIC Void kwUtlAddSduToBeFreedQueue(gCb, sdu)
-KwCb *gCb;
+RlcCb *gCb;
KwSdu *sdu;
#endif
{
#ifdef ANSI
PUBLIC Void kwUtlAddReTxPduToBeFreedQueue
(
-KwCb *gCb,
+RlcCb *gCb,
KwRetx *retx
)
#else
PUBLIC Void kwUtlAddReTxPduToBeFreedQueue(gCb, retx)
-KwCb *gCb;
+RlcCb *gCb;
KwRetx *retx;
#endif
{
#ifdef ANSI
PUBLIC Void kwUtlAddTxPduToBeFreedQueue
(
-KwCb *gCb,
+RlcCb *gCb,
KwTx *pdu
)
#else
PUBLIC Void kwUtlAddTxPduToBeFreedQueue(gCb, pdu)
-KwCb *gCb;
+RlcCb *gCb;
KwTx *pdu;
#endif
{
#ifdef ANSI
PRIVATE Bool kwUtlFreeDlAmRbMemory
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
U32 *toBeFreed
)
#else
PRIVATE Bool kwUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
U32 *toBeFreed
#endif
{
{
while(txBuf->pduLst.first)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(txBuf->pduLst.first->node);
- KW_FREE_BUF(pduInfo->pdu);
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node);
+ RLC_FREE_BUF(pduInfo->pdu);
/* Delete node from the txBuf Pdu lst */
cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
- KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo));
+ RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
kwUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
if(gCb->u.dlCb->shutdownReceived == 0)
}
#ifndef LTE_TDD
- KW_FREE(gCb,AMDL.txBufLst, (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE(gCb,AMDL.txBufLst, (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
#endif
KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
while (retx && (*toBeFreed)) /* Till to be freed becomes 0 */
{
- KW_FREE_BUF(retx->seg);
+ RLC_FREE_BUF(retx->seg);
cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
- KW_FREE_WC(gCb, retx, sizeof(KwRetx));
+ RLC_FREE_WC(gCb, retx, sizeof(KwRetx));
KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
if(gCb->u.dlCb->shutdownReceived == 0)
{
Pst *udxPst;
udxPst = &gCb->u.dlCb->udxDlSap->pst;
- KW_FREE_SHRABL_BUF_WC(udxPst->region,
+ RLC_FREE_SHRABL_BUF_WC(udxPst->region,
udxPst->pool,
AMDL.pStaPdu,
sizeof(KwUdxDlStaPdu));
#ifdef ANSI
PUBLIC Void kwUtlFreeDlMemory
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlFreeDlMemory(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
U32 toBeFreed;
RETVOID;
}
- KwDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed;
+ RlcDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed;
/* ccpu00136940 */
if(gCb->u.dlCb->shutdownReceived)
{
{
KwRetx* seg = (KwRetx *)(lst->first->node);
cmLListDelFrm(lst, lst->first);
- KW_FREE_BUF_WC(seg->seg);
- KW_FREE_WC(gCb,seg, sizeof(KwRetx));
+ RLC_FREE_BUF_WC(seg->seg);
+ RLC_FREE_WC(gCb,seg, sizeof(KwRetx));
toBeFreed--;
}
cmLListDelFrm(lst, lst->first);
while(pdu->pduLst.first)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(pdu->pduLst.first->node);
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pdu->pduLst.first->node);
cmLListDelFrm(&pdu->pduLst, pdu->pduLst.first);
- KW_FREE_BUF_WC(pduInfo->pdu);
- KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo));
+ RLC_FREE_BUF_WC(pduInfo->pdu);
+ RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
- KW_FREE_WC(gCb,pdu, sizeof(KwTx));
+ RLC_FREE_WC(gCb,pdu, sizeof(KwTx));
toBeFreed--;
}
while((lst->first) && toBeFreed)
#endif
{
- KwDlRbCb* rbCb = (KwDlRbCb *)(lst->first->node);
+ RlcDlRbCb* rbCb = (RlcDlRbCb *)(lst->first->node);
Bool moreToBeFreed = kwUtlFreeDlAmRbMemory(gCb, rbCb,&toBeFreed);
if(!moreToBeFreed)
{
cmLListDelFrm(lst, lst->first);
- KW_FREE_WC(gCb, rbCb, sizeof(KwDlRbCb));
+ RLC_FREE_WC(gCb, rbCb, sizeof(RlcDlRbCb));
}
}
* @return Void
*
*/
-S16 kwUtlL2MeasDlInit(KwCb *gCb)
+S16 kwUtlL2MeasDlInit(RlcCb *gCb)
{
U16 cntr;
#ifdef ANSI
PUBLIC Void kwUtlUpdateBurstSdus
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwContSduLst *contSduLst,
S32 dataVol,
U32 schPduSz
)
#else
PUBLIC Void kwUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwContSduLst *contSduLst;
S32 dataVol;
U32 schPduSz;
#ifdef ANSI
PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb(gCb, rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
KwL2MeasTb *curL2MeasTb;
if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
{
- /* Intentionally avoiding the KW_ALLOC macro to avoid memset */
+ /* Intentionally avoiding the RLC_ALLOC macro to avoid memset */
if (SGetSBuf(gCb->init.region,
gCb->init.pool,
(Data **)&curL2MeasTb,
#ifdef ANSI
PUBLIC S16 kwUtlProcHarqInd
(
-KwCb *gCb,
+RlcCb *gCb,
RguHarqStatusInd *hqStaInd,
-KwDlUeCb *ueCb,
+RlcDlUeCb *ueCb,
U8 tbIdx
)
#else
PUBLIC S16 kwUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
-KwCb *gCb;
+RlcCb *gCb;
RguHarqStatusInd *hqStaInd;
-KwDlUeCb *ueCb;
+RlcDlUeCb *ueCb;
U8 tbIdx;
#endif
{
#ifdef LTE_L2_MEAS
- KwDlRbCb *kwRbCb; /* KW Control Block */
+ RlcDlRbCb *kwRbCb; /* KW Control Block */
KwL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
U8 lcIdx; /* Logical channel id index */
U8 sduIndx; /* sdu index to out standing sdu list in rbCb */
}
}
/* Free this tb, deallocate the memory */
- KW_FREE(gCb, l2MeasTb, sizeof(KwL2MeasTb));
+ RLC_FREE(gCb, l2MeasTb, sizeof(KwL2MeasTb));
ueCb->l2MeasTbCb[hqStaInd->tbId[tbIdx]] = NULLP;
/*stopping Task*/
#ifdef ANSI
PUBLIC S16 kwUtlSndDlL2MeasCfm
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasEvtCb *measEvtCb
)
#else
PUBLIC S16 kwUtlSndDlL2MeasCfm(gCb, measEvtCb)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasEvtCb *measEvtCb;
#endif
{
#ifdef ANSI
PUBLIC S16 kwUtlSndDlL2MeasNCfm
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasReqEvt *measReqEvt,
KwL2MeasCfmEvt *measCfmEvt
)
#else
PUBLIC S16 kwUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasReqEvt *measReqEvt;
KwL2MeasCfmEvt *measCfmEvt;
#endif
PUBLIC Void kwUtlResetDlL2MeasInKwRb
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasCb *measCb,
U8 measType
)
#else
PUBLIC Void kwUtlResetDlL2MeasInKwRb(gCb, measCb, measType)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasCb *measCb;
U8 measType;
#endif
{
U32 ueIdx;
U32 qciIdx;
- KwDlUeCb *ueCb = NULL;
+ RlcDlUeCb *ueCb = NULL;
} /* kwUtlResetDlL2MeasInKwRb */
#endif
-PRIVATE Void dumpRLCDlRbInformation(KwDlRbCb* dlRbCb)
+PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
{
if(dlRbCb->mode == CM_LTE_MODE_UM)
{
Void DumpRLCDlDebugInformation(Void)
{
- KwCb* dlInst = kwCb[1]; /* TODO : Check whether DL is 0 or 1 */
+ RlcCb* dlInst = rlcCb[1]; /* TODO : Check whether DL is 0 or 1 */
- KwDlCb *dlCb = dlInst->u.dlCb;
+ RlcDlCb *dlCb = dlInst->u.dlCb;
- KwDlUeCb *ueCb = NULLP;
+ RlcDlUeCb *ueCb = NULLP;
RTLIN_DUMP_DEBUG("RLC Information\n");
RTLIN_DUMP_DEBUG("===============\n");
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
U32 i;
for(i = 0; i< KW_MAX_SRB_PER_UE; i++)
{
- KwDlRbCb* dlRbCb = ueCb->srbCb[i];
+ RlcDlRbCb* dlRbCb = ueCb->srbCb[i];
if( dlRbCb != NULLP)
{
dumpRLCDlRbInformation(dlRbCb);
}
for(i = 0; i< KW_MAX_DRB_PER_UE; i++)
{
- KwDlRbCb* dlRbCb = ueCb->drbCb[i];
+ RlcDlRbCb* dlRbCb = ueCb->drbCb[i];
if( dlRbCb != NULLP)
{
dumpRLCDlRbInformation(dlRbCb);
}
}
- KwDlDataToBeFreed* pToBeFreed = &dlCb->toBeFreed;
+ RlcDlDataToBeFreed* pToBeFreed = &dlCb->toBeFreed;
RTLIN_DUMP_DEBUG("toBeFreed RETX list size = %d\n",(int)pToBeFreed->reTxLst.count);
RTLIN_DUMP_DEBUG("toBeFreed TX list size = %d\n",(int)pToBeFreed->txLst.count);
Void;
#endif
{
- kwUtlFreeDlMemory(KW_GET_KWCB(KW_DL_INST));
+ kwUtlFreeDlMemory(RLC_GET_RLCCB(KW_DL_INST));
}
/**
#ifdef ANSI
PUBLIC Void kwUtlTrigPdbFlowCntrl
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
U32 pktAdmitCnt
)
#else
PUBLIC Void kwUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
U32 pktAdmitCnt;
#endif
{
kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
- KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
+ RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
kwuSap->pst.pool,
flowCntrlInfo,
sizeof(KwuFlowCntrlIndInfo));
(
CmLListCp *txBufLst,
KwTx *txBuf,
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlDelTxBuf(txBufLst, txBuf, gCb)
CmLListCp *txBufLst;
KwTx *txBuf;
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
U32 hashKey;
txBufLstCp = &txBufLst[hashKey];
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
- KW_FREE_WC(gCb, txBuf, sizeof(KwTx));
+ RLC_FREE_WC(gCb, txBuf, sizeof(KwTx));
RETVOID;
} /* kwUtlDelTxBuf */
(
CmLListCp *txBufLst,
KwTx *txBuf,
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlRemovTxBuf(txBufLst, txBuf, gCb)
CmLListCp *txBufLst;
KwTx *txBuf;
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
U32 hashKey;
#ifdef ANSI
PUBLIC S16 kwUtlRcvFrmLi
(
-KwCb *gCb,
+RlcCb *gCb,
KwDatIndInfo *datIndInfo
)
#else
PUBLIC S16 kwUtlRcvFrmLi(gCb,datIndInfo)
-KwCb *gCb;
+RlcCb *gCb;
KwDatIndInfo *datIndInfo;
#endif
{
U32 count; /* Loop Counter */
KwPduInfo *pduInfo; /* PDU Information */
- KwUlRbCb *rbCb; /* RB Control Block */
- KwUlUeCb *ueCb; /* UE Control Block */
+ RlcUlRbCb *rbCb; /* RB Control Block */
+ RlcUlUeCb *ueCb; /* UE Control Block */
/* kw005.201 added support for L2 Measurement */
TRC2(kwUtlRcvFrmLi)
{
if(datIndInfo->lchData[i].pdu.mBuf[j])
{
- KW_FREE_BUF_WC(datIndInfo->lchData[i].pdu.mBuf[j]);
+ RLC_FREE_BUF_WC(datIndInfo->lchData[i].pdu.mBuf[j]);
}
}
}
{
if(pduInfo->mBuf[j])
{
- KW_FREE_BUF_WC(pduInfo->mBuf[j]);
+ RLC_FREE_BUF_WC(pduInfo->mBuf[j]);
}
}
continue;
#ifdef ANSI
PUBLIC S16 kwUtlSndDatInd
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *sdu
)
#else
PUBLIC S16 kwUtlSndDatInd(gCb,rbCb,sdu)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *sdu;
#endif
{
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(sdu);
+ RLC_FREE_BUF(sdu);
RETVALUE(RFAILED);
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
} /* kwUtlSndDatInd */
-PRIVATE Void dumpRLCUlRbInformation(KwUlRbCb* ulRbCb)
+PRIVATE Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
{
if(ulRbCb->mode == CM_LTE_MODE_UM)
{
Void DumpRLCUlDebugInformation(Void)
{
- KwCb* ulInst = kwCb[0]; /* TODO : Check whether UL is 0 or 1 */
- KwUlCb* ulCb = ulInst->u.ulCb;
- KwUlUeCb *ueCb = NULLP;
+ RlcCb* ulInst = rlcCb[0]; /* TODO : Check whether UL is 0 or 1 */
+ RlcUlCb* ulCb = ulInst->u.ulCb;
+ RlcUlUeCb *ueCb = NULLP;
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
while (ROK == cmHashListGetNext(&ulCb->ueLstCp,
U32 i;
for(i = 0; i< KW_MAX_SRB_PER_UE; i++)
{
- KwUlRbCb* ulRbCb = ueCb->srbCb[i];
+ RlcUlRbCb* ulRbCb = ueCb->srbCb[i];
if(ulRbCb != NULLP)
{
dumpRLCUlRbInformation(ulRbCb);
}
for(i = 0; i< KW_MAX_DRB_PER_UE; i++)
{
- KwUlRbCb* ulRbCb = ueCb->drbCb[i];
+ RlcUlRbCb* ulRbCb = ueCb->drbCb[i];
if(ulRbCb != NULLP)
{
dumpRLCUlRbInformation(ulRbCb);
* @return S16
* -# ROK
*/
-S16 kwUtlL2MeasUlInit(KwCb *gCb)
+S16 kwUtlL2MeasUlInit(RlcCb *gCb)
{
U16 cntr;
#ifdef ANSI
PUBLIC Void kwUtlCalUlIpThrPutIncTTI
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
U32 ttiCnt
)
#else
PUBLIC Void kwUtlCalUlIpThrPutIncTTI(gCb, rbCb, ttiCnt)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
U32 ttiCnt;
#endif
{
#ifdef ANSI
PUBLIC Void kwUtlCalUlIpThrPut
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *pdu,
U32 ttiCnt
)
#else
PUBLIC Void kwUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt)
- KwCb *gCb;
- KwUlRbCb *rbCb;
+ RlcCb *gCb;
+ RlcUlRbCb *rbCb;
Buffer *pdu;
U32 ttiCnt;
#endif
#ifdef ANSI
PUBLIC S16 kwUtlHdlL2TmrExp
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasEvtCb *measEvtCb
)
#else
PUBLIC S16 kwUtlHdlL2TmrExp(measEvtCb)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasEvtCb *measEvtCb;
#endif
{
for(qciIdx = 0; qciIdx < measCb->val.nonIpThMeas.numQci;qciIdx++)
{
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.numActvUe +=
- kwCb.kwL2Cb.numActUe[measCb->val.nonIpThMeas.qci[qciIdx]];
+ rlcCb.kwL2Cb.numActUe[measCb->val.nonIpThMeas.qci[qciIdx]];
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.sampOc++;
}
measEvtCb->val.nonIpThMeas.measCb.numSamples--;
#ifdef ANSI
PUBLIC S16 kwUtlSndUlL2MeasCfm
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasEvtCb *measEvtCb
)
#else
PUBLIC S16 kwUtlSndUlL2MeasCfm(gCb, measEvtCb)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasEvtCb *measEvtCb;
#endif
{
#ifdef ANSI
PUBLIC S16 kwUtlSndUlL2MeasNCfm
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasReqEvt *measReqEvt,
KwL2MeasCfmEvt *measCfmEvt
)
#else
PUBLIC S16 kwUtlSndUlL2MeasNCfm(gCb, measReqEvt, measCfmEvt)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasReqEvt *measReqEvt;
KwL2MeasCfmEvt *measCfmEvt;
#endif
}
/* Check for total maximum number of Measurement Control Block */
- if(kwCb.kwL2Cb.kwNumMeas >= LKW_MAX_L2MEAS )
+ if(rlcCb.kwL2Cb.kwNumMeas >= LKW_MAX_L2MEAS )
{
measCfmEvt->transId = measReqEvt->transId;
measCfmEvt->measType = measType;
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
qci = qciVal[qciIdx];
- ret = cmHashListFind(&(kwCb.kwL2Cb.qciHlCp),
+ ret = cmHashListFind(&(rlcCb.kwL2Cb.qciHlCp),
(U8 *)&qci, (U16)sizeof(qci), 0, (PTR *)&rbCb);
if(ret != ROK)
{
{
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
- if(kwCb.kwL2Cb.measOn[qci] & measReqEvt->measReq.measType)
+ if(rlcCb.kwL2Cb.measOn[qci] & measReqEvt->measReq.measType)
{
/* measurement is already ongoing */
measCfmEvt->status.status = LCM_PRIM_NOK;
PUBLIC Void kwUtlResetUlL2MeasInKwRb
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasCb *measCb,
U8 measType
)
#else
PUBLIC Void kwUtlResetUlL2MeasInKwRb(measCb, measType)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasCb *measCb;
U8 measType;
#endif
U32 rbIdx;
U32 ueIdx;
U32 qciIdx;
- KwUlUeCb *ueCb = NULL;
+ RlcUlUeCb *ueCb = NULL;
(
CmLListCp *recBufLst,
KwAmRecBuf *recBuf,
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlDelRecBuf(recBufLst, recBufi, gCb)
CmLListCp *recBufLst;
KwAmRecBuf *recBuf;
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
U32 hashKey;
recBufLstCp = &recBufLst[hashKey];
cmLListDelFrm(recBufLstCp, &recBuf->lnk);
- KW_FREE_WC(gCb, recBuf, sizeof(KwAmRecBuf));
+ RLC_FREE_WC(gCb, recBuf, sizeof(KwAmRecBuf));
RETVOID;
} /* kwUtlDelRecBuf */
rspPst.pool = pst->pool;
/* Filling Scheduling Report */
- KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRepInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRepInfo));
schRep->cellId = boSta->cellId;
schRep->rnti = boSta->rnti;
dlData->pduInfo[0].pduBuf = NULL;
#if 0
- KW_FREE_SHRABL_BUF(pst->region, pst->pool,
+ RLC_FREE_SHRABL_BUF(pst->region, pst->pool,
dlData, sizeof(RlcMacData));
{
- KW_ALLOC_SHRABL_BUF(pst->region, pst->pool,
+ RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool,
ulData, sizeof(RlcMacData));
SRegInfoShow(2, &availmem);
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+*******************************************************************************/
+/* This file contains defines for RLC layer */
+
+/* Memory */
+#define RLC_MEM_REGION_UL 1
+#define RLC_MEM_REGION_DL 4
+#define RLC_POOL 1
+
+/* Inst */
+#define RLC_UL_INST 0
+#define RLC_DL_INST 1
+
+/* Fill Pst structure for sending msg from RLC to DUAPP */
+#define FILL_PST_RLC_TO_DUAPP(_pst, _procId, _srcInst, _event) \
+{ \
+ _pst.selector = ODU_SELECTOR_LWLC; \
+ _pst.srcEnt = ENTKW; \
+ _pst.dstEnt = ENTDUAPP; \
+ _pst.dstInst = 0; \
+ _pst.srcInst = _srcInst; \
+ _pst.dstProcId = _procId; \
+ _pst.srcProcId = _procId; \
+ if(_srcInst == RLC_UL_INST) \
+ { \
+ _pst.region = RLC_MEM_REGION_UL; \
+ } \
+ else if(_srcInst == RLC_DL_INST) \
+ { \
+ _pst.region = RLC_MEM_REGION_DL; \
+ } \
+ _pst.pool = RLC_POOL; \
+ _pst.event = _event; \
+ _pst.route = 0; \
+ _pst.prior = 0; \
+ _pst.intfVer = 0; \
+}
+
+/**********************************************************************
+ End of file
+**********************************************************************/
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+*******************************************************************************/
+/* This file defines API towards RLC interface */
+#include "common_def.h"
+#include "rgu.h" /* RGU interface includes*/
+#include "lkw.h" /* LKW defines */
+#include "ckw.h" /* CKW defines */
+#include "kwu.h" /* KWU defines */
+#include "kw_env.h" /* RLC environment options */
+#include "kw.h" /* RLC defines */
+
+
+/* header/extern include files (.x) */
+#include "rgu.x"
+#include "lkw.x" /* LKW */
+#include "ckw.x" /* CKW */
+#include "kwu.x" /* KWU */
+#include "kw_err.h"
+#include "kw.x"
+
+#include "du_app_rlc_inf.h"
+#include "rlc_mgr.h"
+
+RlcUlDuUeCreateRsp rlcUlUeCreateRspOpts[] =
+{
+ packRlcUlDuUeCreateRsp, /* 0 - loosely coupled */
+ DuProcRlcUlUeCreateRsp, /* 1 - tightly coupled */
+ packRlcUlDuUeCreateRsp, /* 2 - LWLC loosely coupled */
+};
+
+
+/***********************************************************
+ *
+ * @brief
+ *
+ * Handler for the ue create response to DUAPP
+ *
+ * @b Description:
+ *
+ * This function reports ue create response to DUAPP
+ *
+ * @param[in] post Post structure
+ * @param[in] cfgRsp ue create Config Response
+ *
+ * @return uint16_t
+ * -# ROK
+ * -# RFAILED
+ *
+ *************************************************************/
+uint8_t SendRlcUlUeCreateRspToDu(Pst *pst, RlcCfgCfmInfo *cfgRsp)
+{
+ /* jump to specific primitive depending on configured selector */
+ uint8_t ret = ROK;
+ RlcUeCfgRsp *ueCreateRsp = NULLP;
+
+ RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, ueCreateRsp, sizeof(RlcUeCfgRsp));
+ if(!ueCreateRsp)
+ {
+ DU_LOG("RLC: Memory allocation failed for ueCreateRsp at SendRlcUlUeCreateRspToDu()");
+ ret = RFAILED;
+ }
+ else
+ {
+ /* Mapping Old api to New Api */
+ fillRlcUlUeCfgRsp(ueCreateRsp, cfgRsp);
+ ret = (*rlcUlUeCreateRspOpts[pst->selector])(pst, ueCreateRsp);
+ if(ret)
+ {
+ DU_LOG("RLC: Failed at SendRlcUlUeCreateRspToDu()");
+ RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCreateRsp, sizeof(RlcUeCfgRsp));
+ ret = RFAILED;
+ }
+ }
+ return ret;
+} /* end of SendRlcUlUeCreateRspToDu */
+
+/**********************************************************************
+ End of file
+**********************************************************************/
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+*******************************************************************************/
+
+/* This file stores defines used at RLC interface */
+extern void fillRlcUlUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp);
+uint8_t SendRlcUlUeCreateRspToDu(Pst *pst, RlcCfgCfmInfo *cfgRsp);
+
+/**********************************************************************
+ End of file
+**********************************************************************/
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+*******************************************************************************/
+
+/* header include files (.h) */
+#include "common_def.h"
+#include "rgu.h" /* RGU interface includes*/
+#include "lkw.h" /* LKW defines */
+#include "ckw.h" /* CKW defines */
+#include "kwu.h" /* KWU defines */
+#include "kw_env.h" /* RLC environment options */
+#include "kw.h" /* RLC defines */
+
+
+/* header/extern include files (.x) */
+#include "rgu.x"
+#include "lkw.x" /* LKW */
+#include "ckw.x" /* CKW */
+#include "kwu.x" /* KWU */
+#include "kw_err.h"
+#include "kw.x"
+
+#include "du_app_rlc_inf.h"
+#include "rlc.h"
+
+extern U16 getTransId();
+
+/*******************************************************************
+ *
+ * @brief Fills RLC UL UE Cfg Rsp from RlcCRsp
+ *
+ * @details
+ *
+ * Function : fillRlcUlUeCfgRsp
+ *
+ * Functionality:
+ * Fills RLC UL UE Cfg Rsp from RlcCRsp
+ *
+ * @params[in] Pointer to RlcCfgCfm
+ * Pointer to RlcUeCfgRsp
+ *
+ * @return void
+ *
+ *****************************************************************/
+
+void fillRlcUlUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp)
+{
+ uint8_t idx;
+
+ rlcCfgRsp->cellId = rlcCRsp->cellId;
+ rlcCfgRsp->ueIdx = rlcCRsp->ueId;
+ for(idx = 0; idx < rlcCRsp->numEnt; idx++)
+ {
+ if(rlcCRsp->entCfgCfm[idx].status.status == CKW_CFG_CFM_OK)
+ {
+ rlcCfgRsp->result = RLC_DU_APP_RSP_OK;
+ rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason;
+ }
+ else
+ {
+ rlcCfgRsp->result = RLC_DU_APP_RSP_NOK;
+ rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason;
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Fills the entity mode and direction compiling to seed code
+ *
+ * @details
+ *
+ * Function : fillEntModeAndDir
+ *
+ * Functionality:
+ * Fills the entity mode and direction compiling to seed code
+ *
+ * @params[in] Pointer to entMode
+ * Pointer to direction
+ * RlcMode Param
+ * @return void
+ * ****************************************************************/
+
+void fillEntModeAndDir(uint8_t *entMode, uint8_t *direction, RlcMode rlcMode)
+{
+ switch(rlcMode)
+ {
+ case RLC_AM:
+ *entMode = CM_LTE_MODE_AM;
+ *direction = RLC_CFG_DIR_BOTH;
+ break;
+ case RLC_UM_BI_DIRECTIONAL:
+ *entMode = CM_LTE_MODE_UM;
+ *direction = RLC_CFG_DIR_BOTH;
+ break;
+ case RLC_UM_UNI_DIRECTIONAL_UL:
+ *entMode = CM_LTE_MODE_UM;
+ *direction = RLC_CFG_DIR_UL;
+ break;
+ case RLC_UM_UNI_DIRECTIONAL_DL:
+ *entMode = CM_LTE_MODE_UM;
+ *direction = RLC_CFG_DIR_DL;
+ break;
+ default :
+ DU_LOG("\nRLC: Rlc Mode invalid %d", rlcMode);
+ break;
+ }
+}
+/*******************************************************************
+ *
+ * @brief Handles Ue Create Request from DU APP
+ *
+ * @details
+ *
+ * Function : RlcUlProcUeCreateReq
+ *
+ * Functionality:
+ * Handles Ue create Request from DU APP
+ *
+ * @params[in] Post structure pointer
+ * RlcUeCfg pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t RlcUlProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg)
+{
+ uint8_t idx;
+ uint8_t ret = ROK;
+ uint8_t lChRbIdx;
+ RlcCfgInfo *rlcUeCfg = NULLP;
+
+ RlcCb *rlcUeCb = NULLP;
+ rlcUeCb = RLC_GET_RLCCB(pst->dstInst);
+ RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo));
+ if(rlcUeCfg)
+ {
+ memset(rlcUeCfg, 0, sizeof(RlcCfgInfo));
+
+ rlcUeCfg->ueId = ueCfg->ueIdx;
+ rlcUeCfg->cellId = ueCfg->cellId;
+ rlcUeCfg->numEnt = ueCfg->numLcs;
+ rlcUeCfg->transId = getTransId();
+
+ for(idx = 0; idx < ueCfg->numLcs; idx++)
+ {
+ lChRbIdx = 0;
+ rlcUeCfg->entCfg[idx].rbId = ueCfg->rlcBearerCfg[idx].rbId;
+ rlcUeCfg->entCfg[idx].rbType = ueCfg->rlcBearerCfg[idx].rbType; // SRB or DRB
+ rlcUeCfg->entCfg[idx].lCh[lChRbIdx].lChId = ueCfg->rlcBearerCfg[idx].lcId;
+ rlcUeCfg->entCfg[idx].lCh[lChRbIdx].type = ueCfg->rlcBearerCfg[idx].lcType;
+ fillEntModeAndDir(&rlcUeCfg->entCfg[idx].entMode, &rlcUeCfg->entCfg[idx].dir,\
+ ueCfg->rlcBearerCfg[idx].rlcMode);
+ rlcUeCfg->entCfg[idx].cfgType = CKW_CFG_ADD;
+ switch(rlcUeCfg->entCfg[idx].entMode)
+ {
+
+ case CM_LTE_MODE_AM:
+ {
+ /* DL AM INFO */
+ rlcUeCfg->entCfg[idx].m.amInfo.dl.snLen = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.snLenDl;
+ rlcUeCfg->entCfg[idx].m.amInfo.dl.pollRetxTmr = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.pollRetxTmr;
+ rlcUeCfg->entCfg[idx].m.amInfo.dl.pollPdu = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.pollPdu;
+ rlcUeCfg->entCfg[idx].m.amInfo.dl.pollByte = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.pollByte;
+ rlcUeCfg->entCfg[idx].m.amInfo.dl.maxRetx = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.maxRetxTh;
+
+ /* UL AM INFO */
+ lChRbIdx++; //lChRbIdx = 1, indicates UL AM
+ rlcUeCfg->entCfg[idx].lCh[lChRbIdx].lChId = ueCfg->rlcBearerCfg[idx].lcId;
+ rlcUeCfg->entCfg[idx].lCh[lChRbIdx].type = ueCfg->rlcBearerCfg[idx].lcType;
+ rlcUeCfg->entCfg[idx].m.amInfo.ul.snLen = ueCfg->rlcBearerCfg[idx].u.amCfg.ulAmCfg.snLenUl;
+ rlcUeCfg->entCfg[idx].m.amInfo.ul.staProhTmr = ueCfg->rlcBearerCfg[idx].u.amCfg.ulAmCfg.statProhTmr;
+ rlcUeCfg->entCfg[idx].m.amInfo.ul.reOrdTmr = ueCfg->rlcBearerCfg[idx].u.amCfg.ulAmCfg.reAssemTmr;
+ break;
+ }
+ case CM_LTE_MODE_UM:
+ {
+ /* UL UM CONFIG */
+ rlcUeCfg->entCfg[idx].m.umInfo.ul.snLen = ueCfg->rlcBearerCfg[idx].u.umBiDirCfg.ulUmCfg.snLenUlUm;
+ rlcUeCfg->entCfg[idx].m.umInfo.ul.reOrdTmr = ueCfg->rlcBearerCfg[idx].u.umBiDirCfg.ulUmCfg.reAssemTmr;
+
+ /* DL UM CONFIG */
+ rlcUeCfg->entCfg[idx].m.umInfo.dl.snLen = ueCfg->rlcBearerCfg[idx].u.umBiDirCfg.dlUmCfg.snLenDlUm;
+ break;
+ }
+ default:
+ break;
+ }/* End of switch(entMode) */
+ }
+ ret = RlcProcCfgReq(pst, rlcUeCfg);
+ }
+ else
+ {
+ DU_LOG("\nRLC: Failed to allocate memory ");
+ ret = RFAILED;
+ }
+ RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg));
+ return ret;
+}
+/**********************************************************************
+ End of file
+**********************************************************************/
#include "common_def.h"
#include "ckw.h"
#include "ckw.x"
+
/* extern (.x) include files */
\f
\f
/*
*
-* Fun: cmPkCkwTmInfo
+* Fun: cmPkRlcTmInfo
*
-* Desc: pack the structure CkwTmInfo
+* Desc: pack the structure RlcTmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwTmInfo
+PUBLIC S16 cmPkRlcTmInfo
(
-CkwTmInfo *param,
+RlcTmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwTmInfo(param, mBuf)
-CkwTmInfo *param;
+PUBLIC S16 cmPkRlcTmInfo(param, mBuf)
+RlcTmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwTmInfo)
+ TRC3(cmPkRlcTmInfo)
CMCHKPK(SPkU32, param->dl.buffSize, mBuf);
RETVALUE(ROK);
-} /* cmPkCkwTmInfo */
+} /* cmPkRlcTmInfo */
\f
/*
*
-* Fun: cmPkCkwUmInfo
+* Fun: cmPkRlcUmInfo
*
-* Desc: pack the structure CkwUmInfo
+* Desc: pack the structure RlcUmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwUmInfo
+PUBLIC S16 cmPkRlcUmInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwUmInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC S16 cmPkRlcUmInfo(param, mBuf)
+RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwUmInfo)
+ TRC3(cmPkRlcUmInfo)
switch(param->dir)
{
}
RETVALUE(ROK);
-} /* cmPkCkwUmInfo */
+} /* cmPkRlcUmInfo */
\f
/*
*
-* Fun: cmPkCkwAmInfo
+* Fun: cmPkRlcAmInfo
*
-* Desc: pack the structure CkwAmInfo
+* Desc: pack the structure RlcAmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwAmInfo
+PUBLIC S16 cmPkRlcAmInfo
(
-CkwAmInfo *param,
+RlcAmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwAmInfo(param, mBuf)
-CkwAmInfo *param;
+PUBLIC S16 cmPkRlcAmInfo(param, mBuf)
+RlcAmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwAmInfo)
+ TRC3(cmPkRlcAmInfo)
/* UP LINK */
CMCHKPK(SPkU8, param->ul.reOrdTmr, mBuf);
CMCHKPK(SPkU8, param->dl.snLen, mBuf);
RETVALUE(ROK);
-} /* cmPkCkwAmInfo */
+} /* cmPkRlcAmInfo */
\f
/*
\f
/*
*
-* Fun: cmPkCkwEntCfgInfo
+* Fun: cmPkRlcEntCfgInfo
*
-* Desc: pack the structure CkwEntCfgInfo
+* Desc: pack the structure RlcEntCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwEntCfgInfo
+PUBLIC S16 cmPkRlcEntCfgInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwEntCfgInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC S16 cmPkRlcEntCfgInfo(param, mBuf)
+RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwEntCfgInfo)
+ TRC3(cmPkRlcEntCfgInfo)
switch(param->entMode)
{
case CM_LTE_MODE_TM:
{
- CMCHKPK(cmPkCkwTmInfo, &(param->m.tmInfo), mBuf);
+ CMCHKPK(cmPkRlcTmInfo, &(param->m.tmInfo), mBuf);
break;
}
case CM_LTE_MODE_UM:
{
- CMCHKPK(cmPkCkwUmInfo, param, mBuf);
+ CMCHKPK(cmPkRlcUmInfo, param, mBuf);
break;
}
case CM_LTE_MODE_AM:
{
- CMCHKPK(cmPkCkwAmInfo, &(param->m.amInfo), mBuf);
+ CMCHKPK(cmPkRlcAmInfo, &(param->m.amInfo), mBuf);
break;
}
}
CMCHKPK(SPkU8, param->cfgType, mBuf);
RETVALUE(ROK);
-} /* cmPkCkwEntCfgInfo */
+} /* cmPkRlcEntCfgInfo */
\f
/*
*
-* Fun: cmPkCkwCfgInfo
+* Fun: cmPkRlcCfgInfo
*
-* Desc: pack the structure CkwCfgInfo
+* Desc: pack the structure RlcCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwCfgInfo
+PUBLIC S16 cmPkRlcCfgInfo
(
-CkwCfgInfo *param,
+RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwCfgInfo(param, pst, mBuf)
-CkwCfgInfo *param;
+PUBLIC S16 cmPkRlcCfgInfo(param, pst, mBuf)
+RlcCfgInfo *param;
Pst *pst;
Buffer *mBuf;
#endif
{
S16 idx;
- TRC3(cmPkCkwCfgInfo)
+ TRC3(cmPkRlcCfgInfo)
for (idx = param->numEnt-1; idx >= 0; idx--)
{
- CMCHKPK(cmPkCkwEntCfgInfo, &(param->entCfg[idx]), mBuf);
+ CMCHKPK(cmPkRlcEntCfgInfo, &(param->entCfg[idx]), mBuf);
}
CMCHKPK(SPkU8, param->numEnt, mBuf);
CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW010, pst);
RETVALUE(ROK);
-} /* cmPkCkwCfgInfo */
-
-\f
-/*
-*
-* Fun: packUeCreateReq
-*
-* Desc: pack the primitive UE Create Req
-*
-* Ret: ROK -ok
-*
-* Notes: None
-*
-* File: ckw.c
-*
-*/
-#ifdef ANSI
-PUBLIC S16 packUeCreateReq
-(
-Pst *pst,
-CkwCfgInfo *cfgInfo
-)
-#else
-PUBLIC S16 packUeCreateReq(pst, cfgInfo)
-Pst *pst;
-CkwCfgInfo *cfgInfo;
-#endif
-{
- S16 ret1;
- Buffer *mBuf;
- mBuf = NULLP;
- TRC3(packUeCreateReq)
-
- if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
- {
-#if (ERRCLASS & ERRCLS_ADD_RES)
- if(ret1 != ROK)
- {
- SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
- __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)ECKW011, (ErrVal)0, "SGetMsg() failed");
- }
-#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
- }
-
- switch(pst->selector)
- {
- case ODU_SELECTOR_LWLC:
- {
- CMCHKPK(cmPkPtr,(PTR) cfgInfo, mBuf);
- break;
- }
- }
- pst->event = (Event) RLC_EVT_UE_CREATE_REQ;
-
- RETVALUE(SPstTsk(pst,mBuf));
-} /* packUeCreateReq */
+} /* cmPkRlcCfgInfo */
\f
/*
*
-* Fun: cmPkCkwEntCfgCfmInfo
+* Fun: cmPkRlcEntCfgCfmInfo
*
-* Desc: pack the structure CkwEntCfgInfo
+* Desc: pack the structure RlcEntCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwEntCfgCfmInfo
+PUBLIC S16 cmPkRlcEntCfgCfmInfo
(
-CkwEntCfgCfmInfo *param,
+RlcEntCfgCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwEntCfgCfmInfo(param, mBuf)
-CkwEntCfgCfmInfo *param;
+PUBLIC S16 cmPkRlcEntCfgCfmInfo(param, mBuf)
+RlcEntCfgCfmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwEntCfgCfmInfo)
+ TRC3(cmPkRlcEntCfgCfmInfo)
CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
CMCHKPK(SPkU8, param->rbType, mBuf);
CMCHKPK(SPkU8, param->rbId, mBuf);
RETVALUE(ROK);
-} /* cmPkCkwEntCfgCfmInfo */
+} /* cmPkRlcEntCfgCfmInfo */
\f
/*
*
-* Fun: cmPkCkwCfgCfmInfo
+* Fun: cmPkRlcCfgCfmInfo
*
-* Desc: pack the structure CkwCfgCfmInfo
+* Desc: pack the structure RlcCfgCfmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwCfgCfmInfo
+PUBLIC S16 cmPkRlcCfgCfmInfo
(
-CkwCfgCfmInfo *param,
+RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwCfgCfmInfo(param, pst, mBuf)
-CkwCfgCfmInfo *param;
+PUBLIC S16 cmPkRlcCfgCfmInfo(param, pst, mBuf)
+RlcCfgCfmInfo *param;
Pst *pst;
Buffer *mBuf;
#endif
{
S16 idx;
- TRC3(cmPkCkwCfgCfmInfo)
+ TRC3(cmPkRlcCfgCfmInfo)
for (idx = param->numEnt-1; idx >= 0; idx--)
{
- CMCHKPK(cmPkCkwEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
+ CMCHKPK(cmPkRlcEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
}
CMCHKPK(SPkU8, param->numEnt, mBuf);
CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW014, pst);
RETVALUE(ROK);
-} /* cmPkCkwCfgCfmInfo */
+} /* cmPkRlcCfgCfmInfo */
\f
/*
*
-* Fun: cmPkCkwCfgCfm
+* Fun: cmPkRlcCfgCfm
*
-* Desc: pack the primitive KwUiCkwCfgCfm
+* Desc: pack the primitive KwUiRlcCfgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwCfgCfm
+PUBLIC S16 cmPkRlcCfgCfm
(
Pst *pst,
SuId suId,
-CkwCfgCfmInfo *cfgCfmInfo
+RlcCfgCfmInfo *cfgCfmInfo
)
#else
-PUBLIC S16 cmPkCkwCfgCfm(pst, suId, cfgCfmInfo)
+PUBLIC S16 cmPkRlcCfgCfm(pst, suId, cfgCfmInfo)
Pst *pst;
SuId suId;
-CkwCfgCfmInfo *cfgCfmInfo;
+RlcCfgCfmInfo *cfgCfmInfo;
#endif
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkCkwCfgCfm)
+ TRC3(cmPkRlcCfgCfm)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#ifdef LCCKW
case ODU_SELECTOR_LC:
{
- ret1 = cmPkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
+ ret1 = cmPkRlcCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
- sizeof(CkwCfgCfmInfo)) != ROK)
+ sizeof(RlcCfgCfmInfo)) != ROK)
{
SPutMsg(mBuf);
RETVALUE(RFAILED);
pst->event = (Event) CKW_EVT_CFG_CFM;
RETVALUE(SPstTsk(pst,mBuf));
-} /* cmPkCkwCfgCfm */
+} /* cmPkRlcCfgCfm */
/*
*
\f
/*
*
-* Fun: cmUnpkCkwTmInfo
+* Fun: cmUnpkRlcTmInfo
*
-* Desc: pack the structure CkwTmInfo
+* Desc: pack the structure RlcTmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwTmInfo
+PUBLIC S16 cmUnpkRlcTmInfo
(
-CkwTmInfo *param,
+RlcTmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwTmInfo(param, mBuf)
-CkwTmInfo *param;
+PUBLIC S16 cmUnpkRlcTmInfo(param, mBuf)
+RlcTmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCkwTmInfo)
+ TRC3(cmUnpkRlcTmInfo)
CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
RETVALUE(ROK);
-} /* cmUnpkCkwTmInfo */
+} /* cmUnpkRlcTmInfo */
\f
/*
*
-* Fun: cmUnpkCkwUmInfo
+* Fun: cmUnpkRlcUmInfo
*
-* Desc: pack the structure CkwUmInfo
+* Desc: pack the structure RlcUmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwUmInfo
+PUBLIC S16 cmUnpkRlcUmInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwUmInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC S16 cmUnpkRlcUmInfo(param, mBuf)
+RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCkwUmInfo)
+ TRC3(cmUnpkRlcUmInfo)
switch(param->dir)
{
}
RETVALUE(ROK);
-} /* cmUnpkCkwUmInfo */
+} /* cmUnpkRlcUmInfo */
\f
/*
*
-* Fun: cmUnpkCkwAmInfo
+* Fun: cmUnpkRlcAmInfo
*
-* Desc: pack the structure CkwAmInfo
+* Desc: pack the structure RlcAmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwAmInfo
+PUBLIC S16 cmUnpkRlcAmInfo
(
-CkwAmInfo *param,
+RlcAmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwAmInfo(param, mBuf)
-CkwAmInfo *param;
+PUBLIC S16 cmUnpkRlcAmInfo(param, mBuf)
+RlcAmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCkwAmInfo)
+ TRC3(cmUnpkRlcAmInfo)
/* DOWN LINK */
CMCHKUNPK(SUnpkU8, &(param->dl.snLen), mBuf);
CMCHKUNPK(SUnpkU8, &(param->ul.reOrdTmr), mBuf);
RETVALUE(ROK);
-} /* cmUnpkCkwAmInfo */
+} /* cmUnpkRlcAmInfo */
\f
/*
\f
/*
*
-* Fun: cmUnpkCkwEntCfgCfmInfo
+* Fun: cmUnpkRlcEntCfgCfmInfo
*
-* Desc: unpack the structure CkwEntCfgInfo
+* Desc: unpack the structure RlcEntCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwEntCfgCfmInfo
+PUBLIC S16 cmUnpkRlcEntCfgCfmInfo
(
-CkwEntCfgCfmInfo *param,
+RlcEntCfgCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwEntCfgCfmInfo(param, mBuf)
-CkwEntCfgCfmInfo *param;
+PUBLIC S16 cmUnpkRlcEntCfgCfmInfo(param, mBuf)
+RlcEntCfgCfmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCkwEntCfgCfmInfo)
+ TRC3(cmUnpkRlcEntCfgCfmInfo)
CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
CMCHKUNPK(cmUnpkCmStatus, &(param->status), mBuf);
RETVALUE(ROK);
-} /* cmUnpkCkwEntCfgCfmInfo */
+} /* cmUnpkRlcEntCfgCfmInfo */
\f
/*
*
-* Fun: cmUnpkCkwCfgCfmInfo
+* Fun: cmUnpkRlcCfgCfmInfo
*
-* Desc: pack the structure CkwCfgCfmInfo
+* Desc: pack the structure RlcCfgCfmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgCfmInfo
+PUBLIC S16 cmUnpkRlcCfgCfmInfo
(
-CkwCfgCfmInfo *param,
+RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwCfgCfmInfo(param, pst, mBuf)
-CkwCfgCfmInfo *param;
+PUBLIC S16 cmUnpkRlcCfgCfmInfo(param, pst, mBuf)
+RlcCfgCfmInfo *param;
Pst *pst;
Buffer *mBuf;
#endif
{
U8 idx;
- TRC3(cmUnpkCkwCfgCfmInfo)
+ TRC3(cmUnpkRlcCfgCfmInfo)
CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW030, pst);
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
for (idx = 0; idx < param->numEnt; idx++)
{
- CMCHKUNPK(cmUnpkCkwEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
+ CMCHKUNPK(cmUnpkRlcEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
}
RETVALUE(ROK);
-} /* cmUnpkCkwCfgCfmInfo */
+} /* cmUnpkRlcCfgCfmInfo */
\f
/*
*
-* Fun: cmUnpkCkwEntCfgInfo
+* Fun: cmUnpkRlcEntCfgInfo
*
-* Desc: pack the structure CkwEntCfgCfmInfo
+* Desc: pack the structure RlcEntCfgCfmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwEntCfgInfo
+PUBLIC S16 cmUnpkRlcEntCfgInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwEntCfgInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC S16 cmUnpkRlcEntCfgInfo(param, mBuf)
+RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCkwEntCfgInfo)
+ TRC3(cmUnpkRlcEntCfgInfo)
CMCHKUNPK(SUnpkU8, &(param->cfgType), mBuf);
CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
{
case CM_LTE_MODE_TM:
{
- CMCHKUNPK(cmUnpkCkwTmInfo, &(param->m.tmInfo), mBuf);
+ CMCHKUNPK(cmUnpkRlcTmInfo, &(param->m.tmInfo), mBuf);
break;
}
case CM_LTE_MODE_UM:
{
- CMCHKUNPK(cmUnpkCkwUmInfo, param, mBuf);
+ CMCHKUNPK(cmUnpkRlcUmInfo, param, mBuf);
break;
}
case CM_LTE_MODE_AM:
{
- CMCHKUNPK(cmUnpkCkwAmInfo, &(param->m.amInfo), mBuf);
+ CMCHKUNPK(cmUnpkRlcAmInfo, &(param->m.amInfo), mBuf);
break;
}
}
RETVALUE(ROK);
-} /* cmUnpkCkwEntCfgInfo */
+} /* cmUnpkRlcEntCfgInfo */
\f
/*
*
-* Fun: cmUnpkCkwCfgInfo
+* Fun: cmUnpkRlcCfgInfo
*
-* Desc: unpack the structure CkwCfgInfo
+* Desc: unpack the structure RlcCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgInfo
+PUBLIC S16 cmUnpkRlcCfgInfo
(
-CkwCfgInfo *param,
+RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwCfgInfo(param, pst, mBuf)
-CkwCfgInfo *param;
+PUBLIC S16 cmUnpkRlcCfgInfo(param, pst, mBuf)
+RlcCfgInfo *param;
Pst *pst;
Buffer *mBuf;
#endif
{
U8 idx;
- TRC3(cmUnpkCkwCfgInfo)
+ TRC3(cmUnpkRlcCfgInfo)
CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW031, pst);
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
for (idx = 0; idx < param->numEnt; idx++)
{
- CMCHKUNPKLOG(cmUnpkCkwEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
+ CMCHKUNPKLOG(cmUnpkRlcEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
}
RETVALUE(ROK);
-} /* cmUnpkCkwCfgInfo */
-
-\f
-/*
-*
-* Fun: unpackUeCreateReq
-*
-* Desc: unpack the primitive UE create request
-*
-* Ret: ROK -ok
-*
-* Notes: None
-*
-* File: ckw.c
-*
-*/
-#ifdef ANSI
-PUBLIC S16 unpackUeCreateReq
-(
-CkwCfgReq func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkCkwCfgReq(func, pst, mBuf)
-CkwCfgReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
-{
- S16 ret1;
- CkwCfgInfo *cfgInfo = NULLP;
-
- TRC3(unpackUeCreateReq)
-
- if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgInfo,\
- sizeof(CkwCfgInfo))) != ROK)
- {
-#if (ERRCLASS & ERRCLS_ADD_RES)
- /*MBUF_FIXX*/
- SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
- __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)ECKW033, (ErrVal)0, "SGetMsg() failed");
-
-#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
- }
-
- switch(pst->selector)
- {
- case ODU_SELECTOR_LWLC:
- {
- CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgInfo, mBuf);
- break;
- }
- }
- SPutMsg(mBuf);
-
- RETVALUE((*func)(pst, cfgInfo));
-} /* cmUnpkCkwCfgReq */
+} /* cmUnpkRlcCfgInfo */
\f
/*
*
-* Fun: cmUnpkCkwCfgCfm
+* Fun: cmUnpkRlcCfgCfm
*
-* Desc: unpack the primitive KwUiCkwCfgCfm
+* Desc: unpack the primitive KwUiRlcCfgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgCfm
+PUBLIC S16 cmUnpkRlcCfgCfm
(
-CkwCfgCfm func,
+RlcCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwCfgCfm(func, pst, mBuf)
-CkwCfgCfm func;
+PUBLIC S16 cmUnpkRlcCfgCfm(func, pst, mBuf)
+RlcCfgCfm func;
Pst *pst;
Buffer *mBuf;
#endif
{
S16 ret1;
SuId suId = 0;
- CkwCfgCfmInfo *cfgCfmInfo = NULLP;
+ RlcCfgCfmInfo *cfgCfmInfo = NULLP;
- TRC3(cmUnpkCkwCfgCfm)
+ TRC3(cmUnpkRlcCfgCfm)
if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
- sizeof(CkwCfgCfmInfo))) != ROK)
+ sizeof(RlcCfgCfmInfo))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
RETVALUE(ret1);
}
- cmMemset((U8 *)cfgCfmInfo, 0, sizeof(CkwCfgCfmInfo));
+ cmMemset((U8 *)cfgCfmInfo, 0, sizeof(RlcCfgCfmInfo));
CMCHKUNPK(SUnpkS16, &suId, mBuf);
#ifdef LCCKW
case ODU_SELECTOR_LC:
{
- ret1 = cmUnpkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
+ ret1 = cmUnpkRlcCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
{
SPutMsg(mBuf);
RETVALUE((*func)(pst, suId, cfgCfmInfo));
-} /* cmUnpkCkwCfgCfm */
+} /* cmUnpkRlcCfgCfm */
/*
*
/* CKW Interface Hash Defines */
/* CKW Interface defines */
-#define CKW_MAX_ENT_CFG 24 /*!< Maximum number of entities to configure */
+/* TODO: To verify if CKW_MAX_ENT_CFG represents LC or LCGs */
+#define CKW_MAX_ENT_CFG 11 /*!< Maximum number of entities to configure */
/* ckw_h_001.main_3 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
#define CKW_MAX_QCI 10
#define CKW_EVT_BND_REQ 0x01 /*!< Bind Request */
#define CKW_EVT_BND_CFM 0x02 /*!< Bind Confirm */
#define CKW_EVT_UBND_REQ 0x03 /*!< Unbind Request */
-#define RLC_EVT_UE_CREATE_REQ 0x04 /*!< UE Create Request */
#define CKW_EVT_CFG_CFM 0x05 /*!< Config Confirm */
#define CKW_EVT_UEIDCHG_REQ 0x06 /*!< UE Id Change Request */
#define CKW_EVT_UEIDCHG_CFM 0x07 /*!< UE Id Change Confirm */
+
/* Error Codes */
#define ERRCKW 0
#define ECKWXXX 0
/** @brief
Un-acknowledge Mode Information */
-typedef struct ckwUmInfo
+typedef struct rlcUmInfo
{
struct _umDl
{
/*!< Allowed values are 6 and 12*/
U8 reOrdTmr; /*!< T_reordering Timer in msec */
}ul; /*!< Uplink */
-}CkwUmInfo;
+}RlcUmInfo;
/** @brief
Acknowledge Mode Information */
-typedef struct ckwAmInfo
+typedef struct rlcAmInfo
{
struct _amDl
{
U16 staProhTmr; /*!< T_status_prohibit Timer in msec*/
U8 reOrdTmr; /*!< T_reordering Timer in msec*/
}ul; /*!< Up link */
-}CkwAmInfo;
+}RlcAmInfo;
/** @brief
Transparent Mode Information */
-typedef union ckwTmInfo
+typedef union rlcTmInfo
{
struct _tmDl
{
U32 buffSize; /*!< Buffer Size in bytes */
}dl; /*!< Down link */
-}CkwTmInfo;
+}RlcTmInfo;
/** @brief
Entity Configuration Information */
-typedef struct ckwEntCfgInfo
+typedef struct rlcEntCfgInfo
{
U8 cfgType; /*!< Type of Configuration -
ADD/MODIFY/DELETE/RE-ESTABLISH/
/* Supported by SPLIT Architecture ends */
union
{
- CkwUmInfo umInfo; /*!< Un-acknowledged Mode Information */
- CkwAmInfo amInfo; /*!< Acknowledged Mode Information */
- CkwTmInfo tmInfo; /*!< Transparent Mode Information */
+ RlcUmInfo umInfo; /*!< Un-acknowledged Mode Information */
+ RlcAmInfo amInfo; /*!< Acknowledged Mode Information */
+ RlcTmInfo tmInfo; /*!< Transparent Mode Information */
}m;
-}CkwEntCfgInfo;
+}RlcEntCfgInfo;
/** @brief
Configuration Information from RRC to RLC */
-typedef struct ckwCfgInfo
+typedef struct rlcCfgInfo
{
U32 transId; /*!< Transaction Id */
CmLteRnti ueId; /*!< UE ID */
CmLteCellId cellId; /*!< Cell ID */
U8 numEnt; /*!< Number of entities to
configure */
- CkwEntCfgInfo entCfg[CKW_MAX_ENT_CFG]; /*!< Array of Entities to be
+ RlcEntCfgInfo entCfg[CKW_MAX_ENT_CFG]; /*!< Array of Entities to be
configure */
-}CkwCfgInfo;
+}RlcCfgInfo;
/** @brief
Entity Configuration Confirmation Information */
-typedef struct ckwEntCfgCfmInfo
+typedef struct rlcEntCfgCfmInfo
{
U8 rbId; /*!< rb ID */
U8 rbType; /*!< RB type - can be SRB or DRB */
CmStatus status; /*!< Status of the confirmation */
-}CkwEntCfgCfmInfo;
+}RlcEntCfgCfmInfo;
/** @brief
Configuration Confirmation Informatin RLC to RRC */
-typedef struct ckwCfgCfmInfo
+typedef struct rlcCfgCfmInfo
{
U32 transId; /*!< Transaction Id */
CmLteRnti ueId; /*!< UE ID */
CmLteCellId cellId; /*!< Cell ID */
U8 numEnt; /*!< Number of entities configured */
- CkwEntCfgCfmInfo entCfgCfm[CKW_MAX_ENT_CFG]; /*!< Array of Entity cfg
+ RlcEntCfgCfmInfo entCfgCfm[CKW_MAX_ENT_CFG]; /*!< Array of Entity cfg
confiramations */
-}CkwCfgCfmInfo;
+}RlcCfgCfmInfo;
/** @brief
UE Id Information */
/* Control primitives towards LTE RRC */
/* Pointer functiones for Pack/Unpack */
-//typedef S16 (*CkwCfgReq) ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
-typedef S16 (*CkwCfgReq) ARGS((Pst *pst, CkwCfgInfo *cfgInfo));
-typedef S16 (*CkwCfgCfm) ARGS((Pst *pst, SuId suId, CkwCfgCfmInfo *cfmInfo));
+typedef S16 (*RlcCfgReq) ARGS((Pst *pst, RlcCfgInfo *cfgInfo));
+typedef S16 (*RlcCfgCfm) ARGS((Pst *pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
typedef S16 (*CkwUeIdChgReq) ARGS((Pst *pst, SpId spId, U32 transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
* @param[in] cfgInfo - This structure contains the configuration information
* @return ROK
*/
-//EXTERN S16 KwUiCkwCfgReq ARGS((Pst *pst, SpId spId, CkwCfgInfo *cfgInfo));
-EXTERN S16 KwUiCkwCfgReq ARGS((Pst *pst, CkwCfgInfo *cfgInfo));
-EXTERN S16 RlcDuappProcUeCreateReq ARGS((Pst *pst, CkwCfgInfo *cfgInfo));
+EXTERN S16 RlcProcCfgReq ARGS((Pst *pst, RlcCfgInfo *cfgInfo));
/**
*@details This primitive is used by RLC to confirm the configuration requested
* information.
* @return ROK
*/
-EXTERN S16 KwUiCkwCfgCfm ARGS((Pst *pst, SuId suId, CkwCfgCfmInfo *cfmInfo));
+EXTERN S16 KwUiRlcCfgCfm ARGS((Pst *pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
/**
*@details This primitive is used by RRC to change the UeId for the existing UE
SuId suId,
U8 status));
-EXTERN S16 NhLiCkwCfgReq ARGS((
+EXTERN S16 NhLiRlcCfgReq ARGS((
Pst *pst,
SpId spId,
- CkwCfgInfo *cfgInfo));
+ RlcCfgInfo *cfgInfo));
-EXTERN S16 NhLiCkwCfgCfm ARGS((Pst *pst,
+EXTERN S16 NhLiRlcCfgCfm ARGS((Pst *pst,
SuId suId,
- CkwCfgCfmInfo* cfmInfo));
+ RlcCfgCfmInfo* cfmInfo));
EXTERN S16 NhLiCkwUeIdChgReq ARGS((Pst *pst,
SpId spId, U32 transId,
SuId suId,
U8 status));
-EXTERN S16 DmUiCkwCfgReq ARGS((
+EXTERN S16 DmUiRlcCfgReq ARGS((
Pst *pst,
SpId spId,
- CkwCfgInfo *cfgInfo));
+ RlcCfgInfo *cfgInfo));
-EXTERN S16 DmUiCkwCfgCfm ARGS((Pst *pst,
+EXTERN S16 DmUiRlcCfgCfm ARGS((Pst *pst,
SuId suId,
- CkwCfgCfmInfo* cfmInfo));
+ RlcCfgCfmInfo* cfmInfo));
EXTERN S16 DmUiCkwUeIdChgReq ARGS((Pst *pst,
SpId spId, U32 transId,
****************************************************************************/
#ifdef LCCKW
/* Packing functions */
-EXTERN S16 cmPkCkwTmInfo ARGS ((
-CkwTmInfo *param,
+EXTERN S16 cmPkRlcTmInfo ARGS ((
+RlcTmInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmPkCkwUmInfo ARGS ((
-CkwEntCfgInfo *param,
+EXTERN S16 cmPkRlcUmInfo ARGS ((
+RlcEntCfgInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmPkCkwAmInfo ARGS ((
-CkwAmInfo *param,
+EXTERN S16 cmPkRlcAmInfo ARGS ((
+RlcAmInfo *param,
Buffer *mBuf
));
Buffer *mBuf
));
-EXTERN S16 cmPkCkwEntCfgInfo ARGS ((
-CkwEntCfgInfo *param,
+EXTERN S16 cmPkRlcEntCfgInfo ARGS ((
+RlcEntCfgInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmPkCkwCfgInfo ARGS ((
-CkwCfgInfo *param,
+EXTERN S16 cmPkRlcCfgInfo ARGS ((
+RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
));
-EXTERN S16 cmPkCkwEntCfgCfmInfo ARGS ((
-CkwEntCfgCfmInfo *param,
+EXTERN S16 cmPkRlcEntCfgCfmInfo ARGS ((
+RlcEntCfgCfmInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmPkCkwCfgCfmInfo ARGS ((
-CkwCfgCfmInfo *param,
+EXTERN S16 cmPkRlcCfgCfmInfo ARGS ((
+RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
));
EXTERN S16 packUeCreateReq ARGS ((
Pst *pst,
-CkwCfgInfo *cfgInfo
+RlcCfgInfo *cfgInfo
));
-EXTERN S16 cmPkCkwCfgCfm ARGS ((
+EXTERN S16 cmPkRlcCfgCfm ARGS ((
Pst *pst,
SuId suId,
-CkwCfgCfmInfo *cfgCfmInfo
+RlcCfgCfmInfo *cfgCfmInfo
));
EXTERN S16 cmPkCkwUeIdChgReq ARGS ((
));
/* Unpacking functions */
-EXTERN S16 cmUnpkCkwTmInfo ARGS ((
-CkwTmInfo *param,
+EXTERN S16 cmUnpkRlcTmInfo ARGS ((
+RlcTmInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmUnpkCkwUmInfo ARGS ((
-CkwEntCfgInfo *param,
+EXTERN S16 cmUnpkRlcUmInfo ARGS ((
+RlcEntCfgInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmUnpkCkwAmInfo ARGS ((
-CkwAmInfo *param,
+EXTERN S16 cmUnpkRlcAmInfo ARGS ((
+RlcAmInfo *param,
Buffer *mBuf
));
Buffer *mBuf
));
-EXTERN S16 cmUnpkCkwCfgCfmInfo ARGS ((
-CkwCfgCfmInfo *param,
+EXTERN S16 cmUnpkRlcCfgCfmInfo ARGS ((
+RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
));
Buffer *mBuf
));
-EXTERN S16 cmUnpkCkwEntCfgInfo ARGS ((
-CkwEntCfgInfo *param,
+EXTERN S16 cmUnpkRlcEntCfgInfo ARGS ((
+RlcEntCfgInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmUnpkCkwCfgInfo ARGS ((
-CkwCfgInfo *param,
+EXTERN S16 cmUnpkRlcCfgInfo ARGS ((
+RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
));
Buffer *mBuf
));
-EXTERN S16 cmUnpkCkwCfgCfm ARGS ((
-CkwCfgCfm func,
+EXTERN S16 cmUnpkRlcCfgCfm ARGS ((
+RlcCfgCfm func,
Pst *pst,
Buffer *mBuf
));
));
EXTERN S16 unpackUeCreateReq ARGS ((
-CkwCfgReq func,
+RlcCfgReq func,
Pst *pst,
Buffer *mBuf
));
-EXTERN S16 cmUnpkCkwEntCfgCfmInfo ARGS ((
-CkwEntCfgCfmInfo *param,
+EXTERN S16 cmUnpkRlcEntCfgCfmInfo ARGS ((
+RlcEntCfgCfmInfo *param,
Buffer *mBuf
));
uint8_t MacProcUeCreateReq(Pst *pst, MacUeCfg *ueCfg);
uint8_t packDuMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp);
uint8_t unpackDuMacUeCreateRsp(DuMacUeCreateRspFunc func, Pst *pst, Buffer *mBuf);
-uint8_t duHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp);
+uint8_t DuHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp);
uint8_t sendStopIndMacToDuApp(uint16_t cellId);
#endif
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+*******************************************************************************/
+
+#include "common_def.h"
+#include "du_log.h"
+#include "du_app_rlc_inf.h"
+
+/*******************************************************************
+ *
+ * @brief Packs and Sends UE create Request from DUAPP to RLC
+ *
+ * @details
+ *
+ * Function : packDuRlcUlUeCreateReq
+ *
+ * Functionality:
+ * Packs and Sends UE Create Request from DUAPP to RLC
+ *
+ *
+ * @params[in] Post structure pointer
+ * RlcUeCfg pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t packDuRlcUlUeCreateReq(Pst *pst, RlcUeCfg *ueCfg)
+{
+ Buffer *mBuf = NULLP;
+
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ DU_LOG("\nRLC : Memory allocation failed at packDuRlcUeCreateReq");
+ return RFAILED;
+ }
+ /* pack the address of the structure */
+ CMCHKPK(cmPkPtr,(PTR)ueCfg, mBuf);
+ }
+ else
+ {
+ DU_LOG("\nRLC: Only LWLC supported for packDuRlcUeCreateReq");
+ return RFAILED;
+ }
+
+ return SPstTsk(pst,mBuf);
+}
+
+/*******************************************************************
+ *
+ * @brief Unpacks UE Create Request received from DU APP
+ *
+ * @details
+ *
+ * Function : unpackRlcUlUeCreateReq
+ *
+ * Functionality:
+ * Unpacks UE Create Request received from DU APP
+ *
+ * @params[in] Pointer to Handler
+ * Post structure pointer
+ * Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t unpackRlcUlUeCreateReq(DuRlcUlUeCreateReq func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ RlcUeCfg *ueCfg;
+ /* unpack the address of the structure */
+ CMCHKUNPK(cmUnpkPtr, (PTR *)&ueCfg, mBuf);
+ SPutMsg(mBuf);
+ return (*func)(pst, ueCfg);
+ }
+ else
+ {
+ /* Nothing to do for other selectors */
+ DU_LOG("\nRLC: Only LWLC supported for UE Create Request ");
+ SPutMsg(mBuf);
+ }
+
+ return RFAILED;
+}
+
+/*******************************************************************
+ *
+ * @brief Packs and Sends UE create Response from RLC to DUAPP
+ *
+ * @details
+ *
+ * Function : packRlcUlDuUeCreateRsp
+ *
+ * Functionality:
+ * Packs and Sends UE Create Rrsponse from RLC to DUAPP
+ *
+ *
+ * @params[in] Post structure pointer
+ * RlcUeCfg pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t packRlcUlDuUeCreateRsp(Pst *pst, RlcUeCfgRsp *ueCfg)
+{
+ Buffer *mBuf = NULLP;
+
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ DU_LOG("\nRLC : Memory allocation failed at packRlcUlDuUeCreateRsp");
+ return RFAILED;
+ }
+ /* pack the address of the structure */
+ CMCHKPK(cmPkPtr,(PTR)ueCfg, mBuf);
+ }
+ else
+ {
+ DU_LOG("\nRLC: Only LWLC supported for packRlcUlDuUeCreateRsp");
+ return RFAILED;
+ }
+
+ return SPstTsk(pst,mBuf);
+}
+
+/*******************************************************************
+ *
+ * @brief Unpacks UE Create Response received from DU APP
+ *
+ * @details
+ *
+ * Function : unpackRlcUlUeCreateRsp
+ *
+ * Functionality:
+ * Unpacks UE Create Response received from DU APP
+ *
+ * @params[in] Pointer to Handler
+ * Post structure pointer
+ * Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t unpackRlcUlUeCreateRsp(RlcUlDuUeCreateRsp func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ RlcUeCfgRsp *cfgRsp;
+ /* unpack the address of the structure */
+ CMCHKUNPK(cmUnpkPtr, (PTR *)&cfgRsp, mBuf);
+ SPutMsg(mBuf);
+ return (*func)(pst, cfgRsp);
+ }
+ else
+ {
+ /* Nothing to do for other selectors */
+ DU_LOG("\nRLC: Only LWLC supported for UE Create Response ");
+ SPutMsg(mBuf);
+ }
+
+ return RFAILED;
+}
+/**********************************************************************
+ End of file
+**********************************************************************/
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+*******************************************************************************/
+
+/* Defines APIs exchanged between du_app and cl module of RLC */
+#ifndef __RLC_INF_H__
+#define __RLC_INF_H__
+
+/* Macro for Ue Context */
+#define MAX_NUM_LOGICAL_CHANNELS 11
+#define EVENT_RLC_UL_UE_CREATE_REQ 210
+#define EVENT_RLC_UL_UE_CREATE_RSP 211 /*!< Config Confirm */
+
+#define RB_ID_SRB 0
+#define RB_ID_DRB 1
+
+#define RB_TYPE_SRB 0 /* Signalling Radio Bearer */
+#define RB_TYPE_DRB 1 /* Data Radio Bearer */
+
+/* RLC Direction Config */
+#define RLC_CFG_DIR_UL 1 /*!< Uplink direction */
+#define RLC_CFG_DIR_DL 2 /*!< Downlink direction */
+#define RLC_CFG_DIR_BOTH 3 /*!< Both Downlink and Uplink Direction*/
+
+
+/* Logical Channel Type */
+#define LCH_BCCH 1 /*!< BCCH Logical Channel */
+#define LCH_PCCH 2 /*!< PCCH Logical Channel */
+#define LCH_CCCH 3 /*!< CCCH Logical Channel */
+#define LCH_DTCH 4 /*!< DTCH Logical Channel */
+#define LCH_DCCH 5 /*!< DCCH Logical Channel */
+
+
+typedef enum
+{
+ RLC_CFG_REAS_NONE , /*!< No Failure */
+ RLC_CFG_REAS_RB_CREAT_FAIL , /*!< RB CB creation Failure */
+ RLC_CFG_REAS_UE_CREAT_FAIL , /*!< UE CB creation Failure */
+ RLC_CFG_REAS_CELL_CREAT_FAIL , /*!< CELL CB creation Failure */
+ RLC_CFG_REAS_RB_PRSNT , /*!< RB CB already present */
+ RLC_CFG_REAS_LCHTYPE_MIS , /*!< Logical channel type mismatch */
+ RLC_CFG_REAS_RB_UNKWN , /*!< RB Cb unknown */
+ RLC_CFG_REAS_UE_UNKWN , /*!< UE Cb unknown */
+ RLC_CFG_REAS_CELL_UNKWN , /*!< Cell Cb unknown */
+ RLC_CFG_REAS_RB_DEL_FAIL , /*!< RB Cb Deletion Failure */
+ RLC_CFG_REAS_UE_DEL_FAIL , /*!< UE Cb Deletion Failure */
+ RLC_CFG_REAS_RB_REEST_FAIL , /*!< RB Cb Re establish Failure */
+ RLC_CFG_REAS_RB_MODE_MIS , /*!< RB Cb Mode mismatch */
+ RLC_CFG_REAS_REEST_FAIL , /*!< RB Cb Re-establishment Failed */
+ RLC_CFG_REAS_RECFG_FAIL , /*!< RB Cb Re-configuration Failed */
+ RLC_CFG_REAS_INVALID_CFG , /*!< Invalid Configuration Type */
+ RLC_CFG_REAS_SAME_UEID , /*!< UE Ids match in ChngUeId Request */
+ RLC_CFG_REAS_CELL_DEL_FAIL , /*!< Cell Cb Deletion Failure */
+ RLC_CFG_REAS_INVALID_LCHID , /*!< Invalid LChId */
+ RLC_CFG_REAS_INVALID_DIR , /*!< Invalid Direction */
+ RLC_CFG_REAS_UE_EXISTS , /*!< UE ID already exists */
+ RLC_CFG_REAS_INVALID_SNLEN , /*!< Invalid SN Length */
+ RLC_CFG_REAS_SNLEN_MIS , /*!< SN Length mismatch */
+ RLC_CFG_REAS_INVALID_RGUSAP /*!< Invalid RGU SAP ID */
+}FailureReason;
+
+typedef enum
+{
+ RLC_AM, //Acknowledged Mode
+ RLC_UM_BI_DIRECTIONAL, //UnAcknowledged Mode
+ RLC_UM_UNI_DIRECTIONAL_UL,
+ RLC_UM_UNI_DIRECTIONAL_DL
+}RlcMode;
+
+typedef enum
+{
+ AM_SIZE_12,
+ AM_SIZE_18
+}SnLenAm;
+
+typedef enum
+{
+ UM_SIZE_6,
+ UM_SIZE_12
+}SnLenUm;
+
+typedef enum
+{
+ POLL_RETX_TMR_5MS,
+ POLL_RETX_TMR_10MS,
+ POLL_RETX_TMR_15MS,
+ POLL_RETX_TMR_20MS,
+ POLL_RETX_TMR_25MS,
+ POLL_RETX_TMR_30MS,
+ POLL_RETX_TMR_35MS,
+ POLL_RETX_TMR_40MS,
+ POLL_RETX_TMR_45MS,
+ POLL_RETX_TMR_50MS,
+ POLL_RETX_TMR_55MS,
+ POLL_RETX_TMR_60MS,
+ POLL_RETX_TMR_65MS,
+ POLL_RETX_TMR_70MS,
+ POLL_RETX_TMR_75MS,
+ POLL_RETX_TMR_80MS,
+ POLL_RETX_TMR_85MS,
+ POLL_RETX_TMR_90MS,
+ POLL_RETX_TMR_95MS,
+ POLL_RETX_TMR_100MS,
+ POLL_RETX_TMR_105MS,
+ POLL_RETX_TMR_110MS,
+ POLL_RETX_TMR_115MS,
+ POLL_RETX_TMR_120MS,
+ POLL_RETX_TMR_125MS,
+ POLL_RETX_TMR_130MS,
+ POLL_RETX_TMR_135MS,
+ POLL_RETX_TMR_140MS,
+ POLL_RETX_TMR_145MS,
+ POLL_RETX_TMR_150MS,
+ POLL_RETX_TMR_155MS,
+ POLL_RETX_TMR_160MS,
+ POLL_RETX_TMR_165MS,
+ POLL_RETX_TMR_170MS,
+ POLL_RETX_TMR_175MS,
+ POLL_RETX_TMR_180MS,
+ POLL_RETX_TMR_185MS,
+ POLL_RETX_TMR_190MS,
+ POLL_RETX_TMR_195MS,
+ POLL_RETX_TMR_200MS,
+ POLL_RETX_TMR_205MS,
+ POLL_RETX_TMR_210MS,
+ POLL_RETX_TMR_215MS,
+ POLL_RETX_TMR_220MS,
+ POLL_RETX_TMR_225MS,
+ POLL_RETX_TMR_230MS,
+ POLL_RETX_TMR_235MS,
+ POLL_RETX_TMR_240MS,
+ POLL_RETX_TMR_245MS,
+ POLL_RETX_TMR_250MS,
+ POLL_RETX_TMR_300MS,
+ POLL_RETX_TMR_350MS,
+ POLL_RETX_TMR_400MS,
+ POLL_RETX_TMR_450MS,
+ POLL_RETX_TMR_500MS,
+ POLL_RETX_TMR_800MS,
+ POLL_RETX_TMR_1000MS,
+ POLL_RETX_TMR_2000MS,
+ POLL_RETX_TMR_4000MS,
+ POLL_RETX_TMR_SPARE5,
+ POLL_RETX_TMR_SPARE4,
+ POLL_RETX_TMR_SPARE3,
+ POLL_RETX_TMR_SPARE2,
+ POLL_RETX_TMR_SPARE1
+
+}TpollReTxTmr;
+
+typedef enum
+{
+ POLL_PDU_TMR_4MS,
+ POLL_PDU_TMR_8MS,
+ POLL_PDU_TMR_16MS,
+ POLL_PDU_TMR_32MS,
+ POLL_PDU_TMR_64MS,
+ POLL_PDU_TMR_128MS,
+ POLL_PDU_TMR_256MS,
+ POLL_PDU_TMR_512MS,
+ POLL_PDU_TMR_1024MS,
+ POLL_PDU_TMR_2048MS,
+ POLL_PDU_TMR_4096MS,
+ POLL_PDU_TMR_6144MS,
+ POLL_PDU_TMR_8192MS,
+ POLL_PDU_TMR_12288MS,
+ POLL_PDU_TMR_16384MS,
+ POLL_PDU_TMR_20480MS,
+ POLL_PDU_TMR_24576MS,
+ POLL_PDU_TMR_28672MS,
+ POLL_PDU_TMR_32768MS,
+ POLL_PDU_TMR_40960MS,
+ POLL_PDU_TMR_49152MS,
+ POLL_PDU_TMR_57344MS,
+ POLL_PDU_TMR_65536MS,
+ POLL_PDU_TMR_INFINITY,
+ POLL_PDU_TMR_SPARE_8,
+ POLL_PDU_TMR_SPARE_7,
+ POLL_PDU_TMR_SPARE_6,
+ POLL_PDU_TMR_SPARE_5,
+ POLL_PDU_TMR_SPARE_4,
+ POLL_PDU_TMR_SPARE_3,
+ POLL_PDU_TMR_SPARE_2,
+ POLL_PDU_TMR_SPARE_1
+
+}PollPdu;
+
+typedef enum
+{
+ POLL_BYTES_1KB,
+ POLL_BYTES_2KB,
+ POLL_BYTES_5KB,
+ POLL_BYTES_8KB,
+ POLL_BYTES_10KB,
+ POLL_BYTES_15KB,
+ POLL_BYTES_25KB,
+ POLL_BYTES_50KB,
+ POLL_BYTES_75KB,
+ POLL_BYTES_100KB,
+ POLL_BYTES_125KB,
+ POLL_BYTES_250KB,
+ POLL_BYTES_375KB,
+ POLL_BYTES_500KB,
+ POLL_BYTES_750KB,
+ POLL_BYTES_1000KB,
+ POLL_BYTES_1250KB,
+ POLL_BYTES_1500KB,
+ POLL_BYTES_2000KB,
+ POLL_BYTES_3000KB,
+ POLL_BYTES_4000KB,
+ POLL_BYTES_4500KB,
+ POLL_BYTES_5000KB,
+ POLL_BYTES_5500KB,
+ POLL_BYTES_6000KB,
+ POLL_BYTES_6500KB,
+ POLL_BYTES_7000KB,
+ POLL_BYTES_7500KB,
+ POLL_BYTES_8MB,
+ POLL_BYTES_9MB,
+ POLL_BYTES_10MB,
+ POLL_BYTES_11MB,
+ POLL_BYTES_12MB,
+ POLL_BYTES_13MB,
+ POLL_BYTES_14MB,
+ POLL_BYTES_15MB,
+ POLL_BYTES_16MB,
+ POLL_BYTES_17MB,
+ POLL_BYTES_18MB,
+ POLL_BYTES_20MB,
+ POLL_BYTES_25MB,
+ POLL_BYTES_30MB,
+ POLL_BYTES_40MB,
+ POLL_BYTES_INFINITY,
+ POLL_BYTES_SPARE_20,
+ POLL_BYTES_SPARE_19,
+ POLL_BYTES_SPARE_18,
+ POLL_BYTES_SPARE_17,
+ POLL_BYTES_SPARE_16,
+ POLL_BYTES_SPARE_15,
+ POLL_BYTES_SPARE_14,
+ POLL_BYTES_SPARE_13,
+ POLL_BYTES_SPARE_12,
+ POLL_BYTES_SPARE_11,
+ POLL_BYTES_SPARE_10,
+ POLL_BYTES_SPARE_9,
+ POLL_BYTES_SPARE_8,
+ POLL_BYTES_SPARE_7,
+ POLL_BYTES_SPARE_6,
+ POLL_BYTES_SPARE_5,
+ POLL_BYTES_SPARE_4,
+ POLL_BYTES_SPARE_3,
+ POLL_BYTES_SPARE_2,
+ POLL_BYTES_SPARE_1
+
+}PollBytes;
+
+typedef enum
+{
+ RETX_TH_1,
+ RETX_TH_2,
+ RETX_TH_3,
+ RETX_TH_4,
+ RETX_TH_6,
+ RETX_TH_8,
+ RETX_TH_16,
+ RETX_TH_32
+
+}MaxRetxTh;
+
+typedef enum
+{
+ RE_ASM_0MS,
+ RE_ASM_5MS,
+ RE_ASM_10MS,
+ RE_ASM_15MS,
+ RE_ASM_20MS,
+ RE_ASM_25MS,
+ RE_ASM_30MS,
+ RE_ASM_35MS,
+ RE_ASM_40MS,
+ RE_ASM_45MS,
+ RE_ASM_50MS,
+ RE_ASM_55MS,
+ RE_ASM_60MS,
+ RE_ASM_65MS,
+ RE_ASM_70MS,
+ RE_ASM_75MS,
+ RE_ASM_80MS,
+ RE_ASM_85MS,
+ RE_ASM_90MS,
+ RE_ASM_95MS,
+ RE_ASM_100MS,
+ RE_ASM_105MS,
+ RE_ASM_110MS,
+ RE_ASM_115MS,
+ RE_ASM_120MS,
+ RE_ASM_125MS,
+ RE_ASM_130MS,
+ RE_ASM_135MS,
+ RE_ASM_140MS,
+ RE_ASM_145MS,
+ RE_ASM_150MS,
+ RE_ASM_155MS,
+ RE_ASM_160MS,
+ RE_ASM_165MS,
+ RE_ASM_170MS,
+ RE_ASM_175MS,
+ RE_ASM_180MS,
+ RE_ASM_185MS,
+ RE_ASM_190MS,
+ RE_ASM_195MS,
+ RE_ASM_200MS,
+ RE_ASM_SPARE1
+
+}TReAssembleTmr;
+
+typedef enum
+{
+ PROH_0MS,
+ PROH_5MS,
+ PROH_10MS,
+ PROH_15MS,
+ PROH_20MS,
+ PROH_25MS,
+ PROH_30MS,
+ PROH_35MS,
+ PROH_40MS,
+ PROH_45MS,
+ PROH_50MS,
+ PROH_55MS,
+ PROH_60MS,
+ PROH_65MS,
+ PROH_70MS,
+ PROH_75MS,
+ PROH_80MS,
+ PROH_85MS,
+ PROH_90MS,
+ PROH_95MS,
+ PROH_100MS,
+ PROH_105MS,
+ PROH_110MS,
+ PROH_115MS,
+ PROH_120MS,
+ PROH_125MS,
+ PROH_130MS,
+ PROH_135MS,
+ PROH_140MS,
+ PROH_145MS,
+ PROH_150MS,
+ PROH_155MS,
+ PROH_160MS,
+ PROH_165MS,
+ PROH_170MS,
+ PROH_175MS,
+ PROH_180MS,
+ PROH_185MS,
+ PROH_190MS,
+ PROH_195MS,
+ PROH_200MS,
+ PROH_205MS,
+ PROH_210MS,
+ PROH_215MS,
+ PROH_220MS,
+ PROH_225MS,
+ PROH_230MS,
+ PROH_235MS,
+ PROH_240MS,
+ PROH_245MS,
+ PROH_250MS,
+ PROH_300MS,
+ PROH_350MS,
+ PROH_400MS,
+ PROH_450MS,
+ PROH_500MS,
+ PROH_800MS,
+ PROH_1000MS,
+ PROH_1200MS,
+ PROH_1600MS,
+ PROH_2000MS,
+ PROH_2400MS,
+ PROH_SPARE2,
+ PROH_SPARE1
+
+}TStatProhTmr;
+
+typedef enum
+{
+ RLC_DU_APP_RSP_NOK,
+ RLC_DU_APP_RSP_OK
+}RlcRsp;
+
+typedef struct ulAmCfg
+{
+ SnLenAm snLenUl; /* Sequence Number length in bits. Allowed values are 12 and 18 */
+ TReAssembleTmr reAssemTmr; /* T_reassembling Timer in msec*/
+ TStatProhTmr statProhTmr; /* T_status_prohibit Timer in msec*/
+
+}UlAmCfg;
+
+typedef struct dlAmCfg
+{
+ SnLenAm snLenDl; /* Sequence Number length in bits. Allowed values are 12 and 18 */
+ TpollReTxTmr pollRetxTmr; /* T_poll_retransmit Timer in msec */
+ PollPdu pollPdu; /* Used to trigger a poll for every pollPdu.*/
+ PollBytes pollByte; /* Poll_Byte in bytes. */
+ MaxRetxTh maxRetxTh; /* Max_Retx_Threshold */
+
+}DlAmCfg;
+
+typedef struct dlUmCfg
+{
+ SnLenUm snLenDlUm; /* Sequence Number length in bits. Allowed values are 6 and 12 */
+
+}DlUmCfg;
+
+typedef struct ulUmCfg
+{
+ SnLenUm snLenUlUm; /* Sequence Number length in bits. Allowed values are 6 and 12 */
+ TReAssembleTmr reAssemTmr; /* T_reassembling Timer in msec*/
+
+}UlUmCfg;
+
+typedef struct amBearerCfg
+{
+ UlAmCfg ulAmCfg;
+ DlAmCfg dlAmCfg;
+}AmBearerCfg;
+
+typedef struct umBiDirBearerCfg
+{
+ UlUmCfg ulUmCfg;
+ DlUmCfg dlUmCfg;
+}UmBiDirBearerCfg;
+
+typedef struct umUniDirUlBearerCfg
+{
+ UlUmCfg ulUmCfg;
+}UmUniDirUlBearerCfg;
+
+typedef struct umUniDirDlBearerCfg
+{
+ DlUmCfg dlUmCfg;
+}UmUniDirDlBearerCfg;
+
+/* Spec Ref: 38.331, 6.3.2 RLC-BearerConfig */
+typedef struct rlcBearerCfg
+{
+ uint8_t rbId;
+ uint8_t rbType;
+ uint8_t lcId;
+ uint8_t lcType;
+ RlcMode rlcMode;
+ union
+ {
+ AmBearerCfg amCfg;
+ UmBiDirBearerCfg umBiDirCfg;
+ UmUniDirUlBearerCfg umUniDirUlCfg;
+ UmUniDirDlBearerCfg umUniDirDlCfg;
+ }u;
+}RlcBearerCfg;
+
+typedef struct rlcUeCfg
+{
+ uint16_t cellId;
+ uint8_t ueIdx;
+ uint8_t numLcs;
+ RlcBearerCfg rlcBearerCfg[MAX_NUM_LOGICAL_CHANNELS];
+}RlcUeCfg;
+
+typedef struct rlcUeCfgRsp
+{
+ uint16_t cellId;
+ uint16_t ueIdx;
+ RlcRsp result;
+ FailureReason reason;
+}RlcUeCfgRsp;
+
+/* Function Pointers */
+/* UE create Request from DU APP to RLC*/
+typedef uint8_t (*DuRlcUlUeCreateReq) ARGS((
+ Pst *pst,
+ RlcUeCfg *ueCfg ));
+
+/* UE create Response from RLC to DU APP*/
+typedef uint8_t (*RlcUlDuUeCreateRsp) ARGS((
+ Pst *pst,
+ RlcUeCfgRsp *ueCfgRsp));
+
+/* Function Declarations */
+uint8_t packDuRlcUlUeCreateReq(Pst *pst, RlcUeCfg *ueCfg);
+uint8_t unpackRlcUlUeCreateReq(DuRlcUlUeCreateReq func, Pst *pst, Buffer *mBuf);
+uint8_t RlcUlProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg);
+uint8_t packRlcUlDuUeCreateRsp(Pst *pst, RlcUeCfgRsp *ueCfgRsp);
+uint8_t unpackRlcUlUeCreateRsp(RlcUlDuUeCreateRsp func, Pst *pst, Buffer *mBuf);
+uint8_t DuProcRlcUlUeCreateRsp(Pst *pst, RlcUeCfgRsp *cfgRsp);
+
+#endif /* RLC_INF_H */
+
+/**********************************************************************
+ End of file
+**********************************************************************/
} /* cmPkKwuUbndReq */
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatReqInfo
+uint8_t cmPkKwuDatReqInfo
(
KwuDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuDatReqInfo(param, mBuf)
+uint8_t cmPkKwuDatReqInfo(param, mBuf)
KwuDatReqInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatReq
+uint8_t cmPkKwuDatReq
(
Pst * pst,
KwuDatReqInfo* datReq,
Buffer * mBuf
)
#else
-PUBLIC S16 cmPkKwuDatReq(pst, datReq, mBuf)
+uint8_t cmPkKwuDatReq(pst, datReq, mBuf)
Pst * pst;
KwuDatReqInfo* datReq;
Buffer * mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatIndInfo
+uint8_t cmPkKwuDatIndInfo
(
KwuDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuDatIndInfo(param, mBuf)
+uint8_t cmPkKwuDatIndInfo(param, mBuf)
KwuDatIndInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatInd
+uint8_t cmPkKwuDatInd
(
Pst * pst,
KwuDatIndInfo* datInd,
Buffer * mBuf
)
#else
-PUBLIC S16 cmPkKwuDatInd(pst, datInd, mBuf)
+uint8_t cmPkKwuDatInd(pst, datInd, mBuf)
Pst * pst;
KwuDatIndInfo* datInd;
Buffer * mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatIndInfo
+uint8_t cmUnpkKwuDatIndInfo
(
KwuDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatIndInfo(param, mBuf)
+uint8_t cmUnpkKwuDatIndInfo(param, mBuf)
KwuDatIndInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatInd
+uint8_t cmUnpkKwuDatInd
(
KwuDatInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatInd(func, pst, mBuf)
+uint8_t cmUnpkKwuDatInd(func, pst, mBuf)
KwuDatInd func;
Pst *pst;
Buffer *mBuf;
typedef S16 (*KwuUbndReq) ARGS((Pst *pst, SuId suId, Reason reason));
typedef S16 (*KwuDatReq) ARGS((Pst *pst, KwuDatReqInfo* datReq, Buffer *mBuf));
-typedef S16 (*KwuDatInd) ARGS((Pst *pst, KwuDatIndInfo* datInd,
+typedef uint8_t (*KwuDatInd) ARGS((Pst *pst, KwuDatIndInfo* datInd,
Buffer *mBuf));
typedef S16 (*KwuDatCfm) ARGS((Pst *pst, SuId suId, KwuDatCfmInfo* datCfm));
typedef S16 (*KwuDiscSduReq) ARGS((Pst *pst, SpId spId, KwuDiscSduInfo* discSdu));
****************************************************************************/
#ifdef LCKWU
/* Packing Functions */
-EXTERN S16 cmPkKwuDatReqInfo ARGS ((
+EXTERN uint8_t cmPkKwuDatReqInfo ARGS ((
KwuDatReqInfo *param,
Buffer *mBuf
));
-EXTERN S16 cmPkKwuDatIndInfo ARGS ((
+EXTERN uint8_t cmPkKwuDatIndInfo ARGS ((
KwuDatIndInfo *param,
Buffer *mBuf
));
U8 status
));
-EXTERN S16 cmPkKwuDatReq ARGS ((
+EXTERN uint8_t cmPkKwuDatReq ARGS ((
Pst * pst,
KwuDatReqInfo* datReq,
Buffer * mBuf
));
-EXTERN S16 cmPkKwuDatInd ARGS ((
+EXTERN uint8_t cmPkKwuDatInd ARGS ((
Pst * pst,
KwuDatIndInfo* datInd,
Buffer * mBuf
Buffer *mBuf
));
-EXTERN S16 cmUnpkKwuDatIndInfo ARGS ((
+EXTERN uint8_t cmUnpkKwuDatIndInfo ARGS ((
KwuDatIndInfo *param,
Buffer *mBuf
));
Buffer *mBuf
));
-EXTERN S16 cmUnpkKwuDatInd ARGS ((
+EXTERN uint8_t cmUnpkKwuDatInd ARGS ((
KwuDatInd func,
Pst *pst,
Buffer *mBuf
for RLC Layer Manager Interfaces. It contains the
following function definitions
- -- cmPkLkwCfgReq
+ -- packRlcConfigReq
-- cmPkLkwCntrlReq
-- cmPkLkwCntrlCfm
- -- cmPkLkwCfgCfm
+ -- packRlcConfigCfm
-- cmPkLkwStaInd
- -- cmUnpkLkwCfgReq
+ -- unpackRlcConfigReq
-- cmUnpkLkwCntrlReq
-- cmUnpkLkwCntrlCfm
- -- cmUnpkLkwCfgCfm
+ -- unpackRlcConfigCfm
-- cmUnpkLkwStaInd
File: lkw.c
PRIVATE S16 cmPkKwMngmt ARGS ((KwMngmt *param ,Event eventType,
Buffer *mBuf));
-PRIVATE S16 cmPkKwCfg ARGS ((KwMngmt *param ,Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmPkRlcCfg ARGS ((KwMngmt *param ,Elmnt elmnt, Buffer *mBuf));
PRIVATE S16 cmPkKwCntrl ARGS ((KwMngmt *cntrl, Elmnt elmnt, Buffer *mBuf));
PRIVATE S16 cmPkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
PRIVATE S16 cmPkKwSsta ARGS ((KwMngmt *ssta, Elmnt etmnt, Event eventType,
PRIVATE S16 cmUnpkKwMngmt ARGS ((KwMngmt *param, Event eventType,
Buffer * mBuf));
-PRIVATE S16 cmUnpkKwCfg ARGS ((KwMngmt *cfg, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmUnpkRlcCfg ARGS ((KwMngmt *cfg, Elmnt elmnt, Buffer *mBuf));
PRIVATE S16 cmUnpkKwCntrl ARGS ((KwMngmt *param, Elmnt elmnt, Buffer *mBuf));
PRIVATE S16 cmUnpkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
PRIVATE S16 cmUnpkKwSsta ARGS ((KwMngmt *ssta, Elmnt elmnt, Event eventType,
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwCfgReq
+PUBLIC S16 packRlcConfigReq
(
Pst *pst, /* post structure */
KwMngmt *cfg /* RLC LM structure */
)
#else
-PUBLIC S16 cmPkLkwCfgReq(pst, cfg)
+PUBLIC S16 packRlcConfigReq(pst, cfg)
Pst *pst; /* post structure */
KwMngmt *cfg; /* RLC LM structure */
#endif
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwCfgReq)
+ TRC3(packRlcConfigReq)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
RETVALUE(ROK);
-} /* end of cmPkLkwCfgReq */
+} /* end of packRlcConfigReq */
/**
* @brief
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwCfgReq
+PUBLIC S16 unpackRlcConfigReq
(
-LkwCfgReq func, /* primitive to call */
+RlcConfigReq func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwCfgReq(func, pst, mBuf)
-LkwCfgReq func; /* primitive to call */
+PUBLIC S16 unpackRlcConfigReq(func, pst, mBuf)
+RlcConfigReq func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
S16 ret1; /* Return value */
KwMngmt cfg; /* RLC LM structure */
- TRC3(cmUnpkLkwCfgReq)
+ TRC3(unpackRlcConfigReq)
cmMemset((U8 *) &cfg, (U8) 0, (S16) sizeof(KwMngmt));
ret1 = cmUnpkKwMngmt(&cfg, LKW_EVT_CFG_REQ, mBuf);
RETVALUE(ROK);
-} /* end of cmUnpkLkwCfgReq */
+} /* end of unpackRlcConfigReq */
#ifdef ANSI
-PUBLIC S16 cmPkLkwCfgCfm
+PUBLIC S16 packRlcConfigCfm
(
Pst *pst, /* post structure */
KwMngmt *cfm /* RLC LM structure */
)
#else
-PUBLIC S16 cmPkLkwCfgCfm(pst,cfm)
+PUBLIC S16 packRlcConfigCfm(pst,cfm)
Pst *pst; /* post structure */
KwMngmt *cfm; /* RLC LM structure */
#endif
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwCfgCfm)
+ TRC3(packRlcConfigCfm)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
RETVALUE(ROK);
-} /* end of cmPkLkwCfgCfm */
+} /* end of packRlcConfigCfm */
/**
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwCfgCfm
+PUBLIC S16 unpackRlcConfigCfm
(
-LkwCfgCfm func, /* primitive to call */
+RlcConfigCfm func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwCfgCfm(func, pst, mBuf)
-LkwCfgCfm func; /* primitive to call */
+PUBLIC S16 unpackRlcConfigCfm(func, pst, mBuf)
+RlcConfigCfm func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
S16 ret1; /* return value */
KwMngmt cfm; /* RLC LM structure */
- TRC3(cmUnpkLkwCfgCfm)
+ TRC3(unpackRlcConfigCfm)
ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CFG_CFM, mBuf);
SPutMsg(mBuf);
RETVALUE((*func)(pst, &cfm));
-} /* end of cmUnpkLkwCfgCfm */
+} /* end of unpackRlcConfigCfm */
switch( eventType )
{
case LKW_EVT_CFG_REQ:
- ret1 = cmPkKwCfg(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmPkRlcCfg(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
RETVALUE(RFAILED);
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmPkKwCfg
+PRIVATE S16 cmPkRlcCfg
(
KwMngmt *cfg,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmPkKwCfg(cfg, elmnt, mBuf)
+PRIVATE S16 cmPkRlcCfg(cfg, elmnt, mBuf)
KwMngmt *cfg;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmPkKwCfg)
+ TRC3(cmPkRlcCfg)
switch( elmnt )
{
RETVALUE(RFAILED);
}
RETVALUE(ROK);
-} /*end of function cmPkKwCfg*/
+} /*end of function cmPkRlcCfg*/
/**
switch( eventType )
{
case LKW_EVT_CFG_REQ:
- ret1 = cmUnpkKwCfg(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmUnpkRlcCfg(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
RETVALUE(RFAILED);
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmUnpkKwCfg
+PRIVATE S16 cmUnpkRlcCfg
(
KwMngmt *cfg,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmUnpkKwCfg(cfg ,elmnt, mBuf)
+PRIVATE S16 cmUnpkRlcCfg(cfg ,elmnt, mBuf)
KwMngmt *cfg;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwCfg)
+ TRC3(cmUnpkRlcCfg)
switch(elmnt)
{
} /* end of switch */
RETVALUE(ROK);
-} /* end of cmUnpkKwCfg */
+} /* end of cmUnpkRlcCfg */
/**
* @brief
/** @brief
* Configuration Structure
*/
-typedef struct kwCfg
+typedef struct rlcCfg
{
union
{
KwGenCfg gen; /*!< General configuraton. */
KwSapCfg sap; /*!< SAP configuration. */
}s;
-}KwCfg;
+}RlcCfg;
/** @brief
General Statistics Structure */
CmStatus cfm; /*!< Status of confirmation. */
union
{
- KwCfg cfg; /*!< General Configuration. */
+ RlcCfg cfg; /*!< General Configuration. */
KwCntrl cntrl; /*!< Control Structure. */
KwSts sts; /*!< Statistics. */
KwSSta ssta; /*!< Status. */
/* Control primitives towards LTE RLC */
/* Pointer functions to pack/unpack primitives */
-typedef S16 (*LkwCfgReq) ARGS((Pst *pst, KwMngmt *cfg));
-typedef S16 (*LkwCfgCfm) ARGS((Pst *pst, KwMngmt *cfgCfm));
+typedef S16 (*RlcConfigReq) ARGS((Pst *pst, KwMngmt *cfg));
+typedef S16 (*RlcConfigCfm) ARGS((Pst *pst, KwMngmt *cfgCfm));
typedef S16 (*LkwCntrlReq) ARGS((Pst *pst, KwMngmt *cntl));
typedef S16 (*LkwCntrlCfm) ARGS((Pst *pst, KwMngmt *cntlCfm));
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwCfgReq ARGS((Pst *pst, KwMngmt *cfg));
+EXTERN S16 KwMiRlcConfigReq ARGS((Pst *pst, KwMngmt *cfg));
/**
-@details This function is called by the KwMiLkwCfgReq function for responding to configuration requests.The cfm field in the KwMngmt structure contains the response value.
+@details This function is called by the KwMiRlcConfigReq function for responding to configuration requests.The cfm field in the KwMngmt structure contains the response value.
@param[in] pst - Pointer to post structure
@param[in] cfm - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwCfgCfm ARGS((Pst *pst, KwMngmt *cfgCfm));
+EXTERN S16 KwMiRlcConfigCfm ARGS((Pst *pst, KwMngmt *cfgCfm));
/**
@details
U32 ueId));
#ifdef SM
-EXTERN S16 SmMiLkwCfgCfm ARGS((
+EXTERN S16 SmMiRlcConfigCfm ARGS((
Pst *,
KwMngmt *
));
KwMngmt *
));
-EXTERN S16 SmMiLkwCfgReq ARGS((
+EXTERN S16 SmMiRlcConfigReq ARGS((
Pst *,
KwMngmt *
));
/* pack/unpack functions */
#ifdef LCLKW
-EXTERN S16 cmPkLkwCfgReq ARGS((
+EXTERN S16 packRlcConfigReq ARGS((
Pst *,
KwMngmt *
));
-EXTERN S16 cmPkLkwCfgCfm ARGS((
+EXTERN S16 packRlcConfigCfm ARGS((
Pst *,
KwMngmt *
));
Buffer *
));
-EXTERN S16 cmUnpkLkwCfgReq ARGS((
- LkwCfgReq,
+EXTERN S16 unpackRlcConfigReq ARGS((
+ RlcConfigReq,
Pst *,
Buffer *
));
-EXTERN S16 cmUnpkLkwCfgCfm ARGS((
- LkwCfgCfm,
+EXTERN S16 unpackRlcConfigCfm ARGS((
+ RlcConfigCfm,
Pst *,
Buffer *
));
EXTERN S16 cmUnpkLkwCntrlReq ARGS((
- LkwCfgReq,
+ RlcConfigReq,
Pst *,
Buffer *
));
EXTERN S16 cmUnpkLkwCntrlCfm ARGS((
- LkwCfgCfm,
+ RlcConfigCfm,
Pst *,
Buffer *
));
#include "legtp.h"
#include "lrg.x"
#include "lkw.x"
-#include "du_app_mac_inf.h"
-#include "du_cfg.h"
+#include "rgr.h"
+#include "rgr.x"
#include "E2AP-PDU.h"
#include<ProtocolIE-Field.h>
#include "F1AP-PDU.h"
-#include "du_cell_mgr.h"
+#include "du_f1ap_msg_hdl.h"
+#include "du_e2ap_msg_hdl.h"
+#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
+#include "du_cfg.h"
+#include "du_mgr.h"
#include "odu_common_codec.h"
+#include "du_cell_mgr.h"
extern DuCfgParams duCfgParam;
extern S16 duBuildAndSendMacCellCfg();
/* This file contains message handling functionality for DU APP */
#ifndef __DU_CELL_MGR_H__
#define __DU_CELL_MGR_H__
-#include "du_mgr.h"
-#include "du_log.h"
-#include "du_f1ap_msg_hdl.h"
-#include "du_e2ap_msg_hdl.h"
-#include "rgr.h"
-#include "rgr.x"
S16 duSendSchGnbCfg();
S16 duSendSchGnbCfgToMac(RgrCfgReqInfo *cfgReq, U32 trans_id);
-uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg);
#endif
/**********************************************************************
End of file
#include "lkw.x"
#include "lrg.x"
#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
#include "du_cfg.h"
#include "du_mgr.h"
#include "du_utils.h"
#include "lrg.x"
#include "legtp.h"
#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
#include "du_cfg.h"
+#include "du_mgr.h"
#include "du_mgr_main.h"
#include "du_utils.h"
#include "GlobalE2node-gNB-ID.h"
#include "lrg.h"
#include "lkw.x"
#include "lrg.x"
+#include "cm_inet.h"
#include "legtp.h"
+#include "cm_inet.x"
#include "du_app_mac_inf.h"
#include "du_cfg.h"
#include "du_egtp.h"
-#include "du_ue_mgr.h"
#include "du_utils.h"
/* Global variable declaration */
#ifndef __DU_EGTP_H__
#define __DU_EGTP_H__
-#include "du_mgr.h"
-#include "du_log.h"
-#include "cm_inet.h"
-#include "cm_tpt.h"
-#include "legtp.h"
-
-#include "cm_inet.x"
-#include "cm_tpt.x"
-
#define EGTP_DFLT_PORT 2152
#define EGTP_MAX_HDR_LEN 40
#define EGTP_MAX_MSG_RECV 10
}EgtpGlobalCb;
extern EgtpGlobalCb egtpCb; /* EGTP global control block */
+uint8_t duHdlEgtpDlData(EgtpMsg *egtpMsg);
S16 egtpActvInit(Ent entity, Inst inst, Region region, Reason reason);
S16 egtpActvTsk(Pst *pst, Buffer *mBuf);
S16 egtpFillRspPst(Pst *pst, Pst *rspPst);
#include "du_app_mac_inf.h"
#include "du_cfg.h"
#include "E2AP-PDU.h"
-#include "du_mgr.h"
#include "du_mgr_main.h"
-#include "du_f1ap_msg_hdl.h"
#include "du_utils.h"
#include "GNB-DU-System-Information.h"
#include "CellGroupConfigRrc.h"
#include<ProtocolIE-Field.h>
#include "ProtocolExtensionField.h"
#include "F1AP-PDU.h"
-#include "du_cell_mgr.h"
#include "odu_common_codec.h"
+#include "du_f1ap_msg_hdl.h"
S16 procGNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg);
uint8_t procDlRrcMsgTrans(F1AP_PDU_t *f1apMsg);
#define CELL_INDEX 0
void F1APMsgHdlr(Buffer *mBuf);
+uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg);
uint8_t BuildAndSendF1SetupReq();
uint8_t BuildAndSendDUConfigUpdate();
uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti, uint8_t *rrcContainer);
#define __DU_MGR_H__
#define DU_PROC 0
-/* Events */
-#define EVTCFG 0
-#define EVTSCTPSTRT 1
-#define EVENT_CU_DATA 2
-#define EVENT_SCTP_NTFY 3
-#define EVTSRVOPENREQ 4
-#define EVTSRVOPENCFM 5
-#define EVTTNLMGMTREQ 6
-#define EVTTNLMGMTCFM 7
-#define EVTSLOTIND 8
-#define EVTSTARTPOLL 9
-#define EVENT_RIC_DATA 10
-
-
/* SAP IDs */
#define DU_MAC_SUID 0
#define DU_MAC_SPID 0
uint32_t gnbCuUeF1apId; /* GNB CU UE F1AP ID */
UeState ueState;
MacUeCfg macUeCfg;
+ RlcUeCfg rlcUeCfg;
}DuUeCb;
typedef struct duCellCb
S16 duBuildRlcCfg(Inst inst);
S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst);
S16 duBuildRlcUsapCfg(U8 elemId, Ent ent, Inst inst);
-S16 duHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm);
+S16 DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm);
S16 duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cfm);
S16 duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm);
S16 duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm);
S16 duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm);
uint8_t duBuildAndSendMacCellStartReq();
uint8_t duBuildAndSendMacCellStopReq();
-
#endif
/**********************************************************************
#include "common_def.h"
#include "lrg.h"
#include "legtp.h"
+#include "lsctp.h"
+#include "legtp.h"
#include "lkw.h"
+#include "kwu.h"
#include "lrg.x"
#include "lkw.x"
+#include "kwu.x"
#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
#include "du_cfg.h"
+#include "du_mgr.h"
#include "E2AP-PDU.h"
#include "du_sctp.h"
+#include "F1AP-PDU.h"
#include "du_f1ap_msg_hdl.h"
#include "du_e2ap_msg_hdl.h"
-#include "lsctp.h"
-#include "legtp.h"
#include "du_app_mac_inf.h"
#include "du_ue_mgr.h"
-#include "kwu.x"
+#include "du_utils.h"
-extern S16 cmUnpkLkwCfgCfm(LkwCfgCfm func,Pst *pst, Buffer *mBuf);
+extern S16 unpackRlcConfigCfm(RlcConfigCfm func,Pst *pst, Buffer *mBuf);
extern S16 cmUnpkLkwCntrlCfm(LkwCntrlCfm func,Pst *pst, Buffer *mBuf);
extern S16 cmUnpkLrgCfgCfm(LrgCfgCfm func,Pst *pst, Buffer *mBuf);
-extern S16 cmUnpkKwuDatInd(KwuDatInd func,Pst *pst, Buffer *mBuf);
+extern uint8_t cmUnpkKwuDatInd(KwuDatInd func,Pst *pst, Buffer *mBuf);
extern S16 cmUnpkLrgSchCfgCfm(LrgSchCfgCfm func,Pst *pst,Buffer *mBuf);
/**************************************************************************
* @brief Task Initiation callback function.
{
case LKW_EVT_CFG_CFM:
{
- ret = cmUnpkLkwCfgCfm(duHdlRlcCfgComplete, pst, mBuf);
+ ret = unpackRlcConfigCfm(DuHdlRlcCfgComplete, pst, mBuf);
break;
}
case LKW_EVT_CNTRL_CFM:
ret = cmUnpkKwuDatInd(duHdlRlcUlData, pst, mBuf);
break;
}
+ case EVENT_RLC_UL_UE_CREATE_RSP:
+ {
+ ret = unpackRlcUlUeCreateRsp(DuProcRlcUlUeCreateRsp, pst, mBuf);
+ break;
+ }
default:
{
DU_LOG("\nDU_APP : Invalid event %d received at duActvTsk from ENTKW", \
}
case EVENT_MAC_UE_CREATE_RSP:
{
- ret = unpackDuMacUeCreateRsp(duHandleMacUeCreateRsp, pst, mBuf);
+ ret = unpackDuMacUeCreateRsp(DuHandleMacUeCreateRsp, pst, mBuf);
break;
}
#include "lrg.x"
#include "lkw.x"
#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
#include "du_cfg.h"
+#include "du_mgr.h"
#include "du_mgr_main.h"
#include "du_sctp.h"
#include "du_egtp.h"
-extern S16 kwUlActvTsk (Pst *, Buffer *);
-extern S16 kwUlActvInit (Ent, Inst, Region, Reason);
-extern S16 kwDlActvTsk (Pst *, Buffer *);
-extern S16 kwDlActvInit (Ent, Inst, Region, Reason);
+extern S16 rlcUlActvTsk (Pst *, Buffer *);
+extern S16 rlcUlActvInit (Ent, Inst, Region, Reason);
+extern S16 rlcDlActvTsk (Pst *, Buffer *);
+extern S16 rlcDlActvInit (Ent, Inst, Region, Reason);
extern S16 rgActvTsk (Pst *, Buffer *);
extern S16 rgActvInit (Ent, Inst, Region, Reason);
{
/* Register RLC DL TAPA Task */
if(SRegTTsk((Ent)ENTKW, (Inst)1, (Ttype)TTNORM, (Prior)PRIOR0,
- kwDlActvInit, (ActvTsk)kwDlActvTsk) != ROK)
+ rlcDlActvInit, (ActvTsk)rlcDlActvTsk) != ROK)
{
return RFAILED;
}
{
/* Register RLC UL TAPA Task */
if(SRegTTsk((Ent)ENTKW, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
- kwUlActvInit, (ActvTsk)kwUlActvTsk) != ROK)
+ rlcUlActvInit, (ActvTsk)rlcUlActvTsk) != ROK)
{
return RFAILED;
}
#ifndef __DU_MGR_MAIN_H__
#define __DU_MGR_MAIN_H__
-#include "du_mgr.h"
-#include "du_log.h"
-
/* Function declarations */
S16 duAppInit(SSTskId sysTskId);
S16 sctpInit(SSTskId sysTskId);
#include "lrg.h"
#include "legtp.h"
#include "lkw.h"
+#include "kwu.h"
#include "lrg.x"
#include "lkw.x"
+#include "kwu.x"
#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
#include "du_cfg.h"
#include "du_mgr.h"
#include "du_sctp.h"
+#include "F1AP-PDU.h"
#include "du_f1ap_msg_hdl.h"
#include "du_ue_mgr.h"
#include "lsctp.h"
U8 macCfgInst = 0;
extern DuCfgParams duCfgParam;
-extern S16 cmPkLkwCfgReq(Pst *pst, KwMngmt *cfg);
+extern S16 packRlcConfigReq(Pst *pst, KwMngmt *cfg);
extern S16 cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg);
extern S16 cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg);
extern S16 BuildAndSendE2SetupReq();
DU_LOG("\nDU_APP : RLC Gen Cfg Req sent for inst %d", inst);
/* Send the request to RLC */
- cmPkLkwCfgReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &kwMngmt);
return ROK;
}
DU_LOG("\nDU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
}
- cmPkLkwCfgReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &kwMngmt);
return ROK;
}
pst.region = duCb.init.region;
DU_LOG("\nDU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst);
- cmPkLkwCfgReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &kwMngmt);
return ROK;
}
*
* @details
*
- * Function : duHdlRlcCfgComplete
+ * Function : DuHdlRlcCfgComplete
*
* Functionality:
* Handles Gen Config Confirm from RLC
* RFAILED - failure
*
***************************************************************************/
-S16 duHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm)
+S16 DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm)
{
S16 ret = ROK;
if (pst->srcInst == RLC_UL_INST)
#include "legtp.h"
#include "lrg.x"
#include "lkw.x"
+#include "cm_inet.h"
+#include "cm_inet.x"
#include "du_app_mac_inf.h"
#include "du_cfg.h"
#include "du_sctp.h"
#ifndef __DU_SCTP_H__
#define __DU_SCTP_H__
-#include "du_mgr.h"
-#include "du_log.h"
-#include "cm_inet.h"
-#include "cm_tpt.h"
-
-#include "cm_inet.x"
-#include "cm_tpt.x"
-
#define DU_SCTP_DOWN 0
#define DU_SCTP_UP 1
#define DU_SCTP_CONNECTING 2
#include "legtp.h"
#include "du_app_mac_inf.h"
#include "du_cfg.h"
-#include "du_mgr.h"
#include "du_utils.h"
#include "BCCH-BCH-Message.h"
#include "MIB.h"
#include "common_def.h"
#include "lrg.h"
#include "lrg.x"
+#include "ckw.h"
+#include "ckw.x"
+#include "kwu.h"
+#include "kwu.x"
+#include "lkw.h"
#include "lkw.x"
#include "legtp.h"
#include "du_app_mac_inf.h"
+#include "du_app_rlc_inf.h"
#include "du_cfg.h"
-#include "du_ue_mgr.h"
#include "du_utils.h"
#include<ProtocolIE-Field.h>
#include "F1AP-PDU.h"
+#include "du_f1ap_msg_hdl.h"
+#include "du_mgr.h"
+#include "du_ue_mgr.h"
#ifdef EGTP_TEST
U32 sduId = 0;
packDuMacUeCreateReq, /* Light weight-loose coupling */
};
-/******************************************************************
- *
- * @brief Send UE configuration to RLC
- *
- * @details
- *
- * Function : duSendUeCreateReqToRlc
- *
- * Functionality: Send UeCreateReqToRlc
- *
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-S16 duSendUeCreateReqToRlc()
+DuRlcUlUeCreateReq packRlcUlUeCreateReqOpts[] =
{
- U8 idx;
- Pst pst;
- CkwCfgInfo *ueCfg;
-
- DU_SET_ZERO(&ueCfg, sizeof(ueCfg));
- DU_SET_ZERO(&pst, sizeof(Pst));
-
- DU_ALLOC(ueCfg, sizeof(CkwCfgInfo));
-
-#ifdef EGTP_TEST
- ueCfg->ueId = UE_ID;
-#endif
- ueCfg->cellId = NR_CELL_ID;
- ueCfg->numEnt = 1;
-
- for(idx = 0; idx < ueCfg->numEnt; idx++)
- {
-#ifdef EGTP_TEST
- ueCfg->entCfg[idx].rbId = RB_ID;
- ueCfg->entCfg[idx].rbType = CM_LTE_DRB;
- ueCfg->entCfg[idx].lCh[0].lChId = LC_ID;
- ueCfg->entCfg[idx].lCh[0].type = CM_LTE_LCH_DTCH;
-#endif
- ueCfg->entCfg[idx].entMode = CM_LTE_MODE_UM;
- ueCfg->entCfg[idx].dir = CKW_CFG_DIR_BOTH;
- switch(ueCfg->entCfg[idx].entMode)
- {
- case CM_LTE_MODE_TM:
- {
- break;
- }
-
- case CM_LTE_MODE_UM:
- {
- ueCfg->entCfg[idx].m.umInfo.dl.snLen = 1; /* For 12 bit SN */
- ueCfg->entCfg[idx].m.umInfo.ul.snLen = 1; /* For 12 bit SN */
- ueCfg->entCfg[idx].m.umInfo.ul.reOrdTmr = 10; /* in msec */
- break;
- }
-
- case CM_LTE_MODE_AM:
- {
- break;
- }
-
- default:
- break;
- } /* End of switch(entMode) */
- } /* End of entity configuration for loop */
-
- /* Fill Pst */
- pst.selector = ODU_SELECTOR_LWLC;
- pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
- pst.dstInst = RLC_UL_INST;
- pst.dstProcId = DU_PROC;
- pst.srcProcId = DU_PROC;
- pst.region = duCb.init.region;
-
- /* Sending to RLC */
- packUeCreateReq(&pst, ueCfg);
-
- RETVALUE(ROK);
-} /* End of duSendUeCreateReqToRlc */
+ packDuRlcUlUeCreateReq, /* Loose coupling */
+ RlcUlProcUeCreateReq, /* TIght coupling */
+ packDuRlcUlUeCreateReq, /* Light weight-loose coupling */
+};
/*******************************************************************
*
* RFAILED - failure
*
* ****************************************************************/
-S16 duHdlEgtpDlData(EgtpMsg *egtpMsg)
+uint8_t duHdlEgtpDlData(EgtpMsg *egtpMsg)
{
/* TODO : Extract RbId/UeID/CellID/SduId from database
using tunnel id in egtp header */
*
*****************************************************************/
-PUBLIC S16 duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf)
+uint8_t duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf)
{
DU_LOG("\nDU_APP : Received UL Data at DU_APP");
uint16_t idx2;
DlCcchIndInfo *dlCcchIndInfo = NULLP;
Pst pst;
-
memset(&pst, 0, sizeof(Pst));
+
DU_LOG("\nDU APP : Building and Sending DL CCCH Ind to MAC");
DU_ALLOC_SHRABL_BUF(dlCcchIndInfo, sizeof(DlCcchIndInfo));
*
*
*****************************************************************/
-void fillMacUeCfg(MacUeCfg *ueCfg)
+void fillMacUeCfg(uint16_t cellId, uint8_t ueIdx,\
+ uint16_t crnti, MacUeCfg *ueCfg)
{
uint8_t idx;
-
+ ueCfg->cellId = cellId;
+ ueCfg->ueIdx = ueIdx;
+ ueCfg->crnti = crnti;
/* Filling MacCellGroup Config */
fillMacCellGrpInfo(&ueCfg->macCellGrpCfg);
/* Filling PhyCellGroup Config */
}
+/******************************************************************
+ *
+ * @brief Fills Rlc AM Information
+ *
+ * @details
+ *
+ * Function : fillAmInfo
+ *
+ * Functionality: Fills Rlc AM Information
+ *
+ *
+ *****************************************************************/
+void fillAmInfo(AmBearerCfg *amCfg)
+{
+ /* DL AM */
+ amCfg->dlAmCfg.snLenDl = AM_SIZE_12;
+ amCfg->dlAmCfg.pollRetxTmr = POLL_RETX_TMR_45MS;
+ amCfg->dlAmCfg.pollPdu = POLL_PDU_TMR_INFINITY;
+ amCfg->dlAmCfg.pollByte = POLL_BYTES_INFINITY;
+ amCfg->dlAmCfg.maxRetxTh = RETX_TH_8;
+
+ /* UL AM */
+ amCfg->ulAmCfg.snLenUl = AM_SIZE_12;
+ amCfg->ulAmCfg.reAssemTmr = RE_ASM_40MS;
+ amCfg->ulAmCfg.statProhTmr = PROH_35MS;
+
+}
+
+/******************************************************************
+ *
+ * @brief Fills RLC UM Bi Directional Information
+ *
+ * @details
+ *
+ * Function : fillUmBiDirInfo
+ *
+ * Functionality: Fills RLC UM Bi Directional Information
+ *
+ *
+ *****************************************************************/
+void fillUmBiDirInfo(UmBiDirBearerCfg *umBiDirCfg)
+{
+ /* UL UM BI DIR INFO */
+ umBiDirCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
+ umBiDirCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS;
+
+ /* DL UM BI DIR INFO */
+ umBiDirCfg->dlUmCfg.snLenDlUm = UM_SIZE_12;
+
+}
+
+/******************************************************************
+ *
+ * @brief Fills RLC UM Uni Directional UL Information
+ *
+ * @details
+ *
+ * Function : fillUmUniDirUlInfo
+ *
+ * Functionality: Fills RLC UM Uni Directional Info
+ *
+ *
+ *****************************************************************/
+void fillUmUniDirUlInfo(UmUniDirUlBearerCfg *umUniDirUlCfg)
+{
+ umUniDirUlCfg->ulUmCfg.snLenUlUm = UM_SIZE_12;
+ umUniDirUlCfg->ulUmCfg.reAssemTmr = RE_ASM_40MS;
+}
+
+/******************************************************************
+ *
+ * @brief Fills RLC UM Uni Directional DL Information
+ *
+ * @details
+ *
+ * Function : fillUmUniDirDlInfo
+ *
+ * Functionality: Fills RLC UM Uni Directional DL Info
+ *
+ *
+ *****************************************************************/
+void fillUmUniDirDlInfo(UmUniDirDlBearerCfg *umUniDirDlCfg)
+{
+ umUniDirDlCfg->dlUmCfg.snLenDlUm = UM_SIZE_12;
+}
+
+/******************************************************************
+ *
+ * @brief Fills RlcBearerCfg structure
+ *
+ * @details
+ *
+ * Function : fillRlcBearerCfg
+ *
+ * Functionality: Fills Rlc Bearer Cfg
+ *
+ *
+ *****************************************************************/
+void fillRlcBearerCfg(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *ueCfg)
+{
+ uint8_t idx;
+ ueCfg->cellId = cellId;
+ ueCfg->ueIdx = ueIdx;
+ ueCfg->numLcs = SRB_ID_1;
+
+ for(idx = 0; idx < ueCfg->numLcs; idx++)
+ {
+ ueCfg->rlcBearerCfg[idx].rbId = RB_ID_SRB;
+ ueCfg->rlcBearerCfg[idx].rbType = RB_TYPE_SRB;
+ ueCfg->rlcBearerCfg[idx].lcId = SRB_ID_1;
+ ueCfg->rlcBearerCfg[idx].lcType = LCH_DCCH;
+ ueCfg->rlcBearerCfg[idx].rlcMode = RLC_AM;
+ switch(ueCfg->rlcBearerCfg[idx].rlcMode)
+ {
+ case RLC_AM:
+ memset(&ueCfg->rlcBearerCfg[idx].u.amCfg, 0, sizeof(AmBearerCfg));
+ fillAmInfo(&ueCfg->rlcBearerCfg[idx].u.amCfg);
+ break;
+ case RLC_UM_BI_DIRECTIONAL:
+ memset(&ueCfg->rlcBearerCfg[idx].u.umBiDirCfg, 0, sizeof(UmBiDirBearerCfg));
+ fillUmBiDirInfo(&ueCfg->rlcBearerCfg[idx].u.umBiDirCfg);
+ break;
+ case RLC_UM_UNI_DIRECTIONAL_UL:
+ memset(&ueCfg->rlcBearerCfg[idx].u.umUniDirUlCfg, 0, sizeof(UmUniDirUlBearerCfg));
+ fillUmUniDirUlInfo(&ueCfg->rlcBearerCfg[idx].u.umUniDirUlCfg);
+ break;
+ case RLC_UM_UNI_DIRECTIONAL_DL:
+ memset(&ueCfg->rlcBearerCfg[idx].u.umUniDirDlCfg, 0, sizeof(UmUniDirDlBearerCfg));
+ fillUmUniDirDlInfo(&ueCfg->rlcBearerCfg[idx].u.umUniDirDlCfg);
+ break;
+ default :
+ DU_LOG("\nDU_APP: Rlc Mode invalid %d", ueCfg->rlcBearerCfg[idx].rlcMode);
+ break;
+ }
+ }
+}
+
/******************************************************************
*
* @brief creates UE context
/* Filling Mac Ue Config */
memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg, 0, sizeof(MacUeCfg));
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.cellId = ueCcchCtxt->cellId;
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.ueIdx = ueIdx;
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.crnti = ueCcchCtxt->crnti;
- fillMacUeCfg(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg);
+ ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueIdx, ueCcchCtxt->crnti,\
+ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg);
+ if(ret)
+ DU_LOG("\nDU_APP: Failed to send UE create request to MAC");
+
+ /* Filling Rlc Ue Config */
+ memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, 0, sizeof(RlcUeCfg));
+ ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueIdx, \
+ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg);
+ if(ret)
+ DU_LOG("\nDU_APP: Failed to send UE create request to RLC");
+
duCb.actvCellLst[cellIdx]->numActvUes++;
memset(ueCcchCtxt, 0, sizeof(UeCcchCtxt));
-
- /* Send Ue Create Request to MAC */
- ret = duBuildAndSendUeCreateReqToMac(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg.cellId, ueIdx);
- if(ret)
- DU_LOG("\nDU_APP: Failed to send UE create request to MAC");
}
}
-
return ret;
}
*
* ****************************************************************/
-uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx)
+uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\
+ uint16_t crnti, MacUeCfg *duMacUeCfg)
{
uint8_t ret = ROK;
MacUeCfg *macUeCfg = NULLP;
Pst pst;
-
memset(&pst, 0, sizeof(Pst));
+ fillMacUeCfg(cellId, ueIdx, crnti, duMacUeCfg);
+
/* Fill Pst */
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ);
{
memset(macUeCfg, 0, sizeof(MacUeCfg));
memcpy(macUeCfg, &duCb.actvCellLst[cellId - 1]->ueCb[ueIdx].macUeCfg, sizeof(MacUeCfg));
+ DU_LOG("\nDU_APP: Sending UE create request to MAC");
/* Processing one Ue at a time to MAC */
ret = (*packMacUeCreateReqOpts[pst.selector])(&pst, macUeCfg);
if(ret)
}
else
{
- DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReq()");
+ DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToMac()");
ret = RFAILED;
}
return ret;
*
* @details
*
- * Function : duHandleMacUeCreateRsp
+ * Function : DuHandleMacUeCreateRsp
*
* Functionality: Handle UE create response from MAC
*
- * @params[in]
+ * @params[in] Pointer to MacUeCfgRsp and Pst
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t duHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
+uint8_t DuHandleMacUeCreateRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
{
if(cfgRsp->result == MAC_DU_APP_RSP_OK)
{
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Processes UE create Req to RLC UL
+ *
+ * @details
+ *
+ * Function : duBuildAndSendUeCreateReqToRlc
+ *
+ * Functionality:
+ * Processes UE create Req to RLC UL
+ *
+ * @params[in] cellId,
+ * ueIdx,
+ * Pointer to RlcUeCfg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *duRlcUeCfg)
+{
+ uint8_t ret = ROK;
+ RlcUeCfg *rlcUeCfg = NULLP;
+ Pst pst;
+ memset(&pst, 0, sizeof(Pst));
+
+ fillRlcBearerCfg(cellId, ueIdx, duRlcUeCfg);
+ FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UL_UE_CREATE_REQ);
+
+ /* Copying ueCfg to a sharable buffer */
+ DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
+ if(rlcUeCfg)
+ {
+ memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
+ memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg));
+ /* Processing one Ue at a time to RLC */
+ DU_LOG("\nDU_APP: Sending UE create request to RLC UL");
+ ret = (*packRlcUlUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
+ if(ret)
+ {
+ DU_LOG("\nDU_APP : Failure in sending Ue Create Req to RLC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\n DU_APP: Memory alloc failed at duBuildAndSendUeCreateReqToRlc()");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+
+
+/*******************************************************************
+ *
+ * @brief Processes UE create Rsp received from RLC UL
+ *
+ * @details
+ *
+ * Function : DuProcRlcUlUeCfgRsp
+ *
+ * Functionality:
+ * Processes UE create Rsp received from RLC UL
+ *
+ * @params[in] Post structure
+ * Pointer to RlcCfgCfm
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t DuProcRlcUlUeCreateRsp(Pst *pst, RlcUeCfgRsp *cfgRsp)
+{
+ uint8_t ret = ROK;
+
+ if(cfgRsp)
+ {
+ if(cfgRsp->result == RLC_DU_APP_RSP_OK)
+ {
+ DU_LOG("\nDU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueIdx);
+ }
+ else
+ {
+ DU_LOG("\nDU_APP: RLC UE Create Response : FAILED [UE IDX:%d, REASON :%d]",\
+ cfgRsp->ueIdx, cfgRsp->reason);
+ ret = RFAILED;
+ }
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
+ }
+ else
+ {
+ DU_LOG("\nDU_APP: Received RLC Ue Create Response is NULL");
+ ret = RFAILED;
+ }
+ return ret;
+}
/**********************************************************************
End of file
***********************************************************************/
#ifndef __DU_UE_MGR_H__
#define __DU_UE_MGR_H__
-#include "du_mgr.h"
-#include "du_log.h"
-#include "du_f1ap_msg_hdl.h"
-#include "ckw.h"
-#include "kwu.h"
-
-#include "ckw.x"
-#include "kwu.x"
-
-S16 duHdlEgtpDlData(EgtpMsg *egtpMsg);
-S16 duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf);
-S16 packUeCreateReq(Pst *pst,CkwCfgInfo *cfgInfo);
-S16 cmPkKwuDatReq(Pst * pst,KwuDatReqInfo* datReq,Buffer * mBuf);
-uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx);
+uint8_t duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf);
+uint8_t cmPkKwuDatReq(Pst * pst,KwuDatReqInfo* datReq,Buffer * mBuf);
+uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\
+ uint16_t crnti, MacUeCfg *duMacUeCfg);
+uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx, RlcUeCfg *duRlcUeCfg);
uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId);
uint8_t duProcUlCcchInd(UlCcchIndInfo *ulCcchIndInfo);
#endif
#define RLC_POOL 1
#define MAC_POOL 1
+/* Events */
+#define EVTCFG 0
+#define EVTSCTPSTRT 1
+#define EVENT_CU_DATA 2
+#define EVENT_SCTP_NTFY 3
+#define EVTSRVOPENREQ 4
+#define EVTSRVOPENCFM 5
+#define EVTTNLMGMTREQ 6
+#define EVTTNLMGMTCFM 7
+#define EVTSLOTIND 8
+#define EVTSTARTPOLL 9
+#define EVENT_RIC_DATA 10
+
/* allocate and zero out a static buffer */
#define DU_ALLOC(_datPtr, _size) \
{ \
_pst.intfVer = 0; \
}
+/* Fill Pst structure for sending msg from DU_APP to RLC */
+#define FILL_PST_DUAPP_TO_RLC(_pst, _dstInst, _event) \
+{ \
+ _pst.selector = ODU_SELECTOR_LWLC; \
+ _pst.srcEnt = ENTDUAPP; \
+ _pst.dstEnt = ENTKW; \
+ _pst.dstInst = _dstInst; \
+ _pst.srcInst = DU_INST; \
+ _pst.dstProcId = DU_PROC; \
+ _pst.srcProcId = DU_PROC; \
+ _pst.region = DU_APP_MEM_REGION; \
+ _pst.pool = DU_POOL; \
+ _pst.event = _event; \
+ _pst.route = 0; \
+ _pst.prior = 0; \
+ _pst.intfVer = 0; \
+}
+
/**********************************************************************
End of file
**********************************************************************/
Code Review / o-du / l2.git / commitdiff