static int RLOG_FILE_ID=167;
/* header include files (.h) */
-#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 "cm_tkns.h" /* Common Token Defines */
-#include "cm_llist.h" /* Common Link List Defines */
-#include "cm_hash.h" /* Common Hash List Defines */
-#include "cm_mblk.h" /* common memory link list library */
-#include "cm_lte.h" /* Common LTE Defines */
+#include "common_def.h"
#include "rg_env.h" /* MAC Environment Defines */
#include "rgr.h" /* RGR Interface defines */
#include "tfu.h" /* RGU Interface defines */
#include "rl_common.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general */
-#include "ssi.x" /* system services */
-#include "cm5.x" /* system services */
-#include "cm_tkns.x" /* Common Token Definitions */
-#include "cm_llist.x" /* Common Link List Definitions */
-#include "cm_lib.x" /* Common Library Definitions */
-#include "cm_hash.x" /* Common Hash List Definitions */
-#include "cm_mblk.x" /* common memory link list library */
-#include "cm_lte.x" /* Common LTE Defines */
#include "rgr.x" /* RGR Interface includes */
#include "rgm.x" /* RGM Interface includes */
#include "tfu.x" /* RGU Interface includes */
#include "rg_sch_cmn.x" /* typedefs for Scheduler */
#endif
#ifndef LTE_L2_MEAS
-PUBLIC Void rgSCHCmnInit ARGS((Void));
+Void rgSCHCmnInit ARGS((Void));
#endif
/* forward references */
-
+extern int schActvInit(Ent entity, Inst instId, Region region, Reason reason);
#ifdef UNUSE_FUN
PRIVATE U16 rgSCHLmmSapCfg ARGS((
Inst inst,
));
-PUBLIC void printSchCellInfo(void)
+void printSchCellInfo(void)
{
U8 idx=0;
U8 inst=0;
*
* Function : rgSCHLmmSapCfg
*
- * This function in called by HandleSchGenCfgReq(). It handles the
+ * This function in called by SchProcGenCfgReq(). It handles the
* interface SAP configuration of the scheduler instance. It
* initializes the sapState to LRG_UNBND. Returns
* reason for success/failure of this function.
RgSchUpSapCfgInfo *upSapCfg = NULLP;
Inst inst = (dInst - SCH_INST_START);
- TRC2(rgSCHLmmSapCfg)
-
/* Check if Gen Config has been done */
switch(sapType)
{
case STRGRSAP:
#ifndef CL_MAC_LWLC
- if ((cfg->s.schInstCfg.rgrSap[sapIdx].selector != RGR_SEL_TC) &&
- (cfg->s.schInstCfg.rgrSap[sapIdx].selector != RGR_SEL_LC))
+ if ((cfg->s.schInstCfg.rgrSap[sapIdx].selector != ODU_SELECTOR_TC) &&
+ (cfg->s.schInstCfg.rgrSap[sapIdx].selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCfg(): unsupported"
break;
case STTFUSAP:
#ifndef CL_MAC_LWLC
- if ((cfg->s.schInstCfg.tfuSap[sapIdx].selector != TFU_SEL_TC) &&
- (cfg->s.schInstCfg.tfuSap[sapIdx].selector != TFU_SEL_LC))
+ if ((cfg->s.schInstCfg.tfuSap[sapIdx].selector != ODU_SELECTOR_TC) &&
+ (cfg->s.schInstCfg.tfuSap[sapIdx].selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCfg(): unsupported"
lowSapCfg->sapPst.prior = cfg->s.schInstCfg.tfuSap[sapIdx].prior;
lowSapCfg->suId = cfg->s.schInstCfg.tfuSap[sapIdx].suId;
lowSapCfg->spId = cfg->s.schInstCfg.tfuSap[sapIdx].spId;
- cmMemcpy((U8 *)&lowSapCfg->bndTmr,
- (U8 *)&cfg->s.schInstCfg.tfuSap[sapIdx].bndTmr,
+ memcpy(&lowSapCfg->bndTmr,
+ &cfg->s.schInstCfg.tfuSap[sapIdx].bndTmr,
sizeof(TmrCfg));
break;
case STRGMSAP:
/* would never reach here */
break;
}
- RETVALUE(ret);
+ return (ret);
}
#endif
\f
RgSchClcBoRpt *bo = NULL;
#endif
- TRC2(rgSCHLmmShutdown)
-
#ifdef LTE_L2_MEAS
for (idx = 0; idx < instCb->numSaps; idx++)
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHLmmGenCntrl
+Void rgSCHLmmGenCntrl
(
RgMngmt *cntrl,
RgMngmt *cfm,
Pst *cfmPst
)
#else
-PUBLIC Void rgSCHLmmGenCntrl(cntrl, cfm, cfmPst)
+Void rgSCHLmmGenCntrl(cntrl, cfm, cfmPst)
RgMngmt *cntrl;
RgMngmt *cfm;
Pst *cfmPst;
#endif
{
Inst inst = (cfmPst->srcInst - SCH_INST_START); /* Scheduler instance ID */
- TRC2(rgSCHLmmGenCntrl)
cfm->cfm.status = LCM_PRIM_OK;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
/* Enable Unsolicited Status (alarms) */
rgSchCb[inst].rgSchInit.usta = TRUE;
/*Store the response and TransId for sending the Alarms */
- cmMemcpy((U8 *)&rgSchCb[inst].genCfg.ustaResp.response,
- (U8 *)&cntrl->hdr.response, sizeof(Resp));
+ memcpy(&rgSchCb[inst].genCfg.ustaResp.response,
+ &cntrl->hdr.response, sizeof(Resp));
rgSchCb[inst].genCfg.ustaResp.transId = cntrl->hdr.transId;
break;
case SADBG:
* L2
* statistics
* */
- cmMemset((U8 *)&hqRetxStats, 0, sizeof(RgSchHqRetxStats));
- cmMemset((U8 *)&hqFailStats, 0, sizeof(RgSchNackAckStats));
+ memset(&hqRetxStats, 0, sizeof(RgSchHqRetxStats));
+ memset(&hqFailStats, 0, sizeof(RgSchNackAckStats));
#endif
break;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHLmmSapCntrl
+Void rgSCHLmmSapCntrl
(
RgMngmt *cntrl,
RgMngmt *cfm,
Pst *cfmPst
)
#else
-PUBLIC Void rgSCHLmmSapCntrl(cntrl, cfm, cfmPst)
+Void rgSCHLmmSapCntrl(cntrl, cfm, cfmPst)
RgMngmt *cntrl;
RgMngmt *cfm;
Pst *cfmPst;
/* TODO Pass InstId instead of using InstId from cfmPst */
Inst inst = (cfmPst->srcInst - SCH_INST_START); /* Scheduler instance Id */
- TRC2(rgSCHLmmSapCntrl)
/* Only TFU SAP can be controlled by LM */
switch(cntrl->hdr.elmId.elmnt)
rgSchCb[inst].tfuSap[idx].numBndRetries++;
/* Store the response and TransId for sending
* the Control confirm */
- cmMemcpy((U8 *)&rgSchCb[inst].genCfg.bndCfmResp[idx].response,
- (U8 *)&cntrl->hdr.response, sizeof(Resp));
+ memcpy(&rgSchCb[inst].genCfg.bndCfmResp[idx].response,
+ &cntrl->hdr.response, sizeof(Resp));
rgSchCb[inst].genCfg.bndCfmResp[idx].transId =
cntrl->hdr.transId;
(PTR)&rgSchCb[inst].tfuSap[idx]);
}
}
- cmMemset((U8 *)&rgSchCb[inst].tfuSap[idx], 0, sizeof(RgSchLowSapCb));
+ memset(&rgSchCb[inst].tfuSap[idx], 0, sizeof(RgSchLowSapCb));
rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_NOT_CFG;
cfm->cfm.status = LCM_PRIM_OK;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
switch(cntrl->t.cntrl.action)
{
case ADEL:
- cmMemset((U8 *)&rgSchCb[inst].rgrSap[idx], 0, sizeof(RgSchUpSapCb));
+ memset(&rgSchCb[inst].rgrSap[idx], 0, sizeof(RgSchUpSapCb));
rgSchCb[inst].rgrSap[idx].sapSta.sapState = LRG_NOT_CFG;
cfm->cfm.status = LCM_PRIM_OK;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
switch(cntrl->t.cntrl.action)
{
case ADEL:
- cmMemset((U8 *)&rgSchCb[inst].rgmSap[idx], 0, sizeof(RgSchUpSapCb));
+ memset(&rgSchCb[inst].rgmSap[idx], 0, sizeof(RgSchUpSapCb));
rgSchCb[inst].rgmSap[idx].sapSta.sapState = LRG_NOT_CFG;
cfm->cfm.status = LCM_PRIM_OK;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void SchFillCfmPst
+Void SchFillCfmPst
(
Pst *reqPst,
Pst *cfmPst,
RgMngmt *cfm
)
#else
-PUBLIC Void SchFillCfmPst(reqPst, cfmPst, cfm)
+Void SchFillCfmPst(reqPst, cfmPst, cfm)
Pst *reqPst;
Pst *cfmPst;
RgMngmt *cfm;
{
Inst inst;
- TRC2(SchFillCfmPst)
-
inst = (reqPst->dstInst - SCH_INST_START);
- cfmPst->srcEnt = ENTRG;
+ cfmPst->srcEnt = ENTMAC;
cfmPst->srcInst = (Inst) 1;
cfmPst->srcProcId = rgSchCb[inst].rgSchInit.procId;
- cfmPst->dstEnt = ENTRG;
+ cfmPst->dstEnt = ENTMAC;
cfmPst->dstInst = (Inst) 0;
cfmPst->dstProcId = reqPst->srcProcId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmStartTmr
+S16 rgSCHLmmStartTmr
(
Inst inst,
S16 tmrEvnt, /* Timer Event */
PTR cb /* Entry for which Timer Expired */
)
#else
-PUBLIC S16 rgSCHLmmStartTmr(inst, tmrEvnt, tmrVal, cb)
+S16 rgSCHLmmStartTmr(inst, tmrEvnt, tmrVal, cb)
Inst inst; /* scheduler instance ID */
S16 tmrEvnt; /* Timer Event */
U32 tmrVal; /* Wait Time */
CmTmrArg arg;
/* Inst dInst = inst + SCH_INST_START; */
- TRC2(rgSCHLmmStartTmr)
-
UNUSED(tmrEvnt);
/* Initialize the arg structure */
- cmMemset((U8 *)&arg, 0, sizeof(CmTmrArg));
+ memset(&arg, 0, sizeof(CmTmrArg));
arg.tqCp = &rgSchCb[inst].tmrTqCp;
arg.tq = rgSchCb[inst].tmrTq;
arg.wait = tmrVal;
cmPlcCbTq(&arg);
- RETVALUE(ROK);
+ return ROK;
}
\f
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmStopTmr
+S16 rgSCHLmmStopTmr
(
Inst inst, /* Scheduler instance */
S16 tmrEvnt, /* Timer Event */
PTR cb /* Entry for which Timer Expired */
)
#else
-PUBLIC S16 rgSCHLmmStopTmr(inst, tmrEvnt, cb)
+S16 rgSCHLmmStopTmr(inst, tmrEvnt, cb)
Inst inst; /* Scheduler instance */
S16 tmrEvnt; /* Timer Event */
PTR cb; /* Entry for which Timer Expired */
U8 i;
S16 ret;
- TRC2(rgSCHLmmStopTmr)
-
ret = RFAILED;
for(i=0;i<RGSCH_MAX_TIMER;i++)
if(((RgSchLowSapCb *)cb)->tmrBlk.tmrEvnt == tmrEvnt)
{
/* Initialize the arg structure */
- cmMemset((U8 *)&arg, 0, sizeof(CmTmrArg));
+ memset(&arg, 0, sizeof(CmTmrArg));
arg.tqCp = &rgSchCb[inst].tmrTqCp;
arg.tq = rgSchCb[inst].tmrTq;
}
- RETVALUE(ret);
+ return (ret);
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmTmrExpiry
+S16 rgSCHLmmTmrExpiry
(
PTR cb, /* Pointer to timer control block */
S16 tmrEvnt /* Timer Event */
)
#else
-PUBLIC S16 rgSCHLmmTmrExpiry(cb,tmrEvnt)
+S16 rgSCHLmmTmrExpiry(cb,tmrEvnt)
PTR cb; /* Pointer to timer control block */
S16 tmrEvnt; /* Timer Event */
#endif
#ifdef DEBUGP
Inst inst = tfuSap->cell->instIdx;
#endif
- TRC2(rgSCHLmmTmrExpiry)
switch(tmrEvnt)
ret = RFAILED;
break;
}
- RETVALUE(ret);
+ return (ret);
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmBndCfm
+S16 rgSCHLmmBndCfm
(
Pst *pst, /* Post Structure */
SuId suId, /* Service user ID */
U8 status /* Status */
)
#else
-PUBLIC S16 rgSCHLmmBndCfm(pst,suId,status)
+S16 rgSCHLmmBndCfm(pst,suId,status)
Pst *pst; /* Post Structure */
SuId suId; /* Service user Id */
U8 status; /* Status */
Pst cfmPst;
Inst inst = (pst->dstInst - SCH_INST_START); /* scheduler instance */
- TRC2(rgSCHLmmBndCfm)
-
/* check the SAP State */
switch(rgSchCb[inst].tfuSap[suId].sapSta.sapState)
break;
case LRG_BND:
/* SAP is already bound */
- RETVALUE(ROK);
+ return ROK;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
cfmPst = rgSchCb[inst].rgSchInit.lmPst;
cfmPst.region = rgSchCb[inst].genCfg.bndCfmResp[suId].response.mem.region;
cfmPst.pool = rgSchCb[inst].genCfg.bndCfmResp[suId].response.mem.pool;
- cmMemset((U8 *)&cntrlCfm, 0, sizeof(RgMngmt));
+ memset(&cntrlCfm, 0, sizeof(RgMngmt));
switch(status)
{
ret = RgMiLrgSchCntrlCfm(&cfmPst, &cntrlCfm);
- RETVALUE(ret);
+ return (ret);
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmStaInd
+S16 rgSCHLmmStaInd
(
Inst inst,
U16 category,
RgUstaDgn *dgn
)
#else
-PUBLIC S16 rgSCHLmmStaInd(inst, category, event, cause, dgn)
+S16 rgSCHLmmStaInd(inst, category, event, cause, dgn)
Inst inst;
U16 category;
U16 event;
{
RgMngmt usta;
- TRC2(rgSCHLmmStaInd)
-
if(rgSchCb[inst].rgSchInit.usta == FALSE)
{
- RETVALUE(ROK);
+ return ROK;
}
- cmMemset((U8 *)&usta, 0, sizeof(RgMngmt));
+ memset(&usta, 0, sizeof(RgMngmt));
SGetDateTime(&usta.t.usta.cmAlarm.dt);
usta.t.usta.cmAlarm.category = category;
usta.t.usta.cmAlarm.cause = cause;
if (dgn != NULLP)
{
- cmMemcpy((U8 *)&usta.t.usta.dgn, (U8 *)dgn, sizeof(RgUstaDgn));
+ memcpy(&usta.t.usta.dgn, dgn, sizeof(RgUstaDgn));
}
rgSchCb[inst].rgSchInit.lmPst.selector =
rgSchCb[inst].genCfg.ustaResp.response.mem.pool;
usta.hdr.transId = rgSchCb[inst].genCfg.ustaResp.transId;
- RETVALUE(RgMiLrgSchStaInd(&rgSchCb[inst].rgSchInit.lmPst, &usta));
+ return (RgMiLrgSchStaInd(&rgSchCb[inst].rgSchInit.lmPst, &usta));
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 schActvTmr
+S16 schActvTmr
(
Ent ent,
Inst inst
)
#else
-PUBLIC S16 schActvTmr(ent, inst)
+S16 schActvTmr(ent, inst)
Ent ent;
Inst inst;
#endif
{
Inst schInst = (inst - SCH_INST_START);
- TRC2(schActvTmr)
/* Check if any timer in the scheduler instance has expired */
cmPrcTmr(&rgSchCb[schInst].tmrTqCp,
rgSchCb[schInst].tmrTq, (PFV) rgSCHLmmTmrExpiry);
- RETVALUE(ROK);
+ return ROK;
} /* end of schActvTmr */
Code Review / o-du / l2.git / blobdiff