Desc: It contains the following common functions for processing
the all the external interfaces.
- -- KwMiLkwCfgReq
- -- KwMiLkwCfgCfm
+ -- KwMiRlcConfigReq
+ -- KwMiRlcConfigCfm
-- KwMiLkwCntrlReq
-- KwMiLkwCntrlCfm
-- KwMiLkwStaReq
\f
/* header (.h) include files */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-
-#include "gen.h" /* general */
-#include "ssi.h" /* system services */
-#include "cm5.h" /* common timer defines */
-#include "cm_tkns.h" /* common tokens defines */
-#include "cm_mblk.h" /* common memory allocation library defines */
-#include "cm_llist.h" /* common link list defines */
-#include "cm_hash.h" /* common hash list defines */
-#include "cm_lte.h" /* common LTE defines */
+#include "common_def.h"
#include "lkw.h" /* LKW defines */
#include "ckw.h" /* CKW defines */
#include "kwu.h" /* KWU defines */
#include "kw_udx.h"
/* extern (.x) include files */
-#include "gen.x" /* general */
-#include "ssi.x" /* system services */
-
-#include "cm5.x" /* common timer library */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_mblk.x" /* common memory allocation */
-#include "cm_llist.x" /* common link list */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lte.x" /* common LTE includes */
-#include "cm_lib.x" /* common memory allocation library */
#include "lkw.x" /* LKW */
#include "ckw.x" /* CKW */
#include "kwu.x" /* KWU */
/*********************************************************************
* 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
{
KW_MAX_UE,
cfg->maxUe);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if(cfg->maxKwuSaps > KW_MAX_KWUSAPS)
KW_MAX_KWUSAPS,
cfg->maxKwuSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if(cfg->maxUdxSaps > KW_MAX_UDXSAPS)
KW_MAX_UDXSAPS,
cfg->maxUdxSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > KW_MAX_RGUSAPS))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if(gCb->init.cfgDone == TRUE)
{
/* reconfiguration not supported */
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
gCb->genCfg = *cfg;
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");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
/* allocate memory to the KWU sap's */
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);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
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);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
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...!");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
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);
+ 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,
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);
+ return (LCM_REASON_REGTMR_FAIL);
}
-
+#endif
/* initializations for background processing of freeing memory */
kwUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
kwUtlInitializeSelfPst(gCb);
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);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#ifdef LTE_L2_MEAS
}
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");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
/* allocate memory to the KWU sap's */
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);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
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);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
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...!");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
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");
}
/* Register the timer */
-
+#if 0
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);
+ return (LCM_REASON_REGTMR_FAIL);
}
+#endif
#ifdef LTE_L2_MEAS
kwUtlL2MeasUlInit(gCb);
#endif
RLOG0(L_ERROR, "Received Invalid RLC Mode");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
/* Timer Initialization */
gCb->kwTqCp.tmrLen = KW_TMR_LEN;
gCb->init.cfgDone = TRUE;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
* @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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return 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);
- RETVALUE(ROK);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return ROK;
}
else
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = reason;
- kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ return 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);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
+ return RFAILED;
}
RLOG1(L_DEBUG, "Status request for elmId(%d))", sta->hdr.elmId.elmnt);
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);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
+ return 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);
- RETVALUE(RFAILED);
+ kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
+ return RFAILED;
}
RLOG2(L_DEBUG, "KwMiLkwStsReq(elmId(%d),action(%d))",
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);
+ return ROK;
}
/* kw005.201 added support for L2 Measurement */
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))
- RETVALUE(RFAILED);
+ kwUtlSndUlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
+ RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
+ return 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))
- RETVALUE(ROK);
+ kwUtlSndDlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
+ RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
+ return ROK;
}
/* for UL IP throughput meas enable for all QCIs */
{
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));
if(measEvt == NULLP)
{
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cmMemcpy((Void*)measEvt, (Void*)measReqEvt, 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);
+ return (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);
- /*RETVALUE(ROK);*/
+ rlcUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measType);
+ /*return 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);
+ return (ret);
}
/**
@brief
/*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);*/
+ /*return 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);
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_L2_MEAS */
#ifdef ANSI
PRIVATE S16 kwLmmCfgKwuSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgKwuSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
/* Validate the protocol parameters */
if((cfg->sapId >= (S16)gCb->genCfg.maxKwuSaps) || (cfg->sapId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLOG2(L_ERROR,"RLC Mode [%d] : Invalid kwuSap State [%d]",
gCb->genCfg.rlcMode, kwuSapCb->state);
/* reconfiguration not allowed */
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
KW_FILL_SAP_HELPER(kwuSapCb, cfg, gCb);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmCfgCkwSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgCkwSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
/* Validate config parameters */
if ((cfg->sapId >= KW_MAX_CKWSAPS) || (cfg->sapId < 0) )
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
/* Get Sap control block */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
if(ckwSap->state != KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid kwuSap State [%d]",ckwSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
KW_FILL_SAP_HELPER(ckwSap, cfg, gCb);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmCfgUdxSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgUdxSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
/* Validate the protocol parameters */
if((cfg->sapId >= KW_MAX_UDXSAPS) || (cfg->sapId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
/* Get Sap control block */
if(udxDlSap->state != KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid udxDlSap State [%d]",udxDlSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(udxUlSap->state != KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid udxUlSap State [%d]", udxUlSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
cmInitTimers(&(udxUlSap->bndTmr), 1);
}
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmCfgRguSap
(
-KwCb *gCb,
+RlcCb *gCb,
KwSapCfg *cfg
)
#else
PRIVATE S16 kwLmmCfgRguSap(gCb,cfg)
-KwCb *gCb;
+RlcCb *gCb;
KwSapCfg *cfg;
#endif
{
{
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
"kwLmmCfgRguSap: Invalid RGU sapId\n");
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
{
RLOG2(L_ERROR,"RLC Mode [%d]: Invalid rguSap State [%d]",
gCb->genCfg.rlcMode, rguSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
cmInitTimers(&(rguSap->bndTmr), 1);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
break;
}
- RETVALUE(reason);
+ return (reason);
}
/**
#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);
+ return (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
{
if (reason != LCM_REASON_NOT_APPL)
{
- RETVALUE(reason);
+ return (reason);
}
switch(cntrl->t.cntrl.action)
break;
}
}
- RETVALUE(reason);
+ return (reason);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmUdxSapCntrl
(
-KwCb *gCb,
+RlcCb *gCb,
KwMngmt *cntrl
)
#else
PRIVATE S16 kwLmmUdxSapCntrl(gCb,cntrl)
-KwCb *gCb;
+RlcCb *gCb;
KwMngmt *cntrl;
#endif
{
#if (ERRCLASS & ERRCLS_INT_PAR)
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- RETVALUE(LCM_REASON_INVALID_SAP);
+ return (LCM_REASON_INVALID_SAP);
}
/* validate SuId */
if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
(cntrl->t.cntrl.s.sapCntrl.suId >= KW_MAX_UDXSAPS))
{
- RETVALUE(LCM_REASON_INVALID_SAP);
+ return (LCM_REASON_INVALID_SAP);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(UDX_SAP.state == KW_SAP_NOT_CFG)
{
RLOG0(L_ERROR,"udxUlSap not configured yet");
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* 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
{
/* control request received for an already bound SAP */
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
}
break;
{
/* 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:
- RETVALUE(LCM_REASON_INVALID_ACTION);
+ return (LCM_REASON_INVALID_ACTION);
break;
} /* end of switch */
#undef UDX_SAP
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmLSapCntrl
(
-KwCb *gCb,
+RlcCb *gCb,
KwMngmt *cntrl
)
#else
PRIVATE S16 kwLmmLSapCntrl(gCb,cntrl)
-KwCb *gCb;
+RlcCb *gCb;
KwMngmt *cntrl;
#endif
{
{
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
"kwLmmLSapCntrl: Invalid RGU suId\n");
- RETVALUE(LCM_REASON_INVALID_SAP);
+ return (LCM_REASON_INVALID_SAP);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
if(rguSap->state == KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
else
{
/* control request received for an already bound SAP */
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
}
break;
}
break;
default:
- RETVALUE(LCM_REASON_INVALID_ACTION);
+ return (LCM_REASON_INVALID_ACTION);
break;
} /* end of switch */
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmGetKwuSapSta
(
-KwCb *gCb,
+RlcCb *gCb,
KwKwuSapSta *sta
)
#else
PRIVATE S16 kwLmmGetKwuSapSta(gCb,sta)
-KwCb *gCb;
+RlcCb *gCb;
KwKwuSapSta *sta;
#endif
{
if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
(sta->spId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
sta->state = kwSapCb->state;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmGetRguSapSta
(
-KwCb *gCb,
+RlcCb *gCb,
KwRguSapSta *sta
)
#else
PRIVATE S16 kwLmmGetRguSapSta(gCb,sta)
-KwCb *gCb;
+RlcCb *gCb;
KwRguSapSta *sta;
#endif
{
/* Validate the protocol parameters */
if((sta->suId >= KW_MAX_RGUSAPS) || (sta->suId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
gCb->u.dlCb->rguDlSap[sta->suId].state :
gCb->u.ulCb->rguUlSap[sta->suId].state ;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#ifdef ANSI
PRIVATE S16 kwLmmGetCkwCntSapSta
(
-KwCb *gCb,
+RlcCb *gCb,
KwCkwCntSapSta *sta
)
#else
PRIVATE S16 kwLmmGetCkwCntSapSta(gCb,sta)
-kwCb *gCb,
+rlcCb *gCb,
KwCkwCntSapSta *sta;
#endif
{
(sta->spId < 0 ) ||
(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
sta->state = gCb->u.ulCb->ckwSap.state;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
#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
/* Validate protocol parameters */
if ((action != LKW_ZEROSTS) && (action != LKW_NOZEROSTS))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#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);
+ return (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;
/* Validate protocol parameters */
if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
switch(elmnt)
{
if (action == LKW_ZEROSTS)
{
- KW_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
+ RLC_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
}
break;
}
ckwSap = &sts->t.sts.s.ckwSap;
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
ckwSap->statMsgs = gCb->u.ulCb->ckwSap.sts.statMsgs;
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;
}
default:
- RETVALUE(LCM_REASON_INVALID_ELMNT);
+ return (LCM_REASON_INVALID_ELMNT);
}
SGetDateTime(&sts->t.sts.dt);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
#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
{
/* rg005.201 removed SPutSBuf on error */
RLOG0(L_ERROR,"SCpyMsgMsg Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Send Trace Indication to Layer manager */
KwMiLkwTrcInd(&pst, &trc, dstMbuf);
if (SFndLenMsg(mBuf, &bufLen) != ROK)
{
RLOG0(L_ERROR,"SFndLenMsg Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the recvd buffer size is less than request trace len */
if(bufLen < gCb->trcLen)
!= ROK)
{
RLOG0(L_ERROR,"SCpyMsgMsg Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Send Trace Indication to Layer manager */
{
/* 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)
(Void) SPutSMem(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb));
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)
{
RLOG0(L_ERROR,"SCpyMsgFix Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
{
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Copy the tempBuf data to dst mBuf */
if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
{
RLOG0(L_ERROR,"SCpyMsgFix Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* 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);
}
KwMiLkwTrcInd(&pst, &trc, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
Inst inst;
#endif
{
- KwCb *gCb;
+ RlcCb *gCb;
TRC2(kwActvTmr)
- if (inst >= KW_MAX_RLC_INSTANCES)
+ if (inst >= MAX_RLC_INSTANCES)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
- gCb = KW_GET_KWCB(inst);
+ gCb = RLC_GET_RLCCB(inst);
cmPrcTmr(&(gCb->kwTqCp), gCb->kwTq, (PFV) kwTmrExpiry);
-
- RETVALUE(ROK);
+ return ROK;
} /* end of kwActvTmr */
Code Review / o-du / l2.git / blobdiff