The functions for the configuration, control, status and statistics
request primitives are defined here.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=220;
-static int RLOG_MODULE_ID=4096;
/* header include files (.h) */
#include "common_def.h"
#include "rgr.h" /* LRG Interface defines */
#include "rg.h" /* MAC defines */
#include "rg_err.h" /* MAC error defines */
+#include "mac_utils.h"
/* header/extern include files (.x) */
#include "crg.x" /* CRG Interface includes */
#endif
#include "ss_rbuf.h"
#include "ss_rbuf.x"
-#include "lwr_mac.h" /* MAC CL defines */
#include "mac_sch_interface.h"
#include "lwr_mac_upr_inf.h"
#include "mac.h"
-#include "lwr_mac_phy.h"
#include "lwr_mac_fsm.h"
+#include "lwr_mac_phy.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/* Public variable declaration */
-LwrMacCb lwrMacCb;
MacCb macCb;
/* forward references */
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 rgActvInit
(
Ent entity, /* entity */
Region region, /* region */
Reason reason /* reason */
)
-#else
-S16 rgActvInit(entity, inst, region, reason)
-Ent entity; /* entity */
-Inst inst; /* instance */
-Region region; /* region */
-Reason reason; /* reason */
-#endif
{
Inst macInst ;
SAttachSRngBuf(SS_RNG_BUF_ULMAC_TO_ULRLC, SS_RBUF_ENT_ULRLC,SS_RNG_RX);
#endif
- /* Initializing CL control block */
- memset(&lwrMacCb, 0, sizeof(LwrMacCb));
- lwrMacCb.region = region;
- lwrMacCb.pool = 0;
- lwrMacCb.clCfgDone = TRUE;
- lwrMacCb.numCell = 0;
- lwrMacCb.phyState = PHY_STATE_IDLE;
-
/* Initialize Scheduler as well */
- schActvInit(ENTMAC, (DEFAULT_CELLS + SCH_INST_START), DFLT_REGION, PWR_UP);
+ schActvInit(ENTMAC, SCH_INST_START, DFLT_REGION, PWR_UP);
/* Initialize lower mac */
- lwrMacInit();
+ lwrMacLayerInit(region, 0);
return ROK;
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 RgMiLrgCfgReq
(
Pst *pst, /* post structure */
RgMngmt *cfg /* config structure */
)
-#else
-S16 RgMiLrgCfgReq(pst, cfg)
-Pst *pst; /* post structure */
-RgMngmt *cfg; /* config structure */
-#endif
{
uint16_t ret = LCM_PRIM_OK;
uint16_t reason = LCM_REASON_NOT_APPL;
- RG_DIAG_LVL0(inst,0x0a0b0001, RG_DIAG_NA, SS_DIAG_INV_ARG,\
- "Received CfgReq for MAC layer, Entity = %d, Instance = %d\n", pst->srcEnt, pst->srcInst,0,0);
+ DU_LOG("\nINFO --> MAC : Received CfgReq for MAC layer, Entity = %d, Instance = %d", pst->srcEnt, pst->srcInst);
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
switch(cfg->hdr.elmId.elmnt)
{
case STGEN:
+#ifdef INTEL_WLS_MEM
+ /* Start WLS message receiver thread */
+ LwrMacStartWlsRcvr();
+#endif
reason = rgLMMGenCfg(inst,&cfg->t.cfg);
break;
case STRGUSAP:
default:
ret = LCM_PRIM_NOK;
reason = LCM_REASON_INVALID_ELMNT;
- RLOG1(L_ERROR, "Invalid Elmnt=%d",
+ DU_LOG("\nERROR --> MAC : Invalid Elmnt=%d",
cfg->hdr.elmId.elmnt);
break;
}
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 RgMiLrgStsReq
(
Pst *pst, /* post structure */
RgMngmt *sts /* statistics structure */
)
-#else
-S16 RgMiLrgStsReq(pst, sts)
-Pst *pst; /* post structure */
-RgMngmt *sts; /* statistics structure */
-#endif
{
Pst cfmPst;
RgMngmt cfm;
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
RgMiLrgStsCfm(&cfmPst,&cfm);
- RLOG0(L_ERROR, "Gen Cfg not done");
+ DU_LOG("\nERROR --> MAC : Gen Cfg not done");
return ROK;
}
default:
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
- RLOG1(L_ERROR, "Invalid Elmnt = %d",sts->hdr.elmId.elmnt);
+ DU_LOG("\nERROR --> MAC : Invalid Elmnt = %d",sts->hdr.elmId.elmnt);
break;
}
RgMiLrgStsCfm(&cfmPst,&cfm);
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 RgMiLrgStaReq
(
Pst *pst, /* post structure */
RgMngmt *sta /* status structure */
)
-#else
-S16 RgMiLrgStaReq(pst, sta)
-Pst *pst; /* post structure */
-RgMngmt *sta; /* status structure */
-#endif
{
Pst cfmPst;
RgMngmt cfm;
if (sta->t.ssta.s.sysId.ptNmb != NULLP)
{
- SPutSBuf(pst->region, pst->pool, (Data *)sta->t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ MAC_FREE(sta->t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
}
memset(&cfm, 0, sizeof(RgMngmt));
if(rgCb[inst].rgInit.cfgDone != TRUE)
{
SGetDateTime(&cfm.t.ssta.dt);
- if (SGetSBuf(cfmPst.region, cfmPst.pool,
- (Data **)&(cfm.t.ssta.s.sysId.ptNmb), LRG_MAX_PT_NUM_SIZE)
- != ROK)
+ MAC_ALLOC(cfm.t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ if(cfm.t.ssta.s.sysId.ptNmb == NULLP)
{
- RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
+ DU_LOG("\nERROR --> MAC : Memory Unavailable for Confirmation");
return ROK;
}
memset((cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
cfm.hdr.elmId.elmnt = sta->hdr.elmId.elmnt;
RgMiLrgStaCfm(&cfmPst, &cfm);
- RLOG0(L_ERROR, "Gen Cfg not done");
+ DU_LOG("\nERROR --> MAC : Gen Cfg not done");
return ROK;
}
{
case STGEN:
SGetDateTime(&cfm.t.ssta.dt);
- if (SGetSBuf(cfmPst.region, cfmPst.pool,
- (Data **)&(cfm.t.ssta.s.sysId.ptNmb), LRG_MAX_PT_NUM_SIZE)
- != ROK)
+ MAC_ALLOC(cfm.t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ if(cfm.t.ssta.s.sysId.ptNmb == NULLP)
{
- RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
+ DU_LOG("\nERROR --> MAC : Memory Unavailable for Confirmation");
return ROK;
}
memset((cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
RgMiLrgStaCfm(&cfmPst, &cfm);
- RLOG1(L_ERROR, "Invalid elmnt=%d",sta->hdr.elmId.elmnt);
+ DU_LOG("\nERROR --> MAC : Invalid elmnt=%d",sta->hdr.elmId.elmnt);
break;
}
return ROK;
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 RgMiLrgCntrlReq
(
Pst *pst, /* post structure */
RgMngmt *cntrl /* control structure */
)
-#else
-S16 RgMiLrgCntrlReq(pst, cntrl)
-Pst *pst; /* post structure */
-RgMngmt *cntrl; /* control structure */
-#endif
{
S16 ret = ROK; /* return value */
Pst cfmPst;
cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt;
RgMiLrgCntrlCfm(&cfmPst, &cfm);
- RLOG0(L_ERROR, "Gen Cfg not done");
+ DU_LOG("\nERROR --> MAC : Gen Cfg not done");
return ROK;
}
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
RgMiLrgCntrlCfm(&cfmPst, &cfm);
- RLOG1(L_ERROR, "invalid elmnt=%d",cntrl->hdr.elmId.elmnt);
+ DU_LOG("\nERROR --> MAC : invalid elmnt=%d",cntrl->hdr.elmId.elmnt);
break;
}
return (ret);
* -# LCM_REASON_INVALID_SAP
* -# LCM_REASON_NOT_APPL
**/
-#ifdef ANSI
static uint16_t rgLMMSapCfg
(
Inst inst,
RgCfg *cfg, /* Configuaration information */
Elmnt sapType /* Sap Type */
)
-#else
-static uint16_t rgLMMSapCfg(inst,cfg,sapType)
-Inst inst;
-RgCfg *cfg; /* Configuaration information */
-Elmnt sapType; /* Sap Type */
-#endif
{
uint16_t ret = LCM_REASON_NOT_APPL;
RgLowSapCfgInfo *lowSapCfg = NULLP;
(cfg->s.rguSap.selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
- RLOG0(L_ERROR, "unsupported Selector value for RGU");
+ DU_LOG("\nERROR --> MAC : unsupported Selector value for RGU");
break;
}
upSapCb = &(rgCb[inst].rguSap[cfg->s.rguSap.spId]);
(cfg->s.crgSap.selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
- RLOG0(L_ERROR, "unsupported Selector value for CRG");
+ DU_LOG("\nERROR --> MAC : unsupported Selector value for CRG");
break;
}
if(rgCb[inst].crgSap.sapSta.sapState == LRG_NOT_CFG)
(cfg->s.tfuSap.selector != ODU_SELECTOR_LC))
{
ret = LCM_REASON_INVALID_PAR_VAL;
- RLOG0(L_ERROR, "unsupported Selector value for TFU");
+ DU_LOG("\nERROR --> MAC : unsupported Selector value for TFU");
break;
}
#endif
* -# LCM_REASON_INVALID_MSGTYPE
* -# LCM_REASON_MEM_NOAVAIL
**/
-#ifdef ANSI
static uint16_t rgLMMGenCfg
(
Inst inst,
RgCfg *cfg /* Configuaration information */
)
-#else
-static uint16_t rgLMMGenCfg(inst,cfg)
-Inst inst;
-RgCfg *cfg; /* Configuaration information */
-#endif
{
uint16_t ret = LCM_REASON_NOT_APPL;
if ((cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_TC) &&
(cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_LC))
{
- RLOG0(L_ERROR, "unsupported Selector value for RGU");
+ DU_LOG("\nERROR --> MAC : unsupported Selector value for RGU");
return (LCM_REASON_INVALID_PAR_VAL);
}
/* Update the Pst structure for LM interface */
rgCb[inst].rgInit.pool = cfg->s.genCfg.mem.pool;
rgCb[inst].genCfg.tmrRes = cfg->s.genCfg.tmrRes;
+ macCb.tmrRes = cfg->s.genCfg.tmrRes;
macCb.macInst = rgCb[inst].rgInit.inst;
macCb.procId = rgCb[inst].rgInit.procId;
if(cfg->s.genCfg.numRguSaps == 0)
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "\nrgGenCfg(): Invalid numRguSap.\n"));
+ DU_LOG("\nERROR --> MAC : rgGenCfg(): Invalid numRguSap.\n");
return RFAILED;
}
/* allocate RGR saps */
- if (SGetSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data **)&rgCb[inst].rguSap,
- (sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps)) != ROK)
+ MAC_ALLOC(rgCb[inst].rguSap, sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps);
+ if(rgCb[inst].rguSap == NULLP)
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "\nrgGenCfg(): Failed to allocate mem for RGU SAP's.\n"));
+ DU_LOG("\nERROR --> MAC : rgGenCfg(): Failed to allocate mem for RGU SAP's.\n");
return RFAILED;
}
rgCb[inst].numRguSaps = cfg->s.genCfg.numRguSaps;
}
rgCb[inst].tfuSap.sapSta.sapState = LRG_NOT_CFG;
/* Initialize the timer blocks */
- cmInitTimers(rgCb[inst].tmrBlk, RG_MAX_TIMER);
+ cmInitTimers(macCb.tmrBlk, MAX_NUM_TIMER);
/* Initialzie the timer queue */
- memset(&rgCb[inst].tmrTq, 0, sizeof(CmTqType)*RG_TQ_SIZE);
+ memset(&macCb.tmrTq, 0, sizeof(CmTqType) * MAC_TQ_SIZE);
/* Initialize the timer control point */
- memset(&rgCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
- rgCb[inst].tmrTqCp.tmrLen = RG_TQ_SIZE;
-#if 0
+ memset(&macCb.tmrTqCp, 0, sizeof(CmTqCp));
+ macCb.tmrTqCp.tmrLen = MAC_TQ_SIZE;
+
/* Timer Registration request to SSI */
- if (SRegTmrMt(rgCb[inst].rgInit.ent, rgCb[inst].rgInit.inst,
- (S16)rgCb[inst].genCfg.tmrRes, rgActvTmr) != ROK)
+ if(ODU_REG_TMR_MT(ENTMAC, macCb.macInst, macCb.tmrRes, macActvTmr) != ROK)
{
- RLOG0(L_ERROR, "Failed to register timer");
+ DU_LOG("\nERROR --> MAC : Failed to register timer");
- SPutSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data *)rgCb[inst].rguSap,
+ MAC_FREE(rgCb[inst].rguSap,
(sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps));
return (LCM_REASON_MEM_NOAVAIL);
}
-#endif
+
/* Set Config done in TskInit */
rgCb[inst].rgInit.cfgDone = TRUE;
* File : rg_lmm.c
*
**********************************************************/
-#ifdef ANSI
-static Void rgLMMShutdown
-(
-Inst inst
-)
-#else
-static Void rgLMMShutdown(inst)
-Inst inst;
-#endif
+static Void rgLMMShutdown(Inst inst)
{
RgCellCb *cell = rgCb[inst].cell;
uint8_t idx;
/* Unbind the TFU Sap */
if(rgCb[inst].tfuSap.sapSta.sapState == LRG_WAIT_BNDCFM)
{
- rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, LRG_UNBND);
+ //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, LRG_UNBND);
if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
{
rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
}
if(rgCb[inst].tfuSap.sapSta.sapState == LRG_BND)
{
- rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, LRG_UNBND);
+ //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, LRG_UNBND);
rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
}
}
/* Deleting the RGU SAPs */
- SPutSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data *)rgCb[inst].rguSap,
+ MAC_FREE(rgCb[inst].rguSap,
(sizeof(RgUpSapCb) * rgCb[inst].numRguSaps));
- rgCb[inst].rguSap = NULLP;
rgCb[inst].inactiveCell = NULLP;
rgCb[inst].cell = NULLP;
/* De-register the Timer Service */
(Void) SDeregTmrMt(rgCb[inst].rgInit.ent, rgCb[inst].rgInit.inst,
- (S16)rgCb[inst].genCfg.tmrRes, rgActvTmr);
+ (S16)rgCb[inst].genCfg.tmrRes, macActvTmr);
/* call back the task initialization function to intialize
* the global RgCb Struct */
* File : rg_lmm.c
*
**********************************************************/
-#ifdef ANSI
static Void rgLMMGenCntrl
(
RgMngmt *cntrl,
RgMngmt *cfm,
Pst *cfmPst
)
-#else
-static Void rgLMMGenCntrl(cntrl, cfm, cfmPst)
-RgMngmt *cntrl;
-RgMngmt *cfm;
-Pst *cfmPst;
-#endif
{
Inst inst = (cfmPst->srcInst - RG_INST_START);
default:
cfm->cfm.status = LCM_PRIM_NOK;
cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RLOG1(L_ERROR, "invalid subaction=%d",cntrl->t.cntrl.subAction);
+ DU_LOG("\nERROR --> MAC : invalid subaction=%d",cntrl->t.cntrl.subAction);
break;
}
break;
default:
cfm->cfm.status = LCM_PRIM_NOK;
cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RLOG1(L_ERROR, "invalid subaction=%d",cntrl->t.cntrl.subAction);
+ DU_LOG("\nERROR --> MAC : invalid subaction=%d",cntrl->t.cntrl.subAction);
break;
}
break;
default:
cfm->cfm.status = LCM_PRIM_NOK;
cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RLOG1(L_ERROR, "invalid action=%d",cntrl->t.cntrl.action);
+ DU_LOG("\nERROR --> MAC : invalid action=%d",cntrl->t.cntrl.action);
break;
}
RgMiLrgCntrlCfm(cfmPst, cfm);
* File : rg_lmm.c
*
**********************************************************/
-#ifdef ANSI
static Void rgLMMSapCntrl
(
RgMngmt *cntrl,
RgMngmt *cfm,
Pst *cfmPst
)
-#else
-static Void rgLMMSapCntrl(cntrl, cfm, cfmPst)
-RgMngmt *cntrl;
-RgMngmt *cfm;
-Pst *cfmPst;
-#endif
{
Inst inst = cfmPst->srcInst - RG_INST_START;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
RgMiLrgCntrlCfm(cfmPst, cfm);
- rgLIMTfuBndReq(inst,rgCb[inst].tfuSap.sapCfg.suId,
- rgCb[inst].tfuSap.sapCfg.spId);
+ //rgLIMTfuBndReq(inst,rgCb[inst].tfuSap.sapCfg.suId,
+ //rgCb[inst].tfuSap.sapCfg.spId);
RETVOID;
}
break;
}
else
{
- rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, TFU_UBNDREQ_MNGMT);
+ //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, TFU_UBNDREQ_MNGMT);
if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
{
rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
if ((rgCb[inst].tfuSap.sapSta.sapState == LRG_WAIT_BNDCFM) ||
(rgCb[inst].tfuSap.sapSta.sapState == LRG_BND))
{
- rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, TFU_UBNDREQ_MNGMT);
+ //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, TFU_UBNDREQ_MNGMT);
if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
{
rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
default:
cfm->cfm.status = LCM_PRIM_NOK;
cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RGDBGERRNEW(inst,(rgPBuf(inst), "\nrgLMMSapCntrl(): invalid action=%d",
- cntrl->t.cntrl.action));
+ DU_LOG("\nERROR --> MAC : rgLMMSapCntrl(): invalid action=%d",
+ cntrl->t.cntrl.action);
break;
}
break;
default:
cfm->cfm.status = LCM_PRIM_NOK;
cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RGDBGERRNEW(inst,(rgPBuf(inst), "\nrgLMMSapCntrl(): invalid action=%d",
- cntrl->t.cntrl.action));
+ DU_LOG("\nERROR --> MAC : rgLMMSapCntrl(): invalid action=%d",
+ cntrl->t.cntrl.action);
break;
}
break;
default:
cfm->cfm.status = LCM_PRIM_NOK;
cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RLOG1(L_ERROR, "invalid action=%d",cntrl->t.cntrl.action);
+ DU_LOG("\nERROR --> MAC : invalid action=%d",cntrl->t.cntrl.action);
break;
}
* File : rg_lmm.c
*
**********************************************************/
-#ifdef ANSI
static Void rgLMMFillCfmPst
(
Pst *reqPst,
Pst *cfmPst,
RgMngmt *cfm
)
-#else
-static Void rgLMMFillCfmPst(reqPst, cfmPst, cfm)
-Pst *reqPst;
-Pst *cfmPst;
-RgMngmt *cfm;
-#endif
{
Inst inst;
inst = (reqPst->dstInst - RG_INST_START);
* @return S16
* -# ROK
**/
-#ifdef ANSI
- S16 rgLMMStartTmr
+S16 rgLMMStartTmr
(
- Inst inst,
- S16 tmrEvnt, /* Timer Event */
- uint32_t tmrVal, /* Wait Time */
- PTR cb /* Entry for which Timer Expired */
- )
-#else
-S16 rgLMMStartTmr(tmrEvnt, tmrVal, cb)
- Inst inst;
- S16 tmrEvnt; /* Timer Event */
- uint32_t tmrVal; /* Wait Time */
- PTR cb; /* Entry for which Timer Expired */
-#endif
+Inst inst,
+S16 tmrEvnt, /* Timer Event */
+uint32_t tmrVal, /* Wait Time */
+PTR cb /* Entry for which Timer Expired */
+)
{
CmTmrArg arg;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgLMMStopTmr
(
Inst inst, /* Scheduler instance */
S16 tmrEvnt, /* Timer Event */
PTR cb /* Entry for which Timer Expired */
)
-#else
-S16 rgLMMStopTmr(inst,tmrEvnt, cb)
-Inst inst; /* Scheduler instance */
-S16 tmrEvnt; /* Timer Event */
-PTR cb; /* Entry for which Timer Expired */
-#endif
{
CmTmrArg arg;
uint8_t i;
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 rgLMMTmrExpiry
(
PTR cb, /* Pointer to timer control block */
S16 tmrEvnt /* Timer Event */
)
-#else
-S16 rgLMMTmrExpiry(cb,tmrEvnt)
-PTR cb; /* Pointer to timer control block */
-S16 tmrEvnt; /* Timer Event */
-#endif
{
S16 ret = ROK;
RgLowSapCb *tfuSap = (RgLowSapCb *)cb;
}
/* Send bind request */
- rgLIMTfuBndReq(inst,rgCb[inst].tfuSap.sapCfg.suId,
- rgCb[inst].tfuSap.sapCfg.spId);
+ //rgLIMTfuBndReq(inst,rgCb[inst].tfuSap.sapCfg.suId,
+ //rgCb[inst].tfuSap.sapCfg.spId);
}
break;
default:
- RLOG1(L_ERROR, "Invalid tmrEvnt=%d",tmrEvnt);
+ DU_LOG("\nERROR --> MAC : Invalid tmrEvnt=%d",tmrEvnt);
ret = RFAILED;
break;
}
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 rgLMMStaInd
(
Inst inst,
uint16_t cause,
RgUstaDgn *dgn
)
-#else
-S16 rgLMMStaInd(inst,category, event, cause, dgn)
-Inst inst;
-uint16_t category;
-uint16_t event;
-uint16_t cause;
-RgUstaDgn *dgn;
-#endif
{
RgMngmt usta;
-
-
if(rgCb[inst].rgInit.usta == FALSE)
{
return ROK;
* @param[in] uint8_t event, the trace event.
* @return Void
**/
-#ifdef ANSI
Void rgLMMTrcInd
(
Inst inst,
Buffer *srcMbuf, /* Message Buffer */
uint8_t event /* event */
)
-#else
-Void rgLMMTrcInd(inst,srcMbuf,event)
-Inst inst;
-Buffer *srcMbuf; /* Message Buffer */
-uint8_t event; /* event */
-#endif
{
Buffer *dstMbuf = NULLP;
MsgLen bufLen = 0;
if ((rgCb[inst].trcLen == LRG_NO_TRACE) || (srcMbuf == NULLP))
{
- RLOG0(L_ERROR, "Trace Disabled.");
+ DU_LOG("\nERROR --> MAC : Trace Disabled.");
return;
}
if (SCpyMsgMsg(srcMbuf, pst.region, pst.pool, &dstMbuf)
!= ROK)
{
- RLOG0(L_ERROR, "SCpyMsgMsg Failed.");
+ DU_LOG("\nERROR --> MAC : SCpyMsgMsg Failed.");
return;
}
trc.cfm.status = LCM_PRIM_OK;
/* Get the length of the recvd message buffer */
if (SFndLenMsg(srcMbuf, &bufLen) != ROK)
{
- RLOG0(L_ERROR, "SFndLenMsg Failed.");
+ DU_LOG("\nERROR --> MAC : SFndLenMsg Failed.");
return;
}
/* Check if the recvd buffer size is less than request trace len */
if (SCpyMsgMsg(srcMbuf, pst.region, pst.pool, &dstMbuf)
!= ROK)
{
- RLOG0(L_ERROR, "SCpyMsgMsg Failed.");
+ DU_LOG("\nERROR --> MAC : SCpyMsgMsg Failed.");
return;
}
/* Get a temporary buffer to store the msg */
if (rgAllocSBuf(inst,&tempBuf, rgCb[inst].trcLen) != ROK)
{
- RLOG0(L_ERROR, "rgAllocSBuf Failed.");
+ DU_LOG("\nERROR --> MAC : rgAllocSBuf Failed.");
return;
}
/* Copy trcLen nos of bytes from the recvd message */
if (SCpyMsgFix(srcMbuf,0,rgCb[inst].trcLen,tempBuf,&tempCnt) != ROK)
{
- RLOG0(L_ERROR, "SCpyMsgFix Failed.");
+ DU_LOG("\nERROR --> MAC : SCpyMsgFix Failed.");
return;
}
- if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
+ if (ODU_GET_MSG_BUF(pst.region, pst.pool, &dstMbuf) != ROK)
{
- RLOG0(L_ERROR, "dstMbuf Allocation Failed");
+ DU_LOG("\nERROR --> MAC : dstMbuf Allocation Failed");
return;
}
/* Copy the tempBuf data to dst mBuf */
if (SCpyFixMsg(tempBuf,dstMbuf,0,rgCb[inst].trcLen,&tempCnt) != ROK)
{
- RLOG0(L_ERROR, "SCpyFixMsg Failed.");
+ DU_LOG("\nERROR --> MAC : SCpyFixMsg Failed.");
return;
}
* @return S16
* -# ROK
**/
-#ifdef ANSI
S16 rgLMMBndCfm
(
Pst *pst, /* Post Structure */
SuId suId, /* Service user ID */
uint8_t status /* Status */
)
-#else
-S16 rgLMMBndCfm(pst,suId,status)
-Pst *pst; /* Post Structure */
-SuId suId; /* Service user ID */
-uint8_t status; /* Status */
-#endif
{
Inst inst = pst->dstInst - RG_INST_START;
S16 ret = ROK;
/* Check if the suId is valid */
if(rgCb[inst].tfuSap.sapCfg.suId != suId)
{
- RLOG0(L_ERROR, "Invalid SuId");
+ DU_LOG("\nERROR --> MAC : Invalid SuId");
return RFAILED;
}
return (ret);
}
-\f
-/**
- * @brief LTE MAC timer call back function registered with SSI.
- *
- * @details
- *
- * Function : rgActvTmr
- *
- * This function is invoked by SSI for every timer activation
- * period expiry.
- *
- * @return S16
- * -# ROK
- **/
-#ifdef ANSI
-S16 rgActvTmr
-(
-Ent ent,
-Inst inst
-)
-#else
-S16 rgActvTmr(ent, inst)
-Ent ent;
-Inst inst;
-#endif
-{
- Inst macInst = (inst - RG_INST_START);
-
- /* Check if any MAC timer has expired */
- cmPrcTmr(&rgCb[macInst].tmrTqCp, rgCb[macInst].tmrTq, (PFV) rgLMMTmrExpiry);
-
- return ROK;
-
-} /* end of rgActvTmr */
-
/**********************************************************************
End of file
Code Review / o-du / l2.git / blobdiff