/* allocate static buffer from WLS memory */
#define WLS_MEM_ALLOC(_datPtr, _size) \
{ \
- int16_t _ret; \
+ uint8_t _ret; \
_ret = SGetSBufWls(0, 0, (Data **)&_datPtr, _size); \
if(_ret == ROK) \
- memset((U8*)_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
else \
_datPtr = NULLP; \
}
uint8_t ret = ROK;
MacCellCb *macCellCb;
- memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
+ memset(&cfmPst, 0, sizeof(Pst));
MAC_ALLOC(macCellCb, sizeof(MacCellCb));
if(macCellCb == NULLP)
Pst cfgPst;
uint8_t ret;
- memset((uint8_t *)&cfgPst, 0, sizeof(Pst));
+ memset(&cfgPst, 0, sizeof(Pst));
schCellCfg.cellId = macCellCfg->cellId;
schCellCfg.phyCellId = macCellCfg->phyCellId;
schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
uint16_t cellIdx;
MacCellCfgCfm macCellCfgCfm;
- memset((uint8_t *)&pst, 0, sizeof(Pst));
+ memset(&pst, 0, sizeof(Pst));
GET_CELL_IDX(cellId, cellIdx);
macCellCfgCfm.cellId = macCb.macCell[cellIdx]->macCellCfg.cellId;
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
{ \
- cmMemset((uint8_t *)_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
} \
else \
{ \
if(SGetStaticBuffer(MAC_MEM_REGION, MAC_POOL, \
(Data **)&_buf, (Size) _size, 0) == ROK) \
{ \
- cmMemset((uint8_t *)(_buf), 0, _size); \
+ memset((_buf), 0, _size); \
} \
else \
{ \
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGVldtCrgCellCfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_CFG;
if ((rgCb[inst].cell != NULLP)
|| rgCb[inst].inactiveCell != NULLP)
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGVldtCrgUeCfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_CFG;
if ((ueCfg->txMode.pres == PRSNT_NODEF) &&
(ueCfg->txMode.tm == CRG_UE_TM_5))
#endif
{
- TRC2(rgCFGVldtCrgLcCfg);
-
if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
{
/* Dedicated logical channels */
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGVldtCrgCellRecfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_RECFG;
if (((*cell = rgCb[inst].cell) == NULLP)
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGVldtCrgUeRecfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
if ((ueRecfg->txMode.pres == PRSNT_NODEF) &&
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGVldtCrgLcRecfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_LC_RECFG;
/* Fetch the cell */
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGVldtCrgUeReset);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RESET;
/* Fetch the Active cell */
/* RLC SAP to allocate flowCntrlInd buffer*/
Pst *pst ;
- TRC2(rgCFGCrgCellCfg);
-
errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
/* Allocate the cell control block */
cmLListInit(&cell->l2mList);
for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
{
- cmMemset((U8 *)&cell->ulSf[idx], 0, sizeof(RgUlSf));
+ memset(&cell->ulSf[idx], 0, sizeof(RgUlSf));
}
cell->ttiCycle = (U32)RG_TTI_CYCLE_INVLD;
U8 idx;
RgErrInfo errInfo;
- TRC2(rgCfgAddUeSCellCfg);
-
#ifdef LTE_ADV
rguDlSapId = ueSCellCb->rguDlSapId;
rguUlSapId = ueSCellCb->rguUlSapId;
RgPrgUeSCellCfgInfo ueSCellCb;
Pst dstInstPst;
- TRC2(rgFillAndAddSCellCfg);
-
/* Fetch the Active cell */
if(((cell = rgCb[inst].cell) == NULLP) ||
(cell->cellId != ueRecfg->cellId))
ue->cfgCfmInfo.cfgCfgCount = 0;
ue->cfgCfmInfo.mask = 0x0;
- cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
+ memcpy(&(ue->cfgCfmInfo.transId), &transId,
sizeof(CrgCfgTransId));
ueSCellCb.ueId = ueRecfg->oldCrnti;
ueSCellCb.txMode = ue->txMode;
ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
- cmMemcpy((U8 *)ueSCellCb.ulLcInfo, (U8 *)ue->ul.lcCb, sizeof(ue->ul.lcCb));
- cmMemcpy((U8 *)ueSCellCb.dlLcInfo, (U8 *)ue->dl.lcCb, sizeof(ue->dl.lcCb));
+ memcpy(ueSCellCb.ulLcInfo, ue->ul.lcCb, sizeof(ue->ul.lcCb));
+ memcpy(ueSCellCb.dlLcInfo, ue->dl.lcCb, sizeof(ue->dl.lcCb));
for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
{
ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
SuId rguUlSapId = 0;
SuId rguDlSapId = 0;
- TRC2(rgCFGCrgUeCfg);
-
errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
/* Start: LTEMAC_2.1_DEV_CFG */
#endif
{
- TRC2(rgCFGCrgLcCfg);
-
/* Handle Config for dedicated/common logical channels */
if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
{
}
#ifdef LTE_ADV
/*ERAB Multl Cell fix*/
- cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
+ memcpy(&(ue->cfgCfmInfo.transId), &transId,
sizeof(CrgCfgTransId));
rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
#endif
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGCrgCellRecfg);
-
/* Store the given rachCfg */
cell->rachCfg = cellRecfg->rachRecfg;
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGCrgUeRecfg);
-
errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
/* Fix : syed UE ID change at MAC will now be controlled
Bool *isCfmRqrd;
#endif
{
- TRC2(rgCFGCrgLcRecfg);
if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
{
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGCrgUeReset);
RLOG_ARG1(L_DEBUG, DBG_CRNTI, ue->ueId, "UE: of cell %d Reset\n", cell->cellId);
rgDHMUeReset(cell, &ue->dl.hqEnt);
RgCellCb *cell;
U8 idx;
- TRC2(rgCFGCrgCellDel);
errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
if (((cell = rgCb[inst].cell) == NULLP)
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGCrgUeDel);
errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
RgUlLcCb *ulLc;
RgDlLcCb *dlLc;
- TRC2(rgCFGCrgLcDel);
-
errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
/* Fetch the Active cell */
}
#ifdef LTE_ADV
/*ERAB - multicell fix*/
- cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
+ memcpy( &(ue->cfgCfmInfo.transId), &transId,
sizeof(CrgCfgTransId));
rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
#endif
#endif
{
U8 dirVld = FALSE;
- TRC2(rgCFGVldtCrgDedLcCfg);
errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
{
U8 dirVld = FALSE;
- TRC2(rgCFGVldtCrgCmnLcCfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
/* Ensure cell is not in the active list */
#endif
{
//Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGCrgDedLcCfg);
-
errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
/* Uplink/Bi-directional logical channel */
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCFGCrgCmnLcCfg);
-
errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
/* Handle configuration for CCCH/BCCH/PCCH */
U8 sfIdx;
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeUeUlAlloc);
-
for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
{
if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
#endif
{
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeCellCb);
#ifdef LTE_ADV
RgLaaCellCbDeInit(cell);
#endif
{
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeInactvCellCb);
-
/* De-initialize the Ue list */
rgDBMDeInitUeCbLst(cell);
#ifdef LTEMAC_SPS
{
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeUeCb);
-
rgDHMFreeUe(inst,&ue->dl.hqEnt);
/* ccpu00117052 - MOD - Passing double pointer for proper NULLP
RgCellCb *cell;
#endif
{
- TRC2(rgCFGFreeCmnLcLst);
-
rgDBMFreeCmnLcLst(cell);
{
RgUeCb *ue;
- TRC2(rgCFGFreeUeLst);
-
/* Free Ues in the list */
while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
{
{
RgUeCb *ue;
- TRC2(rgCFGFreeSpsUeLst);
-
/* Free Ues in the list */
while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
{
Inst inst;
RgCellCb *cell = NULLP;
- TRC3(RgSchMacCellRegReq)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cell = rgCb[inst].cell;
RgErrInfo errInfo;
Bool isCfmRqrd = TRUE;
- TRC2(rgCOMCfgReq);
-
/* Process Config/Reconfig/Delete request from RRC */
switch (crgCfgReq->action)
{
RgCellCb *cell = NULLP;
RgUeCb *ue = NULLP;
- TRC2(rgCOMHndlCfgReq);
-
errInfo->errType = RGERR_COM_CFG_REQ;
/* Validate and process the configuration request */
RgUeCb *ue = NULLP;
RgUlLcCb *ulLc = NULLP;
- TRC2(rgCOMHndlRecfgReq);
-
errInfo->errType = RGERR_COM_RECFG_REQ;
/* Validate and process the re-configuration request */
#ifdef LTE_ADV
/*ERAB- multicell fix*/
- cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
+ memcpy( &(ue->cfgCfmInfo.transId), &transId,
sizeof(CrgCfgTransId));
#endif
ret = rgCFGCrgLcRecfg(inst,cell, ue, ulLc,
RgErrInfo *errInfo;
#endif
{
- TRC2(rgCOMHndlResetReq);
-
/* Fix : ccpu00126865: ignore CRG reset. Let SCH trigger it. */
errInfo->errCause = RGERR_NONE;
S16 ret;
VOLATILE U32 startTime=0;
- TRC2(rgCOMHndlDelReq);
-
errInfo->errType = RGERR_COM_DEL_REQ;
/* Process the delete request */
S16 ret;
Pst cfmPst;
- TRC2(RgPrgPMacSMacUeSCellCfgReq);
RGDBGPRM(inst,(rgPBuf(inst),
"APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d\n",
Inst inst = pst->dstInst;
RgCellCb *cell;
RgUeCb *ue;
- TRC2(RgPrgSMacPMacCfgCfm);
-
RG_IS_INST_VALID(inst);
RgCellCb *sCell = rgCb[inst].cell;
RgUeCb *sCellUe = NULLP;
- TRC2(RgPrgPMacSMacUeSCellDelReq)
-
/* Checking for cell Cb because in case of shutdownReq it is possible that
* cell is already deleted for this cell*/
if(sCell == NULLP)
{
S16 ret;
- TRC2(rgDBMInitCell);
-
/* Initialize ue list */
if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
return (ret);
{
Inst inst = cellCb->macInst - RG_INST_START;
RgUeCb ue;
- TRC2(rgDBMInitUeCbLst)
return (cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
RgCellCb *cellCb;
#endif
{
- TRC2(rgDBMDeInitUeCbLst)
return (cmHashListDeinit(&cellCb->ueLst));
{
Inst inst = cellCb->macInst - RG_INST_START;
RgUeCb ue;
- TRC2(rgDBMInitSpsUeCbLst)
return (cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
RgCellCb *cellCb;
#endif
{
- TRC2(rgDBMDeInitSpsUeCbLst)
return (cmHashListDeinit(&cellCb->spsUeLst));
RgUeCb *ueCb;
#endif
{
- TRC2(rgDBMInsUeCb)
-
return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
(U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
RgUeCb *ueCb;
#endif
{
- TRC2(rgDBMInsSpsUeCb)
return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
(U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
{
RgUeCb *ueCb = NULLP;
- TRC2(rgDBMGetUeCb)
-
cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
sizeof(ueId), 0, (PTR *)&ueCb);
return (ueCb);
{
RgUeCb *ueCb = NULLP;
- TRC2(rgDBMGetSpsUeCb)
-
cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
sizeof(spsRnti), 0, (PTR *)&ueCb);
return (ueCb);
{
RgUeCb *nextUeCb = NULLP;
- TRC2(rgDBMGetNextUeCb)
-
cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
return (nextUeCb);
} /* rgDBMGetNextUeCb */
{
RgUeCb *nextUeCb = NULLP;
- TRC2(rgDBMGetNextSpsUeCb)
-
cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
return (nextUeCb);
} /* end of rgDBMGetNextSpsUeCb */
RgUeCb *ueCb;
#endif
{
- TRC2(rgDBMDelUeCb)
-
return (cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
} /* rgDBMDelUeCb */
RgUeCb *ueCb;
#endif
{
- TRC2(rgDBMDelSpsUeCb)
return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
} /* end of rgDBMDelSpsUeCb */
U8 idx;
#endif
- TRC2(rgDBMInitUe);
-
/* Initialize Dedicated logical channels */
rgDBMInitDedLcLst(ueCb);
{
U8 idx;
- TRC2(rgDBMInitDedLcLst);
-
for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
{
/* Set Dedicated LCs as not configured */
{
U8 idx;
- TRC2(rgDBMInitCmnLcLst);
-
cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
{
U8 idx;
- TRC2(rgDBMFreeCmnLcLst);
-
cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
CmLteLcId idx;
#endif
{
- TRC2(rgDBMInsDlDedLcCb);
if( idx >= RG_DEDLC_MIN_LCID )
{
ueCb->dl.lcCb[idx-1].lcId = idx;
RgDlLcCb *dlLcCb;
#endif
{
- TRC2(rgDBMDelDlDedLcCb);
-
ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
CmLteLcId idx;
#endif
{
- TRC2(rgDBMGetDlDedLcCb);
-
if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
{
return (NULLP);
#endif
#endif
{
- TRC2(rgDBMInsUlDedLcCb);
if ( idx >= RG_DEDLC_MIN_LCID)
{
ueCb->ul.lcCb[idx - 1].lcId = idx;
LteLcgId gId;
#endif
{
- TRC2(rgDBMUpdUlDedLcCb);
-
ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
RgUlLcCb *ulLcCb;
#endif
{
- TRC2(rgDBMDelUlDedLcCb);
ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
CmLteLcId idx;
#endif
{
- TRC2(rgDBMGetUlDedLcCb)
if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
{
{
U8 idx;
- TRC2(rgDBMChkCmnLcCb)
-
if(cellCb->bcchBchInfo.lcId == lcId)
{
return ROK;
RgCellCb *cellCb;
#endif
{
- TRC2(rgDBMGetBcchOnBch)
if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
{
{
U8 idx;
- TRC2(rgDBMGetBcchOnDlsch)
-
for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
{
if(cellCb->bcchDlschInfo[idx].lcId == lcId)
RgCellCb *cellCb;
#endif
{
- TRC2(rgDBMGetPcch)
if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
{
CmLteLcId idx;
#endif
{
- TRC2(rgDBMInsBcchOnBch)
cellCb->bcchBchInfo.lcId = idx;
CmLteLcId idx;
#endif
{
- TRC2(rgDBMInsBcchOnDlsch)
cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
cellCb->numBcchDlschInfo++;
CmLteLcId idx;
#endif
{
- TRC2(rgDBMInsPcch)
cellCb->pcchInfo.lcId = idx;
RgCellCb *cellCb;
#endif
{
- TRC2(rgDBMInitRachLst)
cmLListInit(&cellCb->raInfo.ueRachLst);
RETVOID;
RgUeCb *ueCb;
#endif
{
- TRC2(rgDBMInsUeCbInRachLst)
cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
{
CmLList *tmpNode;
- TRC2(rgDBMGetUeCbFromRachLst)
-
CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
while(tmpNode)
{
RgUeCb *ueCb;
#endif
{
- TRC2(rgDBMGetNextUeCbFromRachLst)
if(!ueCb)
{
RgUeCb *ueCb;
#endif
{
- TRC2(rgDBMDelUeCbFromRachLst)
cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
RETVOID;
Buffer *ceDBuf = NULLP;
#endif
- TRC2(rgDHMHqEntInit)
-
hqE->numHqProcs = maxHqProcs;
/* for each harq process */
for (idx1 = 0; idx1 < hqE->numHqProcs; idx1++)
{
U8 i = 0;
- TRC2(rgDHMUeReset)
-
if(hqE->procs[0])
{
/* Free all the TB memory associated with HARQ */
#endif
{
RgCb *rgCbP = &rgCb[inst];
- TRC2(rgDHMHdlBufFree)
if (rgCbP->bufCnt < RG_MAX_DFRD_FREE_BUFS)
{
U8 start = rgCbP->bufCnt;
U8 end = 0;
- TRC2(rgDHMFreeTbBufs)
-
if (rgCbP->bufCnt < RG_MAX_FREE_BUFS_PERTTI)
{
end = 0;
U8 start = rgCbP->bufCnt;
U8 end = 0;
- TRC2(rgDHMFreeAllTbBufs)
-
while (start != end)
{
start--;
// U32 lchIdx, pduIdx;
#endif
- TRC2(rgDHMRlsHqProcTB)
-
if((tbIndex > RG_MAX_TB_PER_UE) ||
(tbIndex == 0))
{
RgDlHqProcCb **hqP;
#endif
{
- TRC2(rgDHMGetHqProcFrmId)
-
/* Pick the proc based on the index provided */
*hqP = (ue->dl.hqEnt.procs[idx]);
has to be inclueded in the TFU Data request.*/
Bool dataAvlblUe;
- TRC2(rgDHMSndDatReq)
-
dataAvlblUe = TRUE;
for(i=0;i< RG_MAX_TB_PER_UE;i++)
{
RgTfuDatReqTbInfo *tb;
#endif
- TRC2(rgDHMHndlDedDatReq);
-
tbIndex = (U8)(datReq->transId & 0x03);
/* Accept all the data requests even if delayed in case nothing
* has been sent earlier on the harq proc.
RgUstaDgn dgn;
RgBldPduInfo bldPdu;
- TRC2(rgDHMHndlCmnDatReq)
-
#ifndef L2_OPTMZ
if (hqProc->tbInfo[0].tb != NULLP)
#else
RgTfuDatReqTbInfo *tb; /* TB to be sent to CL/PHY*/
#endif
- TRC2(rgDHMSndConsolidatedStaInd)
- cmMemset ((U8 *)dStaInd, 0, (sizeof(RgRguDedStaInd *) * rgCb[inst].numRguSaps));
- cmMemset ((U8 *)rguDlSap, 0, (sizeof(RgUpSapCb *) * rgCb[inst].numRguSaps));
+ memset (dStaInd, 0, (sizeof(RgRguDedStaInd *) * rgCb[inst].numRguSaps));
+ memset (rguDlSap, 0, (sizeof(RgUpSapCb *) * rgCb[inst].numRguSaps));
/* Send StaInd for the scheduled UEs */
for(ueIdx = 0; ueIdx < ueInfo->numUes; ueIdx++)
#ifdef L2_OPTMZ
U32 lchIdx, pduIdx;
#endif
- TRC2(rgDHMBldTfuDatReq)
datReq->nmbOfTBs = 0;
#ifndef L2_OPTMZ
RgTfuDatReqTbInfo *tb; /* TB to be sent to CL/PHY*/
U8 idx;
- TRC2(rgDHMFreeHqProcTB)
-
if((tbIndex > RG_MAX_TB_PER_UE) ||
(tbIndex == 0))
{
#endif
{
U8 i;
- TRC2(rgDHMFreeUe)
if(hqE->procs)
{
#endif
U32 startTime=0;
- TRC2(RgSchMacRlsHqReq)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cell = rgCb[inst].cell;
S16 ret;
RgMacSdu *sduAloc = NULLP;
- TRC2(rgDUXInsSdu)
RG_DUX_ALLOC(pdu, sizeof(RgMacSdu), sduAloc, ret);
if(ret != ROK)
U8 byte;
U8 fmt=0;
- TRC2(rgDUXExtSubHdr)
*len = 0;
if(oduPackUInt8(&byte,mBuf) != ROK)
{
S16 ret;
- TRC2(rgDUXExtCe);
switch(lcId)
{
Buffer *tmpBuf2 = NULLP;
RgMacSdu *sdu;
- TRC2(rgDUXExtSdu)
if(lcId == RG_CCCH_LCID)
{
U8 lcId;
U16 subPduLen;
MsgLen len;
- TRC2(rgDUXDemuxData)
ceInfo->bitMask = 0x0000;
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(rgHdlSMEvents)
-
switch(pst->event)
{
#ifdef LCRGMILRG
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(rgHdlNHEvents)
-
switch(pst->event)
{
#ifdef LCRGUICRG
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(rgHdlKWEvents)
-
switch(pst->event)
{
#ifdef LCRGUIRGU
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(rgHdlTFEvents)
-
switch(pst->event)
{
#if (defined(LCRGLITFU) || defined(LWLCRGLITFU))
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(rgHdlRGEvents)
-
switch(pst->event)
{
#ifdef LCRG
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(rgActvTsk)
-
switch(pst->srcEnt)
{
/* The originator of this message is the stack manager,
SystemId *s; /* system id */
#endif
{
- TRC2(rgGetSId);
-
s->mVer = sId.mVer;
s->mRev = sId.mRev;
s->bVer = sId.bVer;
s->bRev = sId.bRev;
- cmMemcpy((U8 *)s->ptNmb, (U8 *)sId.ptNmb, LRG_MAX_PT_NUM_SIZE);
+ memcpy(s->ptNmb, sId.ptNmb, LRG_MAX_PT_NUM_SIZE);
/* Stack Crash Problem for TRACE5 Changes. Added the return below */
RETVOID;
UNUSED(measType);
UNUSED(err);
- TRC3(rgL2mCreateMeasCb)
-
- if ((measCb = rgL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
- {
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Allocation of RgL2MeasCb failed");
- return RFAILED;
- }
+ if ((measCb = rgL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
+ {
+ RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Allocation of RgL2MeasCb failed");
+ return RFAILED;
+ }
//Memcpy is already done in rgL2mAllocMeasCb
- /*cmMemcpy((U8 *)&measCb->measReq, (CONSTANT U8 *)measInfo,\
+ /*memcpy(&measCb->measReq, (CONSTANT U8 *)measInfo,\
sizeof(RgInfL2MeasReq));*/
rgL2mInsertMeasCb(cell, measCb, measInfo);
measCb->measReq.timePrd = measInfo->timePrd;
{
S16 ret=RFAILED;
- TRC3(rgL2mMeasReq)
/* Creaet MeasCb Insert in cell->l2mList and return*/
if ( (ret = rgL2mCreateMeasCb(cell, measInfo,
LRG_L2MEAS_AVG_PRB_PER_QCI_UL, err)) != ROK)
{
Pst pst;
Inst macInst = cell->macInst - RG_INST_START;
- TRC3(rgSndL2MeasCfm)
- cmMemset((U8 *)&pst, 0, sizeof(Pst));
+ memset(&pst, 0, sizeof(Pst));
rgGetPstToInst(&pst,macInst, cell->schInstMap.schInst);
RgMacSchL2Meas(&pst, measCfm);
Pst pst;
Inst macInst = cell->macInst - RG_INST_START;
- TRC3(rgSndL2MeasStopCfm)
- cmMemset((U8 *)&pst, 0, sizeof(Pst));
+ memset(&pst, 0, sizeof(Pst));
rgGetPstToInst(&pst,macInst, cell->schInstMap.schInst);
RgMacSchL2MeasStop(&pst, measCfm);
S16 ret = ROK;
RgInfL2MeasCfm measCfm;
- TRC3(RgSchMacL2MeasReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cellCb = rgCb[inst].cell;
ret = rgL2mMeasReq(cellCb, measInfo, &err);
if (ret != ROK)
{
- cmMemset((U8 *)&measCfm, 0, sizeof(RgInfL2MeasCfm));
+ memset(&measCfm, 0, sizeof(RgInfL2MeasCfm));
measCfm.transId = measInfo->transId;
measCfm.cellId = measInfo->cellId;
measCfm.measType = measInfo->measType;
RgInfL2MeasCfm measCfm;
- TRC3(RgSchMacL2MeasStopReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cellCb = rgCb[inst].cell;
cmLListDelFrm(&cellCb->l2mList, &measCb->measLnk);
rgFreeSBuf(inst,(Data**)&measCb, sizeof(RgL2MeasCb));
}
- cmMemset((U8 *)&measCfm, 0, sizeof(RgInfL2MeasCfm));
+ memset(&measCfm, 0, sizeof(RgInfL2MeasCfm));
measCfm.transId = measInfo->transId;
measCfm.cellId = measInfo->cellId;
measCfm.measType = measInfo->measType;
RgCellCb *cellCb = NULLP;
S16 ret = ROK;
- TRC3(RgSchMacL2MeasSendReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cellCb = rgCb[inst].cell;
RgL2MeasCb *oldMeasCb;
U16 diffTime;
- TRC3(rgL2mInsertMeasCb)
-
/*
* 1. Check if l2mList has any entries.
* 2. If yes
RgL2MeasCb *measCb = NULLP;
Inst inst = cell->macInst - RG_INST_START;
- TRC3(rgL2mAllocMeasCb)
if((rgAllocSBuf(inst,(Data **)&(measCb),
sizeof(RgL2MeasCb))) == RFAILED)
err->errCause = RGERR_RAM_MEM_EXHAUST;
return (NULLP);
}
- cmMemcpy((U8 *)&measCb->measReq, (U8 *)measInfo, sizeof(RgInfL2MeasReq));
+ memcpy(&measCb->measReq, measInfo, sizeof(RgInfL2MeasReq));
RGCPYTIMEINFO(cell->crntTime, measCb->startTime);
return (measCb);
CmLteTimingInfo crntTime;
Inst inst = cell->macInst - RG_INST_START;
- TRC3(rgL2Meas)
-
node = cell->l2mList.first;
while(node != NULLP)
/*LTE_L2_MEAS_PHASE2*/
if (cell->sndL2Meas || measPrd == measCb->measReq.timePrd)
{
- cmMemset((U8 *)&measCfm, 0, sizeof(RgInfL2MeasCfm));
+ memset(&measCfm, 0, sizeof(RgInfL2MeasCfm));
for(idx = 0; idx < measCb->measReq.t.prbReq.numQci; idx++)
{
qciVal = measCb->measReq.t.prbReq.qci[idx];
RgLowSapCb *tfuSap;
Pst pst;
- TRC2(rgLIMTfuBndReq);
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgCb[inst].tfuSap);
- (Void)cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuBndReq (&pst, suId, spId)) != ROK)
{
RLOG0(L_ERROR,"Call to RgLiTfuBndReq() failed");
RgLowSapCb *tfuSap;
Pst pst;
- TRC2(rgLIMTfuUbndReq);
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgCb[inst].tfuSap);
- cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuUbndReq (&pst, tfuSap->sapCfg.spId, reason)) != ROK)
{
RLOG0(L_ERROR,"Call to RgLiTfuUbndReq() failed");
S16 ret;
RgLowSapCb *tfuSap;
- TRC3(RgLiTfuBndCfm);
RG_IS_INST_VALID(pst->dstInst);
{
RgLowSapCb *tfuSap;
- TRC2(rgLIMValidateSap)
tfuSap = &(rgCb[inst].tfuSap);
TfuDatInfo *datInfo;
CmLList *node;
- TRC2(rgLIMUtlFreeDatIndEvnt);
/* Steps of freeing up the TfuDatInd.
* 1. loop through the datIndLst and free up all the buffers.
* 2. free up the whole event
S16 ret;
VOLATILE U32 startTime=0;
- TRC3(RgLiTfuDatInd);
// printf("5GTF:: DatindRcvd\n");
CmLList *node;
U8 i;
- TRC2(rgLIMUtlFreeDatReqEvnt);
/* Steps of freeing up the TfuDatReq.
* 1. Free the bch buffer.
* 2. loop through the pdus list and free up all the buffers.
S16 ret;
RgLowSapCb *tfuSap;
- TRC2(rgLIMTfuDatReq)
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgCb[inst].tfuSap);
S16 ret;
RgLowSapCb *tfuSap;
- TRC2(rgLIMTfuDelDatReq)
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgCb[inst].tfuSap);
SuId suId;
#endif
{
- TRC3(RgLiTfuNonRtInd);
#ifdef NO_ERRCLS
if (rgLIMValidateSap (pst->dstInst - RG_INST_START, suId) != ROK)
#endif
{
Inst macInst ;
- TRC2(rgActvInit);
RG_IS_INST_VALID(inst);
macInst = inst - RG_INST_START;
/* Initialize the MAC TskInit structure to zero */
- cmMemset ((U8 *)&rgCb[macInst], 0, sizeof(RgCb));
+ memset (&rgCb[macInst], 0, sizeof(RgCb));
/* Initialize the MAC TskInit with received values */
rgCb[macInst].rgInit.ent = entity;
Pst cfmPst;
Inst inst;
- TRC2(RgMiLrgCfgReq)
-
RG_DIAG_LVL0(inst,0x0a0b0001, RG_DIAG_NA, SS_DIAG_INV_ARG,
"Received CfgReq for MAC layer, Entity = %d, Instance = %d\n",
/* Fill the post structure for sending the confirmation */
rgLMMFillCfmPst(pst, &cfmPst, cfg);
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
#ifdef LMINT3
cfm.hdr.transId = cfg->hdr.transId;
RgMngmt cfm;
Inst inst;
- TRC2(RgMiLrgStsReq)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
/* Fill the post structure for sending the confirmation */
rgLMMFillCfmPst(pst, &cfmPst, sts);
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
#ifdef LMINT3
cfm.hdr.transId = sts->hdr.transId;
{
case STGEN:
{
- cmMemcpy((U8 *)&(cfm.t.sts.s.genSts), (U8 *)&rgCb[inst].genSts,
+ memcpy(&(cfm.t.sts.s.genSts), &rgCb[inst].genSts,
sizeof(RgGenSts));
/* check if action is read and reset */
if(sts->t.sts.action == ARST)
/* Reset statistics */
if(sts->t.sts.action == ZEROSTS)
{
- cmMemset((U8 *)&hqRetxStats, 0, \
+ memset(&hqRetxStats, 0, \
sizeof(RgSchHqRetxStats));
- cmMemset((U8 *)&hqFailStats, 0, \
+ memset(&hqFailStats, 0, \
sizeof(RgSchNackAckStats));
}
}
}
break;
case STRGUSAP:
- cmMemcpy((U8 *)&(cfm.t.sts.s.rguSts), (U8 *)&rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts,
+ memcpy(&(cfm.t.sts.s.rguSts), &rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts,
sizeof(RgSapSts));
/* check if action is read and reset */
if(sts->t.sts.action == ARST)
- cmMemset((U8 *)&rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts, 0, sizeof(RgSapSts));
+ memset(&rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts, 0, sizeof(RgSapSts));
break;
case STCRGSAP:
- cmMemcpy((U8 *)&(cfm.t.sts.s.crgSts), (U8 *)&rgCb[inst].crgSap.sapSts,
+ memcpy(&(cfm.t.sts.s.crgSts), &rgCb[inst].crgSap.sapSts,
sizeof(RgSapSts));
/* check if action is read and reset */
if(sts->t.sts.action == ARST)
- cmMemset((U8 *)&rgCb[inst].crgSap.sapSts, 0, sizeof(RgSapSts));
+ memset(&rgCb[inst].crgSap.sapSts, 0, sizeof(RgSapSts));
break;
case STTFUSAP:
- cmMemcpy((U8 *)&(cfm.t.sts.s.tfuSts), (U8 *)&rgCb[inst].tfuSap.sapSts,
+ memcpy(&(cfm.t.sts.s.tfuSts), &rgCb[inst].tfuSap.sapSts,
sizeof(RgSapSts));
/* check if action is read and reset */
if(sts->t.sts.action == ARST)
- cmMemset((U8 *)&rgCb[inst].tfuSap.sapSts, 0, sizeof(RgSapSts));
+ memset(&rgCb[inst].tfuSap.sapSts, 0, sizeof(RgSapSts));
break;
default:
RgMngmt cfm;
Inst inst ;
- TRC2(RgMiLrgStaReq)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
SPutSBuf(pst->region, pst->pool, (Data *)sta->t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
}
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
cfm.hdr.elmId.elmnt = sta->hdr.elmId.elmnt;
#ifdef LMINT3
RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
return ROK;
}
- cmMemset((U8 *)(cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
+ memset((cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
rgGetSId(&cfm.t.ssta.s.sysId);
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
return ROK;
}
- cmMemset((U8 *)(cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
+ memset((cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
rgGetSId(&cfm.t.ssta.s.sysId);
cfm.cfm.status = LCM_PRIM_OK;
cfm.cfm.reason = LCM_REASON_NOT_APPL;
cfm.cfm.status = LCM_PRIM_OK;
cfm.cfm.reason = LCM_REASON_NOT_APPL;
SGetDateTime(&cfm.t.ssta.dt);
- cmMemcpy((U8 *)&(cfm.t.ssta.s.rguSapSta),
- (U8 *)&rgCb[inst].rguSap[sta->t.ssta.sapInst].sapSta,
+ memcpy(&(cfm.t.ssta.s.rguSapSta),
+ &rgCb[inst].rguSap[sta->t.ssta.sapInst].sapSta,
sizeof(RgSapSta));
RgMiLrgStaCfm(&cfmPst, &cfm);
break;
cfm.cfm.status = LCM_PRIM_OK;
cfm.cfm.reason = LCM_REASON_NOT_APPL;
SGetDateTime(&cfm.t.ssta.dt);
- cmMemcpy((U8 *)&(cfm.t.ssta.s.crgSapSta), (U8 *)&rgCb[inst].crgSap.sapSta,
+ memcpy(&(cfm.t.ssta.s.crgSapSta), &rgCb[inst].crgSap.sapSta,
sizeof(RgSapSta));
RgMiLrgStaCfm(&cfmPst, &cfm);
break;
cfm.cfm.status = LCM_PRIM_OK;
cfm.cfm.reason = LCM_REASON_NOT_APPL;
SGetDateTime(&cfm.t.ssta.dt);
- cmMemcpy((U8 *)&(cfm.t.ssta.s.tfuSapSta), (U8 *)&rgCb[inst].tfuSap.sapSta,
+ memcpy(&(cfm.t.ssta.s.tfuSapSta), &rgCb[inst].tfuSap.sapSta,
sizeof(RgSapSta));
RgMiLrgStaCfm(&cfmPst, &cfm);
break;
RgMngmt cfm;
Inst inst;
- TRC2(RgMiLrgCntrlReq)
/* Fill the post structure for sending the confirmation */
rgLMMFillCfmPst(pst, &cfmPst, cntrl);
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
#ifdef LMINT3
cfm.hdr.transId = cntrl->hdr.transId;
#endif
RgUpSapCfgInfo *upSapCfg = NULLP;
RgUpSapCb *upSapCb = NULLP;
- TRC2(rgLMMSapCfg)
/* Check if Gen Config has been done */
if(rgCb[inst].rgInit.cfgDone != TRUE)
lowSapCfg->sapPst.prior = cfg->s.tfuSap.prior;
lowSapCfg->suId = cfg->s.tfuSap.suId;
lowSapCfg->spId = cfg->s.tfuSap.spId;
- cmMemcpy((U8 *)&lowSapCfg->bndTmr, (U8 *)&cfg->s.tfuSap.bndTmr,
+ memcpy(&lowSapCfg->bndTmr, &cfg->s.tfuSap.bndTmr,
sizeof(TmrCfg));
break;
default:
{
U16 ret = LCM_REASON_NOT_APPL;
- TRC2(rgLMMGenCfg)
/* Check if General Configuration is done already */
if (rgCb[inst].rgInit.cfgDone == TRUE)
return (LCM_REASON_INVALID_PAR_VAL);
}
/* Update the Pst structure for LM interface */
- cmMemcpy((U8 *)&rgCb[inst].rgInit.lmPst, (U8 *)&cfg->s.genCfg.lmPst,
+ memcpy(&rgCb[inst].rgInit.lmPst, &cfg->s.genCfg.lmPst,
sizeof(Pst));
rgCb[inst].rgInit.lmPst.srcProcId = rgCb[inst].rgInit.procId;
for (int idx = 0; idx < rgCb[inst].numRguSaps; idx++)
{
rgCb[inst].rguSap[idx].sapSta.sapState = LRG_NOT_CFG;
- cmMemset((U8 *)&rgCb[inst].rguSap[idx], 0, sizeof(RgUpSapCb));
+ memset(&rgCb[inst].rguSap[idx], 0, sizeof(RgUpSapCb));
}
rgCb[inst].tfuSap.sapSta.sapState = LRG_NOT_CFG;
/* Initialize the timer blocks */
cmInitTimers(rgCb[inst].tmrBlk, RG_MAX_TIMER);
/* Initialzie the timer queue */
- cmMemset((U8 *)&rgCb[inst].tmrTq, 0, sizeof(CmTqType)*RG_TQ_SIZE);
+ memset(&rgCb[inst].tmrTq, 0, sizeof(CmTqType)*RG_TQ_SIZE);
/* Initialize the timer control point */
- cmMemset((U8 *)&rgCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
+ memset(&rgCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
rgCb[inst].tmrTqCp.tmrLen = RG_TQ_SIZE;
#if 0
/* Timer Registration request to SSI */
RgCellCb *cell = rgCb[inst].cell;
U8 idx;
- TRC2(rgLMMShutdown)
/* Unbind the TFU Sap */
if(rgCb[inst].tfuSap.sapSta.sapState == LRG_WAIT_BNDCFM)
#endif
{
Inst inst = (cfmPst->srcInst - RG_INST_START);
- TRC2(rgLMMGenCntrl)
cfm->cfm.status = LCM_PRIM_OK;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
rgCb[inst].rgInit.trc = TRUE;
rgCb[inst].trcLen = cntrl->t.cntrl.s.trcLen;
/*Store the response and TransId for sending the Traces */
- cmMemcpy((U8 *)&rgCb[inst].genCfg.trcResp.response,
- (U8 *)&cntrl->hdr.response, sizeof(Resp));
+ memcpy(&rgCb[inst].genCfg.trcResp.response,
+ &cntrl->hdr.response, sizeof(Resp));
rgCb[inst].genCfg.trcResp.transId = cntrl->hdr.transId;
break;
/* Enable Unsolicited Status (alarms) */
rgCb[inst].rgInit.usta = TRUE;
/*Store the response and TransId for sending the Alarms */
- cmMemcpy((U8 *)&rgCb[inst].genCfg.ustaResp.response,
- (U8 *)&cntrl->hdr.response, sizeof(Resp));
+ memcpy(&rgCb[inst].genCfg.ustaResp.response,
+ &cntrl->hdr.response, sizeof(Resp));
rgCb[inst].genCfg.ustaResp.transId = cntrl->hdr.transId;
break;
case SADBG:
#endif
{
Inst inst = cfmPst->srcInst - RG_INST_START;
- TRC2(rgLMMSapCntrl)
/* Only TFU Sap can be controlled by LM */
switch(cntrl->hdr.elmId.elmnt)
rgCb[inst].tfuSap.numBndRetries++;
/* Store the response and TransId for sending
* the Control confirm */
- cmMemcpy((U8 *)&rgCb[inst].genCfg.bndCfmResp.response,
- (U8 *)&cntrl->hdr.response, sizeof(Resp));
+ memcpy(&rgCb[inst].genCfg.bndCfmResp.response,
+ &cntrl->hdr.response, sizeof(Resp));
rgCb[inst].genCfg.bndCfmResp.transId = cntrl->hdr.transId;
/* Sending Status Indication to Layer Manager */
rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
}
}
- cmMemset((U8 *)&rgCb[inst].tfuSap, 0, sizeof(RgLowSapCb));
+ memset(&rgCb[inst].tfuSap, 0, sizeof(RgLowSapCb));
rgCb[inst].tfuSap.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 *)&rgCb[inst].rguSap[cntrl->t.cntrl.instId], 0, sizeof(RgUpSapCb));
+ memset(&rgCb[inst].rguSap[cntrl->t.cntrl.instId], 0, sizeof(RgUpSapCb));
rgCb[inst].rguSap[cntrl->t.cntrl.instId].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 *)&rgCb[inst].crgSap, 0, sizeof(RgUpSapCb));
+ memset(&rgCb[inst].crgSap, 0, sizeof(RgUpSapCb));
rgCb[inst].crgSap.sapSta.sapState = LRG_NOT_CFG;
cfm->cfm.status = LCM_PRIM_OK;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
#endif
{
Inst inst;
- TRC2(rgLMMFillCfmPst)
inst = (reqPst->dstInst - RG_INST_START);
cfmPst->srcEnt = rgCb[inst].rgInit.ent;
{
CmTmrArg arg;
- TRC2(rgLMMStartTmr)
UNUSED(tmrEvnt);
/* Initialize the arg structure */
- cmMemset((U8 *)&arg, 0, sizeof(CmTmrArg));
+ memset(&arg, 0, sizeof(CmTmrArg));
arg.tqCp = &rgCb[inst].tmrTqCp;
arg.tq = rgCb[inst].tmrTq;
U8 i;
S16 ret;
- TRC2(rgLMMStopTmr)
ret = RFAILED;
if(rgCb[inst].tmrBlk[i].tmrEvnt == tmrEvnt)
{
/* Initialize the arg structure */
- cmMemset((U8 *)&arg, 0, sizeof(CmTmrArg));
+ memset(&arg, 0, sizeof(CmTmrArg));
arg.tqCp = &rgCb[inst].tmrTqCp;
arg.tq = rgCb[inst].tmrTq;
RgLowSapCb *tfuSap = (RgLowSapCb *)cb;
Inst inst = tfuSap->sapCfg.sapPst.srcInst - RG_INST_START;
- TRC2(rgLMMTmrExpiry)
-
-
switch(tmrEvnt)
{
case RG_BNDREQ_TMR:
{
RgMngmt usta;
- TRC2(rgLMMStaInd)
if(rgCb[inst].rgInit.usta == FALSE)
{
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));
}
rgCb[inst].rgInit.lmPst.selector = rgCb[inst].genCfg.ustaResp.response.selector;
RgMngmt trc;
Pst pst;
- TRC2(rgLMMTrcInd)
if ((rgCb[inst].trcLen == LRG_NO_TRACE) || (srcMbuf == NULLP))
RETVOID;
}
- cmMemset((U8 *)&trc, 0, sizeof(RgMngmt));
+ memset(&trc, 0, sizeof(RgMngmt));
pst = rgCb[inst].rgInit.lmPst;
pst.selector = rgCb[inst].genCfg.trcResp.response.selector;
RgMngmt cntrlCfm;
Pst cfmPst;
- TRC3(rgLMMBndCfm)
UNUSED(pst);
cfmPst.region = rgCb[inst].genCfg.bndCfmResp.response.mem.region;
cfmPst.pool = rgCb[inst].genCfg.bndCfmResp.response.mem.pool;
- cmMemset((U8 *)&cntrlCfm, 0, sizeof(RgMngmt));
+ memset(&cntrlCfm, 0, sizeof(RgMngmt));
switch(status)
{
#endif
{
Inst macInst = (inst - RG_INST_START);
- TRC3(rgActvTmr)
/* Check if any MAC timer has expired */
cmPrcTmr(&rgCb[macInst].tmrTqCp, rgCb[macInst].tmrTq, (PFV) rgLMMTmrExpiry);
S16 ret;
RgMUXSubHdr subHdr;
- TRC2(rgMUXAddCes)
-
if (NULLP != pdu->contResId)
{
if(pdu->schdTbSz >= RG_CRES_ELM_LEN)
U8 lenBytes;
MsgLen elmTotLen;
- TRC2(rgMUXInsSdu)
SFndLenMsg(sdu, &msgLen);
RG_MUX_CALC_LEN(msgLen,lenBytes,elmTotLen);
S16 ret = ROK;
Buffer *padBuf = NULLP;
RgMUXSubHdr subHdr;
- TRC2(rgMUXAddPadd)
#ifdef L2_OPTMZ
padSize = 0;
RgRguDDatReqPerUe *dDatReq;
RgRguCmnDatReq *cDatReq;
- TRC2(rgMUXAddSdus)
-
switch(pdu->reqType)
{
case EVTRGUCDATREQ:
{
Buffer *mBuf = NULLP;
- TRC2(rgMUXBldPdu)
-
-
if (rgGetMsg(inst, &mBuf) != ROK)
{
/* Buffer couldnt get allocated. Return a failure */
RgRguCmnDatReq *cDatReq;
U32 lchIdx, pduIdx;
- TRC2(rgMUXAddSdus)
-
switch(pdu->reqType)
{
case EVTRGUCDATREQ:
Buffer *mBuf2; /* MAC CEs */
//U32 lchIdx, pduIdx;
- TRC2(rgMUXBldPdu)
-
/* Reseting macHdr and macCes pointers */
if(tb->macHdr)
SResetMBuf(tb->macHdr);
U8 idx;
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgMUXBldRarPdu)
-
schdTbSz = alloc->schdTbSz;
/* RAR PDU Requirements */
/*
{
U16 riv = rgMUXCalcRiv(ulBw, msg3Grnt->rbStart, msg3Grnt->numRb);
- TRC2(rgMUXGet20bitRarGrnt);
-
grnt[2] = msg3Grnt->cqiBit; /* cqi bit is 0, output from sched */
grnt[2] |= (msg3Grnt->delayBit << 1);
grnt[2] |= (msg3Grnt->tpc << 2);
U8 numRbMinus1 = numRb - 1;
U16 riv;
- TRC2(rgMUXCalcRiv);
-
if (numRbMinus1 <= bw/2)
{
riv = bw * numRbMinus1 + rbStart;
RgUeCb *ue;
RgUlLcCb *ulLc;
- TRC2(RgPrgPMacSMacUeSCellLchModReq);
-
RGDBGPRM(inst,(rgPBuf(inst),
"APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d lcId %d lcgId %d\n",
lchCfgCb->cellId, lchCfgCb->crnti,lchCfgCb->lcId,lchCfgCb->ulLchRecfg.lcgId));
RgCellCb *cell;
RgUeCb *ue;
- TRC2(rgPomSndUeSCellLchDelToSmac);
-
/* Fetch the Active cell */
if(((cell = rgCb[inst].cell) == NULLP) ||
(cell->cellId != lcDel->u.lchDel.cellId))
RgPrgUeSCellLchModInfo lchCfgCb;
Pst dstInstPst;
- TRC2(rgPomSndUeSCellLchModToSmac);
-
for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
{
if(TRUE == ue->sCelInfo[idx].isSCellAdded)
RgPrgUeSCellLchAddInfo lchCfgCb;
Pst dstInstPst;
- TRC2(rgPomSndUeSCellLchAddToSmac);
-
for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
{
if(TRUE == ue->sCelInfo[idx].isSCellAdded)
RgUlLcCb *ulLc;
RgDlLcCb *dlLc;
- TRC2(RgPrgPMacSMacUeSCellLchDelReq);
-
RGDBGPRM(inst,(rgPBuf(inst),
"APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d\n",
lchCfgCb->cellId, lchCfgCb->crnti));
Pst cfmPst;
RgUeCb *ue;
- TRC2(RgPrgPMacSMacUeSCellLchAddReq);
-
RGDBGPRM(inst,(rgPBuf(inst),
"APPLYING UE SCELL CONFIG AT SMAC : cellId %d ueId %d\n",
lchCfgCb->cellId, lchCfgCb->crnti));
#endif
{
- TRC2(rgPomVldtAddLch);
RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC CONFIG: cellId %d ueId %d lcId %d\
cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti, lcCfg->lcId,
(void*)*cell, (void*)*ue));
#endif
{
- TRC2(rgPomUeSCellLcAdd);
RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC CONFIG: cellId %d ueId %d\
lcId %d dir %d cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti,
lcCfg->lcId, lcCfg->dir, (void*)cell, (void*)ue));
RgUeCb **ue;
#endif
{
- TRC2(rgPomVldtSCellDedLchCfg);
RGDBGPRM(inst,(rgPBuf(inst), "VALIDATING CRG DEDICATED LC CONFIG \n"));
#endif
{
//Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgPomUeSCellDedLcCfg);
//RGDBGPRM(inst,(rgPBuf(inst), "APPLYING DEDICATED LC CONFIG\n"));
/* Uplink/Bi-directional logical channel */
RgUlLcCb **ulLc;
#endif
{
- TRC2(rgPomVltdModLch);
RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
lcId %d cell %p ue %p ulLc %p\n",lchCfgCb->cellId,
lchCfgCb->crnti,lchCfgCb->lcId, (void*)*cell, (void*)*ue,
RgPrgUeSCellLchModInfo *lchCfgCb;
#endif
{
- TRC2(rgPomUeSCellLcMod);
RGDBGPRM(inst,(rgPBuf(inst), "APPLYING SMAC LC RECONFIG: cellId %d ueId %d\
lcId %d \n",
lchCfgCb->cellId, lchCfgCb->crnti, lchCfgCb->lcId));
RgDlLcCb **dlLc;
#endif
{
- TRC2(rgPomVltdDelLch);
RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
lcId %d cell %p ue %p ulLc %p\n",delLcCb->cellId,
delLcCb->crnti,delLcCb->lcId, (void*)*cell, (void*)*ue,
#endif
{
- TRC2(rgPomUeSCellLcDel);
RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC DELETE: cellId %d ueId %d\
lcId %d dir %d\n", delLcCb->cellId,
delLcCb->crnti, delLcCb->lcId,
{
Buffer *mBuf = NULLP;
- TRC2(cmPkPrgPMacSMacUeSCellCfgReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
{
RgPrgUeSCellCfgInfo ueSCellCfgInfo;
- TRC2(cmUnpkPrgPMacSMacUeSCellCfgReq)
-
if(SRemPreMsgMult((Data *)&ueSCellCfgInfo, sizeof(RgPrgUeSCellCfgInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkPrgSMacPMacCfgCfm)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
{
RgPrgCfgCfmInfo cfgCfm;
- TRC2(cmUnpkPrgSMacPMacCfgCfm)
-
if(SRemPreMsgMult((Data *)&cfgCfm, sizeof(RgPrgCfgCfmInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkPrgPMacSMacUeSCellDelReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
{
RgPrgUeSCellDelInfo ueSCellDelInfo;
- TRC2(cmUnpkPrgPMacSMacUeSCellDelReq)
-
if(SRemPreMsgMult((Data *)&ueSCellDelInfo, sizeof(RgPrgUeSCellDelInfo),\
mBuf) != ROK)
{
{
Buffer *mBuf = NULLP;
- TRC2(cmPkPrgPMacSMacUeSCellLchAddReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
{
RgPrgLchRecfgInfo lchCfgInfo;
- TRC2(cmUnpkPrgPMacSMacUeSCellLchAddReq)
-
if(SRemPreMsgMult((Data *)&lchCfgInfo, sizeof(RgPrgUeSCellLchAddInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkPrgPMacSMacUeSCellLchDelReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
{
Buffer *mBuf = NULLP;
- TRC2(cmPkPrgPMacSMacUeSCellLchModReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
{
RgPrgUeSCellLchModInfo lchCfgInfo;
- TRC2(cmUnpkPrgPMacSMacAddLchCfgReq)
-
if(SRemPreMsgMult((Data *)&lchCfgInfo, sizeof(RgPrgUeSCellLchModInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
{
RgPrgUeSCellLchDelInfo lchCfgInfo;
- TRC2(cmUnpkPrgPMacSMacUeSCellLchDelReq)
-
if(SRemPreMsgMult((Data *)&lchCfgInfo, sizeof(RgPrgUeSCellLchDelInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
#endif
{
- TRC3(RgPrgPMacSMacUeSCellCfg);
-
return ((*RgPrgPMacSMacUeSCellCfgReqMt[0])(pst, ueSCellCfgInfo));
}
#endif
{
- TRC3(RgPrgSMacPMacCfg);
-
return ((*RgPrgSMacPMacCfgCfmMt[0])(pst, cfgCfm));
}
#endif
{
- TRC3(RgPrgPMacSMacUeSCellDel);
-
return ((*RgPrgPMacSMacUeSCellDelReqMt[0])(pst, ueSCellDelInfo));
}
#endif
{
- TRC3(RgPrgPMacSMacUeScellLchMod);
-
return ((*RgPrgPMacSMacUeScellModLchReqMt[0])(pst, lchCfgInfo));
}
#endif
{
- TRC3(RgPrgPMacSMacUeScellLchDel);
-
return ((*RgPrgPMacSMacUeScellDelLchReqMt[0])(pst, delLcCb));
}
#endif
{
- TRC3(RgPrgPMacSMacUeScellLchAdd);
-
return ((*RgPrgPMacSMacUeScellAddLchReqMt[0])(pst, lchCfgInfo));
}
#endif
{
- TRC3(RgLiTfuBndReq)
-
return ((*RgLiTfuBndReqMt[pst->selector])(pst, suId, spId));
}
#endif
{
- TRC3(RgLiTfuSchBndReq)
-
return ((*RgLiTfuSchBndReqMt[pst->selector])(pst, suId, spId));
}
#endif
{
- TRC3(RgLiTfuUbndReq)
-
return ((*RgLiTfuUbndReqMt[pst->selector])(pst, spId, reason));
}
#endif
{
- TRC3(RgLiTfuSchUbndReq)
-
return ((*RgLiTfuSchUbndReqMt[pst->selector])(pst, spId, reason));
}
#endif
{
- TRC3(RgLiTfuRecpReq)
-
return ((*RgLiTfuRecpReqMt[pst->selector])(pst, spId, recpReq));
}
#endif
{
- TRC3(RgLiTfuCntrlReq)
-
return ((*RgLiTfuCntrlReqMt[pst->selector])(pst, spId, cntrlReq));
}
#endif
{
- TRC3(RgLiTfuDatReq)
-
return ((*RgLiTfuDatReqMt[pst->selector])(pst, spId, datReq));
}
#endif
{
- TRC3(RgLiTfuDelDatReq)
-
return ((*RgLiTfuDelDatReqMt[pst->selector])(pst, spId, delDatReq));
}
#endif
{
- TRC3(PtLiTfuBndReq)
UNUSED(pst);
UNUSED(suId);
#endif
{
- TRC3(PtLiTfuSchBndReq)
-
UNUSED(pst);
UNUSED(suId);
UNUSED(spId);
#endif
{
- TRC3(PtLiTfuUbndReq)
-
UNUSED(pst);
UNUSED(spId);
UNUSED(reason);
#endif
{
- TRC3(PtLiTfuSchUbndReq)
-
UNUSED(pst);
UNUSED(spId);
UNUSED(reason);
#endif
{
- TRC3(PtLiTfuRecpReq)
-
UNUSED(pst);
UNUSED(spId);
UNUSED(recpReq);
#endif
{
- TRC3(PtLiTfuCntrlReq)
-
UNUSED(pst);
UNUSED(spId);
UNUSED(cntrlReq);
#endif
{
- TRC3(PtLiTfuDatReq)
-
UNUSED(pst);
UNUSED(spId);
UNUSED(datReq);
#endif
{
- TRC3(PtLiTfuDelDatReq)
-
UNUSED(pst);
UNUSED(spId);
UNUSED(delDatReq);
#endif
{
- TRC3(RgMiLrgCfgCfm);
-
(*RgMiLrgCfgCfmMt[pst->selector])(pst, cfm);
return ROK;
#endif
{
- TRC3(RgMiLrgSchCfgCfm);
-
(*RgMiLrgSchCfgCfmMt[pst->selector])(pst, cfm);
return ROK;
#endif
{
- TRC3(RgMiLrgStsCfm);
-
(*RgMiLrgStsCfmMt[pst->selector])(pst, cfm);
return ROK;
#endif
{
- TRC3(RgMiLrgStaCfm);
-
(*RgMiLrgStaCfmMt[pst->selector])(pst,cfm);
return ROK;
#endif
{
- TRC3(RgMiLrgCntrlCfm);
-
(*RgMiLrgCntrlCfmMt[pst->selector])(pst,cfm);
return ROK;
#endif
{
- TRC3(RgMiLrgSchCntrlCfm);
-
(*RgMiLrgSchCntrlCfmMt[pst->selector])(pst,cfm);
return ROK;
#endif
{
- TRC3(RgMiLrgStaInd);
-
(*RgMiLrgStaIndMt[pst->selector])(pst,usta);
return ROK;
#endif
{
- TRC3(RgMiLrgSchStaInd);
-
(*RgMiLrgSchStaIndMt[pst->selector])(pst,usta);
return ROK;
#endif
{
- TRC3(RgMiLrgTrcInd);
-
(*RgMiLrgTrcIndMt[pst->selector])(pst,trc,mBuf);
return ROK;
LrgSchMeasCfmInfo *cfm; /* Meas Cfm Info */
#endif
{
- TRC3(RgMiLrgSchL2MeasCfm)
(*RgMiLrgSchL2mMeasCfmMt[pst->selector])(pst,cfm);
LrgSchMeasCfmInfo *cfm; /* Meas Cfm Info */
#endif
{
- TRC3(RgMiLrgSchL2MeasStopCfm)
-
(*RgMiLrgSchL2mMeasStopCfmMt[pst->selector])(pst,cfm);
return ROK;
RgMngmt *cfm; /* Config Confirm */
#endif
{
- TRC3(PtMiLrgCfgCfm)
-
return ROK;
}/* end of PtMiLrgCfgCfm */
RgMngmt *cfm; /* Config Confirm */
#endif
{
- TRC3(PtMiLrgSchCfgCfm)
return ROK;
}/* end of PtMiLrgSchCfgCfm */
RgMngmt *cfm; /* Statistics Confirm */
#endif
{
- TRC3(PtMiLrgStsCfm)
return ROK;
}/* end of PtMiLrgStsCfm */
RgMngmt *cfm; /* Status Confirm */
#endif
{
- TRC3(PtMiLrgStaCfm)
return ROK;
}/* end of PtMiLrgStaCfm */
RgMngmt *usta; /* Status indication */
#endif
{
- TRC3(PtMiLrgStaInd)
return ROK;
}/* end of PtMiLrgStaInd */
RgMngmt *usta; /* Status indication */
#endif
{
- TRC3(PtMiLrgSchStaInd)
return ROK;
}/* end of PtMiLrgSchStaInd */
RgMngmt *cfm; /* Control Confirm */
#endif
{
- TRC3(PtMiLrgCntrlCfm)
return ROK;
}/* end of PtMiLrgCntrlCfm */
RgMngmt *cfm; /* Control Confirm */
#endif
{
- TRC3(PtMiLrgSchCntrlCfm)
return ROK;
}/* end of PtMiLrgSchCntrlCfm */
Buffer *mBuf; /* Trace message */
#endif
{
- TRC3(PtMiLrgTrcInd)
return ROK;
}/* end of PtMiLrgTrcInd */
#ifdef LTE_L2_MEAS
LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
#endif
{
- TRC3(PtMiLrgSchL2MeasCfm)
return ROK;
}/* end of PtMiLrgSchL2MeasCfm */
LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
#endif
{
- TRC3(PtMiLrgSchL2MeasStopCfm)
return ROK;
}/* end of PtMiLrgSchL2MeasStopCfm */
#endif
{
- TRC3(RgUiRgrBndCfm);
-
return ((*RgUiRgrBndCfmMt[pst->selector])(pst, suId, status));
}
#endif
{
- TRC3(RgUiRgmBndCfm);
-
return ((*RgUiRgmBndCfmMt[pst->selector])(pst, suId, status));
}
#endif
{
- TRC3(RgUiRgrTtiInd);
-
return ((*RgUiRgrTtiIndMt[pst->selector])(pst, suId, ttiInd));
}
#endif
{
- TRC3(RgUiRgrCfgCfm);
-
return ((*RgUiRgrCfgCfmMt[pst->selector])(pst, transId, status));
}
#endif
{
- TRC3(RgUiCrgBndCfm);
-
return ((*RgUiCrgBndCfmMt[pst->selector])(pst, suId, status));
}
#endif
{
- TRC3(RgUiCrgCfgCfm);
-
return ((*RgUiCrgCfgCfmMt[pst->selector])(pst, suId, transId, status));
}
#endif
{
- TRC3(RgUiRguBndCfm);
-
return ((*RgUiRguBndCfmMt[pst->selector])(pst, suId, status));
}
{
macCDatIndSnt++;
- TRC3(RgUiRguCDatInd);
-
return ((*RgUiRguCDatIndMt[pst->selector])(pst, suId, datInd));
}
{
macDDatIndSnt++;
- TRC3(RgUiRguDDatInd);
-
#if defined(MAC_RLC_UL_RBUF) && !defined(SS_RBUF)
return (RgUiRguDDatIndRbuf(datInd));
#else
#endif
{
- TRC3(RgUiRguCStaInd);
-
return ((*RgUiRguCStaIndMt[pst->selector])(pst, suId, staInd));
}
#endif
{
- TRC3(RgUiRguDStaInd);
-
return ((*RgUiRguDStaIndMt[pst->selector])(pst, suId, staInd));
}
#endif
{
- TRC3(RgUiRguHqStaInd);
#if defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF)
S16 ret=ROK;
ret = RgUiRguHqStaIndRbuf(pst,suId,harqStatusInd);
#endif
{
- TRC3(RgUiRgrSiCfgCfm);
-
return ((*RgUiRgrSiCfgCfmMt[pst->selector])(pst, suId, transId, status));
}
U8 status;
#endif
{
- TRC3(RgUiRgrWarningSiCfgCfm);
-
return ((*RgUiRgrWarningSiCfgCfmMt[pst->selector])
(pst, suId, transId, siId, status));
}
#endif
{
- TRC3(RgUiRgrStaInd);
-
return ((*RgUiRgrStaIndMt[pst->selector])(pst, suId, staInd));
}
#endif
{
- TRC3(RgUiRgrLoadInfInd);
-
return ((*RgUiRgrLoadInfIndMt[pst->selector])(pst, suId, loadInfInd));
}
#endif
{
- TRC3(RgUiRgrUeStaInd);
-
return ((*RgUiRgrUeStaIndMt[pst->selector])(pst, suId, ueStaInd));
}
#endif
{
- TRC3(PtUiCrgBndCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(status);
#endif
{
- TRC3(PtUiCrgCfgCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(transId);
#endif
{
- TRC3(PtUiRguBndCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(status);
#endif
{
- TRC3(PtUiRguCDatInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(datInd);
#endif
{
- TRC3(PtUiRguDDatInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(datInd);
#endif
{
- TRC3(PtUiRguCStaInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(staInd);
#endif
{
- TRC3(PtUiRguDStaInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(staInd);
#endif
{
- TRC3(PtUiRguHqStaInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(harqStatusInd);
#endif
{
- TRC3(PtUiRguFlowCntrlInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(flowCntrlInd);
#endif
{
- TRC3(PtUiRgrBndCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(status);
#endif
{
- TRC3(PtUiRgrTtiInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(ttiInd);
#endif
{
- TRC3(PtUiRgrCfgCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(transId);
#endif
{
- TRC3(PtUiRgrSiCfgCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(transId);
U8 status;
#endif
{
- TRC3(PtUiRgrWarningSiCfgCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(transId);
#endif
{
- TRC3(PtUiRgrStaInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(staInd);
#endif
{
- TRC3(PtUiRgrLoadInfInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(loadInfInd);
#endif
{
- TRC3(PtUiRgrUeStaInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(ueStaInd);
#endif
{
- TRC3(PtUiRgmBndCfm);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(status);
#endif
{
- TRC3(PtUiRgmPrbRprtInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(prbRprtInd);
#endif
{
- TRC3(PtUiRgmTransModeInd);
-
UNUSED(pst);
UNUSED(suId);
UNUSED(transModeInd);
#endif
{
- TRC2(RgUiRgmSendPrbRprtInd);
return ((*RgUiRgmSendPrbRprtIndMt[pst->selector])(pst, suId, prbRprtInd));
}
#endif
{
- TRC2(RgUiRgmChangeTransModeInd);
return ((*RgUiRgmChangeTransModeIndMt[pst->selector])(pst, suId, transModeInd));
}
}
else
{
- cmMemcpy((U8 *)&(harqStaInd->hqStatusInd), (U8 *)harqStatusInd, sizeof(RguHarqStatusInd));
- cmMemcpy((U8 *)&(harqStaInd->pst), (U8 *)pst, sizeof(Pst));
+ memcpy(&(harqStaInd->hqStatusInd), harqStatusInd, sizeof(RguHarqStatusInd));
+ memcpy(&(harqStaInd->pst), pst, sizeof(Pst));
SRngIncrWIndx(SS_RNG_BUF_MAC_HARQ);
SsRngInfoTbl[SS_RNG_BUF_MAC_HARQ].pktRate++;
}
RgUeCb *ue;
#endif
{
- TRC2(rgRAMFreeUeCb);
-
rgDHMFreeUe(inst,&ue->dl.hqEnt);
/*ccpu00117052 - MOD - Passing double pointer for proper NULLP
Inst inst = cell->macInst - RG_INST_START;
RgUeCb *ueCb = NULLP;
- TRC2(rgRAMCreateUeCb)
-
RLOG_ARG1(L_INFO,DBG_CELLID,cell->cellId,"CREATE UECB FOR CRNTI:%d",
tmpCrnti);
/* Allocate the Ue control block */
Inst inst = cell->macInst - RG_INST_START;
RgUeCb *ueCb;
- TRC2(rgRAMFreeCell);
-
/* Free CURRENT CRG cfg list */
while ((ueCb = rgDBMGetNextUeCbFromRachLst(cell, NULLP)) != NULLP)
{
RgDlSf *dlSf;
U8 idx;
- TRC2(rgHndlRaResp)
-
if(NULLP == rarInfo->raRntiInfo)
{
return RFAILED;
U32 idx;
//U8 datReqFailCnt = 0;
- TRC2(rgROMDedDatReq)
-
if (((cell = rgCb[inst].cell) == NULLP)
|| (cell->cellId != datReq->cellId))
RgDlSf *sf;
#endif
- TRC2(rgROMCmnDatReq)
-
ret = ROK;
err.errType = RGERR_ROM_CMNDATREQ;
if(((cell = rgCb[inst].cell) == NULLP)
RgUstaDgn dgn; /* Alarm diagnostics structure */
#endif
- TRC2(rgROMHndlCcchDatReq);
-
-
err->errType = RGERR_ROM_CMNDATREQ;
if ((ue = rgDBMGetUeCb(cell, datReq->u.rnti)) == NULLP)
RgUstaDgn dgn; /* Alarm diagnostics structure */
#endif
- TRC2(rgROMHndlBcchPcchDatReq);
-
-
timingInfo.slot = (U8)(datReq->transId & 0XFF);
timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
/* Moving the error variables and assignments to available scope */
- TRC2(rgROMDedStaRsp)
-
/* Avoiding memset, as the variables of this are getting
initialized */
RgCellCb *cell;
RgErrInfo err;
- TRC2(rgROMCmnStaRsp)
-
-
if(((cell = rgCb[inst].cell) == NULLP)
|| (cell->cellId != staRsp->cellId))
{
RgUeCb *ue;
U8 lcgId;
U8 loop;
- TRC2(rgROML2MUlThrpMeasReq)
-
-
if(((cell = rgCb[inst].cell) != NULLP)
&&(cell->cellId == measReq->cellId))
Inst macInst = cell->macInst - RG_INST_START;
//RgInfCmnBoRpt boRpt;
- TRC2(rgROMHndlCcchStaRsp);
#ifdef UNUSED_VAR
RgInfCmnBoRpt boRpt;
boRpt.cellSapId = cell->schInstMap.cellSapId;
//RgInfCmnBoRpt boRpt;
Inst macInst = cell->macInst - RG_INST_START;
- TRC2(rgROMHndlBcchPcchStaRsp);
- cmMemset((U8*)&schPst, (U8)0, sizeof(Pst));
+ memset(&schPst, 0, sizeof(Pst));
if (rgDBMChkCmnLcCb(cell, staRsp->lcId) != ROK)
{
RgErrInfo err;
//Inst inst = cellCb->macInst - RG_INST_START;
- TRC2(rgROMUpdDlSfRemDataCnt);
-
-
if(!dlSf->remDatReqCnt)
{
/*This is an error scenario of RLC generating more data
U8 idx;
Inst inst = cellCb->macInst - RG_INST_START;
- TRC2(rgTOMUtlFillDatReqPdus)
/* first lets send the BCCH data down to PHY */
if (dlSf->bcch.tb != NULLP)
TfuDatReqInfo *datInfo;
Inst inst = cellCb->macInst - RG_INST_START;
- TRC2(rgTOMUtlProcDlSf);
/* Fill Data Request Info from scheduler to PHY */
if ((ret = rgAllocEventMem(inst,(Ptr *)&datInfo,
RgUstaDgn dgn; /* Alarm diagnostics structure */
VOLATILE U32 startTime=0;
- TRC2(rgTOMUtlAllocPduEvnt);
evntMem.region = rgCb[inst].rgInit.region;
evntMem.pool = rgCb[inst].rgInit.pool;
RgMacSdu *sdu;
CmLList *node;
- TRC2(rgTOMUtlFreePduEvnt);
/* Steps of freeing up the PDU.
* 1. loop through the subHdrLst and free up all the buffers.
* 2. free up the whole event
RgUstaDgn dgn; /* Alarm diagnostics structure */
VOLATILE U32 startTime=0;
- TRC2(rgTOMInfAllocPduEvnt);
evntMem.region = rgCb[inst].rgInit.region;
evntMem.pool = rgCb[inst].rgInit.pool;
RgInfSfDatInd *sfInfo;
#endif
{
- TRC2(rgTOMInfFreePduEvnt);
RG_FREE_MEM(sfInfo);
RETVOID;
U8 lcId;
U8 lcgId;
U8 loop;
- TRC2(rgTomUtlPrepareL2MUlThrpInfo);
dDatInd->burstInd = RGU_L2M_UL_BURST_END;
for(loop=0;loop<dDatInd->numLch;loop++)
ulLcCb = NULLP;
- TRC2(rgTOMUtlProcMsg)
#ifndef LTE_L2_MEAS
UNUSED(slot);
return RFAILED;
}
dDatInd = (RgRguDedDatInd *)elem;
- cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
+ memset(dDatInd, 0x00, sizeof(RgRguDedDatInd));
#endif
dDatInd->cellId = cellCb->cellId;
dDatInd->rnti = ueCb->ueId;
return RFAILED;
}
dDatInd = (RgRguDedDatInd *)elem;
- cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
+ memset(dDatInd, 0x00, sizeof(RgRguDedDatInd));
#endif
dDatInd->cellId = cellCb->cellId;
dDatInd->rnti = ueCb->ueId;
{
ueCb->ul.explRelCntr = 0;
/* Indicate scheduler for explicit release */
- cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
+ memset(&schPst1, 0, sizeof(Pst));
rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
//TODO: commented for compilation without SCH
#if 0
U32 lcgId = 0;
U32 idx = 0;
- TRC2(rgTOMUtlInsSchInfo);
RG_TOM_INF_ALLOC(sfInfo, sizeof(RgInfUeDatInd), ueInfo, ret);
U32 lcgBytes[RGINF_MAX_LCG_PER_UE];
- TRC2(rgTOMDatInd);
#ifdef STUB_TTI_HANDLING_5GTF
node = datInd->datIndLst.first;
for (;node; node=node->next)
return(RFAILED);
#endif
- cmMemset((U8 *)&lcgBytes, 0, sizeof(lcgBytes));
+ memset(&lcgBytes, 0, sizeof(lcgBytes));
tfuSap = &(rgCb[inst].tfuSap);
ueCb = NULLP;
if (ueCb->ul.implRelCntr == ueCb->ul.implRelCnt)
{
/* Indicate scheduler for implicit release */
- cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
+ memset(&schPst1, 0, sizeof(Pst));
rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
ueCb->ul.implRelCntr = 0;
#endif
/* RRM_RBC_X */
/* Update PRB used for all GBR QCIs to scheduler */
- cmMemcpy((U8*) &sfInfo->qcisUlPrbCnt[0],
- (U8*) &cellCb->qcisUlPrbCnt[0],
+ memcpy( &sfInfo->qcisUlPrbCnt[0],
+ &cellCb->qcisUlPrbCnt[0],
(RGM_MAX_QCI_REPORTS * sizeof(U32)));
/* clear the cellCb ul prb value */
- cmMemset((U8*)&cellCb->qcisUlPrbCnt[0], 0,
+ memset(&cellCb->qcisUlPrbCnt[0], 0,
(RGM_MAX_QCI_REPORTS * sizeof(U32)));
/* RRM_RBC_Y */
RgDlSf *dlSf;
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgHndlCmnChnl)
dlSf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
#endif
{
- TRC2(rgHndlSchdUe);
if(NULLP == ueInfo->allocInfo)
{
RgUlSf *ulSf;
S16 ret;
- TRC2(rgHndlUlUeInfo)
ulSf = &cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)];
{
U8 idx;
- TRC2(rgTOMRlsSf)
if(dlSf->txDone == FALSE)
{
Pst *pst;
U32 ueIdx;
U32 lcIdx;
- TRC3(rgHndlFlowCntrl);
pst = &cell->rguDlSap->sapCfg.sapPst;
/* flowCntrlInd is alloced in cell init time and will be re-used throughout */
VOLATILE U32 startTime=0;
Inst inst;
- TRC2(RgSchMacSfAllocReq)
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
U16 sduSize;
#endif
- TRC2(rgTOMProcCrntiCEInDatInd)
#ifndef LTE_L2_MEAS
UNUSED(slot);
#endif
- TRC2(rgTOMProcCCCHSduInDatInd)
#ifndef LTE_L2_MEAS
UNUSED(slot);
{
U8 lcgId;
U8 bsr;
- TRC2(rgTOMUtlL2MStoreBufSz);
if(ceInfo->bitMask & RG_TRUNC_BSR_CE_PRSNT)
{
RgMacSdu *sdu;
RgUlLcCb *ulLcCb;
- TRC2(rgTOML2MCompileActiveLCs)
node = pdu->sduLst.first;
while (node)
CrgUeCfg *ueCfg;
#endif
{
- TRC2(rgUHMCrgUeCfg);
-
ueCb->ul.hqEnt.maxHqRetx = (ueCfg->ueUlHqCfg.maxUlHqTx - 1);
RETVOID;
} /* rgUHMCrgUeCfg */
CrgUeRecfg *ueRecfg;
#endif
{
- TRC2(rgUHMCrgUeRecfg);
ueCb->ul.hqEnt.maxHqRetx = (ueRecfg->ueUlHqRecfg.maxUlHqTx - 1);
RETVOID;
Pst tmpPst; /* Temporary Post Structure */
RgUstaDgn dgn; /* Alarm diagnostics structure */
- TRC3(RgUiRguBndReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
#endif
{
Inst inst;
- TRC3(RgUiRguUbndReq)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
{
S16 ret = ROK;
- TRC2(rgUIMRguBndCfm)
-
-
ret = RgUiRguBndCfm(&rgCb[inst].rguSap[spId].sapCfg.sapPst,
rgCb[inst].rguSap[spId].sapCfg.suId, status);
if (ret != ROK)
U32 id3;
#endif
- TRC3(RgUiRguDDatReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
#ifndef NO_ERRCLS
Inst inst;
S16 ret = ROK;
- TRC3(RgUiRguCDatReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
#ifndef NO_ERRCLS
S16 ret = ROK;
VOLATILE U32 startTime = 0;
- TRC3(RgUiRguDStaRsp)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
/*starting Task*/
Inst inst;
S16 ret = ROK;
- TRC3(RgUiRguCStaRsp)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
#ifndef NO_ERRCLS
S16 ret = ROK;
- TRC3(RgUiRguL2MUlThrpMeasReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
#ifndef NO_ERRCLS
{
S16 ret = ROK;
- TRC2(rgUIMSndDedStaInd)
-
RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndDedStaInd(): staInd = %p;\n", (void *)staInd));
ret = RgUiRguDStaInd(&(rguSap->sapCfg.sapPst), rguSap->sapCfg.suId,
{
S16 ret = ROK;
-
- TRC2(rgUIMSndCmnStaInd)
-
-
ret = RgUiRguCStaInd(&(rguDlSap->sapCfg.sapPst), rguDlSap->sapCfg.suId,
staInd);
if (ret != ROK)
{
S16 ret = ROK;
-
- TRC2(rgUIMSndDedDatInd)
-
-
rguUlSap->sapSts.numPduTxmit += datInd->numLch;
#ifndef SS_RBUF
ret = RgUiRguDDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId,
{
S16 ret = ROK;
- TRC2(rgUIMSndCmnDatInd)
-
-
RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndCmnDatInd(): staInd = %p;\n", (void *)datInd));
rguUlSap->sapSts.numPduTxmit++;
RgUstaDgn dgn; /* Alarm diagnostics structure */
Inst inst;
- TRC3(RgUiCrgBndReq)
-
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
#endif
{
Inst inst;
- TRC3(RgUiCrgUbndReq)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
U8 status;
#endif
{
- TRC2(rgUIMCrgBndCfm)
-
if(RgUiCrgBndCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, status) != ROK)
{
U8 cfmStatus = 0x00ff;
U8 prntTrans[CRG_CFG_TRANSID_SIZE+1];
- TRC3(RgUiCrgCfgReq);
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
/* Ensuring transId is always Null terminated. */
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, CRG_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, CRG_CFG_TRANSID_SIZE);
prntTrans[CRG_CFG_TRANSID_SIZE] = '\0';
S16 ret = ROK;
U8 prntTrans[CRG_CFG_TRANSID_SIZE+1];
- TRC2(rgUIMCrgCfgCfm)
-
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, CRG_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, CRG_CFG_TRANSID_SIZE);
prntTrans[CRG_CFG_TRANSID_SIZE] = '\0';
{
RgUstaDgn dgn; /* Alarm diagnostics structure */
- TRC2(rgAllocShrablSBuf)
-
/* Initialize the param to NULLP */
*pData = NULLP;
#endif
/* zero out the allocated memory */
- cmMemset((U8 *)*pData, 0x00, size);
+ memset(*pData, 0x00, size);
return ROK;
{
RgUstaDgn dgn; /* Alarm diagnostics structure */
- TRC2(rgAllocSBuf)
-
/* Initialize the param to NULLP */
*pData = NULLP;
}
/* zero out the allocated memory */
- cmMemset((U8 *)*pData, 0x00, size);
+ memset(*pData, 0x00, size);
return ROK;
S16 ret;
- TRC2(rgFreeSharableBuf)
-
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
RETVOID;
S16 ret;
- TRC2(rgFreeSBuf)
-
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
RETVOID;
{
S16 ret;
- TRC2(rgGetMsg)
-
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
MS_BUF_ADD_ALLOC_CALLER();
#endif /* */
#endif
{
- TRC2(rgFillDgnParams)
-
switch(dgnType)
{
case LRG_USTA_DGNVAL_MEM:
U8 idx1,idx2;
U32 idx;
-
- TRC2(rgUpdtRguDedSts)
-
-
switch(stsType)
{
case RG_RGU_SDU_RCVD:
U8 stsType; /* Statistics type to update */
#endif
{
- TRC2(rgUpdtRguCmnSts)
-
-
switch(stsType)
{
U8 updtType;
#endif
{
- TRC2(rgUpdtCellCnt);
switch (updtType)
{
U8 updtType;
#endif
{
- TRC2(rgUpdtUeCnt);
-
switch (updtType)
{
case RG_CFG_ADD:
Mem sMem;
VOLATILE U32 startTime=0;
- TRC2(rgAllocEventMem)
-
sMem.region = rgCb[inst].rgInit.region;
sMem.pool = rgCb[inst].rgInit.pool;
{
S16 ret;
- TRC2(rgGetEventMem)
#ifdef TFU_ALLOC_EVENT_NO_INIT
ret = cmGetMemNoInit(memCp, len, (Ptr *)ptr);
#else
Inst dstInst;
#endif
{
- TRC2(rgGetPstToInst);
pst->srcEnt = rgCb[srcInst].rgInit.ent;
pst->srcInst = rgCb[srcInst].rgInit.inst;
RgCellCb *cell = NULLP;
RgUeCb *ue;
- TRC2(RgSchMacLcgRegReq);
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cell = rgCb[inst].cell;
RgCellCb *cell = NULLP;
RgUeCb *ue;
- TRC2(RgSchMacUlSpsResetReq);
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cell = rgCb[inst].cell;
RgUeCb *ue;
U8 idx;
- TRC2(RgSchMacSpsLcRegReq);
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cell = rgCb[inst].cell;
RgCellCb *cell = NULLP;
RgUeCb *ue;
- TRC2(RgSchMacSpsLcDeregReq);
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cell = rgCb[inst].cell;
RgUeCb *ue = NULLP;
RgUeCb *newUe = NULLP;
- TRC3(rgUtlHndlCrntiChng)
-
ue = rgDBMGetUeCb(cell, rnti);
newUe = rgDBMGetUeCbFromRachLst(cell, newRnti);
if ((ue == NULLP) || (newUe == NULLP))
ue->ueId = newRnti;
- cmMemcpy((U8*)&(ue->contResId), (U8*)&(newUe->contResId),
+ memcpy(&(ue->contResId), &(newUe->contResId),
sizeof(newUe->contResId));
/* Fix : syed MSG4 might be RETXing need to store the
* HARQ context. */
Pst dstInstPst;
RgPrgUeSCellDelInfo ueSCellDelInfo;
- TRC2(rgDelUeFrmAllSCell)
-
/* To Delete the SCells if exisits for that UE */
for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
{
{
S16 ret = ROK;
- TRC3(rgUtlVltdAddSCellCfg)
-
- /* To Validate the CellID presence */
+ /* To Validate the CellID presence */
if((cell == NULLP) ||
(cell->cellId != ueSCellCb->cellId))
{
TfuDelDatReqInfo delDatReq;
#endif
- TRC2(rgUtlSndCrntiChngReq2AllSMacs)
-
/* use newRnti to get UeCb in PMac because rnti is already changed in PMac*/
ue = rgDBMGetUeCb(cell, newRnti);
if (ue == NULLP)
RgUeCb *spsUeCb = NULLP;
#endif
- TRC3(rgUtlHndlCrntiRls)
-
if ((ue = rgDBMGetUeCb(cell, rlsRnti->rnti)) == NULLP)
{
/* Check in RachLst */
TfuDelDatReqInfo delDatReq;
#endif
- TRC3(RgSchMacRlsRntiReq)
-
RG_IS_INST_VALID(pst->dstInst);
macInst = pst->dstInst - RG_INST_START;
cell = rgCb[macInst].cell;
{ \
SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, \
(Size) _size); \
- cmMemset((U8 *)(_buf), 0, _size); \
+ memset((_buf), 0, _size); \
}
#define RLC_RMV_SDU(_cb,_sduQ,_sdu) \
if (SGetStaticBuffer(_region, _pool, (Data **)&_buf, \
(Size) _size, 0) == ROK) \
{ \
- cmMemset((U8 *)(_buf), 0, _size); \
+ memset((_buf), 0, _size); \
} \
else \
{ \
if (SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, \
(Size) _size) == ROK) \
{ \
- cmMemset((U8 *)(_buf), 0, _size); \
+ memset((_buf), 0, _size); \
} \
else \
{ \
#define RLC_FREE_BUF_WC(_buf) SPutMsg((_buf));
-#define RLC_MEM_CPY(_dst, _src, _size) cmMemcpy((U8*)_dst, (U8 *)_src, _size);
+#define RLC_MEM_CPY(_dst, _src, _size) memcpy(_dst, _src, _size);
-#define RLC_MEM_ZERO(_buf, _size) cmMemset((U8 *)(_buf), 0, _size);
+#define RLC_MEM_ZERO(_buf, _size) memset((_buf), 0, _size);
#define RLC_GET_MEM_REGION(_cb) (_cb->init.region)
#define RLC_GET_MEM_POOL_ADDRESS(_cb) (&_cb->init.pool)
/* Memset to value */
-#define RLC_MEM_SET(_arg, _val, _size) cmMemset((U8 *)_arg, (U8)_val, _size);
+#define RLC_MEM_SET(_arg, _val, _size) memset(_arg, _val, _size);
/* Alarms */
/* Send an alarm for sapId events */
{ \
S8 _buf[60]; \
DateTime dt; \
- cmMemset((U8 *)(&dt), 0, sizeof(DateTime)); \
+ memset((&dt), 0, sizeof(DateTime)); \
SGetDateTime(&dt); \
sprintf(_buf, "date: %02d/%02d/%04d time: %02d:%02d:%02d", \
(int)dt.month,(int)dt.day,(int)dt.year + 1900, \
RlcDlPduInfo *pduInfo;
#endif
{
- TRC2(rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer);
-
RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx));
CmLList *lnk;
CmLList *nextLnk;
- TRC2(rlcAmmDlHndlStatus4SduByteSegInTxBuf)
-
txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
if (txBuf == NULLP)
{
RlcTx *txBuf;
RlcRetx *retx;
- TRC2(rlcAmmDlUpdateTxAndReTxBufForNackSn)
-
/* Now process the NACK_SN received. Now the NACK_SN is */
/* either the first element of RETX or is in TX array */
/* To remove the remaining acks from the pdu byte segments */
RlcRetx *retx;
CmLList *node;
- TRC2(RlcDlAmmGetNackSnInfoFrmNackRangeIdx)
-
nackSnInfo->isSegment = FALSE;
if((!nackInfo->isSegment) || (!idx && nackSnInfo->nackRange && (!nackInfo->soStart)))
RlcKwuSapCb *rlckwuSap;
RlcSn mTxNext;
- TRC2(rlcAmmDlHndlStatusPdu)
rlcStatusPduCnt++;
rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
RlcRetx *retx;
#endif
{
- TRC2(rlcRemRetxPdu)
-
cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
if( AMDL.retxLst.count == 0)
RlcRetx *retx;
#endif
{
- TRC2(rlcAmmDlMarkPduForReTx)
if (AMDL.maxReTxReached == TRUE)
{
RETVOID;
{
RlcSdu *sdu;
- TRC2(rlcAmmDlCheckIsSDUDelivered)
-
sdu = sduMap->sdu;
sdu->mode.am.rcvdSz += sduMap->sduSz;
KwuDatCfmInfo **datCfm;
#endif
{
- TRC2(rlcAmmDlProcessSuccessfulTxPdu)
CmLList *pduNode;
RlcTx *txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
KwuStaIndInfo *staInd;
RlcKwuSapCb *rlckwuSap;
- TRC2(rlcAmmSndStaInd);
-
-
/* Sap control block */
rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
U32 sduId;
#endif
{
- TRC2(rlcAmmDiscSdu);
return (RFAILED);
}
RlcAmDl *amDl = &(rbCb->m.amDl);
RlcSn sn;
RlcTx *txBuf;
- TRC2(rlcAmmPollRetxTmrExp);
-
/* kw003.201 - Correcting the logic for determmining whether to do */
/* any transmission of PDU. As per the spec section */
/* 5.2.2.3, if there is any to transmit or retransmit, */
RlcRetx *retx;
RlcTx *txBuf;
- TRC2(rlcAmmDlUpdateTxAndReTxBufForAckSn);
-
/* Remove pdus/segs from retxLst */
while (retxNode)
{
RlcRetx *retx;
RlcTx *txBuf=NULLP;
- TRC2(rlcAmmDlUpdTxAndReTxBufForLessThanNackSn);
-
while (*retxNode)
{
retx = (RlcRetx *)((*retxNode)->node);
RlcSn tMSn;
RlcSn retxMSn;
- TRC2(rlcAmmAddPduToRetxLst);
-
node = amDl->retxLst.last;
MODAMT(retx->amHdr.sn, retxMSn, amDl->txNextAck,amDl->snModMask);
while(node != NULLP)
#endif
{
RlcTx* txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn);
- TRC2(rlcAmmDlMoveFrmTxtoRetxBuffer);
if (txBuf == NULLP)
{
/* U8 rLen1 = 0; */
U16 tVal;
- TRC2(rlcAmmExtractElmnt);
-
hdr = hdrInfo->hdr;
if (pLen == 0)
U32 resrvdBitsAckSn;
U32 resrvdBitsNackSn;
-
- TRC2(rgAmmUlHndlStatusPdu)
-
RLCDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n");
RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
MsgLen totalSz = 0;
RlcExtHdr hdrInfo;
- TRC2(rlcAmmExtractHdrOld)
-
-
RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract fixed part of the header */
#endif
RlcAmRecBuf *recBuf = NULLP;
- TRC2(rlcAmmUlReEstablish);
-
-
sn = AMUL.rxNext;
MODAMR(AMUL.vrMr, mVrMr, AMUL.rxNext, AMUL.snModMask);
Bool tmrRunning = FALSE;
RlcAmRecBuf *recBuf = NULLP;
- TRC2(rlcAmmReOrdTmrExp);
-
-
/* Update rxHighestStatus */
sn = amUl->rxNextStatusTrig;
{
RlcAmUl *amUl = &(rbCb->m.amUl);
- TRC2(rlcAmmStaProTmrExp);
-
-
amUl->gatherStaPduInfo = FALSE;
if (amUl->staTrg == TRUE)
RlcSn windSz; /* PDU window size */
RlcAmRecBuf *recBuf = NULLP;
- TRC2(rlcAmmFreeUlRbCb)
-
-
windSz = (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
ueIdx = freeIdx;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE;
- cmMemset((U8 *)&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(RlcL2Cntr) *LKW_MAX_QCI));
+ memset(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(RlcL2Cntr) *LKW_MAX_QCI));
measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci = 0;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = ueId;
RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(rlcCfgFillDlRbCb)
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
"rlcCfgFillRbCb(ueId(%d),cellId(%d) rbType(%d))",
RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(rlcCfgUpdateDlRb)
if (rbCb->mode != entCfg->entMode)
{
RlcDlRbCb *rlcRbCb; /* KW RB Control Block */
U8 reason; /* Rb Identifier */
- TRC3(rlcCfgAddDlRb)
-
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
"rlcCfgAddRb(cellId(%d),UEID:%d cfgType(%d))",
cellId,
RlcDlUeCb *ueCb; /* Ue Control Block */
U8 ret;
- TRC3(rlcCfgReCfgDlRb)
-
RLOG_ARG3(L_DEBUG,DBG_UEID,ueId,
"rlcCfgReCfgRb(cellId(%d), cfgType(%d)) RBID:%d",
cellId, entCfg->cfgType,entCfg->rbId);
/* Take backup of rbCb before updating.
* Because in failure case restore original rbCb
*/
- cmMemcpy((U8 *)&tRbCb, (U8 *)rbCb, sizeof(RlcDlRbCb));
+ memcpy(&tRbCb, rbCb, sizeof(RlcDlRbCb));
/* Update rbCb */
ret = rlcCfgUpdateDlRb(gCb,rbCb, cellCb,entCfg);
"CELLID:%u RBID:%d updation failed",
cellId,
entCfg->rbId);
- cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(RlcDlRbCb));
+ memcpy(rbCb, &tRbCb, sizeof(RlcDlRbCb));
return (ret);
}
/* Take backup of rbCb before updating.
* Because in failure case restore original rbCb
*/
- cmMemcpy((U8 *)&tRbCb, (U8 *)rbCb, sizeof(RlcDlRbCb));
+ memcpy(&tRbCb, rbCb, sizeof(RlcDlRbCb));
/* Update rbCb */
ret = rlcCfgUpdateDlRb(gCb,rbCb,ueCb, entCfg);
"CELLID:%d RBID:%d updation failed",
cellId,
entCfg->rbId);
- cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(RlcDlRbCb));
+ memcpy(rbCb, &tRbCb, sizeof(RlcDlRbCb));
return (ret);
}
RlcDlCellCb *cellCb; /* UE Control Block */
RlcDlRbCb *rlcRbCb; /* KW RB Control Block */
- TRC3(rlcCfgDelDlRb)
-
RLOG_ARG3(L_DEBUG,DBG_UEID,ueId,
"rlcCfgDelRb(RBID(%d), cellId(%d), cfgType(%d))",
entCfg->rbId,
RlcDlRbCb *rbCb; /* RB Control Block */
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(rlcCfgReEstDlRb)
-
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
"rlcCfgReEstDlRb(ueId(%d), cellId(%d), cfgType(%d))",
ueId,
S16 ret; /* Return Value */
RlcDlUeCb *ueCb; /* UE Control Block */
- TRC3(rlcCfgDelUe)
-
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
"rlcCfgDelUe(ueId(%d), cellId(%d), cfgType(%d))",
ueId,
RlcDlCellCb *cellCb; /* UE Control Block */
U8 rbId; /* RB Identifier */
- TRC3(rlcCfgDelCell)
-
RLOG_ARG2(L_DEBUG,DBG_RBID,entCfg->rbId,
"rlcCfgDelCell( cellId(%d), cfgType(%d)",
cellId,
{
RlcDlUeCb *ueCb;
/*kw004.201 Adding of Missing Trace in LTE RLC PDCP*/
- TRC3(rlcCfgUeIdChng)
if ( (ueInfo->ueId == newUeInfo->ueId) &&
(ueInfo->cellId == newUeInfo->cellId))
ueIdx = freeIdx;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE;
- cmMemset((U8 *)&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(RlcL2Cntr) *LKW_MAX_QCI));
+ memset(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(RlcL2Cntr) *LKW_MAX_QCI));
measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci = 0;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = ueId;
RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(rlcCfgFillUlRbCb)
RLOG_ARG3(L_DEBUG,DBG_UEID,rbCb->rlcId.ueId,
"rlcCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(rlcCfgUpdateUlRb)
switch (rbCb->mode)
{
RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(rlcCfgValidateUlRb)
RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
"cellId(%d), cfgType(%d)",
)
#endif
{
- TRC3(rlcCfgRollBackUlRb)
if(CKW_CFG_ADD == cfg->cfgType)
{
)
#endif
{
- TRC3(rlcCfgApplyUlRb)
switch(cfgToAply->cfgType)
{
RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(rlcCfgValidateDelUlUe)
RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
"cellId(%d), cfgType(%d)",
)
#endif
{
- TRC3(rlcCfgApplyDelUlUe)
#ifdef LTE_L2_MEAS
rlcDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(rlcCfgValidateDelUlCell)
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellId ,"cfgType(%d)",
cfgToValidate->cfgType);
)
#endif
{
- TRC3(rlcCfgApplyDelUlCell)
rlcDbmDelUlCellCb(gCb,cfgInfo->cellCb);
RETVOID;
#endif
{
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(rlcCfgValidateReEstRb)
RLOG_ARG2(L_DEBUG, DBG_UEID,ueId,
"cellId(%d) RBID:%d",
#endif
{
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(rlcCfgApplyReEstUlRb)
rlcId.ueId = ueId;
rlcId.cellId = cellId;
#endif
{
RlcUlUeCb *ueCb;
- TRC3(rlcCfgValidateUeIdChng)
#define CFM_STATUS cfgTmpData->cfgEntData[0].entUlCfgCfm.status
if ( (ueInfo->ueId == newUeInfo->ueId) &&
)
#endif
{
- TRC3(rlcCfgApplyUlUeIdChng)
#ifdef LTE_L2_MEAS
rlcHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
RlcCb *gCb;
#endif
{
- TRC3(rlcDbmDlInit)
/* Initialize ueCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.dlCb->ueLstCp),
RlcCb *gCb;
#endif
{
- TRC3(rlcDbmDlDeInit);
/* De Initialize ueCb Hash List */
{
U32 idx;
- TRC3(rlcDbmDelAllDlRb)
-
for (idx = 0; idx < numRbCb; idx++)
{
{
RlcDlUeCb *tUeCb;
- TRC3(rlcDbmCreateDlUeCb)
-
-
RLC_ALLOC(gCb,*ueCb, sizeof(RlcDlUeCb));
#if (ERRCLASS & ERRCLS_ADD_RES)
Bool abortFlag;
#endif
{
- TRC3(rlcDbmDelDlUeCb)
-
#if (!defined(KW_PDCP) || !(defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))
UNUSED(abortFlag);
{
RlcDlUeCb *ueCb = NULLP;
- TRC3(rlcDbmDelAllDlUe)
-
-
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
while (ROK == cmHashListGetNext(&(gCb->u.dlCb->ueLstCp),
(PTR) ueCb,
{
RlcDlCellCb *tCellCb;
- TRC3(rlcDbmCreateDlCellCb)
RLC_ALLOC(gCb,*cellCb, sizeof(RlcDlCellCb));
#if (ERRCLASS & ERRCLS_ADD_RES)
RlcDlCellCb *cellCb;
#endif
{
- TRC3(rlcDbmDelDlCellCb)
-
/* Delete all rbCbs in cellCb */
rlcDbmDelAllDlRb(gCb,cellCb->rbCb, RLC_MAX_RB_PER_CELL);
{
RlcDlCellCb *cellCb = NULLP;
- TRC3(rlcDbmDelAllDlCell)
-
-
/* Until no more cellCb is ueLstCp hash list get and delete cellCb */
while (ROK == cmHashListGetNext(&(gCb->u.dlCb->cellLstCp),
(PTR) cellCb,
RlcCb *gCb;
#endif
{
- TRC3(rlcDbmDlShutdown)
rlcDbmDelAllDlCell(gCb);
RlcCb *gCb;
#endif
{
- TRC3(rlcUlDbmInit)
-
/* Initialize ueCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.ulCb->ueLstCp),
(U16) RLC_UE_LIST_BUCKET_SIZE,
RlcCb *gCb;
#endif
{
- TRC3(rlcDbmUlDeInit);
-
/* De Initialize ueCb Hash List */
cmHashListDeinit(&(gCb->u.ulCb->ueLstCp));
RlcUlRbCb **rbCb;
#endif
{
- TRC3(rlcDbmFetchUlRbCbByRbId)
-
*rbCb= NULLP;
/* Check for UE CB or CELL CB */
{
U32 idx; /* Index */
- TRC3(rlcDbmDelAllUlRb)
-
-
for (idx = 0; idx < numRbCb; idx++)
{
if (rbCbLst[idx] != NULLP)
RlcUlUeCb *ueCb;
#endif
{
- TRC3(rlcDbmAddUlUeCb)
-
ueCb->ueId = ueId;
ueCb->cellId = cellId;
RlcUlCfgTmpData *cfg;
#endif
{
- TRC3(rlcDbmAddUlTransaction)
-
#ifndef ALIGN_64BIT
RLOG1(L_DEBUG, "(transId(%ld)", cfg->transId);
#else
RlcUlCfgTmpData **cfg;
#endif
{
- TRC3(rlcDbmFindUlTransaction)
if(ROK != cmHashListFind(&(gCb->u.ulCb->transIdLstCp),
(U8 *) &transId,
RlcUlCfgTmpData *cfg;
#endif
{
- TRC3(rlcDbmDelUlTransaction)
-
if(cmHashListDelete(&(gCb->u.ulCb->transIdLstCp),(PTR) (cfg)) != ROK)
{
{
RlcUlCfgTmpData *cfg = NULL;
- TRC3(kwDbmDelAllUlTransctions)
-
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
while (ROK == cmHashListGetNext(&(gCb->u.ulCb->transIdLstCp),
(PTR) cfg,
Bool abortFlag;
#endif
{
- TRC3(rlcDbmDelUlUeCb)
-
#if (!defined(KW_PDCP) || !(defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))
UNUSED(abortFlag);
{
RlcUlUeCb *ueCb = NULLP; /* UE Control Block */
- TRC3(rlcDbmDelAllUlUe)
-
-
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
while (ROK == cmHashListGetNext(&(gCb->u.ulCb->ueLstCp),
(PTR) ueCb,
{
RlcUlCellCb *tCellCb;
- TRC3(rlcDbmAddUlCellCb)
-
-
-
tCellCb = cellCb;
tCellCb->cellId = cellId;
RlcUlCellCb *cellCb;
#endif
{
- TRC3(rlcDbmDelUlCellCb)
-
/* Delete all rbCbs in cellCb */
rlcDbmDelAllUlRb(gCb,cellCb->rbCb, RLC_MAX_RB_PER_CELL);
{
RlcUlCellCb *cellCb = NULLP; /* Cell Control Block */
- TRC3(rlcDbmDelAllUlCell)
-
-
/* Until no more cellCb is ueLstCp hash list get and delete cellCb */
while (ROK == cmHashListGetNext(&(gCb->u.ulCb->cellLstCp),
(PTR) cellCb,
RlcCb *gCb;
#endif
{
- TRC3(rlcDbmUlShutdown)
rlcDbmDelAllUlCell(gCb);
if (_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci == 0) \
{ \
_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.qci[(_rlcRbCb)->qci] = 0; \
- cmMemset((U8 *)&_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci], 0, \
+ memset(&_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci], 0, \
sizeof(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci])); \
} \
} \
S16 rlcDlInitExt()
#endif
{
- TRC2(rlcDlInitExt);
-
return ROK;
} /* kwInitExt */
#endif
{
RlcCb *tRlcCb;
- TRC3(rlcDlActvInit)
if (inst >= MAX_RLC_INSTANCES)
{
{
S16 ret = ROK;
- TRC3(rlcDlActvTsk);
#ifdef RLC_FREE_RING_BUF
gRlcTId = pthread_self();
#endif
SystemId *s; /* system id */
#endif
{
- TRC2(rlcGetSId);
s->mVer = sId.mVer;
s->mRev = sId.mRev;
RlcRguSapCb *rguSap; /* RGU SAP Control Block */
RlcCb *tRlcCb;
- TRC3(RlcLiRguBndCfm)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
U8 tbIdx;
RlcCb *tRlcCb;
- TRC3(RlcLiRguHqStaInd)
-
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
ueKey.cellId = staInd->cellId;
ueKey.ueId = staInd->ueId;
CmTqCp *rlcTqCp;
Size rguSapSize;
- TRC2(rlcLmmGenCfg)
-
if(cfg->maxUe > RLC_MAX_UE)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Timer Initialization */
gCb->rlcTqCp.tmrLen = RLC_TMR_LEN;
- cmMemset((U8*)gCb->rlcTq, NULLP, sizeof(CmTqType) * RLC_TMR_LEN);
+ memset(gCb->rlcTq, NULLP, sizeof(CmTqType) * RLC_TMR_LEN);
RLC_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
{
Pst rPst; /* Reply post structure */
- TRC2(rlcLmmSendCfm);
-
RLC_MEM_SET(&rPst, 0, sizeof(Pst));
/* reply post structure for confirmation */
Reason reason; /* failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiRlcConfigReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
Reason reason; /* failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiLkwCntrlReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
Reason reason; /* Failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiLkwStaReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
Reason reason; /* Reason for failure */
RlcCb *tRlcCb=NULLP;
- TRC3(RlcMiLkwStsReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
if (pst->dstInst >= MAX_RLC_INSTANCES)
RlcCb *tRlcCb;
- TRC3(RlcMiLkwL2MeasReq);
-
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* Initialize measCfmEvt */
return RFAILED;
}
#endif
- cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(RlcL2MeasReqEvt));
+ memcpy(measEvt, measReqEvt, sizeof(RlcL2MeasReqEvt));
/*Redirect the request to DL task */
/* NOTE:As of today, there are no cases where the Req will fail at DL
as long as it reached the DL, so we don't wait for a confirmation from
U8 status = ROK;
RlcCb *tRlcCb;
- TRC3(RlcMiLkwL2MeasStopReq);
-
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* reset the counter values for the measurement that is stopped */
rlcUlUdxL2MeasStopReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measType);
/*return ROK;*/
}
- /*cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
+ /*memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
status = LCM_PRIM_OK;
RlcMiLkwL2MeasStopCfm(&tRlcCb->genCfg.lmPst, measType,status);
RlcL2MeasEvtCb *measEvtCb = NULLP;
U16 cntr;
RlcCb *tRlcCb;
- TRC3(RlcMiLkwL2MeasSendReq);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#endif
{
RlcKwuSapCb *rlcKwuSapCb;
- TRC2(rlcLmmCfgKwuSap)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
{
RlcCkwSapCb *ckwSap;
- TRC2(rlcLmmCfgCkwSap)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate config parameters */
if ((cfg->sapId >= RLC_MAX_CKWSAPS) || (cfg->sapId < 0) )
RlcUdxDlSapCb *udxDlSap;
RlcUdxUlSapCb *udxUlSap;
- TRC2(rlcLmmCfgUdxSap);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
if((cfg->sapId >= RLC_MAX_UDXSAPS) || (cfg->sapId < 0))
{
RlcRguSapCb *rguSap;
- TRC2(rlcLmmCfgRguSap);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
if((cfg->sapId >= gCb->genCfg.maxRguSaps) || \
S16 reason; /* reason for failure */
U8 sAction; /* subaction field */
- TRC2(rlcLmmValidateGenCntrl);
-
reason = LCM_REASON_NOT_APPL;
sAction = cntrl->t.cntrl.subAction;
Size rlcSapSize;
Size rlcUdxSapSize;
- TRC2(rlcLmmCleanGblRsrcs)
-
if (gCb->init.cfgDone)
{
/* Deregister the timers */
RlcRguSapCb *rguSap;
U32 idx;
- TRC2(rlcLmmShutdown)
-
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
#endif /* DEBUGP */
S16 reason; /* reason for failure */
- TRC2(rlcLmmGenCntrl);
-
/* Validate control parameters */
reason = rlcLmmValidateGenCntrl (cntrl);
RlcMngmt *cntrl;
#endif
{
- TRC2(rlcLmmUdxSapCntrl)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
RlcRguSapCb *rguSap; /* rgu sap pointer */
- TRC2(rlcLmmLSapCntrl)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate SuId */
if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
{
RlcKwuSapCb *rlcKwSapCb;
- TRC2(rlcLmmGetKwuSapSta);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
RlcRguSapSta *sta;
#endif
{
- TRC2(rlcLmmGetRguSapSta);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
RlcCkwCntSapSta *sta;
#endif
{
- TRC2(rlcLmmGetCkwCntSapSta);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate config parameters */
Action action;
#endif
{
- TRC2(rlcLmmGetGenSts);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate protocol parameters */
Action action;
#endif
{
- TRC2(rlcLmmGetSapSts);
/* Validate protocol parameters */
if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
{
RlcMngmt usta; /* Rlc Management Structure */
- TRC2(rlcLmmSendAlarm);
-
if(gCb->init.usta == FALSE)
{
RETVOID;
MsgLen tempCnt;
Pst pst;
- TRC2(rlcLmmSendTrc)
-
RLOG2(L_DEBUG, "rlcLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
event,
gCb->trcLen);
- cmMemset((U8 *)&trc, 0, sizeof(RlcMngmt));
+ memset(&trc, 0, sizeof(RlcMngmt));
pst = gCb->init.lmPst;
#endif
{
RlcCb *gCb;
- TRC2(rlcActvTmr)
if (inst >= MAX_RLC_INSTANCES)
{
SpId spId; /* Service Provider Id */
#endif
{
- TRC3(RlcLiRguBndReq)
/* jump to specific primitive depending on configured selector */
(*kwLiRguBndReqMt[post->selector])(post, suId, spId);
Reason reason;
#endif
{
- TRC3(RlcLiRguUbndReq)
/* jump to specific primitive depending on configured selector */
(*kwLiRguUbndReqMt[post->selector])(post, spId, reason);
RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq;
#endif
{
- TRC3(RlcLiRguL2MUlThrpMeasReq)
/* jump to specific primitive depending on configured selector */
(*kwLiRguL2MUlThrpMeasReqMt[post->selector])(post, spId, l2mUlThrpMeasReq);
U8 numLch;
U8 numPdu;
- TRC2(rlcUtlFreeUlRBuf)
/* Free SS_RNG_BUF_ULMAC_TO_ULRLC */
while((SDeqSRngBuf (SS_RNG_BUF_ULMAC_TO_ULRLC, &elem) == ROK))
{
if (NULLP != elem)
{
staRspInfo = (RguDStaRspInfo *)elem;
- cmMemcpy((U8 *)staRspInfo, (U8 *)staRsp, sizeof(RguDStaRspInfo));
+ memcpy(staRspInfo, staRsp, sizeof(RguDStaRspInfo));
staRspInfo->post = *post;
SRngIncrWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].pktRate++;
RlcMngmt *cfm; /* Layer Management structure */
#endif
{
- TRC3(RlcMiRlcConfigCfm);
/* jump to specific primitive depending on configured selector */
(*rlcMiRlcConfigCfmMt[pst->selector])(pst, cfm);
RlcMngmt *cfm; /* confirm */
#endif
{
- TRC3(RlcMiLkwCntrlCfm)
/* jump to specific primitive depending on configured selector */
(*kwMiLkwCntrlCfmMt[pst->selector])(pst, cfm);
RlcMngmt *usta; /* unsolicited status */
#endif
{
- TRC3(RlcMiLkwStaInd);
-
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStaIndMt[pst->selector])(pst, usta);
RlcMngmt *cfm; /* solicited status confirmation */
#endif
{
- TRC3(RlcMiLkwStaCfm);
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStaCfmMt[pst->selector])(pst, cfm);
RlcMngmt *cfm; /* statistics confirmation */
#endif
{
- TRC3(RlcMiLkwStsCfm);
-
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStsCfmMt[pst->selector])(pst, action, cfm);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(RlcMiLkwTrcInd);
-
/* jump to specific primitive depending on configured selector */
(*kwMiLkwTrcIndMt[pst->selector])(pst, trc, mBuf);
#endif
{
- TRC3(RlcMiLkwL2MeasCfm)
-
(*rlcMiLkwL2MeasCfmMt[pst->selector])(pst, measEvt);
return ROK;
#endif
{
- TRC3(RlcMiLkwL2MeasStopCfm)
-
(*RlcMiLkwL2MeasStopCfmMt[pst->selector])(pst, measType,status);
return ROK;
U8 status; /* Status */
#endif
{
- TRC3(RlcUiKwuBndCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuBndCfmMt[pst->selector])(pst, suId, status);
Buffer *mBuf;
#endif
{
- TRC3(rlcSendUlDataToDu)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatIndMt[pst->selector])(pst, datInd, mBuf);
#endif
{
rlcDatCfmsSent++;
- TRC3(RlcUiKwuDatCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatCfmMt[pst->selector])(pst, suId, datCfm);
KwuStaIndInfo *staInd;
#endif
{
- TRC3(RlcUiKwuStaInd)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuStaIndMt[pst->selector])(pst, suId, staInd);
CmLteRlcId rlcId;
#endif
{
- TRC3(RlcUiKwuReEstCmpInd)
RLOG0(L_DEBUG, "In RlcUiKwuReEstCmpInd");
/* jump to specific primitive depending on configured selector */
KwuDiscSduInfo *discCfm;
#endif
{
- TRC3(RlcUiKwuDiscSduCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDiscSduCfmMt[pst->selector])(pst, suId, discCfm);
KwuFlowCntrlIndInfo *flowCntrlIndInfo;
#endif
{
- TRC3(RlcUiKwuFlowCntrlInd)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuFlowCntrlIndMt[pst->selector])(pst, suId, flowCntrlIndInfo);
KwuDatAckInfo *datAckInd;
#endif
{
- TRC3(RlcUiKwuDatAckInd)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatAckIndMt[pst->selector])(pst, suId, datAckInd);
U8 status; /* Status */
#endif
{
- TRC3(RlcUiCkwBndCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiCkwBndCfmMt[pst->selector])(pst, suId, status);
RlcCfgCfmInfo *cfmInfo; /* Configuration Confirm */
#endif
{
- TRC3(RlcUiRlcCfgCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiRlcCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
CmStatus status;
#endif
{
- TRC3(RlcUiCkwUeIdChgCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiCkwUeIdChgCfmMt[pst->selector])(pst, suId, transId, ueInfo, status);
{
U32 cnt=0;
- TRC2(TSL2AllocStatsMem)
-
cmLListInit(&inUseL2UeStatsLst);
cmLListInit(&freeL2UeStatsLst);
for (cnt=0; cnt < L2_STATS_MAX_CELLS; cnt++)
printf("\n STATS Unexpected MEM Alloc Failure\n");
}
}
- cmMemset((U8 *)l2CellStats[cnt], 0x00, (Size)sizeof(TSL2CellStatsCb));
+ memset(l2CellStats[cnt], 0x00, sizeof(TSL2CellStatsCb));
}
for (cnt=0; cnt < L2_STATS_MAX_UES; cnt++)
printf("\n STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
}
}
- cmMemset((U8 *)statsCb, 0x00, (Size)sizeof(TSL2UeStatsCb));
+ memset(statsCb, 0x00, sizeof(TSL2UeStatsCb));
statsCb->lnk.node = (PTR)statsCb;
cmLListAdd2Tail(&freeL2UeStatsLst, &statsCb->lnk);
l2UeStats[cnt] = statsCb;
CmLList *tmp = NULLP;
TSL2UeStatsCb *statsCb = NULLP;
- TRC2(TSL2AllocUeStatsBlk)
-
tmp = freeL2UeStatsLst.first;
if (tmp == NULLP)
{
TSL2UeStatsCb *statsCb;
#endif
{
- TRC2(TSL2DeallocUeStatsBlk)
-
statsCb->inUse = FALSE;
cmLListDelFrm(&inUseL2UeStatsLst, &statsCb->lnk);
freeL2UeStatsLst.crnt = freeL2UeStatsLst.first;
U32 cellId;
#endif
{
- TRC2(TSL2AllocCellStatsBlk)
-
if (cellId != 1)
{
printf("\n STATS Unexpected CellID = %d\n", (int)cellId);
U32 cellId;
#endif
{
- TRC2(TSL2DeallocCellStatsBlk)
RETVOID;
}
{
U32 idx;
- TRC2(TSL2SendStatsToApp)
-
for (idx = 0; idx < L2_STATS_MAX_UES; idx++)
{
TSL2UeStatsCb *statsCb = l2UeStats[idx];
#endif
}
rnti = statsCb->stats.rnti;
- cmMemset((U8 *)&statsCb->stats.nonPersistent, 0x00, (Size)sizeof(statsCb->stats.nonPersistent));
- /* cmMemset((U8 *)&statsCb->stats, 0x00, (Size)sizeof(TSInfL2UeStats)); */
+ memset(&statsCb->stats.nonPersistent, 0x00, sizeof(statsCb->stats.nonPersistent));
+ /* memset(&statsCb->stats, 0x00, sizeof(TSInfL2UeStats)); */
statsCb->stats.rnti = rnti;
}
#endif
}
cellId = statsCellCb->cellId;
- cmMemset((U8 *)l2CellStats[idx], 0x00, (Size)sizeof(TSInfL2CellStats));
+ memset(l2CellStats[idx], 0x00, sizeof(TSInfL2CellStats));
statsCellCb->cellId = cellId;
}
RETVOID;
{
RlcSdu *sdu;
- TRC2(rlcTmmQSdu)
-
-
RLC_ALLOC(gCb,sdu,sizeof(RlcSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
RlcDlRbCb *rbCb;
#endif
{
- TRC2(rlcDlTmmReEstablish)
-
#ifdef LTE_L2_MEAS_RLC
rlcUtlEmptySduQ(gCb, rbCb, &rbCb->m.tm.sduQ);
#ifdef PJ
Pst ulPst2 ={100,100,217,0,216,0,PRIOR0,0,68,0,1,0,0};
#endif
- TRC2(rlcTmmRcvFrmMac)
if(1 == rrcMsgType)
{
RlcUlRbCb *rbCb;
#endif
{
- TRC2(rlcUlTmmReEstablish)
RLOG_ARG0(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,"do nothing for TMM for ReEstablish");
RETVOID;
#endif
{
/* kw005.201 added support for L2 Measurement */
- TRC2(rlcTmrExpiry)
switch (tmrEvnt)
{
{
RlcRguSapCb *rguSapCb;
- TRC2(rlcBndTmrExpiry)
-
rguSapCb = (RlcRguSapCb *) cb;
if (rguSapCb->state == RLC_SAP_BINDING)
{
MsgLen tmpLen;
- TRC3(cmUnpkUdxStruct)
return (SCpyMsgFix(srcMBuf,offset,size,dstBuf,&tmpLen));
} /*end of function cmPkUdxBndReq*/
#endif
{
- TRC3(cmPkUdxStruct)
return (SAddPstMsgMult(srcBuf,size,dstMBuf));
} /*end of function cmPkUdxBndReq*/
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkUdxBndReq)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkUdxUbndReq)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkUdxBndCfm)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkUdxCfgReq)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkUdxCfgCfm)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxUeIdChgReq)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
{
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxUeIdChgCfm)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxStaUpdCfm)
-
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxStaProhTmrStart)
-
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxStaUpdReq)
-
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxStaUpdReq)
-
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxL2MeasReq)
-
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxL2MeasSendReq)
-
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkUdxL2MeasStopReq)
-
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId = 0;
SpId spId = 0;
- TRC3(cmUnpkUdxBndReq)
-
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
SPutMsg(mBuf);
SpId spId = 0;
Reason reason = 0;
- TRC3(cmUnpkUdxUbndReq)
-
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EUDXXXX, pst);
SPutMsg(mBuf);
SuId suId = 0;
U8 status = 0;
- TRC3(cmUnpkUdxBndCfm)
-
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EUDXXXX, pst);
SPutMsg(mBuf);
RlcCfgInfo tmpCfgInfo;
RlcCfgInfo *cfgInfo; /*stack Variable because it is not freed */
- TRC3(cmUnpkUdxCfgReq)
-
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
switch(pst->selector)
{
SuId suId = 0;
RlcCfgCfmInfo *cfgCfmInfo = NULLP;
- TRC3(cmUnpkUdxCfgCfm)
-
CMCHKUNPK(SUnpkS16, &suId, mBuf);
switch(pst->selector)
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
- TRC3(cmUnpkUdxUeIdChgReq)
-
-
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, EUDXXXX, pst);
U32 transId = 0;
CmStatus status;
- TRC3(cmUnpkUdxUeIdChgCfm)
-
- cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
+ memset(&status, 0, sizeof(CmStatus));
CMCHKUNPK(SUnpkS16, &suId, mBuf);
CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, EUDXXXX, pst);
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
RlcUdxBufLst *pBufLst = NULLP; /* KW_FIX*/
- TRC3(cmUnpkUdxStaUpdCfm)
-
CMCHKUNPK(SUnpkS16, &suId, mBuf);
switch (pst->selector)
{
S16 ret1;
CmLteRlcId tmpRlcId;
- TRC3(cmUnpkUdxStaUpdCfm)
-
CMCHKUNPK(SUnpkS16, &spId, mBuf);
switch (pst->selector)
{
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
RlcUdxDlStaPdu *pStaPdu = NULLP; /* KW_FIX */
- TRC3(cmUnpkUdxStaUpdCfm)
-
CMCHKUNPK(SUnpkS16, &spId, mBuf);
switch (pst->selector)
{
CmLteRlcId tmpRlcId;
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
- TRC3(cmUnpkUdxStaProhTmrStart)
-
CMCHKUNPK(SUnpkS16, &spId, mBuf);
switch (pst->selector)
{
RlcL2MeasReqEvt tmpMeasReqEvt;
RlcL2MeasReqEvt *measReqEvt = NULLP; /* KW_FIX */
- TRC3(cmUnpkUdxL2MeasReq)
-
switch (pst->selector)
{
case UDX_SEL_LC:
{
U8 measType = 0; /* KW_FIX */
- TRC3(cmUnpkUdxL2MeasSendReq)
-
switch (pst->selector)
{
case UDX_SEL_LC:
{
U8 measType = 0; /* KW_FIX */
- TRC3(cmUnpkUdxL2MeasStopReq)
-
switch (pst->selector)
{
case UDX_SEL_LC:
RlcUdxDlSapCb *udxSap; /* pointer to session SAP */
RlcCb *tRlcCb;
- TRC3(rlcDlUdxBndReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RlcUdxDlSapCb *udxSap;
RlcCb *tRlcCb;
- TRC3(rlcDlUdxUbndReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RlcCb *tRlcCb;
Pst *pstUdxCfm;
- TRC3(rlcDlUdxCfgReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
CmStatus status;
RlcCb *tRlcCb;
- TRC3(rlcDlUdxUeIdChgReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
VOLATILE U32 startTime = 0;
RlcCb *tRlcCb;
- TRC3(rlcDlUdxL2MeasReq);
-
/*starting Task*/
SStartTask(&startTime, PID_RLC_MEAS_START);
/* RlcL2MeasCfmEvt measCfmEvt; */
VOLATILE U32 startTime = 0;
RlcCb *tRlcCb=NULLP;
- TRC3(rlcDlUdxMeasStopReq);
/*starting Task*/
SStartTask(&startTime, PID_RLC_MEAS_STOP);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
-/* cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
+/* memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
/* reset the counters for the measurement type passed */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
VOLATILE U32 startTime = 0;
RlcCb *tRlcCb;
- TRC3(rlcDlUdxMeasSendReq);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
U8 status; /* Status */
#endif
{
- TRC3(PtDlUdxBndCfm)
return ROK;
RlcCfgCfmInfo *cfmInfo; /* Status */
#endif
{
- TRC3(PtDlUdxCfgCfm)
return ROK;
CmStatus status;
#endif
{
- TRC3(PtDlUdxUeIdChgCfm)
return ROK;
RlcUdxBufLst *pBufLst
)
{
- TRC3(PtDlUdxStaUpdCfm);
return ROK;
}
CmLteRlcId *rlcId
)
{
- TRC3(PtDlUdxStaProhTmrStart);
return ROK;
}
#endif
U8 status; /* Status */
#endif
{
- TRC3(rlcDlUdxBndCfm)
/* jump to specific primitive depending on configured selector */
(*rlcDlUdxBndCfmMt[pst->selector])(pst, suId, status);
RlcCfgCfmInfo *cfmInfo; /* Status */
#endif
{
- TRC3(rlcDlUdxCfgCfm)
/* jump to specific primitive depending on configured selector */
(*rlcDlUdxCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
CmStatus status;
#endif
{
- TRC3(rlcDlUdxUeIdChgCfm)
/* jump to specific primitive depending on configured selector */
(*rlcDlUdxUeIdChgCfmMt[pst->selector])(pst, suId,transId,status);
SpId spId; /* Status */
#endif
{
- TRC3(PtUlUdxBndReq)
return ROK;
Reason Reason; /* Status */
#endif
{
- TRC3(PtUlUdxUbndReq)
return ROK;
RlcCfgInfo *cfmInfo; /* Config Info */
#endif
{
- TRC3(PtUlUdxCfgReq)
return ROK;
CkwUeInfo *newUeInfo; /* Config Info */
#endif
{
- TRC3(PtUlUdxUeIdChgReq)
-
return ROK;
RlcUdxDlStaPdu *pStaPdu
)
{
- TRC3(PtUlUdxStaPduReq);
return ROK;
}
#endif
{
- TRC3(PtUlUdxStaUpdReq);
-
return ROK;
} /* end of RlcUlmDlmStaUpd*/
#endif
{
- TRC3(PtUlUdxL2MeasReq);
-
return ROK;
}
#endif
{
- TRC3(PtUlUdxL2MeasSendReq);
-
return ROK;
}
#endif
{
- TRC3(PtUlUdxL2MeasStopReq);
-
return ROK;
}
#endif
SpId spId; /* Status */
#endif
{
- TRC3(rlcUlUdxBndReq)
-
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxBndReqMt[pst->selector])(pst, suId, spId);
Reason Reason; /* Status */
#endif
{
- TRC3(rlcUlUdxUbndReq)
-
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxUbndReqMt[pst->selector])(pst, spId,reason );
RlcCfgInfo *cfmInfo; /* Config Info */
#endif
{
- TRC3(rlcUlUdxCfgReq)
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxCfgReqMt[pst->selector])(pst, spId, cfmInfo);
CkwUeInfo *newUeInfo; /* Config Info */
#endif
{
- TRC3(rlcUlUdxUeIdChgReq)
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxUeIdChgReqMt[pst->selector])(pst, spId,transId,ueInfo,newUeInfo);
#endif
{
- TRC3(rlcUlUdxStaUpdReq);
-
return ((*rlcUlUdxL2MeasReqMt[pst->selector])(pst,measReqEvt));
} /* end of rlcUlUdxL2MeasReq*/
#endif
{
- TRC3(rlcUlUdxStaUpdReq);
-
return ((*rlcUlUdxL2MeasSendReqMt[pst->selector])(pst,measType));
} /* end of rlcUlUdxMesReq*/
#endif
{
- TRC3(rlcUlUdxStaUpdReq);
-
return ((*rlcUlUdxL2MeasStopReqMt[pst->selector])(pst,measType));
} /* end of rlcUlUdxMesReq*/
#endif
RlcUdxUlSapCb *udxSap; /* RGU SAP Control Block */
RlcCb *tRlcCb;
- TRC3(rlcUlUdxBndCfm)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
Pst rspPst;
memset(&rspPst, 0, sizeof(Pst));
- TRC3(rlcUlUdxCfgCfm)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RlcCb *tRlcCb;
RlcUlCfgTmpData *cfgTmpData;
- TRC3(rlcUlUdxUeIdChgCfm)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RlcCkwSapCb *ckwSap;
RlcCb *tRlcCb;
- TRC3(RlcUiCkwBndReq);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
{
RlcCb *tRlcCb;
- TRC3(RlcUiCkwUbndReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
static U32 transCount;
-
- TRC3(RlcProcCfgReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RlcCb *tRlcCb;
RlcUlCfgTmpData *cfgTmpData = NULLP;
- TRC3(RlcUiCkwUeIdChgReq)
-
do
{
#if (ERRCLASS & ERRCLS_INT_PAR)
{
U8 idx;
- TRC3(rlcUlHdlCfgReq)
-
cfgTmpData->ueId = cfg->ueId;
cfgTmpData->cellId = cfg->cellId;
for (idx = 0; idx < cfg->numEnt; idx++)
RlcKwuSapCb *rlckwuSap; /* SAP Config Block */
RlcCb *tRlcCb;
- TRC3(RlcUiKwuBndReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RlcKwuSapCb *rlckwuSap; /* KWU SAP control block */
RlcCb *tRlcCb;
- TRC3(RlcUiKwuUbndReq)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((pst->dstInst >= MAX_RLC_INSTANCES) ||
(spId >= (S16) rlcCb[pst->dstInst]->genCfg.maxKwuSaps) ||
S16 rlcUlInitExt()
#endif
{
- TRC2(rlcUlInitExt);
return ROK;
} /* kwInitExt */
#endif
{
RlcCb *tRlcCb;
- TRC3(rlcUlActvInit)
if (inst >= MAX_RLC_INSTANCES)
{
{
S16 ret = ROK;
- TRC3(kwActvTsk);
switch(pst->srcEnt)
{
if ((lchInfo.numSdus != 0) && (l2MeasTb != NULLP) &&
(l2MeasTb->numLchInfo < RLC_MAX_ACTV_DRB))
{
- cmMemcpy((U8 *) &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], (U8 *) &lchInfo, sizeof(RlclchInfo));
+ memcpy( &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], &lchInfo, sizeof(RlclchInfo));
l2MeasTb->numLchInfo++;
}
l2MeasTb->txSegSduCnt += segSduCnt;
#endif
{
/* The re-establishment indication is sent from the UL only */
- TRC2(rlcDlUmmReEstablish)
-
rlcUmmFreeDlRbCb(gCb, rbCb);
#endif
{
CmLList *tmpNode; /* Temporary Node in SDU queue */
-
- TRC2(rlcUmmDiscSdu)
-
-
CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,tmpNode);
if (tmpNode)
RlcDlRbCb *rbCb;
#endif
{
- TRC2(rlcUmmFreeDlRbCb)
-
/* cat the SDU queue to the to be freed list */
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.umDl.sduQ));
RlcUmRecBuf **recBuf; /* UM Reception Buffer */
RlcKwuSapCb *rlcKwSap; /* KWU SAP Information */
- TRC2(rlcUmmUlReEstablish)
-
-
curSn = rbCb->m.umUl.vrUr;
vrUh = RLC_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
recBuf = rbCb->m.umUl.recBuf;
#endif
{
RlcSn prevVrUr; /* prevVrUr */
-
- TRC3(rlcUmmReOrdTmrExp)
-
-
prevVrUr = RLC_UMUL.vrUr;
/* set VR(UR) to SN >= VR(UX) that has not been received */
RlcSn windSz; /* PDU window size */
RlcUmRecBuf **umRecBuf; /* UM module receive buffer */
- TRC2(rlcUmmFreeUlRbCb)
-
-
windSz = rbCb->m.umUl.umWinSz << 1;
umRecBuf = rbCb->m.umUl.recBuf;
{
RlcCb* dlInst = rlcCb[1];
RlcCb* ulInst = rlcCb[0];
- cmMemset((U8*)&gRlcStats, 0, sizeof(RLCStats));
- cmMemset((U8*)&dlInst->genSts,0,sizeof(RlcGenSts));
- cmMemset((U8*)&ulInst->genSts,0,sizeof(RlcGenSts));
+ memset(&gRlcStats, 0, sizeof(RLCStats));
+ memset(&dlInst->genSts,0,sizeof(RlcGenSts));
+ memset(&ulInst->genSts,0,sizeof(RlcGenSts));
}
#ifndef ALIGN_64BIT
{
datPerUe = datReqInfo->datReq[ueIdx];
- memset((uint8_t *)dlData, 0, sizeof(RlcData));
+ memset(dlData, 0, sizeof(RlcData));
dlData->cellId = datReqInfo->cellId;
dlData->rnti = datPerUe.rnti;
}
/* kw002.201 Removed the allocation of RlcDatReq */
/* kw004.201 Used SSI function to initialize the variable */
- cmMemset( (U8 *)&datReq, 0, sizeof(RlcDatReq) );
+ memset(&datReq, 0, sizeof(RlcDatReq) );
totNumPdu = 0;
for (numTb = 0; numTb < staInd->nmbOfTbs; numTb++)
{
CmLList *firstSduSnMap; /* First Node in SDU SnMap Queue */
RlcSduSnMap *sduSnMap; /* SDU Sn Map */
- TRC2(rlcUtlEmptySduQ)
sduSnMapQ = NULLP;
firstSduSnMap = NULLP;
sduSnMap = NULLP;
RlcDlRbCb *rbCb;
#endif
{
- TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = TRUE;
RlcDlRbCb *rbCb;
#endif
{
- TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = FALSE;
}
{
U32 rbIdx;
- TRC2(rlcDlUtlSetReestInProgressForAllRBs)
-
for(rbIdx = 0;rbIdx < RLC_MAX_SRB_PER_UE;rbIdx++)
{
if(ueCb->srbCb[rbIdx] != NULLP)
RlcSn mTxNext; /* send state variable */
RlcTx *txBuf;
- TRC2(rlcUtlFreeDlAmRbMemory)
-
-
MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
/* TODO : to be checked changed from <= to < */
gCb->u.dlCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- cmMemset((U8 *)&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
+ memset(&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
}
gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_DISC].measCb.measType = LKW_L2MEAS_DL_DISC;
gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_IP].measCb.measType = LKW_L2MEAS_DL_IP;
U8 currTbIdx;
VOLATILE U32 startTime = 0;
RlcContSduLst *dstContSduLst;
- TRC2(rlcUtlUpdateBurstSdus)
/*starting Task*/
RlcL2MeasTb *curL2MeasTb;
U16 idx;
- TRC3(rlcUtlGetCurMeasTb)
-
if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
{
/* Intentionally avoiding the RLC_ALLOC macro to avoid memset */
VOLATILE U32 startTime = 0;
/*kw005.201 Code added for DL IP thruput measurement*/
- TRC3(rlcUtlProcHarqInd)
-
/*starting Task*/
SStartTask(&startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
U32 cfmIdx =0;
/* Discard new changes ends */
- TRC3(rlcUtlSndL2MeasCfm)
-
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
/* Clean up the RB data structures */
measCb = &measEvtCb->measCb;
- cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
+ memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
measCfmEvt.transId = measEvtCb->transId;
measCfmEvt.measType = measCb->measType;
RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
- TRC3(rlcUtlSndDlL2MeasNCfm)
RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
return ROK;
U32 hashKey;
CmLListCp *txBufLstCp;
- TRC3(rlcUtlDelTxBuf)
-
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
U32 hashKey;
CmLListCp *txBufLstCp;
- TRC3(rlcUtlRemovTxBuf)
-
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
gCb->u.ulCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- cmMemset((U8 *)&(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
+ memset(&(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
}
gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
return ROK;
#endif
{
VOLATILE U32 startTime = 0;
- TRC2(rlcUtlCalUlIpThrPutIncTTI)
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
{
MsgLen rlcSduSz = 0; /*Holds length of Rlc Sdu*/
VOLATILE U32 startTime = 0;
- TRC2(rlcUtlCalUlIpThrPut)
-
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCVOL);
RlcL2MeasEvtCb *measEvtCb;
#endif
{
- TRC3(rlcUtlHdlL2TmrExp)
#ifdef LTE_L2_MEAS_RLC
U16 qciIdx;
U32 cfmIdx =0;
/* Discard new changes ends */
- TRC3(rlcUtlSndUlL2MeasCfm)
-
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
/* Clean up the RB data structures */
measCb = &measEvtCb->measCb;
- cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
+ memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
measCfmEvt.transId = measEvtCb->transId;
measCfmEvt.measType = measCb->measType;
RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
- TRC3(rlcUtlSndUlL2MeasNCfm)
RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
return ROK;
U8 msbNibble = 0;
U8 numFaild = 0;
-
- TRC3(rlcUtlValidateL2Meas)
-
idx = 0;
rbCb = NULLP;
ret = ROK;
U8 lsbNibble = 0;
U8 msbNibble = 0;
- TRC3(rlcUtlValidateIpThL2Meas)
-
measType = measReqEvt->measReq.measType;
/* Check for the range of measType */
/* LKW_L2MEAS_DL_IP+ LKW_L2MEAS_UL_IP = 0x0030*/
U8 measType;
#endif
{
- TRC3(rlcUtlPlcMeasDatInL2Sts)
-
/* We should check the number of measType in the request. This can be done
* by looking at each bit in the measType. Also store the measData in the
* correct index of l2Sts in RbCb.
mLen = 0;
SFndLenMsg(mBuf, &mLen);
- cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
+ memset(&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
/* initialize locals */
cnt = 0;
- cmMemset(revPkArray, 0, CM_IPV4_HDRLEN);
- cmMemset(pkArray, 0, CM_IPV4_HDRLEN);
+ memset(revPkArray, 0, CM_IPV4_HDRLEN);
+ memset(pkArray, 0, CM_IPV4_HDRLEN);
/* Pack Header Version */
pkArray[cnt++] = ipv4Hdr.hdrVer;
RgMngmt cfm;
Inst inst = (pst->dstInst - SCH_INST_START); /* Scheduler instance Id */
- TRC3(RgMiLrgSchCntrlReq)
-
/* Fill the post structure for sending the confirmation */
SchFillCfmPst(pst, &cfmPst, cntrl);
SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt));
return ROK;
} */
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
#ifdef LMINT3
cfm.hdr.transId =
err.errType = 0;
err.errCause = 0;
- TRC3(RgMiLrgSchL2MeasReq)
-
/* Find the cellCb using cellId in measInfo. Iterate through all cells
* in rgrsapCb in RgschCb */
LrgSchMeasCfmInfo measCfm;
U8 idx;
-
- TRC3(RgMiLrgSchL2MeasStopReq)
-
-
for (idx = 0; idx < instCb->numSaps; idx++)
{
if ( instCb->rgrSap[idx].cell->cellId == measInfo->cellId)
"Stop req Failed.Invalid Cell Id ");
return RFAILED;
}
- cmMemset((U8 *)&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
node = cell->l2mList.first;
while(node != NULLP)
{
{
RgInfL2MeasStopReq measStopReq;
Pst pstMac;
- cmMemset((U8 *)&measStopReq, 0, sizeof(RgInfL2MeasStopReq));
+ memset(&measStopReq, 0, sizeof(RgInfL2MeasStopReq));
measStopReq.transId = measInfo->hdr.transId;
measStopReq.measType = measInfo->measType;
/* measReq.timePrd = measInfo->timePrd; */
RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)];
U8 idx;
- TRC3(RgMiLrgSchL2MeasSendReq)
-
-
-
cell = NULLP;
for (idx = 0; idx < instCb->numSaps; idx++)
{
{
RgInfL2MeasSndReq measSndReq;
Pst pstMac;
- cmMemset((U8 *)&measSndReq, 0, sizeof(RgInfL2MeasSndReq));
+ memset(&measSndReq, 0, sizeof(RgInfL2MeasSndReq));
measSndReq.transId = measInfo->hdr.transId;
measSndReq.measType = measInfo->measType;
measSndReq.timePrd = measInfo->timePrd;
Inst instId = pst->dstInst-SCH_INST_START;
RgUstaDgn dgn; /* Alarm diagnostics structure */
- TRC3(RgUiRgrBndReq)
-
-
tmpPst.prior = pst->prior;
tmpPst.route = pst->route;
tmpPst.selector = pst->selector;
#endif
{
Inst instId = pst->dstInst-SCH_INST_START;
- TRC3(RgUiRgrUbndReq)
-
/* SAP Id validation */
if (spId < rgSchCb[instId].numSaps)
U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
Inst instId = pst->dstInst-SCH_INST_START;
- TRC2(RgUiRgrSiCfgReq);
-
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
U8 cfmStatus = RGR_CFG_CFM_NOK;
U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
- TRC2(RgUiRgrWarningSiCfgReq);
-
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
{
Inst instId = pst->dstInst-SCH_INST_START;
- TRC3(RgUiRgrWarningSiStopReq)
-
-
-
if (spId < rgSchCb[instId].numSaps)
{
if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState)
U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
Inst instId = pst->dstInst-SCH_INST_START;
- TRC2(RgUiRgrLoadInfReq);
-
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
Inst inst = (pst->dstInst - SCH_INST_START);
S16 cellSapId = boRpt->cellSapId;
- TRC3(RgMacSchDedBoUpdtReq)
/*
RLOG_ARG2(L_DEBUG,DBG_CELLID,boRpt->cellId,"rgMacSchDedBoUpdtReq():"
" boRpt->rnti = %u boRpt->lcId = %u",boRpt->rnti, boRpt->lcId);
Inst inst = (pst->dstInst - SCH_INST_START);
S16 cellSapId = boRpt->cellSapId;
- TRC3(RgMacSchCmnBoUpdtReq)
/* No need to chk for cell being NULL as MAC would not have found instance if
* it doesnt exist */
CmLList *tmp;
RgSchRntiLnk *rntiLnk=NULL;
- TRC3(RgMacSchUeDelInd)
-
if (rgSchCb[inst].rgrSap == NULLP || rgSchCb[inst].rgrSap[cellSapId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,ueDelInd->cellId,"rgrSap or cell is not configured");
U16 diffBits = 0;
U8 lcCount;
#endif
- TRC3(RgMacSchSfRecpInd)
/* No need to chk for cell being NULL as MAC wouldn't have found instance if
* it doesnt exist */
RgSchCellCb *cell;
Inst inst = (pst->dstInst - SCH_INST_START);
- TRC2(RgMacSchSpsRelInd);
/* No need to chk for cell being NULL as MAC wouldn't have found instance if
* it doesnt exist */
U8 qciVal;
U8 idx1; /*LTE_L2_MEAS_PHASE2*/
U8 qciVal1;
- TRC2(RgMacSchL2MeasCfm);
/* Find the cellCb using cellId in measInfo. Iterate through all cells
* in rgrsapCb in RgschCb */
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb, sizeof(RgSchL2MeasCb));
- cmMemset((U8 *)&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ memset(&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
schMeasCfm.measType = measCfm->measType;
schMeasCfm.cfm = measCfm->cfm;
schMeasCfm.hdr.transId = measCfm->transId;
Inst inst = (pst->dstInst - SCH_INST_START);
RgSchCb *instCb = &rgSchCb[inst];
- TRC2(RgMacSchL2MeasStopCfm);
-
- cmMemset((U8 *)&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ memset(&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
schMeasCfm.measType = measCfm->measType;
schMeasCfm.cfm = measCfm->cfm;
schMeasCfm.hdr.transId = measCfm->transId;
RgSchLowSapCb *tfuSap;
Inst instId = pst->dstInst - SCH_INST_START;
- TRC3(RgLiTfuSchBndCfm);
-
-
if(suId >= rgSchCb[instId].numSaps)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId, "Incorrect SuId");
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuRaReqInd);
-
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_INSTID,inst,"SAP Validation failed SuId(%d)", suId);
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuUlCqiInd);
-
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuPucchDeltaPwrInd);
-
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
S16 ret;
Inst inst = (pst->dstInst - SCH_INST_START);
- TRC3(RgLiTfuHqInd);
#ifndef NO_ERRCLS
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuSrInd);
-
#ifndef NO_ERRCLS
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuDlCqiInd);
-
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst," SAP Validation failed");
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuRawCqiInd);
-
#ifdef NO_ERRCLS
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuSrsInd);
-
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst," SAP Validation failed");
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC2(RgLiTfuDoaInd);
-
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuCrcInd);
#ifdef XEON_SPECIFIC_CHANGES
struct timeval start6, end6;
gettimeofday(&start6, NULL);
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuTimingAdvInd);
-
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
Pst tmpPst; /* Temporary Post Structure */
Inst instId = pst->dstInst-SCH_INST_START;
- TRC3(RgUiRgmBndReq)
-
-
tmpPst.prior = pst->prior;
tmpPst.route = pst->route;
tmpPst.selector = pst->selector;
#endif
{
Inst instId = pst->dstInst-SCH_INST_START;
- TRC3(RgUiRgmUbndReq)
-
/* SAP Id validation */
if (spId < rgSchCb[instId].numSaps)
RgSchPrbUsage *prbUsage;
Inst inst = (pst->dstInst - SCH_INST_START);
- TRC2(RgUiRgmCfgPrbRprt);
cell = rgSchCb[inst].rgmSap[spId].cell;
prbUsage = &cell->prbUsage;
prbUsage->prbRprtEnabld = prbRprtCfg->bConfigType;
RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, prbUsage->startTime, 1);
/* clear the qciPrbRpts for all GBR QCIs */
- cmMemset((U8*)&prbUsage->qciPrbRpts[0], 0,
+ memset(&prbUsage->qciPrbRpts[0], 0,
(RGM_MAX_QCI_REPORTS * sizeof(RgSchQciPrbUsage)));
RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
Inst inst = (pst->dstInst - SCH_INST_START);
#endif
- TRC3(RgLiTfuErrInd);
-
#ifndef NO_ERRCLS
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrSchedEnbCfg);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "VALIDATE RGR SCH ENB CONFIG: \n"));
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_ENB_CFG;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CELL_CFG;
/* check if cell exists already */
RgrSchedCfg *rgSchedCfg;
#endif
{
- TRC2(rgSCHCfgVldtRgrSchCfg);
-
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "rgSCHCfgVldtRgrSchCfg:Validating \
scheduler related Configuration"));
if (rgSchedCfg->ulSchdType > (RGSCH_NUM_SCHEDULERS - 1))
RgrCellCfg *cellCfg;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellSchCfg);
#if RGSCH_NUM_DLFS_SCHEDULERS
if (cellCfg->dlfsSchdType > RGSCH_NUM_DLFS_SCHEDULERS - 1)
RgrCellCfg *cellCfg;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellRACfg);
-
#ifdef LTE_TDD
if ((cellCfg->rachCfg.preambleFormat > RGSCH_MAX_TDD_RA_PREAMBLE_FMT) ||
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrUeCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_CFG;
if (((*cell) == NULLP) ||
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CELL_RECFG;
RgrUePrdDlCqiCfg *pCqiCfg;
#endif
- TRC2(rgSCHSCellCfgUeCfg);
-
RLOG0(L_INFO, "SCELL recfg received from APP \n");
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
RgrUeSCellAckPucchCfg *sCellPucchRecfg = NULLP;
U8 idx;
- TRC2(rgSCHSCellCfgUePucchReCfg);
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
"--------------------------------------------------------------------\n"
"UE SCell PUCCH ReConfiguration at SCH: rnti (%u) cell(%u)\n"
RgSchCellCb *sCell = NULLP;
Inst inst = cell->instIdx;
- TRC2(rgSCHCfgVldtRgrUeSCellRecfg);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "VALIDATE RGR UE SCELL RECONFIG: cellId %d "
"oldUeId %d cell %p \n", ueRecfg->cellId, ueRecfg->oldCrnti));
RgSchUeCellInfo *sCellInfo = NULLP;
RgSchCmnCell *cellSch = NULLP;
- TRC2(rgSCHSCellCfgUeCfgRollBack);
-
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
"--------------------------------------------------------------------\n"
"UE SCell config roll back at SCH: rnti (%u) cell(%u)\n"
#endif
{
- TRC2(rgSCHCfgVldtRgrUeRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_RECFG;
if (((*cell) == NULLP) ||
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLchRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LC_RECFG;
if (((*cell) == NULLP) ||
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrUeReset);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_RESET;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLcgRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LCG_RECFG;
if (((cell) == NULLP) ||
U16 numDlSf;
#endif
- TRC2(rgSCHDynCfiCfg);
-
cell->dynCfiCb.isDynCfiEnb = cellCfg->isDynCfiEnb;
/* Initializing Failure Sample Period */
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgRgrSchedEnbCfg);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "APPLYING RGR SCH ENB CONFIG: \n"));
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_ENB_CFG;
{
U8 idx;
- TRC2(rgSCHCfgRgrCellCfg);
-
for(idx = 0; idx < MAX_5GTF_GROUP; idx++)
{
cell->cell5gtfCb.ueGrp5gConf[idx].beamBitMask = 0;
Inst inst = instCb->rgSchInit.inst;
U32 Idx1 = (U8)((cellCfg->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
- TRC2(rgSCHCfgRgrCellCfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_CFG;
- cmMemset((U8*)&pst, (U8)0, sizeof(Pst));
+ memset(&pst, 0, sizeof(Pst));
/* Allocate the scheduler's cell control block */
if((ret = rgSCHUtlAllocSBuf(inst, (Data**)&cell, sizeof(RgSchCellCb)))
{
cell->lteAdvCb.absCfg =
cellCfg->rgrLteAdvCfg.absCfg;
- cmMemset((U8*)cell->lteAdvCb.absLoadInfo, 0, sizeof(U32)*RGR_ABS_PATTERN_LEN);
+ memset(cell->lteAdvCb.absLoadInfo, 0, sizeof(U32)*RGR_ABS_PATTERN_LEN);
cell->lteAdvCb.absLoadTtiCnt = 0;
}
cell->t300TmrVal = cellCfg->t300TmrVal;
#ifdef RGR_SI_SCH
/*Initialize the SI CB in Cell CB */
- cmMemset((U8 *)&cell->siCb, 0, sizeof(RgSchSiCb));
+ memset(&cell->siCb, 0, sizeof(RgSchSiCb));
#endif
/*Fix: Added Guard Pool for RNTI which will contain RNTIs
*for UEs deleted from Scheduler but not yet from MAC*/
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = NULLP;
#endif
- TRC2(rgSCHCfgRgrUeCfg);
do {
errInfo->errCause = RGSCHERR_CFG_RGR_UE_CFG;
#endif
{
- TRC2(rgSCHCfgRgrUePhrMsg3);
-
/* Record msg3 allocation in the UE */
rgSCHUtlRecMsg3Alloc(cell, ue, raCb);
U8 idx;
RgSchCmnDlCell *cellSchDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHDynCfiReCfg);
-
if(isDynCfiEnb)
{
cell->dynCfiCb.ttiCnt = 0;
U16 len; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
/* LTE_ADV_FLAG_REMOVED_END */
- TRC2(rgSCHCfgRgrCellRecfg);
-
-
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_RECFG;
/* Invoke scheduler to update scheduler specific information */
}
if(cellRecfg->rgrLteAdvCfg.pres & RGR_SFR)
{
- cmMemcpy((U8 *)&cell->lteAdvCb.sfrCfg, (U8 *)&cellRecfg->rgrLteAdvCfg.sfrCfg,
+ memcpy(&cell->lteAdvCb.sfrCfg, &cellRecfg->rgrLteAdvCfg.sfrCfg,
sizeof(RgrSfrConfig));
/* dsfr_pal_fixes ** 21-March-2013 ** SKS */
if (cellRecfg->rgrLteAdvCfg.sfrCfg.status == RGR_ENABLE)
RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
U8 idx;
- TRC2(rgSCHCfgRgrUeRecfgRntiChg);
-
/* Handle CRNTI change in reconfiguration */
if (ueRecfg->oldCrnti != ueRecfg->newCrnti)
{
Bool dciChange = TRUE;
#endif
- TRC2(rgSCHCfgRgrUeRecfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_UE_RECFG;
#ifdef LTE_ADV
{
S16 ret = ROK;
- TRC2(rgSCHCfgRgrLchRecfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_LC_RECFG;
/* Invoke Scheduler to update the new configuration */
ret = rgSCHUtlRgrLcRecfg(cell, ue, dlLc, lcRecfg, errInfo);
{
S16 ret = ROK;
- TRC2(rgSCHCfgRgrLcgRecfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_LCG_RECFG;
/*Added for handling LCG ReConfig if the LCG was deleted */
U32 idx;
RgSchRaCb *raCb;
- TRC2(rgSCHCfgRgrUeReset);
-
-
errInfo->errCause = RGSCHERR_CFG_RGR_UE_RESET;
/* Setting BO of Each Logical Channel of the UE to 0 */
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgRgrCellDel);
-
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_DEL;
RgSchCellCb *secCellCb = NULLP;
#endif
- TRC2(rgSCHCfgRgrUeDel);
errInfo->errCause = RGSCHERR_CFG_RGR_UE_DEL;
if (cell->cellId != ueDelInfo->u.ueDel.cellId)
RgSchUlLcCb *ulLc;
#endif
- TRC2(rgSCHCfgRgrLcDel);
-
errInfo->errCause = RGSCHERR_CFG_RGR_LC_DEL;
/* Fetch the Active cell */
#endif
U8 lcgId = 0;
- TRC2(rgSCHCfgRgrLcgDel);
-
-
lcgId = lcDelInfo->u.lcgDel.lcgId;
errInfo->errCause = RGSCHERR_CFG_RGR_LCG_DEL;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLcCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LC_CFG;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLcgCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LCG_CFG;
UNUSED(cellCfg);
UNUSED(errInfo);
- TRC2(rgSCHCfgVldtRgrCellPwrCfg);
-
/* This function does nothing now, placeholder for
* subsequent power config validations that may be needed */
U8 bitMask = 0x00;
U8 cnt=0;
- TRC2(rgSCHCfgVldtRgrCmnLcCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CMN_LC_CFG;
for (idx = 0; idx < cellCfg->numCmnLcs; idx++)
#endif
{
- TRC2(rgSCHCfgVldtUeCqiModeCfg)
-
#ifndef TFU_UPGRADE
if((ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx < 1) ||
(ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx > 1024))
#endif
{
- TRC2(rgSCHCfgVldtUeMeasGapAckNakRepCfg)
-
#ifdef LTE_TDD
if ((ueCfg->ackNackModeEnum == RGR_TDD_ACKNACK_MODE_MULT) &&
(ueCfg->ueAckNackCfg.isAckNackEnabled == TRUE))
#endif
{
- TRC2(rgSCHCfgVldtUeMeasGapAckNakRepRecfg)
if((ueRecfg->ueAckNackRecfg.isAckNackEnabled == FALSE) &&
(!ueRecfg->ueMeasGapRecfg.isMesGapEnabled))
{
U8 idx = 0;
- TRC2(rgSCHCfgVldtUeDlSpsCfg);
-
/* peridicity validation done in SPS module */
if ((dlSpsCfg->numPucchVal > RG_SCH_MAX_NUM_N1PUCCH_PER_UE) ||
(dlSpsCfg->numPucchVal == 0))
#endif
{
- TRC2(rgSCHCfgVldtUePwrCfg);
-
/* Group power control works only in accumulated mode */
if (!pwrCfg->isAccumulated)
{
#endif
{
- TRC2(rgSCHCfgVldtUeGrpPwrCfg);
-
if ((grpPwrCfg->pres) &&
(((grpPwrCfg->tpcRnti > cell->rntiDb.rntiStart) &&
((grpPwrCfg->tpcRnti <
#endif
{
- TRC2(rgSCHCfgVldtSpsReCfg);
if ((ueRecfg->ueRecfgTypes & RGR_UE_DLSPS_RECFG) &&
(ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled))
{
#endif
{
- TRC2(rgSCHCfgVldtCqiReptReCfg);
/* Validate DL Power Control Config parameters */
if (ueRecfg->ueCqiReptCfg.numColltdCqiRept > RGR_CQIRPTS_MAXN)
{
RgSchUlLcCb *ulLc;
#endif
- TRC2(rgSCHCfgRgrLchCfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_DED_LC_CFG;
/* Allocate the downlink logical channel control block */
U32 idx;
RgSchUlLcCb *ulLc;
#endif
- TRC2(rgSCHCfgRgrLcgCfg);
errInfo->errCause = RGSCHERR_CFG_RGR_DED_LCG_CFG;
#endif
{
RgSchClcDlLcCb cmnLcCb;
- TRC2(rgSCHCfgRgrCmnLcCfg);
errInfo->errCause = RGSCHERR_CFG_RGR_CMN_LC_CFG;
- cmMemset((U8 *)&cmnLcCb, 0, sizeof(cmnLcCb));
+ memset(&cmnLcCb, 0, sizeof(cmnLcCb));
/* Handle configuration for CCCH/BCCH/PCCH */
if (lcCfg->lcType == CM_LTE_LCH_CCCH)
#endif
{
Inst inst = cell->instIdx;
- TRC2(rgSCHCfgFreeDlDedLcCb);
rgSCHUtlFreeDlLc(cell, ue, dlLc);
RgSchClcDlLcCb *cmnDlLc;
#endif
{
- TRC2(rgSCHCfgFreeDlCmnLcCb);
- cmMemset((U8*)cmnDlLc, 0, sizeof(*cmnDlLc));
+ memset(cmnDlLc, 0, sizeof(*cmnDlLc));
cmnDlLc->lcId = RGSCH_INVALID_LC_ID;
RETVOID;
} /* rgSCHCfgFreeDlCmnLcCb */
RgSchWarningSiPdu *warningSiPdu;
U8 idx;
- TRC2(rgSCHCfgFreeCellCb);
/* ccpu00132385- SI Warning PDUs which are not processed need to be deleted */
/* Search for used index in WarningSi */
for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
Inst inst = cell->instIdx;
U8 lcCnt;
U8 lcgId;
- TRC2(rgSCHCfgFreeUeCb);
/* Free all logical channel info per UE */
while((dlLc = rgSCHDbmGetNextDlDedLcCb(ue, NULLP)) != NULLP)
RgSchCfgElem *rgCfgElem;
Inst inst = cell->instIdx;
- TRC2(rgSCHCfgFreeRgrCfgLst);
-
/* Free CURRENT RGR cfg list */
while ((rgCfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
{
{
RgSchClcDlLcCb *dlCmnLc;
- TRC2(rgSCHCfgFreeCmnLcLst);
if ((dlCmnLc = rgSCHDbmGetBcchOnBch(cell)) != NULLP)
{
RgSchUeCellInfo *sCellInfo;
CmLList *node;
#endif
- TRC2(rgSCHCfgFreeUeLst);
/* Free Ues in the list */
while ((ue = rgSCHDbmGetNextUeCb(cell, NULLP)) != NULLP)
{
RgSchUeCb *ue;
- TRC2(rgSCHCfgFreeSpsUeLst);
-
/* Free Ues in the list */
while ((ue = rgSCHDbmGetNextSpsUeCb(cell, NULLP)))
{
UNUSED(inst);
- TRC2(rgSCHCfgVldtRgrCellSiCfg);
-
-
#ifndef LTE_TDD
/* Check that retxCnt value should be <= value of siWinSize.
This validation is only applicable for FDD mode. */
U32 idx;
UNUSED(inst);
- TRC2(rgSCHCfgVldtRgrCellLteAdvCfg);
-
-
if((lteAdvCfg->pres & RGR_SFR) && (RGR_ENABLE == lteAdvCfg->sfrCfg.status))
{
if(lteAdvCfg->sfrCfg.cellEdgeRbRange.startRb > lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb)
return RFAILED;
}
- cmMemcpy(temp, (U8 *) lteAdvCfg->absCfg.absPattern,RGR_ABS_PATTERN_LEN);
+ memcpy(temp, lteAdvCfg->absCfg.absPattern,RGR_ABS_PATTERN_LEN);
/* Added validation for ABS pattern len */
for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
#endif
{
- TRC2(rgSCHCfgVldtRgrCellCsgParamCfg);
-
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "Validating CSG Parameters \n"));
if(csgParam->minDlResNonCsg > 100)
MsgLen msgLen = 0;
U8 numSi;
- TRC2(rgSCHCfgVldtRgrSiCfg);
-
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_SI_CFG;
/*Validate the cfgType parameter */
#endif
{
- TRC2(rgSCHCfgVldtRgrLoadInf);
-
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LOAD_INF;
/* Validate if the CC startRb which we have received from DSFR lies in CE sub-band of the receiving eNB */
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrTxmodePuschMode);
-
if (txMde == RGR_UE_TM_1 || txMde == RGR_UE_TM_2 ||
txMde == RGR_UE_TM_3 || txMde == RGR_UE_TM_7)
{
RgrTxMode txMde;
RgrAprdCqiMode puschMode;
- TRC2(rgSCHCfgVldtRgrUeACqiCfg);
-
if(acqiCfg->pres)
{
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrTxmodePucchMode);
-
if (pucchMode == RGR_PRD_CQI_MOD10 || pucchMode == RGR_PRD_CQI_MOD20 )
{
RgrTxMode txMde;
RgrPrdCqiMode pucchMode;
- TRC2(rgSCHCfgVldtRgrUePCqiCfg);
-
txMde = RGR_UE_TM_1;
pucchMode = RGR_PRD_CQI_MOD20;
if ( RGR_SCH_PCQI_SETUP == cqiCfg->type )
U16 srsOffset=0;
U8 srsSubframe=0;
- TRC2(rgSCHCfgVldtRgrUeUlSrsCfg);
-
-
if ( RGR_SCH_SRS_SETUP == srsCfg->type )
{
#endif
{
- TRC2(rgSCHCfgVldtRgrUeSrCfg);
-
-
-
if ( RGR_SCH_SR_SETUP == srCfg->type )
{
/* 1. Validate SR Configuration related parameter values */
#endif
{
- TRC2(rgSCHCfgVldtCqiSrSrsUeCfg);
-
-
/* 1. Validate UE Aperiodic CQI related parameters */
if ( ROK != rgSCHCfgVldtRgrUeACqiCfg (cellCb, ueCfg->crnti,
&ueCfg->ueDlCqiCfg.aprdCqiCfg, ueCfg->txMode, errInfo ))
#endif
{
RgrUeTxModeCfg txMode;
- TRC3(rgSCHCfgVldtCqiSrSrsUeReCfg);
txMode.pres = TRUE;
txMode.tmTrnstnState = RGR_TXMODE_RECFG_CMPLT;
U8 cqiPmiSzR1; /*CQIPMI Size for Rank =1*/
U8 cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
- TRC3(rgSCHCfgACqiUeCfg);
-
cqiPmiSzR1 = 0;
cqiPmiSzRn1 = 0;
U8 temp;
U8 loop;
RgSchUePCqiCb *cqiCb = NULLP;
- TRC3(rgSCHCfgPCqiUeCfg);
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)+
(cellCb->crntTime.slot);
ueCb->rawCqiBitW[loop].type = TFU_RECP_REQ_INVLD; /* setting invalid type*/
}
/* 1. Copy the Received CQI Cfg parameters to ueCb */
- cmMemcpy((U8 *)&cqiCb->cqiCfg, (U8 *)cqiCfg,
+ memcpy(&cqiCb->cqiCfg, cqiCfg,
sizeof(RgrUePrdDlCqiCfg));
/* 2. Compute Periodic CQI Periodicity and subframe offset */
U16 tempIdx;
RgSchUePCqiCb *cqiCb = NULLP;
- TRC3(rgSCHCfgRiUeCfg);
-
-
-
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cellCb->crntTime.slot);
cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
U16 crntTime;
U16 tempIdx;
- TRC3(rgSCHCfgSrsUeCfg);
-
-
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cellCb->crntTime.slot);
if(RGR_SCH_SRS_SETUP == srsCfg->type)
{
/* 1. Copy the Received Cfg parameters to local cb */
- cmMemcpy((U8 *)&ueCb->srsCb.srsCfg, (U8 *)srsCfg, sizeof(RgrUeUlSrsCfg));
+ memcpy(&ueCb->srsCb.srsCfg, srsCfg, sizeof(RgrUeUlSrsCfg));
#ifndef LTE_TDD
/* 2. Compute SRS Offset and Periodicity */
U16 srTrInsTime;
U16 crntTime;
- TRC3(rgSCHCfgSrUeCfg);
-
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cellCb->crntTime.slot);
if(srCfg->type == RGR_SCH_SR_SETUP)
{
/* 1. Copy the Received Cfg parameters to local cb */
- cmMemcpy((U8 *)&ueCb->srCb.srCfg, (U8 *)srCfg, sizeof(RgrUeSrCfg));
+ memcpy(&ueCb->srCb.srCfg, srCfg, sizeof(RgrUeSrCfg));
/* 2. Compute SR periodicity and offset */
{
RgSchUePCqiCb *cqiCb = NULLP;
- TRC3(rgSCHCfgPCqiUeReCfg);
cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
/* Fix: ccpu00124008 Fix for incorrect check causing missed CQI reception instance */
#endif
{
- TRC3(rgSCHCfgSrsUeReCfg);
-
-
if(( RGR_SCH_SRS_SETUP == srsCfg->type) ||
( RGR_SCH_SRS_SETUP != ueCb->srsCb.srsCfg.type ))
RgrUeSrCfg *srCfg;
#endif
{
- TRC3(rgSCHCfgSrUeReCfg);
-
/* Fix : syed Incorrect check for SR RECFG */
if((srCfg->type == RGR_SCH_SR_SETUP) &&
CmLteUeCategory ueCat;
#endif
{
- TRC3(rgSCHCfgAcqiUeReCfg);
return (rgSCHCfgACqiUeCfg(cellCb,ueCb,(RG_SCH_CMN_GET_ACQICB(ueCb,cellCb))
,ueCb->mimoInfo.txMode, acqiCfg, ueCat));
U32 sCellCnt = 0;
#endif
RgSchUePCqiCb *cqiRiCb = NULLP;
- TRC3(rgSCHCfgPCqiSrsSrUeDel);
cqiRiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
U8 min = 0;
U8 max = 0;
CONSTANT RgSchUePCqiSrsSrCfgIdxTbl* table;
- TRC3(rgSCHUtlGetCfgPerOff);
/* Added the function instead of the MACRO to get the
* periodicity table */
U32 confRepMode;
-
- TRC3(rgSCHCfgUtlFetchAcqiBitSz);
-
confRepMode = acqiCb->aCqiCfg.aprdModeEnum;
switch(confRepMode)
{
#endif
{
CONSTANT RgSchUePCqiSrsSrCfgIdxTbl * table;
- TRC3(rgSCHCfgUtlGetPcqiCrsSrRiTbl);
switch (tblType)
{
RgrUeDrxCfg *ueDrxCfg;
#endif
{
- TRC2(rgSCHCfgVldtDrxUeCfg)
-
if (ueDrxCfg->isDrxEnabled == FALSE)
{
U8 onDurTmr;
#endif
{
- TRC2(rgSCHCfgVldtDrxOnDurCfg)
switch ( onDurTmr )
{
U16 inActvTmr;
#endif
{
- TRC2(rgSCHCfgVldtDrxInActvCfg)
-
switch ( inActvTmr )
{
case RGR_DRX_PRD_1PSF:
U8 reTxTmr;
#endif
{
- TRC2(rgSCHCfgVldtDrxReTxCfg)
-
switch ( reTxTmr )
{
case RGR_DRX_PRD_1PSF:
RgrDrxLongCycleOffst lngCycleOffst;
#endif
{
- TRC2(rgSCHCfgVldtDrxLngCycCfg)
-
if ( rgSCHCfgVldtDrxLngCyclTmrs(lngCycleOffst.longDrxCycle) != ROK )
{
return RFAILED;
U16 val;
#endif
{
- TRC2(rgSCHCfgVldtDrxLngCyclTmrs)
switch ( val )
{
RgrDrxShortDrx shrtCycCfg;
#endif
{
- TRC2(rgSCHCfgVldtDrxShrtCycCfg)
-
switch(shrtCycCfg.shortDrxCycle)
{
case RGR_DRX_PRD_2SF:
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHCfgUeTaRecfg)
-
UNUSED(err);
/* Update the TA related information */
#endif
{
S16 retVal;
- TRC3(rgSCHCfgUeCqiReptReCfg)
/* Check has it been disabled */
if(ueRecfg->ueCqiReptCfg.numColltdCqiRept)
RgSchUeCellInfo *sCellInfo = NULLP;
RgrUeSecCellCfg *sCellInfoRecfg = NULLP;
- TRC2(rgSCHSCellFreeBuf);
for(U8 i = 0; i <= idx; i++)
{
U8 resOfCrs; /* Effective REs occupied by CRS */
U8 i, j;
- TRC2(rgSCHCmnCompEff);
switch (cpType)
{
U8 noSymPerRb;
U8 i, j;
- TRC2(rgSCHCmnCompUlEff);
switch (cpType)
{
U8 resOfCrs; /* Effective REs occupied by CRS */
U8 i, j;
- TRC2(rgSCHCmn2LyrCompEff);
switch (cpType)
{
#endif
{
- TRC2(rgSCHCmnGetDciFrmtSizes);
/* DCI Format 0 size determination */
rgSchCmnDciFrmtSizes[0] = 1 +
U8 i;
U8 j;
- TRC2(rgSCHCmnGetCqiDciFrmt2AggrLvl);
for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
{
RgSchCmnTbSzEff *effTbl;
RgSchCmnCqiToTbs *tbsTbl;
- TRC2(rgSCHCmnDlInit);
/* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
/* Init Efficiency table for normal cyclic prefix */
CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
S16 i;
S16 j;
- TRC2(rgSCHCmnUlInit);
/* Initaializing new variable added for UL eff */
rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP] = &rgSchCmnNorUlEff[0];
#endif
{
U8 idx;
- TRC2(rgSCHCmnInit);
rgSCHCmnDlInit();
rgSCHCmnUlInit();
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *sf;
- TRC2(rgSCHCmnDlRlsSubFrm);
/* Get the pointer to the subframe */
sf = rgSCHUtlSubFrmGet(cell, frm);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCcchRarAlloc);
rgSCHCmnDlCcchRetx(cell, &cellSch->allocInfo);
/* LTE_ADV_FLAG_REMOVED_START */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnCcchSduAlloc);
/* Return if subframe BW exhausted */
if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduTx);
node = cell->ccchSduUeLst.first;
while(node)
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchTx);
node = cell->raInfo.toBeSchdLst.first;
while(node)
RgSchCmnDlUe *ueDl;
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduRetx);
node = cellSch->dl.ccchSduRetxLst.first;
while(node)
U8 retxBw = 0;
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchRetx);
node = cellSch->dl.msg4RetxLst.first;
while(node)
#endif/*RGR_SI_SCH*/
- TRC2(rgSCHCmnDlBcchPcch);
frm = cell->crntTime;
#ifdef LTEMAC_HDFDD
{
Bool inWin = FALSE;
- TRC2(rgSCHCmnChkInWin);
if (end.sfn > start.sfn)
{
CmLteTimingInfo refFrm = end;
Bool pastWin;
- TRC2(rgSCHCmnChkPastWin);
RGSCH_INCR_FRAME(refFrm.sfn);
RGSCH_INCR_SUB_FRAME(end, 1);
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnClcAlloc);
bo = (RgSchClcBoRpt *)(lch->boLst.first->node);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 numCce; /*store num CCEs based on
aggregation level */
- TRC2(rgSCHCmnCmnPdcchAlloc);
aggrLvl = cellSch->dl.cmnChAggrLvl;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi = cellSch->dl.currCfi;
U32 tmpRb=0;
- TRC2(rgSCHCmnClcRbAlloc);
/* first get the CQI to MCS table and determine the number of RBs */
effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnMsg4Alloc);
/* SR_RACH_STATS : MSG4 TO BE TXED */
rgNumMsg4ToBeTx++;
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
- TRC2(rgSCHCmnPdcchAlloc);
/* 3.1 consider the selected DCI format size in determining the
* aggregation level */
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnCcchSduDedAlloc);
rbAllocinfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnMsg4DedAlloc);
effBo = raCb->dlCcchInfo.bo + RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE;
U8 sfnIdx;
U8 subfrmIdx;
U16 rntiIdx=0;
- TRC2(rgSCHCmnDlRaRsp);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
U8 raIdx;
RgSchCmnCell *sched;
U8 i,noRaRnti=0;
- TRC2(rgSCHCmnDlRaRsp);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnRaRspAlloc);
#ifndef RGR_V1
UNUSED(cellUl);
#endif
U8 cfi = cellDl->currCfi;
- TRC2(rgSCHCmnUlAllocFillRbInfo);
alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) +
cell->dynCfiCb.bwInfo[cfi].startRb;
U8 iMcs;
U8 numSb;
- TRC2(rgSCHCmnMsg3GrntReq);
*ulAllocRef = NULLP;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi = cellSch->dl.currCfi;
- TRC2(rgSCHCmnDlSetUeAllocLmt);
#ifdef EMTC_ENABLE
if(TRUE == isEmtcUe)
U8 cqiBasediTbs;
U8 actualiTbs;
- TRC2(rgSCHCheckAndSetTxScheme);
maxiTbs = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
[RG_SCH_CMN_MAX_CQI - 1];
U8 maxiTbs;
U8 cwIdx = 0;
- TRC2(rgSCHCmnDlSetUeAllocLmtLa);
maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
if(ueDl->cqiFlag == TRUE)
#endif
{
- TRC2(rgSCHCmnDlHqPResetTemp);
/* Fix: syed having a hqP added to Lists for RB assignment rather than
* a UE, as adding UE was limiting handling some scenarios */
Void *tmpCb;
#endif
- TRC2(rgSCHCmnDlUeResetTemp);
/* Fix : syed check for UE's existence was useless.
* Instead we need to check that reset is done only for the
#ifdef LTE_ADV
tmpCb = allocInfo->laaCb;
#endif
- cmMemset((U8 *)allocInfo, (U8)0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo, 0, sizeof(RgSchDlRbAlloc));
allocInfo->rnti = ue->ueId;
#ifdef LTE_ADV
allocInfo->laaCb = tmpCb;
{
RgSchCmnUlUe *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlUeResetTemp);
- cmMemset((U8 *)&cmnUlUe->alloc, (U8)0, sizeof(cmnUlUe->alloc));
+ memset(&cmnUlUe->alloc, 0, sizeof(cmnUlUe->alloc));
RETVOID;
} /* rgSCHCmnUlUeResetTemp */
#endif
{
- TRC2(rgSCHCmnFillPdcch);
/* common channel pdcch filling,
* only 1A and Local is supported */
U8 dlSfCnt = 0;
U8 splfrmIdx = 0;
- TRC2(rgSCHCmnIsSplSubfrm);
if(splfrmCnt > 0)
{
{
RgSchUeCb *ue = hqP->hqE->ue;
- TRC2(rgSCHCmnUpdHqAndDai);
if(subFrm != NULLP)
{
U8 ackNackFdbkArrSize;
- TRC2(rgSCHCmnUpdDai);
if(hqP != NULLP)
{/* Non SPS */
RgSchDlHqTbCb *tbInfo = tbAllocInfo->tbCb;
RgSchDlHqProcCb *hqP = tbInfo->hqP;
- TRC2(rgSCHCmnFillHqPTb);
/*ccpu00120365-ADD-if tb is disabled, set mcs=0,rv=1.
* Relevant for DCI format 2 & 2A as per 36.213-7.1.7.2
#endif
{
- TRC2(rgSCHCmnFillHqPPdcchDciFrmtB1B2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
//Currently hardcoding values here.
RgSchPdcch *pdcch = rbAllocInfo->pdcch;
U8 tpc = 1;
- TRC2(rgSCHCmnFillHqPPdcch);
if (hqP->hqE->ue)
{
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1Info.tpcCmd = tpc;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1B)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1bInfo.tpcCmd = tpc;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnInitVars);
cellUl->idx = RGSCH_INVALID_INFO;
cellUl->schdIdx = RGSCH_INVALID_INFO;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
U16 idx;
- TRC2(rgSCHCmnUpdVars);
idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
cellUl->idx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
U16 sfn;
U8 subframe;
- TRC2(rgSCHCmnGetPhichUlSfIdx);
dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
U8 idx = 0;
U16 numUlSf;
- TRC2(rgSCHCmnGetUlSfIdx);
/* ccpu00130980: numUlSf(U16) parameter added to avoid integer
* wrap case such that idx will be proper*/
U8 numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
/* TRACE 5 Changes */
- TRC2(rgSCHCmnGetUlHqProcIdx);
/* Calculate the number of UL SF in one SFN */
numUlSfInSfn = RGSCH_NUM_SUB_FRAMES -
#endif
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
RgSchDlSf *sf;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnPdcchAllocCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillNdmrs);
alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
RETVOID;
}
Bool isRetx;
#endif
{
- TRC2(rgSCHCmnUlAllocLnkHqProc);
if(TRUE == isRetx)
{
CmLteTimingInfo frm = cell->crntTime;
RgSchDlSf *sf;
- TRC2(rgSCHCmnPdcchRlsCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
#endif
{
- TRC2(rgSCHCmnUlFillPdcchWithAlloc);
pdcch->ue = ue;
pdcch->rnti = alloc->rnti;
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillTpc);
alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
RETVOID;
}
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnAddUeToRefreshQ);
UNUSED(cell);
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
RgSchCmnLcg *lcgCmn;
CmLList *node;
RgSchCmnAllocRecord *allRcd;
- TRC2(rgSCHCmnUlUeReset);
ue->ul.minReqBytes = 0;
ue->ul.totalBsr = 0;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnResetRiCqi);
rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd,
cell->isCpUlExtend);
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlUeReset);
if (ueDl->rachInfo.poLnk.node != NULLP)
{
Pst pst;
RgInfResetHqEnt hqEntRstInfo;
- TRC2(rgSCHCmnUeReset);
/* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
rgSCHCmnDelRachInfo(cell, ue);
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtUlUe);
/* : take care of this in UL retransmission */
cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtDlUe);
cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
RETVOID;
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHCmnHdlUlTransInd);
/* Update the latest UL dat/sig transmission time */
RGSCHCPYTIMEINFO(timingInfo, ue->ul.ulTransTime);
#endif
{
U32 bitMap0, bitMap1;
- TRC2(rgSCHCmnComp4TxMode4);
bitMap0 = pmiBitMap[0];
bitMap1 = pmiBitMap[1];
if((bitMap1) & 0xFFFF)
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode4);
bitMap0 = pmiBitMap[0];
if((bitMap0>>26)& 0x0F)
{
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp4TxMode3);
bitMap0 = pmiBitMap[0];
if((bitMap0>>28)& 1)
{
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode3);
bitMap0 = pmiBitMap[0];
if((bitMap0>>30)& 1)
{
U8 numTxPorts;
#endif
{
- TRC2(rgSCHCmnComputeRank);
if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
{
U8 cnt;
S16 ret;
- TRC2(rgSCHCmnDlDeInitHqEnt);
ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
/* Free only If the Harq proc are created*/
U8 cnt;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlInitHqEnt);
for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
{
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnGetRefreshDist);
for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
{
U32 refreshPer;
U32 crntSubFrm;
- TRC2(rgSCHCmnGetRefreshPer);
refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
crntSubFrm = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot;
Inst inst = ue->cell->instIdx;
#endif
U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
- TRC2(rgSCHCmnRgrSCellUeCfg);
pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
pCellUeDl = &pCellUeSchCmn->dl;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
Inst inst = ue->cell->instIdx;
- TRC2(rgSCHCmnRgrSCellUeDel);
cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
RgrUeCfg *cfg;
#endif
{
- TRC2(rgSCHCmnRgrUeCfg);
RgSchUeGrp *ue5gtfGrp;
ue->ue5gtfCb.grpId = cfg->ue5gtfCfg.grpId;
U32 waitPer;
U32 idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
- TRC2(rgSCHCmnRgrUeCfg);
/* 1. Allocate Common sched control block */
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlHdlTxModeRecfg);
if (ueRecfg->txMode.pres != PRSNT_NODEF)
{
RgSchCmnCell *cellSchd;
#endif
{
- TRC2(rgSCHCmnUpdUeMimoInfo)
#ifdef TFU_UPGRADE
if(ueCfg->txMode.pres)
{
#endif
{
- TRC2(rgSCHCmnUpdUeUlCqiInfo)
#ifdef TFU_UPGRADE
if(ue->srsCb.srsCfg.type == RGR_SCH_SRS_SETUP)
RgSchCmnUe *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUpdUeCatCfg)
ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
U32 waitPer;
- TRC2(rgSCHCmnRgrUeRecfg);
/* Basic validations */
if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
{
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUlUeDelAllocs);
for (i = 0; i < ueUl->hqEnt.numHqPrcs; ++i)
{
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDelUeFrmRefreshQ);
#ifdef RGL_SPECIFIC_CHANGES
if(ue->refreshOffset < RGSCH_MAX_REFRESH_GRPSZ)
#endif
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
RgSchDlHqProcCb *ccchSduHqP = NULLP;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUeCcchSduDel);
hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
if (hqE == NULLP)
U8 cnt;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
U32 idx = 0;
- TRC2(rgSCHCmnUeDel);
if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
{
U8 i, rbNum;
U32 pdcchBits;
- TRC2(rgSCHCmnDlCnsdrCmnRt);
/* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
* bits per 1024/2 REs */
U8 splSfCfi;
U8 mPhich;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi;
U8 cfiIdx;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
{
U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
- TRC2(rgSCHCmnUlCalcReqRbCeil);
return ((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
}
U8 iTbs = 0;
U16 msg3GrntSz = 0;
- TRC2(rgSCHCmnPrecompMsg3Vars);
if (ccchCqi > cellUl->max16qamCqi)
{
/* Maximum value of M as per Table 10.1-1 */
U8 M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
#endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUlCellInit);
cellUl->maxUeNewTxPerTti = cellCfg->maxUlUeNewTxPerTti;
if (maxUePerUlSf == 0)
{
S16 ret;
RgSchCmnCell *cellSch;
- TRC2(rgSCHCmnRgrCellCfg);
/* As part of RGR cell configuration, validate the CRGCellCfg
* There is no trigger for crgCellCfg from SC1 */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnRgrCellRecfg);
if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
{
CmLList *lnk = NULLP;
RgSchL2MeasCb *measCb;
#endif
- TRC2(rgSCHCmnUlCellDeinit);
#ifdef LTE_L2_MEAS
#ifdef LTE_TDD
for(ulSfIdx = 0; ulSfIdx < RGSCH_SF_ALLOC_SIZE; ulSfIdx++)
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnCellDel);
#ifdef LTE_L2_MEAS
glblTtiCnt = 0;
{
U8 qci = dlQos->qci;
- TRC2(rgSCHCmnValidateDlQos);
if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchCfg);
ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchRecfg)
if(dlLc->lcType != CM_LTE_LCH_DCCH)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgCfg);
ulLcg->cfgdGbr = (lcgCfg->ulInfo.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[reCfg->ulRecfg.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgRecfg);
ulLcg->cfgdGbr = (reCfg->ulRecfg.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchDel);
#ifdef EMTC_ENABLE
if(TRUE == ue->isEmtcUe)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
- TRC2(rgSCHCmnLcgDel);
if (lcgCmn == NULLP)
{
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnFreeDlLc);
if (svc->sch == NULLP)
{
RETVOID;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchUeCb *ue;
- TRC2(rgSCHCmnDlCcchSduRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduRetxLst.first;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchRaCb *raCb;
- TRC2(rgSCHCmnDlCcchRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4RetxLst.first;
hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
/* Fix: syed dlAllocCb reset should be performed.
hqP = (RgSchDlHqProcCb *)(node->node);
raCb = hqP->hqE->raCb;
node = node->next;
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
RETVOID;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchSduTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduTxLst.first;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4TxLst.first;
}
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
node = allocInfo->msg4Alloc.nonSchdMsg4TxLst.first;
/*Fix: Removing releasing of TB1 as it will not exist for MSG4 and hence caused a crash*/
/* rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
/* reset the UE allocation Information */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
U8 idx = 0;
U16 timeDiff = 0;
- TRC2(rgSCHCmnGetBiIndex)
if (cell->biInfo.prevBiTime != 0)
{
U8 msg3Subfrm;
#endif
- TRC2(rgSCHCmnDlRaRspFnlz);
for (rarCnt=0; rarCnt<RG_SCH_CMN_MAX_CMN_PDCCH; rarCnt++)
{
{
U8 k, rv;
CmLteTimingInfo frm;
- TRC2(rgSCHCmnDlCalcRvForBcch);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
#endif
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnDlBcchPcchFnlz);
/* handle PCCH */
rbAllocInfo = &allocInfo->pcchAlloc;
{
CmLList *node;
- TRC2(rgSCHCmnUlSetAllUnSched);
node = allocInfo->contResLst.first;
while (node)
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
- TRC2(rgSCHCmnUlAdd2CntResLst);
cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
ulAllocInfo->reqLnk.node = (PTR)ue;
RETVOID;
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
- TRC2(rgSCHCmnUlAdd2UeLst);
if (ulAllocInfo->reqLnk.node == NULLP)
{
cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
#endif
{
RgSchUlSf *sf = allocInfo->sf;
- TRC2(rgSCHCmnAllocUlRb);
/* Schedule for new transmissions */
rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
CmLteTimingInfo timeInfo;
#endif
#endif
- TRC2(rgSCHCmnUlRbAllocForLst);
if(schdLst->count == 0)
{
Bool mdfyiTbsFlg = FALSE;
U8 resiTbs = *iTbs;
- TRC2(rgSCHCmnUlMdfyGrntForCqi)
do
U8 numLyr;
#endif
- TRC2(rgSCHCmnUlRbAllocForUe);
#ifdef RG_5GTF
rgSCHUhmGetAvlHqProc(cell, ue, &proc);
if (proc == NULLP)
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlRbAllocAddUeToLst);
UNUSED(cell);
gUl5gtfUeRbAllocDone++;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlAllocFnlz);
/* call scheduler specific Finalization */
cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlAllocFnlz);
rgSCHCmnDlCcchRetxFnlz(cell, allocInfo);
rgSCHCmnDlCcchTxFnlz(cell, allocInfo);
#endif
{
CmLList *lnk;
- TRC2(rgSCHCmnUlUpdSf);
while ((lnk = sf->allocs.first))
{
{
U32 bytes;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlHndlAllocRetx);
bytes = \
rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
[alloc->grnt.numRb-1]/8;
#endif
- TRC2(rgSCHCmnUlAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure */
rgSCHCmnInitUlRbAllocInfo(allocInfoRef);
Pst pst;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSndCnsldtInfo);
subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
CmLListCp ulInActvLst;
RgSchCmnCell *cellSch = NULLP;
- TRC2(rgSCHCmnCnsldtSfAlloc);
cmLListInit(&dlDrxInactvTmrLst);
cmLListInit(&dlInActvLst);
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitDlRbAllocInfo);
- cmMemset((U8 *)&allocInfo->pcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)&allocInfo->bcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)allocInfo->raRspAlloc, (U8)0,
+ memset(&allocInfo->pcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(&allocInfo->bcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo->raRspAlloc, 0,
RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
allocInfo->msg4Alloc.msg4DlSf = NULLP;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitUlRbAllocInfo);
allocInfo->sf = NULLP;
cmLListInit(&allocInfo->contResLst);
cmLListInit(&allocInfo->schdContResLst);
RgSchDlSf *dlSf;
#endif
{
- TRC2(rgSCHCmnGrpPwrCntrlPucch);
rgSCHPwrGrpCntrlPucch(cell, dlSf);
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
- TRC2(rgSCHCmnGrpPwrCntrlPusch);
/* Got to pass DL SF corresponding to UL SF, so get that first.
* There is no easy way of getting dlSf by having the RgSchUlSf*,
U32 effNonGbrBsr = 0;
U32 lcgId;
- TRC2(rgSCHCmnApplyUeRefresh);
/* Reset the refresh cycle variableCAP */
ue->ul.effAmbr = ue->ul.cfgdAmbr;
#if (ERRCLASS & ERRCLS_DEBUG)
#endif
- TRC2(rgSCHCmnTmrExpiry);
#if (ERRCLASS & ERRCLS_DEBUG)
if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
/* Moving the assignment of scheduler pointer
to available scope for optimization */
- TRC2(rgSCHCmnTmrProc);
if ((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES_5G) == 0)
{
U8 splSfCfi = 0;
#endif
- TRC2(rgSchCmnUpdCfiVal);
pdsch = cell->crntTime;
RGSCH_INCR_SUB_FRAME(pdsch, delta);
{
U8 idx;
- TRC2(rgSchCmnUpdtPdcchSfIdx);
/* Resetting the parameters on CFI switching */
cell->dynCfiCb.cceUsed = 0;
U8 dlIdx;
U16 ttiMod;
- TRC2(rgSchCmnUpdCfiDb);
/* Get Downlink Subframe */
frm = cell->crntTime;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCommonChSch);
cellSch->apisDl->rgSCHDlTickForPdbTrkng(cell);
rgSchCmnUpdCfiVal(cell, RG_SCH_CMN_DL_DELTA);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlSch);
#ifdef LTE_ADV
/* LAA_SCELL: */
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlDedBoUpd);
/* RACHO : if UEs idle time exceeded and a BO update
* is received, then add UE to the pdcch Order Q */
#endif
{
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnRmvFrmTaLst);
#ifdef EMTC_ENABLE
if(cell->emtcEnable && ue->isEmtcUe)
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlMsg4ProcRmvFrmRetx);
if (hqP->tbInfo[0].ccchSchdInfo.retxLnk.node)
{
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlProcAddToRetx);
if (hqP->hqE->msg4Proc == hqP) /* indicating msg4 transmission */
{
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUeInfo *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDlSetUeRi);
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlSetUePmi);
if (ue->txModeTransCmplt == FALSE)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode10);
if (pucchCqi->u.mode10Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode11);
if (pucchCqi->u.mode11Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode20);
if (pucchCqi->u.mode20Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode21);
if (pucchCqi->u.mode21Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlCqiOnPucchInd);
/* ccpu00117452 - MOD - Changed
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U32 prevRiVal = 0;
- TRC2(rgSCHCmnDlCqiOnPuschInd);
if (puschCqi->ri.pres == PRSNT_NODEF)
{
if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
Bool is2ndCwCqiAvail = FALSE;
#endif
- TRC2(rgSCHCmnDlCqiInd);
#ifdef RGR_CQI_REPT
if (isPucchInfo)
#endif
{
U8 wideCqi=1; /*Calculated value from SNR*/
- TRC2(rgSCHCmnCalcWcqiFrmSnr);
/*Need to map a certain SNR with a WideCQI value.
* The CQI calculation is still primitive. Further, need to
* use a improvized method for calculating WideCQI from SNR*/
{
U8 wideCqi; /*Calculated value from SNR*/
U32 recReqTime; /*Received Time in TTI*/
- TRC2(rgSCHCmnSrsInd);
recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.slot;
ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
CmLListCp poInactvLst;
- TRC2(rgSCHCmnDlTARpt);
/* RACHO: If UE idle time is more than threshold, then
* set its poInactv pdcch order inactivity */
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
#endif
- TRC2(rgSCHCmnUlCqiInd);
/* consider inputs from SRS handlers about SRS occassions
* in determining the UL TX Antenna selection */
ueUl->crntUlCqi[0] = ulCqiInfo->wideCqi;
#ifndef RG_5GTF
U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
#endif
- TRC2(rgSCHCmnUlHqProcForUe);
#ifndef RG_5GTF
*procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
#else
RgSchUlHqProcCb *oldProc;
#endif
{
- TRC2(rgSCHCmnUpdUlHqProc);
UNUSED(cell);
UNUSED(oldProc);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
- TRC2(rgSCHCmnBsrTmrExpry)
ueCb->isSrGrant = TRUE;
#ifdef LTE_L2_MEAS
U8 idx;
#endif
- TRC2(rgSCHCmnUpdBsrShort);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
U8 idx;
#endif
- TRC2(rgSCHCmnUpdBsrTrunc);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
#endif
U32 lcgId;
- TRC2(rgSCHCmnUpdBsrLong);
#ifdef LTE_L2_MEAS
for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdExtPhr);
UNUSED(err);
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdPhr);
UNUSED(err);
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnContResUlGrant);
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
CmLList *node = ueUl->ulAllocLst.last;
- TRC2(rgSCHCmnSrRcvd);
#ifdef EMTC_ENABLE
emtcStatsUlTomSrInd++;
/* ACC_TDD */
RgSchUlAlloc* alloc = NULLP;
- TRC2(rgSCHCmnFirstRcptnReq);
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
/* ACC-TDD */
//RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
- TRC2(rgSCHCmnNextRcptnReq);
/* ACC-TDD */
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
RgSchUeCb *ueCb;
- TRC2(rgSCHCmnDrxStrtInActvTmrInUl);
-
cmLListInit(&ulUeLst);
while(alloc)
/* ACC-TDD */
RgSchUlAlloc *alloc = NULLP;
- TRC2(rgSCHCmnFirstHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnNextHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
U8 iMcs;
#endif
{
- TRC2(rgSCHCmnUlGetITbsFrmIMcs);
return (rgUlIMcsTbl[iMcs].iTbs);
}
#endif
{
U8 iMcs;
- TRC2(rgSCHCmnUlGetIMcsFrmITbs);
if (iTbs <= 10)
{
U8 iTbs;
#endif
{
- TRC2(rgSCHCmnUlMinTbBitsForITbs);
RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs);
{
U8 holeSz; /* valid hole size */
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlSbAlloc);
if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
{
RgSchCmnUeUlAlloc *ulAllocInfo;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlUeFillAllocInfo);
ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
ulAllocInfo = &ueUl->alloc;
U32 nonLcg0Bsr=0;
U8 lcgId;
RgSchCmnLcg *cmnLcg = NULLP;
- TRC2(rgSCHCmnUpdUlCompEffBsr);
while (node)
{
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
RgSchCmnUeUlAlloc *ulAllocInfo = &ueUl->alloc;
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRecordUeAlloc);
cmLListDelFrm(lst, &allRcd->lnk);
#ifndef LTE_TDD
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
/* Stack Crash problem for TRACE5 changes */
- TRC2(rgSCHCmnUlRecMsg3Alloc);
cmLListDelFrm(lst, node);
allRcd->allocTime = raCb->msg3AllocTime;
#endif
{
U32 nonLcg0Alloc=0;
- TRC2(rgSCHCmnUlUpdOutStndAlloc);
/* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
U8 maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi];
#endif
- TRC2(rgSCHCmnUlGetITbs);
/* #ifdef RG_SCH_CMN_EXT_CP_SUP For ECP pick index 1 */
#ifdef TFU_UPGRADE
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbInfoAddUeTx);
if (hqP->reqLnk.node == NULLP)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetx);
if (cellSch->dl.isDlFreqSel)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetxTx);
if (cellSch->dl.isDlFreqSel)
{
{
CmLList *schdLnkNode;
- TRC2(rgSCHCmnDlAdd2NonSchdRetxLst);
#ifdef LTEMAC_SPS
if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) &&
RgSchTddSubfrmInfo ulSubfrmInfo;
U8 maxUlSubfrms;
- TRC2(rgSCHCmnDlANFdbkInit);
ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
[RGSCH_NUM_SUB_FRAMES-1];
U8 dlPres = 0;
- TRC2(rgSCHCmnDlKdashUlAscInit);
/* Generate ACK/NACK offset information for each DL subframe in a radio frame
* Calculate this information based on K` in UL Association Set table */
{
U8 idx;
U16 np;
- TRC2(rgSCHCmnDlNpValInit);
/* Always Np is 0 for p=0 */
cell->rgSchTddNpValTbl[0] = 0;
S16 ret;
U8 lstSize;
- TRC2(rgSCHCmnDlCreateRachPrmLst);
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
S8 sfnOffset;
U8 numSubfrms;
- TRC2(rgSCHCmnDlRachInfoInit);
- cmMemset((U8 *)rachRspLst, 0, sizeof(rachRspLst));
+ memset(rachRspLst, 0, sizeof(rachRspLst));
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- TRC2(rgSCHCmnDlPhichOffsetInit);
/* Generate PHICH offset information for each DL subframe in a radio frame
* Calculate this information based on K in PHICH table */
U8 ulDlCfgIdx = cell->ulDlCfgIdx;
U8 msg3Subfrm;
U8 Mval;
- TRC2(rgSCHCmnUpdVars);
/* ccpu00132654-ADD- Initializing all the indices in every subframe*/
rgSCHCmnInitVars(cell);
#endif
{
U8 i;
- TRC2(rgSCHCmnGetPValFrmCCE);
for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
{
RgSchUlHqProcCb *proc;
#endif
{
- TRC2(rgSCHCmnUlAdapRetx);
rgSCHUhmRetx(proc, alloc);
#ifndef RG_5GTF
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp ulInactvLst;
- TRC2(rgSCHCmnHdlUlInactUes);
/* Get a List of Inactv UEs for UL*/
cmLListInit(&ulInactvLst);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp dlInactvLst;
- TRC2(rgSCHCmnHdlDlInactUes);
/* Get a List of Inactv UEs for DL */
cmLListInit(&dlInactvLst);
/* Time difference in subframes */
U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
- TRC2(rgSCHCmnUeIdleExdThrsld);
if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
{
U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
U32 sfDiff;
U8 cnt;
- TRC2(rgSCHCmnCfgRachDedPrm);
if (cell->macPreambleSet.pres == NOTPRSNT)
{
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUpdNxtPrchMskIdx);
/* Determine the next prach mask Index */
if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size - 1)
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
U32 sfDiff;
- TRC2(rgSCHCmnUpdRachParam);
if (cell->macPreambleSet.pres == NOTPRSNT)
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnAllocPOParam);
if (cell->macPreambleSet.pres == PRSNT_NODEF)
{
U8 prachMskIdx;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnGenPdcchOrder);
while (node)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlAdd2PdcchOdrQ);
if (ueDl->rachInfo.poLnk.node == NULLP)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlRmvFrmPdcchOdrQ);
cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = NULLP;
{
RgSchUeACqiCb *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell);
- TRC2(rgSCHCmnFillPdcchOdr2Sf);
pdcch->rnti = ue->ueId;
pdcch->dci.dciFormat = TFU_DCI_FORMAT_1A;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 rapIdIdx;
- TRC2(rgSCHCmnDelRachInfo);
if (ueDl->rachInfo.poLnk.node)
{
#endif
{
RgSchUeCb *ue = raReq->ue;
- TRC2(rgSCHCmnHdlHoPo);
if ( ue->isDrxEnabled )
{
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnGetHoUe);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnDelDedPreamble);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
U8 rapIdIdx;
- TRC2(rgSCHCmnGetPoUe);
rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
U8 cqi;
- TRC2(rgSCHCmnUlGetCqi);
cqi = ueUl->maxUlCqi;
#ifdef TFU_UPGRADE
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRbAllocForPoHoUe);
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
return RFAILED;
RgSchUlGrnt *grnt;
RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
- TRC2(rgSCHCmnAllocPoHoGrnt);
/* Clearing previous allocs if any*/
rgSCHCmnUlUeDelAllocs(cell, ue);
U8 idx;
#endif
{
- TRC2(rgSCHCmnUlNonadapRetx);
rgSCHUhmRetx(alloc->hqProc, alloc);
/* Update alloc to retx */
#endif
{
- TRC2(rgSCHCmnUlAllocsOvrLap);
if (((alloc1->sbStart >= alloc2->sbStart) &&
(alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
#endif
{
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlCpyAllocInfo);
dstAlloc->grnt = srcAlloc->grnt;
dstAlloc->hqProc = srcAlloc->hqProc;
/* MS_WORKAROUND ccpu00120827 */
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
U8 remAllocs;
- TRC2(rgSCHCmnUlInsAllocFrmNewSf2OldSf);
if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
{
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlMergeSfAllocs);
UNUSED(cell);
/* Merge each alloc of newSf in to oldSf
RgSchUlHoleDb *tempHoleDb = newSf->holeDb;
U8 tempAvailSbs = newSf->availSubbands;
- TRC2(rgSCHCmnUlSwapSfAllocs);
UNUSED(cell);
newSf->allocDb = oldSf->allocDb;
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlPrcNonAdptRetx);
/* perform non-adaptive retx allocation(adjustment) */
if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
U8 idx;
#endif
{
- TRC2(rgSCHCmnUlPrfmSfMerge);
/* Preassigned resources for msg3 in newSf.
* Hence do adaptive retx for all NACKED TXs */
rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf);
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlRmvCmpltdAllocs);
if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
{
U8 idx;
#endif
{
- TRC2(rgSCHCmnRlsUlSf);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlUpdAllocRetx);
alloc->hqProc->reTxAlloc.rnti = alloc->rnti;
alloc->hqProc->reTxAlloc.numSb = alloc->numSb;
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlAdapRetxAlloc);
/* Fetch PDCCH for msg3 */
/* ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
RgSchUlHqProcCb *proc;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfRlsRetxProcs);
cp = &(cellUl->reTxLst);
node = cp->first;
RgSchUeCb *ue;
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfReTxAllocs);
cp = &(cellUl->reTxLst);
node = cp->first;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
{
rbgInfo->lastRbgSize = rbgSize -
(dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
#ifdef RGSCH_SPS_UNUSED
- cmMemcpy((U8 *)rbgInfo->rbgSubsetSize, (U8 *) subsetSize, 4 * sizeof(U8));
+ memcpy(rbgInfo->rbgSubsetSize, subsetSize, 4 * sizeof(U8));
#endif
rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
dlTotalBw:(rbgInfo->numRbgs * rbgSize);
{
bestAvailNumRbs = numAvailRbs;
bestStartPos = startPos;
- cmMemcpy((U8 *)bestMask, (U8 *) tmpMask, 4 * sizeof(U32));
+ memcpy(bestMask, tmpMask, 4 * sizeof(U32));
}
numAvailRbs = 0;
startPos = -1;
- cmMemset((U8 *)tmpMask, 0, 4 * sizeof(U32));
+ memset(tmpMask, 0, 4 * sizeof(U32));
}
}
if (*allocNumRbs == rbsReq)
if (*allocNumRbs == rbsReq)
{
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) tmpMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, tmpMask, 4 * sizeof(U32));
RETVOID;
}
else
*allocStart = (U8)bestStartPos;
*allocNumRbs = bestAvailNumRbs;
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) bestMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, bestMask, 4 * sizeof(U32));
}
}
{
U8 addtlRbsAvl = 0;
- TRC2(rgSCHCmnFindNumAddtlRbsAvl)
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
{
#endif
{
*numOvrlapgPbchRb = 0;
- TRC2(rgSCHCmnFindNumPbchOvrlapRbs)
/*Find if we have already crossed the start boundary for PBCH 6 RBs,
* if yes then lets find the number of RBs which are getting overlapped
* with this allocation.*/
U8 divResult;
- TRC2(rgSCHCmnNonDlfsPbchRbAllocAdj);
origRbsReq = allocInfo->rbsReq;
U8 spsRbsAlloc = 0;
RgSchDlSfAllocInfo *dlSfAlloc = &allocInfo->dlSf->dlSfAllocInfo;
#endif
- TRC2(rgSCHCmnNonDlfsCmnRbAlloc);
allocInfo->tbInfo[0].noLyr = 1;
/* Note: Initialize the masks to 0, this might not be needed since alloInfo
* is initialized to 0 at the beginning of allcoation */
allocInfo->resAllocInfo.raType0Mask = 0;
- cmMemset((U8*)allocInfo->resAllocInfo.raType1Mask, 0,
+ memset(allocInfo->resAllocInfo.raType1Mask, 0,
RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (U32));
- cmMemset((U8*)allocInfo->resAllocInfo.raType2Mask, 0,
+ memset(allocInfo->resAllocInfo.raType2Mask, 0,
RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (U32));
if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
#endif
{
RgSchDlSf *dlSf = allocInfo->dlSf;
- TRC2(rgSCHCmnNonDlfsCmnRbAllocRar);
if(dlSf->bwAlloced == dlSf->bw)
U8 noLyrs;
U8 ignoredDfctRbg = FALSE;
- TRC2(rgSCHCmnNonDlfsBwAvlbl);
if (dlSf->bw <= dlSf->bwAlloced)
{
RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
CmLListCp *l;
CmLList *n;
RgSchSFRPoolInfo *sfrPool;
- TRC2(rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc);
l = &dlSf->sfrTotalPoolInfo.ccPool;
RgSchSFRPoolInfo *sfrCCPool2 = NULL;
S16 ret = RFAILED;
- TRC2(rgSCHCmnNonDlfsUpdDSFRTyp2Alloc);
/* Move the type2End pivot forward */
U8 numRb;
#endif
{
- TRC2(rgSCHCmnNonDlfsUpdTyp2Alloc);
/* Move the type2End pivot forward */
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
//#ifndef LTEMAC_SPS
U32 tb2BytesAlloc = 0;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnNonDlfsType0Alloc);
//if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
/* Fix for ccpu00123919*/
U16 rbBitLoc; /* Bit Location to be set as 1 in the current Byte */
U16 nmbRbPerByte; /* PRB's to be set in the current Byte (in case of multiple Bytes) */
- TRC2(rgSCHCmnBuildRntpInfo);
rbPtrStartIdx = (startRb)/8;
rbPtrEndIdx = (startRb + nmbRb)/8;
S16 ret;
#endif
- TRC2(rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc);
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
sfrPool->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
U8 noLyr;
U8 iTbs;
- TRC2(rgSCHCmnNonDlfsSFRPoolType0Alloc);
if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
{
U16 len;
U16 ret = ROK;
- TRC2(rgSCHCmnNonDlfsDsfrRntpComp);
len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
"rgSCHUtlRgrLoadInfInd() returned RFAILED");
}
- cmMemset(cell->rntpAggrInfo.val,0,len);
+ memset(cell->rntpAggrInfo.val,0,len);
samples = 0;
}
}
Bool isUECellEdge;
RgSchSFRPoolInfo *sfrpoolInfo = NULLP;
- TRC2(rgSCHCmnSFRNonDlfsUeRbAlloc);
isUECellEdge = RG_SCH_CMN_IS_UE_CELL_EDGE(ue);
#ifdef LAA_DBG
U32 dbgRbsReq = 0;
#endif
- TRC2(rgSCHCmnNonDlfsUeRbAlloc);
#ifdef RG_5GTF
RgSch5gtfUeCb *ue5gtfCb = &(ue->ue5gtfCb);
RgSchDlSf *dlSf = allocInfo->ccchSduDlSf;
RgSchUeCb *ueCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsCcchSduAlloc);
if (isRetx)
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnNonDlfsCcchSduRbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb,cell);
#endif
{
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnNonDlfsMsg4RbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(raCb);
RgSchDlSf *dlSf = allocInfo->msg4DlSf;
RgSchRaCb *raCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsMsg4Alloc);
if (isRetx)
{
RgSchUeCb *ue = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
U8 isDlBwAvail;
- TRC2(rgSCHCmnNonDlfsDedRbAlloc);
/* Perform allocaations for the list */
{
U8 raRspCnt = 0;
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsRbAlloc);
/* Allocate for MSG4 retransmissions */
if (allocInfo->msg4Alloc.msg4RetxLst.count)
U8 numRbMinus1 = numRb - 1;
U32 riv;
- TRC2(rgSCHCmnCalcRiv);
if (numRbMinus1 <= bw/2)
{
U8 sfcount;
S16 ret;
- TRC2(rgSCHCmnDlCpyRachInfo);
/* Allocate RACH response information for each DL
* subframe in a radio frame */
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
S32 iTbs = 0;
- TRC2(rgSchCmnFetchItbs);
#ifdef LTE_TDD
/* Special Handling for Spl Sf when CFI is 3 as
RgSchDlRbAlloc *allocInfo;
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocTxRb1Tb1Cw);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchDlRbAlloc *allocInfo;
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocRetxRb1Tb1Cw);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM1);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM1);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM2);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM2);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM3);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM3);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSlctPdcchFrmt);
/* ccpu00140894- Selective DCI Format and RA type should be selected only
* after TX Mode transition is completed*/
U8 noTxLyrs;
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
#endif
U8 noTxLyrs;
- TRC2(rgSCHCmnDlTM4RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlSMGetAttrForTxRetx);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
Bool bothCwEnbld;
#endif
{
- TRC2(rgSCHCmnDlTM3PrecInf2);
return (0);
}
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf2);
if (ueDl->mimoInfo.ri == numTxLyrs)
{
{
U8 precIdx;
- TRC2(rgSCHCmnDlTM3PrecInf4);
if (bothCwEnbld)
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoBaseIdx, precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf4);
precInfoBaseIdx = (ue->mimoInfo.puschFdbkVld)? (16):
(ueDl->mimoInfo.pmi);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM3);
/* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with
HQP */
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM4);
*frthrScp = FALSE;
/* Integration_fix: SPS Proc shall always have only one Cw */
U8 prcdngInf;
U8 numTxLyrs;
- TRC2(rgSCHCmnDlTM3TxRetx);
frthrScp = FALSE;
ret = ROK;
U8 prcdngInf;
U8 numTxLyrs;
- TRC2(rgSCHCmnDlTM4TxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
S16 ret;
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
S16 ret;
- TRC2(rgSCHCmnDlTM4TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM4);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM4);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocTxRbTM6);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocRetxRbTM6);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM7);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM7);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
U32 prevSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocTxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
{
RgSchTddSfType txSfType = 0;
- TRC2(rgSCHCmnRetxAvoidTdd);
/* Get the RBs of TB that will be retransmitted */
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
U8 reqRbs;
- TRC2(rgSCHCmnRetxAllocAvoid);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
U32 newSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocRetxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
/* Correcting wrap around issue.
* This change has been done at mutliple places in this function.*/
U32 tempNumRb;
- TRC2(rgSCHCmnDlAlloc1CwTxRb);
reqBytes = bo;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 iTbs;
U16 numRb;
- TRC2(rgSCHCmnRdcImcsTxTb);
iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
noLyr = allocInfo->tbInfo[tbInfoIdx].noLyr;
U32 boTmp = bo;
#endif
- TRC2(rgSCHCmnDlAlloc2CwTxRb);
reqBytes = bo;
cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
U8 cfi = cellDl->currCfi;
U8 iTbs;
- TRC2(rgSCHCmnDlAlloc2CwTxRetxRb);
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
U8 imcs2;
RgSchDlHqTbCb *lrgTbInfo, *othrTbInfo;
- TRC2(rgSCHCmnDlAlloc2CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchDlRbAlloc *allocInfo;
U8 imcs;
- TRC2(rgSCHCmnDlAlloc1CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
#endif
{
- TRC2(rgSCHCmnDlRelPdcchFbk);
rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
RETVOID;
#endif
{
- TRC2(rgSCHCmnDlProcAck);
if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
{
#endif
{
- TRC2(rgSCHCmnHdlCrntiCE);
#ifdef RGSCH_SPS_STATS
rgSchStatCrntiCeRcvCnt++;
#endif
#endif
{
- TRC2(rgSCHCmnUlSpsRelInd);
rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
RETVOID;
#endif
{
- TRC2(rgSCHCmnUlSpsActInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
#endif
{
- TRC2(rgSCHCmnUlCrcInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
#endif
{
- TRC2(rgSCHCmnUlCrcFailInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlBcchPcchAlloc);
/*Reset the bitmask for BCCH/PCCH*/
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHBcchPcchDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
{
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsBcchPcchRbAlloc);
/* 143473 */
/* Allocate for PCCH */
{
CmLteTimingInfo pdSchTmInfo;
- TRC2(rgSCHChkNUpdSiCfg);
pdSchTmInfo = cell->crntTime;
U16 x;
U16 windowId;
- TRC2(rgSCHSelectSi);
crntTmInfo = cell->crntTime;
#endif
/* DwPTS Scheduling Changes End */
- TRC2(rgSCHDlSiSched);
crntTimInfo = cell->crntTime;
S16 retVal;
RgrStaIndInfo *staInfo = NULLP;
- TRC2(rgSCHCmnUeDlPwrCtColltCqiRept)
/* Step 1: Store the CQI in collation array */
/* Step 2: Increament the tracking count */
Bool *reTxAllwd;
#endif
{
- TRC3(rgSCHCmnChkRetxAllowDtx)
*reTxAllwd = TRUE;
U32 numRE = *rb * cellDl->noResPerRb[cfi];
U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, cellDl->maxDlBwPerUe);
U32 numRE = *rb * cellDl->noResPerRb[cfi];
U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz2Cw);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, maxRb);
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnUpdUeDataIndLcg);
for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
{
RgSchDlSf *dlSf;
U8 idx;
- TRC2(rgSCHCmnInitRbAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure.*/
rgSCHCmnInitDlRbAllocInfo(&cellSch->allocInfo);
RgmTransModeInd *txModeChgInd;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnSendTxModeInd);
if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
{
RgrTxMode txMode; /*!< UE's Transmission Mode */
RgrTxMode modTxMode; /*!< UE's Transmission Mode */
- TRC2(rgSchCheckAndTriggerModeChange);
txMode = ue->mimoInfo.txMode;
RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnIsDlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
{
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnIsUlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
RgSchDlSf *sf;
U8 idx;
- TRC2(rgSchCmnPreDlSch);
if(nCell > CM_LTE_MAX_CELLS)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSchCmnPstDlSch);
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
{
U8 ri;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
- TRC3(rgSCHCmnCalcPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
U16 dlCntrlSfIdx;
#endif
- TRC2(rgSCHCmnDlSch);
dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
#ifdef RG_5GTF
{
S16 ret;
- TRC2(rgSCHDbmInitCell);
-
/* Initialize ue list */
if ((ret = rgSCHDbmInitUeCbLst(cellCb, RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
return (ret);
#endif
{
RgSchUeCellInfo ueCellInfo;
- TRC2(rgSCHDbmInitUeCbLst)
/* Fix: syed It is better to compute offset dynamically
* rather than hardcoding it as 0 */
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmDeInitUeCbLst)
return (cmHashListDeinit(&cellCb->ueLst));
#endif
{
RgSchUeCb ue;
- TRC2(rgSCHDbmInitSpsUeCbLst)
return (cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
CM_HASH_KEYTYPE_CONID,
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmDeInitSpsUeCbLst)
return (cmHashListDeinit(&cellCb->spsUeLst));
#endif
{
RgSchUeCellInfo *ueCellInfo = NULLP;
- TRC2(rgSCHDbmInsUeCb)
ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHDbmInsSpsUeCb)
-
return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
(U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
{
RgSchUeCellInfo *ueCellInfo = NULLP;
- TRC2(rgSCHDbmGetUeCb)
-
cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
sizeof(ueId), 0, (PTR *)&ueCellInfo);
{
RgSchUeCb *ueCb = NULLP;
- TRC2(rgSCHDbmGetSpsUeCb)
-
cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
sizeof(spsRnti), 0, (PTR *)&ueCb);
return (ueCb);
RgSchUeCellInfo *ueCellInfo = NULLP;
RgSchUeCellInfo *nextUeCellInfo = NULLP;
- TRC2(rgSCHDbmGetNextUeCb)
-
if (ueCb)
{
ueCellInfo = ueCb->cellInfo[
{
RgSchUeCb *nextUeCb = NULLP;
- TRC2(rgSCHDbmGetNextSpsUeCb)
-
cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
return (nextUeCb);
} /* end of rgSCHDbmGetNextSpsUeCb */
U8 lcCnt = 0;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
- TRC2(rgSCHDbmDelL2MUe)
-
ueUl->hqEnt.numBusyHqProcs = 0;
/* Clean cell level UE Active Count */
for (lcCnt =0; lcCnt < RGSCH_MAX_LC_PER_UE; lcCnt++)
#endif
{
RgSchUeCellInfo *ueCellInfo = NULLP;
- TRC2(rgSCHDbmDelUeCb)
ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHDbmDelSpsUeCb)
return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
} /* end of rgSCHDbmDelSpsUeCb */
{
S16 ret = ROK;
- TRC2(rgSCHDbmInitUe);
-
/* Initialize Dedicated logical channels */
rgSCHDbmInitDedLcLst(ueCb);
{
U8 idx;
- TRC2(rgSCHDbmInitDedLcLst);
-
for (idx = 0; idx < RGSCH_MAX_LC_PER_UE; ++idx)
{
/* Set Dedicated LCs as not configured */
{
U8 idx;
- TRC2(rgSCHDbmInitCmnLcLst);
-
for (idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
{
cellCb->cmnLcCb[idx].lcId = RGSCH_INVALID_LC_ID;
RgSchDlLcCb *dlLcCb;
#endif
{
- TRC2(rgSCHDbmInsDlDedLcCb);
ueCb->dl.lcCb[dlLcCb->lcId - 1] = dlLcCb;
RgSchDlLcCb *dlLcCb;
#endif
{
- TRC2(rgSCHDbmDelDlDedLcCb);
#ifdef LTE_L2_MEAS
/* Clean cell level UE Active Count */
CmLteLcId idx;
#endif
{
- TRC2(rgSCHDbmGetDlDedLcCb);
-
if (idx < RGSCH_DEDLC_MIN_LCID || idx > RGSCH_DEDLC_MAX_LCID)
{
return (NULLP);
#endif
{
U8 idx;
- TRC2(rgSCHDbmGetFirstDlDedLcCb)
for(idx = 0; idx < RGSCH_DEDLC_MAX_LCID; idx++)
{
#endif
{
U8 idx;
- TRC2(rgSCHDbmGetNextDlDedLcCb);
if (!lcCb)
{
{
U8 idx;
- TRC2(rgSCHDbmGetCmnLcCb)
-
for(idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
{
if(cellCb->cmnLcCb[idx].lcId == lcId)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetBcchOnBch)
if(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].lcId != RGSCH_INVALID_LC_ID)
{
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetFirstBcchOnDlsch)
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId != RGSCH_INVALID_LC_ID)
{
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetSecondBcchOnDlsch)
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].lcId != RGSCH_INVALID_LC_ID)
{
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetPcch)
if(cellCb->cmnLcCb[RGSCH_PCCH_IDX].lcId != RGSCH_INVALID_LC_ID)
{
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInsBcchOnBch)
cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].lcId = cmnDlLcCb->lcId;
cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].boLst = cmnDlLcCb->boLst;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInsBcchOnDlsch)
-
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId == RGSCH_INVALID_LC_ID)
{
cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId = cmnDlLcCb->lcId;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInsPcch)
cellCb->cmnLcCb[RGSCH_PCCH_IDX].lcId = cmnDlLcCb->lcId;
cellCb->cmnLcCb[RGSCH_PCCH_IDX].boLst = cmnDlLcCb->boLst;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInitCmnLcBoLst)
cmLListInit(&cmnDlLcCb->boLst);
RETVOID;
RgSchClcBoRpt *cmnBoRpt;
#endif
{
- TRC2(rgSCHDbmInsCmnLcBoRpt)
-
cmnBoRpt->boLstEnt.next = NULLP;
cmnBoRpt->boLstEnt.prev = NULLP;
cmnBoRpt->boLstEnt.node = (PTR)cmnBoRpt;
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmInitRaCbLst)
cmLListInit(&cellCb->raInfo.raCbLst);
RETVOID;
{
CmLList *tmpNode;
- TRC2(rgSCHDbmGetRaCb)
-
CM_LLIST_FIRST_NODE(&cellCb->raInfo.raCbLst,tmpNode);
while(tmpNode)
{
{
U8 idx;
- TRC2(rgSCHDbmInitRaReqLst)
-
/* ccpu00133557- Memory Leak Fix- initializing for the all nodes
* in RAREQ list*/
for(idx = 0; idx < RGSCH_RAREQ_ARRAY_SIZE; idx++)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmInitCrntRgrCfgLst)
cmLListInit(&cellCb->rgCfgInfo.crntRgrCfgLst);
RETVOID;
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmInitPndngRgrCfgLst)
cmLListInit(&cellCb->rgCfgInfo.pndngRgrCfgLst);
RETVOID;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmInsCrntRgrCfgElem)
-
cfgElem->cfgReqLstEnt.next = NULLP;
cfgElem->cfgReqLstEnt.prev = NULLP;
cmLListAdd2Tail(&cellCb->rgCfgInfo.crntRgrCfgLst, &cfgElem->cfgReqLstEnt);
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmInsPndngRgrCfgElem)
cfgElem->cfgReqLstEnt.next = NULLP;
cfgElem->cfgReqLstEnt.prev = NULLP;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmGetNextCrntRgrCfgElem)
if(!cfgElem)
{
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmGetNextPndngRgrCfgElem)
if(!cfgElem)
{
{
CmLList *tmpNode;
- TRC2(rgSCHDbmGetPndngRgrCfgElemByKey)
-
CM_LLIST_FIRST_NODE(&cellCb->rgCfgInfo.pndngRgrCfgLst,tmpNode);
while(tmpNode)
{
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmDelCrntRgrCfgElem)
if(cmLListDelFrm(&cellCb->rgCfgInfo.crntRgrCfgLst,&cfgElem->cfgReqLstEnt))
{
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmDelPndngRgrCfgElem)
-
if(cmLListDelFrm(&cellCb->rgCfgInfo.pndngRgrCfgLst,&cfgElem->cfgReqLstEnt))
{
return ((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
U16 rnti;
RgSchRntiLnk *rntiPool;
- TRC2(rgSCHDbmRntiDbInit)
-
- /* Fix for Change Request ccpu00099150 */
+ /* Fix for Change Request ccpu00099150 */
if(rgSCHUtlAllocSBuf(cellCb->instIdx,
(Data **)&cellCb->rntiDb.rntiPool,maxRntis*sizeof(RgSchRntiLnk)) != ROK)
{
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmRntiDbDeInit)
-
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cellCb->instIdx, (Data **)(&(cellCb->rntiDb.rntiPool)),
{
RgSchRntiLnk *rntiLnk;
- TRC2(rgSCHDbmGetRnti)
-
if (!(cellCb->rntiDb.freeRnti))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI exhausted count:%d",
RgSchRntiLnk *rntiLnk;
#endif
{
- TRC2(rgSCHDbmRlsRnti)
#ifdef EMTC_ENABLE
if(ROK==rgSCHDbmPutEmtcRnti(cellCb,rntiLnk))
{
#endif
{
RgSchUePucchRecpInfo pucchInfo;
- TRC2(rgSCHDbmInitUeTfuPendLst)
/* Fix: syed It is better to compute offset dynamically
* rather than hardcoding it as 0 */
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmDeInitUeTfuPendLst)
cmHashListDeinit(&cellCb->ueTfuPendLst);
{
RgSchDlHqProcCb *hqP;
U8 i;
- TRC2(rgSCHDhmHqEntReset)
cmLListInit(&hqE->inUse);
cmLListInit(&hqE->free);
for (i=0; i < hqE->numHqPrcs; i++)
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHDhmAssgnUeHqEntFrmRaCb)
ue->cellInfo[0]->hqEnt = raCb->dlHqE;
ue->cellInfo[0]->hqEnt->ue = ue;
RgSchDlHqEnt **hqE;
#endif
{
- TRC2(rgSCHDhmDelHqEnt)
if (!(*hqE))
{
RgSchDlHqEnt *hqE;
Inst inst = cell->instIdx;
- TRC2(rgSCHDhmHqEntInit)
-
/* Init the HARQ data structure */
if (rgSCHUtlAllocSBuf(inst, (Data **)&hqE, sizeof(RgSchDlHqEnt)) != ROK)
{
RgSchDlHqEnt *hqE = NULLP;
RgSchDlHqProcCb *tmpHqProc;
CmLList *tmp;
- TRC2(rgSCHDhmGetAvlHqProc);
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
#endif
{
U8 othrTbIdx = tbIdx ^ 1;
- TRC2(rgSCHDhmHqTbRetx)
hqP->tbInfo[tbIdx].timingInfo = timingInfo;
RgSchDlHqEnt *hqE;
#endif
{
- TRC2(rgSCHDhmLastSchedHqProc);
/* GRPPWR_CNTRL Fix: UE context will not hold a valid hqE,
* until RACH procedure is completed */
if ((hqE == NULLP) || (hqE->inUse.last == NULLP))
CmLList *tmp;
RgSchDlHqEnt *hqE;
- TRC2(rgSCHDhmGetCcchSduHqProc)
-
hqE = ueCb->cellInfo[0]->hqEnt;
CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
if (NULLP == tmp)
CmLList *tmp;
RgSchDlHqEnt *hqE;
- TRC2(rgSCHDhmGetMsg4HqProc)
-
hqE = raCb->dlHqE;
CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
if (NULLP == tmp)
U8 numLch = 0;
#endif
- TRC2(rgSCHDhmRlsHqpTb)
-
/* Reset all tbInfo values */
hqE = hqP->hqE;
#endif
{
- TRC2(rgSCHDhmRlsHqProc)
-
#ifdef MAC_SCH_STATS
/* THIS FUNCTION IS NOT CALLED */
#endif
{
RgSchDlHqEnt *hqE;
- TRC2(rgSCHDhmGetHqProcFrmId)
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
/* Pick the proc based on the index provided */
RgSchDlHqProcCb *hqProc = NULLP;
CmLList *tmp = NULLP;
- TRC2(rgSCHDhmSpsDlGetHqProc);
-
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
RgSchUeCb *ueCb;
RgSchCellCb *cell;
- TRC2(rgSCHDhmFdbkIndHndlTa)
-
ueCb = hqP->hqE->ue;
cell = ueCb->cell;
switch(fdbk)
#endif
{
- TRC2(rgSCHDhmSchdTa)
-
ueCb->dl.taCb.state = RGSCH_TA_SCHEDULED;
ueCb->dl.taCb.numRemSf = 2;
tbInfo->schdTa.pres = PRSNT_NODEF;
RgSchDlHqEnt *hqE;
U8 maxHqTx;
- TRC2(rgSCHDhmHqTbTrnsFail)
-
hqE = hqP->hqE;
/* Fetch the maximum number of harq transmissions */
#endif
/* LTEMAC_SPS_AN_MUX*/
RgrSchFrmt1b3TypEnum uciFrmtTyp = RG_SCH_UCI_FORMAT1A_1B;
- TRC2(rgSCHDhmHqFdbkInd)
if (cbType == RGSCH_HQ_FDB_IND_CB_TYPE_RA_CB)
{
CmLteTimingInfo frm = timingInfo;
#endif
- TRC2(rgSCHDhmPrcFdbkForTb)
if (ue)
{
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 hqPCount = 0;
RgInfRlsHqInfo *rlsHqBufs = NULLP;
- TRC2(rgSCHDhm5gtfHqFdbkInd)
-
RGSCHDECRFRMCRNTTIME(timingInfo, timingInfo, 4);
sf = rgSCHUtlSubFrmGet(cell, timingInfo);
#endif
RgrSchFrmt1b3TypEnum uciFrmtTyp = RG_SCH_UCI_FORMAT1A_1B;
- TRC2(rgSCHDhmHqFdbkInd)
-
/* Get the subframe associated with the feedback */
/* ccpu00133109: Removed RGSCHSUBFRMCRNTTIME as it is not giving proper output
* if diff is more than 10. Instead using RGSCHDECRFRMCRNTTIME() as it is
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHDhmRgrUeCfg)
UNUSED(err);
S16 ret;
U8 idx;
- TRC2(rgSCHDhmRgrCellCfg)
-
UNUSED(err);
pUeCb = NULLP;
PTR nUeCb;/* next UE control block */
S16 ret;
- TRC2(rgSCHDhmRgrCellRecfg)
-
UNUSED(err);
pUeCb = NULLP;
#endif
{
- TRC2(rgSCHDhmFreeUe)
-
/* If TA Timer is running. Stop it */
if (ueCb->taTmr.tmrEvnt != TMR_NONE)
{
U8 ta;
#endif
{
- TRC2(rgSCHDhmUpdTa)
if (ueCb->dl.taCb.state == RGSCH_TA_IDLE)
{
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHDhmProcTAExp);
-
/* Ask scheduler to schedule this UE */
ueCb->dl.taCb.state = RGSCH_TA_TOBE_SCHEDULED;
rgSCHUtlDlTARpt(ueCb->cell, ueCb);
#endif
{
- TRC2(rgSCHDhmAddLcData)
-
if(tbInfo->numLch >= RGSCH_MAX_NUM_DED_LC)
{
return RFAILED;
U8 noFdbks;
U8 i;
- TRC2(rgSCHDhmTddRlsSubFrm)
-
ascIdx =
rgSchTddDlAscSetIdxKTbl[cellCb->ulDlCfgIdx][uciTimingInfo.slot];
noFdbks = ascIdx.numFdbkSubfrms;
RgSchTddANInfo *anInfo = NULLP;
RgSchDlHqTbCb *tbCb;
RgSchUeCb *ue = NULLP;
- TRC2(rgSCHDhmRlsDlsfHqProc)
ascIdx =
rgSchTddDlAscSetIdxKTbl[cellCb->ulDlCfgIdx][uciTimingInfo.slot];
RgSchDlHqTbCb *tbCb;
RgSchUeCb *ue;
- TRC2(rgSCHDhmRlsDlsfHqProc)
-
/* Fetch the current timing info. Modify it to Last sf to be rlsd.*/
/* ccpu00133109: Removed RGSCHSUBFRMCRNTTIME as it is not giving proper
* output if diff is more than 10. Instead using RGSCHDECRFRMCRNTTIME()
#endif
{
RgSchDlHqProcCb *hqP;
- TRC2(rgSCHDhmMarkSpsHqProc)
/* Pick the proc based on the index provided */
rgSCHDhmGetHqProcFrmId(ue->cell, ue, idx, &hqP);
U8 *isAck;
#endif
{
- TRC2(rgSCHDhmProcHqFdbkAckNackRep)
/* Check if this is repeating UE */
rgSCHUtlDlHqPTbRmvFrmTx(sf, hqP, tbCnt, TRUE);
/* Check if last repetition */
Bool maxRetx = FALSE;
RgSchCmnCell *cellSch;
- TRC2(rgSCHDhmDlRetxAllocFail);
-
cell = hqP->hqE->cell;
cellSch = RG_SCH_CMN_GET_CELL(cell);
rlsHqInfo = &(cell->rlsHqArr[cell->crntHqIdx]);
{
U8 numOfAcks;
- TRC2(rgSCHDhmPrcSplBundlFdbk);
-
/* Num of ACKs reported by UE */
numOfAcks = fdbk->isAck[0];
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPAdd2FreeLst)
#ifdef LAA_DBG
if (hqP->hqPLst)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPAdd2InUseLst)
#ifdef LAA_DBG
if (hqP->hqPLst)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPDelFrmFreeLst)
#ifdef LAA_DBG
if (!hqP->hqPLst)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPDelFrmInUseLst)
#ifdef LAA_DBG
if (!hqP->hqPLst)
U16 dlIndex;
U16 ulIndex;
- TRC2(rgSCHDrxTtiInd );
-
-
dlIndex = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot +
RG_SCH_DRX_DL_DELTA) % RG_SCH_MAX_DRXQ_SIZE;
#endif
{
- TRC2(rgSCHDrxTtiHdlOnDur);
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
RgSchCmnCell *cellSch = NULLP;
Bool delInUlScan = FALSE;
- TRC2(rgSCHDrxTtiHdlInActv);
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
RgSchUeCb *ue=NULLP;
RgSchDrxUeCb *drxUe=NULLP;
- TRC2(rgSCHDrxTtiHdlShortCycle );
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
#endif /*ERRCLASS & ERRCLS_INT_PAR*/
- TRC2(rgSCHDrxTtiHdlDlHarq );
-
rgSCHDrxTtiHdlDlHarqRTT(cell, dlIndex);
rgSCHDrxTtiHdlUlHarqRTT(cell, ulIndex);
RgSchCmnCell *cellSch = NULLP;
Bool delInUlScan = FALSE;
-
- TRC2(rgSCHDrxStrtInActvTmr);
-
-
if ( direction == RG_SCH_DRX_UL)
{
#ifndef LTE_TDD
U8 firstDlTxOcassion;
U8 drxRetxTmrStartSf;
#endif
- TRC2(rgSCHDrxStartHarqRTTTmr);
-
drxCell = RG_SCH_DRX_GET_CELL(cell);
drxHq = RG_SCH_DRX_GET_DL_HQ(hqP);
U8 cellIdx;
- TRC2(rgSCHDrxUeCfg);
-
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
U32 numOfCycles;
U32 nxtDist;
- TRC3(rgSCHDrxGetNxtOnDur);
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
RgrUeDrxCfg *drxCfg;
#endif
{
- TRC3(rgSCHDrxCpyUeCfg);
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( (ueCb == (RgSchDrxUeCb* )NULLP )
U16 curIndx;
U8 cellIdx;
- TRC2(rgSCHDrxUeReCfg);
-
/* drx was disabled but now enabled for this ue */
if ( (ue->isDrxEnabled == FALSE)
RgSchDrxDlHqProcCb *drxHq =NULLP;
U8 i;
- TRC2(rgSCHDrxUeHqReset);
-
for(i=0; i < hqE->numHqPrcs; i++)
{
hqP = &hqE->procs[i];
#ifdef EMTC_ENABLE
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
#endif
- TRC2(rgSCHDrxUeDel);
/* ccpu00129899: Moved the drx-enabled check to the caller */
* Function: rgSCHDrxCellCfg
*
* Processing steps:
- * - Initializes the following drxQ (cmMemset would do).
+ * - Initializes the following drxQ (memset would do).
*
*
* @param RgSchCellCb *cell
S16 ret = ROK;
Inst instIdx = cell->instIdx;
- TRC2(rgSCHDrxCellCfg);
-
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
/*KWORK_FIX :Removed check for cell being NULL*/
if( (cellCfg == (RgrCellCfg* )NULLP))
{
Inst instIdx = cell->instIdx;
- TRC2(rgSCHCfgRgrCellDel);
-
-
if (cell->drxCb)
{
/* ccpu00117052 - MOD - Passing double pointer
{
RgSchDrxUeCb *drxCb;
- TRC2(rgSCHDrxSrInd);
-
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
{
RgSchDrxUeCb *drxCb;
- TRC2(rgSCHDrxDedRa);
-
-
drxCb = RG_SCH_DRX_GET_UE(ueCb);
/* Mark the UE as active for UL & DL */
drxCell = cell->drxCb;
drxUe = ueCb->drxCb;
- TRC2(rgSCHDrxMvToNxtOnDurOcc)
if(calcFrmOffst == FALSE)
{
CmLteTimingInfo crntTime; /*!< current SFN & sf */
- TRC2(rgSCHDrxGetNxtTmrExpry);
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( (cell == (RgSchCellCb* )NULLP)
||
CmLteTimingInfo tmrExpry;
U16 tmrExpryInSf; /*timer expry in no of subframes*/
- TRC2(rgSCHDrxCalcNxtTmrExpry)
-
curTimeInSf = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G +
cell->crntTime.slot;
U16 startTime;
U16 endTimeInSf;
CmLteTimingInfo endTime;
- TRC2(rgSCHCfgVldtTddDrxCycCfg)
startTime = offSet;
do
RgSchCmnCell *cellSch = NULLP;
Bool delInUlScan = FALSE;
- TRC2(rgSCHDrxTtiHdlOnDurUl)
-
drxCell = (cell->drxCb);
delInUlScan = drxCell->delInUlScan;
/***********************************************************
* in the onDurationTmrExprQ. If !delInUlScan, then calculate the next
* OnDuration occurence, q it there and remove it from the current location.
*/
- TRC2(rgSCHDrxTtiHdlOnDurDl)
/***********************************************************
* Scanning OnDurationQ in DL
***********************************************************/
U8 cellIdx;
U32 dlInactvMask;
- TRC2(rgSCHDrxTtiHdlDlHarqRTT);
-
drxCell = cell->drxCb;
delInUlScan = drxCell->delInUlScan;
U32 ulInactvMask;
- TRC2(rgSCHDrxTtiHdlUlHarqRTT);
-
drxCell = cell->drxCb;
delInUlScan = drxCell->delInUlScan;
Void rgSCHCmnSpsInit ()
#endif /* ANSI */
{
- TRC2(rgSCHCmnSpsInit);
-
RETVOID;
}
#endif /* ANSI */
{
- TRC2(rgSCHCmnSpsUeCfg);
-
return ROK;
}
#endif /* ANSI */
{
- TRC2(rgSCHCmnSpsUeRecfg);
-
return ROK;
}
#endif /* ANSI */
{
- TRC2(rgSCHCmnSpsUeDel);
RETVOID;
}
#endif /* ANSI */
{
- TRC2(rgSCHCmnSpsCellCfg);
return ROK;
}
#endif /* ANSI */
{
- TRC2(rgSCHCmnSpsCellDel);
RETVOID;
}
#endif /* ANSI */
{
- TRC2(rgSCHCmnSpsDlLcCfg);
return ROK;
}
RgSchCellCb *cell
))
{
- TRC2(rgSchCmnDlSfHqDel);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsDlLcRecfg);
return ROK;
}
RgSchLcgCb *lcg
))
{
- TRC2(rgSCHCmnSpsUlLcgDel);
RETVOID;
}
RgSchDlLcCb *dlLc
))
{
- TRC2(rgSCHCmnSpsUlLcgDel);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsUlTti);
return ROK;
}
))
{
- TRC2(rgSCHCmnSpsDlDedBoUpd);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsDlProcAddToRetx);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsDlCqiIndHndlr);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsUlCqiInd);
return ROK;
}
))
{
- TRC2(rgSCHCmnSpsBsrRpt);
return ROK;
}
))
{
- TRC2(rgSCHCmnSpsPhrInd);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsDlRelPdcchFbk);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsDlProcAck);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsDlUeReset);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsUlUeReset);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsUlProcRelInd);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsUlProcActInd);
RETVOID;
}
))
{
- TRC2(rgSCHCmnSpsUlProcActInd);
return ROK;
}
))
{
- TRC2(rgSCHCmnSpsUlProcDtxInd);
return ROK;
}
))
{
- TRC2(rgSCHCmnSpsUlProcDtxInd);
RETVOID;
}
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(schActvTsk)
-
switch(pst->srcEnt)
{
/* The originator of this message is the stack manager,
Inst inst = (instCb->rgSchInit.inst );
#endif
- TRC2(rgSCHGomHndlCfg);
/* Apply the configuration for Cell Configuration or Delete */
if (cfgReqInfo->action != RGR_RECONFIG)
{
#ifdef DEBUGP
Inst inst = (instCb->rgSchInit.inst );
#endif
- TRC2(rgSCHGomCfgReq);
#ifdef EMTC_ENABLE
printf("\n AT MAC rgSCHGomCfgReq \n");
#endif
CmLteTimingInfo actvTime;
Inst inst = cell->instIdx;
- TRC2(rgSCHGomEnqCfgReq);
-
/* Allocate memory for config Element */
ret = rgSCHUtlAllocSBuf(inst, (Data **)&rgrCfgElem, sizeof(RgSchCfgElem));
if ((ret != ROK) || ((U8 *)rgrCfgElem == NULLP))
}
/* Initialize the configuration element */
- cmMemcpy((U8*)rgrCfgElem->rgrCfg.transId.trans,(U8*)transId.trans,
+ memcpy(rgrCfgElem->rgrCfg.transId.trans,transId.trans,
sizeof(transId.trans));
rgrCfgElem->rgrCfg.reg = reg;
rgrCfgElem->rgrCfg.pool = pool;
{
RgSchCfgElem *cfgElem;
Inst inst= cell->instIdx;
- TRC2(rgSCHGomTtiHndlr);
/* Dequeue from current config list */
while ((cfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
Inst inst = (instCb->rgSchInit.inst );
RgSchUeCb *ue;
- TRC2(rgSCHGomHndlCfgReq);
-
errInfo->errType = RGSCHERR_GOM_CFG_REQ;
/* Validate and process the configuration request */
RgSchCellCb *cell = instCb->rgrSap[spId].cell;
Inst inst = (instCb->rgSchInit.inst);
- TRC2(rgSCHGomHndlSCellActDeactReq);
RGSCHDBGPRM(inst,(rgSchPBuf(inst), "Processing RGR SCell Actication request:"
"%d\n", sCellActDeactEvnt->crnti));
RgSchCellCb *cell = instCb->rgrSap[spId].cell;
Inst inst = (instCb->rgSchInit.inst );
- TRC2(rgSCHGomHndlRecfgReq);
-
errInfo->errType = RGSCHERR_GOM_RECFG_REQ;
/* Validate and process the re-configuration request */
Inst inst = (instCb->rgSchInit.inst );
RgSchUeCb *ue = NULLP;
- TRC2(rgSCHGomHndlResetReq);
-
-
errInfo->errType = RGSCHERR_GOM_RESET_REQ;
/* Validate and process the UE reset request */
#endif
VOLATILE U32 startTime=0;
- TRC2(rgSCHGomHndlDelReq);
-
errInfo->errType = RGSCHERR_GOM_DEL_REQ;
if(instCb->rgrSap[spId].cell == NULLP)
#endif
{
- TRC2(rgSCHGomGetCellIdFrmCfgReq);
-
-
/* Extract CellId depending on the action and Config Type in the Request
* As of now this function is called for only re configuration so removed
* othe CASES below if needed we can add them*/
U8 nPrb = 0;
U8 mcs = 0;
- TRC2(rgSCHGomHndlSiCfg);
-
/* check if cell does not exists */
if (((U8 *)cell == NULLP) || (cell->cellId != cfgReqInfo->cellId))
return RFAILED;
}
- cmMemset((U8*)padding,(U8)0,nmPadBytes);
+ memset(padding,0,nmPadBytes);
#ifdef MS_MBUF_CORRUPTION
MS_BUF_ADD_ALLOC_CALLER();
U8 isEmtc = warningSiCfgReqInfo->emtcEnable;
#endif
- TRC2(rgSCHGomHndlWarningSiCfg);
-
#ifdef EMTC_ENABLE
if(TRUE == isEmtc)
{
RgSchWarningSiPdu *warningSiPdu;
Buffer *pdu;
- TRC3(rgSCHGomHndlWarningSiStopReq)
-
for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
{
if(cell->siCb.warningSi[idx].siId == siId)
CmLList *n;
S16 ret = RFAILED;
- TRC2(rgSchUpdtRNTPInfo);
-
l = &sf->sfrTotalPoolInfo.ccPool;
/*Get the first node from the CC Pool*/
RgSchErrInfo errInfo;
U16 i;
- TRC2(rgSCHGomHndlLoadInf);
-
-
/* check if cell does not exists */
if (((U8 *)cell == NULLP) || (cell->cellId != loadInfReq->cellId))
{
#endif /* ANSI */
{
U8 sfi;
- TRC3(rgSCHHdFddUeCfg)
RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
"rgSCHHdFddUeCfg(): UeId =%d hdFddEnbl=%d",
RgSchUeCb *ueCb;
#endif /* ANSI */
{
- TRC3(rgSCHHdFddUeDel)
RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
" rgSCHHdFddUeDel(): UeId =%d hdFdd=%x",
RgSchUePCqiCb *cqiCb = NULLP;
RgSchUePCqiCb *riCb = NULLP;
- TRC3(rgSCHCmnHdFddPtUlMrk)
timeInfo = cellCb->crntTime;
RgSchDlSf *sf = NULLP; /* Dl subframe info */
U8 ulOffset
- TRC3(rgSCHCmnHdFddChkUlAllow)
-
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
" rgSCHCmnHdFddChkUlAllow: ueId=%d ", ueCb->ueId);
CmLteTimingInfo timeInfo;
CmLteTimingInfo tempTimeInfo;
- TRC3(rgSCHCmnHdFddChkDlAllow)
-
*allow = FALSE;
timeInfo = cellCb->crntTime;
RgSchDlSf *sf;
CmLteTimingInfo tempTimeInfo;
- TRC3(rgSCHCmnHdFddChkNackAllow)
-
/* Information in timeInfo contains (n+DL_DELTA) th subframe info*/
*sndNACK = FALSE;
CmLteTimingInfo timeInfo;
U8 ulOffset;
- TRC3(rgSCHCmnHdFddUpdULMark)
-
-
ulOffset = RGSCH_PDCCH_PUSCH_DELTA -
TFU_CRCIND_ULDELTA + RGSCH_PDCCH_PUSCH_DELTA;
RG_SCH_ADD_TO_CRNT_TIME(cellCb->crntTime, timeInfo, ulOffset)
U16 sfi;
CmLteTimingInfo timeInfo;
- TRC3(rgSCHCmnHdFddUpdDLMark)
-
timeInfo = cellCb->crntTime;
RGSCH_INCR_SUB_FRAME(timeInfo, RG_SCH_CMN_DL_DELTA);
U16 tempSfn;
S16 tempSfCount;
- TRC3(rgSCHHdFddGetSfn)
if(((S16)(timeInfo.subframe) + offset) >= RGSCH_NUM_SUB_FRAMES)
{
/* Increament to number of times of SFNs that can be possible
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchUeDelInd)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
{
RgInfUeDelInd ueDelInd;
- TRC2(cmUnpkMacSchUeDelInd)
-
if(SRemPreMsgMult((Data *)&ueDelInd, sizeof(RgInfUeDelInd), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchDedBoUpdtReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfDedBoRpt boRpt;
- TRC2(cmUnpkMacSchDedBoUpdtReq)
-
if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfDedBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchCmnBoUpdtReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfCmnBoRpt boRpt;
- TRC2(cmUnpkMacSchCmnBoUpdtReq)
-
if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfCmnBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchSfRecpInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfSfDatInd* datInd;
- TRC2(cmUnpkMacSchCmnBoUpdtReq)
-
if(oduUnpackPointer((PTR *)&datInd, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchSpsRelInd)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
RgInfSpsRelInfo *relInfo;
- TRC2(cmUnpkMacSchSpsRelInd)
-
if(oduUnpackPointer((PTR *)&relInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacSfAllocReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfSfAlloc* resAllocReq;
- TRC2(cmUnpkSchMacSfAllocReq)
-
if(oduUnpackPointer((PTR *)&resAllocReq, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacRstHqEntReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfResetHqEnt* hqEntRstInfo;
- TRC2(cmUnpkSchMacRstHqEntReq)
-
if(oduUnpackPointer((PTR *)&hqEntRstInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacRlsHqReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfRlsHqInfo* sfHqInfo;
- TRC2(cmUnpkSchMacRlsHqReq)
-
if(oduUnpackPointer((PTR *)&sfHqInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacRlsRntiReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfRlsRnti rlsRnti;
- TRC2(cmUnpkSchMacRlsRntiReq)
-
if(SRemPreMsgMult((Data *)&rlsRnti, sizeof(RgInfRlsRnti), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacCellRegReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
{
RgInfCellReg regReq;
- TRC2(cmUnpkSchMacCellRegReq)
-
if(SRemPreMsgMult((Data *)®Req, sizeof(RgInfCellReg), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacLcgRegReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
RgInfLcgRegReq *lcgRegReq;
- TRC2(cmUnpkSchMacLcgRegReq)
-
if(oduUnpackPointer((PTR *)&lcgRegReq, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacSpsLcRegReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacUlSpsResetReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
RgInfSpsLcInfo *lcInfo;
- TRC2(cmUnpkSchMacSpsLcRegReq)
-
if(oduUnpackPointer((PTR *)&lcInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
{
RgInfUlSpsReset *ulSpsResetInfo;
- TRC2(cmUnpkSchMacUlSpsResetReq)
-
if(oduUnpackPointer((PTR *)&ulSpsResetInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacSpsLcDeregReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
CmLteCellId cellId;
CmLteRnti crnti;
- TRC2(cmUnpkSchMacSpsLcDeregReq)
-
CMCHKUNPK(cmUnpkLteRnti, &crnti, mBuf);
CMCHKUNPK(cmUnpkLteCellId, &cellId, mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacL2MeasReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacL2MeasStopReq)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- TRC2(cmPkSchMacL2MeasSendReq)
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
+ if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
RgInfL2MeasReq measInfo;
- TRC2(cmUnpkSchMacL2MeasReq)
-
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasReq), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
{
RgInfL2MeasStopReq measInfo;
- TRC2(cmUnpkSchMacL2MeasStopReq)
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
{
SPutMsg(mBuf);
{
RgInfL2MeasSndReq measInfo;
- TRC2(cmUnpkSchMacL2MeasSendReq)
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)
{
SPutMsg(mBuf);
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchL2MeasCfm)
-
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
Buffer *mBuf = NULLP;
- TRC2(cmPkMacSchL2MeasStopCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return RFAILED;
}
{
RgInfL2MeasCfm measCfm;
- TRC2(cmUnpkMacSchL2MeasCfm)
-
if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
{
RgInfL2MeasCfm measCfm;
- TRC2(cmUnpkMacSchL2MeasStopCfm)
-
if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
SPutMsg(mBuf);
U8 qciVal = 0;
U32 sampOc = 0;
- TRC3(rgSchFillL2MeasCfm)
-
measInfo = &measCb->measReq;
cfm->hdr.transId = measInfo->hdr.transId;
{
LrgSchMeasCfmInfo cfm;
- TRC3(rgSchL2mSndCfm)
-
- cmMemset((U8 *)&cfm, (U8)0, sizeof(LrgSchMeasCfmInfo));
+ memset(&cfm, 0, sizeof(LrgSchMeasCfmInfo));
cfm.hdr.transId = measInfo->hdr.transId;
cfm.measType = measInfo->measType;
cfm.cellId = measInfo->cellId;
#endif
{
-
- TRC3(rgSchL2mFillCfmPst)
-
-
cfmPst->srcEnt = pst->dstEnt;
cfmPst->srcInst = pst->dstInst;
cfmPst->srcProcId = pst->dstProcId;
RgSchL2MeasCb *oldMeasCb;
U32 diffTime;
- TRC3(rgSchL2mInsertMeasCb)
/*
* 1. Check if l2mList has any entries.
* 2. If yes
U8 idx;
#endif
- TRC3(rgSchL2CalDlPrbCount)
-
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
U8 idx;
#endif
- TRC3(rgSchL2CalUlPrbCount)
-
#ifdef LTE_TDD
idx = cellUl->schdIdx;
if(idx < cellUl->numUlSubfrms)
RgSchL2MeasCb *measCb = NULLP;
Inst inst = cell->instIdx;
UNUSED(err);
- TRC3(rgSchL2mAllocMeasCb)
if((rgSCHUtlAllocSBuf(inst, (Data **)&measCb,
sizeof(RgSchL2MeasCb))) == RFAILED)
"Allocation of RgSchL2MeasCb failed");
return (NULLP);
}
- cmMemcpy((U8 *)&measCb->measReq, (U8 *)measInfo, sizeof(LrgSchMeasReqInfo));
+ memcpy(&measCb->measReq, measInfo, sizeof(LrgSchMeasReqInfo));
RGSCHCPYTIMEINFO(cell->crntTime, measCb->startTime);
measCb->dlTotalBw = 0;
U8 idx;
U8 qciVal;
- TRC3(rgSchL2mMeasReq)
qciVal = 0;
if ((measCb = rgSchL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
"Allocation of RgSchL2MeasCb failed");
return RFAILED;
}
- /*cmMemcpy((U8 *)&measCb->measReq, (CONSTANT U8 *)measInfo,\
+ /*memcpy(&measCb->measReq, measInfo,\
sizeof(LrgSchMeasReqInfo));*/
rgSchL2mInsertMeasCb(cell, measCb, measInfo);
{
RgInfL2MeasReq measReq;
Pst pst;
- cmMemset((U8 *)&measReq, 0, sizeof(RgInfL2MeasReq));
+ memset(&measReq, 0, sizeof(RgInfL2MeasReq));
measReq.transId = measInfo->hdr.transId;
measReq.measType = measInfo->measType;
measReq.timePrd = measInfo->timePrd;
U32 numDlSf;
U32 numUlSf;
#endif
- TRC3(rgSCHL2Meas)
- node = cell->l2mList.first;
- cmMemset((U8 *)&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ node = cell->l2mList.first;
+ memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
while(node != NULLP)
{
measCb = (RgSchL2MeasCb *)node->node;
}
RgMiLrgSchL2MeasCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst),
&measCfm);
- cmMemset((U8 *)&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
/* Delete this measCb from the list */
if(measCb->measReq.timePrd > 0)
measCb->startTime = cell->crntTime;
measCb->sfnCycle = 0;
measCb->cfmRcvd = FALSE;
- cmMemset((U8 *)&measCb->avgPrbQciUl, 0, sizeof(LrgAvgPrbQCICfm));
+ memset(&measCb->avgPrbQciUl, 0, sizeof(LrgAvgPrbQCICfm));
cell->sndL2Meas = FALSE;
}
/* ccpu00117052 - MOD - Passing double pointer
RgSchUpSapCfgInfo *upSapCfg = NULLP;
Inst inst = (dInst - SCH_INST_START);
- TRC2(rgSCHLmmSapCfg)
-
/* Check if Gen Config has been done */
switch(sapType)
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:
RgSchClcBoRpt *bo = NULL;
#endif
- TRC2(rgSCHLmmShutdown)
-
#ifdef LTE_L2_MEAS
for (idx = 0; idx < instCb->numSaps; idx++)
{
#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;
}
/* 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;
{
Inst inst;
- TRC2(SchFillCfmPst)
-
inst = (reqPst->dstInst - SCH_INST_START);
cfmPst->srcEnt = ENTMAC;
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;
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;
#ifdef DEBUGP
Inst inst = tfuSap->cell->instIdx;
#endif
- TRC2(rgSCHLmmTmrExpiry)
switch(tmrEvnt)
Pst cfmPst;
Inst inst = (pst->dstInst - SCH_INST_START); /* scheduler instance */
- TRC2(rgSCHLmmBndCfm)
-
/* check the SAP State */
switch(rgSchCb[inst].tfuSap[suId].sapSta.sapState)
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)
{
{
RgMngmt usta;
- TRC2(rgSCHLmmStaInd)
-
if(rgSchCb[inst].rgSchInit.usta == FALSE)
{
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 =
#endif
{
Inst schInst = (inst - SCH_INST_START);
- TRC2(schActvTmr)
/* Check if any timer in the scheduler instance has expired */
cmPrcTmr(&rgSchCb[schInst].tmrTqCp,
#endif
{
- TRC2(rgSCHMeasGapANRepUeCfg);
-
-
ue->measGapCb.isMesGapEnabled = ueCfg->ueMesGapCfg.isMesGapEnabled;
if (ueCfg->ueMesGapCfg.isMesGapEnabled)
RgrUeAckNackRepCfg *ackNackReCfg = &(ueRecfg->ueAckNackRecfg);
RgSchUeAckNakRepCb *ackNakRepCb = &(ue->ackNakRepCb);
- TRC2(rgSCHMeasGapANRepUeRecfg);
-
-
reCfg = &(ueRecfg->ueMeasGapRecfg);
ueMeasCb = &(ue->measGapCb);
#endif
{
- TRC2(rgSCHMeasGapANRepUtlAddUe);
-
switch (cfg->gapPrd)
{
case RG_MEAS_GAPPRD_40:
#endif
{
- TRC2(rgSCHMeasGapANRepUtlRmvUe);
-
switch (ue->measGapCb.gapPrd)
{
case RG_MEAS_GAPPRD_40:
#endif
{
-
- TRC2(rgSCHMeasGapANRepUeDel);
-
if (ue->measGapCb.isMesGapEnabled)
{
rgSCHMeasGapANRepUtlRmvUe (cell, ue);
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
- TRC3(rgSchAckNackRepUtlRmvUe);
-
for (hqIdx = 0; hqIdx < hqEnt->numHqPrcs; hqIdx++)
{
hqP = &hqEnt->procs[hqIdx];
RgSchDlSf *dlSf;
CmLteTimingInfo repTime;
- TRC2(rgSCHMeasGapANRepTtiHndl);
-
/* Measurement GAP Starts at offSet - however at MAC we are concerned at
* subframe + TFU_DELTA.
*/
CmLList *node;
RgSchUeCb *ue;
- TRC2(rgSchAckNackRepUtlHdlTti);
-
node = ackNackRepQ->first;
while (node)
{
CmLList *node;
RgSchUeCb *ue;
- TRC2(rgSCHMeasGapANRepUtlHdlTti);
-
node = measGapQ->first;
while (node)
{
RgSchDlHqTbCb *tbCb;
U32 i;
- TRC2(rgSCHMeasGapANRepGetDlInactvUe);
-
schedTime = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot + RG_DL_DELTA;
#ifdef LTE_TDD
RgSchDlHqTbCb *tbCb;
U32 i;
- TRC2(rgSCHMeasGapANRepGetUlInactvUe);
-
/*ccpu00139481- Meas Gap should be monitored in UL with TFU_ULCNTRL_DLDELTA*/
schedTime = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot + \
TFU_ULCNTRL_DLDELTA;
{
RgSchCellCb *cell = ue->cell;
- TRC2(rgSCHMeasGapANRepDlInactvTmrExpry);
switch (tmrEvnt)
{
#endif
{
RgSchCellCb *cell = ue->cell;
- TRC2(rgSCHMeasGapANRepUlInactvTmrExpry);
switch (tmrEvnt)
{
#endif
{
- TRC2(rgSCHMeasGapANRepTmrExpry);
-
ue->measGapCb.isMeasuring = FALSE;
cmInitTimers (&ue->measGapCb.measGapTmr, 1);
#endif
{
- TRC2(rgSCHAckNakRepTmrExpry);
-
ue->ackNakRepCb.isAckNakRep = FALSE;
cmInitTimers (&ue->ackNakRepCb.ackNakRepTmr, 1);
RgSchDlHqTbCb *tbCb;
U32 i;
- TRC2(rgSCHAckNakRepAddToQ);
-
node = crntDlSf->ueLst.first;
while (node)
{
S16 idx;
S8 diff;
- TRC2(rgSCHAckNakRepFindUlDuration)
rgSCHAckNakRepGetUlOffsetFrmDl(dlSf, repTime, &noSubfrms);
RG_SCH_ADD_TO_CRNT_TIME(repTime, ulfrm, noSubfrms);
diff = repCnt-1;
U8 *noSubfrms;
#endif
{
- TRC2(rgSCHAckNakRepGetUlOffsetFrmDl)
if(dlSf->dlFdbkInfo.sfnOffset != 0)
{
#endif
{
- TRC3(RgSchMacCellReg);
-
return ((*RgSchMacCellRegReqMt[0])(pst, regReq));
}
#endif
{
- TRC3(RgMacSchDedBoUpdt);
-
return ((*RgMacSchDedBoUpdtReqMt[0])(pst, boRpt));
}
#endif
{
- TRC3(RgMacSchCmnBoUpdt);
-
return ((*RgMacSchCmnBoUpdtReqMt[0])(pst, boRpt));
}
#endif
{
- TRC3(RgMacSchUeDel);
-
return ((*RgMacSchUeDelIndMt[0])(pst, ueDelInd));
}
/*Fix: end: Inform UE delete to scheduler*/
#endif
{
- TRC3(RgMacSchSfRecp);
-
return ((*RgMacSchSfRecpIndMt[0])(pst, datInd));
}
#endif
{
- TRC3(RgSchMacSfAlloc);
-
return ((*RgSchMacSfAllocReqMt[0])(pst, resAllocReq));
}
#endif
{
- TRC3(RgSchMacRstHqEnt)
-
return ((*RgSchMacRstHqEntReqMt[0])(pst, hqEntInfo));
}
#endif
{
- TRC3(RgSchMacRlsHq);
-
return ((*RgSchMacRlsHqReqMt[0])(pst, sfHqInfo));
}
#endif
{
- TRC3(RgSchMacRlsRnti);
-
return ((*RgSchMacRlsRntiReqMt[0])(pst, rlsRnti));
}
#endif
{
- TRC3(RgSchMacLcgReg);
-
return ((*RgSchMacLcgRegReqMt[0])(pst, lcgRegReq));
} /* end of RgSchMacLcgReg */
#endif
{
- TRC3(RgMacSchS);
-
return ((*RgMacSchSpsRelIndMt[0])(pst, relInfo));
} /* end of RgMacSchSpsRel */
#endif
{
- TRC3(RgSchMacSpsLcReg);
-
return ((*RgSchMacSpsLcRegReqMt[0])(pst, lcInfo));
} /* end of RgSchMacSpsLcReg */
#endif
{
- TRC3(RgSchMacUlSpsReset);
-
return ((*RgSchMacUlSpsResetMt[0])(pst, ulSpsResetInfo));
} /* end of RgSchMacUlSpsReset */
#endif
{
- TRC3(RgSchMacSpsLcDereg);
-
return ((*RgSchMacSpsLcDeregReqMt[0])(pst, cellId, crnti));
} /* end of RgSchMacSpsLcDereg */
#endif
{
- TRC3(RgSchMacL2Meas);
-
return ((*RgSchMacL2MeasReqMt[0])(pst, measInfo));
} /* end of RgSchMacL2Meas */
#endif
{
- TRC3(RgSchMacL2MeasStop);
-
return ((*RgSchMacL2MeasStopReqMt[0])(pst, measInfo));
} /* end of RgSchMacL2Meas */
#endif
{
- TRC3(RgSchMacL2MeasSend);
-
return ((*RgSchMacL2MeasSendReqMt[0])(pst, measInfo));
} /* end of RgSchMacL2MeasSend */
#endif
{
- TRC3(RgMacSchL2Meas);
-
return ((*RgMacSchL2MeasCfmMt[0])(pst, measInfo));
} /* end of RgSchMacL2Meas */
/**
#endif
{
- TRC3(RgMacSchL2MeasStop);
-
return ((*RgMacSchL2MeasStopCfmMt[0])(pst, measInfo));
} /* end of RgSchMacL2MeasStop*/
#endif/*LTE_L2_MEAS*/
#endif
{
U8 idx;
- TRC2(rgSCHPwrInit);
rgSchPwrCqiToPwrTbl[0] = 0; /* This should never be used anyway */
for (idx = 1; idx < RG_SCH_CMN_UL_NUM_CQI; ++idx)
U8 cqi;
#endif
{
- TRC2(rgSCHPwrGetCqiPwr);
return (rgSchPwrCqiToPwrTbl[cqi]);
} /* rgSCHPwrGetCqiPwr */
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrGetCqiPwrForUe);
if (!uePwr->deltaMcsEnbld)
{
{
F64 ks = 1.25; /* or F64 */
F64 tmp = cmPow(2, ks*eff/1024) - 1;
- TRC2(rgSCHPwrCalcEfficncyPwr);
if (tmp <= 0)
return (0);
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue,cell);
UNUSED(cell);
- TRC2(rgSCHPwrPuschTpcForUe);
rgSCHPwrOnSchedPuschTpc(cell, ue);
return (uePwr->puschTpc);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrGetMaxUlRb);
rgSCHPwrPuschCntrl(cell, ue); /* This stores tpc, delta and maxRb
* in uePwr */
UNUSED(cell);
- TRC2(rgSCHPwrPuschCntrl);
-
if (!uePwr->isPhrAvail)
{
availPwr = 60; /* setting a large value so that availPwr does
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrPucchTpcForUe);
rgSCHPwrPucchCntrl(cell, ue);
return (uePwr->pucchTpc);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrGetDelta2FrmCqi);
if (uePwr->isPhrAvail)
{
S8 *tpcDelta;
#endif
{
- TRC2(rgSCHPwrGetPuschTpc);
delta = RGSCH_MIN(delta, availPwr);
{
RgSchCmnUlCell *cellUl;
- TRC2(rgSCHPwrGetMaxRb);
-
cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
if (pwr <= 0)
{
#ifndef NO_ERRCLS
RgSchCmnUlCell *cellUl;
#endif
- TRC2(rgSCHPwrRbToPwr);
#if (ERRCLASS & ERRCLS_DEBUG)
cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
if (numRb > cellUl->maxUlBwPerUe)
{
S8 delta;
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrPucchCntrl);
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, &uePwr->pucchTpc, &delta);
rgSCHPwrOnSchedPucchTpc(cell, ue, delta);
CmLListCp *lst;
CmLList *lnk;
RgSchPdcch *pdcch;
- TRC2(rgSCHPwrGrpCntrlPucch);
lst = &cellPwr->pucchGrpPwr;
lnk = lst->first;
CmLListCp *lst;
CmLList *lnk;
RgSchPdcch *pdcch;
- TRC2(rgSCHPwrGrpCntrlPusch);
lst = &cellPwr->puschGrpPwr;
lnk = lst->first;
U8 tpc;
S8 delta;
Bool atleastOne;
- TRC2(rgSCHPwrSchedPucchRnti);
pdcch->rnti = cb->tpcRnti;
pdcch->dci.u.format3Info.isPucch = TRUE;
/* Fill TPC 1 (corresponding to no power change) initially */
- cmMemset((U8 *)tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
+ memset(tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
for (atleastOne = FALSE, lnk = lst->first; lnk; lnk = lnk->next)
{
U8 tpc;
S8 delta;
Bool atleastOne;
- TRC2(rgSCHPwrSchedPuschRnti);
pdcch->rnti = cb->tpcRnti;
tpcCmds = pdcch->dci.u.format3Info.tpcCmd;
/* Fill TPC 1 (corresponding to no power change) initially */
- cmMemset((U8 *)tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
+ memset(tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
for (atleastOne = FALSE, lnk = lst->first; lnk; lnk = lnk->next)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrGetPucchFmt3TpcForUe);
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, tpc, delta);
RETVOID;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrGetPucchFmt3aTpcForUe);
rgSCHPwrGetAcc1bitTpc(uePwr->remPucchPwr, tpc, delta);
RETVOID;
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
S8 adj = RGSCH_MIN(uePwr->remPuschPwr, uePwr->phVal);
- TRC2(rgSCHPwrGetPuschFmt3TpcForUe);
rgSCHPwrGetAcc2bitTpc(adj, tpc, delta);
RETVOID;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrGetPuschFmt3aTpcForUe);
/* Don't attempt to look at headroom now, power
* adjustment is small anyway */
S8 *delta;
#endif
{
- TRC2(rgSCHPwrGetAcc1bitTpc);
/*
* TPC delta
* 0 -1
*/
U8 tpcs[3] = {1, 2, 2};
U8 deltas[3] = {0, 1, 1};
- TRC2(rgSCHPwrGetAcc2bitTpc);
if (remPwr <= -1)
{
*tpc = 0;
S8 *delta;
#endif
{
- TRC2(rgSCHPwrGetAbsTpc);
/*
* TPC delta
* 0 -4
UNUSED(cell);
- TRC2(rgSCHPwrOnPucchGrpPwrForUe);
-
uePwr->remPucchPwr -= delta;
/* UE was already scheduled for PUCCH group power
Bool rmvUe = FALSE;
UNUSED(cell);
- TRC2(rgSCHPwrOnPuschGrpPwrForUe);
uePwr->delta = delta;
uePwr->remPuschPwr -= delta;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
RgSchDlHqProcCb *proc = rgSCHDhmLastSchedHqProc(hqEnt);
- TRC2(rgSCHPwrIsDlUeSched);
-
if (proc == NULLP)
{
return (FALSE);
RgSchCmnUlCell *cmnCell = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlHqProcCb *proc = rgSCHUhmGetUlHqProc(cell, ue, cmnCell->schdHqProcIdx);
- TRC2(rgSCHPwrIsUlUeSched);
-
UNUSED(sf);
#if (ERRCLASS & ERRCLS_DEBUG)
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgSchCmnTpcRntiCb *cb;
Bool toAdd;
- TRC2(rgSCHPwrPucchDeltaInd);
uePwr->remPucchPwr = pwrDelta;
* improved its remPwr as part of power control. */
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
Bool rmvUe = FALSE;
- TRC2(rgSCHPwrOnSchedPucchTpc);
uePwr->remPucchPwr -= delta;
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
Bool rmvUe = FALSE;
- TRC2(rgSCHPwrOnSchedPuschTpc);
/* Don't do anything for the case of absolute TPC commands */
if (!uePwr->isAccumulated)
RgInfExtPhrSCellInfo *servCellPhr;
S8 pCMax;
- TRC2(rgSCHPwrUpdExtPhr);
-
for (idx = 0; idx < extPhr->numServCells; idx++)
{
servCellPhr = &extPhr->servCellPhr[idx];
U8 effPwr;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHPwrUpdPhr);
-
uePwr->phVal = rgSCHPwrGetPhValFromPhr(phr);
if (maxUePwr == RG_SCH_CMN_PWR_USE_CFG_MAX_PWR)
#ifdef TFU_UPGRADE
S32 tmp;
#endif
- TRC2(rgSCHPwrUlCqiInd);
/*
* For absolute power cmd case, we could look at the time
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
UNUSED(cell);
- TRC2(rgSCHPwrRecordRbAlloc);
RETVOID;
if (uePwr->isPhrAvail)
CmLteRnti startRnti;
U16 size;
Bool isFmt3a;
- TRC2(rgSCHPwrCellCfg);
/* Right now, all UEs have fixed maximum power capability. So
* we store cell wide pMax as minimum of configured pMax and
{
UNUSED(cell);
UNUSED(recfg);
- TRC2(rgSCHPwrCellRecfg);
/* Not doing anything for power reconfig, so such structure
* in RGR */
#endif
{
UNUSED(cell);
- TRC2(rgSCHPwrCellDel);
/* There is no allocated memory, so do nothing */
RETVOID;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHPwrUeSCellCfg);
uePwr->maxUePwr = cellPwr->pMax;
uePwr->trgCqi = cellPwr->trgUlCqi; /* Overriding with UE's happens later */
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHPwrUeCfg);
-
uePwr->maxUePwr = cellPwr->pMax;
uePwr->trgCqi = cellPwr->trgUlCqi; /* Overriding with UE's happens later */
uePwr->numRb = 1;
S16 ret;
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgrUeUlPwrCfg *pwrCfg = &recfg->ueUlPwrRecfg;
- TRC2(rgSCHPwrUeRecfg);
if (pwrCfg->p0UePucch != uePwr->p0UePucch)
{
RgSchCmnTpcRntiCb *puschRntiCb = NULLP;
U8 pucchIdx = 0;
U8 puschIdx = 0;
- TRC2(rgSCHPwrApplyUePwrCfg);
/* Validate Pucch group power control config */
if (pwrCfg->uePucchPwr.pres)
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrUeDel);
if (uePwr->tpcPucchRntiCb)
{
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHPwrUeReset);
rgSCHPwrUeResetPucch(cell, ue);
rgSCHPwrUeResetPusch(cell, ue);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrUeResetPucch);
uePwr->pucchTpc = 1;
uePwr->remPucchPwr = 0;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrUeResetPusch);
uePwr->isPhrAvail = FALSE;
uePwr->phVal = 40;
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgSchCmnTpcRntiCb *cb;
Bool toAdd;
- TRC2(rgSCHPwrOnPuschPwrUpd);
if ((cb = uePwr->tpcPuschRntiCb) == NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddRntiToPucchRntiLst);
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPucchRntiLst[cellPwr->tpcPucchRntiCnt++],
rnti, isFmt3a);
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddRntiToPuschRntiLst);
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPuschRntiLst[cellPwr->tpcPuschRntiCnt++],
rnti, isFmt3a);
Bool isFmt3a;
#endif
{
- TRC2(rgSCHPwrInitTpcRntiCb);
- cmMemset((U8 *)cb, 0, sizeof(*cb));
+ memset(cb, 0, sizeof(*cb));
cb->tpcRnti = rnti;
cb->isFmt3a = isFmt3a;
/* Not initialising lists as memset 0 takes care of it */
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
U16 idx;
- TRC2(rgSCHPwrGetPucchRntiCb);
if (!cellPwr->tpcPucchRntiCnt)
{
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
U16 idx;
- TRC2(rgSCHPwrGetPuschRntiCb);
if (!cellPwr->tpcPuschRntiCnt)
{
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
UNUSED(cell);
- TRC2(rgSCHPwrAddUeToPucchTpcRntiCb);
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->pucchGrpLnk);
uePwr->pucchGrpLnk.node = (PTR)ue;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrDelUeFrmPucchTpcRntiCb);
rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->pucchGrpLnk);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb);
if (uePwr->schdPucchGrpLnk.node == NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeOnlyFrmPucchTpcRntiCb);
if (uePwr->schdPucchGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrRmvSchdPucchTpcRntiCb);
if (cb->schdLnk.node == NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrAddSchdUeToPucchTpcRntiCb);
if (uePwr->schdPucchGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddSchdPucchTpcRntiCb);
cmLListAdd2Tail(&cellPwr->pucchGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrAddUeToPuschTpcRntiCb);
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->puschGrpLnk);
uePwr->puschGrpLnk.node = (PTR)ue;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrAddSchdUeToPuschTpcRntiCb);
if (uePwr->schdPuschGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrDelUeFrmPuschTpcRntiCb);
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->puschGrpLnk);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb);
if (uePwr->schdPuschGrpLnk.node == NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeOnlyFrmPuschTpcRntiCb);
if (uePwr->schdPuschGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddSchdPuschTpcRntiCb);
cmLListAdd2Tail(&cellPwr->puschGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrRmvSchdPuschTpcRntiCb);
if (cb->schdLnk.node == NULLP)
{
U8 idx;
#endif
{
- TRC2(rgSCHPwrChkPucchTpcRntiIdx);
if (rgSCHPwrChkTpcRntiIdx(cb, idx) != ROK)
{
U8 idx;
#endif
{
- TRC2(rgSCHPwrChkPuschTpcRntiIdx);
if (rgSCHPwrChkTpcRntiIdx(cb, idx) != ROK)
{
#endif
{
CmLList *lnk;
- TRC2(rgSCHPwrChkUniqPucchTpcRntiIdx);
for (lnk = cb->cfgdUes.first; lnk; lnk = lnk->next)
{
#endif
{
CmLList *lnk;
- TRC2(rgSCHPwrChkUniqPuschTpcRntiIdx);
for (lnk = cb->cfgdUes.first; lnk; lnk = lnk->next)
{
U8 idx;
#endif
{
- TRC2(rgSCHPwrChkTpcRntiIdx);
-
if (cb->isFmt3a)
{
if (idx >= TFU_MAX_1BIT_TPC)
U8 pCMax;
#endif
{
- TRC2(rgSCHPwrGetPCMaxValFromPCMax);
return ((pCMax & 63) - 30);
}
U8 phr;
#endif
{
- TRC2(rgSCHPwrGetPhValFromPhr);
return ((phr & 63) - 23);
}
RgrUeCfg *ueCfg;
#endif
{
- TRC2(rgSCHRamVldtUeCfg);
if (ueCfg->dedPreambleId.pres == PRSNT_NODEF)
{
if ((ueCfg->dedPreambleId.val < cell->rachCfg.numRaPreamble) ||
U8 tid;
#endif
- TRC2(rgSCHRamProcRaReq)
/* SR_RACH_STATS : RACH REQ */
RgSchRntiLnk *rntiLnk;
Inst inst = cell->instIdx;
- TRC2(rgSCHRamCreateRaCb)
if((rgSCHUtlAllocSBuf(inst, (Data **)(raCb),
sizeof(RgSchRaCb))) == RFAILED)
/* U32 cnt; */
RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
- TRC2(rgSCHRamRgrUeCfg)
/* Fix : set UE inactive in DL until UE is reinitialization completed */
{
TfuUlCqiRpt ulCqiRpt;
RgSchCmnCell *cellSch= (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHRamContResCrnti)
/* Fix: syed It is incorrect to copy over msg3HqProc to ueCb's
CmLteTimingInfo expTime = {0};
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
- TRC2(rgSCHRamContResCcchsdu)
if(raCb->raState != RGSCH_RA_MSG3_PENDING)
{
RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHRamProcMsg3)
/* Update raCb with PHR if received along with Msg3 */
RgInfCmnBoRpt *staRsp;
#endif
{
- TRC2(rgSCHRamUpdtBo)
/* Update Bo in RaCb */
raCb->dlCcchInfo.bo = (U32)(staRsp->bo);
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHRamMsg3DatInd)
/* SR_RACH_STATS : MSG3 ACK*/
rgNumMsg3CrcPassed++;
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHRamMsg3FailureInd)
/*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
rgSCHUhmProcMsg3Failure(&(raCb->msg3HqProc));
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHRamMsg4FdbkInd)
return ROK;
} /* rgSCHRamMsg4FdbkInd */
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHRamMsg4Done)
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHRamMsg4Done(): tmpCRNTI = %u",
{
Inst inst = cell->instIdx;
Bool isEmtc = FALSE;
- TRC2(rgSCHRamDelRaCb)
/* Delete from all the lists it is enqueued */
cmLListDelFrm(&(cell->raInfo.raCbLst),&(raCb->raCbLnk));
U8 raIdx;
#endif
- TRC2(rgSCHRamTtiHndlr)
crntSfn = cell->crntTime.sfn;
#endif
- TRC2(rgSCHRamFreeCell)
#ifdef LTE_TDD
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHRamProcContResExp);
raCb->expiryTime.sfn = RGSCH_CONTRES_EXP;
/*MSG4 Fix*/
if (raCb->ue)
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHRamProcContResGrdExp)
/*Guard timer has expired, schedule only the contention REsolution CE with
CmLList *chkLnk = NULLP;
RgSchRaCb *raCb = NULLP;
- TRC2(rgSCHChkContResTmrExp)
chkLnk = cmLListFirst(&(cell->contResTmrLst));
CmLList *chkLnk = NULLP;
RgSchRaCb *raCb = NULLP;
- TRC2(rgSCHChkContResGrdTmrExp)
chkLnk = cmLListFirst(&(cell->contResGrdTmrLst));
U8 raRntiIdx;
CmLteRnti raRnti;
- TRC2(rgSCHRamDelRaReq)
rachRsp = &cell->rachRspLst[raIdx];
CmLteTimingInfo expTime ={0};
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHRamAddToRaInfoSchdLst)
/*Fix: This can be called even when guard timer is not expired.
* In this case CR timer expiry should be guard timer expiry time + Guard timer time*/
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHRamRmvFrmRaInfoSchdLst)
cmLListDelFrm(&(cell->raInfo.toBeSchdLst), &(raCb->schdLnk));
raCb->schdLnk.node = NULLP;
Bool isEmtc;
#endif
{
- TRC2(rgSCHRamUlFreeAllocation);
rgSCHUhmFreeProc(alloc->hqProc, cell);
if(!isEmtc)
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHSc1DlUeReset);
rgSCHSc1DlSuspendUe(cell, ue);
RgSchDlHqProcCb *hqP;
RgSchDlLcCb *svc;
U8 idx;
- TRC2(rgSCHSc1DlActvtUe);
/* Add UE's HqProcs From UERetxLst to CellRetxLst */
lst = &ueDl->retxHqProcs;
CmLListCp *lst;
CmLList *node;
RgSchDlLcCb *svc;
- TRC2(rgSCHSc1DlUeRefresh);
if (ue->dl.ambrCfgd)
{
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
RgSchCmnDlHqProc *hqProcDl = RG_SCH_CMN_GET_DL_HQP(hqP);
- TRC2(rgSCHSc1DlProcRmvFrmCellRetx);
if (hqProcDl->retxLnk.node != NULLP)
{
RgSchSc1DlUe *sc1Ue = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlHqProc *hqProcDl = RG_GET_SC1_HQP_DL(hqP);
- TRC2(rgSCHSc1DlProcRmvFrmUeRetx);
if (hqProcDl->retxLnkUe.node != NULLP)
{
RgSchSc1DlUe *sc1Ue = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlHqProc *cmnHqDl = RG_GET_SC1_HQP_DL(hqP);
- TRC2(rgSCHSc1DlProcAddToUeRetx);
cmLListAdd2Tail(&sc1Ue->retxHqProcs,
&(cmnHqDl->retxLnkUe));
RgSchSc1DlCell *sc1CellDl = RG_GET_SC1_CELL_DL(cell);
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
- TRC2(rgSCHSc1DlProcAddToCellRetx);
if (!RG_SCH_CMN_DL_IS_UE_ACTIVE(hqP->hqE->ue))
{
Bool dlAllowed = FALSE;
#endif
RgSchDlRbAlloc *dlAllocCb;
- TRC2(rgSCHSc1DlRetxAlloc);
sc1CellDl = RG_GET_SC1_CELL_DL(cell);
#if (defined(LTEMAC_SPS) || (!defined(LTE_TDD)))
RgSchDlHqProcCb *hqProc;
#endif
{
- TRC2(rgSCHSc1RlsHqProc)
rgSCHDhmRlsHqProc(hqProc);
RETVOID;
}
#endif
S16 ret;
- TRC2(rgSCHSc1DlDedSvcAlloc);
/* Get the UE to which this service belongs to */
ue = svc->ue;
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchSc1DlUe *ueSc1 = RG_GET_SC1_UE_DL(ue, cell);
- TRC2(rgSCHSc1DlAdd2UeSchdSvcs);
/* checking SVC's presence in this lst is unnecessary */
cmLListAdd2Tail(&ueSc1->schdSvcs, &svcSc1->schdSvcLnk);
RgSchSc1DlUe *ueDl;
RgSchSc1DlCell *sc1CellDl = RG_GET_SC1_CELL_DL(cell);
- TRC2(rgSCHSc1DlDedTx);
/* Process the first queue that is for RRC signalling and is of */
/* highest priority. */
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHSc1DlPreSchd);
RETVOID;
}
Inst schInst
#endif
{
- TRC2(rgSCHSc1DlPstSchd);
RETVOID;
}
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHSc1DlDedNewTx);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "rgSCHSc1DlDedNewTx\n"));
/* Now perform the new UE selections */
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHSc1DlDedRetx);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "rgSCHSc1DlDedRetx\n"));
rgSCHSc1DlRetxAlloc(cell, subFrm, allocInfo);
RgSchSc1DlCell *sc1CellDl = RG_GET_SC1_CELL_DL(cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcAddToSchd);
svcSc1 = RG_GET_SC1_SVC_DL(svc->ue,svc,cell);
/* The service is already in the scheduler */
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
CmLListCp *lst;
- TRC2(rgSCHSc1DlUeRmvFrmSchd);
lst = &cellDl->prioLst[ueDl->prio];
if (ueDl->prioLnk.node != NULLP)
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
CmLListCp *lst;
- TRC2(rgSCHSc1DlSvcRmvFrmUeAmbrLst);
-
lst = &ueDl->ambrLst;
if (svcSc1->prioLnk.node != NULLP)
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcAddToUeAmbrLst);
/* If svc already present in AMBR List return */
if (svcSc1->prioLnk.node != NULLP)
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
CmLListCp *lst;
- TRC2(rgSCHSc1DlSvcRmvFrmSchd);
lst = &(cellDl->prioLst[svcCmn->prio]);
if (svcDl->prioLnk.node != NULLP)
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcAdd);
UNUSED(cfg);
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlLcRmv);
if (svcSc1 == NULLP)
{
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcMod);
if (RG_SCH_CMN_SVC_IS_GBR(svc))
{
CmLList *node;
CmLListCp *lst;
RgSchUeCb *nodeUe = NULLP;
- TRC2(rgSCHSc1DlUeAddToSchd);
ueDl->prio = ((RgSchCmnDlSvc *)(ueDl->ambrSvc->sch))->prio;
lst = &cellDl->prioLst[ueDl->prio];
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlMngAmbrSvcPosn);
-
if (svcSc1->bo == 0)
{
if (ueDl->ambrSvc == svc)
#endif
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlLcBoUpd);
if (svcSc1->bo == svc->bo)
{
#endif
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlMngPrio0SvcPosn);
/* In this priority, we just add or remove to the queue */
if (svcSc1->bo > 0)
#endif
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlMngGbrSvcPosn);
/* Handle a GBR service. */
svcSc1->effGbr = RGSCH_MIN(svcSc1->bo, svcSc1->gbr);
{
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
- TRC2(rgSCHSc1DlMngSvcPosn);
(cellDl->svcMngFunc[svcCmn->prio])(cell, ue, svc);
RETVOID;
S16 ret;
RgSchSc1DlCell *cellDl;
- TRC2(rgSCHSc1RgrDlCellCfg);
if((ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(((RgSchCmnCell*)((cell)->sc.sch))->dl.schSpfc), \
#endif
{
U8 i;
- TRC2(rgSCHSc1DlDeinitQueues);
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHSc1DlCellDel);
if (((RgSchSc1DlCell *)((RgSchCmnCell*)((cell)->sc.sch))->dl.schSpfc) \
== NULLP)
Inst inst = cell->instIdx;
RgSchSc1DlUe *ueDl;
- TRC2(rgSCHSc1RgrDlUeCfg);
if((rgSCHUtlAllocSBuf(inst,
(Data**)&(ueSchCmn->dl.schSpfc), (sizeof(RgSchSc1DlUe))) != ROK))
RgSchSc1DlHqProc *hqSpcSch;
RgSchDlHqProcCb *hqP;
U8 cnt;
- TRC2(rgSCHSc1DlUeHqEntInit);
/* making use of hqE->sch for one shot allocation
* of RgSchSc1DlHqProc structures */
if (rgSCHUtlAllocSBuf(cell->instIdx,
RgSchDlHqEnt *hqE;
#endif
{
- TRC2(rgSCHSc1DlUeHqEntDeInit);
if(hqE->sch)
{
RgSchCmnDlUe *ueCmnDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
/*cell added as part of CA dev*/
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
- TRC2(rgSCHSc1RgrDlUeRecfg);
if (ue->dl.ambrCfgd)
{
RgSchDlLcCb *svc;
U32 idx;
- TRC2(rgSCHSc1DlRmvUeFrmPrioQs);
sc1Ue = RG_GET_SC1_UE_DL(ue, cell);
U8 i;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
- TRC2(rgSCHSc1DlInactvtUe);
/* ccpu00130170: UE related HARQ Procs are cleared only
if UE's Re-establishment procedure is not in progress*/
U8 j;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
- TRC2(rgSCHSc1DlSuspendUe);
/* remove all in use HARQ processes from the subframes.
* Store them in UEs hqProc Lst. Add back to cell's
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHSc1DlScanUpdPdbPrio);
RETVOID;
}
RgInfSfAlloc *sfAlloc;
#endif
{
- TRC2(rgSCHSc1DlFillFlowCntrlInfo);
return ROK;
}
/**
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
RgSchSc1DlUe *sc1DlUe = RG_GET_SC1_UE_DL(ue, cell);
- TRC2(rgSCHSc1DlUeDel);
if (sc1DlUe == NULLP)
{
#endif
{
S16 ret;
- TRC2(rgSCHSc1RgrLcCfg);
ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(RG_SCH_CMN_GET_LC_SCH_SPFC(ue,dlLc,cell)), \
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrLcRecfg);
UNUSED(err);
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1DlUeReset);
return ROK;
}
#ifdef LTEMAC_HDFDD
Bool dlAllowed = FALSE;
#endif
- TRC2(rgSCHSc1DlTaCmd);
lst = &cellCmnDl->taLst;
node = lst->first;
CmLList *node;
RgSchUeCb *ue;
- TRC2(rgSCHSc1DlHndlInActUes);
node = inactvLst->first;
while(node)
RgDlSchdApis *rgSchDlApis;
#endif
{
- TRC2(rgSCHSc1DlInit);
/* Init the function pointers */
rgSchDlApis->rgSCHRgrDlUeCfg = rgSCHSc1RgrDlUeCfg;
rgSchDlApis->rgSCHRgrDlUeRecfg = rgSCHSc1RgrDlUeRecfg;
#endif
{
U8 i;
- TRC2(rgSCHSc1DlInitQueues);
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
RgSchDlRbAlloc *dlAllocCb = NULLP;
- TRC2(rgSCHSc1DlRetxAllocFnlz);
node = allocInfo->dedAlloc.schdRetxHqPLst.first;
while(node)
U32 effBo;
U32 rlcHdrEstmt;
- TRC2(rgSCHSc1DlSprTxTbDstn);
while((*node) && (*effAlloc > 0))
{
RgSchLchAllocInfo lchSchdData;
CmLList *prev = NULLP;
- TRC2(rgSCHSc1DlNewTxTbDstn);
if (ueDl->taReqBytes)
{
/*ccpu00120365-ADD-added to code to check if second TB is utilized */
U32 tb2Bytes = 0;
- TRC2(rgSCHSc1DlNewTxUeFnlz);
/* 3.1 MIMO Consider the allocation of New TX TB for distribution */
RgSchUeCb *ue;
RgSchCmnDlUe *cmnUeDl;
RgSchDlHqProcCb *hqP;
- TRC2(rgSCHSc1DlNewTxAllocFnlz);
node = allocInfo->dedAlloc.schdTxHqPLst.first;
while(node)
RgSchDlRbAlloc *ueAllocInfo;
RgSchDlRbAlloc *dlAllocCb;
- TRC2(rgSCHSc1DlRetxNewTxAllocFnlz);
node = cellAllocInfo->dedAlloc.schdTxRetxHqPLst.first;
while(node)
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHSc1DlAllocFnlz);
rgSCHSc1DlRetxAllocFnlz(cell, allocInfo);
Void *dlCqi;
#endif
{
- TRC2(rgSCHSc1DlCqiInd);
RETVOID;
}
RgSchSc1DlUe *sc1DlUe = RG_GET_SC1_UE_DL(ue, cell);
RgSchCmnDlSvc *cmnDlLstSvc;
- TRC2(rgSCHSc1DlAdd2UeLcsWithData);
lst = &(sc1DlUe->lcsWithData);
node = lst->first;
RgSchSc1DlSvc *sc1DlSvc = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchSc1DlUe *sc1DlUe = RG_GET_SC1_UE_DL(ue, cell);
- TRC2(rgSCHSc1DlRmFrmUeLcsWithData);
cmLListDelFrm(&(sc1DlUe->lcsWithData), &sc1DlSvc->lcWithDataLnk);
sc1DlSvc->lcWithDataLnk.node = NULLP;
RgUlSchdApis *rgSchUlApis;
#endif
{
- TRC2(rgSCHSc1UlInit);
/* Init the function pointers */
rgSchUlApis->rgSCHRgrUlUeCfg = rgSCHSc1RgrUlUeCfg;
rgSchUlApis->rgSCHRgrUlUeRecfg = rgSCHSc1RgrUlUeRecfg;
{
RgSchCmnUe *ueSchCmn = RG_SCH_CMN_GET_UE(ue, cell);
- TRC2(rgSCHSc1RgrUlUeCfg);
if(rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(ueSchCmn->ul.schSpfc), (sizeof(RgSchSc1UlUe))) != ROK)
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrUlUeRecfg);
return ROK;
} /* rgSCHSc1RgrUeRecfg */
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
RgSchSc1UlUe *ueUl = RG_GET_SC1_UE_UL(ue, cell);
- TRC2(rgSCHSc1UlUeDel);
if (ueUl == NULLP)
{
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
RgSchSc1UlUe *ueUl = RG_GET_SC1_UE_UL(ue, cell);
- TRC2(rgSCHSc1UlUeReset);
ueUl->srRcvd = FALSE;
{
RgSchSc1UlCell *cellUl;
- TRC2(rgSCHSc1RgrUlCellCfg);
if((rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(((RgSchCmnCell*)((cell)->sc.sch))->ul.schSpfc), \
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrUlCellRecfg);
return ROK;
}
{
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1UlCellDel);
if (cellUl == NULLP)
{
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrLcgCfg);
return ROK;
} /* rgSCHSc1RgrLcgCfg */
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrLcgRecfg);
return ROK;
} /* rgSCHSc1RgrLcgRecfg */
RgSchLcgCb *lcg;
#endif
{
- TRC2(rgSCHSc1LcgDel);
rgSCHSc1UlPosnUeInQ(cell, ue);
RETVOID;
}
/*cell added as part of CA dev*/
RgSchSc1UlUe *ulUe = RG_GET_SC1_UE_UL(ue, cell);
- TRC2(rgSCHSc1UlSchdUe);
if(ulUe->srRcvd == TRUE)
{
{
RgSchSc1UlCell *sc1UlCell = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1UlSchdForDataTrans);
if (remUe == 0)
{
Bool ulAllowed = FALSE;
#endif
- TRC2(rgSCHSc1UlSchdUeTxLst);
node = ueTxLst->first;
while ((node) && (*remUe))
Bool ulAllowed = FALSE;
#endif
- TRC2(rgSCHSc1UlSchdForContRes);
node = sc1UlCell->contResLst.first;
while ((node) && (*remUe))
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
U8 remUe = cellUl->maxUeNewTxPerTti;
- TRC2(rgSCHSc1UlNewTx);
rgSCHSc1UlSchdForContRes(cell, allocInfo, &remUe);
rgSCHSc1UlSchdForDataTrans(cell, allocInfo, remUe);
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHSc1UlSched);
rgSCHSc1UlNewTx(cell, allocInfo);
RETVOID;
}
RgSchUeCb *lUe;
CmLList *node;
- TRC2(rgSCHSc1UlInsUeInQ);
node = lst->first;
while(node)
RgSchCmnLcg *cmnLcg0 = RG_SCH_CMN_GET_UL_LCG(&ue->ul.lcgArr[0]);
CmLListCp *lst;
- TRC2(rgSCHSc1UlPosnUeInQ);
if (!RG_SCH_CMN_UL_IS_UE_ACTIVE(ue))
{
U8 bsr;
#endif
{
- TRC2(rgSCHSc1UpdBsrShort);
rgSCHSc1UlPosnUeInQ(cell, ue);
RETVOID;
} /* rgSCHSc1UpdBsrShort */
U8 bsr;
#endif
{
- TRC2(rgSCHSc1UpdBsrTrunc);
rgSCHSc1UlPosnUeInQ(cell, ue);
RETVOID;
} /* rgSCHSc1UpdBsrTrunc */
U8 *bsArr;
#endif
{
- TRC2(rgSCHSc1UpdBsrLong);
rgSCHSc1UlPosnUeInQ(cell, ue);
RETVOID;
} /* rgSCHSc1UpdBsrLong */
RgSchSc1UlUe *ueUl = RG_GET_SC1_UE_UL(ue, cell);
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1ContResUlGrant);
if (ueUl->contResLnk.node)
{
RgSchSc1UlUe *ulUe = RG_GET_SC1_UE_UL(ue, cell);
RgSchSc1UlCell *ulCell = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1SrRcvd);
ulUe->srRcvd = TRUE;
TfuUlCqiRpt *ulCqiInfo;
#endif
{
- TRC2(rgSCHSc1UlCqiInd);
/* Stack Crash problem for TRACE5 changes. Added the return below */
RETVOID;
#endif
{
- TRC2(rgSCHSc1UlLcgUpd);
return ROK;
}
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHSc1UlUeRefresh);
rgSCHSc1UlPosnUeInQ(cell, ue);
RETVOID;
}
CmLList *node;
RgSchDrxUeCb *drxUe = NULLP;
CmLListCp ulInactvLst; /* list of UE's becoming UL-inactive */
- TRC2(rgSCHSc1UlDatTransAllocFnlz);
cmLListInit(&ulInactvLst);
node = allocInfo->schdUeLst.first;
RgSchSc1UlUe *ueUl;
RgSchUeCb *ue;
CmLList *node;
- TRC2(rgSCHSc1UlContResAllocFnlz);
node = allocInfo->schdContResLst.first;
while(node)
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHSc1UlAllocFnlz);
rgSCHSc1UlContResAllocFnlz(cell, allocInfo);
rgSCHSc1UlDatTransAllocFnlz(cell, allocInfo);
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHSc1UlActvtUe);
rgSCHSc1UlPosnUeInQ(cell, ue);
RETVOID;
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
CmLList *node = inactvLst->first;
- TRC2(rgSCHSc1UlHndlInActUes);
while (node)
{
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHSc1DlProcRmvFrmRetx);
+
/* Remove the HqP from retx Queue.
Release HqP.*/
rgSCHSc1DlProcRmvFrmCellRetx(cell, hqP);
U8 bitVal = 0;
U8 sCellActDeactBitMask = 0;
- TRC3(rgSCHSCellSchdActDeactCe);
/* Change the state of all Scells waiting for
* activation */
#endif
{
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC3(rgSCHSCellAddToActDeactLst);
if(NULLP == ue->sCellActLnk.node)
{/* Ue is not present in the list */
#endif
{
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC3(rgSCHSCellRmvFrmActLst);
if (NULLP != ue->sCellActLnk.node)
{
cmLListDelFrm(&cellCmnDl->secCellActCeLst, &ue->sCellActLnk);
U16 crntTime;
#endif
- TRC3(rgSCHSCellActivation);
sCellInfo->sCellState = RG_SCH_SCELL_ACTIVE;
#ifdef TENB_STATS
#endif
{
- TRC3(rgSCHCellClearScellLstOfCQI);
RgSchUePCqiCb *cqiRiCb = NULLP;
RgSchUeCb *ueCb;
ueCb = sCellInfo->ue;
RgSchCmnCell *cellSch;
Inst inst = sCellInfo->cell->instIdx;
- TRC3(rgSCHSCellDeActivation);
/* Stop the timer if running */
if(sCellInfo->deactTmr.tmrEvnt != TMR_NONE)
RgSchCellCb *cell;
RgSchUeCellInfo *sCellInfo;
- TRC3(rgSCHSCellHndlFdbkInd);
ueCb = hqP->hqE->ue;
cell = ueCb->cell;
#endif
{
- TRC3(rgSCHSCellDeactTmrExpry);
if (sCellInfo->ue->isScellExplicitDeAct == TRUE)
{
/* Deactivation Timer is not configured (infinity), thus send deactivation CE explicitly */
Inst inst = cell->instIdx;
S16 ret = ROK;
- TRC3(rgSCHSCellTrigActDeact);
-
if((sCellIdx < 1) ||
(sCellIdx > RGR_MAX_SCELL_PER_UE))
{
U8 *sCellIdx;
#endif
{
- TRC3(rgSCHSCellSelectAndAct);
for((*sCellIdx) = 1; (*sCellIdx) <= RG_SCH_MAX_SCELL; (*sCellIdx)++)
{
RgSchUeCellInfo *sCellInfo;
RgSchCmnUlUe *ueUl;
- TRC3(rgSCHSCellDelUeSCell);
sCellInfo = ueCb->cellInfo[sCellIdx];
#endif
{
- TRC3(rgSCHSCellDelUe);
-
for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
rgSCHSCellDelUeSCell(cellCb,ueCb,idx);
RgSchUeCellInfo *sCellInfo;
RgSchUePCqiCb *cqiCb = NULLP;
- TRC3(rgSCHSCellPCqiCfg);
-
RGSCHDBGINFO(priCellCb->instIdx, (rgSchPBuf(priCellCb->instIdx),
"rgSCHSCellPCqiCfg cellId =%d, ueId = %d, CfgType =%d\n",
secCellCb->cellId, ueCb->ueId, cqiCfg->type));
if (cqiCfg->type == RGR_SCH_PCQI_SETUP)
{
/* 1. Copy the Received CQI Cfg parameters to ueCb */
- cmMemcpy((U8 *)&cqiCb->cqiCfg, (U8 *)cqiCfg,
+ memcpy(&cqiCb->cqiCfg, cqiCfg,
sizeof(RgrUePrdDlCqiCfg));
/* 2. Compute Periodic CQI Periodicity and subframe offset */
#endif
{
RgSchCmnCell *cellSch;
- TRC3(rgSCHSCellDlUeReset);
for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC3(rgSCHSCellDlLcCfg);
for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ue->cellInfo[idx] != NULLP)
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC3(rgSCHSCellDlLcDel);
for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ue->cellInfo[idx] != NULLP)
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC3(rgSCHSCellDlDedBoUpd);
/* If this is not invoked by PCell, then
invoke the call to PCell handler
#endif
{
RgSchUePCqiCb *retCqiCb;
- TRC3(rgSCHUtlSCellCmpCqiCfg);
/* Collision rules are defined in TS 36.213,7.2.2 */
/* RI, WB first PMI > WB CQI > SB CQI */
/* As of now only taking care of RI > WB CQI > SB CQI */
U32 sCellCnt = 0;
CmLteTimingInfo timingInfo;
U8 idx = 0;
- TRC3(rgSCHUtlSCellHndlCqiCollsn);
#ifdef xLTE_TDD
RG_SCH_ADD_TO_CRNT_TIME(priCellCb->crntTime, timingInfo, TFU_DELTA);
U32 cellIdx;
U32 sCellCnt = 0;
CmLteTimingInfo timingInfo;
- TRC3(rgSCHUtlSCellHndlRiCollsn);
#ifdef xLTE_TDD
RG_SCH_ADD_TO_CRNT_TIME(priCellCb->crntTime, timingInfo, TFU_DELTA);
#endif
{
S16 retVal = RFAILED;
- TRC3(rgSCHSCellIsActive);
for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
RgSchUeCb *ue
#endif
{
- TRC2(rgSCHIsActvReqd)
/* Check if remBoCnt in this UE is greater than ZERO for sufficient number of
* Scheduling TTIs. If yes then We should activate a secondary cell to handle
* outstanding BO */
RgSchUeCellInfo *sCellCb = NULLP;
#endif
- TRC2(rgSCHTmrStartTmr);
-
-
#ifndef LTE_ADV
ue = (RgSchUeCb*)cb;
#else
RgSchUeCellInfo *sCellCb = NULLP;
#endif
- TRC2(rgSCHTmrStopTmr);
-
-
#ifndef LTE_ADV
ue = (RgSchUeCb*)cb;
#else
RgSchUeCellInfo *sCellCb = NULLP;
#endif
- TRC2(rgSCHTmrProcTmr);
-
#ifndef LTE_ADV
ue = (RgSchUeCb*)cb;
#else
U16 rapId;
RgSchUeCb *ue = NULLP;
- TRC2(rgSCHTomRaReqInd);
-
if(cell->cellId != raReqInd->cellId)
{
err.errType = RGSCHERR_TOM_RAREQIND;
RgSchUeCb *ue;
CmLList *node;
TfuUlCqiRpt *ulCqiInfo;
- TRC2(rgSCHTomUlCqiInd);
node = ulCqiInd->ulCqiRpt.first;
if(cell->cellId != ulCqiInd->cellId)
CmLList *node;
TfuPucchDeltaPwr *ueElem;
- TRC2(rgSCHTomPucchDeltaPwrInd);
-
if(cell->cellId != pucchDeltaPwr->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
U32 cellIdx;
RgSchCellCb *iterCellP;
- TRC2(rgSCHTomHarqAckInd);
-
if(cell->cellId != harqAckInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() Unable to get"
CmLList *node;
TfuSrInfo *srInfo;
- TRC2(rgSCHTomSrInd);
-
if(cell->cellId != srInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for srcInd cellId"
RgSchUeCb *ue;
CmLList *node;
TfuDoaRpt *doaInfo;
- TRC2(rgSCHTomDoaInd);
if(cell->cellId != doaInd->cellId)
{
RgSchUeCb *ue;
CmLList *node;
TfuDlCqiRpt *dlCqiInfo;
- TRC2(rgSCHTomDlCqiInd);
if(cell->cellId != dlCqiInd->cellId)
{
U16 cqiIdx = 0;
CmLteTimingInfo timingInfo;
- TRC2(rgSCHTomUtlMovePcqiNxtOccasion);
if(cqiCb->cqiCfg.cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP)
{
U16 crntTime;
U16 tempIdx;
- TRC2(rgSCHTomUtlMovePriNxtOccasion);
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cell->crntTime.slot);
#ifdef XEON_SPECIFIC_CHANGES
{
U16 srIdx = 0;
- TRC2(rgSCHTomUtlMoveSrNxtOccasion);
-
/* Compute Next Transmission Instance */
srIdx = ue->srCb.peri + ue->srCb.nSrTrIdx;
srIdx = srIdx%RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
U16 crntTime;
- TRC2(rgSCHTomUtlMoveSrsNxtOccasion);
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cell->crntTime.slot);
RgSchRaCb *raCb;
TfuHqInfo hqInfo;
- TRC2(rgSCHTomRawCqiInd);
-
if(cell->cellId != rawCqiInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
CmLList *node;
TfuSrsRpt* srsInfo;
- TRC2(rgSCHTomSrsInd);
-
if(cell->cellId != srsInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
RgSchUlHqProcCb *ulHqProc;
#endif
- TRC2(rgSCHTomCrcInd);
-
if(cell->cellId != crcInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
CmLList *node;
TfuTimingAdvInfo *timingAdvInfo;
-
- TRC2(rgSCHTomTimingAdvInd);
-
if(cell->cellId != timingAdvInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
RgSchCellCb *cell[CM_LTE_MAX_CELLS];
RgSchCellCb *cellLst[CM_LTE_MAX_CELLS];
- TRC2(rgSCHTomTtiInd);
-
#ifdef LTE_L2_MEAS
glblTtiCnt++;
#endif
#endif
Inst inst = cell->instIdx;
- TRC2(rgSCHTomUtlProcUlSf)
-
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
U16 validIdx; /* Index computed from recreq's timing info*/
Inst inst = cell->instIdx;
- TRC2(rgSCHTomUtlPrcUlTddSpclSf)
-
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
S16 ret;
U8 sfTyp = 1; /* Dl Subframe */
- TRC2(rgSCHTomUtlProcDlSf);
-
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
cmLListInit(&cntrlInfo->ulPdcchLst);
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
#endif
- TRC2(rgSCHTomUtlFillPhich)
ret = ROK;
/* Traversing the list of Phichs */
node = dlSf->phichInfo.phichs.first;
U8 isDcivld = FALSE;
U8 numUePerTti = 0;
- TRC2(rgSCHTomUtlFillDlPdcch)
ret = ROK;
/* Traversing the scheduled Harq processes */
node = dlSf->pdcchInfo.pdcchs.first;
TfuPdcchInfo *tfuPdcch;
U8 isDcivld = FALSE;
- TRC2(rgSCHTomUtlFillUlPdcch)
ret = ROK;
/* Traversing the scheduled Harq processes */
node = dlSf->pdcchInfo.pdcchs.first;
CmLList *node;
RgSchUeCb *ue;
- TRC2(rgSCHTomUtlProcTA);
-
node = cell->taUeLst.first;
while (node)
{
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = ue->f1bCsAVal;
- cmMemset((U8 *)pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
#ifdef LTEMAC_SPS
/* Two Resources needs to be configured if the
* serving cell is in mimo mode else single
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = 1;
- cmMemset((U8 *)pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
#endif/*TFU_UPGRADE*/
pucchReqInfo->hqInfo.hqRes[0] = dlSfHqInfo->n3ScellPucch.n3PucchIdx;
#ifdef TFU_UPGRADE
RgSchUeCb *ue;
RgSchDlHqProcCb *prvHqCb=NULLP;
- TRC2(rgSCHTomUtlFillHqFdbkRecpReq);
-
#ifdef CA_DBG
{
gF1bCsPres = FALSE;
#endif
- TRC2(rgSCHTomUtlFillSrRecpReq);
-
isAddToLst = FALSE;
node = cell->pCqiSrsSrLst[validIdx].srLst.first;
return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
/*Fill SR params*/
Bool *willueRprtCqiRi;
#endif
{
- TRC2(rgSCHTomUtlWillUeRprtCqiRi);
-
/* Intialising Reporting probability as TRUE */
*willueRprtCqiRi = TRUE;
Bool willUeRprtCqi; /* Flag set due to CQI Mask
and UE inactive state (DRX) */
RgSchUePCqiCb *riCb = NULLP;
- TRC2(rgSCHTomUtlFillRiRecpReq);
node = cell->pCqiSrsSrLst[validIdx].riLst.first;
while(node)
return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
/*Fill RI params*/
RgSchUeCb *ue = NULLP;
U16 ret;
- TRC2(rgSCHTomUtlFillCqiRiRecpReq);
-
while ((ue = rgSCHDbmGetNextUeCb(cell, ue)) != NULLP)
{
if (RGSCH_TIMEINFO_SAME (recpReqInfo->timingInfo, ue->ue5gtfCb.nxtCqiRiOccn))
return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
pucchRecpInfo->rnti = ue->ueId;
RgSchUePCqiCb *cqiCb = NULLP;
Bool isAddToLst = FALSE;
- TRC2(rgSCHTomUtlFillPcqiRecpReq);
-
node = cell->pCqiSrsSrLst[validIdx].cqiLst.first;
while(node)
{
return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
S16 ret;
RgSchUeCb *ue;
- TRC2(rgSCHTomUtlFillSrsRecpReq);
-
node = cell->pCqiSrsSrLst[validIdx].srsLst.first;
while(node)
{
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
- TRC2(rgSCHTomUtlFillDatRecpReq)
/* processing steps are
* - Run through the UL allocations going out in this subframe.
Bool isAperiodic = FALSE; /*Set when Aperiodic CQI is expected */
U8 numUePerTti = 0;
- TRC2(rgSCHTomUtlFillDatRecpReq);
-
if((0 == (recpReqInfo->timingInfo.sfn % 30)) && (0 == recpReqInfo->timingInfo.slot))
{
//printf("5GTF_CHECK rgSCHTomUtlFillDatRecpReq (%d : %d)\n", recpReqInfo->timingInfo.sfn, recpReqInfo->timingInfo.slot);
#endif
{
RgSchUePCqiCb *riCb = ueCb->nPRiCb;
- TRC2(rgSCHTomUtlFillRiBitWidthInfo);
if (ueCb->mimoInfo.txMode != RGR_UE_TM_3 &&
ueCb->mimoInfo.txMode != RGR_UE_TM_4)
TfuCqiPucchMode21 *mode21Info;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
- TRC3(rgSCHTomUtlFetchPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
U16 tti = (crntTimInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTimInfo.slot);
U16 prdNum = tti/cqiCb->cqiPeri;
- TRC2(rgSCHTomUtlPcqiSbCalcBpIdx);
if((prdNum % cqiCb->h) == 0)
{
cqiCb->isWb = TRUE;
{
RgSchUePCqiCb *cqiCb = ue->nPCqiCb;
RgSchUePCqiCb *riCb = ue->nPRiCb;
- TRC2(rgSCHTomUtlMoveNxtOccasion);
/* ccpu00140578::Skip the UE if already RI recpetion
* is processed in the same subframe */
U8 numOfCells = 0;
RgSchUeACqiCb *acqiCb = &ueCb->cellInfo[sCellIdx]->acqiCb;
- TRC2(rgSCHTomPrepareAcqiRecp);
-
/* Fill TFU Recp */
cqiRecpReqInfo->reportType = TFU_APERIODIC_CQI_TYPE; /* Aperiodic */
if (ueCb->mimoInfo.txMode == RGR_UE_TM_3 ||
U8 triggerSet = 0;
U8 sIdx = 0;
#endif
- TRC2(rgSCHTomUtlFillDatAperRecpReq);
/*Fill RI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
#endif
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- TRC2(rgSCHTomUtlFillDatPriRecpReq);
/*Fill RI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
U8 cqiPmiSz; /*Raw CQI/PMI Size*/
U8 ri;
- TRC2(rgSCHTomUtlFillDatPCqiRecpReq);
-
-
/*Fill CQI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
#ifdef TFU_ALLOC_EVENT_NO_INIT
Bool hqPres;
#endif
{
- TRC2(rgSCHTomUtlFillDatSrsRecpReq);
datRecpInfo->rnti = alloc->rnti;
rgSCHTomFillOnlySrsRecpReq(cell,alloc, datRecpInfo);
if(hqPres)
#endif
{
TfuUePuschSrsRecpInfo *srsRecpReqInfo;
- TRC2(rgSCHTomFillOnlySrsRecpReq);
srsRecpReqInfo = &datRecpInfo->t.puschRecpReq.srsInfo;
srsRecpReqInfo->srsBw = (TfuUlSrsBwInfo)alloc->ue->srsCb.srsCfg.srsSetup.srsBw;
RgSchEmtcUeInfo *emtcUe = NULLP;
#endif
- TRC2(rgSCHTomUtlFillCqiSrSrsWithHq);
-
if(ue)
{
/*Changes for PUCCH Format3 */
U8 ri; /*To fetch RI value*/
Bool willUeRprtCqi; /* Flag set due to CQI Mask and
UE Inactive state (DRX)*/
- TRC2(rgSCHTomUtlFillCqiSrsWithSr);
-
riCb = ue->nPRiCb;
cqiCb = ue->nPCqiCb;
rgSCHTomUtlWillUeRprtCqiRi(ue, &willUeRprtCqi);
RgSchDlHqTbCb *tbCb;
RgSchDlHqProcCb *prvHqCb = NULLP;
- TRC2(rgSCHTomUtlFillSfRepHqFdbk)
-
node = dlSf->ackNakRepQ.first;
while (node)
{
U8 hqSz = 0;
U32 idx = 0;
- TRC2(rgSCHTomUtlFillSfHqFdbkInfo)
-
#ifndef TFU_UPGRADE
RG_SCH_ADD_TO_CRNT_TIME(cellCb->crntTime, futTime, TFU_RECPREQ_DLDELTA);
#endif
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
- cmMemset((U8 *)pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
#endif
pucchInfo->pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchInfo->pucchRecpInfo->rnti = rnti;
Inst inst = cell->instIdx;
S16 ret;
- TRC2(rgSCHTomUtlProcDlSfAtCrc);
-
-
cntrlInfo->numDlActvUes = 0;
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
{
RgrTtiIndInfo *rgrTtiInd;
- TRC2(rgSCHTomUtlSendSfnTick);
-
/* TTI to be sent to RRM only once per system frame */
/* Added support for period = 0 to disable tick to RRM */
if ((cell->rrmTtiIndPrd != 0) &&
{
RgSchDynTddCb *rgSchDynTddInfo = &(rgSchCb[schInst].rgSchDynTdd);
- TRC2(rgSCHDynTDDMrkCrntSfIdx)
RG_SCH_DYN_TDD_MARKTYPE(rgSchDynTddInfo, rgSchDynTddInfo->crntDTddSfIdx,
RG_SCH_DYNTDD_NOTDEF);
CmLteTimingInfo frm;
- TRC2 (rgSchTomFillCellTtiInfo);
-
if (CM_LTE_MAX_CELLS < ttiInd->numCells)
{
RETVOID;
#endif
{
- TRC2(rgSchTomTtiUlAndDlCmnChSch);
-
cell->rlsHqArr[cell->crntHqIdx].numUes = 0;
cell->crntHqIdx++;
cell->crntHqIdx = cell->crntHqIdx % RGSCH_NUM_SUB_FRAMES;
{
U8 suId = cell->tfuSap->sapCfg.suId;
- TRC2(rgSchTomTtiMiscFunctions);
-
/* Invoke RAM Tti Handler */
rgSCHRamTtiHndlr(cell);
RgSchCellCb *cell;
#endif
{
- TRC2(rgSchTomTtiDlSch);
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
{
dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
- TRC2(rgSchTomTtiCnsldtSfAlloc);
-
/* Prepare Subframe allocation info and send to MAC */
rgSCHCmnCnsldtSfAlloc(cell);
RgSchDlSf *ulSf = rgSCHUtlSubFrmGet (cell, cell->hiDci0Time);
RgSchErrInfo err;
- TRC2(rgSchTomTtiL1DlAndUlCfg);
-
rgSCHTomUtlProcDlSf (dlSf, ulSf, cell, cntrlInfo, &err);
/* Mark this frame as sent */
dlSf->txDone = TRUE;
RgSchCellCb *cell;
#endif
{
- TRC2(rgSchTomUtlTddRlsSfAndHarq);
/* ccpu00132341-MOD- rgSchTddRlsDlSubfrmTbl is dependent on DELTA(=2).
* Instead rgSchTddDlAscSetIdxKTbl can be used as the K set gives proper
{
RgSchErrInfo err;
- TRC2(rgSCHTomUtlProcTddUlSf);
-
if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx]
[cell->rcpReqTime.subframe] == RG_SCH_TDD_UL_SUBFRAME)
{
[ueUl->maxUlCqi];
#endif
- TRC2(rgSCHUhmProcDatInd);
-
rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
if (hqProc == NULLP)
{
RgSchUlHqProcCb *hqProc;
#endif
{
- TRC2(rgSCHUhmProcMsg3DatInd);
hqProc->rcvdCrcInd = TRUE;
hqProc->remTx = 0; /*Reseting the value of rem Tx*/
printf("\nrgSCHUhmProcMsg3DatInd,id:%u\n",hqProc->procId);
RgSchUlHqProcCb *hqProc;
#endif
{
- TRC2(rgSCHUhmProcMsg3Failure);
#ifdef EMTC_ENABLE
RG_SCH_EMTC_IS_CRCIND_RCVD_CHK_RACB(hqProc);
#endif
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
S32 iTbs;
#endif
- TRC2(rgSCHUhmProcHqFailure);
rgSCHUtlUlHqProcForUe(cell, frm, ue, &hqProc);
if (hqProc == NULLP)
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
- TRC2(rgSCHUhmGetUlHqProc);
#if (ERRCLASS & ERRCLS_DEBUG)
if(idx >= ueUl->hqEnt.numHqPrcs)
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUhmNewTx);
hqProc->ndi ^= 1;
hqProc->alloc = alloc;
RgSchUeCb *ueCb;
U8 qci = 1;
#endif
- TRC2(rgSCHUhmFreeProc);
#ifdef LTE_L2_MEAS
if (hqProc->alloc && hqProc->alloc->ue)
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUhmRetx);
hqProc->alloc = alloc;
--hqProc->remTx;
U8 i;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
- TRC2(rgSCHUhmRgrUeCfg);
-
ueUl->hqEnt.maxHqRetx = ((ueCfg->ueUlHqCfg.maxUlHqTx) - 1);
#ifdef TFU_UPGRADE
/* Storing the delta HARQ offset for HARQ + PUSCH */
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
- TRC2(rgSCHUhmRgrUeRecfg);
/* [ccpu00123958]-ADD- Check for HARQ Reconfig from the bit mask */
if(RGR_UE_ULHARQ_RECFG & ueRecfg->ueRecfgTypes)
RgUeUlHqCb *hqEnt;
#endif
{
- TRC2(rgSCHUhmFreeUe);
#ifdef LTE_TDD
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
#endif /* LTEMAC_HDFDD */
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cellCb);
- TRC2(rgSCHUhmAppendPhich)
-
#ifdef RG_5GTF
return ROK;
#endif
#ifdef LTE_TDD
Inst inst = ueCb->cell->instIdx;
#endif
- TRC2(rgSCHUhmHqEntInit)
#ifndef LTE_TDD
/* Init the HARQ processes */
CmLList *tmp;
RgUeUlHqCb *hqE;
- TRC2(rgSCHUhmGetAvlHqProc);
-
hqE = &ueUl->hqEnt;
CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
CmLList *lnk = lst->first;
RgSchUlHqProcCb *proc;
- TRC2(rgSCHUhmGetUlProcByTime);
-
while (lnk)
{
proc = (RgSchUlHqProcCb *)(lnk->node);
U8 pointToChar,pointToEnd, loop;
U8 size = endPos - startPos;
F64 result = 0;
- TRC2(rgSCHUtlParse);
pointToEnd = (startPos)%8;
for ( loop=0; loop<size; loop++)
{
S16 ret;
U16 offsetStepMask;
- TRC2(rgSCHUtlPdcchAvail);
-
/* V5G_213 : 10.1 */
offset = 0;
byte = &pdcchInfo->map[0];
U8 offset;
uint16_t mask;
- TRC2(rgSCHUtlPdcchPut);
-
switch(pdcch->aggrLvl)
{
case CM_LTE_AGGR_LVL2:
U8 extraBits;
U32 cceMapSz;
- TRC2(rgSCHUtlPdcchInit);
-
pdcchInfo = &subFrm->pdcchInfo;
while(pdcchInfo->pdcchs.first != NULLP)
{
}
}
- cmMemset(subFrm->pdcchInfo.map, 0, cceMapSz);
+ memset(subFrm->pdcchInfo.map, 0, cceMapSz);
/* If nCce is not exactly same as the bitMap size(no of bits allocated
* to represent the Cce's, then mark the extra bits as unavailable
extra bits = (((pdcchInfo->nCce + 7) >> 3)*8) - pdcchInfo->nCce
{
CmLListCp *l;
CmLList *n;
- TRC2(rgSchSFRTotalPoolFree);
/*Deinitialise if these cc pools and ce pools are already existent*/
l = &sfrTotalPoolInfo->ccPool;
CmLList *temp = NULLP;
S16 ret = 0;
- TRC2(rgSchSFRTotalPoolInit);
-
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo, cell);
sf->sfrTotalPoolInfo.CCPool1BwAvlbl = 0;
sf->sfrTotalPoolInfo.CCPool2BwAvlbl = 0;
Inst inst = cell->instIdx;
U16 len;
- TRC2(rgSchDSFRRntpInfoInit);
-
rntpPtr->pres = PRSNT_NODEF;
len = (bw % 8 == 0) ? (bw/8) : (bw/8 + 1);
Inst inst = cell->instIdx;
U16 len;
- TRC2(rgSchDSFRRntpInfoFree);
-
len = (bw % 8 == 0) ? (bw/8) : (bw/8 + 1);
if(rntpPtr->pres == PRSNT_NODEF)
#endif
{
- TRC2(rgSchSFRResetPoolVariables);
pool->bwAlloced = 0;
/*type0end will be the last RBG in pool with all available RBs*/
CmLList *node = NULLP;
RgSchSFRPoolInfo *tempPool = NULLP;
- TRC2(rgSCHSFRUtlTotalPoolReset);
-
totalPoolInfo->ccBwFull = FALSE;
totalPoolInfo->ceBwFull = FALSE;
totalPoolInfo->isUeCellEdge = FALSE;
RgSchPhich *phich;
RgSchDlSf *dlSf;
Inst inst = cell->instIdx;
- TRC2(rgSCHUtlAddPhich);
dlSf = rgSCHUtlSubFrmGet(cell, frm);
RGSCH_PHICH_ALLOC(inst, phich,sizeof(RgSchPhich), ret);
UNUSED(cell);
- TRC2(rgSCHUtlPhichReset);
-
phichInfo = &subFrm->phichInfo;
while(phichInfo->phichs.first != NULLP)
{
RgSchDlSf *sf;
U8 dlIdx;
- TRC2(rgSCHUtlSubFrmGet);
-
#ifdef LTE_TDD
dlIdx = rgSCHUtlGetDlSfIdx(cell, &frm);
//RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
U8 i;
U8 noRaRsps;
- TRC2(rgSCHUtlSubFrmPut);
-
#ifdef LTE_TDD
/* Release all the held PDCCH information */
rgSCHUtlPdcchInit(cell, sf, sf->nCce);
}
sf->spsAllocdBw = 0;
sf->type2Start = sf->bwAlloced;
- cmMemset((U8*) &sf->dlSfAllocInfo, 0, sizeof(RgSchDlSfAllocInfo));
+ memset( &sf->dlSfAllocInfo, 0, sizeof(RgSchDlSfAllocInfo));
#else
sf->bwAlloced = 0;
/* Fix for ccpu00123918*/
/* dsfr_pal_fixes ** 21-March-2013 ** SKS */
if (cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
{
- cmMemset((U8*) sf->rntpInfo.val, 0, sf->rntpInfo.len);
+ memset(sf->rntpInfo.val, 0, sf->rntpInfo.len);
}
/* LTE_ADV_FLAG_REMOVED_END */
#endif
S16 i;
U8 ret = 0;
- TRC2(rgSCHUtlLog32bitNbase2)
-
for (i=4; i >= 0; i--)
{
if (n & b[i])
U8 isAck;
#endif
{
- TRC2(rgSCHUtlDlRelPdcchFbk);
cell->sc.apis->rgSCHDlRelPdcchFbk(cell, ue, isAck);
RETVOID;
}
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHUtlDlProcAck);
cell->sc.apis->rgSCHDlProcAck(cell, hqP);
RETVOID;
}
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlHdlCrntiCE);
cell->sc.apis->rgSCHHdlCrntiCE(cell, ue);
RETVOID;
#endif
{
U16 regs = 0;
- TRC2(rgSCHUtlCalcTotalRegs);
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
U8 ng6;
#endif
{
- TRC2(rgSCHUtlCalcPhichRegs);
/* ccpu00115330: Corrected the calculation for number of PHICH groups*/
return (RGSCH_CEIL((bw * ng6) ,(8 * 6)) * RGSCH_NUM_REG_PER_PHICH_GRP);
}
U16 phichRegs;
U16 cceRegs;
U8 ng6;
- TRC2(rgSCHUtlCalcNCce);
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
U16 phichRegs;
U16 cceRegs;
U8 ng6;
- TRC2(rgSCHUtlCalcNCce);
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
/* ACC-TDD */
S16 ret = RFAILED;
- TRC2(rgSCHUtlGetPhichInfo);
-
if ((hqProc != NULLP) && (hqProc->alloc != NULLP))
{
*rbStartRef = hqProc->alloc->grnt.rbStart;
* min(4,modulation order in grant). Please refer to 36.213-8.6.1*/
CmLteUeCategory ueCtgy;
- TRC2(rgSCHUtlAllocRcptInfo);
#if (ERRCLASS & ERRCLS_DEBUG)
if ((alloc == NULLP) || (alloc->hqProc == NULLP))
{
TfuUeUlSchRecpInfo *recpReq;
#endif
{
- TRC2(rgSCHUtlAllocRcptInfo);
#if (ERRCLASS & ERRCLS_DEBUG)
if ((alloc == NULLP) || (alloc->hqProc == NULLP))
{
U8 startIdx;
U8 endIdx;
- TRC2(rgSCHUtlUpdPrachOcc)
-
/* In the 1st half frame */
if(cellCfg->halfFrm == 0)
{
U8 subfrmIdx;
U8 splFrm;
- TRC2(rgSCHUtlPrachCfgInit)
if(cellCfg->prachRscInfo.numRsc <= 0)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid"
S16 ret = ROK;
U16 bw; /*!< Number of RBs in the cell */
- TRC2(rgSCHUtlRgrCellCfg);
-
- cmMemset((U8 *)&frm,0,sizeof(CmLteTimingInfo));
+ memset(&frm,0,sizeof(CmLteTimingInfo));
/* ccpu00132657-MOD- Determining DLSF array size independent of DELTAS */
maxDlslots = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
{
break;
}
- cmMemset((U8 *)sf, 0, sizeof(*sf));
+ memset(sf, 0, sizeof(*sf));
#ifdef LTE_ADV
if (ROK != rgSCHLaaInitDlSfCb(cell, sf))
U16 len;
len = (U16)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /*KW fix for LTE_ADV */
/* LTE_ADV_FLAG_REMOVED_END */
- TRC2(rgSCHUtlRgrCellCfg);
- cmMemset((U8 *)&frm,0,sizeof(CmLteTimingInfo));
+ memset(&frm,0,sizeof(CmLteTimingInfo));
/* determine the RBG size and no of RBGs for the configured
* DL BW */
{
break;
}
- cmMemset((U8 *)sf, 0, sizeof(*sf));
+ memset(sf, 0, sizeof(*sf));
#ifdef LTE_ADV
if (ROK != rgSCHLaaInitDlSfCb(cell, sf))
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrCellRecfg);
return (cell->sc.apis->rgSCHRgrCellRecfg(cell, recfg, err));
}
RgSchRaReqInfo *raReqInfo;
U8 idx;
#endif
- TRC2(rgSCHUtlFreeCell);
#ifdef LTE_TDD
maxslots = cell->numDlSubfrms;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrUeCfg);
/* Assign TM 1 as UE's default TM */
ue->mimoInfo.txMode = RGR_UE_TM_1;
#endif
ue->csgMmbrSta = cfg->csgMmbrSta;
#ifdef RG_PFS_STATS
- cmMemset((U8 *)&ue->pfsStats, 0, sizeof(RgSchPfsStats));
+ memset(&ue->pfsStats, 0, sizeof(RgSchPfsStats));
#endif
/* Call the handler of the scheduler based on cell configuration */
return (cell->sc.apis->rgSCHRgrUeCfg(cell, ue, cfg, err));
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHUtlRgrLcCfg);
return (cell->sc.apis->rgSCHRgrLchCfg(cell, ue, dlLc, cfg, errInfo));
}
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrLcRecfg);
return (cell->sc.apis->rgSCHRgrLchRecfg(cell, ue, dlLc, recfg, err));
}
U8 lcgId;
#endif
{
- TRC2(rgSCHUtlRgrLcDel);
cell->sc.apis->rgSCHRgrLchDel(cell, ue, lcId, lcgId);
return (ROK);
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHUtlRgrLcgCfg);
return (cell->sc.apis->rgSCHRgrLcgCfg(cell, ue, &(ue->ul.lcgArr[cfg->ulInfo.lcgId]), cfg, errInfo));
}
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrLcgRecfg);
return (cell->sc.apis->rgSCHRgrLcgRecfg(cell, ue, &(ue->ul.lcgArr[recfg->ulRecfg.lcgId]), recfg, err));
} /* rgSCHUtlRgrLcRecfg */
U8 lcgId;
#endif
{
- TRC2(rgSCHUtlRgrLcgDel);
cell->sc.apis->rgSCHFreeLcg(cell, ue, &ue->ul.lcgArr[lcgId]);
/* Stack Crash problem for TRACE5 changes. added the return below . */
TfuDoaRpt *doaRpt;
#endif
{
- TRC2(rgSCHUtlDoaInd);
ue->mimoInfo.doa.pres = PRSNT_NODEF;
ue->mimoInfo.doa.val = doaRpt->doa;
RETVOID;
#endif
{
RgSchCellCb *sCellCb = NULLP;
- TRC2(rgSCHUtlDlCqiInd);
if (dlCqiRpt->isPucchInfo)
{
sCellCb = ue->cellInfo[dlCqiRpt->dlCqiInfo.pucchCqi.cellIdx]->cell;
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlSrsInd);
cell->sc.apis->rgSCHSrsInd(cell, ue, srsRpt, timingInfo);
RETVOID;
}
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlDlTARpt);
cell->sc.apis->rgSCHDlTARpt(cell, ue);
RETVOID;
}
CmLteTimingInfo subFrm;
#endif
{
- TRC2(rgSCHUtlDlRlsSubFrm);
cell->sc.apis->rgSCHDlRlsSubFrm(cell, subFrm);
RETVOID;
}
U8 sIdx = 0;
#endif
- TRC2(rgSCHUtlUpdACqiTrigWt);
-
if (isAck == TFU_HQFDB_ACK)
{
cellInfo->acqiCb.aCqiTrigWt += RG_APER_CQI_ACK_WGT;
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlHdlUlTransInd);
cell->sc.apis->rgSCHHdlUlTransInd(cell, ue, timingInfo);
RETVOID;
}
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlHdlCrcFail);
cell->sc.apis->rgSCHUlCrcInd(cell, ue, timingInfo);
RETVOID;
} /* end of rgSCHUtlHdlCrcFailInd */
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlHdlCrcFail);
cell->sc.apis->rgSCHUlCrcFailInd(cell, ue, timingInfo);
RETVOID;
} /* end of rgSCHUtlHdlCrcFailInd */
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHUtlDlProcAddToRetx);
cell->sc.apis->rgSCHDlProcAddToRetx(cell, hqP);
RETVOID;
}
RgSchCellCb *cellCb = NULLP;
U8 strtCellId;
- TRC2(rgSchUtlGetCellCb);
-
strtCellId = rgSchCb[inst].genCfg.startCellId;
cellCb = rgSchCb[inst].cells[cellId - strtCellId];
U8 servCellIdx;
U16 strtCellId;
- TRC2(rgSchUtlGetCellCb);
-
strtCellId = rgSchCb[inst].genCfg.startCellId;
servCellIdx = ue->cellIdToCellIdxMap[cellId - strtCellId];
{
U8 strtCellId;
- TRC2(rgSchUtlVldtCellId);
-
strtCellId = rgSchCb[inst].genCfg.startCellId;
if((cellId >= strtCellId) && ((cellId - strtCellId) < CM_LTE_MAX_CELLS))
{
/* Changes for UE Category Reconfiguration feature addition */
RgSchCmnUe *ueSch = RG_SCH_CMN_GET_UE(ue, cell);
- TRC2(rgSCHUtlRgrUeRecfg);
-
/* Changes for UE Category Reconfiguration feature addition */
if (ueRecfg->ueRecfgTypes & RGR_UE_UECAT_RECFG)
{
RgSchDlLcCb *svc;
#endif
{
- TRC2(rgSCHUtlFreeDlLc);
cell->sc.apis->rgSCHFreeDlLc(cell, ue, svc);
/* Stack Crash problem for TRACE5 changes. added the return below . */
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlFreeUe);
#ifdef LTE_TDD
rgSCHUtlDelUeANFdbkInfo(ue,RGSCH_PCELL_INDEX);
#endif
RgSchDlLcCb *lc;
#endif
{
- TRC2(rgSCHUtlDlDedBoUpd);
cell->sc.apis->rgSCHDlDedBoUpd(cell, ue, lc);
RETVOID;
}
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHUtlRecMsg3Alloc)
cell->sc.apis->rgSCHUlRecMsg3Alloc(cell, ue, raCb);
RETVOID;
RgSchUlHqProcCb *oldProc;
#endif
{
- TRC2(rgSCHUtlUpdUlHqProc);
return (cell->sc.apis->rgSCHUpdUlHqProc(cell, curProc, oldProc));
} /* rgSCHUtlUpdUlHqProc */
#endif
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlContResUlGrant);
-
ue->isMsg4PdcchWithCrnti = TRUE;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlSrRcvd);
return (cell->sc.apis->rgSCHSrRcvd(cell, ue, frm, err));
} /* rgSCHUtlSrRcvd */
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdBsrShort);
cell->sc.apis->rgSCHUpdBsrShort(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
RETVOID;
} /* rgSCHUtlUpdBsrShort */
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdBsrTrunc);
cell->sc.apis->rgSCHUpdBsrTrunc(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
RETVOID;
} /* rgSCHUtlUpdBsrTrunc */
#endif
{
U8 bsArr[4];
- TRC2(rgSCHUtlUpdBsrLong);
bsArr[0] = bsr0;
bsArr[1] = bsr1;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdExtPhr);
return (cell->sc.apis->rgSCHUpdExtPhr(cell, ue, extPhr, err));
} /* rgSCHUtlUpdExtPhr */
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdPhr);
return (cell->sc.apis->rgSCHUpdPhr(cell, ue, phr, err));
} /* rgSCHUtlUpdPhr */
TfuUlCqiRpt *ulCqiInfo;
#endif
{
- TRC2(rgSCHUtlUlCqiInd);
cell->sc.apis->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
RETVOID;
} /* rgSCHUtlUlCqiInd */
S8 delta;
#endif
{
- TRC2(rgSCHUtlPucchDeltaPwrInd);
cell->sc.apis->rgSCHPucchDeltaPwrInd(cell, ue, delta);
RETVOID;
} /* rgSCHUtlPucchDeltaPwrInd */
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlUeReset);
ue->remBoCnt = 0;
cell->sc.apis->rgSCHUeReset(cell, ue);
RETVOID;
RgSchUlHqProcCb **procRef;
#endif
{
- TRC2(rgSCHUtlUlHqProcForUe);
cell->sc.apis->rgSCHUlHqProcForUe(cell, frm, ue, procRef);
/* Stack Crash problems for TRACE5 changes. added the return below */
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHUtlFirstRcptnReq);
return (cell->sc.apis->rgSCHFirstRcptnReq(cell));
}
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlNextRcptnReq);
return (cell->sc.apis->rgSCHNextRcptnReq(cell, alloc));
}
U8 idx;
#endif
{
- TRC2(rgSCHUtlFirstHqFdbkAlloc);
return (cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
}
U8 idx;
#endif
{
- TRC2(rgSCHUtlNextHqFdbkAlloc);
return (cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
}
S16 ret;
RgSchLowSapCb *tfuSap;
Pst pst;
- TRC2(rgSCHUtlTfuBndReq);
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[instId].tfuSap[suId]);
- (Void)cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuSchBndReq (&pst, suId, spId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlTfuBndReq() Call to RgLiTfuBndReq()"
S16 ret;
Pst pst;
- TRC2(rgSCHUtlTfuUBndReq);
-
/* Get the lower SAP control block from the layer control block. */
- cmMemcpy ((U8*)&pst, (U8*)&(sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuSchUbndReq (&pst, sapCfg.spId, reason)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"rgSCHUtlTfuUBndReq() Call to"
Bool restAlloc;
#endif
{
- TRC2(rgSCHUtlResetSfAlloc);
if(TRUE == restAlloc)
{
if(sfAlloc->ueInfo.numUes)
{
- cmMemset((U8 *)sfAlloc->ueInfo.allocInfo,0x00,
+ memset(sfAlloc->ueInfo.allocInfo,0x00,
(sizeof(RgInfUeAlloc)*sfAlloc->ueInfo.numUes));
}
sfAlloc->ueInfo.numUes = 0;
{
U8 idx = 0;
Inst inst = cell->instIdx;
- TRC2(rgSCHUtlGetRlsHqAlloc);
for(idx=0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
{
cell->rlsHqArr[idx].cellId = cell->cellId;
{
U8 idx = 0;
Inst inst = cell->instIdx;
- TRC2(rgSCHUtlPutRlsHqAlloc);
for(idx=0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
{
U8 indx;
Inst inst = cell->instIdx;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHUtlGetSfAlloc);
#ifdef LTE_TDD
for(idx=0; idx < RGSCH_SF_ALLOC_SIZE; idx++)
U8 indx;
Inst inst = cell->instIdx;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHUtlPutSfAlloc);
#ifdef LTE_TDD
for(idx=0; idx < RGSCH_SF_ALLOC_SIZE; idx++)
{
/* Moving alarm diagnostics to available scope */
- TRC2(rgSCHUtlAllocSBuf)
-
/* Initialize the param to NULLP */
*pData = NULLP;
/* zero out the allocated memory */
- cmMemset((U8 *)*pData, 0x00, size);
+ memset(*pData, 0x00, size);
return ROK;
S16 ret;
- TRC2(rgSCHUtlFreeSBuf)
-
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
RETVOID;
CmLList *node;
Buffer *pdu;
- TRC2(rgSCHUtlFreeWarningSiSeg)
-
while (siPduLst->first != NULLP)
{
node = siPduLst->first;
RgSchWarningSiInfo *warningSi;
RgSchWarningSiPdu *warningSiPdu;
- TRC2(rgSCHUtlFreeWarningSiPdu)
-
warningSi = (RgSchWarningSiInfo *) cell->siCb.\
siArray[cell->siCb.siCtx.siId-1].si;
/* ccpu00136659: CMAS ETWS design changes */
Buffer *pdu;
CmLList *node;
- TRC2(rgSCHUtlGetWarningSiPdu)
-
- warningSi = (RgSchWarningSiInfo *) cell->siCb.
- siArray[cell->siCb.siCtx.siId-1].si;
+ warningSi = (RgSchWarningSiInfo *) cell->siCb.
+ siArray[cell->siCb.siCtx.siId-1].si;
/* ccpu00136659: CMAS ETWS design changes */
CM_LLIST_FIRST_NODE(&warningSi->warningSiMsg.segLstCp, node);
if (node != NULLP)
RgSchWarningSiPdu *warningSiPdu;
CmLList *node;
- TRC2(rgSCHUtlGetMcsAndNPrb)
-
if(cell->siCb.siCtx.warningSiFlag == FALSE)
{
*mcs = cell->siCb.crntSiInfo.siInfo[cell->siCb.siCtx.siId-1].mcs;
U8 mcs = 0;
U8 nPrb = 0;
- TRC2(rgSCHUtlCalMcsAndNPrb)
-
/*Get the nPrb and mcs parametr values */
if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
{
#endif
{
- TRC2(rgSCHUtlFillDgnParams)
-
switch(dgnType)
{
case LRG_USTA_DGNVAL_MEM:
Inst macInst;
#endif
{
- TRC2(rgSCHUtlGetPstToLyr);
/* Only the needed params are filled */
pst->region = schCb->rgSchInit.region;
Bool sendInd;
#endif
{
- TRC2(rgSCHUtlFillRgInfCmnLcInfo);
if((sf->bch.tbSize)&&
!(sfAlloc->cmnLcInfo.bitMask & RGINF_BCH_INFO))
U8 noRaRsps;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHUtlFillRgInfRarInfo);
-
#ifdef LTE_TDD
noRaRsps = RGSCH_MAX_TDD_RA_RSP_ALLOC;
#else
TfuDciInfo *pdcchDci;
#endif
{
- TRC2(rgSCHUtlFillPdschDciInfo)
#ifdef EMTC_ENABLE
S16 ret = ROK;
CmLListCp *l;
CmLList *n;
- TRC2(rgSchDSFRPwrCheck);
-
l = &sf->sfrTotalPoolInfo.ccPool;
n = cmLListFirst(l);
while(n)
{
S16 ret;
- TRC2(rgSCHUtlUpdSch);
#ifdef LTEMAC_SPS
if (RGSCH_UL_SPS_ACT_PRSENT & pdu->ceInfo.bitMask)
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb, cell);
RgSchDlHqProcCb *hqP = (RgSchDlHqProcCb *)ueDl->proc;
- TRC2(rgSCHUtlAddUeToCcchSduLst);
/* Temp Guard: For back to back CCCH SDU BO
* twice. Hence an extra guard. If already added to scheduling
#endif
{
RgSchUeCb *ueCb;
- TRC2(rgSCHUtlUpdtBo)
-
if ((ueCb = rgSCHDbmGetUeCb(cell, staRsp->u.rnti)) == NULLP)
{
RgSchRaCb *raCb;
RgSchUeCb *ueCb;
- TRC2(rgSCHUtlHndlCcchBoUpdt);
-
if ((raCb = rgSCHDbmGetRaCb(cell, boRpt->u.rnti)) == NULLP)
{
#ifdef RGR_V1
S32 cn;
S32 rt;
- TRC2(rgSCHUtlGetAllwdCchTbSz);
-
for (lt = 0, rt = 43; lt <= rt;)
{
cn = (lt + rt)/2;
U8 nPrb=0;
U8 mcs=0;
- TRC2(rgSCHUtlHndlBcchPcchBoUpdt);
-
dlLc = rgSCHDbmGetBcchOnBch(cell);
if (dlLc == NULLP)
{
{
S16 ret = ROK;
- TRC2(rgSCHUtlRgrBndCfm)
-
-
ret = RgUiRgrBndCfm(&rgSchCb[instId].rgrSap[suId].sapCfg.sapPst, rgSchCb[instId].rgrSap[suId].sapCfg.suId, status);
if (ret != ROK)
{
{
S16 ret = ROK;
- TRC2(rgSCHUtlRgmBndCfm)
-
-
ret = RgUiRgmBndCfm(&rgSchCb[instId].rgmSap[suId].sapCfg.sapPst, rgSchCb[instId].rgmSap[suId].sapCfg.suId, status);
if (ret != ROK)
{
Pst cfmPst;
Inst inst = 0;
- TRC2(schSendCfgCfm)
- cmMemset((U8 *)(&cfmPst), 0, sizeof(Pst));
+ memset((&cfmPst), 0, sizeof(Pst));
cfmPst.srcEnt = (Ent)ENTDUAPP;
cfmPst.srcInst = (Inst) 0;
extern Void mtTmrHdlrPublic(void);
#endif
- TRC2(rgSCHUtlRgrTtiInd)
-
-
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
S16 ret;
RgSchRaCb *raCb;
- TRC2(rgSCHUtlProcMsg3)
-
-
/* must have an raCb for this case */
raCb = rgSCHDbmGetRaCb (cellCb, rnti);
if (raCb == NULLP)
Bool isExplRel;
#endif
{
- TRC2(rgSCHUtlSpsRelInd);
cellCb->sc.apis->rgSCHUlSpsRelInd(cellCb, ueCb, isExplRel);
return ROK;
} /* end of rgSCHUtlSpsRelInd */
U16 spsSduSize;
#endif
{
- TRC2(rgSCHUtlSpsActInd);
cellCb->sc.apis->rgSCHUlSpsActInd(cellCb, ueCb, spsSduSize);
return ROK;
} /* end of rgSCHUtlSpsActInd */
RgSchLowSapCb *tfuSap;
Pst pst;
- TRC2(rgSCHUtlTfuGrpPwrCntrlReq);
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[inst].tfuSap[sapId]);
"rgSCHUtlTfuGrpPwrCntrlReq() Lower SAP not bound (%d) ",tfuSap->sapSta.sapState);
return RFAILED;
}
- cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuGrpPwrCntrlReq (&pst, tfuSap->sapCfg.spId, grpPwrCntrlReq)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,grpPwrCntrlReq->cellId,
S16 ret;
RgSchLowSapCb *tfuSap;
- TRC2(rgSCHUtlTfuCntrlReq)
-
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[inst].tfuSap[sapId]);
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlDlActvtUe);
cell->sc.apis->rgSCHActvtDlUe(cell, ue);
return ROK;
}
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlUlActvtUe);
cell->sc.apis->rgSCHActvtUlUe(cell, ue);
return ROK;
}
S16 ret;
RgSchLowSapCb *tfuSap;
- TRC2(rgSCHUtlTfuRecpReq)
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[inst].tfuSap[sapId]);
{
RgSchLowSapCb *tfuSap;
- TRC2(rgSCHUtlValidateTfuSap)
-
if(suId >= rgSchCb[inst].numSaps)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Incorrect SuId");
Mem sMem;
VOLATILE U32 startTime=0;
- TRC2(rgSCHUtlAllocEventMem)
-
sMem.region = rgSchCb[inst].rgSchInit.region;
sMem.pool = rgSchCb[inst].rgSchInit.pool;
{
S16 ret;
- TRC2(rgSCHUtlGetEventMem)
#ifdef TFU_ALLOC_EVENT_NO_INIT
ret = cmGetMemNoInit(memCp, len, (Ptr *)ptr);
#else
{
U8 idx;
- TRC2(rgSCHUtlAllocUeANFdbkInfo);
-
if (rgSCHUtlAllocSBuf(ue->cell->instIdx,
(Data **) &(ue->cellInfo[servCellIdx]->anInfo), sizeof(RgSchTddANInfo) * \
ue->cell->ackNackFdbkArrSize) != ROK)
U8 servCellIdx;
#endif
{
- TRC2(rgSCHUtlDelUeANFdbkInfo);
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
RgSchTddANInfo *anFdInfo;
#endif
{
- TRC2(rgSCHUtlInitUeANFdbkInfo);
anFdInfo->sfn = RGSCH_MAX_SFN+1; /* defensively setting invalid sfn */
anFdInfo->slot = 0;
{
U8 idx;
- TRC2(rgSCHUtlGetUeANFdbkInfo);
-
for (idx = 0; idx < ueCb->cell->ackNackFdbkArrSize; ++idx)
{
if( (timeInfo->sfn == ueCb->cellInfo[servCellIdx]->anInfo[idx].sfn) &&
#endif
{
U16 idx = 0;
- TRC2(rgSCHUtlGetDlSfIdx);
idx = RGSCH_NUM_SUB_FRAMES - \
rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
{
U16 idx = curDlTime.slot;
U8 count = 0;
- TRC2(rgSCHUtlGetNxtDlSfInfo);
while(TRUE)
{
{
S16 idx = curDlTime.slot;
U8 count = 0;
- TRC2(rgSCHUtlGetPrevDlSfInfo);
do
{
#endif
{
S16 ret=ROK;
- TRC2(rgSCHUtlUlSfInit);
sf->idx = idx;
#ifdef RG_5GTF
RgSchUlSf *sf;
#endif
{
- TRC2(rgSCHUtlUlSfDeinit);
if (sf->allocDb)
{
rgSCHUtlUlAllocDbDeinit(cell, sf->allocDb);
#endif
{
S16 ret = rgSCHUtlUlAllocMemInit(cell, &allocDb->mem, maxAllocs);
- TRC2(rgSCHUtlUlAllocDbInit);
if (ret != ROK)
{
return (ret);
RgSchUlAllocDb *allocDb;
#endif
{
- TRC2(rgSCHUtlUlAllocDbDeinit);
rgSCHUtlUlAllocMemDeinit(cell, &allocDb->mem);
allocDb->count = 0;
allocDb->first = NULLP;
{
S16 ret;
RgSchUlHole *hole = NULLP;
- TRC2(rgSCHUtlUlHoleDbInit);
ret = rgSCHUtlUlHoleMemInit(cell, &holeDb->mem, maxHoles, &hole);
if (ret != ROK)
RgSchUlHoleDb *holeDb;
#endif
{
- TRC2(rgSCHUtlUlHoleDbDeinit);
rgSCHUtlUlHoleMemDeinit(cell, &holeDb->mem);
holeDb->count = 0;
holeDb->first = NULLP;
RgSchUlHole *hole;
#endif
{
- TRC2(rgSCHUtlUlAllocGetHole);
if (numSb < hole->num)
{
return (rgSCHUtlUlAllocGetPartHole(sf, numSb, hole));
* updated, causing another check for prv */
RgSchUlAlloc *prv = hole->prvAlloc;
RgSchUlAlloc *nxt = hole->nxtAlloc;
- TRC2(rgSCHUtlUlAllocGetCompHole);
if (prv)
{
/* Calling rgSchCmnUlAllocGetAndIns is ok, but prv alloc needs to have nxtHole
* updated, causing another check for prv */
RgSchUlAlloc *prv = hole->prvAlloc;
- TRC2(rgSCHUtlUlAllocGetPartHole);
if (prv)
{
RgSchUlSf *sf;
#endif
{
- TRC2(rgSCHUtlUlAllocFirst);
return (sf->allocDb->first);
}
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlAllocNxt);
UNUSED(sf);
return (alloc->nxt);
}
{
RgSchUlAlloc *alloc = rgSCHUtlUlAllocMemGet(&db->mem);
RgSchUlAlloc *nxt = prv->nxt;
- TRC2(rgSCHUtlUlAllocGetAdjNxt);
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
{
RgSchUlAlloc *alloc = rgSCHUtlUlAllocMemGet(&db->mem);
RgSchUlAlloc *nxt = db->first;
- TRC2(rgSCHUtlUlAllocGetFirst);
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
RgSchUlHoleDb *db = alloc->holeDbRef;
RgSchUlHole *prv = alloc->prvHole;
RgSchUlHole *nxt = alloc->nxtHole;
- TRC2(rgSCHUtlUlHoleAddAllocation);
if (prv)
{
RgSchUlAllocDb *allocDb = alloc->allocDbRef;
RgSchUlAlloc *prv = alloc->prv;
RgSchUlAlloc *nxt = alloc->nxt;
- TRC2(rgSCHUtlUlAllocRelease);
alloc->ue = NULLP;
alloc->raCb = NULLP;
RgSchUlAllocDb *allocDb = sf->allocDb;
RgSchUlAlloc *prv = alloc->prv;
RgSchUlAlloc *nxt = alloc->nxt;
- TRC2(rgSCHUtlUlAllocRls);
alloc->ue = NULLP;
alloc->raCb = NULLP;
RgSchUlSf *sf;
#endif
{
- TRC2(rgSCHUtlUlHoleFirst);
return (sf->holeDb->first);
}
RgSchUlHole *hole;
#endif
{
- TRC2(rgSCHUtlUlHoleNxt);
UNUSED(sf);
return (hole->nxt);
}
RgSchUlHoleDb *db = sf->holeDb;
RgSchUlHole *prv = alloc->prvHole;
RgSchUlHole *nxt = alloc->nxtHole;
- TRC2(rgSCHUtlUlHoleAddAlloc);
if (prv)
{
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlHoleJoin);
prv->num += alloc->numSb + nxt->num;
rgSCHUtlUlHoleRls(db, nxt);
rgSCHUtlUlHoleIncr(db, prv);
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlHoleExtndRight);
prv->num += alloc->numSb;
rgSCHUtlUlHoleIncr(db, prv);
rgSCHUtlUlHoleUpdAllocLnks(prv, alloc->prv, alloc->nxt);
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlHoleExtndLeft);
nxt->num += alloc->numSb;
nxt->start = alloc->sbStart;
rgSCHUtlUlHoleIncr(db, nxt);
RETVOID;
}
#endif
- TRC2(rgSCHUtlUlHoleNew);
hole->start = alloc->sbStart;
hole->num = alloc->numSb;
++db->count;
RgSchUlAlloc *nxtAlloc;
#endif
{
- TRC2(rgSCHUtlUlHoleUpdAllocLnks);
if (prvAlloc)
{
prvAlloc->nxtHole = hole;
#endif
{
RgSchUlHole *cur;
- TRC2(rgSCHUtlUlHoleIns);
if ((cur = db->first) != NULLP)
{
#endif
{
RgSchUlHole *cur;
- TRC2(rgSCHUtlUlHoleIncr);
if ((cur = hole->prv) != NULLP)
{
#endif
{
RgSchUlHole *cur;
- TRC2(rgSCHUtlUlHoleDecr);
if ((cur = hole->nxt) != NULLP)
{
{
RgSchUlHole *prv = hole->prv;
RgSchUlHole *nxt = hole->nxt;
- TRC2(rgSCHUtlUlHoleRls);
--db->count;
if (prv)
{
S16 ret;
RgSchUlAlloc *allocs;
- TRC2(rgSCHUtlUlAllocMemInit);
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&allocs,
maxAllocs * sizeof(*allocs));
RgSchUlAllocMem *mem;
#endif
{
- TRC2(rgSCHUtlUlAllocMemDeinit);
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(mem->allocs)),
{
S16 ret;
RgSchUlHole *holes;
- TRC2(rgSCHUtlUlHoleMemInit);
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&holes,
maxHoles * sizeof(*holes));
RgSchUlHoleMem *mem;
#endif
{
- TRC2(rgSCHUtlUlHoleMemDeinit);
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(mem->holes)),
#endif
{
RgSchUlAlloc *alloc;
- TRC2(rgSCHUtlUlAllocMemGet);
#if (ERRCLASS & ERRCLS_DEBUG)
if (mem->firstFree == NULLP)
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlAllocMemRls);
alloc->prv = NULLP;
alloc->nxt = mem->firstFree;
#endif
{
RgSchUlHole *hole;
- TRC2(rgSCHUtlUlHoleMemGet);
#if (ERRCLASS & ERRCLS_DEBUG)
if (mem->firstFree == NULLP)
RgSchUlHole *hole;
#endif
{
- TRC2(rgSCHUtlUlHoleMemRls);
hole->prv = NULLP;
hole->nxt = mem->firstFree;
{
RgSchUlHole *hole, *nxtHole;
RgSchUlAlloc *alloc = NULLP;
- TRC2(rgSCHUtlUlGetSpfcAlloc);
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
U8 qciIdx;
U8 qciVal;
- TRC3(rgSCHUtlValidateQci)
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
U16 measType;
S16 ret;
- TRC3(rgSCHUtlValidateMeasReq)
measType = schL2MeasInfo->measType;
{
U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
- TRC2(rgSCHUtlRgrSiCfgCfm)
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
{
U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
- TRC2(rgSCHUtlRgrWarningSiCfgCfm)
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
{
U8 idx = 0;
U32 sizeOfSiInfo = 0;
- TRC2(rgSCHUtlPutSiInfo)
/*Free the buffers in crntSiInfo*/
RGSCH_FREE_MSG(cell->siCb.crntSiInfo.mib)
RGSCH_FREE_MSG(cell->siCb.crntSiInfo.sib1Info.sib1)
idxStart = ue->schCqiInfo.cqiCount - numCqiRept;
- cmMemcpy ((U8*)&(staInfo->ueCqiInfo.cqiRept),
- (U8*)&(ue->schCqiInfo.cqiRept[idxStart]),
+ memcpy (&(staInfo->ueCqiInfo.cqiRept),
+ &(ue->schCqiInfo.cqiRept[idxStart]),
numCqiRept * sizeof(RgrUeCqiRept));
staInfo->ueCqiInfo.numCqiRept = numCqiRept;
S16 ret = ROK;
RgSchUpSapCb *rgrSap; /*!< RGR SAP Control Block */
- TRC2(rgSCHUtlRgrStaInd)
rgrSap = cell->rgrSap;
Inst inst = cell->instIdx;
RgInfRlsRnti rntiInfo;
- TRC2(rgSCHUtlIndRntiRls2Mac)
/* Copy the info to rntiInfo */
rntiInfo.cellId = cell->cellId;
S16 ret = ROK;
RgSchUpSapCb *rgrSap; /*!< RGR SAP Control Block */
- TRC2(rgSCHUtlRgrLoadInfInd)
-
-
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
#endif
{
- TRC2(rgSCHUtlRlsRnti)
U8 isLegacy = 0;
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
S16 ret = ROK;
RgSchUpSapCb *rgrSap; /*!< RGR SAP Control Block */
- TRC2(rgSCHUtlRgrStaInd)
-
-
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
count++;
#endif
- TRC2(rgSCHUtlUpdAvgPrbUsage);
-
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
return RFAILED;
}
- cmMemset((U8 *) &prbRprtInd->stQciPrbRpts[0],
+ memset(&prbRprtInd->stQciPrbRpts[0],
0,
(RGM_MAX_QCI_REPORTS * sizeof(RgmPrbRptPerQci)));
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHUtlReTxTa)
/* If TA Timer is running. Stop it */
if (ueCb->taTmr.tmrEvnt != TMR_NONE)
U32 crntTimeInSubFrms = 0;
U32 boUpdTimeInSubFrms = 0;
U32 distance = 0;
- TRC2(rgSCHChkBoUpdate);
crntTimeInSubFrms = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) + cell->crntTime.slot +
RG_SCH_CMN_DL_DELTA + 2; /* As bo received will scheduled in next TTI
RgSchUlSf *ulSf;
U8 ulSF; /* UL SF in the TDD frame */
- TRC2(rgSchUtlCfg0ReTxIdx);
-
ulSf = &cellUl->ulSfArr[hqFdbkIdx];
ulSF = ulSf->ulSfIdx;
U8 iTbs;
U8 cfi = dlCell->currCfi;
- TRC2(rgSchUtlDlCalc1CwPrb);
-
iTbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
eff = (*(RgSchCmnTbSzEff *)(dlCell->cqiToEffTbl[0][cfi]))[iTbs];
U8 iTbs1, iTbs2;
U8 cfi = dlCell->currCfi;
- TRC2(rgSchUtlDlCalc2CwPrb);
-
if ((dlUe->mimoInfo.forceTD) ||/* Transmit Diversity (TD) */
(dlUe->mimoInfo.ri < 2))/* 1 layer precoding */
{
U32 *prbReqrd;
#endif
{
- TRC2(rgSchUtlCalcTotalPrbReq);
-
/* Call TM specific Prb calculation routine */
(dlCalcPrbFunc[ue->mimoInfo.txMode - 1])(cell, ue, bo, prbReqrd);
U8 ri;
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cell);
- TRC3(rgSCHUtlFetchPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
(ueCb->mimoInfo.txMode != RGR_UE_TM_4))
Pst pst;
RgInfLcgRegReq lcgRegReq;
- TRC3(rgSCHUtlBuildNSendLcgReg);
-
- cmMemset((U8*)&pst, (U8)0, sizeof(Pst));
+ memset(&pst, 0, sizeof(Pst));
lcgRegReq.isGbr = isGbr;
lcgRegReq.cellId = cell->cellId;
lcgRegReq.crnti = crnti;
TfuAckNackMode mode = TFU_UCI_FORMAT_1A_1B;
- TRC2(rgSchUtlGetFdbkMode);
-
switch(fdbkType)
{
case RG_SCH_UCI_FORMAT_NON_CA:
Inst inst = cell->instIdx;
RgInfRlsRnti rntiInfo;
- TRC2(rgSCHUtlSndUeSCellDel2Mac)
-
RGSCHDBGINFONEW(inst,(rgSchPBuf(inst),"RNTI Release IND for UE(%d)\n", rnti));
/* Copy the info to rntiInfo */
rntiInfo.cellId = cell->cellId;
{
U8 maxTbCount;
- TRC2(rgSCHUtlGetMaxTbSupp);
-
/* Primary Cell */
switch(txMode)
{
U32 tptDelta;
- TRC3(rgSCHUtlCpuOvrLdAdjItbsCap)
-
if ((cell->cpuOvrLdCntrl.cpuOvrLdIns) & (RGR_CPU_OVRLD_DL_TPT_UP |
RGR_CPU_OVRLD_DL_TPT_DOWN))
{
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
U8 idx;
- TRC3(rgSCHUtlResetCpuOvrLdState)
-
#ifdef CPU_OL_DBG_PRINTS
printf("\n CPU OVR LD Ins Rcvd = %d\n", (int)crntCpuOvrLdIns);
#endif
RgSchRrCListCp *lCp; /* list control point */
#endif
{
- TRC2(rgSCHRrCListInit);
lCp->first = (RgSchRrCList *)NULLP;
lCp->crnt = (RgSchRrCList *)NULLP;
RgSchRrCList *node; /* node to be added */
#endif
{
- TRC2(rgSCHRrCListAdd2Crnt);
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
RETVOID;
RgSchRrCList *node; /* node to be added */
#endif
{
- TRC2(rgSCHRrCListAdd2Tail);
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
RgSchRrCList *node; /* node to be removed */
#endif
{
- TRC2(rgSCHRrCListDelFrm);
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
#endif
{
RgSchRrCList *crnt;
- TRC2(rgSCHRrCListInsrtAtCrnt);
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
return LCM_REASON_INVALID_MSGTYPE;
}
/* Update the Pst structure for LM interface */
- memcpy((uint8_t *)&schCb[inst].schInit.lmPst,
- (uint8_t *)&cfg->s.schInstCfg.genCfg.lmPst,
+ memcpy(&schCb[inst].schInit.lmPst,
+ &cfg->s.schInstCfg.genCfg.lmPst,
sizeof(Pst));
schCb[inst].schInit.inst = inst;
schCb[inst].genCfg.startCellId = cfg->s.schInstCfg.genCfg.startCellId;
#if 0
/* Initialzie the timer queue */
- memset((uint8_t *)&schCb[inst].tmrTq, 0, sizeof(CmTqType)*RGSCH_TQ_SIZE);
+ memset(&schCb[inst].tmrTq, 0, sizeof(CmTqType)*RGSCH_TQ_SIZE);
/* Initialize the timer control point */
- memset((uint8_t *)&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
+ memset(&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
schCb[inst].tmrTqCp.tmrLen = RGSCH_TQ_SIZE;
/* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */
memset(&cfmPst, 0 , sizeof(Pst));
SchFillCfmPst(pst, &cfmPst, cfg);
- memset((uint8_t *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
#ifdef LMINT3
cfm.hdr.transId =
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
{ \
- memset((U8*)_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
} \
else \
{ \
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkCkwBndReq)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkCkwUbndReq)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkCkwBndCfm)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkRlcTmInfo)
CMCHKPK(oduUnpackUInt32, param->dl.buffSize, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRlcUmInfo)
switch(param->dir)
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkRlcAmInfo)
/* UP LINK */
CMCHKPK(oduUnpackUInt8, param->ul.reOrdTmr, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwLChInfo)
CMCHKPK(oduUnpackUInt8, param->type, mBuf);
CMCHKPK(oduUnpackUInt8, param->lChId, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRlcEntCfgInfo)
switch(param->entMode)
{
{
S16 idx;
- TRC3(cmPkRlcCfgInfo)
for (idx = param->numEnt-1; idx >= 0; idx--)
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkRlcEntCfgCfmInfo)
CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
{
S16 idx;
- TRC3(cmPkRlcCfgCfmInfo)
for (idx = param->numEnt-1; idx >= 0; idx--)
{
S16 ret1;
Buffer *mBuf;
mBuf = NULLP;
- TRC3(cmPkRlcCfgCfm)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
Buffer *mBuf;
#endif
{
- TRC2(cmPkCkwUeInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkCkwUeIdChgReq)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
S16 ret1;
Buffer *mBuf = NULLP;
- TRC3(cmPkCkwUeIdChgCfm)
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
{
SuId suId = 0;
SpId spId = 0;
- TRC3(cmUnpkCkwBndReq)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW024, pst);
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
SpId spId = 0;
Reason reason = 0;
- TRC3(cmUnpkCkwUbndReq)
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW026, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, ECKW027, pst);
SuId suId = 0;
U8 status = 0;
- TRC3(cmUnpkCkwBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, ECKW029, pst);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcTmInfo)
CMCHKUNPK(oduPackUInt32, &(param->dl.buffSize), mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcUmInfo)
switch(param->dir)
{
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcAmInfo)
/* DOWN LINK */
CMCHKUNPK(oduPackUInt8, &(param->dl.snLen), mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCkwLChInfo)
CMCHKUNPK(oduPackUInt8, &(param->lChId), mBuf);
CMCHKUNPK(oduPackUInt8, &(param->type), mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcEntCfgCfmInfo)
CMCHKUNPK(oduPackUInt8, &(param->rbId), mBuf);
CMCHKUNPK(oduPackUInt8, &(param->rbType), mBuf);
{
U8 idx;
- TRC3(cmUnpkRlcCfgCfmInfo)
CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW030, pst);
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcEntCfgInfo)
CMCHKUNPK(oduPackUInt8, &(param->cfgType), mBuf);
CMCHKUNPK(oduPackUInt8, &(param->rbId), mBuf);
{
U8 idx;
- TRC3(cmUnpkRlcCfgInfo)
CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW031, pst);
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
SuId suId = 0;
RlcCfgCfmInfo *cfgCfmInfo = NULLP;
- TRC3(cmUnpkRlcCfgCfm)
if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
sizeof(RlcCfgCfmInfo))) != ROK)
return (ret1);
}
- cmMemset((U8 *)cfgCfmInfo, 0, sizeof(RlcCfgCfmInfo));
+ memset(cfgCfmInfo, 0, sizeof(RlcCfgCfmInfo));
CMCHKUNPK(SUnpkS16, &suId, mBuf);
Buffer *mBuf;
#endif
{
- TRC2(cmUnpkCkwUeInfo)
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
CkwUeInfo *ueInfo = NULLP;
CkwUeInfo *newUeInfo = NULLP;
- TRC3(cmUnpkCkwUeIdChgReq)
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
return (ret1);
}
- cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
+ memset(ueInfo, 0, sizeof(CkwUeInfo));
ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
return (ret1);
}
- cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
+ memset(newUeInfo, 0, sizeof(CkwUeInfo));
ret1 = cmUnpkCkwUeInfo((newUeInfo), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
CkwUeInfo *ueInfo = NULLP;
CmStatus status;
- TRC3(cmUnpkCkwUeIdChgCfm)
- cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
+ memset(&status, 0, sizeof(CmStatus));
CMCHKUNPK(SUnpkS16, &suId, mBuf);
CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, ECKW042, pst);
return (ret1);
}
- cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
+ memset(ueInfo, 0, sizeof(CkwUeInfo));
ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
CmTimer *tmp1;
CmTimer **tmp2;
- TRC2(cmPrcTmr)
#ifdef CMDBG
{
CmTimer *tmp1;
VOLATILE U32 startTime = 0;
- TRC2(cmPrcTmr)
/*starting Task*/
SStartTask(&startTime, PID_CM_PRC_TMR);
CmTimer *tPtr;
REG1 U8 i;
- TRC2(cmInitTimers)
for (i = 0, tPtr = timers; i < max; i++, tPtr++)
{
U32 expire;
CmTimer **tmp;
- TRC2(cmPlcCbTq)
expire = (arg->tqCp->nxtEnt + arg->wait);
/* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
CmTqType *tq;
CmTimer *target;
U32 expire;
- TRC2(cmPlcCbTq)
expire = (arg->tqCp->nxtEnt + arg->wait);
ent = (U32)(expire % (U32)(arg->tqCp->tmrLen));
CmTmrArg *arg;
#endif
{
- TRC2(cmRstCbTq)
arg->timers[arg->tNum].tqExpire = arg->tqCp->nxtEnt + arg->wait;
arg->timers[arg->tNum].ent2bUpd = TRUE;
CmTimer *tmp1;
CmTimer **tmp2;
- TRC2(cmRmvCbTq)
target = &arg->timers[arg->tNum];
if (target->tmrEvnt != TMR_NONE)
CmTimer *target;
CmTqType *tq;
-
- TRC2(cmRmvCbTq)
-
target = &arg->timers[arg->tNum];
if (target->tmrEvnt != TMR_NONE)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkDateTime)
/*-- cm_gen_c_001.main_36 - added for micro seconds --*/
#ifdef SS_DATETIME_USEC
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkDuration)
CMCHKPK(oduUnpackUInt8, duration->tenths, mBuf);
CMCHKPK(oduUnpackUInt8, duration->secs, mBuf);
U32 tmp32;
#endif
- TRC2(oduPackPointer)
ret = ROK;
switch (PTRSIZE)
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkEntityId)
CMCHKPK(cmPkInst, entityId->inst, mBuf);
CMCHKPK(cmPkEnt, entityId->ent, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkElmntId)
CMCHKPK(cmPkElmntInst3, elmntId->elmntInst3, mBuf);
CMCHKPK(cmPkElmntInst2, elmntId->elmntInst2, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkMemoryId)
CMCHKPK(cmPkPool, memoryId->pool, mBuf);
CMCHKPK(cmPkRegion, memoryId->region, mBuf);
{
Txt *p; /* part number string */
- TRC2(cmPkSystemId)
for (p = systemId->ptNmb; *p; p++);
{
U8 j; /* Index */
- TRC3(cmPkProtAddr)
#ifdef CM_ARI2
CMCHKPK(oduUnpackUInt32, pAddr->autoSysId, mBuf);
U8 j; /* Index */
ProtAddr *pAddr; /* protocol Address */
- TRC3(cmPkProtAddrTbl)
if (protAddr->count > MAX_PROT_ADDRS)
return RFAILED;
{
U8 i; /* loop counter */
- TRC2(cmPkAddrs)
if (addrs->length > ADRLEN)
return RFAILED;
{
U8 i; /* loop counter */
- TRC2(cmPkShrtAddrs)
if (addrs->length > SHRTADRLEN)
return RFAILED;
{
S16 i; /* counter */
- TRC2(cmPkAddrMask)
/* pack address mask */
for (i = (ADRLEN - 1); i >= 0; i--)
{
Txt *p; /* temporary */
- TRC2(cmPkBndCfg)
CMCHKPK(cmPkSelector, bndCfg->selector, mBuf);
CMCHKPK(cmPkAddrs, &bndCfg->sapAdr, mBuf);
Buffer *mBuf;
#endif
{
- TRC2(cmPkPst)
CMCHKPK(cmPkEvent, pst->event, mBuf);
CMCHKPK(cmPkInst, pst->srcInst, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkElmtHdr)
#if (LCAMT || ATM_BISUP)
CMCHKPK(oduUnpackUInt16, m->compInd, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknU8)
if (tknU8->pres)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknS8)
if (tknS8->pres)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknU16)
if (tknU16->pres)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknU32)
if (tknU32->pres)
{
{
Cntr i; /* counter */
- TRC2(cmPkTknStr)
if (tknStr->pres)
{
{
Cntr i; /* counter */
- TRC2(cmPkTknStrM)
if(tknStr->pres)
{
{
Cntr i; /* counter */
- TRC2(cmPkTknStrS)
if(tknStr->pres)
{
{
Cntr i; /* counter */
- TRC2(cmPkTknStrE)
if(tknStr->pres)
{
{
S16 i;
- TRC3(cmPkPnNodeId);
for (i = PN_NODEID_LEN - 1; i >= 0; i--)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr4)
CMPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr12)
CMPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr32)
CMPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr64)
CMPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr132)
CMPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr256)
CMPKTKNSTR(tknStr, mBuf);
{
U16 i;
- TRC2(cmPkTknOid)
if (tknOid->pres == TRUE)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknS32)
if (tknS32->pres)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkHeader)
#ifdef LMINT3
CMCHKPK(cmPkMemoryId, &header->response.mem, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkCmStatus)
CMCHKPK(oduUnpackUInt16, sta->reason, mBuf);
CMCHKPK(oduUnpackUInt16, sta->status, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkCmAlarm)
CMCHKPK(oduUnpackUInt16, alarm->cause, mBuf);
CMCHKPK(oduUnpackUInt16, alarm->event, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkSmCfg)
CMCHKPK(cmPkSelector, smCfg->selector, mBuf);
CMCHKPK(cmPkRoute, smCfg->route, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTmrCfg)
CMCHKPK(oduUnpackUInt16, tmrCfg->val, mBuf);
CMCHKPK(oduPackBool, tmrCfg->enb, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknBuf)
if(tknBuf->pres)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkIntf)
CMCHKPK(cmPkIntfId, intf->intfId, mBuf);
CMCHKPK(cmPkIntfVer, intf->intfVer, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpDateTime)
CMCHKUNPK(oduPackUInt8, &dateTime->month, mBuf);
CMCHKUNPK(oduPackUInt8, &dateTime->day, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpDuration)
CMCHKUNPK(oduPackUInt8, &duration->days, mBuf);
CMCHKUNPK(oduPackUInt8, &duration->hours, mBuf);
U64 tmp64;
#endif
- TRC2(oduUnpackPointer)
switch (PTRSIZE)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkEntityId)
CMCHKUNPK(cmUnpkEnt, &entityId->ent, mBuf);
CMCHKUNPK(cmUnpkInst, &entityId->inst, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkElmntId)
CMCHKUNPK(cmUnpkElmnt, &elmntId->elmnt, mBuf);
CMCHKUNPK(cmUnpkElmntInst1, &elmntId->elmntInst1, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkMemoryId)
CMCHKUNPK(cmUnpkRegion, &memoryId->region, mBuf);
CMCHKUNPK(cmUnpkPool, &memoryId->pool, mBuf);
S16 i; /* loop counter */
MsgLen len;
- TRC2(cmUnpkSystemId)
CMCHKUNPK(SUnpkS16, &systemId->mVer, mBuf);
CMCHKUNPK(SUnpkS16, &systemId->mRev, mBuf);
{
U8 j; /* Index */
- TRC3(cmUnpkProtAddr)
CMCHKUNPK(oduPackUInt16, &(pAddr->protType), mBuf);
CMCHKUNPK(oduPackUInt8, &(pAddr->len), mBuf);
U8 j; /* Index */
ProtAddr *pAddr; /* Protocol Address */
- TRC3(cmUnpkProtAddrTbl)
CMCHKUNPK(oduPackUInt8, &protAddr->count, mBuf);
for (i = 0; i < protAddr->count; i++)
{
U8 i; /* loop counter */
- TRC2(cmUnpAddrs)
CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
{
U8 i; /* loop counter */
- TRC2(cmUnpShrtAddrs)
CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
{
S16 i; /* counter */
- TRC2(cmUnpAddrMask)
/* unpack address mask */
for (i = 0; i< ADRLEN; i++)
{
S16 i; /* loop counter */
- TRC2(cmUnpBndCfg)
for (i = 0; bndCfg->usrId[i]; i++);
CMCHKUNPK(cmUnpkTxt, bndCfg->usrId+i, mBuf);
Buffer *mBuf;
#endif
{
- TRC2(cmUnpkPst)
#ifdef TDS_ROLL_UPGRADE_SUPPORT
CMCHKUNPK(cmUnpkIntfVer, &pst->intfVer, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpElmtHdr)
/* Present */
CMCHKUNPK(oduUnpackBool, &m->pres , mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpTknU8)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknU8->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpTknS8)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknS8->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpTknU16)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknU16->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpTknU32)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknU32->pres, mBuf);
{
Cntr i; /* counter */
- TRC2(cmUnpTknStr)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
Cntr i; /* counter */
- TRC2(cmUnpTknStrM)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
Cntr i; /* counter */
- TRC2(cmUnpTknStrS)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
Cntr i; /* counter */
- TRC2(cmUnpTknStrE)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
S16 i;
- TRC3(cmUnpkPnNodeId);
for (i = 0; i < PN_NODEID_LEN; i++)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr4)
CMUNPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr12)
CMUNPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr32)
CMUNPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr64)
CMUNPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr132)
CMUNPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr256)
CMUNPKTKNSTR(tknStr, mBuf);
{
U16 i;
- TRC2(cmUnpkTknOid)
/* Unpack the token header */
CMCHKUNPK(oduPackUInt8, &tknOid->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpTknS32)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknS32->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpHeader)
CMCHKUNPK(oduPackUInt16, &header->msgLen, mBuf);
CMCHKUNPK(oduPackUInt8, &header->msgType, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkCmStatus)
CMCHKUNPK(oduPackUInt16, &sta->status, mBuf);
CMCHKUNPK(oduPackUInt16, &sta->reason, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkCmAlarm)
CMCHKUNPK(cmUnpkDateTime, &alarm->dt, mBuf);
CMCHKUNPK(oduPackUInt16, &alarm->category, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpSmCfg)
CMCHKUNPK(cmUnpkEnt, &smCfg->ent, mBuf);
CMCHKUNPK(cmUnpkInst, &smCfg->inst, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpTmrCfg)
CMCHKUNPK(oduUnpackBool, &tmrCfg->enb, mBuf);
CMCHKUNPK(oduPackUInt16, &tmrCfg->val, mBuf);
Buffer *mBuf;
- TRC2(cmUnpkTknBuf)
mBuf = *tBuf;
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkIntf)
CMCHKUNPK(cmUnpkIntfVer, &intf->intfVer, mBuf);
CMCHKUNPK(cmUnpkIntfId, &intf->intfId, mBuf);
U32 len; /* length */
/*cm_hash_c_001.main_23 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHashFuncAnyKey);
/* Set up the internal state */
len = keyLen; /* key length */
a = 0x9e3779b9; /* a = b = the golden ratio; an arbitrary value */
{
U32 sum; /* Sum of octets for hash function */
- TRC2(cmHashFuncU32Mod);
/* keyLen is marked Unused to remove compilation
* warnings. */
U32 secondU32 = 0; /* Second U32 prepared for higher 4 octets */
U32 sum; /* Sum of the above 2 octets to get the index */
- TRC2(cmHashFuncBCD8);
/* keyLen is marked Unused to remove compilation
* warnings. */
U16 cntr; /* Index */
U32 sum; /* Sum of octets for hash function */
- TRC2(cmHashFuncString)
sum = 0;
{
U32 sum; /* sum of key string octets */
- TRC2(cmHashFuncDefault);
/* add all bytes of the key */
sum = 0;
U32 prod; /* (constant multiplier * key) */
U8 shift; /* Bits to be shifted to get index */
- TRC2(cmHashFuncMult24);
UNUSED(keyLen);
#endif
{
- TRC2(cmHashFuncConId);
/* switch based on the length of the key */
switch (keyLen)
U16 *idx; /* index to return */
#endif
{
- TRC2(cmHashFuncDirIdx);
UNUSED(hashListCp);
UNUSED(keyLen);
U16 keyLen2; /* length of second key string */
#endif
{
- TRC2(cmHashMatchKey);
/* compare key lengths */
if (keyLen1 != keyLen2)
CmListEnt *newEntry; /* new entry to add */
#endif
{
- TRC2(cmListInsert);
newEntry->next = oldEntry->next;
newEntry->prev = oldEntry;
CmListEnt *entry; /* entry to delete */
#endif
{
- TRC2(cmListDelete);
if (entry == NULLP)
return RFAILED;
CmListBinEnt *hl;
#endif
- TRC2(cmHashListInit);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
CmHashListCp *hashListCp; /* hash list to deinitialize */
#endif
{
- TRC2(cmHashListDeinit);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
PTR dupEntry; /* pointer to entry with duplicate key */
U16 idx; /* index for insertion into hash list */
- TRC2(cmHashListInsert);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
U16 idx; /* index for selecting the right hash list bin */
#endif
- TRC2(cmHashListDelete);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
U16 i; /* counter for sequence number */
U16 idx; /* index for insertion into hash list */
- TRC2(cmHashListFind);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
CmHashListEnt *prevListEnt; /* previous hash list entry pointer */
U16 i; /* hash list counter */
- TRC2(cmHashListGetNext);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
CmHashListEnt *hashListEnt; /* temporary hash list entry pointer */
CmHashListEnt *prevListEnt; /* previous hash list entry pointer */
- TRC2(cmHashListBinGetNextEntry);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
U8 i;
#endif
- TRC2(cmHashListQuery);
/* deal with queries that do not need hashListCp */
/* cm_hash_c_001.main_21. Modify. Compilation Issue resolved. */
U16 nmbEnt;
- TRC2(cmHashListOAInsert);
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
{
S32 ret;
- TRC2(cmInetPoll);
ret = 0;
*numRdyFds = 0;
#endif
{
- TRC2(cmInetPollSetFd);
if ((idx) >= CM_INET_POLL_MAXFDSUPP || (idx) < 0)
{
{
S16 ret;
- TRC2(cmInetPollFdIsSet);
if((idx < 0) || (idx > CM_INET_POLL_MAXFDSUPP))
{
#endif
{
- TRC2(cmInetPollClearFdREvent);
if((idx < 0) || (idx > CM_INET_POLL_MAXFDSUPP))
#endif
{
- TRC2(cmInetPollClearFdEvent);
if((idx < 0) || (idx > CM_INET_POLL_MAXFDSUPP))
#endif
{
- TRC2(cmInetPollDelFd);
if(lastIdx < delIdx || lastIdx < 0 || delIdx < 0)
{
{
S16 idx;
- TRC2(cmInetPollInitFdArr);
/* Sets each element of pollFdArr to initial value
fd = -1
events = 0
Bool bNewBehavior;
#endif /* WIN2K && WIN32 */
- TRC2(cmInetSocket);
#if (defined(WIN32) && defined(WIN2K))
bytesReturned = 0;
U32 sizeOfAddr; /* sizeof address passed to the bind call */
CmInetSockAddr *sockAddrPtr;
- TRC2(cmInetBind);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
#ifdef IPV6_SUPPORTED
if (myAddr->type == CM_INET_IPV6ADDR_TYPE)
{
- cmMemset((U8*)&srcAddr6, 0, sizeof(srcAddr6));
+ memset(&srcAddr6, 0, sizeof(srcAddr6));
srcAddr6.sin6_family = AF_INET6;
srcAddr6.sin6_port = CM_INET_HTON_U16(myAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&srcAddr6.sin6_addr,
}
else
{
- cmMemset((U8*)&srcAddr, 0, sizeof(srcAddr));
+ memset(&srcAddr, 0, sizeof(srcAddr));
srcAddr.sin_family = AF_INET;
srcAddr.sin_port = CM_INET_HTON_U16(myAddr->u.ipv4Addr.port);
srcAddr.sin_addr.s_addr = CM_INET_HTON_U32(myAddr->u.ipv4Addr.address);
sockAddrPtr = (CmInetSockAddr *)&srcAddr;
}
#else
- cmMemset((U8*)&srcAddr, 0, sizeof(srcAddr));
+ memset(&srcAddr, 0, sizeof(srcAddr));
srcAddr.sin_family = AF_INET;
srcAddr.sin_port = CM_INET_HTON_U16(myAddr->port);
srcAddr.sin_addr.s_addr = CM_INET_HTON_U32(myAddr->address);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- cmMemset((U8*)&addrs, 0, (sizeof(struct sockaddr_in) * CM_INET_NUM_NET_ADDR));
+ memset(&addrs, 0, (sizeof(struct sockaddr_in) * CM_INET_NUM_NET_ADDR));
#ifdef IPV6_SUPPORTED
- cmMemset((U8*)&addrs6, 0, (sizeof(struct sockaddr_in6) * CM_INET_NUM_NET_ADDR));
+ memset(&addrs6, 0, (sizeof(struct sockaddr_in6) * CM_INET_NUM_NET_ADDR));
#endif /* IPV6_SUPPORTED */
for (idx = 0; idx < addrLst->count; idx++)
addrLst->addrs[idx].u.ipv4NetAddr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
cmInetNtoa(addrLst->addrs[idx].u.ipv4NetAddr, &addrString);
addrLen = cmStrlen((U8*)addrString);
- cmMemcpy((U8*)(ipv4Format+7), (U8*)addrString, addrLen);
+ memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)(addrs6[idx6].sin6_addr.s6_addr), ipv4Format);
idx6++;
{
sockAddrPtr = (struct sockaddr*)address_array;
sockAddrLen = sizeof(struct sockaddr_in);
- cmMemcpy((U8*)address_array, (U8*)addrs, ipv4_array_size);
+ memcpy(address_array, addrs, ipv4_array_size);
}
#ifdef IPV6_SUPPORTED
else
if(ipv6_array_size > 0)
{
- cmMemcpy((U8*)(address_array + ipv4_array_size), (U8*)addrs6, ipv6_array_size);
+ memcpy((address_array + ipv4_array_size), addrs6, ipv6_array_size);
}
#endif /* IPV6_SUPPORTED */
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- cmMemset((U8*)&addrs, 0, (sizeof(struct sockaddr_in) * CM_INET_NUM_NET_ADDR));
+ memset(&addrs, 0, (sizeof(struct sockaddr_in) * CM_INET_NUM_NET_ADDR));
#ifdef IPV6_SUPPORTED
- cmMemset((U8*)&addrs6, 0, (sizeof(struct sockaddr_in6) * CM_INET_NUM_NET_ADDR));
+ memset(&addrs6, 0, (sizeof(struct sockaddr_in6) * CM_INET_NUM_NET_ADDR));
#endif /* IPV6_SUPPORTED */
cnt = 0;
ipv4NetAddr = CM_INET_HTON_U32(primAddr->u.ipv4NetAddr);
cmInetNtoa(ipv4NetAddr, &addrString);
addrLen = cmStrlen((U8*)addrString);
- cmMemcpy((U8*)(ipv4Format+7), (U8*)addrString, addrLen);
+ memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)&(addrs6[idx6].sin6_addr), ipv4Format);
addresses_array_size += sizeof(struct sockaddr_in6);
ipv4NetAddr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
cmInetNtoa(ipv4NetAddr, &addrString);
addrLen = cmStrlen((U8*)addrString);
- cmMemcpy((U8*)(ipv4Format+7), (U8*)addrString, addrLen);
+ memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)(addrs6[idx6].sin6_addr.s6_addr), ipv4Format);
addresses_array_size += sizeof(struct sockaddr_in6);
if((ipv4_array_size > 0) && (ipv4_array_size <= (CM_INET_NUM_NET_ADDR * \
sizeof(struct sockaddr_in))))
{
- cmMemcpy((U8*)address_array, (U8*)&addrs[0], ipv4_array_size);
+ memcpy(address_array, &addrs[0], ipv4_array_size);
}
else
{
if((ipv6_array_size > 0) && (ipv6_array_size <= (CM_INET_NUM_NET_ADDR * \
sizeof(struct sockaddr_in))))
{
- cmMemcpy((U8*)(address_array + ipv4_array_size), (U8*)addrs6, ipv6_array_size);
+ memcpy((address_array + ipv4_array_size), addrs6, ipv6_array_size);
}
else
{
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- cmMemset((U8*)&addr, 0, sizeof(struct sockaddr_in));
+ memset(&addr, 0, sizeof(struct sockaddr_in));
#ifdef IPV6_SUPPORTED
- cmMemset((U8*)&addr6, 0, sizeof(struct sockaddr_in6));
+ memset(&addr6, 0, sizeof(struct sockaddr_in6));
#endif /* IPV6_SUPPORTED */
/* copy message to a flat buffer */
ipv4NetAddr = CM_INET_HTON_U32(dstAddr->u.ipv4NetAddr);
cmInetNtoa(ipv4NetAddr, &addrString);
addrLen = cmStrlen((U8*)addrString);
- cmMemcpy((U8*)(ipv4Format+7), (U8*)addrString, addrLen);
+ memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)(addr6.sin6_addr.s6_addr), ipv4Format);
sockAddrLen = sizeof(struct sockaddr_in6);
*mBuf = NULLP;
*len = 0;
- cmMemset((U8*)ntfy, 0, sizeof(CmInetSctpNotification));
+ memset(ntfy, 0, sizeof(CmInetSctpNotification));
buflen = CM_INET_MAX_MSG_LEN;
addrlen = sizeof(struct sockaddr_storage);
msgFlags = 0;
- cmMemset((U8*)&addr, 0, sizeof(struct sockaddr_storage));
- cmMemset((U8*)&info, 0, sizeof(struct sctp_sndrcvinfo));
+ memset(&addr, 0, sizeof(struct sockaddr_storage));
+ memset(&info, 0, sizeof(struct sctp_sndrcvinfo));
ret = sctp_recvmsg(sockFd->fd, (Void *)recvbuf, (size_t)buflen,
(struct sockaddr*)&addr, &addrlen, &info,
if((cmMemcmp(ipv4Format, pAddr6->sin6_addr.s6_addr, 12)) == 0)
{
srcAddr->type = CM_INET_IPV4ADDR_TYPE;
- cmMemcpy((U8*)&srcAddr->u.ipv4NetAddr, (U8*)((pAddr6->sin6_addr.s6_addr) + 12), sizeof(U32));
+ memcpy(&srcAddr->u.ipv4NetAddr, ((pAddr6->sin6_addr.s6_addr) + 12), sizeof(U32));
srcAddr->u.ipv4NetAddr = CM_INET_HTON_U32(srcAddr->u.ipv4NetAddr);
}
ntfy->u.remoteErr.data = NULLP;
break;
}
- cmMemcpy(ntfy->u.remoteErr.data,\
+ memcpy(ntfy->u.remoteErr.data,\
sctpNtfy->sn_remote_error.sre_data, datlen);
#endif
break;
ntfy->u.sndFailed.data = NULLP;
break;
}
- cmMemcpy(ntfy->u.sndFailed.data,\
+ memcpy(ntfy->u.sndFailed.data,\
sctpNtfy->sn_send_failed.ssf_data, datlen );
#endif
ntfy->u.sndFailed.info.stream = sctpNtfy->sn_send_failed.ssf_info.sinfo_stream;
/*cm_inet_c_001.main_58 : fix for klockwork issue */
S32 ret;
- TRC2(cmInetGetOpt);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
{
case CM_INET_OPT_SCTP_GET_ASSOC_STA:
pSctpStatus = (CmInetSctpStatus*)value;
- cmMemset((U8*)&status, 0, sizeof(struct sctp_status));
+ memset(&status, 0, sizeof(struct sctp_status));
len = sizeof(status);
status.sstat_assoc_id = pSctpStatus->assocId;
case CM_INET_OPT_SCTP_GET_PADDR_INFO:
pPeerAddrInfo = (CmInetSctpPeerAddrInfo*)value;
- cmMemset((U8*)&addrInfo, 0, sizeof(struct sctp_paddrinfo));
+ memset(&addrInfo, 0, sizeof(struct sctp_paddrinfo));
len = sizeof(addrInfo);
addrInfo.spinfo_assoc_id = pPeerAddrInfo->assocId;
pPeerAddrParams = (CmInetSctpPeerAddrParams *)value;
- cmMemset((U8*)&addrParams, 0, sizeof(struct sctp_paddrparams));
+ memset(&addrParams, 0, sizeof(struct sctp_paddrparams));
addrParams.spp_assoc_id = pPeerAddrParams->assocId;
pAssocParams = (CmInetSctpAssocParams *)value;
- cmMemset((U8*)&assocParams, 0, sizeof(struct sctp_assocparams));
+ memset(&assocParams, 0, sizeof(struct sctp_assocparams));
assocParams.sasoc_assoc_id = pAssocParams->assocId;
pRtoInfo = (CmInetSctpRtoInfo *)value;
- cmMemset((U8*)&rtoInfo, 0, sizeof(struct sctp_rtoinfo));
+ memset(&rtoInfo, 0, sizeof(struct sctp_rtoinfo));
len = sizeof(rtoInfo);
pInitMsg = (CmInetSctpInitMsg *)value;
- cmMemset((U8*)&initMsg, 0, sizeof(struct sctp_initmsg));
+ memset(&initMsg, 0, sizeof(struct sctp_initmsg));
len = sizeof(initMsg);
S32 ret;
struct sctp_sndrcvinfo sndRcvInfo;
- TRC2(cmInetShutDownSctp);
- cmMemset((U8*)&sndRcvInfo, 0, sizeof(sndRcvInfo));
+ memset(&sndRcvInfo, 0, sizeof(sndRcvInfo));
#ifdef SUN_KSCTP
sndRcvInfo.sinfo_flags = MSG_EOF;
S32 ret;
struct sctp_sndrcvinfo sndRcvInfo;
- TRC2(cmInetAbortSctpAssoc);
- cmMemset((U8*)&sndRcvInfo, 0, sizeof(sndRcvInfo));
+ memset(&sndRcvInfo, 0, sizeof(sndRcvInfo));
#ifdef SUN_KSCTP
sndRcvInfo.sinfo_flags = MSG_ABORT;
S32 sizeOfAddr;
CmInetSockAddr *sockAddrPtr;
- TRC2(cmInetConnect);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
#ifdef IPV6_SUPPORTED
if (servAddr->type == CM_INET_IPV6ADDR_TYPE)
{
- cmMemset((U8*)&dstAddr6, 0, sizeof(dstAddr6));
+ memset(&dstAddr6, 0, sizeof(dstAddr6));
dstAddr6.sin6_family = AF_INET6;
dstAddr6.sin6_port = CM_INET_HTON_U16(servAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&dstAddr6.sin6_addr,
}
else
{
- cmMemset((U8*)&dstAddr, 0, sizeof(dstAddr));
+ memset(&dstAddr, 0, sizeof(dstAddr));
dstAddr.sin_family = AF_INET;
dstAddr.sin_port = CM_INET_HTON_U16(servAddr->u.ipv4Addr.port);
dstAddr.sin_addr.s_addr = CM_INET_HTON_U32(servAddr->u.ipv4Addr.address);
sockAddrPtr = (CmInetSockAddr *)&dstAddr;
}
#else
- cmMemset((U8*)&dstAddr, 0, sizeof(dstAddr));
+ memset(&dstAddr, 0, sizeof(dstAddr));
dstAddr.sin_family = AF_INET;
dstAddr.sin_port = CM_INET_HTON_U16(servAddr->port);
dstAddr.sin_addr.s_addr = CM_INET_HTON_U32(servAddr->address);
{
S32 ret; /* temporary return value */
- TRC2(cmInetListen);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
U32 optVal;
/* added */
- TRC2(cmInetAccept)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
}
#ifdef IPV6_SUPPORTED
- cmMemset((U8*)fromAddr, 0, sizeof(fromAddr));
+ memset(fromAddr, 0, sizeof(fromAddr));
if (addrLen == sizeof(struct sockaddr_in))
{
peerAddr = (struct sockaddr_in *)&sockAddr;
struct cmsghdr *tempHdr;
U8 len;
- TRC2(cmInet4FillTos)
len = 0;
MsgLen ioLen;
#endif
- TRC2(cmInetSendDscpMsg)
UNUSED(flags);
/* added for IPv6 ext hdr */
#if !(defined(WIN32) || defined(CMINETFLATBUF))
#if (defined(SS_LINUX) || defined(_XPG4_2))
-/* cmMemset((U8*)cmsgData, 0, sizeof(cmsgData)); */
+/* memset(cmsgData, 0, sizeof(cmsgData)); */
#endif /* SS_LINUX || _XPG4_2 */
curMsgIdx = 0;
#endif /* WIN32 | CMINETFLATBUF */
#ifdef IPV6_SUPPORTED
if (dstAddr->type == CM_INET_IPV6ADDR_TYPE)
{
- cmMemset((U8*)&remAddr6, 0, sizeof(remAddr6));
+ memset(&remAddr6, 0, sizeof(remAddr6));
remAddr6.sin6_family = AF_INET6;
remAddr6.sin6_port = CM_INET_HTON_U16(dstAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&remAddr6.sin6_addr,
}
else
{
- cmMemset((U8*)&remAddr, 0, sizeof(remAddr));
+ memset(&remAddr, 0, sizeof(remAddr));
remAddr.sin_family = AF_INET;
remAddr.sin_port = CM_INET_HTON_U16(dstAddr->u.ipv4Addr.port);
remAddr.sin_addr.s_addr =
sockAddrPtr = (CmInetSockAddr *)&remAddr;
}
#else
-/* cmMemset((U8*)&remAddr, 0, sizeof(remAddr)); */
+/* memset(&remAddr, 0, sizeof(remAddr)); */
remAddr.sin_family = AF_INET;
remAddr.sin_port = CM_INET_HTON_U16(dstAddr->port);
remAddr.sin_addr.s_addr = CM_INET_HTON_U32(dstAddr->address);
}
/* added */
-/* cmMemset((U8*)&msg, 0, sizeof(msg)); */
+/* memset(&msg, 0, sizeof(msg)); */
msg.msg_flags = 0;
if (dstAddr != NULLP)
MsgLen ioLen;
#endif
- TRC2(cmInetSendMsg)
UNUSED(flags);
/* added for IPv6 ext hdr */
#if !(defined(WIN32) || defined(CMINETFLATBUF))
#if (defined(SS_LINUX) || defined(_XPG4_2))
-/* cmMemset((U8*)cmsgData, 0, sizeof(cmsgData)); */
+/* memset(cmsgData, 0, sizeof(cmsgData)); */
#endif /* SS_LINUX || _XPG4_2 */
#ifdef IPV6_OPTS_SUPPORTED
curMsgIdx = 0;
#ifdef IPV6_SUPPORTED
if (dstAddr->type == CM_INET_IPV6ADDR_TYPE)
{
- cmMemset((U8*)&remAddr6, 0, sizeof(remAddr6));
+ memset(&remAddr6, 0, sizeof(remAddr6));
remAddr6.sin6_family = AF_INET6;
remAddr6.sin6_port = CM_INET_HTON_U16(dstAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&remAddr6.sin6_addr,
}
else
{
- cmMemset((U8*)&remAddr, 0, sizeof(remAddr));
+ memset(&remAddr, 0, sizeof(remAddr));
remAddr.sin_family = AF_INET;
remAddr.sin_port = CM_INET_HTON_U16(dstAddr->u.ipv4Addr.port);
remAddr.sin_addr.s_addr =
sockAddrPtr = (CmInetSockAddr *)&remAddr;
}
#else
-/* cmMemset((U8*)&remAddr, 0, sizeof(remAddr)); */
+/* memset(&remAddr, 0, sizeof(remAddr)); */
remAddr.sin_family = AF_INET;
remAddr.sin_port = CM_INET_HTON_U16(dstAddr->port);
remAddr.sin_addr.s_addr = CM_INET_HTON_U32(dstAddr->address);
}
/* added */
-/* cmMemset((U8*)&msg, 0, sizeof(msg)); */
+/* memset(&msg, 0, sizeof(msg)); */
msg.msg_flags = 0;
if (dstAddr != NULLP)
struct in6_addr lpBkAddr;
U8 len;
- TRC2(cmInet6BuildSendPktinfo)
len = 0;
if(protType == AF_INET6)
{
/* store ipv6 src addr */
- cmMemcpy((U8 *)&(ipv6Pktinfo->ipi6_addr), (U8 *)srcAddr, 16);
+ memcpy(&(ipv6Pktinfo->ipi6_addr), srcAddr, 16);
len += 16;
/* store interface index */
struct cmsghdr *tempHdr;
U8 len;
- TRC2(cmInetBuildSendHoplimit)
len = 0;
U8 len;
U8 optsIdx;
- TRC2(cmInet6BuildSendHBHOpts)
len = 0;
optsIdx = 0;
len += sizeof(hbhOptsArr->hbhOpts[optsIdx].length);
/* copy all value bytes of current HBH/dest option to the flat buffer */
- cmMemcpy((U8 *)(cmsgBuf + len),
- (U8 *)(hbhOptsArr->hbhOpts[optsIdx].value),
+ memcpy((cmsgBuf + len),
+ (hbhOptsArr->hbhOpts[optsIdx].value),
hbhOptsArr->hbhOpts[optsIdx].length);
len += hbhOptsArr->hbhOpts[optsIdx].length;
}
U8 len;
U8 addrIdx;
- TRC2(cmInet6BuildSendRouteOpts);
len = 0;
addrIdx = 0;
/* fill up all IPV6 addresses from rtOptsArr in the flat buffer */
for (addrIdx = 0; addrIdx < rtOptsArr->numAddrs; addrIdx++)
{
- cmMemcpy((U8 *)(cmsgBuf + len),
- (U8 *)(rtOptsArr->ipv6Addrs[addrIdx]), 16);
+ memcpy((cmsgBuf + len),
+ (rtOptsArr->ipv6Addrs[addrIdx]), 16);
len += 16;
}
U8 tempType;
S16 ret;
- TRC2(cmInet6BuildRecvHopOptsArr)
/* get length of actual hbh ancillary data */
hbhDataLen -= sizeof(struct cmsghdr);
return (ROUTRES);
}
/* copy the value bytes */
- cmMemcpy((U8 *)hbhOptsArr->hbhOpts[optsIdx].value,
- (U8 *)(cmsgData + curDataIdx),
+ memcpy(hbhOptsArr->hbhOpts[optsIdx].value,
+ (cmsgData + curDataIdx),
hbhOptsArr->hbhOpts[optsIdx].length);
curDataIdx += hbhOptsArr->hbhOpts[optsIdx].length;
}
U8 i; /* loop counter */
S16 ret; /* temporary return value */
- TRC2(cmInet6BuildRecvRtHdr)
/* byte len of actual rtHdr ancil data */
rtDataLen -= sizeof(struct cmsghdr);
curDataIdx += 1;
/* copy 1 reserve byte + 3 strict/loose bytes */
- cmMemcpy((U8 *)(&rtOptsArr->slMap),
- (U8 *)(cmsgData + curDataIdx), 4);
+ memcpy((&rtOptsArr->slMap),
+ (cmsgData + curDataIdx), 4);
curDataIdx += 4;
/* also save reserv byte + 3 sl bytes to rtHdro struc */
/* copy all the ipv6 addresses */
for(i=0; i < rtOptsArr->numAddrs; i++)
{
- cmMemcpy((U8 *)(rtOptsArr->ipv6Addrs[i]),
- (U8 *)(cmsgData + curDataIdx), 16);
+ memcpy((rtOptsArr->ipv6Addrs[i]),
+ (cmsgData + curDataIdx), 16);
curDataIdx += 16;
}
/* cm_inet_c_001.main_55:Removed unused variables errValue and optLen */
- TRC2(cmInetRecvMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
#endif /* IPV6_SUPPORTED */
#if (defined(SS_LINUX) || defined(_XPG4_2))
- cmMemset((U8*)ancillData, 0, sizeof(ancillData));
+ memset(ancillData, 0, sizeof(ancillData));
#endif /* SS_LINUX || _XPG4_2 */
#endif /* (WIN32 | CMINETFLATBUF) */
/* clear the structure */
- cmMemset((U8*)&remSockAddr, 0, sizeof(remSockAddr));
+ memset(&remSockAddr, 0, sizeof(remSockAddr));
/* get number of pending data */
/* removed 3rd arg memInfo. MemInfo is no longer
localIf->intfPrsnt = TRUE;
localIf->localIf = pkt6Info->ipi6_ifindex;
localIf->localIfAddr.type = CM_INET_IPV6ADDR_TYPE;
- cmMemcpy((U8 *)&localIf->localIfAddr.u.ipv6NetAddr,
- (U8 *)(int *)&pkt6Info->ipi6_addr, 16);
+ memcpy(&localIf->localIfAddr.u.ipv6NetAddr,
+ &pkt6Info->ipi6_addr, 16);
}
}
#endif /* LOCAL_INTF */
CmInetSockAddr remSockAddr; /* to get packet's source IP address */
#endif /* IPV6_SUPPORTED */
- TRC2(cmInetPeeknew);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((fromAddr != NULLP) && (remAddrLen > 0))
{
#ifdef IPV6_SUPPORTED
- cmMemset((U8*)fromAddr, 0, sizeof(fromAddr));
+ memset(fromAddr, 0, sizeof(fromAddr));
if (remAddrLen == sizeof(struct sockaddr_in6))
{
remAddr6 = (struct sockaddr_in6 *)&remSockAddr;
CmInetSockAddr remSockAddr; /* to get packet's source IP address */
#endif /* IPV6_SUPPORTED */
- TRC2(cmInetPeek);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((fromAddr != NULLP) && (remAddrLen > 0))
{
#ifdef IPV6_SUPPORTED
- cmMemset((U8*)fromAddr, 0, sizeof(fromAddr));
+ memset(fromAddr, 0, sizeof(fromAddr));
if (remAddrLen == sizeof(struct sockaddr_in6))
{
remAddr6 = (struct sockaddr_in6 *)&remSockAddr;
{
S32 ret; /* temporary return value */
- TRC2(cmInetClose);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
{
S32 ret; /* temporary return value */
- TRC2(cmInetShutdown);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
U32 *optVal;
- TRC2(cmInetSetOpt);
/* cm_inet_c_001.main_58 : Added NULL check for value field */
if(value == NULLP)
case CM_INET_OPT_LINGER:
pSockLinger = (CmInetSockLinger *)value;
- cmMemset((U8*)&lngr, 0, sizeof(struct linger));
+ memset(&lngr, 0, sizeof(struct linger));
if (pSockLinger->enable == TRUE)
lngr.l_onoff = 1;
case CM_INET_OPT_SCTP_EVENTS:
pSctpEvent = (CmInetSctpSockEvent *)value;
- cmMemset((U8*)&event, 0, sizeof(struct sctp_event_subscribe));
+ memset(&event, 0, sizeof(struct sctp_event_subscribe));
if (pSctpEvent->dataIoEvent == TRUE)
event.sctp_data_io_event = 1;
case CM_INET_OPT_SCTP_PRIM_ADDR:
pSctpPrimAddr = (CmInetSctpPrimAddr *)value;
- cmMemset((U8*)&setPrim, 0, sizeof(struct sctp_setprim));
+ memset(&setPrim, 0, sizeof(struct sctp_setprim));
#ifdef IPV6_SUPPORTED
if (pSctpPrimAddr->addr.type == CM_INET_IPV6ADDR_TYPE)
case CM_INET_OPT_SCTP_PEERADDR_PARAMS:
pSctpPAddrParams = (CmInetSctpPeerAddrParams *)value;
- cmMemset((U8*)&addrParams, 0, sizeof(struct sctp_paddrparams));
+ memset(&addrParams, 0, sizeof(struct sctp_paddrparams));
if (pSctpPAddrParams->s.addrPres == TRUE)
case CM_INET_OPT_SCTP_ASSOC_PARAMS:
pSctpAssocParams = (CmInetSctpAssocParams *)value;
- cmMemset((U8*)&assocParams, 0, sizeof(struct sctp_assocparams));
+ memset(&assocParams, 0, sizeof(struct sctp_assocparams));
assocParams.sasoc_cookie_life = pSctpAssocParams->cookieLife;
assocParams.sasoc_asocmaxrxt = pSctpAssocParams->assocMaxReTx;
case CM_INET_OPT_SCTP_RTO_INFO:
pSctpRtoInfo = (CmInetSctpRtoInfo *)value;
- cmMemset((U8*)&rtoinfo, 0, sizeof(struct sctp_rtoinfo));
+ memset(&rtoinfo, 0, sizeof(struct sctp_rtoinfo));
rtoinfo.srto_assoc_id = pSctpRtoInfo->assocId;
rtoinfo.srto_initial = pSctpRtoInfo->rtoInitial;
case CM_INET_OPT_SCTP_INIT_MSG:
pSctpInitMsg = (CmInetSctpInitMsg *)value;
- cmMemset((U8*)&initmsg, 0, sizeof(struct sctp_initmsg));
+ memset(&initmsg, 0, sizeof(struct sctp_initmsg));
initmsg.sinit_max_attempts = pSctpInitMsg->maxInitReTx;
initmsg.sinit_max_init_timeo = pSctpInitMsg->maxInitTimeout;
/* removed local variables added for recvfrom call */
- TRC2(cmInetGetNumRead);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
#endif /* SS_VW */
#endif /* WIN32 || SS_LINUX || HPOS */
- TRC2(cmInetGetHostByName)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
#endif /* SUNOS */
#endif /* IPV6_SUPPORTED */
- TRC2(cmInetGetIpNodeByName)
#if (ERRCLASS & ERRCLS_INT_PAR)
CmInetIpAddr *address; /* 4 byte interent address */
#endif
{
- TRC2(cmInetAddr);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
{
struct in_addr inetAddr; /* internet address structure */
- TRC2(cmInetNtoa);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
{
S32 domain = 0;
- TRC2(cmInetNtop);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
{
S16 ret;
- TRC2(cmInetPton);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
struct sockaddr_storage ss;
U32 sslen = sizeof(ss);
#endif /* WIN32 */
- TRC2(cmInetPton);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
/* cm_inet_c_001.main_44 : In windows inet_pton is not implemented. so we are using the below function
* to convert the ipv6 address string to appropriate form */
WSAStringToAddressA((LPTSTR)asciiAddr, AF_INET6, NULL, (struct sockaddr*)&ss, &sslen);
- cmMemcpy((U8*)address6, (U8*)&(((struct sockaddr_in6 *)&ss)->sin6_addr), sizeof(CmInetIpAddr6));
+ memcpy(address6, &(((struct sockaddr_in6 *)&ss)->sin6_addr), sizeof(CmInetIpAddr6));
#endif /* WIN32 */
return ROK;
/*cm_inet_c_001.main_58 : fix for klockwork issue */
S32 ret;
- TRC2(cmInetGetSockName);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- cmMemset((U8*)&lclSockAddr, 0, sizeof(lclSockAddr));
+ memset(&lclSockAddr, 0, sizeof(lclSockAddr));
size = sizeof(lclSockAddr);
#ifdef UNIX
/* Fill the returned address in to locAddr */
#ifdef IPV6_SUPPORTED
- cmMemset((U8*)locAddr, 0, sizeof(CmInetAddr));
+ memset(locAddr, 0, sizeof(CmInetAddr));
if (size == sizeof(struct sockaddr_in6))
{
sockAddr6 = (struct sockaddr_in6 *)&lclSockAddr;
Bool embedIPV4 = FALSE; /* IPV4 embedded in IPV6 ? */
#endif /* IPV6_SUPPORTED*/
- TRC2(cmInetConvertStrToIpAddr)
idx = 0;
#ifdef IPV6_SUPPORTED
compressed = FALSE;
embedIPV4 = FALSE;
ipv6 = ipv6Reg; /* assign pointer to IPV6 regular, uncompressed */
- cmMemset((U8 *)ipv6Reg, 0, CM_INET_IPV6ADDR_SIZE);
- cmMemset((U8 *)ipv6Cmp, 0, CM_INET_IPV6ADDR_SIZE);
+ memset(ipv6Reg, 0, CM_INET_IPV6ADDR_SIZE);
+ memset(ipv6Cmp, 0, CM_INET_IPV6ADDR_SIZE);
#endif /* IPV6_SUPPORTED*/
- cmMemset((U8 *)ipv4, 0, CM_INET_IPV4ADDR_SIZE);
+ memset(ipv4, 0, CM_INET_IPV4ADDR_SIZE);
/* Check for IP Address */
while ((val[idx] != '.') && (val[idx] != ':') &&
{
/* convert number to IPV4 */
ipv6[ipv6Idx] = 0; /* clear out whatever we did */
- cmMemset((U8 *)ipv4, 0, CM_INET_IPV4ADDR_SIZE);
+ memset(ipv4, 0, CM_INET_IPV4ADDR_SIZE);
retVal = cmInetAsciiToIpv4(4, ipv4, len - blkBeginIdx,
&(val[blkBeginIdx]));
/* stop the loop, embedded IPV4 is the last part of
/* convert IPV6 to cmInetIpv6 */
address->type = CM_INET_IPV6ADDR_TYPE;
- cmMemcpy((U8 *)address->u.ipv6NetAddr,
- (CONSTANT U8 *) ipv6Reg, CM_INET_IPV6ADDR_SIZE);
+ memcpy(address->u.ipv6NetAddr,
+ ipv6Reg, CM_INET_IPV6ADDR_SIZE);
} /* else, IPV6 */
#endif /* IPV6_SUPPORTED */
U8 byteCount; /* Byte Count */
U8 idx; /* Index for string*/
- TRC2(cmInetAsciiToIpv4)
idx = 0;
for (byteCount = 0; byteCount < numBytes; byteCount++)
#endif
{
S32 ret;
- TRC2(cmInetGetAddrInfo);
ret = ROK;
#if (ERRCLASS & ERRCLS_INT_PAR)
CmInetAddrInfo *res; /* Link list of addrInfo structure */
#endif
{
- TRC2(cmInetFreeAddrInfo);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
U32 errValue; /* error value */
U32 optLen; /* option length */
- TRC2(cmInetFlushRcvBuf)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
#endif /* (WIN32 | CMINETFLATBUF) */
/* clear the structure */
- cmMemset((U8*)&remSockAddr, 0, sizeof(remSockAddr));
+ memset(&remSockAddr, 0, sizeof(remSockAddr));
/* get number of pending data */
ret = cmInetGetNumRead(sockFd, &pendLen);
*/
while (curLen > 0)
{
- cmMemset((U8*)recvTempBuf, 0, CM_INET_MAX_BYTES_READ);
+ memset(recvTempBuf, 0, CM_INET_MAX_BYTES_READ);
/* added separate recvfrom calls different OS */
#if( defined(SS_VW) || defined(HPOS) || defined(SS_PS))
*/
while (curLen > 0)
{
- cmMemset((U8*)recvTempBuf, 0, CM_INET_MAX_BYTES_READ);
+ memset(recvTempBuf, 0, CM_INET_MAX_BYTES_READ);
/* update the message structure */
#ifdef SS_LINUX
rxArr[0].iov_base = (Void*)recvTempBuf;
#ifdef IPV6_SUPPORTED
#define CM_INET_COPY_IPV6ADDR(_addrToFill, _fromAddr) \
{ \
- (Void)cmMemcpy((U8 *)_addrToFill, (U8 *)_fromAddr, sizeof(CmInetIpAddr6)); \
+ memcpy(_addrToFill, _fromAddr, sizeof(CmInetIpAddr6)); \
}
#if (defined(SUNOS) || defined(HPOS) || defined(SS_VW))
#ifdef SS_VW
#define CM_COPY_VWIPADDR(vwIpAddr, addr) \
{ \
- (Void)cmMemcpy((U8 *)addr, (U8 *)&vwIpAddr, sizeof(S32)); \
+ memcpy(addr, &vwIpAddr, sizeof(S32)); \
}
#endif
#endif
{
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmMemcpy)
#ifdef MS_MBUF_CORRUPTION /* checking for valid memory address */
if ((tgt > startPtr128) && (tgt < (startPtr128+regMemSize)))
}
#endif
#if (MEMCPY_AVAIL) /* memcpy is available */
- return ((U8 *) memcpy((Void *)tgt, (CONSTANT Void *)src, (size_t)len));
+ return ( memcpy(tgt, src, len));
#else
while (len--)
*tgt++ = *src++;
#endif
{
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmMemcmp)
#if MEMCMP_AVAIL /* memcmp is available */
return ((S16) memcmp((CONSTANT Void *)s1, (CONSTANT Void *)s2, (size_t)len));
#else /* MEMCMP_AVAIL: memcmp is not available */
#endif
{
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmMemset)
#if MS_MBUF_CORRUPTION /* checking for valid memory address */
if ((str > startPtr128) && (str < (startPtr128+regMemSize)))
{
}
else
{
- memset((void *)str,val,(size_t) len);
+ memset(str,val, len);
}
#else /* MEMSET_AVAIL: memset is not available */
while (len --)
#endif
{
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmStrcmp)
#if (STRCMP_AVAIL)
return (strcmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2));
#else /* STRCMP_AVAIL */
#endif
{
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmStrncmp)
#if (STRNCMP_AVAIL)
return (strncmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2, (size_t) len));
#else /* STRNCMP_AVAIL */
{
#if (STRLEN_AVAIL)
/*cm_lib_c_001.main_15 : Fix for warning due to mixed declation*/
- TRC2(cmStrlen)
return ((MsgLen)strlen((CONSTANT S8 *)s));
#else /* STRLEN_AVAIL */
MsgLen i;
/*cm_lib_c_001.main_15 : Fix for warning due to mixed declation*/
- TRC2(cmStrlen)
for (i = 0; *s; i++, s++);
return (i);
CmLListCp *lCp; /* list control point */
#endif
{
- TRC3(cmLListInit);
lCp->first = (CmLList *)NULLP;
lCp->last = (CmLList *)NULLP;
CmLList *node; /* node to be added */
#endif
{
- TRC3(cmLListAdd2Head);
#ifdef ERRCHK
if (lCp == (CmLListCp *)NULLP)
CmLList *node; /* node to be added */
#endif
{
- TRC3(cmLListAdd2Tail);
#ifdef ERRCHK
if (lCp == (CmLListCp *)NULLP)
CmLList *node; /* node to be added */
#endif
{
- TRC3(cmLListInsCrnt);
#ifdef ERRCHK
if (!lCp)
CmLList *node; /* node to be added */
#endif
{
- TRC3(cmLListInsAfterCrnt);
#ifdef ERRCHK
if (!lCp)
CmLList *node; /* node to be removed */
#endif
{
- TRC3(cmLListDelFrm);
#ifdef ERRCHK
/* cm_llist_c_001.main_8 : added null check for node */
CmLListCp *list2; /*-- node to be added --*/
#endif
{
- TRC3(cmLListCatLList);
/*-- if the second list is empty nothing to do --*/
if(list2->count == 0)
#endif
{
- TRC3(cmPkLteRlcId);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
#endif
{
- TRC3(cmUnpkLteRlcId);
CMCHKUNPK(cmUnpkLteRbId, ¶m->rbId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbType, mBuf);
#endif
{
- TRC3(cmPkLteTimingInfo);
CMCHKPK(oduUnpackUInt16, param->slot, mBuf);
CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
#endif
{
- TRC3(cmUnpkLteTimingInfo);
//CMCHKUNPK(oduPackUInt16, ¶m->hSfn, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->sfn, mBuf);
#endif
{
- TRC3(cmPkLtePdcpId);
CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
CMCHKPK(cmPkLteRbId, param->rbId, mBuf);
#endif
{
- TRC3(cmUnpkLtePdcpId);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CmMemListCp *memCp; /* memory Link list control point */
CmMemCb *cb; /* Allocated Memory Control Block */
- TRC2(cmAllocEvnt)
/* Validation check */
#ifndef LTE_ENB_PAL
return RFAILED;
/* Reset the contents */
- cmMemset((U8 *)allocPtr, (U8 )0,
- (PTR)(maxBlkSize + sizeof(CmMemList)) );
+ memset(allocPtr, 0,
+ (maxBlkSize + sizeof(CmMemList)) );
/* The above allocated memory chunk is structured as follows
#endif
{
- TRC2(cmInitMemCp)
/* Intialise Memory Control Point */
CM_INIT_MEMCP(memCp,maxBlkSize,sMem);
/* cm_mblk_c_001.101: added local variable */
Size blkSize; /* required block size */
- TRC2(cmGetMem)
memCp = (CmMemListCp *)memPtr;
cb = &memCp->memCb;
/* Reset the contents */
/* Initialise above allocated structure */
/* cm_mblk_c_001.101: use blkSize instead of cb->maxSize */
- cmMemset((U8 *)cb->initPtr, (U8 )0,
- (PTR)(blkSize + sizeof(CmMemList) ));
+ memset(&(cb->initPtr), 0,
+ (blkSize + sizeof(CmMemList) ));
/* The above allocated memory chunk is structured as follows
CmMemListCp *memCp; /* memory Link list control point */
CmMemCb *cb; /* Allocated Memory Control Block */
- TRC2(cmAllocEvntNoInit)
/* Validation check */
if( evntSize > maxBlkSize)
return RFAILED;
/* Reset the contents */
- cmMemset((U8 *)allocPtr, (U8 )0,
- (PTR)(sizeof(CmMemList)) );
+ memset(allocPtr, 0,
+ (sizeof(CmMemList)) );
/* The above allocated memory chunk is structured as follows
/* cm_mblk_c_001.101: added local variable */
Size blkSize; /* required block size */
- TRC2(cmGetMemNoInit)
memCp = (CmMemListCp *)memPtr;
cb = &memCp->memCb;
{
/* Requested memory is available in present chunk */
*allocPtr = (Ptr) cb->runPtr;
- //cmMemset((U8 *)*allocPtr, (U8 )0,
+ //memset(*allocPtr, (U8 )0,
// (PTR)(size) );
cb->memAllocated += size;
cb->runPtr += size;
/* Reset the contents */
/* Initialise above allocated structure */
/* cm_mblk_c_001.101: use blkSize instead of cb->maxSize */
- cmMemset((U8 *)cb->initPtr, (U8 )0,
- (PTR)(sizeof(CmMemList)));
+ memset(&(cb->initPtr), 0,
+ (sizeof(CmMemList)));
/* The above allocated memory chunk is structured as follows
+-------------------+
CmMemList *prevNode; /* Pointer to previous node */
CmMemListCp *lcp; /* Memory Link List */
- TRC2(cmFreeMem)
lcp = (CmMemListCp *)memPtr;
CmMemList *node; /* node to be added */
#endif
{
- TRC3(cmAddMemNode);
lCp->count++;
CmMemListCp *memCp; /* Memory Link List */
- TRC3(cmGetMemStatus)
memCp = (CmMemListCp *)memPtr;
CmMmBlkHdr ptrHdr;
#endif
- TRC2(cmMmRegInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
{
U16 bktIdx;
- TRC2(cmMmRegDeInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
prevptr=&prevptr1;
#endif
- TRC2(cmAlloc);
#ifndef USE_MEMCAL
UNUSED(flags);
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0xAB */
- cmMemset((U8 *)*ptr, 0xAB, *size);
+ memset(*ptr, 0xAB, *size);
#endif
// printf("Pointer allocated %8p size %d\n", *ptr, *size);
/* Store this pointer in hash list */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
*ptr = (Data*) malloc(*size);
#endif
U16 memIndex=0;
#endif
- TRC2(cmFree);
regCb = (CmMmRegCb *)regionCb;
ptrHdr->requestedSize = 0;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0xAB */
- cmMemset((U8 *)ptr, 0xAB, size);
+ memset(ptr, 0xAB, size);
#endif
/* check if the block to be freed is already having the state as FREE */
if (CMM_IS_FREE(ptrHdr->memFlags))
return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
- TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmAllocNL);
#ifndef USE_MEMCAL
UNUSED(flags);
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0xAB */
- cmMemset((U8 *)*ptr, 0xAB, *size);
+ memset(*ptr, 0xAB, *size);
#endif
if ((bkt->nextBlk) && *ptr)
#elif SS_LIGHT_MEM_LEAK_STS
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
*ptr = (Data*) malloc(*size);
#endif
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmFreeNL);
regCb = (CmMmRegCb *)regionCb;
ptrHdr->requestedSize = 0;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0XAB */
- cmMemset((U8 *)ptr, 0xAB, size);
+ memset(ptr, 0xAB, size);
#endif
/* check if the block to be freed is already having the state as FREE */
if (CMM_IS_FREE(ptrHdr->memFlags))
return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
- TRC2(cmFreeNL);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmAllocWL);
/*cm_mem_c_001.main_23 Removed support of USE_MEMCAL and MEMCAL_DEBUG support for SS_FAP*/
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
*ptr = (Data*) malloc(*size);
#endif
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmFreeWL);
regCb = (CmMmRegCb *)regionCb;
/* The memory block was allocated from the heap pool */
return (cmHeapFree (&(regCb->heapCb), ptr, size));
#else /* use pure is on */
- TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
{
CmMmRegCb *regCb;
- TRC2(cmCtl);
regCb = (CmMmRegCb *)regionCb;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmBktInit);
size = cfg->bktCfg[bktIdx].size;
#ifdef SSI_DEBUG_LEVEL1
U16 idx;
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmHeapInit);
/* Initialize the heap control block */
heapCb->vStart = memAddr;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapAlloc);
/* cm_mem_c_001.main_15 : Additions */
/* Acquire the heap lock */
/* cm_mem_c_001.main_13 : Replaced SLock with WTLock for NT */
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapFree);
/* Roundup the requested size */
size = CMM_DATALIGN(size, (heapCb->minSize));
{
U32 indx;
- TRC3(cmInitMemLeak);
gmemLkCb.isStarted = FALSE;
gmemLkCb.head = 0;
{
U32 indx;
- TRC3(cmDeinitMemLeak);
for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++)
{
U32 allocQIndx;
#endif
{
- TRC3(cmRlsAllocBlk);
if(allocQIndx < CM_MAX_ALLOC_ENTERIES)
{
CmMmBlkHdr *aBkt;
static U32 leakCount =0;
- TRC3(cmPrintLeakLog);
printf("---- START OF LEAK LOG ----");
SLock(&gmemLkCb.memLock);
MemAllocInfo *memAllocInfo;
#endif
- TRC3(cmRlsAllocBlk);
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef BIT_64
S32 traceSize;
#endif
- TRC3(cmStorAllocBlk);
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
if( memLkCb.memLkMdlInit == FALSE)
{
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(U32) * CM_MAX_STACK_TRACE));
- cmMemset((U8*)funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ memset(funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
#else
funcNm = (S8 **)calloc(1, (sizeof(U32) * CM_MAX_STACK_TRACE));
#endif
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef SS_4GMX_LCORE
allocInfo = (MemAllocInfo *)MxHeapAlloc(SsiHeap, sizeof(MemAllocInfo));
- cmMemset((U8*)allocInfo, 0, sizeof(MemAllocInfo));
+ memset(allocInfo, 0, sizeof(MemAllocInfo));
#else
allocInfo = (MemAllocInfo *)calloc(1, sizeof(MemAllocInfo));
#endif
CmMmRegCb *tmpRegCb;
FILE *fp;
- TRC3(SLogLkInfo);
fp = fopen("meLeakLog.txt", "w");
if(fp == NULL)
{
U8 idx;
Txt prntBuf[255];
S8 **funcNm;
- TRC3(SLogLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
U8 memMdl;
U8 hashIdx;
- TRC3(cmInitMemLeakMdl);
memLkCb.memLkMdlInit = FALSE;
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
U8 memMdl;
U8 hashIdx;
- TRC3(cmDeinitMemLeakMdl);
memLkCb.memLkMdlInit = FALSE;
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
S8 *msOptArg;
#endif
{
- TRC3(cmMemOpenMemLkFile);
memLkCb.fileLkLog = NULLP;
memLkCb.fileLkLog = fopen(arg, "w");
RETVOID;
U8 i;
#endif /* SS_MEM_LEAK_SOL */
- TRC3(SFlushLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
Txt *memFn[]={"SGetMsg", "SGetSBuf", "SGetDBuf", NULLP};
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC3(cmMemGetModuleId)
for(idx = 0; idx < traceSize; idx++)
{
memReqIdx = -1;
U32 tempLen;
U8 idx;
S32 retVal;
- TRC3(cmMemGetStrMtchIdx);
len = strlen((const S8 *)str);
cmpStr[0] = '(';
Dl_info info;
Sym *sym;
- TRC3(cmAddrToSymStr);
if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0)
{
#endif
{
S8 *buffer;
- TRC3(cmLeakCallBack);
Backtrace_t *bt = (Backtrace_t *)arg;
if (bt->bt_actcount >= bt->bt_maxcount)
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
buffer = (S8 *)MxHeapAlloc(SsiHeap, 510);
- cmMemset((U8*)buffer, 0, 510);
+ memset(buffer, 0, 510);
#else
buffer = (S8 *)calloc(1, 510);
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
CmMmBlkTail *tailPtr;
#endif
- TRC2(cmMmRegIsBlkSane);
for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++)
{
CmMmBlkHdr *ptrBlk;
U32 blkCnt;
- TRC2(cmMmBktSanityChk);
-
bkt->trampleCount = 0;
/* scan the entire memory list of the bucket */
#endif
{
- TRC2(cmMmHeapSanityChk);
/* increment the trample count */
heapCb->trampleCount++;
U16 *idx; /* idx to return */
#endif
{
- TRC2(cmMmHashFunc);
*idx = (U16)(key % hashListCp->numOfbins);
U16 i;
CmMmHashListEnt *hl;
- TRC2(cmMmHashListInit);
/* initialize control point fields */
hashListCp->hashList = NULLP;
Pool pool; /* memory pool to allocate bins */
#endif
{
- TRC2(cmMmHashListDeinit);
/* deallocate memory for bins */
if (hashListCp->numOfbins)
U16 idx; /* index for insertion into hash list */
U16 i;
- TRC2(cmMmHashListInsert);
/* check if hashListCp is initialised yet */
if ( hashListCp->numOfbins == 0)
#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListDeInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
CmMemEntries *entry = NULLP; /* Entry which contains the information */
- TRC2(cmHstGrmFreeInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
U32 ret = 0;
CmMemEntries *entry = NULLP;
- TRC2(cmHstGrmAllocInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
{
U32 i = 0;
- TRC2(cmHstGrmGetHashIdxAndKey);
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
{
U32 idx = 0;
- TRC2(cmHstGrmFillEntry);
entry->key = key;
entry->line = line;
entry->entId = entId;
U32 numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
- TRC2(cmHstGrmFindEntry);
-
-
for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++)
{
/* find for the entry in the bin */
Data **next;
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmStatBktInit);
size = cfg->bktCfg[bktIdx].size;
Txt errMsg[256] = {'\0'};
#endif
- TRC2(cmMmRegInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
Txt errMsg[256] = {'\0'};
#endif
- TRC2(cmMmGlobRegInit);
#ifdef SS_MEM_WL_DEBUG
if (cmInitBtInfo() == RFAILED)
CmMmDynRegCb *regCb;
Data *memPtr;
- TRC2(cmIccAllocWithLock);
regCb = (CmMmDynRegCb *)regionCb;
{
CmMmDynRegCb *regCb;
- TRC2(cmIccFreeWithLock);
regCb = (CmMmDynRegCb *)regionCb;
CmMmDynRegCb *regCb;
Data *memPtr;
- TRC2(cmIccAlloc);
regCb = (CmMmDynRegCb *)regionCb;
#endif
{
CmMmDynRegCb *regCb;
- TRC2(cmIccFree);
regCb = (CmMmDynRegCb *)regionCb;
Txt regIccStr[64] = {'\0'};
#endif
- TRC2(cmMmDynRegInit);
/* Register the region/memory with ICC and get the handler for same. The id is starting
* from region+1 as the zero is used by PHY code */
printf("\nICC Region is %d\n",regCb->region);
/* Call SRegRegion to register the memory region with SSI */
- cmMemset((U8*)®Info, 0, sizeof(regInfo));
+ memset(®Info, 0, sizeof(regInfo));
/* Register the lock region for SS_MAX_REGS - 1 region */
if((SS_MAX_REGS - 1) == regCb->region)
U16 idx1;
U16 numBkts;
- TRC2(cmMmDynRegInit);
/* Initialize the region control block */
region = regCb->region;
}
/* Call SRegRegion to register the memory region with SSI */
- cmMemset((U8*)®Info, 0, sizeof(regInfo));
+ memset(®Info, 0, sizeof(regInfo));
if((SS_MAX_REGS - 1) == regCb->region)
{
regInfo.alloc = cmDynAllocWithLock;
{
U16 bktIdx;
- TRC2(cmMmRegDeInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
{
S16 ret;
- TRC2(cmDynAlloc);
if((SLock(&dynAllocFreeLock)) != ROK)
{
{
CmMmDynRegCb *regCb;
- TRC2(cmDynAlloc);
regCb = (CmMmDynRegCb *)regionCb;
btInfo->btInfo[btIdx].ptr = (PTR)0;
btInfo->btInfo[btIdx].btSize = 0;
- cmMemset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
+ memset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
btInfo->btInfoIdx = btIdx;
}
#endif
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
/* *ptr = (Data*) malloc(*size); */
#endif
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmAlloc);
#ifndef USE_MEMCAL
UNUSED(flags);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
*ptr = (Data*) malloc(*size);
#endif
U16 offset;
CmMemDoubleFree memNode;
- TRC2(cmInitDoubleFreeList);
offset = (U16)((PTR)(&memNode.tmpListEnt) - (PTR)&memNode);
U8 tmpVal;
#endif
- TRC2(cmDynFree);
regCb = (CmMmDynRegCb *)regionCb;
#ifdef SS_MEM_WL_DEBUG
btInfo->btInfo[btIdx].ptr = (PTR)0;
btInfo->btInfo[btIdx].btSize = 0;
- cmMemset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
+ memset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
btInfo->btInfoIdx = btIdx;
}
prvAllocPtr[regCb->region] = NULLP;
}
- cmMemset(ptr, (regCb->region+1), bkt->size);
+ memset(ptr, (regCb->region+1), bkt->size);
#endif
/* Get the bucket node from the index returned and allocate the memory */
return ROK;
#else /* use pure is on */
- TRC2(cmDynFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmFree);
regCb = (CmMmRegCb *)regionCb;
return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
- TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmAllocWL);
/*cm_mem_c_001.main_23 Removed support of USE_MEMCAL and MEMCAL_DEBUG support for SS_FAP*/
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
/* *ptr = (Data*) malloc(*size); */
#endif
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmFreeWL);
regCb = (CmMmRegCb *)regionCb;
/* The memory block was allocated from the heap pool */
return (cmHeapFree (&(regCb->heapCb), ptr, size));
#else /* use pure is on */
- TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
{
CmMmRegCb *regCb;
- TRC2(cmCtl);
regCb = (CmMmRegCb *)regionCb;
#ifdef SSI_DEBUG_LEVEL1
U16 idx;
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmHeapInit);
/* Initialize the heap control block */
heapCb->vStart = memAddr;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapAlloc);
/* cm_mem_c_001.main_15 : Additions */
/* Acquire the heap lock */
/* cm_mem_c_001.main_13 : Replaced SLock with WTLock for NT */
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapFree);
/* Roundup the requested size */
size = CMM_DATALIGN(size, (heapCb->minSize));
U8 memMdl;
U8 hashIdx;
- TRC3(cmInitMemLeakMdl);
memLkCb.memLkMdlInit = FALSE;
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
U8 memMdl;
U8 hashIdx;
- TRC3(cmDeinitMemLeakMdl);
memLkCb.memLkMdlInit = FALSE;
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
S8 *msOptArg;
#endif
{
- TRC3(cmMemOpenMemLkFile);
memLkCb.fileLkLog = NULLP;
memLkCb.fileLkLog = fopen(arg, "w");
RETVOID;
U8 idx;
Txt prntBuf[255];
S8 **funcNm;
- TRC3(SLogLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
U8 i;
#endif /* SS_MEM_LEAK_SOL */
- TRC3(SFlushLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
MemAllocInfo *allocInfo;
U8 moduleId;
- TRC3(cmStorAllocBlk);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(U32) * CM_MAX_STACK_TRACE));
- cmMemset((U8*)funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ memset(funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
#else
funcNm = (S8 **)calloc(1, (sizeof(U32) * CM_MAX_STACK_TRACE));
#endif
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
allocInfo = (MemAllocInfo *)MxHeapAlloc(SsiHeap, sizeof(MemAllocInfo));
- cmMemset((U8*)allocInfo, 0, sizeof(MemAllocInfo));
+ memset(allocInfo, 0, sizeof(MemAllocInfo));
#else
allocInfo = (MemAllocInfo *)calloc(1, sizeof(MemAllocInfo));
#endif
Txt *memFn[]={"SGetMsg", "SGetSBuf", "SGetDBuf", NULLP};
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC3(cmMemGetModuleId)
for(idx = 0; idx < traceSize; idx++)
{
memReqIdx = -1;
U32 tempLen;
U8 idx;
S32 retVal;
- TRC3(cmMemGetStrMtchIdx);
len = strlen((const S8 *)str);
cmpStr[0] = '(';
S32 traceSize;
MemAllocInfo *memAllocInfo;
- TRC3(cmRlsAllocBlk);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
Dl_info info;
Sym *sym;
- TRC3(cmAddrToSymStr);
if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0)
{
#endif
{
S8 *buffer;
- TRC3(cmLeakCallBack);
Backtrace_t *bt = (Backtrace_t *)arg;
if (bt->bt_actcount >= bt->bt_maxcount)
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
buffer = (S8 *)MxHeapAlloc(SsiHeap, 510);
- cmMemset((U8*)buffer, 0, 510);
+ memset(buffer, 0, 510);
#else
buffer = (S8 *)calloc(1, 510);
#endif
S32 count;
#endif
{
- TRC3(backtrace);
Backtrace_t bt;
ucontext_t u;
CmMmBlkHdr *ptrBlk;
U32 blkCnt;
- TRC2(cmMmBktSanityChk);
bkt->trampleCount = 0;
#endif
{
- TRC2(cmMmHeapSanityChk);
/* increment the trample count */
heapCb->trampleCount++;
{
U32 sigCnt;
- TRC2(cmMmRegIsBlkSane);
for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++)
{
U16 *idx; /* idx to return */
#endif
{
- TRC2(cmMmHashFunc);
*idx = (U16)(key % hashListCp->numOfbins);
U16 i;
CmMmHashListEnt *hl;
- TRC2(cmMmHashListInit);
/* initialize control point fields */
hashListCp->hashList = NULLP;
Pool pool; /* memory pool to allocate bins */
#endif
{
- TRC2(cmMmHashListDeinit);
/* deallocate memory for bins */
if (hashListCp->numOfbins)
U16 idx; /* index for insertion into hash list */
U16 i;
- TRC2(cmMmHashListInsert);
/* check if hashListCp is initialised yet */
if ( hashListCp->numOfbins == 0)
#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListDeInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
CmMemEntries *entry = NULLP; /* Entry which contains the information */
- TRC2(cmHstGrmFreeInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
U32 ret = 0;
CmMemEntries *entry = NULLP;
- TRC2(cmHstGrmAllocInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
{
U32 i = 0;
- TRC2(cmHstGrmGetHashIdxAndKey);
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
{
U32 idx = 0;
- TRC2(cmHstGrmFillEntry);
entry->key = key;
entry->line = line;
entry->entId = entId;
U32 numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
- TRC2(cmHstGrmFindEntry);
for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++)
Region reg;
#endif
{
- TRC3(isMemThreshReached)
if(gMemoryAlarm)
{
gMemoryAlarm = !(isMemUsageBelowLowerThreshold(reg));
Buffer* pBuf;
Pst pst = {0};
- TRC2(TSInfTrigL2Stats)
SGetMsg(region, pool, &pBuf);
//#if defined(SCH_STATS) || defined(TENB_STATS)
Pool pool;
#endif
{
- TRC2(TSInfTrigStats)
//TODO
TSInfTrigL2Stats(region, pool);
{
Buffer *mBuf;
- TRC2(TSInfUtlAllocMsg)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
printf("\n MBuf Allocation failed\n");
S32 i;
U32 k;
- TRC2(TSInfUtlPackUeInfo)
CMCHKPK(oduUnpackUInt32, stats->persistent.numDeactivation, mBuf);
CMCHKPK(oduUnpackUInt32, stats->persistent.numActivation, mBuf);
{
S32 i,j;
- TRC2(TSInfUtlPackCellInfo)
CMCHKPK(oduUnpackUInt32, stats->rlc.reOdrTmrExp, mBuf);
CMCHKPK(oduUnpackUInt32, stats->rlc.maxRlcDrbRetxFail, mBuf);
S32 i;
U32 k;
- TRC2(TSInfUtlUnpkUeInfo)
CMCHKUNPK(oduPackUInt32, &stats->rnti, mBuf);
{
S32 i,j;
- TRC2(TSInfUtlUnpkCellInfo)
CMCHKUNPK(oduPackUInt32, &stats->cellId, mBuf);
{
Buffer *mBuf;
- TRC2(TSInfPkSndL2UeStats)
mBuf = TSInfUtlAllocMsg(pst);
TSInfUtlPackUeInfo(mBuf, stats);
SuId suId;
TSInfL2UeStats stats;
- TRC2(TSInfUnpkL2UeStats)
SUnpkS16(&suId, mBuf);
TSInfUtlUnpkUeInfo(mBuf, &stats);
{
Buffer *mBuf;
- TRC2(TSInfPkSndL2CellStats)
mBuf = TSInfUtlAllocMsg(pst);
TSInfUtlPackCellInfo(mBuf, stats);
SuId suId;
TSInfL2CellStats stats;
- TRC2(TSInfUnpkL2CellStats)
SUnpkS16(&suId, mBuf);
TSInfUtlUnpkCellInfo(mBuf, &stats);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknS16)
if (tknS16->pres)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknBStr32)
CMPKTKNBSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr8)
CMPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkTknStr16)
CMPKTKNSTR(tknStr, mBuf);
{
U16 ndx;
- TRC2(cmPkTknStrOSXL)
if(tknStr->pres)
{
U16 ndx;
U16 len;
- TRC2(cmPkTknStrBSXL)
if(tknStr->pres)
{
{
U8 ndx;
- TRC2(cmPkTknStrBMP4)
if(tknStr->pres)
{
{
U16 ndx;
- TRC2(cmPkTknStrBMPXL)
if(tknStr->pres)
{
{
U8 ndx;
- TRC2(cmPkTknStrUNI4)
if(tknStr->pres)
{
{
U16 ndx;
- TRC2(cmPkTknStrUNIXL)
if(tknStr->pres)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknS16)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknS16->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknBStr32)
CMUNPKTKNBSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr8)
CMUNPKTKNSTR(tknStr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkTknStr16)
CMUNPKTKNSTR(tknStr, mBuf);
{
U16 ndx;
- TRC2(cmUnpkTknStrOSXL)
-
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if(tknStr->pres)
U16 ndx;
U16 len;
- TRC2(cmUnpkTknStrBSXL)
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
U8 ndx;
- TRC2(cmUnpkTknStrBMP4)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
U16 ndx;
- TRC2(cmUnpkTknStrBMPXL)
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
U8 ndx;
- TRC2(cmUnpkTknStrUNI4)
/* Token Header */
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
{
U16 ndx;
- TRC2(cmUnpkTknStrUNIXL)
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmPkCmIpv4TptAddr)
CMCHKPK(cmPkCmIpv4NetAddr, pkParam->address, mBuf);
CMCHKPK(oduUnpackUInt16, pkParam->port, mBuf);
U8 num;
U8 *ptr = (U8*)pkParam;
- TRC3(cmPkCmIpv6NetAddr)
for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmIpv6TptAddr)
CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->ipv6NetAddr, mBuf);
CMCHKPK(oduUnpackUInt16, pkParam->port, mBuf);
U16 idx; /* Loop Index */
CmNetAddr *netAddr; /* Network Address */
- TRC2(cmPkCmNetAddrTbl)
if (pkParam->count > CM_MAX_NET_ADDR)
return RFAILED;
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmNetAddr)
switch (pkParam->type)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmTptAddr)
switch (pkParam->type)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmTptLocalInf)
if (pkParam->intfPrsnt == TRUE)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmNetMCastInf6)
CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->mCastAddr, mBuf);
CMCHKPK(oduUnpackUInt32, pkParam->localInf, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmSockOpts)
switch (pkParam->option)
{
{
U32 num;
- TRC3(cmPkCmSockParam)
if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
{
{
U32 num;
- TRC3(cmPkTlsTptParam)
if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmTptParam)
switch (pkParam->type)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC2(cmUnpkCmIpv4TptAddr)
CMCHKUNPK(oduPackUInt16, &unpkParam->port, mBuf);
CMCHKUNPK(cmUnpkCmIpv4NetAddr, &unpkParam->address, mBuf);
U32 num;
U8 *ptr = (U8*)unpkParam;
- TRC3(cmUnpkCmIpv6NetAddr)
ptr += (CM_INET_IPV6ADDR_SIZE - 1);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmUnpkCmIpv6TptAddr)
CMCHKUNPK(oduPackUInt16, &unpkParam->port, mBuf);
CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->ipv6NetAddr, mBuf);
U16 idx; /* Loop Index */
CmNetAddr *netAddr; /* Network Address */
- TRC2(cmUnpkCmNetAddrTbl)
/* Unpack the count */
CMCHKUNPK(oduPackUInt16, &(unpkParam->count), mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmUnpkCmNetAddr)
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmUnpkCmTptAddr)
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmUnpkCmNetMCastInf6)
CMCHKUNPK(oduPackUInt32, &unpkParam->localInf, mBuf);
CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->mCastAddr, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmUnpkCmSockOpts)
CMCHKUNPK(oduPackUInt32, &unpkParam->level, mBuf);
CMCHKUNPK(oduPackUInt32, &unpkParam->option, mBuf);
{
U32 num;
- TRC3(cmUnpkCmSockParam)
CMCHKUNPK(oduPackUInt8, &unpkParam->listenQSize, mBuf);
CMCHKUNPK(oduPackUInt8, &unpkParam->numOpts, mBuf);
{
U32 num;
- TRC3(cmUnpkTlsTptParam)
CMCHKUNPK(SUnpkS16, &unpkParam->ctxId, mBuf);
CMCHKUNPK(oduPackUInt8, &unpkParam->listenQSize, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmUnpkCmTptParam)
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmIpHdrParm)
switch (pkParam->type)
{
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmUnpkCmTptLocalInf)
/* first unpack the bool intfPrsnt value which is always packed */
CMCHKUNPK(oduUnpackBool, &unpkParam->intfPrsnt, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(cmPkCmIpv6ExtHdr)
/* pack first Route hdr */
if (pkParam->rtOptsPrsnt)
{
U8 idx;
- TRC3(cmPkCmIpv6RtHdr);
/* pack all IPV6 addrs in the route hdr */
for(idx = 0; idx < pkParam->numAddrs; idx++)
U8 idx; /* array index */
S32 retVal; /* temporary return value */
- TRC3(cmUnpkCmIpv6RtHdr);
CMCHKUNPK(oduPackUInt8, &unpkParam->numAddrs, mBuf);
Mem *memInfo; /* meminfo to allocate for IPV6 ext hdr */
#endif
{
- TRC3(cmUnpkCmIpv6ExtHdr)
/* unpack HBH hdr first */
CMCHKUNPK(oduUnpackBool, &unpkParam->hbhHdrPrsnt, mBuf);
U8 numOptions;
- TRC3(cmPkCmIpv6DestOptsArr);
/* pack all HBH options */
for(numOptions = 0; numOptions<pkParam->numDestOpts; numOptions++)
{
U8 optLen;
- TRC3(cmPkCmIpv6DestOptsHdr);
for(optLen = 0; optLen < pkParam->length; optLen++)
{
S32 retVal; /* temporary return value */
U8 optLen; /* length of value field */
- TRC3(cmUnpkCmIpv6DestOptsHdr);
/* unpack type, length */
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
U8 numOptions;
S16 retVal;
- TRC3(cmUnpkCmIpv6DestOptsArr);
CMCHKUNPK(oduPackUInt8, &unpkParam->numDestOpts, mBuf);
if (unpkParam->numDestOpts)
{
U8 numOptions;
- TRC3(cmPkCmIpv6HBHHdrArr);
for(numOptions = 0; numOptions<pkParam->numHBHOpts; numOptions++)
CMCHKPK(cmPkCmIpv6HBHHdr, &pkParam->hbhOpts[numOptions], mBuf);
{
U8 optLen;
- TRC3(cmPkCmIpv6HBHHdr);
/* pack value field */
for(optLen = 0; optLen<pkParam->length; optLen++)
S32 retVal; /* temporary return value */
U8 optLen; /* length of value field */
- TRC3(cmUnpkCmIpv6HBHHdr)
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
CMCHKUNPK(oduPackUInt8, &unpkParam->length, mBuf);
U8 numOptions;
S16 retVal;
- TRC3(cmUnpkCmIpv6HBHHdrArr);
CMCHKUNPK(oduPackUInt8, &unpkParam->numHBHOpts, mBuf);
if (unpkParam->numHBHOpts)
#endif /* IPV6_OPTS_SUPPORTED */
#endif
{
- TRC3(cmUnpkCmIpHdrParm)
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
/* Variable declaration */
S16 idx;
- TRC3(cmPkCmIcmpFilter)
switch (pkParam->type)
{
/* Variable declaration */
S16 idx;
- TRC3(cmUnpkCmIcmpFilter)
-
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
switch (unpkParam->type)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCrgBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
SpId spId;
- TRC3(cmUnpkCrgBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCrgBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
U8 status;
- TRC3(cmUnpkCrgBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCrgUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
Reason reason;
- TRC3(cmUnpkCrgUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCrgCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
CrgCfgTransId transId;
CrgCfgReqInfo *cfgReqInfo;
- TRC3(cmUnpkCrgCfgReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCrgCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
CrgCfgTransId transId;
U8 status;
- TRC3(cmUnpkCrgCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
{
S32 i;
- TRC3(cmPkCrgCfgTransId)
for (i=CRG_CFG_TRANSID_SIZE-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
{
S32 i;
- TRC3(cmUnpkCrgCfgTransId)
for (i=0; i<CRG_CFG_TRANSID_SIZE; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
#endif
{
- TRC3(cmPkCrgBwCfg)
CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
#endif
{
- TRC3(cmUnpkCrgBwCfg)
CMCHKUNPK(oduPackUInt8, ¶m->dlTotalBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulTotalBw, mBuf);
#endif
{
- TRC3(cmPkCrgRachCfg)
CMCHKPK(oduUnpackUInt8, param->maxMsg3Tx, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkCrgRachCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxMsg3Tx, mBuf);
return ROK;
#endif
{
- TRC3(cmPkCrgCellCfg)
#ifdef EMTC_ENABLE
CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
#endif
{
- TRC3(cmUnpkCrgCellCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkCrgRachCfg, ¶m->rachCfg, mBuf);
#endif
{
- TRC3(cmPkCrgUeUlHqCfg)
CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkCrgUeUlHqCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxUlHqTx, mBuf);
return ROK;
#endif
{
- TRC3(cmPkCrgUeCfg)
#ifdef TENB_MULT_CELL_SUPPRT
CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkCrgUeCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkCrgDlLchCfg)
CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkCrgDlLchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->dlTrchType, mBuf);
return ROK;
#endif
{
- TRC3(cmPkCrgUlLchCfg)
CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
#endif
{
- TRC3(cmUnpkCrgUlLchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->ulTrchType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
#endif
{
- TRC3(cmPkCrgLchCfg)
/* crg_c_001.main_5 - ADD - Added the packing for LTE_L2_MEAS. */
#ifdef LTE_L2_MEAS
CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
#endif
{
- TRC3(cmUnpkCrgLchCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkCrgCfg)
switch(param->cfgType) {
case CRG_LCH_CFG:
#endif
{
- TRC3(cmUnpkCrgCfg)
CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
#endif
{
- TRC3(cmPkCrgCellRecfg)
CMCHKPK(cmPkCrgRachCfg, ¶m->rachRecfg, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#endif
{
- TRC3(cmUnpkCrgCellRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkCrgRachCfg, ¶m->rachRecfg, mBuf);
#endif
{
- TRC3(cmPkCrgUeRecfg)
#ifdef LTE_ADV
if(TRUE == param->crgSCellCfg.isSCellCfgPres)
{
#endif
{
- TRC3(cmUnpkCrgUeRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->oldCrnti, mBuf);
#endif
{
- TRC3(cmPkCrgLchRecfg)
CMCHKPK(oduUnpackUInt8, param->ulRecfg.lcgId, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
#endif
{
- TRC3(cmUnpkCrgLchRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkCrgRecfg)
switch(param->recfgType) {
case CRG_LCH_CFG:
#endif
{
- TRC3(cmUnpkCrgRecfg)
CMCHKUNPK(oduPackUInt8, ¶m->recfgType, mBuf);
switch(param->recfgType) {
#endif
{
- TRC3(cmPkCrgDel)
switch(param->delType) {
case CRG_LCH_CFG:
#endif
{
- TRC3(cmUnpkCrgDel)
CMCHKUNPK(oduPackUInt8, ¶m->delType, mBuf);
switch(param->delType) {
#endif
{
- TRC3(cmPkCrgRst)
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#endif
{
- TRC3(cmUnpkCrgRst)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkCrgCfgReqInfo)
switch(param->action) {
case CRG_RESET:
#endif
{
- TRC3(cmUnpkCrgCfgReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
switch(param->action) {
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId = 0;
SpId spId = 0;
- TRC3(cmUnpkCtfBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId = 0;
U8 status;
- TRC3(cmUnpkCtfBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId = 0;
Reason reason = 0;
- TRC3(cmUnpkCtfUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
S16 idx;
- TRC3(cmPkCtfNhKeyInfo)
for(idx=31;idx>=0;idx--)
{
S16 idx;
- TRC3(cmPkCtfKenbStarInfo)
for(idx=31;idx>=0;idx--)
{
S16 idx;
- TRC3(cmPkCtfAskeyInfo)
for(idx=31;idx>=0;idx--)
#endif
{
- TRC3(cmPkCtfKdfReqInfo)
switch (param->keyDerType)
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfKdfReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
S32 i;
- TRC3(cmPkCtfCnmVendorSpecificInfo);
if(param->numOfVendorSpecifcParam <= CTF_CNM_MAX_VENDOR_PARAMS)
{
for(i= param->numOfVendorSpecifcParam-1; i >= 0; i--)
#endif
{
- TRC3(cmPkCtfCtfCnmCellSyncReq);
CMCHKPK(oduUnpackUInt16, param->nbrEarfcn, mBuf);
CMCHKPK(oduUnpackUInt16, param->nbrPCellId, mBuf);
CMCHKPK(oduUnpackUInt8, param->nbrTxAntCount, mBuf);
#endif
{
S32 i;
- TRC3(cmPkCtfcfgReqInfo);
CMCHKPK(oduUnpackUInt8, param->searchType, mBuf);
CMCHKPK(oduUnpackUInt8, param->mibRequest, mBuf);
#endif
{
S32 i;
- TRC3(cmUnpkCtfCnmVendorSpecificInfo);
CMCHKUNPK(oduPackUInt16, ¶m->numOfVendorSpecifcParam, mBuf);
for(i=0; (i<param->numOfVendorSpecifcParam)&&(i < CTF_CNM_MAX_VENDOR_PARAMS); i++)
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCtfCnmCellSyncReq);
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
#endif
{
S32 i;
- TRC3(cmUnpkCtfsyncReqInfo);
CMCHKUNPK(oduPackUInt16, ¶m->numOfPciList, mBuf);
for(i=0; (i < param->numOfPciList)&&(i < CTF_CNM_MAX_CELL_SEARCH); i++)
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmCellSyncReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmCellSyncReq *SyncReqMsg = NULLP;
- TRC3(cmUnpkCtfCnmCellSyncReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmInitSyncReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmInitSyncReq *syncReqInfo = NULLP;
- TRC3(cmUnpkCtfCnmInitSyncReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfctfCnmMibInfo)
CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
CMCHKPK(oduUnpackUInt8, param->numTxAntennas, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfctfCnmInitSyncInfo)
CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
CMCHKPK(oduUnpackUInt8, param->rsrp, mBuf);
#endif
{
S32 i;
- TRC3(cmPkCtfcfgRspInfo)
CMCHKPK(oduUnpackUInt8, param->status, mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmInitSyncRsp)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfctfCnmMibInfo);
CMCHKUNPK(oduPackUInt8, ¶m->dlSystemBandWidht, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkctfCnmInitSyncInfo);
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
CMCHKUNPK(cmUnpkCtfctfCnmMibInfo, ¶m->ctfCnmMibInfo, mBuf);
#endif
{
S32 i;
- TRC3(cmUnpkCtfCnmInitSyncRspMsg);
CMCHKUNPK(oduPackUInt8, ¶m->numOfNeighbourInfo, mBuf);
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmInitSyncRsp *syncRspInfo = NULLP;
- TRC3(cmUnpkCtfCnmInitSyncRsp)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
- TRC3(cmPkCtfCellSyncRsp)
CMCHKPK(oduUnpackUInt8, param->status, mBuf);
return ROK;
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmCellSyncRsp)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
- TRC3(cmUnpkCtfCnmSyncRspMsg);
CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
return ROK;
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmCellSyncRsp *syncRspMsg = NULLP;
- TRC3(cmUnpkCtfCnmCellSyncRsp)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
- TRC3(cmPkCtfcfgIndInfo);
CMCHKPK(oduUnpackUInt8, param->status, mBuf);
CMCHKPK(cmPkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmCellSyncInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
- TRC3(cmUnpkCtfCnmSyncIndMsg);
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmCellSyncInd *syncIndMsg = NULLP;
- TRC3(cmUnpkCtfCnmInitSyncRsp)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
U8 idx;
- TRC3(cmUnpkCtfNhKeyInfo)
CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->physCellId, mBuf);
U8 idx;
- TRC3(cmUnpkCtfKenbStarInfo)
CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->physCellId, mBuf);
U8 idx;
- TRC3(cmUnpkCtfAskeyInfo)
CMCHKUNPK(oduPackUInt8, ¶m->intgAlgoType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ciphAlgoType, mBuf);
#endif
{
- TRC3(cmUnpkCtfKdfReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->keyDerType, mBuf);
switch (param->keyDerType)
CtfCfgTransId transId;
CtfKdfReqInfo *kdfReqInfo = NULLP;
- TRC3(cmUnpkCtfKdfReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
CtfCfgTransId transId;
CtfCfgReqInfo *cfgReqInfo = NULLP;
- TRC3(cmUnpkCtfCfgReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
S16 idx;
- TRC3(cmPkCtfNhKeyCfmInfo)
for(idx=31;idx>=0;idx--)
{
S16 idx;
- TRC3(cmPkCtfKenbStarCfmInfo)
for(idx=31;idx>=0;idx--)
{
S16 idx;
- TRC3(cmPkCtfCtfAskeyCfmInfo)
for(idx=15;idx>=0;idx--)
{
#endif
{
- TRC3(cmPkCtfKdfCfmInfo)
switch (param->keyDerType)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfKdfCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfEnbStopInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
U8 idx;
- TRC3(cmUnpkCtfNhKeyCfmInfo)
for(idx=0;idx<32;idx++)
{
U8 idx;
- TRC3(cmUnpkCtfKenbStarCfmInfo)
for(idx=0;idx<32;idx++)
{
U8 idx;
- TRC3(cmUnpkCtfCtfAskeyCfmInfo)
for(idx=0;idx<16;idx++)
{
#endif
{
- TRC3(cmUnpkCtfKdfCfmInfo)
CMCHKUNPK(oduPackUInt8, ¶m->keyDerType, mBuf);
switch (param->keyDerType)
U8 status;
CtfKdfCfmInfo kdfCfmInfo;
- TRC3(cmUnpkCtfKdfCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
CtfCfgTransId transId;
U8 status;
- TRC3(cmUnpkCtfCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
SuId suId = 0;
CtfCfgTransId transId;
- TRC3(cmUnpkCtfCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfUeIdChgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
CtfUeInfo *ueInfo = NULLP;
CtfUeInfo *newUeInfo = NULLP;
- TRC3(cmUnpkCtfUeIdChgReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfUeIdChgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
CtfUeInfo *ueInfo = NULLP;
CmStatus status;
- TRC3(cmUnpkCtfUeIdChgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
{
S32 i;
- TRC3(cmPkCtfCfgTransId)
for (i=CTF_CFG_TRANSID_SIZE-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
{
S32 i;
- TRC3(cmUnpkCtfCfgTransId)
for (i=0; i<CTF_CFG_TRANSID_SIZE; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
#endif
{
- TRC3(cmPkCtfUeInfo)
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#endif
{
- TRC3(cmUnpkCtfUeInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
#endif
{
- TRC3(cmPkCtfBwCfgInfo)
CMCHKPK(oduUnpackUInt8, param->eUtraBand, mBuf);
CMCHKPK(oduUnpackUInt32, param->ulBw, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkCtfBwCfgInfo)
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkCtfTxSchemeCfg)
CMCHKPK(oduUnpackUInt32, param->cycPfx, mBuf);
CMCHKPK(oduUnpackUInt32, param->scSpacing, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkCtfTxSchemeCfg)
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkCtfAntennaCfgInfo)
CMCHKPK(oduUnpackUInt32, param->antPortsCnt, mBuf);
return ROK;
{
U32 tmpEnum;
- TRC3(cmUnpkCtfAntennaCfgInfo)
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->antPortsCnt = (CtfAntennaPortsCount)tmpEnum;
return ROK;
#endif
{
- TRC3(cmPkCtfPrachCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfPrachCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfPdschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
#endif
{
- TRC3(cmUnpkCtfPdschCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfPuschCfgBasic)
CMCHKPK(oduUnpackUInt8, param->enable64QAM, mBuf);
CMCHKPK(oduUnpackUInt8, param->hoppingOffset, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkCtfPuschCfgBasic)
CMCHKUNPK(oduPackUInt8, ¶m->noOfsubBands, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkCtfPuschUlRS)
CMCHKPK(oduUnpackUInt8, param->cycShift, mBuf);
CMCHKPK(oduUnpackUInt8, param->grpNum, mBuf);
#endif
{
- TRC3(cmUnpkCtfPuschUlRS)
CMCHKUNPK(oduPackUInt8, ¶m->grpHopEnabled, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->seqHopEnabled, mBuf);
#endif
{
- TRC3(cmPkCtfPuschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfPuschCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfPhichCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
U32 tmpEnum;
- TRC3(cmUnpkCtfPhichCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfPucchCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
U32 tmpEnum;
- TRC3(cmUnpkCtfPucchCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfSrsUlCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfSrsUlCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfTddSfCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmPkCtfVendorSpecParams)
if( param->buffLen != 0) {
SAddPreMsgMultInOrder(param->paramBuffer,param->buffLen,mBuf);
}
#endif
{
- TRC3(cmUnpkCtfVendorSpecParams)
CMCHKUNPK(oduPackUInt16, ¶m->buffLen, mBuf);
#endif
{
- TRC3(cmUnpkCtfTddSfCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
{
U8 idx;
- TRC3(cmPkCtfUnLicnsdCellParam)
CMCHKPK(SPkS32, param->txPowerLimit, mBuf);
CMCHKPK(oduUnpackUInt8, param->coExistMethod, mBuf);
#ifdef EMTC_ENABLE
S32 i;
#endif
- TRC3(cmPkCtfCellCfgInfo)
#ifdef EMTC_ENABLE
for (i = CTF_MAX_CE_LEVEL-1; i >= 0; i--) {
{
U8 idx;
- TRC3(cmPkCtfUnLicnsdCellParam)
CMCHKUNPK(oduPackUInt8, ¶m->numFreq, mBuf);
#ifdef EMTC_ENABLE
S32 i;
#endif
- TRC3(cmUnpkCtfCellCfgInfo)
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
#endif
{
- TRC3(cmPkCtfCellRecfgInfo)
#ifdef ENABLE_API_LOG
CMCHKPK(oduUnpackUInt8, param->enableAPILog, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkCtfCellRecfgInfo)
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkCtfDedPdschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
U32 tmpEnum;
- TRC3(cmUnpkCtfDedPdschCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfDedPucchCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfDedPucchCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfDedPuschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfDedPuschCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfCqiRptModePeriodic)
/* ctf_c_001.main_2: added packning for cqiMask*/
#ifdef CTF_VER1
CMCHKPK(oduUnpackUInt32, (U32 )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
#ifdef CTF_VER1
U32 tmpEnum;
#endif
- TRC3(cmUnpkCtfCqiRptModePeriodic)
CMCHKUNPK(oduPackUInt8, ¶m->cqiPeriodicCfgType, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
#endif
{
- TRC3(cmPkCtfCqiReportCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#if defined (CTF_VER1) || defined (CTF_VER2)
U32 tmpEnum;
#endif
- TRC3(cmUnpkCtfCqiReportCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfDedSrsUlCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfDedSrsUlCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfDedSRCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfDedSRCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
U8 idx;
#endif /* CTF_VER2 */
- TRC3(cmPkCtfDedAntCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
U32 tmpEnum;
- TRC3(cmUnpkCtfDedAntCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfUeCatCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
#endif
{
- TRC3(cmUnpkCtfUeCatCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmPkCtfDedCfgInfo)
#ifdef EMTC_ENABLE
CMCHKPK(oduUnpackUInt8, param->isEmtcUe, mBuf);
#endif
#endif
{
- TRC3(cmUnpkCtfDedCfgInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
#endif
{
- TRC3(cmPkCtfDedRecfgInfo)
CMCHKPK(cmPkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
/*ctf_c_001.main_1*/
#endif
{
- TRC3(cmUnpkCtfDedRecfgInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
#endif
{
- TRC3(cmPkCtfCellReleaseInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkCtfCellReleaseInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
return ROK;
#endif
{
- TRC3(cmPkCtfDedReleaseInfo)
CMCHKPK(cmPkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#endif
{
- TRC3(cmUnpkCtfDedReleaseInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
#endif
{
- TRC3(cmPkCtfCfgInfo)
switch(param->cfgElem) {
case CTF_UE_CFG:
#endif
{
- TRC3(cmUnpkCtfCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
#endif
{
- TRC3(cmPkCtfReCfgInfo)
switch(param->cfgElem) {
case CTF_UE_CFG:
#endif
{
- TRC3(cmUnpkCtfReCfgInfo)
CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
#endif
{
- TRC3(cmPkCtfReleaseInfo)
switch(param->cfgElem) {
case CTF_UE_CFG:
#endif
{
- TRC3(cmUnpkCtfReleaseInfo)
CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
#endif
{
- TRC3(cmPkCtfCfgReqInfo)
/* ctf_c_001.main_4: Added support for vendor specific parameters */
#ifdef CTF_VER3
S16 retVal;
#endif
- TRC3(cmUnpkCtfCfgReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
#endif
{
- TRC3(cmPkCtfCellPwrcfgInfo)
/* Added the pack for newly added reference signal Power*/
CMCHKPK(oduUnpackUInt32, (U32)param->ctfCellStatus, mBuf);
#endif
{
- TRC3(cmUnpkCtfCellPwrcfgInfo)
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
#endif
{
- TRC3(cmPkCtfCellStop)
/* Added the pack for newly added reference signal Power*/
CMCHKPK(oduUnpackUInt32, (U32)param->ctfCellStatus, mBuf);
#endif
{
- TRC3(cmUnpkCtfCellStop)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkPerRemScanCellInfo)
CMCHKPK(oduUnpackUInt16,param->pci, mBuf);
CMCHKPK(oduUnpackUInt8, param->rsrp, mBuf);
#endif
{
S16 idx;
- TRC3(cmPkCtfPeriodicCellSearchRsp)
for(idx = param->numCells - 1; idx >=0; idx--)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfPeriodicRemCellSearchRsp)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfPerRemScanCellInfo);
CMCHKUNPK(oduPackUInt8, ¶m->numTx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->dlBw, mBuf);
#endif
{
S16 idx;
- TRC3(cmUnpkCtfPerRemCellSrch);
CMCHKUNPK(oduPackUInt8, ¶m->numCells, mBuf);
for(idx = 0; idx < (param->numCells); idx++)
SuId suId = 0;
CtfCfgTransId transId;
CtfPeriodicRemCellSearchRsp *CellSrchRsp = NULLP;
- TRC3(cmUnpkPerRemCellSrchRsp)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
**********************************************************************/
/*
- trace macros are at the beginning of each function. they may
- be used for debugging purposes. the trace macros are turned on
- by the following command line option:
-
- TRACE0 - trace mos support functions
- TRACE1 - trace mos interface functions
- TRACE2 - trace layer support functions
- TRACE3 - trace layer interface functions
- TRACE4 - trace interrupt service functions
there is one additional trace macro which turns on trace macros 0 - 4
and pushes the text within trace macros 0 - 4 onto a stack. the text
*/
#ifdef TRACE5 /* trace 5 - call stack */
-#define TRACE0 /* trace 0 - mos support functions */
-#define TRACE1 /* trace 1 - mos interface functions */
-#define TRACE2 /* trace 2 - layer support functions */
-#define TRACE3 /* trace 3 - layer interface functions */
-#define TRACE4 /* trace 4 - interrupt service functions */
#define T5M 64 /* trace 5 - maximum call stack height */
extern S8 *t5s[]; /* trace 5 - call stack */
#endif
#endif
-#ifdef TRACE5 /* trace 5 - call stack */
-#ifdef ERRCHK
-#define TRC0(a) if(t5t>=0&&t5t<T5M-1) t5s[t5t++] = #a; else exit(0);
-#else
-#define TRC0(a) t5s[t5t++] = #a;
-#endif
-#else
-#ifdef TRACE0 /* trace 0 - mos support functions */
-#ifdef ANSI /* ansi */
-#define TRC0(a) printf(#a "\n");
-#else /* not ansi */
-#define TRC0(a);
-#endif
-#else
-#define TRC0(a);
-#endif
-#endif
-
-#ifdef TRACE5 /* trace 5 - call stack */
-#ifdef ERRCHK
-#define TRC1(a) if(t5t>=0&&t5t<T5M-1) t5s[t5t++] = #a; else exit(0);
-#else
-#define TRC1(a) t5s[t5t++] = #a;
-#endif
-#else
-#ifdef TRACE1 /* trace 1 - mos interface functions */
-#ifdef ANSI /* ansi */
-#define TRC1(a) printf(#a "\n");
-#else /* not ansi */
-#define TRC1(a) ;
-#endif
-#else
-#define TRC1(a);
-#endif
-#endif
-
-#ifdef TRACE5 /* trace 5 - call stack */
-#ifdef ERRCHK
-#define TRC2(a) if(t5t>=0&&t5t<T5M-1) t5s[t5t++] = #a; else exit(0);
-#else
-#define TRC2(a) t5s[t5t++] = #a;
-#endif
-#else
-#ifdef TRACE2 /* trace 2 - layer support functions */
-#ifdef ANSI /* ansi */
-/* envdep_h_001.main_68 Corrected the macro */
-#define TRC2(a) printf(#a "\n");
-#else /* not ansi */
-#define TRC2(a) ;
-#endif
-#else
-#define TRC2(a);
-#endif
-#endif
-
-#ifdef TRACE5 /* trace 5 - call stack */
-#ifdef ERRCHK
-#define TRC3(a) if(t5t>=0&&t5t<T5M-1) t5s[t5t++] = #a; else exit(0);
-#else
-#define TRC3(a) t5s[t5t++] = #a;
-#endif
-#else
-#ifdef TRACE3 /* trace 3 - layer interface functions */
-#ifdef ANSI /* ansi */
-/* envdep_h_001.main_68 Corrected the macro */
-#define TRC3(a) printf(#a "\n");
-#else /* not ansi */
-#define TRC3(a) ;
-#endif
-#else
-#define TRC3(a);
-#endif
-#endif
-
-#ifdef TRACE5 /* trace 5 - call stack */
-#ifdef ERRCHK
-#define TRC4(a) if(t5t>=0&&t5t<T5M-1) t5s[t5t++] = #a; else exit(0);
-#else
-#define TRC4(a) t5s[t5t++] = #a;
-#endif
-#else
-#ifdef TRACE4 /* trace 4 - interrupt service functions */
-#ifdef ANSI /* ansi */
-#define TRC4(a) printf(#a "\n");
-#else /* not ansi */
-#define TRC4(a);
-#endif
-#else
-#define TRC4(a);
-#endif
-#endif
-
\f
/**********************************************************************
returns
&(_class).cBuf.cBufPtr,size); \
(_class).cBuf.cBufSize = size; \
(_class).cBuf.cBufIdx = 0; \
- cmMemset((U8 *)(_class).cBuf.cBufPtr,'|',size); \
+ memset((_class).cBuf.cBufPtr,'|',size); \
}
#define CBUF_WRITE(_class,_argList) \
U32 tmpIdx=0; \
SGetSBuf((_class).region,(_class).pool, \
(U8 **)&tmpBuf,(_class).cBuf.cBufSize); \
- cmMemset((U8 *)tmpBuf,0,(_class).cBuf.cBufSize); \
+ memset(tmpBuf,0,(_class).cBuf.cBufSize); \
for(cBufIdx = (_class).cBuf.cBufIdx; cBufIdx < (_class).cBuf.cBufSize; cBufIdx++) \
{ \
tmpBuf[tmpIdx++] = (_class).cBuf.cBufPtr[cBufIdx]; \
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuBndReq)
mBuf = NULLP;
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuBndCfm)
mBuf = NULLP;
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuUbndReq)
mBuf = NULLP;
#endif
{
- TRC3(cmPkKwuDatReqInfo);
#ifdef CCPU_OPT
switch(param->lcType) {
#ifndef SS_RBUF
KwuDatReqInfo* datReqInfo;
#endif
- TRC3(cmPkKwuDatReq)
#ifndef SS_RBUF
switch(pst->selector)
{
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
+ memcpy(datReqInfo,datReq,sizeof(KwuDatReqInfo));
CMCHKPK(oduPackPointer,(PTR)datReqInfo, mBuf);
}
else
Buffer *mBuf;
#endif
{
- TRC3(cmPkKwuDatIndInfo);
CMCHKPK(oduUnpackUInt8, param->isOutOfSeq, mBuf);
#ifdef CCPU_OPT
#endif
KwuDatIndInfo *datIndInfo = NULLP;
- TRC3(cmPkKwuDatInd)
#ifdef TENB_SPLIT_ARCH
/* SSI_CHANGES: */
return (ret1);
}
- cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
+ memcpy(datIndInfo, datInd,sizeof(KwuDatIndInfo));
CMCHKPK(oduPackPointer,(PTR)datIndInfo, mBuf);
}
break;
{
register U32 iter;
- TRC3(cmPkKwuDatCfmInfo);
for(iter = 0; iter < param->numSduIds; iter++)
{
CMCHKPK(oduUnpackUInt32, param->sduIds[iter], mBuf);
#endif
Buffer *mBuf;
- TRC3(cmPkKwuDatCfm)
mBuf = NULLP;
Buffer *mBuf;
KwuDiscSduInfo* discSduInfo = NULLP;
- TRC3(cmPkKwuDiscSduReq)
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return (ret1);
}
- cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
+ memcpy(discSduInfo, discSdu,sizeof(KwuDiscSduInfo));
CMCHKPK(oduPackPointer,(PTR)discSduInfo, mBuf);
}
break;
{
S16 i;
- TRC3(cmPkKwuStaIndInfo);
for (i = (param->numSdu - 1); i >= 0; i--)
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkKwuFlowCntrlIndInfo);
CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwuFlowCntrlIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
#endif /* LCKWU */
Buffer *mBuf;
- TRC3(cmPkKwuStaInd)
mBuf = NULLP;
#endif /* LCKWU */
Buffer *mBuf;
- TRC3(cmPkKwuReEstCmpInd)
mBuf = NULLP;
#endif
Buffer *mBuf;
- TRC3(cmPkKwuDiscSduCfm)
mBuf = NULLP;
{
Buffer *mBuf;
- TRC3(cmPkKwuFlowCntrlInd)
mBuf = NULLP;
Buffer *mBuf;
#endif
{
- TRC3(cmPkKwuDatAckIndInfo);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
Buffer *mBuf;
- TRC3(cmPkKwuDatAckInd);
mBuf = NULLP;
SuId suId = 0;
SpId spId = 0;
- TRC3(cmUnpkKwuBndReq)
-
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU020, pst);
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
SPutMsg(mBuf);
SuId suId = 0;
U8 status = 0;
- TRC3(cmUnpkKwuBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EKWU023, pst);
SpId spId = 0;
Reason reason = 0;
- TRC3(cmUnpkKwuUbndReq)
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
#endif
{
- TRC3(cmUnpkKwuDatReqInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
KwuDatReqInfo *datReq = NULLP;
KwuDatReqInfo datReqTmp;
- TRC3(cmUnpkKwuDatReq)
switch(pst->selector)
{
/* Allocate the memory statically as there is no free
* in RLC */
datReq = &datReqTmp;
- cmMemset((U8 *)datReq, 0, sizeof(KwuDatReqInfo));
+ memset(datReq, 0, sizeof(KwuDatReqInfo));
#if(ERRCLASS & ERRCLS_DEBUG)
ret1 = cmUnpkKwuDatReqInfo( (datReq), mBuf);
if(ret1 != ROK)
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwuDatIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
KwuDatIndInfo *datInd = NULLP;
KwuDatIndInfo datIndTmp;
- TRC3(cmUnpkKwuDatInd)
switch(pst->selector)
{
#endif
{
register S32 iter;
- TRC3(cmUnpkKwuDatCfmInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numSduIds, mBuf);
SuId suId = 0;
KwuDatCfmInfo *datCfm = NULLP;
- TRC3(cmUnpkKwuDatCfm)
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
return (ret1);
}
- cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
+ memset(datCfm, 0, sizeof(KwuDatCfmInfo));
ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
return (ret1);
}
- cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
+ memset(discSdu, 0, sizeof(KwuDiscSduInfo));
ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
{
U32 i;
- TRC3(cmUnpkKwuStaIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numSdu, mBuf);
SuId suId = 0;
KwuStaIndInfo *staInd = NULLP;
- TRC3(cmUnpkKwuStaInd)
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
return (ret1);
}
- cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
+ memset(staInd, 0, sizeof(KwuStaIndInfo));
ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
SuId suId = 0;
CmLteRlcId rlcId;
- TRC3(cmUnpkKwuReEstCmpInd)
- cmMemset((U8 *)&rlcId, 0, sizeof(CmLteRlcId));
+ memset(&rlcId, 0, sizeof(CmLteRlcId));
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
switch(pst->selector)
SpId spId = 0;
KwuDiscSduInfo *discSdu = NULLP;
- TRC3(cmUnpkKwuDiscSduCfm);
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
+ memset(discSdu, 0, sizeof(KwuDiscSduInfo));
ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
SuId suId;
KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP;
- TRC3(cmUnpkKwuFlowCntrlInd);
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
switch(pst->selector)
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwuDatAckInfo);
CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
SuId suId = 0;
KwuDatAckInfo *datInd = NULLP;
- TRC3(cmUnpkKwuDatAckInd);
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
return (ret1);
}
- cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
+ memset(datInd, 0, sizeof(KwuDatAckInfo));
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf);
{
EgtpConfig egtpCfg;
- memset((uint8_t *)&egtpCfg, 0, sizeof(EgtpConfig));
+ memset(&egtpCfg, 0, sizeof(EgtpConfig));
oduPackUInt32(&(egtpCfg.maxTunnelId), mBuf);
oduPackUInt32(&(egtpCfg.minTunnelId), mBuf);
{
CmStatus cfm;
- memset((uint8_t *)&cfm, 0, sizeof(CmStatus));
+ memset(&cfm, 0, sizeof(CmStatus));
unpackEgtpCfmStatus(&cfm, mBuf);
return ((*func)(cfm));
{
CmStatus cfm;
- memset((uint8_t *)&cfm, 0, sizeof(CmStatus));
+ memset(&cfm, 0, sizeof(CmStatus));
unpackEgtpCfmStatus(&cfm, mBuf);
return ((*func)(cfm));
{
EgtpTnlEvt tnlEvt;
- memset((uint8_t *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
+ memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
oduPackUInt32(&(tnlEvt.remTeid), mBuf);
oduPackUInt32(&(tnlEvt.lclTeid), mBuf);
{
EgtpTnlEvt tnlEvt;
- memset((uint8_t *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
+ memset(&tnlEvt, 0, sizeof(EgtpTnlEvt));
unpackEgtpCfmStatus(&(tnlEvt.cfmStatus), mBuf);
oduPackUInt32(&(tnlEvt.remTeid), mBuf);
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(packRlcConfigReq)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
S16 ret1; /* Return value */
RlcMngmt cfg; /* RLC LM structure */
- TRC3(unpackRlcConfigReq)
- cmMemset((U8 *) &cfg, (U8) 0, (S16) sizeof(RlcMngmt));
+ memset(&cfg, 0, sizeof(RlcMngmt));
ret1 = cmUnpkRlcMngmt(&cfg, LKW_EVT_CFG_REQ, mBuf);
if(ret1 != ROK)
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwCntrlReq)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
S16 ret1; /* return value */
RlcMngmt cfm; /* Confirmation */
- TRC3(cmUnpkLkwCntrlReq)
ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_CNTRL_REQ, mBuf);
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwCntrlCfm)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
RlcMngmt cfm; /* RLC LM structure */
S16 ret1; /* return value */
- TRC3(cmUnpkLkwCntrlCfm)
ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_CNTRL_CFM, mBuf);
RlcMngmt cfm; /* RLC LM structure */
S16 ret1; /* return value */
- TRC3(cmUnpkLkwStsCfm)
ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_STS_CFM, mBuf);
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(packRlcConfigCfm)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
S16 ret1; /* return value */
RlcMngmt cfm; /* RLC LM structure */
- TRC3(unpackRlcConfigCfm)
ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_CFG_CFM, mBuf);
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwStaInd)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
RlcMngmt usta; /* RLC LM structure */
S16 ret1; /* return value */
- TRC3(cmUnpkLkwStaInd)
ret1 = cmUnpkRlcMngmt(&usta, LKW_EVT_STA_IND, mBuf);
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwStaReq)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
RlcMngmt cfm; /* RLC LM structure */
S16 ret1; /* return value */
- TRC3(cmUnpkLkwStaReq)
ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_STA_CFM, mBuf);
S16 ret1; /* return value */
Action action; /* Action */
- TRC3(cmUnpkLkwStsReq)
CMCHKUNPK(SUnpkS16, &action, mBuf);
RlcMngmt sta; /* RLC LM structure */
S16 ret1; /* return value */
- TRC3(cmUnpkLkwStaReq)
ret1 = cmUnpkRlcMngmt(&sta, LKW_EVT_STA_REQ, mBuf);
S16 ret1; /* return value */
RlcMngmt trc; /* RLC LM structure */
- TRC3(cmUnpkLkwTrcInd)
ret1 = cmUnpkRlcMngmt(&trc, LKW_EVT_TRC_IND, mBuf);
Buffer *mBuf; /* Message buffer */
#endif
{
- TRC3(cmPkCkwSapSta)
CMCHKPK(cmPkState, rcSap->state, mBuf);
CMCHKPK(SPkS16, rcSap->spId, mBuf);
Buffer *mBuf; /* Message buffer */
#endif
{
- TRC3(cmUnpkCkwSapSta)
CMCHKUNPK(SUnpkS16, &rcSap->spId, mBuf);
CMCHKUNPK(cmUnpkState, &rcSap->state, mBuf);
Buffer *mBuf; /* Message buffer */
#endif
{
- TRC3(cmPkKwuSapSta)
CMCHKPK(cmPkState, rlSap->state, mBuf);
CMCHKPK(SPkS16, rlSap->spId, mBuf);
Buffer *mBuf; /* Message buffer */
#endif
{
- TRC3(cmUnpkKwuSapSta)
CMCHKUNPK(SUnpkS16, &rlSap->spId, mBuf);
CMCHKUNPK(cmUnpkState, &rlSap->state, mBuf);
Buffer *mBuf; /* Message buffer */
#endif
{
- TRC3(cmPkRguSapSta)
CMCHKPK(cmPkState, mkSap->state, mBuf);
CMCHKPK(cmPkSuId, mkSap->suId, mBuf);
Buffer *mBuf; /* Message buffer */
#endif
{
- TRC3(cmUnpkRguSapSta)
CMCHKUNPK(cmUnpkSuId, &mkSap->suId, mBuf);
CMCHKUNPK(cmUnpkState, &mkSap->state, mBuf);
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwStaCfm);
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
S16 ret1 = ROK; /* return value */
Buffer *mBuf = NULLP; /* Buffer to trace */
- TRC3(cmPkLkwTrcInd);
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwStsReq)
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
if (ret1 != ROK)
Buffer *mBuf; /* message buffer */
S16 ret1; /* return value */
- TRC3(cmPkLkwStsCfm);
/* lkw_c_001.main_2 removed warning */
UNUSED(action);
ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
{
S16 ret1; /* return value */
- TRC3(cmPkRlcMngmt)
switch( eventType )
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkRlcCfg)
switch( elmnt )
{
{
U8 subAction; /* sub action */
- TRC3(cmPkRlcCntrl)
switch( elmnt )
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkRlcUsta)
/* lkw_c_001.main_2 removed warning */
UNUSED(elmnt);
#endif
{
S16 ret1;
- TRC3(cmPkRlcSsta)
ret1 = RFAILED;
switch(elmnt)
Buffer *mBuf; /* data buffer */
#endif
{
- TRC3(cmPkRlcTrc)
CMCHKPK(oduUnpackUInt16, trc->t.trc.event, mBuf);
CMCHKPK(cmPkDateTime, &trc->t.trc.dt, mBuf);
#endif
{
S16 ret1;
- TRC3(cmPkRlcSts)
ret1 = RFAILED;
switch(elmnt)
Buffer *mBuf;
#endif
{
- TRC3(cmPkGenSts)
CMCHKPK(oduUnpackUInt32, gen->numSduDisc, mBuf);
CMCHKPK(oduUnpackUInt32, gen->numOfRb, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwSapSts)
CMCHKPK(oduUnpackUInt32, rcSap->statMsgs, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkCkwSapSts)
CMCHKPK(oduUnpackUInt32, ruSap->sduTx, mBuf);
CMCHKPK(oduUnpackUInt32, ruSap->sduRx, mBuf);
#endif
{
S16 ret1;
- TRC3(cmUnpkRlcMngmt)
- cmMemset((U8 *) param, (U8) 0, (S16) sizeof(RlcMngmt));
+ memset(param, 0, sizeof(RlcMngmt));
CMCHKUNPK(cmUnpkHeader, ¶m->hdr, mBuf);
CMCHKUNPK(cmUnpkCmStatus, ¶m->cfm, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcCfg)
switch(elmnt)
{
RlcDbgCntrl *dbgCntrl;
RlcTrcCntrl *trcCntrl;
- TRC3(cmUnpkRlcCntrl);
/* lkw_c_001.main_2 removed warning */
UNUSED(elmnt);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcUsta);
/* lkw_c_001.main_2 removed warning */
UNUSED(elmnt);
#endif
{
S16 ret1; /* return value */
- TRC3(cmUnpkRlcSsta);
CMCHKUNPK(cmUnpkDateTime, &ssta->t.ssta.dt, mBuf);
switch(elmnt)
ret1 = ROK;
if(eventType == LKW_EVT_STA_CFM)
{
- cmMemset((U8 *) ptNmb, (U8) 0, LKW_PART_NUM_STR_LEN);
+ memset( ptNmb, 0, LKW_PART_NUM_STR_LEN);
ssta->t.ssta.s.sysId.ptNmb = ptNmb;
CMCHKUNPK(cmUnpkSystemId, &ssta->t.ssta.s.sysId,mBuf);
}
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRlcTrc);
CMCHKUNPK(cmUnpkDateTime, &trc->t.trc.dt, mBuf);
CMCHKUNPK(oduPackUInt16, &trc->t.trc.event, mBuf);
#endif
{
S16 ret1; /* return value */
- TRC3(cmUnpkRlcSts);
CMCHKUNPK(cmUnpkDateTime, &sts->t.sts.dt, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkGenSts);
CMCHKUNPK(oduPackUInt32, &gen->numUe, mBuf);
CMCHKUNPK(oduPackUInt32, &gen->pdusRecv, mBuf);
#endif
{
- TRC3(cmUnpkCkwSapSts);
CMCHKUNPK(oduPackUInt32, &rcSap->statMsgs, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwuSapSts)
/* lkw_c_001.main_2 changed from suId to spId */
CMCHKUNPK(cmUnpkSuId, &ruSap->spId, mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLkwL2MeasReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
U8 idx;
U16 idx1;
- TRC3(cmPkRlcL2MeasReqInfo)
if((param->measType & LKW_L2MEAS_DL_IP) ||
(param->measType & LKW_L2MEAS_UL_IP))
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLkwL2MeasStopReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLkwL2MeasSendReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
{
RlcL2MeasReqEvt measReqEvt;
- TRC3(cmUnpkLkwL2MeasReq)
if (oduPackUInt32(&measReqEvt.transId, mBuf) != ROK) {
SPutMsg(mBuf);
S16 ret;
RlcL2MeasReqEvt *measReqEvt;
- TRC3(cmUnpkLkwL2MeasReq)
if((ret = SGetSBuf(pst->region, pst->pool, (Data **)&measReqEvt,\
U8 idx;
U16 idx1;
- TRC3(cmUnpkRlcL2MeasReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->measType, mBuf);
#endif
{
U8 measType;
- TRC3(cmUnpkLkwL2MeasReq)
CMCHKUNPK(oduPackUInt8, &measType, mBuf);
SPutMsg(mBuf);
{
U8 measType;
- TRC3(cmUnpkLkwL2MeasSendReq)
CMCHKUNPK(oduPackUInt8, &measType, mBuf);
SPutMsg(mBuf);
U8 idx;
U8 idx1;
- TRC3(cmPkLkwL2MeasCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
U8 measType;
#endif
{
- TRC3(cmPkRlcL2MeasCfmInfo)
if((measType & LKW_L2MEAS_DL_IP) ||
(measType & LKW_L2MEAS_UL_IP))
U16 idx1;
RlcL2MeasCfmEvt measCfmEvt;
- TRC3(cmUnpkLkwL2MeasCfm)
- cmMemset((U8 *)&measCfmEvt, 0 , sizeof(RlcL2MeasCfmEvt));
+ memset(&measCfmEvt, 0 , sizeof(RlcL2MeasCfmEvt));
if (oduPackUInt32(&measCfmEvt.transId, mBuf) != ROK) {
SPutMsg(mBuf);
U8 measType;
#endif
{
- TRC3(cmUnpkRlcL2MeasCfmInfo)
if((measType & LKW_L2MEAS_DL_IP) ||
(measType & LKW_L2MEAS_UL_IP))
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLkwL2MeasStopCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
U8 measType;
U8 status;
- TRC3(cmUnpkLkwL2MeasCfm)
CMCHKUNPK(oduPackUInt8, &measType, mBuf);
CMCHKUNPK(oduPackUInt8, &status, mBuf);
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* lrg_c_001.main_2: Changed Pointer across Interface */
RgMngmt cfg;
- TRC3(cmUnpkLrgCfgReq)
if (cmUnpkRgMngmt(pst, &cfg, EVTLRGCFGREQ, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* lrg_c_001.main_2: Changed Pointer across Interface */
RgMngmt cfg;
- TRC3(cmUnpkLrgSchCfgReq)
if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cfm;
- TRC3(cmUnpkLrgCfgCfm)
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCFGCFM, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cfg;
- TRC3(cmUnpkLrgSchCfgCfm)
-
if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStsReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt sts;
- TRC3(cmUnpkLrgStsReq)
if (cmUnpkRgMngmt(pst, &sts, EVTLRGSTSREQ, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStsCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cfm;
- TRC3(cmUnpkLrgStsCfm)
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGSTSCFM, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStaReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt sta;
- TRC3(cmUnpkLrgStaReq)
- cmMemset((U8 *)&sta, 0, sizeof(RgMngmt));
+ memset(&sta, 0, sizeof(RgMngmt));
if (cmUnpkRgMngmt(pst, &sta, EVTLRGSSTAREQ, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStaCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cfm;
- TRC3(cmUnpkLrgStaCfm)
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGSSTACFM, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt usta;
- TRC3(cmUnpkLrgStaInd)
if (cmUnpkRgMngmt(pst, &usta, EVTLRGUSTAIND, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt sta;
- TRC3(cmUnpkLrgSchStaInd)
if (cmUnpkRgMngmt(pst, &sta, EVTLRGSCHSTAIND, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCntrlReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cntrl;
- TRC3(cmUnpkLrgCntrlReq)
if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGCNTRLREQ, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCntrlReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cntrl;
- TRC3(cmUnpkLrgSchCntrlReq)
if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLREQ, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCntrlCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cfm;
- TRC3(cmUnpkLrgCntrlCfm)
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCNTRLCFM, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCntrlCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RgMngmt cntrl;
- TRC3(cmUnpkLrgSchCntrlCfm)
if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLCFM, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgTrcInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* lrg_c_001.main_3 - MODIFY - Modified trcBuf to have it initialized to NULLP */
Buffer *trcBuf = NULLP;
- TRC3(cmUnpkLrgTrcInd)
if (cmUnpkRgMngmt(pst, &trc, EVTLRGTRCIND, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
- TRC3(cmPkRgGenCfg)
#ifdef LTE_ADV
CMCHKPK(oduUnpackUInt8, param->isSCellActDeactAlgoEnable, mBuf);
#endif
{
- TRC3(cmUnpkRgGenCfg)
CMCHKUNPK(cmUnpkPst, ¶m->lmPst, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
#endif
{
- TRC3(cmPkRgUpSapCfg)
CMCHKPK(SPkS16, param->suId, mBuf);
CMCHKPK(SPkS16, param->spId, mBuf);
#endif
{
- TRC3(cmUnpkRgUpSapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->selector, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
#endif
{
- TRC3(cmPkRgLowSapCfg)
CMCHKPK(cmPkTmrCfg, ¶m->bndTmr, mBuf);
CMCHKPK(SPkS16, param->suId, mBuf);
#endif
{
- TRC3(cmUnpkRgLowSapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->selector, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
#endif
{
- TRC3(cmPkRgAckNack)
CMCHKPK(oduUnpackUInt16, param->numOfAcks, mBuf);
CMCHKPK(oduUnpackUInt16, param->numOfNacks, mBuf);
{
S32 i;
- TRC3(cmPkRgSchNackAckStats)
for (i=14; i >= 0; i--) {
CMCHKPK(cmPkRgAckNack, ¶m->ulCqiStat[i], mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgHqNumRetx)
CMCHKPK(oduUnpackUInt32, param->totalTx, mBuf);
CMCHKPK(oduUnpackUInt16, param->numOfHQ_4, mBuf);
{
S32 i;
- TRC3(cmPkRgSchHqRetxStats)
for (i=14; i >= 0; i--) {
CMCHKPK(cmPkRgHqNumRetx, ¶m->ulCqiStat[i], mBuf);
#endif
{
- TRC3(cmUnpkRgAckNack)
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->numOfNacks, mBuf);
#endif
{
S32 i;
- TRC3(cmUnpkRgSchNackAckStats)
for (i=0; i <= 14; i++) {
CMCHKUNPK(cmUnpkRgAckNack, ¶m->dlCqiStat[i], mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgHqNumRetx)
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->numOfHQ_1, mBuf);
#endif
{
S32 i;
- TRC3(cmUnpkRgSchHqRetxStats)
for (i=0; i <= 14; i++) {
CMCHKUNPK(cmUnpkRgHqNumRetx, ¶m->dlCqiStat[i], mBuf);
#endif
{
- TRC3(cmPkRgGenSts)
#ifdef MAC_SCH_STATS
CMCHKPK(cmPkRgSchHqRetxStats, ¶m->hqRetxStats, mBuf);
#endif
{
- TRC3(cmUnpkRgGenSts)
CMCHKUNPK(oduPackUInt32, ¶m->numHarqFail, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numUeCfg, mBuf);
#endif
{
- TRC3(cmPkRgSapSts)
CMCHKPK(oduUnpackUInt32, param->numPduDrop, mBuf);
CMCHKPK(oduUnpackUInt32, param->numPduTxmit, mBuf);
#endif
{
- TRC3(cmUnpkRgSapSts)
CMCHKUNPK(oduPackUInt32, ¶m->numPduRcvd, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numPduTxmit, mBuf);
{
S32 i;
- TRC3(cmPkRgSchInstCfg)
for (i=param->numSaps-1; i >= 0; i--) {
CMCHKPK(cmPkRgLowSapCfg, ¶m->tfuSap[i], mBuf);
{
S32 i;
- TRC3(cmUnpkRgSchInstCfg)
CMCHKUNPK(oduPackUInt8, ¶m->instId, mBuf);
CMCHKUNPK(cmUnpkRgGenCfg, ¶m->genCfg, mBuf);
#endif
{
- TRC3(cmPkRgCfg)
switch(elmnt) {
case STSCHINST:
#endif
{
- TRC3(cmUnpkRgCfg)
switch(elmnt) {
case STGEN:
#endif
{
- TRC3(cmPkRgSapSta)
CMCHKPK(oduUnpackUInt8, param->sapState, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkRgSapSta)
CMCHKUNPK(oduPackUInt8, ¶m->sapState, mBuf);
return ROK;
#endif
{
- TRC3(cmPkRgSts)
switch(elmnt) {
case STTFUSAP:
#endif
{
- TRC3(cmUnpkRgSts)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sapInst, mBuf);
#endif
{
- TRC3(cmPkRgSsta)
switch(elmnt) {
case STTFUSAP:
#endif
{
- TRC3(cmUnpkRgSsta)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sapInst, mBuf);
/* KWORK_FIX: Moved the memset under the NULL check */
if (param->s.sysId.ptNmb != NULLP)
{
- cmMemset((U8 *)param->s.sysId.ptNmb, 0, LRG_MAX_PT_NUM_SIZE);
+ memset(param->s.sysId.ptNmb, 0, LRG_MAX_PT_NUM_SIZE);
CMCHKUNPK(cmUnpkSystemId, ¶m->s.sysId, mBuf);
}
}
#endif
{
- TRC3(cmPkRgUstaDgn)
switch(param->type) {
case LRG_USTA_DGNVAL_MEM:
#endif
{
- TRC3(cmUnpkRgUstaDgn)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
switch(param->type) {
#endif
{
- TRC3(cmPkRgUsta)
CMCHKPK(cmPkRgUstaDgn, ¶m->dgn, mBuf);
CMCHKPK(cmPkCmAlarm, ¶m->cmAlarm, mBuf);
#endif
{
- TRC3(cmUnpkRgUsta)
CMCHKUNPK(cmUnpkCmAlarm, ¶m->cmAlarm, mBuf);
CMCHKUNPK(cmUnpkRgUstaDgn, ¶m->dgn, mBuf);
#endif
{
- TRC3(cmPkRgTrc)
CMCHKPK(oduUnpackUInt8, param->evnt, mBuf);
CMCHKPK(cmPkDateTime, ¶m->dt, mBuf);
#endif
{
- TRC3(cmUnpkRgTrc)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->evnt, mBuf);
#endif
{
- TRC3(cmPkRgDbgCntrl)
CMCHKPK(oduUnpackUInt32, param->dbgMask, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgSchUlAllocCntrl)
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(oduUnpackUInt16, param->numOfRb, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgSchUlAllocCntrl)
CMCHKUNPK(oduPackUInt16, ¶m->logTime, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->enaLog, mBuf);
#endif
{
- TRC3(cmUnpkRgDbgCntrl)
CMCHKUNPK(oduPackUInt32, ¶m->dbgMask, mBuf);
return ROK;
#endif
{
- TRC3(cmPkRgSapCntrl)
CMCHKPK(SPkS16, param->spId, mBuf);
CMCHKPK(SPkS16, param->suId, mBuf);
#endif
{
- TRC3(cmUnpkRgSapCntrl)
CMCHKUNPK(SUnpkS16, ¶m->suId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->spId, mBuf);
#endif
{
- TRC3(cmPkRgCntrl)
switch(elmnt) {
case STTFUSAP:
#endif
{
- TRC3(cmUnpkRgCntrl)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
#endif
{
- TRC3(cmPkRgMngmt)
switch(eventType) {
case EVTLRGCNTRLREQ:
#endif
{
- TRC3(cmUnpkRgMngmt)
CMCHKUNPK(cmUnpkHeader, ¶m->hdr, mBuf);
CMCHKUNPK(cmUnpkCmStatus, ¶m->cfm, mBuf);
{
U8 idx;
- TRC3(cmPkNmbActvUeQciReq)
for(idx = 0; idx < nmbActvUeQci->numQci; idx++)
{
{
U8 idx;
- TRC3(cmPkAvgPrbQciReq)
-
for(idx = 0; idx < avgPrbQciReq->numQci; idx++)
{
CMCHKPK(oduUnpackUInt8, avgPrbQciReq->qci[idx], mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasStopReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasSendReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
{
U8 idx;
- TRC3(cmUnpkNmbActvUeQciReq)
-
CMCHKUNPK(oduPackUInt8, ¶m->sampPrd, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
U8 idx;
- TRC3(cmUnpkAvgPrbQciReq)
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
LrgSchMeasReqInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasReq)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
{
LrgSchMeasStopReqInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasStopReq)
-
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
/*CMCHKUNPK(oduPackUInt16, &measInfo.timePrd, mBuf);*/
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasStopCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
{
LrgSchMeasCfmInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasCfm)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
{
U8 idx;
- TRC3(cmPkNumUeQciCfm)
for(idx = 0; idx < param->numQci; idx++)
{
{
U8 idx;
- TRC3(cmPkAvgPrbQciCfm)
for(idx = 0; idx < param->numQci; idx++)
{
/*LRG : Review Tag*/
#endif
{
- TRC3(cmPkRaPrmbsCfm)
CMCHKPK(oduUnpackUInt16, param->randSelPreHighRange, mBuf);
CMCHKPK(oduUnpackUInt16, param->randSelPreLowRange, mBuf);
CMCHKPK(oduUnpackUInt16, param->dedPreambles, mBuf);
#endif
{
- TRC3(cmPkAvgPrbCfm)
CMCHKPK(oduUnpackUInt8, param->prbPerc, mBuf);
return ROK;
}
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
U8 idx;
- TRC3(cmUnpkNumUeQciCfm)
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
{
U8 idx;
- TRC3(cmUnpkAvgPrbQciCfm)
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
#endif
{
- TRC3(cmUnpkRaPrmbsCfm)
CMCHKUNPK(oduPackUInt16, ¶m->dedPreambles, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->randSelPreLowRange, mBuf);
#endif
{
- TRC3(cmUnpkAvgPrbCfm)
CMCHKUNPK(oduPackUInt8, ¶m->prbPerc, mBuf);
return ROK;
{
LrgSchMeasCfmInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasCfm)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
uint8_t cmUnpkSctpNtfy(SctpNtfy func, Pst *pst, Buffer *mBuf)
{
CmInetSctpNotification ntfy;
- memset((uint8_t*)&ntfy, 0, sizeof(CmInetSctpNotification));
+ memset(&ntfy, 0, sizeof(CmInetSctpNotification));
oduPackUInt16(&(ntfy.header.nType), mBuf);
if(ntfy.header.nType == CM_INET_SCTP_ASSOC_CHANGE)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLwLcRgmBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SpId spId;
S16 ret;
- TRC3(cmUnpkLwLcRgmBndReq)
if (SUnpkS16(&suId, mBuf) != ROK)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLwLcRgmUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLwLcRgmBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SuId suId;
U8 status;
- TRC3(cmUnpkLwLcRgmBndCfm)
if (oduPackUInt8(&status, mBuf) != ROK)
{
{
Buffer *mBuf = NULLP;
U32 len = sizeof(RgmPrbRprtCfg);
- TRC3(cmPkLwLcRgmCfgPrbRprt)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SpId spId;
RgmPrbRprtCfg *prbRprtCfg;
- TRC3(cmUnpkLwLcRgmCfgPrbRprt)
if (SUnpkS16(&spId, mBuf) != ROK)
{
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLwLcRgmPrbRprtInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
RgmPrbRprtInd *prbRprtInd;
S16 ret;
- TRC3(cmUnpkLwLcRgmPrbRprtInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgmBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SpId spId;
S16 ret;
- TRC3(cmUnpkRgmBndReq)
if (SUnpkS16(&suId, mBuf) != ROK)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgmUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SpId spId;
Reason reason;
- TRC3(cmUnpkRgmUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgmBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SuId suId;
U8 status;
- TRC3(cmUnpkRgmBndCfm)
if (oduPackUInt8(&status, mBuf) != ROK)
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkCfgPrbRprt);
CMCHKPK(oduUnpackUInt16, prbRprtCfg->usPrbAvgPeriodicty, mBuf);
CMCHKPK(oduUnpackUInt8, prbRprtCfg->bConfigType, mBuf);
CMCHKPK(oduUnpackUInt8, prbRprtCfg->bCellId, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnPkCfgPrbRprt);
CMCHKUNPK(oduPackUInt8, &prbRprtCfg->bCellId, mBuf);
CMCHKUNPK(oduPackUInt8, &prbRprtCfg->bConfigType, mBuf);
CMCHKUNPK(oduPackUInt16, &prbRprtCfg->usPrbAvgPeriodicty, mBuf);
{
Buffer *mBuf = NULLP;
U32 len = sizeof(RgmPrbRprtCfg);
- TRC3(cmPkRgmCfgPrbRprt)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SpId spId;
RgmPrbRprtCfg *prbRprtCfg;
- TRC3(cmUnpkRgmCfgPrbRprt)
if ((SGetSBuf(pst->region, pst->pool, (Data **)&prbRprtCfg, sizeof(RgmPrbRprtCfg))) != ROK)
{
SPutMsg(mBuf);
{
S32 idx = 0;
- TRC3(cmPkPrbRprtInd);
/* RRM_SP1_START */
for(idx = RGM_MAX_QCI_REPORTS-1; idx >= 0; idx--)
{
U32 idx = 0;
- TRC3(cmUnpkPrbRprtInd);
/* RRM_SP1_START */
CMCHKUNPK(oduPackUInt8, &prbRprtInd->bCellId, mBuf);
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgmPrbRprtInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SuId suId;
RgmPrbRprtInd prbRprtInd;
- TRC3(cmUnpkRgmPrbRprtInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkTransModeInd);
CMCHKPK(oduUnpackUInt32, transModeInd->eMode, mBuf);
CMCHKPK(oduUnpackUInt16, transModeInd->usCrnti, mBuf);
CMCHKPK(oduUnpackUInt8, transModeInd->bCellId, mBuf);
#endif
{
U32 tmpModeEnum;
- TRC3(cmUnpkTransModeInd);
CMCHKUNPK(oduPackUInt8, &transModeInd->bCellId, mBuf);
CMCHKUNPK(oduPackUInt16, &transModeInd->usCrnti, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpModeEnum, mBuf);
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgmTransModeInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
SuId suId;
RgmTransModeInd transModeInd;
- TRC3(cmUnpkRgmTransModeInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
SpId spId;
- TRC3(cmUnpkRgrBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
U8 status;
- TRC3(cmUnpkRgrBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
Reason reason;
- TRC3(cmUnpkRgrUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
RgrCfgTransId transId;
RgrCfgReqInfo *cfgReqInfo;
- TRC3(cmUnpkRgrCfgReq)
#if 0
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
SPutMsg(mBuf);
return RFAILED;
}
- cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
+ memset(cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrTtiInd)
CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrTtiIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->sfn, mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrTtiInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
RgrTtiIndInfo *ttiInd;
- TRC3(cmUnpkRgrTtiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
RgrCfgTransId transId;
U8 status;
- TRC3(cmUnpkRgrCfgCfm)
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrSiCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
RgrCfgTransId transId;
U8 status;
- TRC3(cmUnpkRgrSiCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
{
S32 i;
- TRC3(cmPkRgrCfgTransId)
for (i=RGR_CFG_TRANSID_SIZE-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
{
S32 i;
- TRC3(cmUnpkRgrCfgTransId)
for (i=0; i<RGR_CFG_TRANSID_SIZE; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
#endif
{
- TRC3(cmPkRgrDlHqCfg)
CMCHKPK(oduUnpackUInt8, param->maxMsg4HqTx, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxDlHqTx, mBuf);
#endif
{
- TRC3(cmUnpkRgrDlHqCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxDlHqTx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->maxMsg4HqTx, mBuf);
#endif
{
- TRC3(cmPkRgrRntiCfg)
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->startRnti, mBuf);
#endif
{
- TRC3(cmUnpkRgrRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->startRnti, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
#endif
{
- TRC3(cmPkRgrEmtcRntiCfg)
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->rntiCeModeBRange, mBuf);
#endif
{
- TRC3(cmUnpkRgrEmtcRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rntiCeModeAStart, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rntiCeModeARange, mBuf);
#endif
{
- TRC3(cmPkRgrDlCmnCodeRateCfg)
-
CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
CMCHKPK(oduUnpackUInt16, param->pdcchCodeRate, mBuf);
CMCHKPK(oduUnpackUInt16, param->bcchPchRaCodeRate, mBuf);
#endif
{
- TRC3(cmUnpkRgrDlCmnCodeRateCfg)
-
CMCHKUNPK(oduPackUInt16, ¶m->bcchPchRaCodeRate, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->pdcchCodeRate, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ccchCqi, mBuf);
#endif
{
- TRC3(cmPkRgrCfiCfg)
-
CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
return ROK;
}
#endif
{
- TRC3(cmUnpkRgrCfiCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->cfi, mBuf);
return ROK;
}
{
S32 i;
- TRC3(cmPkRgrPuschSubBandCfg)
for (i=param->numSubbands-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->dmrs[i], mBuf);
{
S32 i;
- TRC3(cmUnpkRgrPuschSubBandCfg)
CMCHKUNPK(oduPackUInt8, ¶m->subbandStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSubbands, mBuf);
#endif
{
- TRC3(cmPkRgrUlCmnCodeRateCfg)
-
CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
return ROK;
}
#endif
{
- TRC3(cmUnpkRgrUlCmnCodeRateCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->ccchCqi, mBuf);
return ROK;
}
#endif
{
- TRC3(cmPkRgrUlTrgCqiCfg)
-
CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
return ROK;
}
#endif
{
- TRC3(cmUnpkRgrUlTrgCqiCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->trgCqi, mBuf);
return ROK;
}
#endif
{
- TRC3(cmPkRgrBwCfg)
-
CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
return ROK;
{
S32 i;
- TRC3(cmPkRgrEmtcSiCfg)
CMCHKPK(oduUnpackUInt8, param->siHoppingEnable, mBuf);
CMCHKPK(oduUnpackUInt32, param->modPrd, mBuf);
{
S32 i;
- TRC3(cmPkRgrEmtcRachCfg)
CMCHKPK(oduUnpackUInt8, param->emtcCeLvlSupported, mBuf);
#endif
{
- TRC3(cmPkRgrEmtcPdschCfg)
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrEmtcPuschCfg)
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcHoppingOffset, mBuf);
S32 i;
- TRC3(cmPkRgrEmtcPucchCfg)
for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt16, param->emtcN1pucchAnInfoLst[i], mBuf);
}
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrEmtcPrachCeParamCfg)
CMCHKPK(oduUnpackUInt8, param->emtcPrachCfgIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcPrachFreqOffset, mBuf);
CMCHKPK(oduUnpackUInt16, param->emtcPrachStartSubFrame, mBuf);
{
S32 i;
- TRC3(cmPkRgrEmtcPrachCfg)
CMCHKPK(oduUnpackUInt8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcPrachHopingOffset, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcInitialCElevel, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrEmtcCfg)
CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
CMCHKPK(oduUnpackUInt32, param->emtcT300Tmr, mBuf);
CMCHKPK(oduUnpackUInt32, param->emtcT301Tmr, mBuf);
S32 i;
U32 tmpEnum;
- TRC3(cmUnpkRgrEmtcSiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
for (i=0; i < param->numSi ; i++) {
{
S32 i;
- TRC3(cmUnpkRgrEmtcRachCfg)
for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
#endif
{
- TRC3(cmUnpkRgrEmtcPdschCfg)
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeB, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeA, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrEmtcPuschCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcHoppingOffset, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeB, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeA, mBuf);
S32 i;
- TRC3(cmUnpkRgrEmtcPucchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl3, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl2, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrEmtcPrachCeParamCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcPrachHoppingCfg, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMpdcchNumRep, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchNBtoMonitor[1], mBuf);
{
S32 i;
- TRC3(cmUnpkRgrEmtcPrachCfg)
for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
CMCHKUNPK(cmUnpkRgrEmtcPrachCeParamCfg, ¶m->emtcPrachCEparmLst[i], mBuf);
}
#endif
{
- TRC3(cmUnpkRgrEmtcCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcPuschNbIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchNbIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcPdschNbIdx, mBuf);
#endif
{
- TRC3(cmUnpkRgrBwCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->dlTotalBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulTotalBw, mBuf);
return ROK;
#endif
{
- TRC3(cmPkRgrPhichCfg)
-
CMCHKPK(oduUnpackUInt8, param->isDurExtend, mBuf);
CMCHKPK(oduUnpackUInt32, param->ngEnum, mBuf);
return ROK;
{
U32 tmpEnum;
- TRC3(cmUnpkRgrPhichCfg)
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ngEnum = (RgrPhichNg) tmpEnum;
#endif
{
- TRC3(cmPkRgrPucchCfg)
-
CMCHKPK(oduUnpackUInt8, param->maxPucchRb, mBuf);
CMCHKPK(oduUnpackUInt8, param->cyclicShift, mBuf);
CMCHKPK(oduUnpackUInt8, param->deltaShift, mBuf);
#endif
{
- TRC3(cmUnpkRgrPucchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->resourceSize, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->n1PucchAn, mBuf);
#endif
{
- TRC3(cmPkRgrSrsCfg)
CMCHKPK(oduUnpackUInt8, param->srsSubFrameCfg, mBuf);
CMCHKPK(oduUnpackUInt32, param->srsBwEnum, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrSrsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isSrsCfgSetup, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
{
S32 i;
- TRC3(cmPkRgrRachCfg)
CMCHKPK(oduUnpackUInt8, param->prachResource, mBuf);
CMCHKPK(oduUnpackUInt16, param->msgSizeGrpA, mBuf);
U32 tmpEnum;
S32 i;
- TRC3(cmUnpkRgrRachCfg)
#ifdef RGR_V1
/* rgr_c_001.main_5: cccpu00112372: Added contention resolution
* timer configuration */
S16 idx;
#endif/*RGR_SI_SCH*/
- TRC3(cmPkRgrSiCfg)
#ifdef RGR_SI_SCH
if(param->numSi > sizeof(param->siPeriodicity)/
S16 idx;
#endif/*RGR_SI_SCH*/
- TRC3(cmUnpkRgrSiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->siWinSize, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->retxCnt, mBuf);
#endif
{
- TRC3(cmPkRgrTpcRntiCfg)
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->startTpcRnti, mBuf);
#endif
{
- TRC3(cmUnpkRgrTpcRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->startTpcRnti, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
#endif
{
- TRC3(cmPkRgrUlPwrCfg)
CMCHKPK(cmPkRgrTpcRntiCfg, ¶m->puschPwrFmt3a, mBuf);
CMCHKPK(cmPkRgrTpcRntiCfg, ¶m->puschPwrFmt3, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUlPwrCfg)
CMCHKUNPK(SUnpkS8, ¶m->p0NominalPusch, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkRgrPuschCfg)
CMCHKPK(oduUnpackUInt8, param->hopOffst, mBuf);
CMCHKPK(oduUnpackUInt8, param->isIntraHop, mBuf);
#endif
{
- TRC3(cmUnpkRgrPuschCfg)
CMCHKUNPK(oduPackUInt8, ¶m->numSubBands, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isIntraHop, mBuf);
{
S32 i;
- TRC3(cmPkRgrCodeBookRstCfg)
for (i=1-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt32, param->pmiBitMap[i], mBuf);
{
S32 i;
- TRC3(cmUnpkRgrCodeBookRstCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
for (i=0; i<1; i++) {
#endif
{
- TRC3(cmPkRgrPreambleSetCfg)
CMCHKPK(oduUnpackUInt8, param->size, mBuf);
CMCHKPK(oduUnpackUInt8, param->start, mBuf);
#endif
{
- TRC3(cmUnpkRgrPreambleSetCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->start, mBuf);
#endif
{
- TRC3(cmPkRgrCmnLchCfg)
CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
#endif
{
- TRC3(cmUnpkRgrCmnLchCfg)
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
#endif
{
- TRC3(cmPkRgrDlfsCfg)
CMCHKPK(oduUnpackUInt8, param->thresholdCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->isDlFreqSel, mBuf);
#endif
{
- TRC3(cmUnpkRgrDlfsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isDlFreqSel, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->thresholdCqi, mBuf);
#endif
{
- TRC3(cmPkRgrTddPrachInfo)
CMCHKPK(oduUnpackUInt8, param->ulStartSfIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->halfFrm, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrTddPrachInfo)
CMCHKUNPK(oduPackUInt8, ¶m->freqIdx, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
{
S32 i;
- TRC3(cmPkRgrTddPrachRscInfo)
for (i=param->numRsc-1; i >= 0; i--) {
CMCHKPK(cmPkRgrTddPrachInfo, ¶m->prachInfo[i], mBuf);
{
S32 i;
- TRC3(cmUnpkRgrTddPrachRscInfo)
CMCHKUNPK(oduPackUInt8, ¶m->numRsc, mBuf);
for (i=0; i<param->numRsc; i++) {
#endif
{
S32 idx;
- TRC3(cmPkRgrEnbPfs)
for(idx = RGR_MAX_NUM_QCI-1; idx >= 0; idx--)
{
CMCHKPK(oduUnpackUInt32, param->qciWgt[idx], mBuf);
#endif
{
S32 idx;
- TRC3(cmUnpkRgrEnbPfs)
CMCHKUNPK(oduPackUInt8, ¶m->tptCoeffi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->fairCoeffi, mBuf);
#endif
{
- TRC3(cmPkRgrSpsCellCfg)
CMCHKPK(oduUnpackUInt16, param->maxSpsUePerUlSf, mBuf);
CMCHKPK(oduUnpackUInt16, param->maxSpsUePerDlSf, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxSpsDlBw, mBuf);
#endif
{
- TRC3(cmUnpkRgrSpsDlCellCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxSpsDlBw, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->maxSpsUePerDlSf, mBuf);
#endif
{
- TRC3(cmPkRgrlteUCellCfg)
CMCHKPK(oduUnpackUInt8, param->isLaaCell, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkRgrLteUCellCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isLaaCell, mBuf);
#endif
{
- TRC3(cmPkRgrLteAdvancedUeConfig)
CMCHKPK(oduUnpackUInt8, param->isUeCellEdge, mBuf);
CMCHKPK(oduUnpackUInt8, param->isAbsUe, mBuf);
CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
#endif
{
- TRC3(cmUnpkRgrLteAdvancedUeConfig)
CMCHKUNPK(oduPackUInt32, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isAbsUe, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isUeCellEdge, mBuf);
{
S8 indx = 0;
- TRC3(cmPkRgrAbsConfig)
CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
for (indx = RGR_ABS_PATTERN_LEN-1; indx >= 0; indx--)
{
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrSfrConfig)
CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
#ifdef TFU_UPGRADE
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrDsfrConfig)
CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrDsfrConfig)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->status, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrCellLteAdvancedFeatureCfg)
CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
CMCHKPK(cmPkRgrDsfrConfig, ¶m->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
{
S8 indx = 0;
- TRC3(cmUnpkRgrAbsConfig)
CMCHKUNPK(oduPackUInt32, ¶m->absLoadPeriodicity, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->absPatternType, mBuf);
#endif
{
- TRC3(cmUnpkRgrSfrConfig)
CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.startRb, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.endRb, mBuf);
#endif
{
- TRC3(cmUnpkRgrCellLteAdvancedFeatureCfg)
CMCHKUNPK(cmUnpkRgrAbsConfig, ¶m->absCfg, mBuf);
CMCHKUNPK(cmUnpkRgrSfrConfig, ¶m->sfrCfg, mBuf);
CMCHKUNPK(cmUnpkRgrDsfrConfig, ¶m->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
Buffer *mBuf;
#endif
{
- TRC3(cmPkMacSchedGnbCfg)
CMCHKPK(oduUnpackUInt8, param->maxDlUePerTti, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxUlUePerTti, mBuf);
#endif
{
- TRC3(cmUnpkMacSchedGnbCfg)
CMCHKUNPK(oduPackUInt8, ¶m->numTxAntPorts, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulSchdType, mBuf);
{
S32 i;
- TRC3(cmPkRgrCellCfg)
#ifdef EMTC_ENABLE
/* EMTC related changes start*/
S32 i;
- TRC3(cmUnpkRgrCellCfg)
#ifdef EMTC_ENABLE
/* EMTC related changes start*/
CMCHKUNPK(cmUnpkRgrEmtcCfg, ¶m->emtcCellCfg, mBuf);
#endif
{
- TRC3(cmPkRgrUeAprdDlCqiCfg)
/*Pack Aperiodic Trigger List only for Pcell */
#ifdef LTE_ADV
CMCHKPK(oduUnpackUInt8, param->triggerSet2, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeAprdDlCqiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkRgrUePrdDlCqiCfg)
CMCHKPK(oduUnpackUInt16, param->cqiPmiCfgIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->k, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUePrdDlCqiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkRgrUeDlPCqiSetup)
CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
CMCHKPK(oduUnpackUInt8, param->sANCQI, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeDlPCqiSetup)
CMCHKUNPK(oduPackUInt16, ¶m->cqiPResIdx, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->cqiPCfgIdx, mBuf);
#endif
{
- TRC3(cmPkRgrUePrdDlCqiCfg)
CMCHKPK(cmPkRgrUeDlPCqiSetup, ¶m->cqiSetup, mBuf);
CMCHKPK(oduUnpackUInt8, param->type, mBuf);
#endif
{
- TRC3(cmUnpkRgrUePrdDlCqiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
CMCHKUNPK(cmUnpkRgrUeDlPCqiSetup, ¶m->cqiSetup, mBuf);
#endif
{
- TRC3(cmPkRgrUeUlSrsSetupCfg)
CMCHKPK(oduUnpackUInt8, param->fDomPosi, mBuf);
CMCHKPK(oduUnpackUInt8, param->txComb, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeUlSrsSetupCfg)
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
#endif
{
- TRC3(cmPkRgrUeSrSetupCfg)
/* ccpu00131601:DEL - dTMax Packing removed since this param will not
* be required by Scheduler*/
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrUeSrSetupCfg)
CMCHKUNPK(oduPackUInt16, ¶m->srResIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->srCfgIdx, mBuf);
#endif
{
- TRC3(cmPkRgrUeSrCfg)
CMCHKPK(cmPkRgrUeSrSetupCfg, ¶m->srSetup, mBuf);
CMCHKPK(oduUnpackUInt8, param->type, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeSrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
CMCHKUNPK(cmUnpkRgrUeSrSetupCfg, ¶m->srSetup, mBuf);
#endif
{
- TRC3(cmPkRgrUeUlSrsCfg)
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKPK(cmPkRgrUeUlSrsSetupCfg, ¶m->srsSetup, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeUlSrsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
#endif
{
- TRC3(cmPkRgrUeDlCqiCfg)
/* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
#endif
{
- TRC3(cmUnpkRgrUeDlCqiCfg)
CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, ¶m->aprdCqiCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, ¶m->prdCqiCfg, mBuf);
#endif
{
- TRC3(cmPkRgrUeMeasGapCfg)
CMCHKPK(oduUnpackUInt8, param->gapOffst, mBuf);
CMCHKPK(oduUnpackUInt8, param->gapPrd, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeMeasGapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isMesGapEnabled, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->gapPrd, mBuf);
#endif
{
- TRC3(cmPkRgrDrxLongCycleOffst)
CMCHKPK(oduUnpackUInt16, param->drxStartOffst, mBuf);
CMCHKPK(oduUnpackUInt16, param->longDrxCycle, mBuf);
#endif
{
- TRC3(cmUnpkRgrDrxLongCycleOffst)
CMCHKUNPK(oduPackUInt16, ¶m->longDrxCycle, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->drxStartOffst, mBuf);
#endif
{
- TRC3(cmPkRgrDrxShortDrx)
CMCHKPK(oduUnpackUInt8, param->drxShortCycleTmr, mBuf);
CMCHKPK(oduUnpackUInt16, param->shortDrxCycle, mBuf);
#endif
{
- TRC3(cmUnpkRgrDrxShortDrx)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->shortDrxCycle, mBuf);
#endif
{
- TRC3(cmPkRgrUeDrxCfg)
CMCHKPK(cmPkRgrDrxShortDrx, ¶m->drxShortDrx, mBuf);
CMCHKPK(cmPkRgrDrxLongCycleOffst, ¶m->drxLongCycleOffst, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeDrxCfg)
/*rgr_c_001.main_9 ADD added changes for R9*/
#ifdef LTEMAC_R9
#endif
{
- TRC3(cmPkRgrUeCapCfg)
CMCHKPK(oduUnpackUInt8, param->txAntSel, mBuf);
CMCHKPK(oduUnpackUInt8, param->simCqiAckNack, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeCapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pwrClass, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->intraSfFeqHop, mBuf);
#endif
{
- TRC3(cmPkRgrUeAckNackRepCfg)
CMCHKPK(oduUnpackUInt32, param->ackNackRepFactor, mBuf);
CMCHKPK(oduUnpackUInt16, param->pucchAckNackRep, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeAckNackRepCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isAckNackEnabled, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->pucchAckNackRep, mBuf);
#endif
{
- TRC3(cmPkRgrUeTxModeCfg)
CMCHKPK(oduUnpackUInt32, param->txModeEnum, mBuf);
CMCHKPK(oduUnpackUInt32, param->tmTrnstnState, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeTxModeCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkRgrUeUlHqCfg)
CMCHKPK(oduUnpackUInt8, param->deltaHqOffst, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeUlHqCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxUlHqTx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->deltaHqOffst, mBuf);
#endif
{
- TRC3(cmPkRgrUeGrpPwrCfg)
CMCHKPK(oduUnpackUInt8, param->idx, mBuf);
CMCHKPK(cmPkLteRnti, param->tpcRnti, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeGrpPwrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->tpcRnti, mBuf);
{
S32 i;
- TRC3(cmPkRgrUeSpsDlCfg)
CMCHKPK(oduUnpackUInt16, param->explicitRelCnt, mBuf);
CMCHKPK(oduUnpackUInt32, param->dlSpsPrdctyEnum, mBuf);
for (i=param->numPucchVal-1; i >= 0; i--) {
U32 tmpEnum;
S32 i;
- TRC3(cmUnpkRgrUeSpsDlCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isDlSpsEnabled, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSpsHqProc, mBuf);
{
S32 i;
- TRC3(cmPkRgrUeSpsUlCfg)
CMCHKPK(oduUnpackUInt8, param->isLcSRMaskEnab, mBuf);
for (i=param->lcCnt-1; i >= 0; i--) {
U32 tmpEnum;
S32 i;
- TRC3(cmUnpkRgrUeSpsUlCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isUlSpsEnabled, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkRgrUeSpsCfg)
CMCHKPK(cmPkRgrUeSpsUlCfg, ¶m->ulSpsCfg, mBuf);
CMCHKPK(cmPkRgrUeSpsDlCfg, ¶m->dlSpsCfg, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeSpsCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->spsRnti, mBuf);
CMCHKUNPK(cmUnpkRgrUeSpsDlCfg, ¶m->dlSpsCfg, mBuf);
#endif
{
- TRC3(cmPkRgrUeUlPwrCfg)
CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeUlPwrCfg)
CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, ¶m->uePuschPwr, mBuf);
CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, ¶m->uePucchPwr, mBuf);
#endif
{
- TRC3(cmPkRgrUeQosCfg)
CMCHKPK(oduUnpackUInt32, param->ueBr, mBuf);
CMCHKPK(oduUnpackUInt32, param->dlAmbr, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeQosCfg)
CMCHKUNPK(oduPackUInt8, ¶m->ambrPres, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->dlAmbr, mBuf);
#endif
{
- TRC3(cmPkRgrUePuschDedCfg)
CMCHKPK(oduUnpackUInt8, param->bCQIIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->bRIIdx, mBuf);
#endif
{
- TRC3(cmUnpkRgrUePuschDedCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->bACKIdx, mBuf);
#endif
{
- TRC3(cmPkRgrUeTxAntSelCfg)
CMCHKPK(oduUnpackUInt32, param->selType, mBuf);
CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeTxAntSelCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
#endif
{
- TRC3(cmPkRgrUeTaTmrCfg)
CMCHKPK(oduUnpackUInt16, param->taTmr, mBuf);
CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeTaTmrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->taTmr, mBuf);
#endif
{
- TRC3(cmPkRgrUeCfg)
#ifdef RG_5GTF
CMCHKPK(cmPkRgr5gtfUeCfg, ¶m->ue5gtfCfg, mBuf);
#endif
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkRgrLchQosCfg)
CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
#endif
{
- TRC3(cmUnpkRgrLchQosCfg)
CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->gbr, mBuf);
#endif
{
- TRC3(cmPkRgrLchSpsCfg)
/* SPS_DEV */
CMCHKPK(oduUnpackUInt8, param->isSpsEnabled, mBuf);
#endif
{
- TRC3(cmUnpkRgrLchSpsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isSpsEnabled, mBuf);
#endif
{
- TRC3(cmPkRgrDlLchCfg)
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKPK(oduUnpackUInt8, param->rlcReorderTmr, mBuf);
#endif
{
- TRC3(cmUnpkRgrDlLchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->dlTrchType, mBuf);
CMCHKUNPK(cmUnpkRgrLchQosCfg, ¶m->dlQos, mBuf);
#endif
{
- TRC3(cmPkRgrUlLchCfg)
CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
#endif
{
- TRC3(cmUnpkRgrUlLchCfg)
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
#ifdef LTE_L2_MEAS
S32 i;
#endif
- TRC3(cmPkRgrUlLcgCfg)
CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
#ifdef LTE_L2_MEAS
S32 i;
#endif
- TRC3(cmUnpkRgrUlLcgCfg)
CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
/*rgr_c_001.main_9 ADD added changes for L2 measurements*/
#endif
{
- TRC3(cmPkRgrLchCfg)
CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
CMCHKPK(cmPkRgrUlLchQciCfg, ¶m->ulLchQciInfo, mBuf);
CMCHKPK(cmPkRgrDlLchCfg, ¶m->dlInfo, mBuf);
#endif
{
- TRC3(cmUnpkRgrLchCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkRgrLcgCfg)
CMCHKPK(cmPkRgrUlLcgCfg, ¶m->ulInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
#endif
{
- TRC3(cmUnpkRgrLcgCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkRgrCfg)
switch(param->cfgType) {
case RGR_LCG_CFG:
#endif
{
- TRC3(cmUnpkRgrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
#endif
{
- TRC3(cmPkRgrActvTime)
CMCHKPK(cmPkLteTimingInfo, ¶m->actvTime, mBuf);
CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
#endif
{
- TRC3(cmUnpkRgrActvTime)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->actvTime, mBuf);
#endif
{
- TRC3(cmPkRgrCellRecfg)
CMCHKPK(cmPkRgrCellCntrlCmdCfg, ¶m->cntrlCmdCfg, mBuf);
CMCHKPK(cmPkRgrCellCsgParamCfg, ¶m->csgParamCfg, mBuf);
CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
#endif
{
- TRC3(cmUnpkRgrCellRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->recfgTypes, mBuf);
#endif
{
- TRC3(cmPkRgrUeRecfg)
#ifdef EMTC_ENABLE
/* Note: As we add more members to emtcUeRecfg,
create a new function for pkUnpk */
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUeRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->oldCrnti, mBuf);
#endif
{
- TRC3(cmPkRgrLchRecfg)
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
#endif
{
- TRC3(cmUnpkRgrLchRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#ifdef RG_UNUSED
S32 i;
#endif
- TRC3(cmPkRgrLcgRecfg)
CMCHKPK(oduUnpackUInt32, param->ulRecfg.mbr, mBuf);
CMCHKPK(oduUnpackUInt32, param->ulRecfg.gbr, mBuf);
#ifdef RG_UNUSED
S32 i;
#endif
- TRC3(cmUnpkRgrLcgRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkRgrRecfg)
switch(param->recfgType) {
case RGR_LCG_CFG:
#endif
{
- TRC3(cmUnpkRgrRecfg)
CMCHKUNPK(oduPackUInt8, ¶m->recfgType, mBuf);
switch(param->recfgType) {
#endif
{
- TRC3(cmPkRgrDel)
switch(param->delType) {
case RGR_LCG_CFG:
#endif
{
- TRC3(cmUnpkRgrDel)
CMCHKUNPK(oduPackUInt8, ¶m->delType, mBuf);
switch(param->delType) {
#endif
{
S32 count;
- TRC3(cmPkRgrPrbCfg)
for(count = RGR_SCH_MAX_PA_PER_PRB - 1; count >= 0; count --)
{
CMCHKPK(oduUnpackUInt32, param->paLevelPerPrb[count], mBuf);
#endif
{
S32 count;
- TRC3(cmUnpkRgrSonPrbCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isSonIcicEnable, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numCellEdgeUEs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numCellCentreUEs, mBuf);
#endif
{
- TRC3(cmPkRgrSonCfg)
switch(param->cfgType)
{
case RGR_SON_PRB_CFG :
#endif
{
- TRC3(cmUnpkRgrSonCfg)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->cfgType, mBuf);
switch(param->cfgType)
{
#endif
{
- TRC3(cmPkRgrRst)
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#endif
{
- TRC3(cmUnpkRgrRst)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnPkRgrSCellActDeactInfo)
CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- TRC3(cmUnPkRgrSCellActDeactEvnt)
U8 idx;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrSCellActDeactInfo)
CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
#endif
{
- TRC3(cmPkRgrSCellActDeactEvnt)
S8 idx;
for(idx = param->numOfSCells - 1; idx >= 0; idx--)
#endif
{
- TRC3(cmPkRgrCfgReqInfo)
switch(param->action) {
case RGR_SON_CFG:
#endif
{
- TRC3(cmUnpkRgrCfgReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
switch(param->action) {
#endif
{
- TRC3(cmPkRgrUeBsrTmrCfg)
CMCHKPK(oduUnpackUInt16, param->prdBsrTmr, mBuf);
CMCHKPK(oduUnpackUInt16, param->retxBsrTmr, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeBsrTmrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isPrdBsrTmrPres, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->retxBsrTmr, mBuf);
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrSiCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
RgrCfgTransId transId;
RgrSiCfgReqInfo *cfgReqInfo;
- TRC3(cmUnpkRgrSiCfgReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
SPutMsg(mBuf);
return RFAILED;
}
- cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
+ memset(cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
/* ccpu00111328: S16 is renamed as MsgLen */
MsgLen msgLen;
- TRC3(cmPkRgrSiCfgReqInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(SPkS32, param->cfgType, mBuf);
/*Merge from Mohit Changes*/
S32 cfgType;
- TRC3(cmUnpkRgrSiCfgReqInfo)
SFndLenMsg(mBuf, &msgLen);
if(msgLen > 0)
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrWarningSiCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
RgrCfgTransId transId;
RgrWarningSiCfgReqInfo *warningSiCfgReqInfo;
- TRC3(cmUnpkRgrWarningSiCfgReq)
if (SUnpkS16(&spId, mBuf) != ROK)
{
CmLList *node, *prevNode;
RgrSegmentInfo *pdu;
- TRC3(cmPkRgrWarningSiCfgReqInfo)
CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
Buffer *pdu;
CmLList *node;
- TRC3(cmUnpkRgrWarningSiCfgReqInfo)
cmLListInit(¶m->siPduLst);
CMCHKUNPK(oduPackUInt32, &count, mBuf);
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrWarningSiStopReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
U8 siId;
RgrCfgTransId transId;
- TRC3(cmUnpkRgrWarningSiStopReq)
if (SUnpkS16(&spId, mBuf) != ROK)
{
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrWarningSiCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
RgrCfgTransId transId;
U8 status;
- TRC3(cmUnpkRgrWarningSiCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK)
{
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrLoadInfReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
RgrCfgTransId transId;
RgrLoadInfReqInfo *loadInfReq;
- TRC3(cmUnpkRgrLoadInfReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
return RFAILED;
}
- cmMemset((U8 *)loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
+ memset(loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrLoadInfReqInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(oduUnpackUInt8, param->rgrCcPHighStartRb, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrLoadInfReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rgrCcPHighEndRb, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rgrCcPHighStartRb, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrUeCqiReptCfg)
CMCHKPK(oduUnpackUInt8, param->numColltdCqiRept, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrUeCqiReptCfg)
CMCHKUNPK(oduPackUInt8, ¶m->numColltdCqiRept, mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SuId suId;
RgrStaIndInfo *staInd;
- TRC3(cmUnpkRgrStaInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
#endif
{
- TRC3(cmPkRgrStaIndInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
#endif
{
- TRC3(cmUnpkRgrStaIndInfo)
CMCHKUNPK(cmUnpkRgrUeCqiInfo, ¶m->ueCqiInfo, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
{
S16 idx;
- TRC3(cmPkRgrUeCqiInfo)
for (idx = param->numCqiRept - 1; idx >= 0; idx--)
{
{
U8 idx;
- TRC3(cmUnpkRgrUeCqiInfo)
CMCHKUNPK(oduPackUInt8, ¶m->numCqiRept, mBuf);
for (idx = 0; idx < param->numCqiRept; idx++)
#endif
{
- TRC3(cmPkRgrSubBandCqiInfo)
CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
S8 idx;
U8 count;
- TRC3(cmPkRgrUeCqiRept)
CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
#endif
{
- TRC3(cmUnpkRgrSubBandCqiInfo)
CMCHKUNPK(oduPackUInt8, ¶m->subBandIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqi[1], mBuf);
{
U8 idx;
- TRC3(cmUnpkRgrUeCqiRept)
CMCHKUNPK(oduPackUInt8, ¶m->numSubBand, mBuf);
for (idx = 0; idx < param->numSubBand; idx++)
{
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrLoadInfInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SuId suId;
RgrLoadInfIndInfo *loadInfInd = NULLP; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
- TRC3(cmUnpkRgrLoadInfInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
#endif
{
U8 idx;
- TRC3(cmPkRgrLoadInfIndInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(oduUnpackUInt16, param->bw, mBuf);
TknStrOSXL *tknStr;
U16 ndx;
- TRC3(cmUnpkRgrLoadInfIndInfo)
CMCHKUNPK(oduPackUInt32, ¶m->type, mBuf);
if(RGR_ABS == param->type)
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrUepACfg)
if(param->pAPrsnt)
{
#endif
{
U32 tmpEnum;
- TRC3(cmUnpkRgrUepACfg)
CMCHKUNPK(oduPackUInt8, (U8 *)¶m->pAPrsnt, mBuf);
if (param->pAPrsnt)
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrUePdschDedCfg)
CMCHKPK(cmPkRgrUepACfg, ¶m->uepACfg, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgrUePdschDedCfg)
CMCHKUNPK(cmUnpkRgrUepACfg, ¶m->uepACfg, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrUeUlPwrDedSCellCfg)
CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
CMCHKPK(SPkS8, param->p0UePusch, mBuf);
CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeUlPwrDedSCellCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isAccumulated, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isDeltaMCSEnabled, mBuf);
#endif
{
S8 idx;
- TRC3(cmPkRgrUeSCellAckPucchCfg);
if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
{
{
U8 idx;
- TRC3(cmUnpkRgrUeSCellAckPucchCfg);
CMCHKUNPK(oduPackUInt32, (U32*)¶m->pucchFormatType, mBuf);
//if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrUeStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
RgrUeStaIndInfo *ueStaInd;
- TRC3(cmUnpkRgrUeStaInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
#endif
{
- TRC3(cmPkRgrUeStaIndInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeStaIndInfo)
CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
{
- TRC3(cmPkRgrCellCsgParamCfg)
CMCHKPK(oduUnpackUInt8, param->minUlResNonCsg, mBuf);
CMCHKPK(oduUnpackUInt8, param->minDlResNonCsg, mBuf);
#endif
{
- TRC3(cmUnpkRgrCellCsgParamCfg)
CMCHKUNPK(oduPackUInt8, ¶m->minDlResNonCsg, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->minUlResNonCsg, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrCellCntrlCmdCfg)
switch(param->cmdType)
{
{
U32 tmpEnum;
- TRC3(cmUnpkRgrCellCntrlCmdCfg)
CMCHKUNPK(oduPackUInt32, &tmpEnum, mBuf);
param->cmdType = (RgrCellCntrlCmdType) tmpEnum;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRguBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
SpId spId;
- TRC3(cmUnpkRguBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRguUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
Reason reason;
- TRC3(cmUnpkRguUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRguBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
U8 status;
- TRC3(cmUnpkRguBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
S32 loop;
- TRC3(cmPkRguL2MUlThrpMeasReqInfo);
CMCHKPK(oduUnpackUInt8, param->enbMeas, mBuf);
for (loop=param->numLcId-1; loop >= 0; loop--)
#endif
{
U8 loop;
- TRC3(cmUnpkRguL2MUlThrpMeasReqInfo);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRguL2MUlThrpMeasReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
RguL2MUlThrpMeasReqInfo* measReq;
- TRC3(cmUnpkRguL2MUlThrpMeasReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
U8 idx;
RguHarqStatusInd *harqStaInd = NULL;
- TRC3(cmPkRguHqStaInd)
#ifdef XEON_SPECIFIC_CHANGES
if (SGetSBuf(pst->region, pst->pool, (Data **)&harqStaInd, sizeof(RguHarqStatusInd)) != ROK)
#else
return RFAILED;
}
- cmMemcpy((U8 *)harqStaInd, (U8 *)harqStatusInd, sizeof(RguHarqStatusInd));
+ memcpy(harqStaInd, harqStatusInd, sizeof(RguHarqStatusInd));
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
U8 idx;
- TRC3(cmUnpkRguHqStaInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
Buffer *mBuf;
#endif
{
- TRC3(cmPkRguLcFlowCntrlInfo);
CMCHKPK(oduUnpackUInt32, param->maxBo4FlowCtrl, mBuf);
CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
{
U32 idx;
- TRC3(cmPkRguUeFlowCntrlInfo);
for(idx=(param->numLcs - 1); idx >= 0; idx--)
{
{
U32 idx;
- TRC3(cmPkRguFlowCntrlInfo);
for (idx=(param->numUes - 1); idx >= 0; idx--)
{
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRguFlowCntrlInd);
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRguLcFlowCntrlInfo);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
#endif
{
U32 idx;
- TRC3(cmUnpkRguUeFlowCntrlInfo);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numLcs, mBuf);
for(idx=0; idx < param->numLcs; idx++)
{
U32 idx;
- TRC3(cmUnpkRguFlowCntrlInfo);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numUes, mBuf);
SuId suId;
RguFlowCntrlInd *flowCntrlInd;
- TRC3(cmUnpkRguFlowCntrlInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
S32 i;
- TRC3(cmPkRguPduInfo);
for (i=param->numPdu-1; i >= 0; i--) {
/* rgu_c_001.main_3: ccpu00111328: S16 is renamed as MsgLen */
{
S32 i;
- TRC3(cmUnpkRguPduInfo);
CMCHKUNPK(oduPackUInt8, ¶m->numPdu, mBuf);
for (i=0; i<param->numPdu; i++) {
#endif
{
- TRC3(cmPkRguDBoReport);
CMCHKPK(oduUnpackUInt32, param->oldestSduArrTime, mBuf);
CMCHKPK(oduUnpackUInt32, param->staPduBo, mBuf);
#endif
{
- TRC3(cmUnpkRguDBoReport);
CMCHKUNPK(SUnpkS32, ¶m->bo, mBuf);
#ifdef CCPU_OPT
{
MsgLen msgLen;
- TRC3(cmPkRguCDatReqInfo);
if (param->pdu != NULLP)
{
{
MsgLen msgLen, totalMsgLen;
- TRC3(cmUnpkRguCDatReqInfo);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
#endif
{
- TRC3(cmPkRguLchDatReq);
#ifdef L2_OPTMZ
CMCHKPK(oduUnpackUInt8, param->freeBuff, mBuf);
#endif
{
- TRC3(cmUnpkRguLchDatReq);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkRguDBoReport, ¶m->boReport, mBuf);
{
S32 i;
- TRC3(cmPkRguDatReqTb);
/*rgu_c_001.main_5 - ADD - L2M Support */
#ifdef LTE_L2_MEAS
CMCHKPK(oduUnpackUInt32, param->tbId, mBuf);
{
S32 i;
- TRC3(cmUnpkRguDatReqTb);
CMCHKUNPK(oduPackUInt8, ¶m->nmbLch, mBuf);
for (i=0; i<param->nmbLch; i++) {
S32 i;
S32 idx;
- TRC3(cmPkRguDDatReqInfo);
for(idx = (param->nmbOfUeGrantPerTti-1); idx >= 0; idx--)
{
#endif
S32 idx;
- TRC3(cmUnpkRguDDatReqInfo);
/* After Merging from 2.1 to 2.2 */
/*rgu_c_001.main_5 - ADD - L2M Support */
{
MsgLen msgLen;
- TRC3(cmPkRguCDatIndInfo);
if (SFndLenMsg(param->pdu, &msgLen) != ROK)
return RFAILED;
{
MsgLen msgLen, totalMsgLen;
- TRC3(cmUnpkRguCDatIndInfo);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRguLchDatInd);
CMCHKPK(cmPkRguPduInfo, ¶m->pdu, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRguLchDatInd);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkRguPduInfo, ¶m->pdu, mBuf);
#endif
{
- TRC3(cmPkRguCStaRspInfo);
switch(param->lcType) {
case CM_LTE_LCH_CCCH:
#endif
{
- TRC3(cmUnpkRguCStaRspInfo);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
#endif
{
- TRC3(cmPkRguLchStaInd);
CMCHKPK(SPkS16, param->totBufSize, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
#endif
{
- TRC3(cmUnpkRguLchStaInd);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->totBufSize, mBuf);
{
S32 i;
- TRC3(cmPkRguStaIndTb);
#ifdef LTE_L2_MEAS
CMCHKPK(oduUnpackUInt16, param->status, mBuf);
{
S32 i;
- TRC3(cmUnpkRguStaIndTb);
-
CMCHKUNPK(oduPackUInt8, ¶m->nmbLch, mBuf);
for (i=0; i<param->nmbLch; i++) {
CMCHKUNPK(cmUnpkRguLchStaInd, ¶m->lchStaInd[i], mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
SpId spId;
- TRC3(cmUnpkTfuBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
U8 status;
- TRC3(cmUnpkTfuBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
Reason reason;
- TRC3(cmUnpkTfuUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuSchBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
SpId spId;
- TRC3(cmUnpkTfuSchBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuSchBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
U8 status;
- TRC3(cmUnpkTfuSchBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuSchUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
Reason reason;
- TRC3(cmUnpkTfuSchUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuRaReqInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuRaReqIndInfo *raReqInd;
- TRC3(cmUnpkTfuRaReqInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuRecpReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
TfuRecpReqInfo *recpReq;
- TRC3(cmUnpkTfuRecpReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuUlCqiInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuUlCqiIndInfo *ulCqiInd;
- TRC3(cmUnpkTfuUlCqiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuHqInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
TfuHqIndInfo *hqInd;
- TRC3(cmUnpkTfuHqInd)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuSrInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
TfuSrIndInfo *srInd;
- TRC3(cmUnpkTfuSrInd)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuDlCqiInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuDlCqiIndInfo *dlCqiInd;
- TRC3(cmUnpkTfuDlCqiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuRawCqiInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuRawCqiIndInfo *rawCqiInd;
- TRC3(cmUnpkTfuRawCqiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuSrsInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuSrsIndInfo *srsInd;
- TRC3(cmUnpkTfuSrsInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuDatInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
TfuDatIndInfo *datInd;
- TRC3(cmUnpkTfuDatInd)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuCrcInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuCrcIndInfo *crcIndInfo;
- TRC3(cmUnpkTfuCrcInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuTimingAdvInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuTimingAdvIndInfo *timingAdvInd;
- TRC3(cmUnpkTfuTimingAdvInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuDatReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
TfuDatReqInfo *datReq;
- TRC3(cmUnpkTfuDatReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuCntrlReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SpId spId;
TfuCntrlReqInfo *cntrlReq;
- TRC3(cmUnpkTfuCntrlReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuTtiInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuNonRtInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
{
SuId suId;
- TRC3(cmUnpkTfuNonRtInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuPucchDeltaPwr)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
- TRC3(cmUnpkTfuPucchDeltaPwr)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
- TRC3(cmPkTfuRbAssignA1Val324)
CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
#endif
{
- TRC3(cmPkTfuRbAssignB1Val324)
CMCHKPK(oduUnpackUInt8, param->bmiHqAckNack, mBuf);
CMCHKPK(oduUnpackUInt8, param->RV, mBuf);
#endif
{
- TRC3(cmPkTfuRbAssignVal326)
CMCHKPK(oduUnpackUInt8, param->CyclicShiftInd, mBuf);
CMCHKPK(oduUnpackUInt8, param->OCCInd, mBuf);
#endif
{
- TRC3(cmUnpkTfuRbAssignA1Val324)
CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
#endif
{
- TRC3(cmUnpkTfuRbAssignB1Val324)
CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
#endif
{
- TRC3(cmUnpkTfuRbAssignVal326)
CMCHKUNPK(oduPackUInt8, ¶m->FreqBandIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->OCCInd, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormatA1A2Info)
//printf("5GTF_DBG: cmPkTfuDciFormatA1Info() called by eNB\n");
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormatB1B2Info)
CMCHKPK(oduUnpackUInt8, param->DL_PCRS, mBuf);
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormatA1A2Info)
CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->xPUSCHRange, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormatB1B2Info)
CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->xPDSCHRange, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat0Info)
/* tfu_c_001.main_3: Adding pack for hqProcId */
CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat0Info)
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
{
S32 i;
- TRC3(cmPkTfuAllocMapOrRiv)
switch(param->type) {
/*tfu_c_001.main_7 - ADD - TFU_RESMAP_CHANGE support */
{
S32 i;
- TRC3(cmUnpkTfuAllocMapOrRiv)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
{
S32 i;
- TRC3(cmPkTfuDciFormat1AllocInfo)
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
{
S32 i;
- TRC3(cmUnpkTfuDciFormat1AllocInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
#endif
{
- TRC3(cmPkTfuDciFormat1Info)
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat1Info)
CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, ¶m->allocInfo, mBuf);
{
S32 i;
- TRC3(cmPkTfuDciFormat2AAllocInfo)
CMCHKPK(oduUnpackUInt8, param->transSwap, mBuf);
CMCHKPK(oduUnpackUInt8, param->precoding, mBuf);
{
S32 i;
- TRC3(cmUnpkTfuDciFormat2AAllocInfo)
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
#endif
{
- TRC3(cmPkTfuDciFormat6AAllocInfo)
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat6AAllocInfo)
CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat2AInfo)
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat2AInfo)
CMCHKUNPK(cmUnpkTfuDciFormat2AAllocInfo, ¶m->allocInfo, mBuf);
{
S32 i;
- TRC3(cmPkTfuDciFormat2AllocInfo)
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
{
S32 i;
- TRC3(cmUnpkTfuDciFormat2AllocInfo)
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
#endif
{
- TRC3(cmPkTfuDciFormat2Info)
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
#endif
{
- TRC3(cmUnpkTfuDciFormat2Info)
CMCHKUNPK(cmUnpkTfuDciFormat2AllocInfo, ¶m->allocInfo, mBuf);
{
S32 i;
- TRC3(cmPkTfuDciFormat3Info)
CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
{
S32 i;
- TRC3(cmUnpkTfuDciFormat3Info)
for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
{
S32 i;
- TRC3(cmPkTfuDciFormat3AInfo)
CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->tpcCmd[i], mBuf);
{
S32 i;
- TRC3(cmUnpkTfuDciFormat3AInfo)
for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat60aInfo)
CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
CMCHKPK(oduUnpackUInt8, param->isSrs, mBuf);
#endif
{
- TRC3(cmPkTfuPdcchOrderInfoEmtc)
CMCHKPK(oduUnpackUInt8, param->ceLevel, mBuf);
CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
#endif
{
- TRC3(cmPkTfudciformat61aPdsch)
CMCHKPK(oduUnpackUInt8, param->isTBMsg4, mBuf);
CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat61aInfo)
switch(param->isPdcchOrder) {
case FALSE:
#endif
{
- TRC3(cmUnpkTfuDciFormat60aInfo)
printf("In cmUnpkTfuDciFormat60aInfo :: Entry \n");
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
#endif
{
- TRC3(cmUnpkTfuPdcchOrderInfoEmtc)
printf("In cmUnpkTfuPdcchOrderInfoEmtc :: Entry \n");
CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat61aInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
printf("1. cmUnpkTfuDciFormat61aInfo :: isPdcchOrder %d \n", param->isPdcchOrder);
#endif
{
- TRC3(cmPkTfuDciFormat1dAllocInfo)
CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat1dAllocInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat1dInfo)
CMCHKPK(oduUnpackUInt8, param->dlPwrOffset, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat1dInfo)
CMCHKUNPK(cmUnpkTfuDciFormat1dAllocInfo, ¶m->allocInfo, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat1cInfo)
CMCHKPK(oduUnpackUInt8, param->iTbs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat1cInfo)
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat1bAllocInfo)
CMCHKPK(oduUnpackUInt8, param->pmiCfm, mBuf);
CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat1bAllocInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
#endif
{
- TRC3(cmPkTfuPdcchOrderInfo)
CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->preambleIdx, mBuf);
#endif
{
- TRC3(cmUnpkTfuPdcchOrderInfo)
CMCHKUNPK(oduPackUInt8, ¶m->preambleIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->prachMaskIdx, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat1aAllocInfo)
CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
CMCHKPK(cmPkTknU8, ¶m->harqProcId, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat1aAllocInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
#endif
{
- TRC3(cmPkTfudciformat1aPdsch)
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#endif
{
- TRC3(cmUnpkTfudciformat1aPdsch)
CMCHKUNPK(cmUnpkTfuDciFormat1aAllocInfo, ¶m->allocInfo, mBuf);
#endif
{
- TRC3(cmUnpkTfudciformat61aPdsch)
printf("1. cmUnpkTfudciformat61aPdsch :: Entry \n");
CMCHKUNPK(cmUnpkTfuDciFormat6AAllocInfo, ¶m->allocInfo, mBuf);
#endif
{
- TRC3(cmUnpkTfuDirectIndication)
CMCHKUNPK(oduPackUInt8, ¶m->directInd, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormat62AllocInfo)
CMCHKUNPK(oduPackUInt8, ¶m->riv, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
#endif
{
- TRC3(cmUnpkTfudciformat62Pdsch)
-
CMCHKUNPK(cmUnpkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->repNum, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat62Info)
CMCHKUNPK(oduPackUInt8, ¶m->isPaging, mBuf);
switch(param->isPaging) {
case FALSE:
#endif
{
- TRC3(cmPkTfuDirectIndication)
CMCHKPK(oduUnpackUInt8, param->directInd, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat6AAllocInfo)
-
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(oduUnpackUInt8, param->riv, mBuf);
#endif
{
- TRC3(cmPkTfudciformat62Pdsch)
CMCHKPK(oduUnpackUInt8, param->dciSubRepNum, mBuf);
CMCHKPK(oduUnpackUInt8, param->repNum, mBuf);
CMCHKPK(cmPkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat62Info)
-
switch(param->isPaging) {
case TRUE:
CMCHKPK(cmPkTfudciformat62Pdsch, ¶m->t.pdschInfo, mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat1aInfo)
switch(param->isPdcchOrder) {
case FALSE:
#endif
{
- TRC3(cmUnpkTfuDciFormat1aInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
switch(param->isPdcchOrder) {
#endif
{
- TRC3(cmPkTfuDciFormat1bInfo)
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormat1bInfo)
CMCHKUNPK(cmUnpkTfuDciFormat1bAllocInfo, ¶m->allocInfo, mBuf);
#endif
{
- TRC3(cmPkTfuDciInfo)
switch(param->dciFormat) {
#ifdef TFU_5GTF
#endif
{
- TRC3(cmUnpkTfuDciInfo)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->dciFormat, mBuf);
#endif
{
- TRC3(cmPkTfuSubbandInfo)
CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
#endif
{
- TRC3(cmUnpkTfuSubbandInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
#endif
{
- TRC3(cmPkTfuSubbandCqiInfo)
CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subband, mBuf);
#endif
{
- TRC3(cmUnpkTfuSubbandCqiInfo)
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subband, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
#endif
{
- TRC3(cmPkTfuPdcchCceInfo)
CMCHKPK(cmPkLteAggrLvl, param->aggrLvl, mBuf);
CMCHKPK(oduUnpackUInt8, param->cceIdx, mBuf);
#endif
{
- TRC3(cmUnpkTfuPdcchCceInfo)
CMCHKUNPK(oduPackUInt8, ¶m->cceIdx, mBuf);
CMCHKUNPK(cmUnpkLteAggrLvl,(U32 *)¶m->aggrLvl, mBuf);
#endif
{
- TRC3(cmPkTfuCqiPucchMode10)
switch(param->type) {
case TFU_RPT_CQI:
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode10)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
#endif
{
- TRC3(cmPkTfuCqiMode11Cqi)
CMCHKPK(cmPkTknU8, ¶m->wideDiffCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
#endif
{
- TRC3(cmUnpkTfuCqiMode11Cqi)
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
#endif
{
- TRC3(cmPkTfuCqiPucchMode11)
switch(param->type) {
case TFU_RPT_CQI:
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode11)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
#endif
{
- TRC3(cmPkTfuCqiMode20SubCqi)
CMCHKPK(oduUnpackUInt8, param->l, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
#endif
{
- TRC3(cmUnpkTfuCqiMode20SubCqi)
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
#endif
{
- TRC3(cmPkTfuCqiMode20Cqi)
switch(param->isWideband) {
case FALSE:
#endif
{
- TRC3(cmUnpkTfuCqiMode20Cqi)
CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
#endif
{
- TRC3(cmPkTfuCqiPucchMode20)
switch(param->type) {
case TFU_RPT_CQI:
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode20)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
#endif
{
- TRC3(cmPkTfuCqiMode21SubCqi)
CMCHKPK(cmPkTknU8, ¶m->diffCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->l, mBuf);
#endif
{
- TRC3(cmUnpkTfuCqiMode21SubCqi)
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
#endif
{
- TRC3(cmPkTfuCqiMode21WideCqi)
CMCHKPK(cmPkTknU8, ¶m->diffCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
#endif
{
- TRC3(cmUnpkTfuCqiMode21WideCqi)
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
#endif
{
- TRC3(cmPkTfuCqiMode21Cqi)
switch(param->isWideband) {
case FALSE:
#endif
{
- TRC3(cmUnpkTfuCqiMode21Cqi)
CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
#endif
{
- TRC3(cmPkTfuCqiPucchMode21)
switch(param->type) {
case TFU_RPT_CQI:
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode21)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
#endif
{
- TRC3(cmPkTfuDlCqiPucch)
switch(param->mode) {
case TFU_PUCCH_CQI_MODE21:
#endif
{
- TRC3(cmUnpkTfuDlCqiPucch)
CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
#endif
{
- TRC3(cmPkTfuSubbandMode12)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
#endif
{
- TRC3(cmUnpkTfuSubbandMode12)
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode12)
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuSubbandMode12, ¶m->subbandArr[i], mBuf);
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode12)
CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode20)
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode20)
CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode22)
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode22)
for (i=0; i<TFU_MAX_TB; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
#endif
{
- TRC3(cmPkTfuSubbandMode30)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
#endif
{
- TRC3(cmUnpkTfuSubbandMode30)
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode30)
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuSubbandMode30, ¶m->subbandArr[i], mBuf);
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode30)
CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
{
S32 i;
- TRC3(cmPkTfuSubbandMode31)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
{
S32 i;
- TRC3(cmUnpkTfuSubbandMode31)
for (i=0; i<TFU_MAX_TB; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode31)
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode31)
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
#endif
{
- TRC3(cmPkTfuDlCqiPusch)
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_31:
#endif
{
- TRC3(cmUnpkTfuDlCqiPusch)
CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
{
U32 idx;
- TRC3(cmPkTfuDlCqiInfo)
switch(selector) {
case FALSE:
{
U8 idx;
- TRC3(cmUnpkTfuDlCqiInfo)
switch(selector) {
case TRUE:
U32 count;
TfuUeRecpReqInfo *tfuUeRecpReqInfo;
- TRC3(cmPkTfuRecpReqInfo)
/*ccpu00116923 - ADD - SRS present support*/
/*tfu_c_001.main_7 - ADD - SRS present field inclusion */
U32 count, loopCnt;
TfuUeRecpReqInfo *tfuUeRecpReqInfo;
- TRC3(cmUnpkTfuRecpReqInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuPdcchInfo)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
#endif
{
- TRC3(cmUnpkTfuPdcchInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
#ifdef LTEMAC_SPS
#endif
{
- TRC3(cmPkTfuPhichInfo)
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
CMCHKPK(oduUnpackUInt16, param->txPower, mBuf);
#endif
{
- TRC3(cmUnpkTfuPhichInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
CmLList *node;
U32 count;
- TRC3(cmPkTfuCntrlReqInfo)
#ifdef EMTC_ENABLE
count = param->dlMpdcchLst.count;
node = param->dlMpdcchLst.last;
U32 count, loopCnt;
TfuPhichInfo *tfuPhichInfo;
- TRC3(cmUnpkTfuCntrlReqInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->ulTiming, mBuf);
#endif
{
- TRC3(cmPkTfuPdschDciInfo)
switch(param->format) {
#ifdef TFU_5GTF
#endif
{
- TRC3(cmUnpkTfuPdschDciInfo)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->format, mBuf);
switch(param->format) {
#endif
{
S32 idx, idx2;
- TRC3(cmPkTfuBfVectorInfo)
for(idx=TFU_MAX_DL_SUBBAND-1;idx>=0; idx--)
{
for (idx2=param->numPhyAnt -1; idx2 >= 0; idx2--) {
#endif
{
S32 idx, idx2;
- TRC3(cmUnpkTfuBfVectorInfo)
for(idx=0;idx<TFU_MAX_DL_SUBBAND; idx++)
{
CMCHKUNPK(oduPackUInt8, ¶m->sbIndex, mBuf);
U32 lchIdx, pduIdx;
#endif
- TRC3(cmPkTfuDatReqPduInfo)
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKPK(oduUnpackUInt8, param->isEnbSFR, mBuf);
#ifdef L2_OPTMZ
U32 lchIdx, pduIdx;
#endif
- TRC3(cmUnpkTfuDatReqPduInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkTfuPdschDciInfo, ¶m->dciInfo, mBuf);
U32 count;
TfuDatReqPduInfo *tfuDatReqPduInfo;
- TRC3(cmPkTfuDatReqInfo)
count = param->pdus.count;
node = param->pdus.last;
U32 count, loopCnt;
TfuDatReqPduInfo *tfuDatReqPduInfo;
- TRC3(cmUnpkTfuDatReqInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuDatInfo)
CMCHKPK(cmPkBuffer, ¶m->mBuf, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
#endif
{
- TRC3(cmUnpkTfuDatInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->mBuf, mBuf);
U32 count;
TfuDatInfo *tfuDatInfo;
- TRC3(cmPkTfuDatIndInfo)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
U32 count, loopCnt;
TfuDatInfo *tfuDatInfo;
- TRC3(cmUnpkTfuDatIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuSrInfo)
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkTfuSrInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
return ROK;
U32 count;
TfuSrInfo *tfuSrInfo;
- TRC3(cmPkTfuSrIndInfo)
count = param->srLst.count;
node = param->srLst.last;
U32 count, loopCnt;
TfuSrInfo *tfuSrInfo;
- TRC3(cmUnpkTfuSrIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
{
S32 i;
- TRC3(cmPkTfuHqInfo)
CMCHKPK(oduUnpackUInt8, param->isPusch, mBuf);
for (i=TFU_MAX_HARQ_FDBKS-1; i >= 0; i--) {
#endif
{
S32 i;
- TRC3(cmUnpkTfuHqInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
/* ACC-TDD ccpu00130520 */
U32 count;
TfuHqInfo *tfuHqInfo;
- TRC3(cmPkTfuHqIndInfo)
count = param->hqIndLst.count;
node = param->hqIndLst.last;
U32 count, loopCnt;
TfuHqInfo *tfuHqInfo;
- TRC3(cmUnpkTfuHqIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuUlCqiInfo)
CMCHKPK(cmPkTfuSubbandCqiInfo, ¶m->subbandCqi, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkTfuUlCqiInfo)
CMCHKUNPK(cmUnpkTfuSubbandCqiInfo, ¶m->subbandCqi, mBuf);
return ROK;
{
S32 i;
- TRC3(cmPkTfuUlCqiRpt)
for (i=TFU_MAX_UL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuUlCqiInfo, ¶m->ulCqiInfoArr[i], mBuf);
{
S32 i;
- TRC3(cmUnpkTfuUlCqiRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isTxPort0, mBuf);
U32 count;
TfuUlCqiRpt *tfuUlCqiRpt;
- TRC3(cmPkTfuUlCqiIndInfo)
count = param->ulCqiRpt.count;
node = param->ulCqiRpt.last;
U32 count, loopCnt;
TfuUlCqiRpt *tfuUlCqiRpt;
- TRC3(cmUnpkTfuUlCqiIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuDlCqiRpt)
if (cmPkTfuDlCqiInfo(param->isPucchInfo, ¶m->dlCqiInfo, mBuf) != ROK)
return RFAILED;
#endif
{
- TRC3(cmUnpkTfuDlCqiRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isPucchInfo, mBuf);
U32 count;
TfuDlCqiRpt *tfuDlCqiRpt;
- TRC3(cmPkTfuDlCqiIndInfo)
count = param->dlCqiRptsLst.count;
node = param->dlCqiRptsLst.last;
U32 count, loopCnt;
TfuDlCqiRpt *tfuDlCqiRpt;
- TRC3(cmUnpkTfuDlCqiIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuCrcInfo)
CMCHKPK(cmPkTknU8, ¶m->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->isFailure, mBuf);
#endif
{
- TRC3(cmUnpkTfuCrcInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isFailure, mBuf);
U32 count;
TfuCrcInfo *tfuCrcIndInfo;
- TRC3(cmPkTfuCrcIndInfo)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
U32 count, loopCnt;
TfuCrcInfo *tfuCrcIndInfo;
- TRC3(cmUnpkTfuCrcIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuTimingAdvInfo)
CMCHKPK(oduUnpackUInt8, param->timingAdv, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
#endif
{
- TRC3(cmUnpkTfuTimingAdvInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->timingAdv, mBuf);
U32 count;
TfuTimingAdvInfo *tfuTimingAdvInfo;
- TRC3(cmPkTfuTimingAdvIndInfo)
count = param->timingAdvLst.count;
node = param->timingAdvLst.last;
U32 count, loopCnt;
TfuTimingAdvInfo *tfuTimingAdvInfo;
- TRC3(cmUnpkTfuTimingAdvIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuTtiCellInfo)
CMCHKPK(oduUnpackUInt8, param->ulBlankSf, mBuf);
CMCHKPK(oduUnpackUInt8, param->dlBlankSf, mBuf);
{
S32 i;
- TRC3(cmPkTfuTtiIndInfo)
/*CA dev Start*/
for (i=(param->numCells-1); i >= 0; i--) {
#endif
{
- TRC3(cmUnpkTfuTtiCellInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuRaReqInfo)
CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiPres, mBuf);
#endif
{
- TRC3(cmUnpkTfuRaReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rapId, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->ta, mBuf);
{
S32 i;
- TRC3(cmPkTfuRachInfo)
for (i= (param->numRaReqInfo - 1); i >= 0; i--) {
CMCHKPK(cmPkTfuRaReqInfo, &(param->raReqInfoArr[i]), mBuf);
{
S32 i;
- TRC3(cmUnpkTfuRachInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->raRnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numRaReqInfo, mBuf);
{
S32 i;
- TRC3(cmPkTfuRaReqIndInfo)
for (i= (param->nmbOfRaRnti-1); i >= 0; i--)
{
{
S32 i;
- TRC3(cmUnpkTfuRaReqIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuPucchDeltaPwrInfo)
CMCHKPK(SPkS8, param->pucchDeltaPwr, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
#endif
{
- TRC3(cmUnpkTfuPucchDeltaPwrInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pucchDeltaPwr, mBuf);
U32 count;
TfuPucchDeltaPwr *tfuPucchDeltaPwr;
- TRC3(cmPkTfuPucchDeltaPwrIndInfo)
count = param->pucchDeltaPwrLst.count;
node = param->pucchDeltaPwrLst.last;
U32 count, loopCnt;
TfuPucchDeltaPwr *tfuPucchDeltaPwr;
- TRC3(cmUnpkTfuPucchDeltaPwrIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
MsgLen msgLen=0;
- TRC3(cmPkBuffer)
if (SFndLenMsg(*param, &msgLen) != ROK)
return RFAILED;
if (SCatMsg(mBuf, *param, M1M2) != ROK)
#endif
{
MsgLen msgLen=0, totalMsgLen=0;
- TRC3(cmUnpkBuffer)
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
return RFAILED;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuDoaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuDoaIndInfo *doaInd;
- TRC3(cmUnpkTfuDoaInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#endif
{
- TRC3(cmPkTfuDciFormatTbInfo)
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
#endif
{
- TRC3(cmUnpkTfuDciFormatTbInfo)
CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
{
S32 i;
- TRC3(cmPkTfuSubbandDlCqiInfo)
for (i=TFU_MAX_TB-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->cqiIdx[i], mBuf);
{
S32 i;
- TRC3(cmUnpkTfuSubbandDlCqiInfo)
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subband, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
#endif
{
- TRC3(cmPkTfuDlCqiPuschInfo)
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_31:
#endif
{
- TRC3(cmUnpkTfuDlCqiPuschInfo)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
switch(param->mode) {
#endif
{
- TRC3(cmPkTfuDoaRpt)
CMCHKPK(oduUnpackUInt32, param->doa, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
#endif
{
- TRC3(cmUnpkTfuDoaRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->doa, mBuf);
CmLList *node;
U32 count;
TfuDoaRpt *tfuDoaRpt;
- TRC3(cmPkTfuDoaIndInfo)
count = param->doaRpt.count;
node = param->doaRpt.last;
U32 count, loopCnt;
TfuDoaRpt *tfuDoaRpt;
- TRC3(cmUnpkTfuDoaIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
cmLListInit(¶m->doaRpt);
{
S32 i;
- TRC3(cmPkTfuSrsRpt)
CMCHKPK(oduUnpackUInt8, param->wideCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->wideCqiPres, mBuf);
{
S32 i;
- TRC3(cmUnpkTfuSrsRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->dopEst, mBuf);
U32 count;
TfuSrsRpt *tfuSrsRpt;
- TRC3(cmPkTfuSrsIndInfo)
count = param->srsRpt.count;
node = param->srsRpt.last;
U32 count, loopCnt;
TfuSrsRpt *tfuSrsRpt;
- TRC3(cmUnpkTfuSrsIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
- TRC3(cmPkTfuRawCqiRpt)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt32, param->uciPayload, mBuf);
#else
#endif
{
- TRC3(cmUnpkTfuRawCqiRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numBits, mBuf);
TfuRawCqiRpt *tfuRawCqiRpt;
CmLList *node;
- TRC3(cmPkTfuRawCqiIndInfo)
count = param->rawCqiRpt.count;
node = param->rawCqiRpt.last;
U32 count, loopCnt;
TfuRawCqiRpt *tfuRawCqiRpt;
- TRC3(cmUnpkTfuRawCqiIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
{
S32 i;
- TRC3(cmPkTfuUePucchHqRecpInfo)
CMCHKPK(oduUnpackUInt8, param->a, mBuf);
for (i=TFU_MAX_HQ_RES-1; i >= 0; i--) {
{
S32 i;
- TRC3(cmUnpkTfuUePucchHqRecpInfo)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
#endif
{
- TRC3(cmPkTfuUePucchHqRecpInfo)
#ifdef LTE_ADV
S32 idx;
for (idx=(TFU_MAX_HQ_RES-1); idx >= 0; idx--) {
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchHqRecpInfo)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
#endif
{
- TRC3(cmPkTfuUePucchSrRecpInfo)
CMCHKPK(oduUnpackUInt16, param->n1PucchIdx, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkTfuUePucchSrRecpInfo)
CMCHKUNPK(oduPackUInt16, ¶m->n1PucchIdx, mBuf);
return ROK;
#endif
{
- TRC3(cmPkTfuUePucchCqiRecpInfo)
CMCHKPK(oduUnpackUInt8, param->cqiPmiSz, mBuf);
CMCHKPK(oduUnpackUInt16, param->n2PucchIdx, mBuf);
#endif
{
- TRC3(cmUnpkTfuUePucchCqiRecpInfo)
CMCHKUNPK(oduPackUInt16, ¶m->n2PucchIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSz, mBuf);
#endif
{
- TRC3(cmPkTfuUePucchSrsRecpInfo)
CMCHKPK(oduUnpackUInt32, param->srsCyclicShft, mBuf);
CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
#endif
{
- TRC3(cmPkTfuUePucchUciRecpInfo)
CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
CMCHKPK(oduUnpackUInt8, param->pucchIndex, mBuf);
#endif
{
- TRC3(cmUnpkTfuUePucchSrsRecpInfo)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nRrc, mBuf);
#endif
{
- TRC3(cmPkTfuUePucchBsiBriRecpInfo)
CMCHKPK(oduUnpackUInt8, param->briRpt, mBuf);
CMCHKPK(oduUnpackUInt8, param->bsiRpt, mBuf);
#endif
{
- TRC3(cmUnpkTfuUePucchBsiBriRecpInfo)
CMCHKUNPK(oduPackUInt8, ¶m->puschFlag, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
#endif
{
- TRC3(cmUnpkTfuUePucchUciRecpInfo)
CMCHKUNPK(oduPackUInt8, ¶m->numBits, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
#endif
{
- TRC3(cmPkTfuUePucchRecpReq)
#ifdef TFU_5GTF
CMCHKPK(cmPkTfuUePucchBsiBriRecpInfo, ¶m->bsiBriInfo, mBuf);
#endif
{
- TRC3(cmUnpkTfuUePucchRecpReq)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->uciInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchCqiRecpInfo, ¶m->cqiInfo, mBuf);
#endif
{
- TRC3(cmPkTfuUeUlSchRecpInfo)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
CMCHKPK(oduUnpackUInt8, param->uciWoTBFlag, mBuf);
#endif
{
- TRC3(cmUnpkTfuUeUlSchRecpInfo)
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
{
U32 idx = 0;
- TRC3(cmPkTfuUePuschCqiRecpInfo)
CMCHKPK(oduUnpackUInt8, param->riBetaOff, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiBetaOff, mBuf);
{
U32 idx;
- TRC3(cmUnpkTfuUePuschCqiRecpInfo)
CMCHKUNPK(oduPackUInt8, ¶m->reportType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cCNum, mBuf);
#endif
{
- TRC3(cmPkTfuUePuschHqRecpInfo)
#ifdef TFU_TDD
#endif
{
- TRC3(cmUnpkTfuUePuschHqRecpInfo)
CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqBetaOff, mBuf);
#endif
{
- TRC3(cmPkTfuUePuschRecpReq)
CMCHKPK(cmPkTknU8, ¶m->initialNumRbs, mBuf);
CMCHKPK(cmPkTknU8, ¶m->initialNSrs, mBuf);
#endif
{
- TRC3(cmUnpkTfuUePuschRecpReq)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->rcpInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUeUlSchRecpInfo, ¶m->ulSchInfo, mBuf);
#endif
{
- TRC3(cmPkTfuUeRecpReqInfo)
switch(param->type) {
case TFU_RECP_REQ_PUSCH:
#endif
{
- TRC3(cmUnpkTfuUeRecpReqInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
#ifdef TFU_5GTF
#ifdef TFU_TDD
S32 i;
#endif
- TRC3(cmPkTfuUePucchRecpReq)
#ifdef TFU_TDD
#ifdef TFU_TDD
S32 i;
#endif
- TRC3(cmUnpkTfuUePucchRecpReq)
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqType, mBuf);
switch(param->hqType) {
#endif
{
- TRC3(cmPkTfuUeMsg3RecpReq)
CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
#endif
{
- TRC3(cmUnpkTfuUeMsg3RecpReq)
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
#endif
{
- TRC3(cmPkTfuUePuschRecpReq)
CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
#endif
{
- TRC3(cmUnpkTfuUePuschRecpReq)
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
#endif
{
- TRC3(cmPkTfuUeRecpReqInfo)
switch(param->type) {
case TFU_RECP_REQ_PUSCH:
#endif
{
- TRC3(cmUnpkTfuUeRecpReqInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
#endif
{
- TRC3(cmPkTfuErrIndInfo)
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#endif
{
- TRC3(cmUnpkTfuErrIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuErrInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SuId suId;
TfuErrIndInfo *errInd;
- TRC3(cmUnpkTfuErrInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as UPER */
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as UPER */
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
{
/* encode DL-CCCH message into RRC Container */
xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
/* Encode results */
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as UPER */
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
_ret = SGetSBuf(CU_APP_MEM_REG, CU_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
- cmMemset((U8*)_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
else \
_datPtr = NULLP; \
}
S16 egtpActvInit()
{
DU_LOG("\n\nEGTP : Initializing");
- cmMemset ((U8 *)&egtpCb, 0, sizeof(EgtpGlobalCb));
+ memset (&egtpCb, 0, sizeof(EgtpGlobalCb));
protType = CM_INET_PROTO_UDP;
return ROK;
}
{
U8 ret;
- cmMemcpy((U8 *)&egtpCb.egtpCfg, (U8 *)&cuCfgParams.egtpParams, (PTR)sizeof(EgtpParams));
+ memcpy(&egtpCb.egtpCfg, &cuCfgParams.egtpParams, sizeof(EgtpParams));
egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
}
- cmMemset((U8 *)teidCb, 0, sizeof(EgtpTeIdCb));
+ memset(teidCb, 0, sizeof(EgtpTeIdCb));
teidCb->teId = tnlEvt.lclTeid;
teidCb->remTeId = tnlEvt.remTeid;
egtpCb.dstCb.numTunn++;
/* Encoding pre-defined header */
- cmMemset((U8*)&preDefHdr, 0, sizeof(EgtpMsgHdr));
+ memset(&preDefHdr, 0, sizeof(EgtpMsgHdr));
preDefHdr.msgType = EGTPU_MSG_GPDU;
preDefHdr.teId = teidCb->remTeId;
preDefHdr.extHdr.pdcpNmb.pres = FALSE;
mLen = 0;
ODU_GET_MSG_LEN(mBuf, &mLen);
- cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
+ memset(&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
/* initialize locals */
cnt = 0;
- cmMemset(revPkArray, 0, CM_IPV4_HDRLEN);
- cmMemset(pkArray, 0, CM_IPV4_HDRLEN);
+ memset(revPkArray, 0, CM_IPV4_HDRLEN);
+ memset(pkArray, 0, CM_IPV4_HDRLEN);
/* Pack Header Version */
pkArray[cnt++] = ipv4Hdr.hdrVer;
Pst pst;
Buffer *mBuf;
- memset((uint8_t *)&duCfgParam, 0, sizeof(DuCfgParams));
+ memset(&duCfgParam, 0, sizeof(DuCfgParams));
//Read configs into duCfgParams
if(readCfg() != ROK)
{
}
//Fill pst structure
- memset((uint8_t *)&(pst), 0, sizeof(Pst));
+ memset(&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTDUAPP;
pst.srcInst = (Inst)DU_INST;
pst.srcProcId = DU_PROC;
/* Prints the Msg formed */
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
encBuf);
/* Prints the Msg formed */
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
encBuf);
}
/* Prints the Msg formed */
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
encBuf);
{
DU_LOG("\n\nEGTP : Initializing");
- memset ((uint8_t *)&egtpCb, 0, sizeof(EgtpGlobalCb));
+ memset (&egtpCb, 0, sizeof(EgtpGlobalCb));
protType = CM_INET_PROTO_UDP;
return ROK;
Pst rspPst; /* Response Pst structure */
CmStatus cfgCfm; /* Configuration Confirm */
- memcpy((uint8_t *)&egtpCb.egtpCfg, (uint8_t *)&egtpCfg, (PTR)sizeof(EgtpConfig));
+ memcpy(&egtpCb.egtpCfg, &egtpCfg, sizeof(EgtpConfig));
egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
uint8_t egtpFillRspPst(Pst *pst, Pst *rspPst)
{
- memset((uint8_t *)rspPst, 0, sizeof(Pst));
+ memset(rspPst, 0, sizeof(Pst));
rspPst->srcEnt = pst->dstEnt;
rspPst->srcInst = pst->dstInst;
rspPst->srcProcId = pst->dstProcId;
return LCM_REASON_MEM_NOAVAIL;
}
- memset((uint8_t *)teidCb, 0, sizeof(EgtpTeIdCb));
+ memset(teidCb, 0, sizeof(EgtpTeIdCb));
teidCb->teId = tnlEvt.lclTeid;
teidCb->remTeId = tnlEvt.remTeid;
egtpCb.dstCb.numTunn++;
/* Encoding pre-defined header */
- memset((uint8_t*)&preDefHdr, 0, sizeof(EgtpMsgHdr));
+ memset(&preDefHdr, 0, sizeof(EgtpMsgHdr));
preDefHdr.msgType = EGTPU_MSG_GPDU;
preDefHdr.teId = teidCb->remTeId;
preDefHdr.extHdr.pdcpNmb.pres = FALSE;
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
/* Encode the DU Config Update type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
/* encode cellGrpCfg into duToCuRrcContainer */
xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
/* Encode results */
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
/* Encode results */
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the UE context setup response type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as UPER */
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the RRC DELIVERY REPORT type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
#define MAC_CONFIGURED (MAC_GEN_CFG | MAC_SAP_CFG)
#define DU_SET_ZERO(_buf, _size) \
- memset((uint8_t *)(_buf), 0, _size);
+ memset((_buf), 0, _size);
typedef enum
{
{
RlcCntrl *cntrl = NULLP;
RlcMngmt rlcMngmt;
- Pst pst;
+ Pst pst;
- TRC2(smBindKwToRguSap)
- DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
+ DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
DU_SET_ZERO(&pst, sizeof(Pst));
if (action == ABND)
* ****************************************************************/
uint8_t duFillEgtpPst(Pst *pst, Event event)
{
- memset((uint8_t *)pst, 0, sizeof(Pst));
+ memset(pst, 0, sizeof(Pst));
pst->srcEnt = (Ent)ENTDUAPP;
pst->srcInst = (Inst)DU_INST;
pst->srcProcId = DU_PROC;
DU_LOG("\nDU_APP : Sending EGTP config request");
- memset((uint8_t *)&egtpCfg, 0, sizeof(EgtpConfig));
- memcpy((uint8_t *)&egtpCfg, (uint8_t *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig));
+ memset(&egtpCfg, 0, sizeof(EgtpConfig));
+ memcpy(&egtpCfg, &duCfgParam.egtpParams, sizeof(EgtpConfig));
duFillEgtpPst(&pst, EVTCFGREQ);
packEgtpCfgReq(&pst, egtpCfg);
mLen = 0;
ODU_GET_MSG_LEN(mBuf, &mLen);
- memset((uint8_t *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
+ memset(&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
f1Params.itfState = DU_SCTP_DOWN;
f1Params.srcPort = sctpCfg.duPort[F1_INTERFACE];
f1Params.recvMsgSet = ROK;
- memset ((uint8_t *)&f1Params.sockFd, -1, sizeof(CmInetFd));
+ memset (&f1Params.sockFd, -1, sizeof(CmInetFd));
fillDestNetAddr(&f1Params.destIpNetAddr, &f1Params.destIpAddr);
fillAddrLst(&f1Params.destAddrLst, &f1Params.destIpAddr);
ricParams.itfState = DU_SCTP_DOWN;
ricParams.srcPort = sctpCfg.duPort[E2_INTERFACE];
ricParams.recvMsgSet = ROK;
- memset ((uint8_t *)&ricParams.sockFd, -1, sizeof(CmInetFd));
+ memset (&ricParams.sockFd, -1, sizeof(CmInetFd));
fillDestNetAddr(&ricParams.destIpNetAddr, &ricParams.destIpAddr);
fillAddrLst(&ricParams.destAddrLst, &ricParams.destIpAddr);
printf("\nDU_APP : Failed to allocate memory");
return RFAILED;
}
- memset((uint8_t *)pst, 0, sizeof(Pst));
+ memset(pst, 0, sizeof(Pst));
pst->srcEnt = (Ent)ENTDUAPP;
pst->srcInst = (Inst)DU_INST;
pst->srcProcId = DU_PROC;
ODU_PRINT_MSG(mBuf, 0, 0);
- memset((uint8_t *)&(pst), 0, sizeof(Pst));
+ memset(&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTSCTP;
pst.srcInst = (Inst)SCTP_INST;
pst.srcProcId = DU_PROC;
/* Pack notification and send to APP */
DU_LOG("\nSCTP : Forwarding received message to duApp");
- memset((uint8_t *)&(pst), 0, sizeof(Pst));
+ memset(&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTSCTP;
pst.srcInst = (Inst)SCTP_INST;
pst.srcProcId = DU_PROC;
break;
}
xer_fprint(stdout, &asn_DEF_BCCH_BCH_Message, bcchMsg);
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_BCCH_BCH_Message, 0,
bcchMsg, PrepFinalEncBuf, encBuf);
break;
}
xer_fprint(stdout, &asn_DEF_MIB, mibMsg);
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_MIB, 0,
mibMsg, PrepFinalEncBuf, encBuf);
xer_fprint(stdout, &asn_DEF_SIB1, sib1Msg);
/* Encode the F1SetupRequest type as APER */
- memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_SIB1, 0, sib1Msg, PrepFinalEncBuf,\
encBuf);
_ret = SGetSBuf(DU_APP_MEM_REGION, DU_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
- memset((uint8_t*)_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
else \
_datPtr = NULLP; \
}
if(SGetStaticBuffer(DU_APP_MEM_REGION, DU_POOL, \
(Data **)&_buf, (Size) _size, 0) == ROK) \
{ \
- memset((uint8_t *)(_buf), 0, _size); \
+ memset((_buf), 0, _size); \
} \
else \
{ \
char **argv; /* argument vector */
#endif
{
- TRC0(main);
#ifdef XEON_MULTIPLE_CELL_CHANGES
/* Read the WLS parameters from the file and copy into global control block */
char **argv; /* argument vector */
#endif
{
- TRC0(ssMain);
msArgc = argc;
struct sigaction sa;
#endif
- TRC0(ssdInitGen);
/*mt014.301 : 4GMX release related changes*/
#ifdef SS_4GMX_UCORE
Void ssdDeinitGen()
#endif
{
- TRC0(ssdDeinitGen);
sem_destroy(&osCp.dep.ssStarted);
CmMmBlkSetElement *globMemNode;
S16 lockRet = 0;
- TRC1(ssPutDynMemBlkSet);
globReg = osCp.globRegCb;
CmMmBlkSetElement *globMemNode;
S16 lockRet = 0;
- TRC1(ssGetDynMemBlkSet);
globReg = osCp.globRegCb;
CmMmGlobRegCb *globReg;
CmMmGlobalBktCb *bktCb;
U8 bktIdx= reg;
- TRC3(isMemThreshReached)
globReg = osCp.globRegCb;
#endif
#endif /* SS_LOCKLESS_MEMORY */
- TRC0(ssdInitMem);
/* Use the default SSI memory manager if the ICC memory manager is not
* avilable. If ICC memory manager is avilable, it will be used for
/* mt018.201 - added local variables */
U8 i;
- TRC0(ssdDeinitMem);
/* mt008.301 Additions */
#ifdef SS_MEM_LEAK_STS
cmDeinitMemLeakMdl();
U32 tskInd = 0;
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT */
- TRC0(ssdInitTsk);
/*mt013.301 :Added SS_AFFINITY_SUPPORT */
Void ssdDeinitTsk()
#endif
{
- TRC0(ssdDeinitTsk);
RETVOID;
}
pthread_attr_t attr;
#endif
- TRC0(ssdInitDrvr);
/* initialize the dependent portion of the driver task entries */
Void ssdDeinitDrvr()
#endif
{
- TRC0(ssdDeinitDrvr);
/* mt008.301: Terminate the Driver Task on exit */
while(pthread_cancel(osCp.dep.isTskHdlrTID));
U32 threadCreated = FALSE;
#endif /* SS_THR_REG_MAP */
- TRC0(ssdInitTmr);
osCp.dep.tmrTqCp.tmrLen = SS_MAX_TMRS;
S16 ret;
#endif /* SS_MULTICORE_SUPPORT */
- TRC0(ssdDeinitTmr);
#ifdef SS_MULTICORE_SUPPORT
ret = SLock(&osCp.sTskTblLock);
#endif /* CONAVL */
/* mt008.301: ssdInitFinal changed to ssdInitLog */
- TRC0(ssdInitLog);
#ifdef CONAVL
#endif
{
/* mt008.301: ssdDeinitFinal changed to ssdDeinitLog */
- TRC0(ssdDeinitLog);
#ifdef CONAVL
#ifndef CONRD
/* mt008.301: Terminate the console reader on exit */
}
#endif /* SS_MULTIPLE_PROCS */
- TRC0(ssdInitWatchDog);
SInitLock(&osCp.wdCp.wdLock, SS_LOCK_MUTEX);
Pst *pst;
#endif
{
- TRC1(ssInitWatchDgPst);
pst->selector = SS_LOOSE_COUPLING;
#endif
#endif /* SS_MULTIPLE_PROCS */
{
- TRC3(ssWatchDgActvTmr);
cmPrcTmr(&osCp.wdCp.watchDgTqCp, osCp.wdCp.watchDgTs, (PFV)ssdWatchDgTmrEvt);
Bool restartTmr;
int i;
- TRC2(ssWatchDgTmrEvt);
switch(event)
{
#endif
- TRC2(ssStartWatchDgTmr)
/* mt003.301 Modifications */
#ifdef DEBUGP
SGetDateTime(&dt);
int i;
#endif
- TRC2(ssStopWatchDgTmr)
/* mt003.301 Modifications */
#ifdef DEBUGP
SGetDateTime(&dt);
int n;
int err;
- TRC2(ssdSndHrtBtReq)
#ifdef DEBUGP
SGetDateTime(&dt);
Cntr idx=0;
#endif
- TRC0(mtGetOpts);
msOptInd = 1;
S8 *cp;
#endif
- TRC1(SGetOpt);
/* mt020.201 - Addition for no command line */
#ifdef NOCMDLINE
S16 i;
- TRC0(ssdStart);
/* mt025.201 - Modification for adding lock to timer handler */
SsMsgInfo *mInfo;
S16 ret;
-
- TRC0(ssdAttachTTsk);
-
-
if (tTsk->tskType == SS_TSK_PERMANENT)
{
/* Send a permanent tick message to this task, to start
SsTTskEntry *tTsk; /* pointer to TAPA task entry */
#endif
{
- TRC0(ssdDetachTTsk);
-
return ROK;
}
U32 threadCreated = FALSE;
#endif
- TRC0(ssdCreateSTsk);
#ifdef SS_SINGLE_THREADED
threadArg->argument = arg;
threadArg->start_routine = start_routine;
- TRC0(SCreatePThread);
printf("Creating thread here %s %d\n", __FILE__, __LINE__);
{
{
struct sched_param param;
- TRC0 (ssdSetPthreadAttr)
SMemSet(¶m, 0, sizeof(param));
U32 lwpId = *tskId;
#endif /*SUNOS*/
#endif /*SS_LINUX*/
- TRC0(ssdGetAffinity);
#ifdef SS_LINUX
for (tskInd = 0; tskInd < SS_MAX_STSKS; tskInd++)
{
#endif /*SUNOS*/
#endif /*SS_LINUX*/
- TRC0(ssdSetAffinity)
#ifdef SS_LINUX
for (tskInd = 0; tskInd < SS_MAX_STSKS; tskInd++)
SsMsgInfo *mInfo;
- TRC0(ssdDestroySTsk);
/* we send a message to this system task to tell it to die */
#endif
{
- TRC0(SThreadYield);
/* mt024.201 - seperated Linux and other UNIX implementations
*/
CmTmrArg arg;
- TRC0(ssdRegTmr);
/* initialize common timers */
CmTmrArg arg;
- TRC0(ssdDeregTmr);
/* stop the timer */
Txt errBuf[256];
- TRC0(ssdError);
/* get calling task ID */
Txt errBuf[512];
- TRC0(ssdLogError);
/* get calling task ID */
SsDrvrTskEntry *drvrTsk; /* driver task entry */
#endif
{
- TRC0(ssdRegDrvrTsk);
return ROK;
SsDrvrTskEntry *drvrTsk; /* driver task entry */
#endif
{
- TRC0(ssdDeregDrvrTsk);
return ROK;
S16 n;
S16 ret;
- TRC0(ssdProcTTskTerm);
ent = tTsk->ent;
#endif
#endif
- TRC0(mtTimeout);
/* get the timer entry */
#endif
MtIsFlag isFlag;
-
- TRC0(mtIsTskHdlr);
-
-
for (; ;)
{
if (read(osCp.dep.isFildes[0], &isFlag, sizeof(isFlag)) != sizeof(isFlag))
#endif
{
- TRC0(mtIntSigHndlr);
-
osCp.dep.sigEvnt=TRUE;
#ifdef MSPD
S8 buf[128];
- TRC0(mtExitClnup);
-
SGetSysTime(&ticks);
#ifdef ALIGN_64BIT
sprintf(buf, "\n\nmtss(posix) ends\nticks: %u\n", ticks);
Txt *buf; /* buffer */
#endif
{
- TRC1(SDisplay);
/* mt020.201 - Fixed typo */
#if (ERRCLASS & ERRCLS_INT_PAR)
S16 SFini()
#endif
{
- TRC1(SFini);
/* mt030.201 added under compilet time flag SS_LINUX and SLES9_PLUS
a loop to overcome the child processes being killed upon exiting the
REG1 DateTime *dt; /* date and time */
#endif
{
- TRC1(SSetDateTime);
-
UNUSED(dt);
struct tm tme;
- TRC1(SGetDateTime);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (dt == NULLP)
struct timeval ptime;
#endif
- TRC1(SEpcTime);
#if (ERRCLASS & ERRCLS_INT_PAR)
Ticks *sysTime; /* system time */
#endif
{
- TRC1(SGetSysTime);
#if (ERRCLASS & ERRCLS_INT_PAR)
struct timeval ptime;
#endif
- TRC1(SGetSysTime);
#ifndef SS_LINUX
clock_gettime(CLOCK_REALTIME, &ptime);
Random *value; /* random number */
#endif
{
- TRC1(SRandom);
#if (ERRCLASS & ERRCLS_INT_PAR)
S16 SExitTsk()
#endif
{
- TRC1(SExitTsk);
return ROK;
S16 SExitInt()
#endif
{
- TRC1(SExitInt);
return ROK;
S16 SHoldInt()
#endif
{
- TRC1(SHoldInt);
return ROK;
S16 SRelInt()
#endif
{
- TRC1(SRelInt);
return ROK;
INLINE S16 SEnbInt()
#endif
{
- TRC1(SEnbInt);
return ROK;
INLINE S16 SDisInt()
#endif
{
- TRC1(SDisInt);
return ROK;
PIF *vectFnct; /* vector function */
#endif
{
- TRC1(SGetVect);
UNUSED(vectNmb);
PIF vectFnct; /* vector function */
#endif
{
- TRC1(SPutVect);
UNUSED(vectNmb);
SsSTskEntry *sTsk;
- TRC1(SGetEntInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
SsSTskEntry *sTsk;
- TRC1(SSetEntInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
MtIsFlag isFlag;
- TRC1(SSetIntPend);
#if (ERRCLASS & ERRCLS_INT_PAR)
Txt prntBuf[100];
CmMmGlobRegCb *globReg;
- TRC1(SGlobMemInfoShow);
globReg = osCp.globRegCb;
U16 idx;
Txt prntBuf[100];
- TRC1(SRegInfoShow);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region > (SS_MAX_REGS-1) )
{
U32 idx;
- TRC1(SGetRegInfo);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region >= mtMemoCfg.numRegions )
U32 statMemSize;
U32 dynMemSize;
- TRC1(SPrintRegMemStatusInfo);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region >= mtMemoCfg.numRegions )
U32 idx;
U32 cntEnt;
- TRC1(SPrintRegMemStats);
hashListCp = &mtCMMRegCb[region]->hashListCp;
{
Txt prntBuf[150];
- TRC1(SRegMemErrHdlr);
if (errCode == RDBLFREE)
{
U32 blkCnt;
- TRC1(SPrintRegMemProfile);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (region >= mtMemoCfg.numRegions )
S8 time_string[40];
S32 microseconds;
- TRC1(SGetTimeStamp);
#ifndef SS_LINUX
clock_gettime(CLOCK_REALTIME, &ptime);
U32 SGetSystemTsk()
#endif
{
- TRC1(SGetSystemTskS);
return (pthread_self());
SsSTskEntry *sTsk;
S16 ret;
- TRC1(ssdAddTmrSTsk);
sTsk = NULLP;
/* lock the system task table */
ret = SLock(&osCp.sTskTblLock);
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdInitLockNew);
switch(lockType)
{
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdLockNew);
switch(lockType)
{
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdUnlockNew);
switch(lockType)
{
Txt prntBuf[PRNTSZE];
S16 retVal = ROK;
- TRC1(ssdDestroyLockNew);
switch(lockType)
{
pthread_attr_t attr;
pthread_t thread;
- TRC1(ssInitRcvWork);
/* set the required attributes */
pthread_attr_init(&attr);
struct timespec ts;
Pst pst;
- TRC1(workRcvTsk);
for (;;)
PRIVATE pthread_t createdThreadIds[SS_MAX_THREAD_CREATE_RETRY];
U32 indx;
- TRC1(ssCheckAndAddMemoryRegionMap);
/* Here 0xFF is considered as invalid region and if the mapping table
* contains 0xFF, that mapping entry is free
)
{
- TRC1(ssCheckAndDelMemoryRegionMap);
/* Raghu To-Do Check with team, is it necessary to acquire lock
* as del and add may go parallel */
SsSTskEntry *sTsk;
S16 ret;
- TRC1(ssdReAddTmrSTsk);
sTsk = NULLP;
/* lock the system task table */
ret = SLock(&osCp.sTskTblLock);
U32 threadCreated = FALSE;
#endif /* SS_THR_REG_MAP */
- TRC0(ssdReInitTmr);
#ifndef XEON_SPECIFIC_CHANGES
ret = ssCheckAndDelMemoryRegionMap(osCp.dep.tmrHdlrTID);
#endif
- TRC1(SRegDrvrTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
#endif
{
/* ss002.301 Modifications */
- TRC1(SRegDrvrTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (channel >= SS_MAX_DRVRTSKS)
SsDrvrTskEntry *drvrTsk;
#endif
/* ss002.301 : Modications */
- TRC1(SInit);
osCp.configFilePath = "/mnt/tmp/configFile";
#endif /* SS_MULTIPLE_PROCS */
#ifdef SS_THR_REG_MAP
- cmMemset(osCp.threadMemoryRegionMap, SS_INVALID_THREAD_REG_MAP,
+ memset(osCp.threadMemoryRegionMap, SS_INVALID_THREAD_REG_MAP,
(sizeof(Region) * SS_MAX_THREAD_REGION_MAP));
ssRegMainThread();
#endif
/* ss007.301 */
U16 regCnt;
- TRC1(SDeInit);
-
ssdDeinitTmr();
SDestroyLock(&osCp.tmrTblLock);
#endif
{
S16 bufSz;
- TRC1(SWrtLogBuf);
/* buffer synchronisation*/
bufSz = cmStrlen((U8 *)buf);
SLock(&osCp.logger.bufLock);
{
SFlushBufToLog(osCp.logger.buffer);
osCp.logger.curBufSiz = 0;
- cmMemset((U8 *)osCp.logger.buffer, '\0', osCp.logger.maxBufSiz);
+ memset(osCp.logger.buffer, '\0', osCp.logger.maxBufSiz);
sprintf(osCp.logger.buffer, "%s", buf);
osCp.logger.curBufSiz += bufSz;
}
Txt *buf; /* buffer */
#endif
{
- TRC1(SPrint);
/* ss001.301: additions */
SDisplay(0, buf);
DateTime dt;
Txt errBuf[256];
-
- TRC1(SError);
-
-
SGetDateTime(&dt);
sprintf(errBuf, "\n\ndate: %02d/%02d/%04d time: %02d:%02d:%02d\n",
(int)dt.month,(int)dt.day,(int)dt.year + 1900,
Txt errBuf[512];
- TRC1(SLogError);
-
/*ss014.301: SSI-4GMX related changes*/
#ifndef SS_4GMX_LCORE
SGetDateTime(&dt);
ProcId SFndProcId()
#endif
{
- TRC1(SFndProcId);
return (osCp.procId);
} /* end of SFndProcId */
ProcId procId;
#endif
{
- TRC1(SSetProcId);
osCp.procId = procId;
U16 i;
U16 idx;
- TRC1(SGetProcIdIdx);
-
idx = SS_HASH_IDX(proc);
for (i = idx; i < SS_MAX_PROCS; i++)
U16 i;
U16 idx;
- TRC1(SInsProcId);
idx = SS_HASH_IDX(proc);
U16 i;
U16 idx;
- TRC1(SRemProcId);
idx = SS_HASH_IDX(proc);
{
S16 ret;
- TRC1(SLockOsCp);
ret = SLock(&osCp.sTskTblLock);
if (ret != ROK)
PRIVATE S16 SULockOsCp(Void)
#endif
{
- TRC1(SULockOsCp);
/* unlock the table */
SS_RELEASE_ALL_SEMA(&osCp.tTskTblSem);
U16 i;
S16 ret;
- TRC1(SAddProcIdLst);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* range check */
{
U16 i;
- TRC1(SRemProcIdLst);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* range check */
U16 i;
U16 count = 0;
- TRC1(SGetProcIdLst);
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((numPIds == NULLP) || (pIdLst == NULLP))
U16 procIdIdx;
SsIdx idx;
- TRC1(SGetXxCb);
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
};
/*ss013.301 :Adding TRC MACRO*/
- TRC2(SFillEntIds)
memcpy((U8*)osCp.entId, (U8*)entInfo, sizeof(entInfo));
return ROK;
U8 firstIdx = 0;
U8 secondIdx = 0;
- TRC1(SGetEntInd);
/* ss002.301 Additions */
if ((strippedName = strrchr((const char *)fileName, '/')))
{
S16 retVal = ROK;
- TRC1(SLockNew);
if((retVal = ssdLockNew(lockId, lockType)) != ROK)
{
{
S16 retVal = ROK;
- TRC1(SInitLockNew);
if((retVal = ssdInitLockNew(lockId, lockType)) != ROK)
{
{
S16 retVal = ROK;
- TRC1(SUnlockNew);
if((retVal = ssdUnlockNew(lockId, lockType)) != ROK)
{
{
S16 retVal = ROK;
- TRC1(SDestroyLockNew);
if((retVal = ssdDestroyLockNew(lockId, lockType)) != ROK)
{
{
S16 ret;
-
- TRC1(SRegDynRegion);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
if (region >= SS_MAX_REGS)
{
S16 ret;
-
- TRC1(SRegRegion);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
if (region >= SS_MAX_REGS)
{
S16 ret;
-
- TRC1(SDeregRegion);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
if (region >= SS_MAX_REGS)
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC1(SAlloc);
#if (ERRCLASS & ERRCLS_INT_PAR)
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC1(SFree);
/* Get the region which is assgined with this thread. The region was
* stored in the osCp and is taken with respect to thread ID. This macro
CmMemEntries *entry = NULLP;
U32 blkSize = 0;
- TRC1(SRegInfoShow);
memset(tapaTsk, ENTNC, sizeof(tapaTsk));
Data *data;
SsDblk *dptr;
- TRC1(ssGetDBufOfSize)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer pointer */
if (!dBuf)
#endif
- TRC1(SGetMsgNew)
-
#ifdef XEON_SPECIFIC_CHANGES
region = 0;
pool = 0;
Ent entId = 0;
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC1(SPutMsgNew)
-
#ifdef L2_OPTMZ
//#ifdef RADIO_CLUSTER
if(clusterMode == RADIO_CLUSTER_MODE)
{
S16 ret = RFAILED;
- TRC1(SPutStaticBuffer);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
if (region >= SS_MAX_REGS)
S16 ret = RFAILED;
U32 flags;
- TRC1(SGetStaticBuffer);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
if (region >= SS_MAX_REGS)
Bool hstReg = FALSE;
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC1(SGetSBufNew);
region = SS_GET_THREAD_MEM_REGION();
#ifdef INTEL_WLS
Bool hstReg = FALSE;
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC1(SPutSBufNew);
-
-
region = SS_GET_THREAD_MEM_REGION();
#if (!defined(SS_LOCKLESS_MEMORY) && defined(INTEL_WLS))
region = 1;
Buffer *tmp;
U8 tmpRegId;
- TRC1(SInitMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
if (mBuf == NULLP)
MsgLen offset;
Data *rptr;
Data *revSrc;
- TRC1(SAddPreMsgMultInOrder)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
Buffer *tmp;
Buffer *newb;
- TRC1(SAddPreMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
if (!mBuf)
SsMsgInfo *minfo;
Buffer *tmp;
Buffer *newb;
-
- TRC1(SAddPstMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
MsgLen offset;
Data *rptr;
- TRC1(SAddPreMsgMult)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
if (mBuf == NULLP)
MsgLen numBytes;
Data *wptr;
- TRC1(SAddPstMsgMult)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
if (mBuf == NULLP)
U32 line = __LINE__;
#endif
- TRC1(SRemPreMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!dataPtr)
U32 line = __LINE__;
#endif
- TRC1(SRemPstMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (dataPtr == NULLP)
U32 line = __LINE__;
#endif
- TRC1(SRemPreMsgMult)
/* ss023.103 - Modification of SRemPreMsgMult for bug fix */
U32 line = __LINE__;
#endif
- TRC1(SRemPstMsgMult)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check count */
SsMsgInfo *minfo;
Buffer *tmp;
- TRC1(SExamMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!dataPtr)
MsgLen offSetLen;
Data *tmpDataPtr = dataPtr;
- TRC1(SGetDataFrmMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!dataPtr)
{
SsMsgInfo *minfo;
- TRC1(SFndLenMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
if (mBuf == NULLP)
Buffer *prev;
Buffer *next;
- TRC1(SSegMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer 1 */
SsMsgInfo *minfo;
Buffer *right;
- TRC1(SCpyFixMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check source message buffer */
if (srcBuf == NULLP)
SsMsgInfo *minfo;
MsgLen numBytes;
- TRC1(SCpyMsgFix)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check source message buffer */
if (srcMbuf == NULLP)
#endif
#endif
- TRC1(SCpyMsgMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!srcBuf)
{
Data *cptr;
MsgLen numBytes;
- TRC1(SAddMsgRef)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!srcBuf)
S16 r; /* return value */
Size m; /* temporary */
- TRC1(DupMsg);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
#endif
#endif
- TRC1(SGetDBuf)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer pointer */
if (!bufPtr)
Data *dpdkBuf;
#endif
- TRC2(SPutDBuf);
/* ss021.103 - Addition of ret initialization */
ret = ROK;
Buffer *tmp;
Buffer *newb;
- TRC1(SCatMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer 1 */
if (mBuf1 == NULLP)
Buffer *prev;
MsgLen numBytes;
- TRC1(SRepMsg)
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
{
SsMsgInfo *minfo;
- TRC1(SUpdMsg)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!mBuf)
{
{
SsMsgInfo *minfo;
- TRC1(SAddDBufPst)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer queue */
if (!mBuf || !dBuf)
SsMsgInfo *minfo;
Buffer *tmp;
- TRC1(SAddDBufPre)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer queue */
if (!mBuf || !dBuf)
{
SsMsgInfo *minfo;
- TRC1(SRemDBufPre)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer pointer */
if (dBufPtr == NULLP)
SsMsgInfo *minfo;
Buffer *tmp;
- TRC1(SRemDBufPst)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer pointer */
if (!dBufPtr)
{
SsMsgInfo *minfo;
- TRC1(SInitNxtDBuf)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!mBuf)
{
{
SsMsgInfo *minfo;
- TRC1(SGetNxtDBuf)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!mBuf)
{
{
SsMsgInfo *minfo;
- TRC1(SChkNxtDBuf)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!mBuf)
{
MsgLen *retDatLen; /* return data length */
#endif
{
- TRC1(SGetDataRx)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!dBuf)
MsgLen *retDatLen; /* return data length */
#endif
{
- TRC1(SGetDataTx)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* ss021.103 - Modification to check parameters */
{
SsMsgInfo *mInfo; /* message info pointer */
- TRC1(SGetBufRegionPool)
#if (ERRCLASS & ERRCLS_INT_PAR)
char* file = __FILE__;
U32 line = __LINE__;
#endif
- TRC1(SCompressMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!mBuf)
Data reg;
- TRC1(SPrntMsg)
if (mBuf == NULLP)
{
MsgLen numBytes;
MsgLen avail;
- TRC1(SGetPstMsgMult)
#if ( ERRCLASS & ERRCLS_INT_PAR )
/* check message buffer */
SsMsgInfo *minfo;
Buffer *tmp;
- TRC1(SChkMsg)
#if ( ERRCLASS & ERRCLS_INT_PAR )
/* check message buffer */
MsgLen len;
Data *src;
- TRC1(SAlignDBufEven)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!dBuf)
{
U32 upShift; /* no. of bytes to be shifted up */
U32 downShift; /* no. of bytes to be shifted down */
- TRC1(SAlignDBuf)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!dBuf)
{
Pool *pool; /* pointer to pool ID */
#endif
{
- TRC1(SGetSMem);
-
UNUSED(size);
S16 ret;
#endif
- TRC1(SPutSMem);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
SMemCtl mctl;
- TRC1(SChkRes);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
Buffer *tmp;
U8 tmp2;
- TRC1(SSwapMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer 1 */
SsDblk *dblkPtr;
SsFrtn *frtnPtr;
- TRC1(SConvPtrPhy);
-
/* check mBuf for NULLP */
if ( (mBuf == NULLP) || (*mBuf == NULLP ) )
SsDblk *dblkPtr;
SsFrtn *frtnPtr;
- TRC1(SConvPhyPtr);
-
/* check workPtr for NULLP */
if ( (workPtr == NULLP) || (*workPtr == NULLP) )
SsDblk *dblkPtr = NULLP;
SsDblk *dptr = NULLP;
- TRC1(SCpyFpaMsg);
-
if ( srcBuf == (Buffer*)NULLP )
{
U32 numBytes;
Pool pool;
- TRC1(SCpyMsgFpa);
-
if (srcBuf == (Buffer*)NULLP)
{
Buffer *nextBlk;
SsDblk *dblkPtr;
- TRC1(SPutFpaMsg);
if( fpaBuf == NULLP )
{
MsgLen dCnt;
MsgLen numCpd;
- TRC1(SCpyPartMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!srcBuf)
MsgLen sIdx;
MsgLen cpBytes;
- TRC1(SRepPartMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!dstBuf)
U32 line = __LINE__;
#endif
- TRC1(SMovPartMsg)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer 1 */
MsgLen numBytes; /* no. of bytes to be copied */
MsgLen offset;
- TRC1(SPkMsgMult)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
Buffer *newblk;
/* Void *iccHdlr; */
- TRC1(SAttachPtrToBuf)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (ptr == NULLP)
MsgLen bufLen;
S16 ret = ROK;
- TRC2(SPutZbcDBuf);
dptr = buf->b_datap;
/* Get the length of the buffer */
Buffer *newblk;
/* Void *iccHdlr; */
- TRC1(SAttachPtrToMBuf)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (ptr == NULLP)
Buffer *newblk;
/* Void *iccHdlr; */
- TRC1(SAttachWlsPtrToMBuf)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (ptr == NULLP)
#endif
{
S16 ret; /* return code */
- TRC1(SPkS8)
ret = SAddPreMsg((Data) val, mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (ret != ROK)
#endif
{
S16 ret; /* return code */
- TRC1(oduUnpackUInt8)
ret = SAddPreMsg((Data) val, mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (ret != ROK)
Data pkArray[2]; /* array for packing */
S16 ret; /* return code */
- TRC1(SPkS16)
#ifndef FCSPKINT /* backward compatibility, packing order */
pkArray[0] = (Data) GetHiByte(val);
pkArray[1] = (Data) GetLoByte(val);
Data pkArray[2]; /* array for packing */
S16 ret; /* return code */
- TRC1(oduUnpackUInt16)
#ifndef FCSPKINT /* backward compatibility, packing order */
pkArray[0] = (Data) GetHiByte(val);
pkArray[1] = (Data) GetLoByte(val);
Data pkArray[4]; /* packing array */
S16 ret; /* return code */
- TRC1(SPkS32)
#ifndef FCSPKINT /* backward compatibility, packing order */
tmp = (U16) GetHiWord(val);
pkArray[0] = (Data) GetHiByte(tmp);
Data pkArray[4]; /* packing array */
S16 ret; /* return code */
- TRC1(oduUnpackUInt32)
#ifndef FCSPKINT /* backward compatibility, packing order */
tmp = (U16) GetHiWord(val);
pkArray[0] = (Data) GetHiByte(tmp);
S8 pkArray[15]; /* packing array */
#endif /*FCSPKINT*/
- TRC1(SPkF32)
-
sprintf(tmpArray, "%.7e", val);
#ifndef FCSPKINT /* backward compatibility, packing order */
S8 pkArray[25]; /* packing array */
#endif /*FCSPKINT*/
- TRC1(SPkF64)
-
sprintf(tmpArray, "%.16le", val);
#ifndef FCSPKINT /* backward compatibility, packing order */
{
Data tmp; /* temporary value */
S16 ret; /* return code */
- TRC1(SUnpkS8)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
{
Data tmp; /* temporary value */
S16 ret; /* return code */
- TRC1(oduPackUInt8)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
U16 tmp16; /* temporary value */
Data unpkArray[2]; /* unpacking array */
S16 ret; /* return code */
- TRC1(SUnpkS16)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
U16 tmp16; /* temporary value */
Data unpkArray[2]; /* unpacking array */
S16 ret; /* return code */
- TRC1(oduPackUInt16)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
U32 tmp32; /* temporary value */
Data unpkArray[4]; /* unpacking array */
S16 ret; /* return code */
- TRC1(SUnpkS32)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
#ifdef ERRCLASS
S16 ret; /* return code */
#endif /* ERRCLASS */
- TRC1(oduPackUInt32)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
S8 unpkArray[15]; /* unpacking array */
#endif /* FCSPKINT */
- TRC1(SUnpkF32)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!val)
S8 unpkArray[25]; /* unpacking array */
#endif /* FCSPKINT */
- TRC1(SUnpkF64)
-
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!val)
Queue *q; /* queue */
#endif
{
- TRC1(SInitQueue)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check queue pointer */
U32 line = __LINE__;
#endif
- TRC1(SFlushQueue)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check queue */
Order order; /* order */
#endif
{
- TRC1(SCatQueue)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (q1 == NULLP)
QLen *lngPtr; /* pointer to length */
#endif
{
- TRC1(SFndLenQueue)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check queue */
Buffer *tmpBuf;
QLen i;
- TRC1(SExamQueue)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer pointer */
Buffer *tBuf;
QLen i;
- TRC1(SAddQueue)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check queue */
Buffer *tBuf;
QLen i;
- TRC1(SRemQueue)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer pointer */
Queue *q; /* queue */
#endif
{
- TRC1(SQueueFirst)
return (SAddQueue(buf, q, 0));
} /* end of SQueueFirst */
Queue *q; /* queue */
#endif
{
- TRC2(SDequeueFirst)
return (SRemQueue(bufPtr, q, 0));
} /* end of SDequeueFirst */
Queue *q; /* queue */
#endif
{
- TRC1(SQueueLast)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check queue */
{
S16 ret;
- TRC1(SDequeueLast)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check buffer pointer */
U8 i;
S16 ret;
- TRC0(ssInitDmnddQ)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (dQueue == NULLP)
Buffer *tBuf;
S16 ret;
- TRC0(ssDestroyDmndQ)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (dQueue == NULLP)
U32 t = MacGetTick();
#endif
- TRC0(ssDmndQPut)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (dQueue == NULLP)
{
S16 ret;
- TRC0(ssDmndQWait)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (dQueue == NULLP)
U8 qIndex;
#endif
- TRC0(ssDmndQGet)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mBuf == NULLP)
S16 ret; /* return value */
U8 i;
- TRC0(ssFndLenDmndQ)
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((dQueue == NULLP) || (len == NULLP))
Region datRegId; /* region for data buffers */
#endif
{
- TRC1(ssStrmCfg);
-
strmCfg.mdRegion = mdRegId;
strmCfg.datRegion = datRegId;
SsMblk *bp; /* mblk for iteration */
SsMblk *first; /* first mblk to be adjusted */
-
- TRC1(ssAdjMsg);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
char* file = __FILE__;
U32 line = __LINE__;
#endif
- TRC1(ssAllocB);
-
UNUSED(pri);
U32 size; /* size of data content */
- TRC1(ssCopyB);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
SsMblk *first; /* first mblk in message */
SsMblk *bp; /* mblk for iteration */
-
- TRC1(ssCopyMsg);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
SsMblk *bp; /* mblk for iteration */
/* ss028.103 - Addition of lock for mBuf reference count */
- TRC1(ssDupB);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
SsMblk *first; /* first mblk in message */
SsMblk *bp; /* mblk for iteration */
-
- TRC1(ssDupMsg);
-
-
/* dup the first mblock */
first = bp = ssDupB(mp);
if (bp == NULLP)
Size m; /* mblk + dblk */
S16 r; /* return value */
-
- TRC1(ssESBAlloc);
-
-
UNUSED(pri);
U32 line = __LINE__;
#endif
- TRC1(ssFreeB);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
{
SsMblk *bp; /* mblk for iteration */
-
- TRC1(ssFreeMsg);
-
-
/* free all the message blocks in the message */
while (mp)
{
SsMblk *bp; /* second message block */
#endif
{
- TRC1(ssLinkB);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP || bp == NULLP)
S32 n; /* temporary */
S32 size; /* size of data */
-
- TRC1(ssMsgDSize);
-
-
/* for all blocks that are of type data, count the bytes */
size = 0;
while (mp)
S32 n; /* temporary */
U8 type; /* message type */
-
- TRC1(ssPullupMsg);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
{
SsMblk *rp; /* mblk that will be returned */
-
- TRC1(ssRmvB);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP || bp == NULLP)
{
{
SsMblk *bp; /* mblk for iteration */
-
- TRC1(ssTestB);
-
-
bp = ssAllocB(size, pri);
if (bp)
{
{
SsMblk *bp; /* mblk for iteration */
-
- TRC1(ssUnlinkB);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
S16 ret; /* return value */
SsTTskEntry *tTsk;
- TRC1(SRegInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* ss021.103 - Addition for pointer */
SsTTskEntry *tTsk;
- TRC1(SRegActvTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
Bool destroySTsk;
- TRC1(SDeregInitTskTmr);
#if (ERRCLASS & ERRCLS_INT_PAR)
U16 procIdIdx;
#endif
- TRC1(SRegTTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
U16 procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
- TRC1(SRegCbTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
Buffer *mBuf;
SsMsgInfo *mInfo;
- TRC1(SDeregTTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
SsSTskEntry *sTsk;
- TRC1(SCreateSTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
struct sockaddr_in localAddr={0};
struct sockaddr_in remoteAddr ={0};
- TRC1(SRegLogCfg);
#if (ERRCLASS & ERRCLS_INT_PAR)
#endif
}
- cmMemset((U8*)osCp.logger.buffer, '\0', sizeof(osCp.logger.buffer));
+ memset(osCp.logger.buffer, '\0', sizeof(osCp.logger.buffer));
osCp.logger.maxBufSiz = SS_MAX_LOGBUF_SIZE;
osCp.logger.curBufSiz = 0;
#endif
FILE* oldFileP;
/*ss013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC1(SFlushBufToLog)
buffer = logBuf;
osCp.logger.curNumFlush++;
if(osCp.logger.curNumFlush == osCp.logger.maxNumFlush)
{
- cmMemset((U8 *)newFileName,'\0',sizeof(newFileName));
+ memset(newFileName,'\0',sizeof(newFileName));
/*Store the current File*/
oldFileP = osCp.logger.filep;
/*Open a new file and use it as a new log file*/
#endif
{
- TRC1(SCleanUp);
/*Flush the remaining data in the log file*/
SLock(&osCp.logger.bufLock);
if(osCp.logger.started == FALSE)
{
- TRC1(SDeregLogCfg);
SCleanUp();
U32 coreCount = 0;
/*ss013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC1(SRegCpuInfo)
/* check the number of cores */
if ( cpuInfo->numCores > SS_MAX_CORES ||
cpuInfo->threadsPerCore > SS_MAX_THREADS_PER_CORE ||
S16 ret;
/*ss013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC1(SGetAffinity)
/* implementation specific */
ret = ssdGetAffinity(tskId, coreId);
S16 ret;
/*ss013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC1(SSetAffinity)
/* validate the mode */
if (mode < SS_AFFINITY_MODE_DEFAULT ||
mode > SS_AFFINITY_MODE_EXCL)
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT*/
- TRC1(SDestroySTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
#endif
- TRC1(SAttachTTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
U16 procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
- TRC1(SDetachTTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
U32 t = MacGetTick();
#endif
- TRC1(SPstTsk);
#if (ERRCLASS & ERRCLS_INT_PAR)
*/
tTsk = &osCp.tTskTbl[dstIdx];
- cmMemcpy((U8*)&tempPst, (U8*)pst, sizeof(Pst));
+ memcpy(&tempPst, pst, sizeof(Pst));
if(tTsk->cbTsk != NULLP)
{
retValue = tTsk->cbTsk(&tempPst,mBuf);
U32 tskCnt = 0;
- TRC1(SGetTapaTskEntIds);
/* Get the tapa task entity Ids from the osCp structure */
for(tskCnt = 0; tskCnt < osCp.numTTsks; tskCnt++)
{
U32 tskCnt = 0;
S16 r = 0;
- TRC1(SRegForHstGrm);
SS_ACQUIRE_SEMA(&osCp.tTskTblSem, r);
if (r != ROK)
Bool found = FALSE;
*hstReg = 0;
- TRC1(SGetHstGrmInfo);
for(tskCnt = 0; tskCnt < osCp.numTTsks; tskCnt++)
{
if( *entId == osCp.tTskTbl[tskCnt].ent)
int i = 0;
/*ss013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC1(SRegCfgWd)
osCp.wdCp.globWd.timeout = timeout;
osCp.wdCp.globWd.callback = callback;
int i = 0;
/*ss013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC1(SDeregCfgWd)
osCp.wdCp.globWd.timeout = 0;
osCp.wdCp.globWd.callback = 0;
U8 timeInterval;
#endif
{
- TRC1(SStartHrtBt);
ssdStartWatchDgTmr(NULLP, SS_TMR_HRTBT, timeInterval);
ssdSndHrtBtMsg(TRUE, SS_WD_HB_REQ);
void
#endif
{
- TRC1(SStopHrtBt);
osCp.wdCp.globWd.watchdogStop = 1;
Txt prntBuf[PRNTSZE];
#endif /* DEBUGP */
- TRC3(watchDgActvTsk)
#ifdef DEBUGP
SGetDateTime(&dt);
sprintf(prntBuf,"watchDgActvTsk: Time: %02d:%02d:%02d\n",dt.hour,dt.min, dt.sec
int socklen = sizeof(struct sockaddr);
#endif
- TRC3(watchDgActvTsk)
#ifdef DEBUGP
SGetDateTime(&dt);
#endif
- TRC1(SGetThrdProf);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check entity and instance range */
SsTmrActvFn ssTmrActvFn;
/* ss041.103 - Moved handling to STmrRegHndlr */
- TRC1(SRegCfgTmr);
-
ssTmrActvFn.mtFlag = FALSE;
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrRegHndlr(ent, inst, period, units, ssTmrActvFn);
SsTmrActvFn ssTmrActvFn;
/* ss041.103 - Moved handling to STmrRegHndlr */
- TRC1(SRegCfgTmr);
-
ssTmrActvFn.mtFlag = FALSE;
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrRegHndlr(proc, ent, inst, period, units, ssTmrActvFn);
/* ss015.301 - Enclosed all timer activation functions in a union. */
SsTmrActvFn ssTmrActvFn;
- TRC1(SRegCfgTmrMt);
-
ssTmrActvFn.actvFnc.tmrActvFnMt = tmrFnctMt;
ssTmrActvFn.mtFlag = TRUE;
ret = STmrRegHndlr(ent, inst, period, units, ssTmrActvFn);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /* SS_MULTPLE_PROCS */
- TRC1(STmrRegHndlr);
-
#if (ERRCLASS & ERRCLS_INT_PAR)
#ifdef SS_MULTIPLE_PROCS
SsTmrActvFn ssTmrActvFn;
/* ss041.103 - Moved handling to STmrDeregHndlr */
- TRC1(SDeregCfgTmr);
-
ssTmrActvFn.mtFlag = FALSE;
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrDeregHndlr(ent, inst, period, units, ssTmrActvFn);
/* ss041.103 - Moved handling to STmrDeregHndlr */
- TRC1(SDeregCfgTmr);
-
ssTmrActvFn.mtFlag = FALSE;
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrDeregHndlr(proc, ent, inst, period, units, ssTmrActvFn);
/* ss015.301 Enclosed all timer activation functions in a union. */
SsTmrActvFn ssTmrActvFn;
- TRC1(SDeregCfgTmrMt);
-
ssTmrActvFn.actvFnc.tmrActvFnMt = tmrFnctMt;
ssTmrActvFn.mtFlag = TRUE;
#endif /* SS_MULTIPLE_PROCS */
- TRC1(STmrDeregHndlr);
-
-
#if (ERRCLASS & ERRCLS_INT_PAR)
#ifdef SS_MULTIPLE_PROCS
BuildGlobalRicId(&(e2SetupRsp->protocolIEs.list.array[idx]->value.choice.GlobalRIC_ID));
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf, encBuf);
/* Prints the Msg formed */
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
encBuf);
_ret = SGetSBuf(RIC_APP_MEM_REG, RIC_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
- cmMemset((U8*)_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
else \
_datPtr = NULLP; \
}
_ret = SGetSBuf(RIC_APP_MEM_REG, RIC_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
- cmMemset((uint8_t*)_datPtr, 0, _size); \
+ memset(_datPtr, 0, _size); \
else \
_datPtr = NULLP; \
}
/* ccpu00147898 fixes */
memset(&hints, 0, sizeof(hints));
- memset((void*)&serv_addr, 0, sizeof(serv_addr));
- memset((void*)&serv_addr6, 0, sizeof(serv_addr6));
+ memset(&serv_addr, 0, sizeof(serv_addr));
+ memset(&serv_addr6, 0, sizeof(serv_addr6));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags |= AI_CANONNAME;
int newsockfd;
int clilen = 0;
int domain = AF_INET;
- memset((void*)&serv_addr, 0, sizeof(serv_addr));
+ memset(&serv_addr, 0, sizeof(serv_addr));
if(gIpType == CM_IPV4ADDR_TYPE)
Code Review / o-du / l2.git / commitdiff