X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_lmm.c;h=d023c56a6aacf5d4bd2d34fa4fbb45731936c2e4;hb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;hp=a530dffa225fccb9eb8a3fdaef36fde3293fd908;hpb=5ea4c59cb4dd37164953218b0bd355284e11d22c;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_lmm.c b/src/5gnrrlc/kw_lmm.c index a530dffa2..d023c56a6 100755 --- a/src/5gnrrlc/kw_lmm.c +++ b/src/5gnrrlc/kw_lmm.c @@ -24,8 +24,8 @@ Desc: It contains the following common functions for processing the all the external interfaces. - -- KwMiLkwCfgReq - -- KwMiLkwCfgCfm + -- KwMiRlcConfigReq + -- KwMiRlcConfigCfm -- KwMiLkwCntrlReq -- KwMiLkwCntrlCfm -- KwMiLkwStaReq @@ -47,18 +47,7 @@ static int RLOG_FILE_ID=197; /* 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 */ @@ -72,16 +61,6 @@ static int RLOG_FILE_ID=197; #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 */ @@ -99,24 +78,24 @@ RLCStats gRlcStats; /********************************************************************* * 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)); @@ -146,12 +125,12 @@ PRIVATE S16 kwLmmGetSapSts ARGS ((KwCb *gCb,KwMngmt *sts,Elmnt elmnt,Action #ifdef ANSI PRIVATE S16 kwLmmGenCfg ( -KwCb *gCb, +RlcCb *gCb, KwGenCfg *cfg ) #else PRIVATE S16 kwLmmGenCfg(gCB,cfg) -KwCb *gCb; +RlcCb *gCb; KwGenCfg *cfg; #endif { @@ -170,7 +149,7 @@ KwGenCfg *cfg; 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) @@ -180,7 +159,7 @@ KwGenCfg *cfg; 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) @@ -190,19 +169,19 @@ KwGenCfg *cfg; 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; @@ -214,25 +193,25 @@ KwGenCfg *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 */ @@ -241,30 +220,30 @@ KwGenCfg *cfg; 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 */ @@ -273,12 +252,12 @@ KwGenCfg *cfg; 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 */ @@ -286,12 +265,12 @@ KwGenCfg *cfg; 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 */ @@ -302,12 +281,12 @@ KwGenCfg *cfg; 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 @@ -316,25 +295,25 @@ KwGenCfg *cfg; } 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 */ @@ -344,31 +323,31 @@ KwGenCfg *cfg; 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 */ @@ -376,10 +355,10 @@ KwGenCfg *cfg; 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"); } @@ -388,12 +367,12 @@ KwGenCfg *cfg; 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 @@ -406,7 +385,7 @@ KwGenCfg *cfg; 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; @@ -429,12 +408,12 @@ KwGenCfg *cfg; 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 @@ -448,7 +427,7 @@ KwGenCfg *cfg; #ifdef ANSI PRIVATE Void kwLmmSendCfm ( -KwCb *gCb, +RlcCb *gCb, Pst *pst, KwMngmt *cfm, U8 type, @@ -456,7 +435,7 @@ Header *hdr ) #else PRIVATE Void kwLmmSendCfm(gCb,pst, cfm, type, hdr) -KwCb gCb; +RlcCb gCb; Pst *pst; KwMngmt *cfm; U8 type; @@ -467,7 +446,7 @@ Header *hdr; TRC2(kwLmmSendCfm); - KW_MEM_SET(&rPst, 0, sizeof(Pst)); + RLC_MEM_SET(&rPst, 0, sizeof(Pst)); /* reply post structure for confirmation */ if (gCb) @@ -501,7 +480,7 @@ Header *hdr; switch(type) { case TCFG: - KwMiLkwCfgCfm(&rPst,cfm); + KwMiRlcConfigCfm(&rPst,cfm); break; case TCNTRL: SGetDateTime(&(cfm->t.cntrl.dt)); @@ -587,44 +566,44 @@ Header *hdr; */ #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)) { /* @@ -634,37 +613,37 @@ KwMngmt *cfg; 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: @@ -678,15 +657,15 @@ KwMngmt *cfg; { 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; } } @@ -755,38 +734,38 @@ KwMngmt *cntrl; #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); @@ -800,19 +779,19 @@ KwMngmt *cntrl; 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: @@ -833,9 +812,9 @@ KwMngmt *cntrl; cntrl->cfm.reason = reason; } - kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr); + kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr); - RETVALUE(ROK); + return ROK; } /** @@ -864,37 +843,37 @@ KwMngmt *sta; { 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: @@ -909,7 +888,7 @@ KwMngmt *sta; &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: @@ -918,7 +897,7 @@ KwMngmt *sta; &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: @@ -927,7 +906,7 @@ KwMngmt *sta; &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: @@ -947,9 +926,9 @@ KwMngmt *sta; 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; } /** @@ -1000,43 +979,43 @@ KwMngmt *sts; { 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: @@ -1047,7 +1026,7 @@ KwMngmt *sts; /* 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: @@ -1067,9 +1046,9 @@ KwMngmt *sts; 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 */ @@ -1119,11 +1098,11 @@ KwL2MeasReqEvt *measReqEvt; 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)); @@ -1142,9 +1121,9 @@ KwL2MeasReqEvt *measReqEvt; { #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; } } @@ -1161,9 +1140,9 @@ KwL2MeasReqEvt *measReqEvt; 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 */ @@ -1171,7 +1150,7 @@ KwL2MeasReqEvt *measReqEvt; { 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; } } @@ -1182,9 +1161,9 @@ KwL2MeasReqEvt *measReqEvt; 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)); @@ -1193,7 +1172,7 @@ KwL2MeasReqEvt *measReqEvt; if(measEvt == NULLP) { RLOG0(L_FATAL,"Memory Allocation failed"); - RETVALUE(RFAILED); + return RFAILED; } #endif cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(KwL2MeasReqEvt)); @@ -1203,21 +1182,21 @@ KwL2MeasReqEvt *measReqEvt; 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 */ /** @@ -1248,19 +1227,19 @@ U8 measType; 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); } } @@ -1270,7 +1249,7 @@ U8 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; } } @@ -1278,15 +1257,15 @@ U8 measType; || (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 @@ -1314,10 +1293,10 @@ U8 measType; /*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)*/ @@ -1326,22 +1305,22 @@ U8 measType; | 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 */ @@ -1361,12 +1340,12 @@ U8 measType; #ifdef ANSI PRIVATE S16 kwLmmCfgKwuSap ( -KwCb *gCb, +RlcCb *gCb, KwSapCfg *cfg ) #else PRIVATE S16 kwLmmCfgKwuSap(gCb,cfg) -KwCb *gCb; +RlcCb *gCb; KwSapCfg *cfg; #endif { @@ -1377,7 +1356,7 @@ KwSapCfg *cfg; /* 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 */ @@ -1392,14 +1371,14 @@ KwSapCfg *cfg; 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); } /** @@ -1418,12 +1397,12 @@ KwSapCfg *cfg; #ifdef ANSI PRIVATE S16 kwLmmCfgCkwSap ( -KwCb *gCb, +RlcCb *gCb, KwSapCfg *cfg ) #else PRIVATE S16 kwLmmCfgCkwSap(gCb,cfg) -KwCb *gCb; +RlcCb *gCb; KwSapCfg *cfg; #endif { @@ -1435,13 +1414,13 @@ KwSapCfg *cfg; /* 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 @@ -1452,14 +1431,14 @@ KwSapCfg *cfg; 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); } /** @@ -1478,12 +1457,12 @@ KwSapCfg *cfg; #ifdef ANSI PRIVATE S16 kwLmmCfgUdxSap ( -KwCb *gCb, +RlcCb *gCb, KwSapCfg *cfg ) #else PRIVATE S16 kwLmmCfgUdxSap(gCb,cfg) -KwCb *gCb; +RlcCb *gCb; KwSapCfg *cfg; #endif { @@ -1496,7 +1475,7 @@ KwSapCfg *cfg; /* 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 */ @@ -1508,7 +1487,7 @@ KwSapCfg *cfg; 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 */ @@ -1524,7 +1503,7 @@ KwSapCfg *cfg; 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 */ @@ -1536,7 +1515,7 @@ KwSapCfg *cfg; cmInitTimers(&(udxUlSap->bndTmr), 1); } - RETVALUE(LCM_REASON_NOT_APPL); + return (LCM_REASON_NOT_APPL); } /** @@ -1554,12 +1533,12 @@ KwSapCfg *cfg; #ifdef ANSI PRIVATE S16 kwLmmCfgRguSap ( -KwCb *gCb, +RlcCb *gCb, KwSapCfg *cfg ) #else PRIVATE S16 kwLmmCfgRguSap(gCb,cfg) -KwCb *gCb; +RlcCb *gCb; KwSapCfg *cfg; #endif { @@ -1574,7 +1553,7 @@ KwSapCfg *cfg; { 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 @@ -1587,7 +1566,7 @@ KwSapCfg *cfg; { 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 */ @@ -1600,7 +1579,7 @@ KwSapCfg *cfg; cmInitTimers(&(rguSap->bndTmr), 1); - RETVALUE(LCM_REASON_NOT_APPL); + return (LCM_REASON_NOT_APPL); } /** @@ -1650,7 +1629,7 @@ KwMngmt *cntrl; break; } - RETVALUE(reason); + return (reason); } /** @@ -1664,11 +1643,11 @@ KwMngmt *cntrl; #ifdef ANSI PRIVATE Void kwLmmCleanGblRsrcs ( -KwCb *gCb +RlcCb *gCb ) #else PRIVATE Void kwLmmCleanGblRsrcs(gCb) -KwCb *gCb; +RlcCb *gCb; #endif { Size kwSapSize; @@ -1696,17 +1675,17 @@ KwCb *gCb; 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) @@ -1715,7 +1694,7 @@ KwCb *gCb; { SPutMsg(gCb->u.dlCb->selfPstMBuf); } - KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb)); + RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb)); } } @@ -1727,21 +1706,21 @@ KwCb *gCb; { 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)); } } @@ -1773,11 +1752,11 @@ KwCb *gCb; #ifdef ANSI PRIVATE S16 kwLmmShutdown ( -KwCb *gCb +RlcCb *gCb ) #else PRIVATE S16 kwLmmShutdown(gCb) -KwCb *gCb; +RlcCb *gCb; #endif { KwRguSapCb *rguSap; @@ -1819,9 +1798,9 @@ KwCb *gCb; 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); } /** @@ -1839,12 +1818,12 @@ KwCb *gCb; #ifdef ANSI PRIVATE S16 kwLmmGenCntrl ( -KwCb *gCb, +RlcCb *gCb, KwMngmt *cntrl ) #else PRIVATE S16 kwLmmGenCntrl(gCb,cntrl) -KwCb *gCb; +RlcCb *gCb; KwMngmt *cntrl; #endif { @@ -1861,7 +1840,7 @@ KwMngmt *cntrl; if (reason != LCM_REASON_NOT_APPL) { - RETVALUE(reason); + return (reason); } switch(cntrl->t.cntrl.action) @@ -1927,7 +1906,7 @@ KwMngmt *cntrl; break; } } - RETVALUE(reason); + return (reason); } /** @@ -1946,12 +1925,12 @@ KwMngmt *cntrl; #ifdef ANSI PRIVATE S16 kwLmmUdxSapCntrl ( -KwCb *gCb, +RlcCb *gCb, KwMngmt *cntrl ) #else PRIVATE S16 kwLmmUdxSapCntrl(gCb,cntrl) -KwCb *gCb; +RlcCb *gCb; KwMngmt *cntrl; #endif { @@ -1960,13 +1939,13 @@ KwMngmt *cntrl; #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 */ @@ -1976,7 +1955,7 @@ KwMngmt *cntrl; 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 */ @@ -1989,12 +1968,12 @@ KwMngmt *cntrl; /* 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; @@ -2002,15 +1981,15 @@ KwMngmt *cntrl; { /* 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); } /** @@ -2028,12 +2007,12 @@ KwMngmt *cntrl; #ifdef ANSI PRIVATE S16 kwLmmLSapCntrl ( -KwCb *gCb, +RlcCb *gCb, KwMngmt *cntrl ) #else PRIVATE S16 kwLmmLSapCntrl(gCb,cntrl) -KwCb *gCb; +RlcCb *gCb; KwMngmt *cntrl; #endif { @@ -2048,7 +2027,7 @@ KwMngmt *cntrl; { 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) ? @@ -2060,7 +2039,7 @@ KwMngmt *cntrl; 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 */ @@ -2080,7 +2059,7 @@ KwMngmt *cntrl; else { /* control request received for an already bound SAP */ - RETVALUE(LCM_REASON_INVALID_STATE); + return (LCM_REASON_INVALID_STATE); } } break; @@ -2092,11 +2071,11 @@ KwMngmt *cntrl; } 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); } /** @@ -2113,12 +2092,12 @@ KwMngmt *cntrl; #ifdef ANSI PRIVATE S16 kwLmmGetKwuSapSta ( -KwCb *gCb, +RlcCb *gCb, KwKwuSapSta *sta ) #else PRIVATE S16 kwLmmGetKwuSapSta(gCb,sta) -KwCb *gCb; +RlcCb *gCb; KwKwuSapSta *sta; #endif { @@ -2131,7 +2110,7 @@ KwKwuSapSta *sta; if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)|| (sta->spId < 0)) { - RETVALUE(LCM_REASON_INVALID_PAR_VAL); + return (LCM_REASON_INVALID_PAR_VAL); } #endif @@ -2142,7 +2121,7 @@ KwKwuSapSta *sta; sta->state = kwSapCb->state; - RETVALUE(LCM_REASON_NOT_APPL); + return (LCM_REASON_NOT_APPL); } /** @@ -2158,12 +2137,12 @@ KwKwuSapSta *sta; #ifdef ANSI PRIVATE S16 kwLmmGetRguSapSta ( -KwCb *gCb, +RlcCb *gCb, KwRguSapSta *sta ) #else PRIVATE S16 kwLmmGetRguSapSta(gCb,sta) -KwCb *gCb; +RlcCb *gCb; KwRguSapSta *sta; #endif { @@ -2173,7 +2152,7 @@ KwRguSapSta *sta; /* 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 @@ -2181,7 +2160,7 @@ KwRguSapSta *sta; gCb->u.dlCb->rguDlSap[sta->suId].state : gCb->u.ulCb->rguUlSap[sta->suId].state ; - RETVALUE(LCM_REASON_NOT_APPL); + return (LCM_REASON_NOT_APPL); } /** @@ -2197,12 +2176,12 @@ KwRguSapSta *sta; #ifdef ANSI PRIVATE S16 kwLmmGetCkwCntSapSta ( -KwCb *gCb, +RlcCb *gCb, KwCkwCntSapSta *sta ) #else PRIVATE S16 kwLmmGetCkwCntSapSta(gCb,sta) -kwCb *gCb, +rlcCb *gCb, KwCkwCntSapSta *sta; #endif { @@ -2214,12 +2193,12 @@ KwCkwCntSapSta *sta; (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); } @@ -2237,13 +2216,13 @@ KwCkwCntSapSta *sta; #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 @@ -2254,7 +2233,7 @@ Action action; /* Validate protocol parameters */ if ((action != LKW_ZEROSTS) && (action != LKW_NOZEROSTS)) { - RETVALUE(LCM_REASON_INVALID_PAR_VAL); + return (LCM_REASON_INVALID_PAR_VAL); } #endif @@ -2262,10 +2241,10 @@ Action action; 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); } /** @@ -2284,14 +2263,14 @@ Action action; #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; @@ -2302,7 +2281,7 @@ 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) { @@ -2323,7 +2302,7 @@ Action action; if (action == LKW_ZEROSTS) { - KW_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts)); + RLC_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts)); } break; } @@ -2334,24 +2313,24 @@ Action action; 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); } /** @@ -2372,7 +2351,7 @@ Action action; #ifdef ANSI PUBLIC Void kwLmmSendAlarm ( -KwCb *gCb, +RlcCb *gCb, U16 category, U16 event, U16 cause, @@ -2382,7 +2361,7 @@ U8 qci ) #else PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId, qci) -KwCb *gCb; +RlcCb *gCb; U16 category; U16 event; U16 cause; @@ -2394,7 +2373,7 @@ U8 qci; #ifdef ANSI PUBLIC Void kwLmmSendAlarm ( -KwCb *gCb, +RlcCb *gCb, U16 category, U16 event, U16 cause, @@ -2403,7 +2382,7 @@ U32 ueId ) #else PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId) -KwCb *gCb; +RlcCb *gCb; U16 category; U16 event; U16 cause; @@ -2464,13 +2443,13 @@ U32 ueId; #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 @@ -2507,7 +2486,7 @@ Buffer *mBuf; { /* 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); @@ -2519,7 +2498,7 @@ Buffer *mBuf; 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) @@ -2530,7 +2509,7 @@ Buffer *mBuf; != ROK) { RLOG0(L_ERROR,"SCpyMsgMsg Failed"); - RETVALUE(RFAILED); + return RFAILED; } /* Send Trace Indication to Layer manager */ @@ -2540,7 +2519,7 @@ Buffer *mBuf; { /* 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) @@ -2548,7 +2527,7 @@ Buffer *mBuf; (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 */ @@ -2556,23 +2535,23 @@ Buffer *mBuf; 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); } @@ -2583,7 +2562,7 @@ Buffer *mBuf; KwMiLkwTrcInd(&pst, &trc, mBuf); } - RETVALUE(ROK); + return ROK; } @@ -2615,16 +2594,16 @@ Ent ent; 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 */