/********************************************************************20**
- Name: LTE - RLC - Layer Manager file
+ Name: NR RLC - Layer Manager file
Type: C source file
File: kw_lmm.c
*********************************************************************21*/
-static const char* RLOG_MODULE_NAME="LMM";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=197;
/** @file kw_lmm.c
@brief RLC Layer Manager Module
**/
* Forward Declaration of LKW Porting Functions
********************************************************************/
RlcCb *rlcCb[MAX_RLC_INSTANCES];
-EXTERN S16 rlcActvTmr ARGS ((Ent ent, Inst inst));
+S16 rlcActvTmr ARGS ((Ent ent, Inst inst));
-PRIVATE Void rlcLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,RlcMngmt *cfm,U8 type,
+static Void rlcLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,RlcMngmt *cfm,uint8_t type,
Header *hdr));
-PRIVATE S16 rlcLmmGenCfg ARGS ((RlcCb *gCb, RlcGenCfg *cfg));
-PRIVATE S16 rlcLmmCfgKwuSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
-PRIVATE S16 rlcLmmCfgUdxSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
-PRIVATE S16 rlcLmmCfgCkwSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
-PRIVATE S16 rlcLmmCfgRguSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
-PRIVATE S16 rlcLmmGenCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
-PRIVATE S16 rlcLmmUdxSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
-PRIVATE S16 rlcLmmLSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
-PRIVATE S16 rlcLmmGetKwuSapSta ARGS ((RlcCb *gCb,RlcKwuSapSta *sta));
-PRIVATE S16 rlcLmmGetRguSapSta ARGS ((RlcCb *gCb,RlcRguSapSta *sta));
-PRIVATE S16 rlcLmmGetCkwCntSapSta ARGS ((RlcCb *gCb,RlcCkwCntSapSta *sta));
-PRIVATE S16 rlcLmmGetGenSts ARGS ((RlcCb *gCb,RlcGenSts *sts,Action action));
-PRIVATE S16 rlcLmmGetSapSts ARGS ((RlcCb *gCb,RlcMngmt *sts,Elmnt elmnt,Action
+static S16 rlcLmmGenCfg ARGS ((RlcCb *gCb, RlcGenCfg *cfg));
+static S16 rlcLmmCfgKwuSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+static S16 rlcLmmCfgUdxSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+static S16 rlcLmmCfgCkwSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+static S16 rlcLmmCfgRguSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+static S16 rlcLmmGenCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
+static S16 rlcLmmUdxSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
+static S16 rlcLmmLSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
+static S16 rlcLmmGetKwuSapSta ARGS ((RlcCb *gCb,RlcKwuSapSta *sta));
+static S16 rlcLmmGetRguSapSta ARGS ((RlcCb *gCb,RlcRguSapSta *sta));
+static S16 rlcLmmGetCkwCntSapSta ARGS ((RlcCb *gCb,RlcCkwCntSapSta *sta));
+static S16 rlcLmmGetGenSts ARGS ((RlcCb *gCb,RlcGenSts *sts,Action action));
+static S16 rlcLmmGetSapSts ARGS ((RlcCb *gCb,RlcMngmt *sts,Elmnt elmnt,Action
action));
\f
* LCM_REASON_INVALID_PAR_VAL
* LCM_REASON_HASHING_FAILED
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmGenCfg
-(
-RlcCb *gCb,
-RlcGenCfg *cfg
-)
-#else
-PRIVATE S16 rlcLmmGenCfg(gCB,cfg)
-RlcCb *gCb;
-RlcGenCfg *cfg;
-#endif
+static S16 rlcLmmGenCfg(RlcCb *gCb,RlcGenCfg *cfg)
{
Size rlcSapSize;
Size rlcUdxSapSize;
CmTqCp *rlcTqCp;
Size rguSapSize;
- TRC2(rlcLmmGenCfg)
-
if(cfg->maxUe > RLC_MAX_UE)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- RLOG2(L_ERROR, "Invalid maxUe : Max [%lu] Received [%lu]",
+ DU_LOG("\nERROR --> RLC : Invalid maxUe : Max [%lu] Received [%lu]",
RLC_MAX_UE,
cfg->maxUe);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(cfg->maxKwuSaps > RLC_MAX_KWUSAPS)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- RLOG2(L_ERROR, "Invalid maxKwuSaps : Max [%lu] Received [%lu]",
+ DU_LOG("\nERROR --> RLC : Invalid maxKwuSaps : Max [%lu] Received [%lu]",
RLC_MAX_KWUSAPS,
cfg->maxKwuSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(cfg->maxUdxSaps > RLC_MAX_UDXSAPS)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- RLOG2(L_ERROR, "Invalid maxUduSaps : Max [%lu] Received [%lu]",
+ DU_LOG("\nERROR --> RLC : Invalid maxUduSaps : Max [%lu] Received [%lu]",
RLC_MAX_UDXSAPS,
cfg->maxUdxSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_ALLOC(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
if (gCb->u.dlCb == NULLP)
{
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
if(gCb->u.dlCb->rlcKwuDlSap == NULLP)
{
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
{
RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- RLOG0(L_FATAL,"RLC DL Initialization failed");
+ DU_LOG("\nERROR --> RLC_DL : RLC DL Initialization failed");
return (LCM_REASON_MEM_NOAVAIL);
}
-#if 0
+
/* Register the timer */
-/*Pradeep: changing the SRegTmrMt() to SRegTmr()*/
- if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
+ if(ODU_REG_TMR_MT(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
rlcActvTmr) != ROK)
{
RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
return (LCM_REASON_REGTMR_FAIL);
}
-#endif
+
/* initializations for background processing of freeing memory */
rlcUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
rlcUtlInitializeSelfPst(gCb);
RLC_ALLOC(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
if (gCb->u.ulCb == NULLP)
{
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
if(gCb->u.ulCb->rlcKwuUlSap == NULLP)
{
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
{
RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- RLOG0(L_FATAL,"RLC DL Initialization failed");
+ DU_LOG("\nERROR --> RLC_DL : RLC DL Initialization failed");
}
/* Register the timer */
-#if 0
- if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
+ if(ODU_REG_TMR_MT(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
rlcActvTmr) != ROK)
{
RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
return (LCM_REASON_REGTMR_FAIL);
}
-#endif
+
#ifdef LTE_L2_MEAS
rlcUtlL2MeasUlInit(gCb);
#endif
else
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- RLOG0(L_ERROR, "Received Invalid RLC Mode");
+ DU_LOG("\nERROR --> RLC : Received Invalid RLC Mode");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
return (LCM_REASON_INVALID_PAR_VAL);
/* Timer Initialization */
gCb->rlcTqCp.tmrLen = RLC_TMR_LEN;
- cmMemset((U8*)gCb->rlcTq, NULLP, sizeof(CmTqType) * RLC_TMR_LEN);
+ memset(gCb->rlcTq, NULLP, sizeof(CmTqType) * RLC_TMR_LEN);
RLC_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
* @return S16
* -# ROK
*/
-#ifdef ANSI
-PRIVATE Void rlcLmmSendCfm
+static Void rlcLmmSendCfm
(
RlcCb *gCb,
-Pst *pst,
+Pst *pst,
RlcMngmt *cfm,
-U8 type,
-Header *hdr
+uint8_t type,
+Header *hdr
)
-#else
-PRIVATE Void rlcLmmSendCfm(gCb,pst, cfm, type, hdr)
-RlcCb gCb;
-Pst *pst;
-RlcMngmt *cfm;
-U8 type;
-Header *hdr;
-#endif
{
Pst rPst; /* Reply post structure */
- TRC2(rlcLmmSendCfm);
-
RLC_MEM_SET(&rPst, 0, sizeof(Pst));
/* reply post structure for confirmation */
break;
default:
#if (ERRCLASS & ERRCLS_INT_PAR)
- RLOG0(L_ERROR, "Received Invalid Message Type");
+ DU_LOG("\nERROR --> RLC : Received Invalid Message Type");
if(!gCb)
{
fflush(stdout);
break;
}
- RETVOID;
+ return;
}
* -# Failure : RFAILED
*/
-#ifdef ANSI
-uint8_t RlcMiRlcConfigReq
-(
-Pst *pst,
-RlcMngmt *cfg
-)
-#else
-uint8_t RlcMiRlcConfigReq (pst, cfg)
-Pst *pst;
-RlcMngmt *cfg;
-#endif
+uint8_t RlcMiRlcConfigReq (Pst *pst,RlcMngmt *cfg)
{
Reason reason; /* failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiRlcConfigReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
return (RFAILED);
}
- RLOG1(L_DEBUG, "RlcMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
+ DU_LOG("\nDEBUG --> RLC : RlcMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
switch(cfg->hdr.elmId.elmnt)
{
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-uint8_t RlcMiLkwCntrlReq
-(
-Pst *pst,
-RlcMngmt *cntrl
-)
-#else
-uint8_t RlcMiLkwCntrlReq(pst, cntrl)
-Pst *pst;
-RlcMngmt *cntrl;
-#endif
+uint8_t RlcMiLkwCntrlReq(Pst *pst, RlcMngmt *cntrl)
{
Reason reason; /* failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiLkwCntrlReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
return (RFAILED);
}
- RLOG1(L_DEBUG, "RlcMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
+ DU_LOG("\nDEBUG --> RLC : RlcMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
/* In normal cases, LCM_REASON_NOT_APPL is returned in cfm.
* In all error cases appropriate reason is returned
* -# ROK (SUCCESS)
* -# RFAILED
*/
-#ifdef ANSI
-S16 RlcMiLkwStaReq
-(
-Pst *pst,
-RlcMngmt *sta
-)
-#else
-S16 RlcMiLkwStaReq(pst, sta)
-Pst *pst;
-RlcMngmt *sta;
-#endif
+S16 RlcMiLkwStaReq(Pst *pst,RlcMngmt *sta)
{
RlcMngmt rSta; /* Status */
Reason reason; /* Failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiLkwStaReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
return (RFAILED);
}
- RLOG1(L_DEBUG, "Status request for elmId(%d))", sta->hdr.elmId.elmnt);
+ DU_LOG("\nDEBUG --> RLC : Status request for elmId(%d))", sta->hdr.elmId.elmnt);
reason = LCM_REASON_NOT_APPL;
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-S16 RlcMiLkwStsReq
-(
-Pst *pst,
-Action action,
-RlcMngmt *sts
-)
-#else
-S16 RlcMiLkwStsReq (pst, action, sts)
-Pst *pst;
-Action action;
-RlcMngmt *sts;
-#endif
+S16 RlcMiLkwStsReq (Pst *pst, Action action,RlcMngmt *sts)
{
RlcMngmt rSts; /* Statistics */
Reason reason; /* Reason for failure */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiLkwStsReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
return (RFAILED);
}
- RLOG2(L_DEBUG, "RlcMiLkwStsReq(elmId(%d),action(%d))",
+ DU_LOG("\nDEBUG --> RLC : RlcMiLkwStsReq(elmId(%d),action(%d))",
action,
sts->hdr.elmId.elmnt);
* -# Success : ROK
* -# Failure : RFAILED
*/
-#ifdef ANSI
-S16 RlcMiLkwL2MeasReq
-(
-Pst *pst,
-RlcL2MeasReqEvt *measReqEvt
-)
-#else
-S16 RlcMiLkwL2MeasReq (pst, measReqEvt)
-Pst *pst;
-RlcL2MeasReqEvt *measReqEvt;
-#endif
+S16 RlcMiLkwL2MeasReq(Pst *pst, RlcL2MeasReqEvt *measReqEvt)
{
S16 ret = ROK;
- U16 cntr;
- U8 measType;
+ uint16_t cntr;
+ uint8_t measType;
RlcL2MeasCfmEvt measCfmEvt;
RlcCb *tRlcCb;
- TRC3(RlcMiLkwL2MeasReq);
-
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* Initialize measCfmEvt */
#if (ERRCLASS & ERRCLS_ADD_RES) /* KW_FIX */
if(measEvt == NULLP)
{
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return RFAILED;
}
#endif
- cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(RlcL2MeasReqEvt));
+ memcpy(measEvt, measReqEvt, sizeof(RlcL2MeasReqEvt));
/*Redirect the request to DL task */
/* NOTE:As of today, there are no cases where the Req will fail at DL
as long as it reached the DL, so we don't wait for a confirmation from
* -# Failure : RFAILED
*/
-#ifdef ANSI
-S16 RlcMiLkwL2MeasStopReq
-(
-Pst *pst,
-U8 measType
-)
-#else
-S16 RlcMiLkwL2MeasStopReq (pst, measType)
-Pst *pst;
-U8 measType;
-#endif
+S16 RlcMiLkwL2MeasStopReq(Pst *pst,uint8_t measType)
{
S16 ret = ROK;
RlcL2MeasEvtCb *measEvtCb = NULLP;
- U16 cntr;
- U8 status = ROK;
+ uint16_t cntr;
+ uint8_t status = ROK;
RlcCb *tRlcCb;
- TRC3(RlcMiLkwL2MeasStopReq);
-
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* reset the counter values for the measurement that is stopped */
rlcUlUdxL2MeasStopReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measType);
/*return ROK;*/
}
- /*cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
+ /*memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
status = LCM_PRIM_OK;
RlcMiLkwL2MeasStopCfm(&tRlcCb->genCfg.lmPst, measType,status);
* -# Failure : RFAILED
*/
-#ifdef ANSI
-S16 RlcMiLkwL2MeasSendReq
-(
-Pst *pst,
-U8 measType
-)
-#else
-S16 RlcMiLkwL2MeasSendReq (pst, measType)
-Pst *pst;
-U8 measType;
-#endif
+S16 RlcMiLkwL2MeasSendReq(Pst *pst,uint8_t measType)
{
/*S16 ret = ROK;*/
RlcL2MeasEvtCb *measEvtCb = NULLP;
- U16 cntr;
+ uint16_t cntr;
RlcCb *tRlcCb;
- TRC3(RlcMiLkwL2MeasSendReq);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
* -# LCM_REASON_MEM_NOAVAIL
* -# LCM_REASON_RECONFIG_FAIL
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmCfgKwuSap
-(
-RlcCb *gCb,
-RlcSapCfg *cfg
-)
-#else
-PRIVATE S16 rlcLmmCfgKwuSap(gCb,cfg)
-RlcCb *gCb;
-RlcSapCfg *cfg;
-#endif
+static S16 rlcLmmCfgKwuSap(RlcCb *gCb,RlcSapCfg *cfg)
{
RlcKwuSapCb *rlcKwuSapCb;
- TRC2(rlcLmmCfgKwuSap)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
/* Check for reconfiguration */
if (rlcKwuSapCb->state != RLC_SAP_NOT_CFG)
{
- RLOG2(L_ERROR,"RLC Mode [%d] : Invalid rlckwuSap State [%d]",
+ DU_LOG("\nERROR --> RLC : RLC Mode [%d] : Invalid rlckwuSap State [%d]",
gCb->genCfg.rlcMode, rlcKwuSapCb->state);
/* reconfiguration not allowed */
return (LCM_REASON_RECONFIG_FAIL);
* -# LCM_REASON_INVALID_SAP
* -# LCM_REASON_RECONFIG_FAIL
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmCfgCkwSap
-(
-RlcCb *gCb,
-RlcSapCfg *cfg
-)
-#else
-PRIVATE S16 rlcLmmCfgCkwSap(gCb,cfg)
-RlcCb *gCb;
-RlcSapCfg *cfg;
-#endif
+static S16 rlcLmmCfgCkwSap(RlcCb *gCb,RlcSapCfg *cfg)
{
RlcCkwSapCb *ckwSap;
- TRC2(rlcLmmCfgCkwSap)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate config parameters */
if ((cfg->sapId >= RLC_MAX_CKWSAPS) || (cfg->sapId < 0) )
/* Check for reconfiguration */
if(ckwSap->state != RLC_SAP_NOT_CFG)
{
- RLOG1(L_ERROR,"Invalid rlckwuSap State [%d]",ckwSap->state);
+ DU_LOG("\nERROR --> RLC : Invalid rlckwuSap State [%d]",ckwSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
* -# LCM_REASON_INVALID_SAP
* -# LCM_REASON_RECONFIG_FAIL
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmCfgUdxSap
-(
-RlcCb *gCb,
-RlcSapCfg *cfg
-)
-#else
-PRIVATE S16 rlcLmmCfgUdxSap(gCb,cfg)
-RlcCb *gCb;
-RlcSapCfg *cfg;
-#endif
+static S16 rlcLmmCfgUdxSap(RlcCb *gCb,RlcSapCfg *cfg)
{
RlcUdxDlSapCb *udxDlSap;
RlcUdxUlSapCb *udxUlSap;
- TRC2(rlcLmmCfgUdxSap);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
if((cfg->sapId >= RLC_MAX_UDXSAPS) || (cfg->sapId < 0))
/* Check for reconfiguration */
if(udxDlSap->state != RLC_SAP_NOT_CFG)
{
- RLOG1(L_ERROR,"Invalid udxDlSap State [%d]",udxDlSap->state);
+ DU_LOG("\nERROR --> RLC : Invalid udxDlSap State [%d]",udxDlSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Check for reconfiguration */
if(udxUlSap->state != RLC_SAP_NOT_CFG)
{
- RLOG1(L_ERROR,"Invalid udxUlSap State [%d]", udxUlSap->state);
+ DU_LOG("\nERROR --> RLC : Invalid udxUlSap State [%d]", udxUlSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
* -# LCM_REASON_INVALID_SAP
* -# LCM_REASON_RECONFIG_FAIL
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmCfgRguSap
-(
-RlcCb *gCb,
-RlcSapCfg *cfg
-)
-#else
-PRIVATE S16 rlcLmmCfgRguSap(gCb,cfg)
-RlcCb *gCb;
-RlcSapCfg *cfg;
-#endif
+static S16 rlcLmmCfgRguSap(RlcCb *gCb,RlcSapCfg *cfg)
{
RlcRguSapCb *rguSap;
- TRC2(rlcLmmCfgRguSap);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
if((cfg->sapId >= gCb->genCfg.maxRguSaps) || \
/* Check for reconfiguration */
if(rguSap->state != RLC_SAP_NOT_CFG)
{
- RLOG2(L_ERROR,"RLC Mode [%d]: Invalid rguSap State [%d]",
+ DU_LOG("\nERROR --> RLC : RLC Mode [%d]: Invalid rguSap State [%d]",
gCb->genCfg.rlcMode, rguSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
* -# LCM_REASON_INVALID_SUBACTION
* -# LCM_REASON_INVALID_ACTION
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmValidateGenCntrl
-(
-RlcMngmt *cntrl
-)
-#else
-PRIVATE S16 rlcLmmValidateGenCntrl(cntrl)
-RlcMngmt *cntrl;
-#endif
+static S16 rlcLmmValidateGenCntrl(RlcMngmt *cntrl)
{
- S16 reason; /* reason for failure */
- U8 sAction; /* subaction field */
-
- TRC2(rlcLmmValidateGenCntrl);
+ S16 reason; /* reason for failure */
+ uint8_t sAction; /* subaction field */
reason = LCM_REASON_NOT_APPL;
sAction = cntrl->t.cntrl.subAction;
*
* @return Void
*/
-#ifdef ANSI
-PRIVATE Void rlcLmmCleanGblRsrcs
-(
-RlcCb *gCb
-)
-#else
-PRIVATE Void rlcLmmCleanGblRsrcs(gCb)
-RlcCb *gCb;
-#endif
+static Void rlcLmmCleanGblRsrcs(RlcCb *gCb)
{
Size rlcSapSize;
Size rlcUdxSapSize;
- TRC2(rlcLmmCleanGblRsrcs)
-
if (gCb->init.cfgDone)
{
/* Deregister the timers */
gCb->init.usta = FALSE;
}
- RETVOID;
+ return;
}
/**
* -# LCM_REASON_NOT_APPL (SUCCESS)
* -# LCM_REASON_HASHING_FAILED
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmShutdown
-(
-RlcCb *gCb
-)
-#else
-PRIVATE S16 rlcLmmShutdown(gCb)
-RlcCb *gCb;
-#endif
+static S16 rlcLmmShutdown(RlcCb *gCb)
{
RlcRguSapCb *rguSap;
- U32 idx;
-
- TRC2(rlcLmmShutdown)
+ uint32_t idx;
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
* -# LCM_REASON_INVALID_SUBACTION
* -# LCM_REASON_INVALID_ACTION
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmGenCntrl
-(
-RlcCb *gCb,
-RlcMngmt *cntrl
-)
-#else
-PRIVATE S16 rlcLmmGenCntrl(gCb,cntrl)
-RlcCb *gCb;
-RlcMngmt *cntrl;
-#endif
+static S16 rlcLmmGenCntrl(RlcCb *gCb,RlcMngmt *cntrl)
{
RlcTrcCntrl *trcCntrl; /* trace */
#ifdef DEBUGP
#endif /* DEBUGP */
S16 reason; /* reason for failure */
- TRC2(rlcLmmGenCntrl);
-
/* Validate control parameters */
reason = rlcLmmValidateGenCntrl (cntrl);
* -# LCM_REASON_INVALID_STATE
* -# LCM_REASON_INVALID_ACTION
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmUdxSapCntrl
-(
-RlcCb *gCb,
-RlcMngmt *cntrl
-)
-#else
-PRIVATE S16 rlcLmmUdxSapCntrl(gCb,cntrl)
-RlcCb *gCb;
-RlcMngmt *cntrl;
-#endif
+static S16 rlcLmmUdxSapCntrl(RlcCb *gCb,RlcMngmt *cntrl)
{
- TRC2(rlcLmmUdxSapCntrl)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
/* validate SAP */
if(UDX_SAP.state == RLC_SAP_NOT_CFG)
{
- RLOG0(L_ERROR,"udxUlSap not configured yet");
+ DU_LOG("\nERROR --> RLC : udxUlSap not configured yet");
return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(UDX_SAP.state != RLC_SAP_BND)
{
/* start timer to wait for bind confirm */
- rlcStartTmr(gCb,(PTR)(&UDX_SAP), RLC_EVT_WAIT_BNDCFM);
+ rlcStartTmr(gCb,(PTR)(&UDX_SAP), EVENT_RLC_WAIT_BNDCFM);
UDX_SAP.state = RLC_SAP_BINDING;
rlcUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
}
* -# LCM_REASON_INVALID_STATE
* -# LCM_REASON_INVALID_ACTION
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmLSapCntrl
-(
-RlcCb *gCb,
-RlcMngmt *cntrl
-)
-#else
-PRIVATE S16 rlcLmmLSapCntrl(gCb,cntrl)
-RlcCb *gCb;
-RlcMngmt *cntrl;
-#endif
+static S16 rlcLmmLSapCntrl(RlcCb *gCb,RlcMngmt *cntrl)
{
RlcRguSapCb *rguSap; /* rgu sap pointer */
- TRC2(rlcLmmLSapCntrl)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate SuId */
if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
/* validate SAP */
if(rguSap->state == RLC_SAP_NOT_CFG)
{
- RLOG1(L_ERROR,"RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
+ DU_LOG("\nERROR --> RLC : RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(rguSap->state != RLC_SAP_BND)
{
/* start timer to wait for bind confirm */
- rlcStartTmr(gCb,(PTR)(rguSap), RLC_EVT_WAIT_BNDCFM);
+ rlcStartTmr(gCb,(PTR)(rguSap), EVENT_RLC_WAIT_BNDCFM);
rguSap->state = RLC_SAP_BINDING;
rguSap->spId = cntrl->t.cntrl.s.sapCntrl.spId;
rguSap->suId = cntrl->t.cntrl.s.sapCntrl.suId;
* -# LCM_REASON_NOT_APPL (SUCCESS)
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmGetKwuSapSta
-(
-RlcCb *gCb,
-RlcKwuSapSta *sta
-)
-#else
-PRIVATE S16 rlcLmmGetKwuSapSta(gCb,sta)
-RlcCb *gCb;
-RlcKwuSapSta *sta;
-#endif
+static S16 rlcLmmGetKwuSapSta (RlcCb *gCb,RlcKwuSapSta *sta)
{
RlcKwuSapCb *rlcKwSapCb;
- TRC2(rlcLmmGetKwuSapSta);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
* -# LCM_REASON_NOT_APPL (SUCCESS)
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmGetRguSapSta
-(
-RlcCb *gCb,
-RlcRguSapSta *sta
-)
-#else
-PRIVATE S16 rlcLmmGetRguSapSta(gCb,sta)
-RlcCb *gCb;
-RlcRguSapSta *sta;
-#endif
+static S16 rlcLmmGetRguSapSta(RlcCb *gCb,RlcRguSapSta *sta)
{
- TRC2(rlcLmmGetRguSapSta);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
* -# LCM_REASON_NOT_APPL (SUCCESS)
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmGetCkwCntSapSta
-(
-RlcCb *gCb,
-RlcCkwCntSapSta *sta
-)
-#else
-PRIVATE S16 rlcLmmGetCkwCntSapSta(gCb,sta)
-rlcCb *gCb,
-RlcCkwCntSapSta *sta;
-#endif
+static S16 rlcLmmGetCkwCntSapSta(RlcCb *gCb,RlcCkwCntSapSta *sta)
{
- TRC2(rlcLmmGetCkwCntSapSta);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate config parameters */
* -# LCM_REASON_NOT_APPL (SUCCESS)
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmGetGenSts
-(
-RlcCb *gCb,
-RlcGenSts *sts,
-Action action
-)
-#else
-PRIVATE S16 rlcLmmGetGenSts(gCb,sts, action)
-RlcCb *gCb;
-RlcGenSts *sts;
-Action action;
-#endif
+static S16 rlcLmmGetGenSts(RlcCb *gCb,RlcGenSts *sts,Action action)
{
- TRC2(rlcLmmGetGenSts);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate protocol parameters */
* -# LCM_REASON_NOT_APPL (SUCCESS)
* -# LCM_REASON_INVALID_PAR_VAL (FAIL)
*/
-#ifdef ANSI
-PRIVATE S16 rlcLmmGetSapSts
-(
-RlcCb *gCb,
-RlcMngmt *sts,
-Elmnt elmnt,
-Action action
-)
-#else
-PRIVATE S16 rlcLmmGetSapSts(sts, elmnt, action)
-RlcCb *gCb;
-RlcMngmt *sts;
-Elmnt elmnt;
-Action action;
-#endif
+static S16 rlcLmmGetSapSts(RlcCb *gCb,RlcMngmt *sts,Elmnt elmnt, Action action)
{
- TRC2(rlcLmmGetSapSts);
/* Validate protocol parameters */
if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
* @return Void
*/
#ifdef LTE_L2_MEAS
-#ifdef ANSI
Void rlcLmmSendAlarm
(
-RlcCb *gCb,
-U16 category,
-U16 event,
-U16 cause,
-SuId suId,
-U32 ueId,
-U8 qci
+RlcCb *gCb,
+uint16_t category,
+uint16_t event,
+uint16_t cause,
+SuId suId,
+uint32_t ueId,
+uint8_t qci
)
-#else
-Void rlcLmmSendAlarm(category, event, cause, suId, ueId, qci)
-RlcCb *gCb;
-U16 category;
-U16 event;
-U16 cause;
-SuId suId;
-U32 ueId;
-U8 qci;
-#endif
#else /* LTE_L2_MEAS */
-#ifdef ANSI
Void rlcLmmSendAlarm
(
-RlcCb *gCb,
-U16 category,
-U16 event,
-U16 cause,
-SuId suId,
-U32 ueId
+RlcCb *gCb,
+uint16_t category,
+uint16_t event,
+uint16_t cause,
+SuId suId,
+uint32_t ueId
)
-#else
-Void rlcLmmSendAlarm(category, event, cause, suId, ueId)
-RlcCb *gCb;
-U16 category;
-U16 event;
-U16 cause;
-SuId suId;
-U32 ueId;
-#endif
#endif /* LTE_L2_MEAS */
{
RlcMngmt usta; /* Rlc Management Structure */
- TRC2(rlcLmmSendAlarm);
-
if(gCb->init.usta == FALSE)
{
- RETVOID;
+ return;
}
usta.hdr.elmId.elmnt = STGEN;
RlcMiLkwStaInd(&(gCb->init.lmPst), &usta);
- RETVOID;
+ return;
}
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-S16 rlcLmmSendTrc
-(
-RlcCb *gCb,
-Event event,
-Buffer *mBuf
-)
-#else
-S16 rlcLmmSendTrc(gCb,event, mBuf)
-RlcCb *gCb;
-Event event;
-Buffer *mBuf;
-#endif
+S16 rlcLmmSendTrc(RlcCb *gCb,Event event,Buffer *mBuf)
{
RlcMngmt trc; /* RLC management control block */
Buffer *dstMbuf;
MsgLen tempCnt;
Pst pst;
- TRC2(rlcLmmSendTrc)
-
- RLOG2(L_DEBUG, "rlcLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
+ DU_LOG("\nDEBUG --> RLC : rlcLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
event,
gCb->trcLen);
- cmMemset((U8 *)&trc, 0, sizeof(RlcMngmt));
+ memset(&trc, 0, sizeof(RlcMngmt));
pst = gCb->init.lmPst;
!= ROK)
{
/* rg005.201 removed SPutSBuf on error */
- RLOG0(L_ERROR,"SCpyMsgMsg Failed");
+ DU_LOG("\nERROR --> RLC : SCpyMsgMsg Failed");
return RFAILED;
}
/* Send Trace Indication to Layer manager */
/* Get the length of the recvd message buffer */
if (SFndLenMsg(mBuf, &bufLen) != ROK)
{
- RLOG0(L_ERROR,"SFndLenMsg Failed");
+ DU_LOG("\nERROR --> RLC : SFndLenMsg Failed");
return RFAILED;
}
/* Check if the recvd buffer size is less than request trace len */
if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
!= ROK)
{
- RLOG0(L_ERROR,"SCpyMsgMsg Failed");
+ DU_LOG("\nERROR --> RLC : SCpyMsgMsg Failed");
return RFAILED;
}
{
(Void) SPutSMem(RLC_GET_MEM_REGION(gCb), RLC_GET_MEM_POOL(gCb));
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Copy trcLen nos of bytes from the recvd message */
if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)
{
- RLOG0(L_ERROR,"SCpyMsgFix Failed");
+ DU_LOG("\nERROR --> RLC : SCpyMsgFix Failed");
return RFAILED;
}
if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
{
- RLOG0(L_FATAL,"Memory Allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory Allocation failed");
return RFAILED;
}
/* Copy the tempBuf data to dst mBuf */
if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
{
- RLOG0(L_ERROR,"SCpyMsgFix Failed");
+ DU_LOG("\nERROR --> RLC : SCpyMsgFix Failed");
return RFAILED;
}
*
*/
-#ifdef ANSI
-S16 rlcActvTmr
-(
-Ent ent,
-Inst inst
-)
-#else
-S16 rlcActvTmr(ent,inst)
-Ent ent;
-Inst inst;
-#endif
+S16 rlcActvTmr(Ent ent,Inst inst)
{
RlcCb *gCb;
- TRC2(rlcActvTmr)
if (inst >= MAX_RLC_INSTANCES)
{
Code Review / o-du / l2.git / blobdiff