* @return void
*
* ****************************************************************/
-PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
+void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
{
memset(hdr, 0, sizeof(fapi_msg_t));
hdr->msg_id = msgType;
* @return void
*
* ****************************************************************/
-PUBLIC void fillTlvs(fapi_uint32_tlv_t *tlv, uint16_t tag, uint16_t length,
+void fillTlvs(fapi_uint32_tlv_t *tlv, uint16_t tag, uint16_t length,
uint16_t value, uint32_t *msgLen)
{
tlv->tl.tag = tag;
* @return void
*
********************************************************************/
-PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
+void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
+void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
+void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
{
if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
+void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
+void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
{
if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr)
+void fillCCEmaping(uint8_t value, ClCellParam **cellPtr)
{
if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
+void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
+void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
+void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
{
* @return void
*
******************************************************************/
-PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
+void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
{
*
******************************************************************/
-PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
+void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
{
* @return void
*
******************************************************************/
-PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
+void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
{
if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
{
*
******************************************************************/
-PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
+void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
{
* @return void
*
******************************************************************/
-PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
+void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
{
if(value == 0 )
{
*
******************************************************************/
-PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
+void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
+void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
{
if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
{
*
******************************************************************/
-PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
+void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
+void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
+void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
+void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
{
*
******************************************************************/
-PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
+void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
{
if(value == 0)
{
*
******************************************************************/
-PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
+void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
+void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
+void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
{
*
******************************************************************/
-PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
+void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
{
if(value == 0)
{
*
******************************************************************/
-PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
+void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
{
* pointer to modified value
******************************************************************/
-PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
+void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
{
*mibPdu |= (((uint8_t)(sfn >> 2)) & MIB_SFN_BITMASK);
*val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
*
* *****************************************************************/
-PUBLIC uint16_t LwrMacSendToPhy(uint8_t msgType, uint32_t msgLen, void *msg)
+uint8_t LwrMacSendToPhy(uint8_t msgType, uint32_t msgLen, void *msg)
{
#ifdef INTEL_WLS
- int ret;
+ uint8_t ret;
unsigned long long pMsg;
pMsg = WLS_VA2PA(mtGetWlsHdl(), msg);
CmLListCp wlsBlockToFreeList[WLS_MEM_FREE_PRD];
extern uint8_t slotIndIdx;
-EXTERN void freeWlsBlockList(uint8_t idx);
-EXTERN void LwrMacEnqueueWlsBlock();
+void freeWlsBlockList(uint8_t idx);
+void LwrMacEnqueueWlsBlock();
#endif /* INTEL_WLS */
-EXTERN uint16_t LwrMacSendToPhy(uint8_t msgType, uint32_t msgLen, void *msg);
+uint8_t LwrMacSendToPhy(uint8_t msgType, uint32_t msgLen, void *msg);
#endif
/**********************************************************************
* NULLP - failure
*
* ****************************************************************/
-PUBLIC LwrMacCellCb * lwrMacGetCellCb
+LwrMacCellCb * lwrMacGetCellCb
(
uint16_t cellId
)
#define FILL_PST_LWR_MAC_TO_MAC(_pst, _event) \
{ \
_pst.selector = ODU_SELECTOR_TC; \
- _pst.srcEnt = ENTTF; \
- _pst.dstEnt = ENTRG; \
+ _pst.srcEnt = ENTLWRMAC; \
+ _pst.dstEnt = ENTMAC; \
_pst.dstInst = 0; \
_pst.srcInst = 0; \
_pst.dstProcId = SFndProcId(); \
* @return
* -# ROK
**/
-PUBLIC uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
+uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
{
printf("\nReceived Scheduler gen config at MAC");
pst->dstInst = DEFAULT_CELLS + 1;
* @return
* -# ROK
**/
-PUBLIC uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm)
+uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm)
{
printf("\nSending Scheduler config confirm to DU APP");
pst->dstEnt = ENTDUAPP;
{
Pst cfmPst;
uint16_t cellIdx;
- uint16_t ret = ROK;
+ uint8_t ret = ROK;
MacCellCb *macCellCb;
memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
#define FILL_PST_MAC_TO_DUAPP(_pst, _event) \
{ \
_pst.selector = ODU_SELECTOR_LWLC; \
- _pst.srcEnt = ENTRG; \
+ _pst.srcEnt = ENTMAC; \
_pst.dstEnt = ENTDUAPP; \
_pst.dstInst = 0; \
_pst.srcInst = macCb.macInst; \
#define FILL_PST_MAC_TO_SCH(_pst, _event) \
{ \
_pst.selector = ODU_SELECTOR_TC; \
- _pst.srcEnt = ENTRG; \
- _pst.dstEnt = ENTRG; \
+ _pst.srcEnt = ENTMAC; \
+ _pst.dstEnt = ENTMAC; \
_pst.dstInst = 1; \
_pst.srcInst = macCb.macInst; \
_pst.dstProcId = macCb.procId; \
#define FILL_PST_MAC_TO_RLC(_pst, _dstInst, _event) \
{ \
pst.selector = ODU_SELECTOR_LWLC; \
- pst.srcEnt = ENTRG; \
- pst.dstEnt = ENTKW; \
+ pst.srcEnt = ENTMAC; \
+ pst.dstEnt = ENTRLC; \
pst.dstInst = _dstInst; \
pst.srcInst = macCb.macInst; \
pst.dstProcId = macCb.procId; \
{ \
if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL0) \
{ \
- ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL0, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
+ ssDiagFix(_tknId, _splArgEnum, ENTMAC, rgCb[_inst].rgInit.inst, SS_DIAG_LVL0, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
} \
}
{ \
if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL1) \
{ \
- ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL1, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
+ ssDiagFix(_tknId, _splArgEnum, ENTMAC, rgCb[_inst].rgInit.inst, SS_DIAG_LVL1, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
} \
}
{ \
if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL2) \
{ \
- ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL2, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
+ ssDiagFix(_tknId, _splArgEnum, ENTMAC, rgCb[_inst].rgInit.inst, SS_DIAG_LVL2, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
} \
}
{ \
if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL3) \
{ \
- ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL3, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
+ ssDiagFix(_tknId, _splArgEnum, ENTMAC, rgCb[_inst].rgInit.inst, SS_DIAG_LVL3, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
} \
}
{ \
if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL4) \
{ \
- ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL4, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
+ ssDiagFix(_tknId, _splArgEnum, ENTMAC, rgCb[_inst].rgInit.inst, SS_DIAG_LVL4, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
} \
}
#include "rg_pom_scell.x"
#endif
/* LTE-MAC Control Block Structure */
-PUBLIC RgCb rgCb[RG_MAX_INST];
+RgCb rgCb[RG_MAX_INST];
/* local defines */
PRIVATE S16 rgCFGVldtCrgDedLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgCellCfg
+S16 rgCFGVldtCrgCellCfg
(
Inst inst,
CrgCellCfg *cellCfg,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGVldtCrgCellCfg(inst,cellCfg, errInfo)
+S16 rgCFGVldtCrgCellCfg(inst,cellCfg, errInfo)
Inst inst;
CrgCellCfg *cellCfg;
RgErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgUeCfg
+S16 rgCFGVldtCrgUeCfg
(
Inst inst,
CrgUeCfg *ueCfg,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGVldtCrgUeCfg(inst,ueCfg, cell, errInfo)
+S16 rgCFGVldtCrgUeCfg(inst,ueCfg, cell, errInfo)
Inst inst;
CrgUeCfg *ueCfg;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgLcCfg
+S16 rgCFGVldtCrgLcCfg
(
Inst inst,
CrgLchCfg *lcCfg,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGVldtCrgLcCfg(inst,lcCfg, cell, ue, errInfo)
+S16 rgCFGVldtCrgLcCfg(inst,lcCfg, cell, ue, errInfo)
Inst inst;
CrgLchCfg *lcCfg;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgCellRecfg
+S16 rgCFGVldtCrgCellRecfg
(
Inst inst,
CrgCellRecfg *cellRecfg,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGVldtCrgCellRecfg(inst,cellRecfg, cell, errInfo)
+S16 rgCFGVldtCrgCellRecfg(inst,cellRecfg, cell, errInfo)
Inst inst;
CrgCellRecfg *cellRecfg;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgUeRecfg
+S16 rgCFGVldtCrgUeRecfg
(
Inst inst,
CrgUeRecfg *ueRecfg,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGVldtCrgUeRecfg(inst,ueRecfg, cell, ue, errInfo)
+S16 rgCFGVldtCrgUeRecfg(inst,ueRecfg, cell, ue, errInfo)
Inst inst;
CrgUeRecfg *ueRecfg;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgLcRecfg
+S16 rgCFGVldtCrgLcRecfg
(
Inst inst,
CrgLchRecfg *lcRecfg,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGVldtCrgLcRecfg(inst,lcRecfg, cell, ue, ulLc, errInfo)
+S16 rgCFGVldtCrgLcRecfg(inst,lcRecfg, cell, ue, ulLc, errInfo)
Inst inst;
CrgLchRecfg *lcRecfg;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgUeReset
+S16 rgCFGVldtCrgUeReset
(
Inst inst,
CrgRst *reset,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
+S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
Inst inst;
CrgRst *reset;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgCellCfg
+S16 rgCFGCrgCellCfg
(
Inst inst,
CrgCellCfg *cellCfg,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGCrgCellCfg(inst,cellCfg, errInfo)
+S16 rgCFGCrgCellCfg(inst,cellCfg, errInfo)
Inst inst;
CrgCellCfg *cellCfg;
RgErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCfgAddUeSCellCfg
+S16 rgCfgAddUeSCellCfg
(
Inst dstMacInst,
RgPrgUeSCellCfgInfo *ueSCellCb,
RgCellCb *cell
)
#else
-PUBLIC S16 rgCfgAddUeSCellCfg(dstMacInst, ueSCellCb, cell)
+S16 rgCfgAddUeSCellCfg(dstMacInst, ueSCellCb, cell)
Inst dstMacInst;
RgPrgUeSCellCfgInfo *ueSCellCb;
RgCellCb *cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgFillAndAddSCellCfg
+S16 rgFillAndAddSCellCfg
(
Inst inst,
RgCellCb *cell,
Bool *isCfmRqrd
)
#else
-PUBLIC S16 rgFillAndAddSCellCfg(inst, cell, ueRecfg, transId, isCfmRqrd)
+S16 rgFillAndAddSCellCfg(inst, cell, ueRecfg, transId, isCfmRqrd)
Inst inst;
RgCellCb *cell;
CrgUeRecfg *ueRecfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeCfg
+S16 rgCFGCrgUeCfg
(
Inst inst,
RgCellCb *cell,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGCrgUeCfg(inst,cell, ueCfg, errInfo)
+S16 rgCFGCrgUeCfg(inst,cell, ueCfg, errInfo)
Inst inst;
RgCellCb *cell;
CrgUeCfg *ueCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgLcCfg
+S16 rgCFGCrgLcCfg
(
Inst inst,
RgCellCb *cell,
CrgCfgTransId transId
)
#else
-PUBLIC S16 rgCFGCrgLcCfg(inst,cell, ue, lcCfg, errInfo, isCfmRqrd,transId)
+S16 rgCFGCrgLcCfg(inst,cell, ue, lcCfg, errInfo, isCfmRqrd,transId)
Inst inst;
RgCellCb *cell;
RgUeCb *ue;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgCellRecfg
+S16 rgCFGCrgCellRecfg
(
Inst inst,
RgCellCb *cell,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGCrgCellRecfg(inst,cell, cellRecfg, errInfo)
+S16 rgCFGCrgCellRecfg(inst,cell, cellRecfg, errInfo)
Inst inst;
RgCellCb *cell;
CrgCellRecfg *cellRecfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeRecfg
+S16 rgCFGCrgUeRecfg
(
Inst inst,
RgCellCb *cell,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGCrgUeRecfg(inst,cell, ue, ueRecfg, errInfo)
+S16 rgCFGCrgUeRecfg(inst,cell, ue, ueRecfg, errInfo)
Inst inst;
RgCellCb *cell;
RgUeCb *ue;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgLcRecfg
+S16 rgCFGCrgLcRecfg
(
Inst inst,
RgCellCb *cell,
Bool *isCfmRqrd
)
#else
-PUBLIC S16 rgCFGCrgLcRecfg(inst,cell, ue, ulLc, lcRecfg, errInfo, isCfmRqrd)
+S16 rgCFGCrgLcRecfg(inst,cell, ue, ulLc, lcRecfg, errInfo, isCfmRqrd)
Inst inst;
RgCellCb *cell;
RgUeCb *ue;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeReset
+S16 rgCFGCrgUeReset
(
RgCellCb *cell,
RgUeCb *ue,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
+S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
RgCellCb *cell;
RgUeCb *ue;
CrgRst *reset;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgCellDel
+S16 rgCFGCrgCellDel
(
Inst inst,
CrgDel *cellDelInfo,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGCrgCellDel(inst,cellDelInfo, errInfo)
+S16 rgCFGCrgCellDel(inst,cellDelInfo, errInfo)
Inst inst,
CrgDel *cellDelInfo;
RgErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeDel
+S16 rgCFGCrgUeDel
(
Inst inst,
CrgDel *ueDelInfo,
RgErrInfo *errInfo
)
#else
-PUBLIC S16 rgCFGCrgUeDel(inst,ueDelInfo, errInfo)
+S16 rgCFGCrgUeDel(inst,ueDelInfo, errInfo)
Inst inst;
CrgDel *ueDelInfo;
RgErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCFGCrgLcDel
+S16 rgCFGCrgLcDel
(
Inst inst,
CrgDel *lcDelInfo,
CrgCfgTransId transId
)
#else
-PUBLIC S16 rgCFGCrgLcDel(inst,lcDelInfo, errInfo,isCfmRqrd,transId)
+S16 rgCFGCrgLcDel(inst,lcDelInfo, errInfo,isCfmRqrd,transId)
Inst inst;
CrgDel *lcDelInfo;
RgErrInfo *errInfo;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgCFGFreeCellCb
+Void rgCFGFreeCellCb
(
RgCellCb *cell
)
#else
-PUBLIC Void rgCFGFreeCellCb(cell)
+Void rgCFGFreeCellCb(cell)
RgCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgCFGFreeInactvCellCb
+Void rgCFGFreeInactvCellCb
(
RgCellCb *cell
)
#else
-PUBLIC Void rgCFGFreeInactvCellCb(cell)
+Void rgCFGFreeInactvCellCb(cell)
RgCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgCFGFreeUeCb
+Void rgCFGFreeUeCb
(
RgCellCb *cell,
RgUeCb *ue
)
#else
-PUBLIC Void rgCFGFreeUeCb(cell, ue)
+Void rgCFGFreeUeCb(cell, ue)
RgCellCb *cell;
RgUeCb *ue;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacCellRegReq
+S16 RgSchMacCellRegReq
(
Pst* pst,
RgInfCellReg* regReq
)
#else
-PUBLIC S16 RgSchMacCellRegReq(pst, regReq)
+S16 RgSchMacCellRegReq(pst, regReq)
Pst* pst;
RgInfCellReg* regReq;
#endif
/*Added Ue for Onging L2 Meas*/
#ifdef LTE_L2_MEAS
/*LTE_L2_MEAS_PHASE2*/
-PUBLIC S16 rgAddToL2MeasPerQci(RgCellCb *cell,U8 qci)
+S16 rgAddToL2MeasPerQci(RgCellCb *cell,U8 qci)
{
S16 ret = ROK;
CmLList *lnk;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgCOMCfgReq
+S16 rgCOMCfgReq
(
Inst inst,
CrgCfgTransId transId,
CrgCfgReqInfo *crgCfgReq
)
#else
-PUBLIC S16 rgCOMCfgReq(inst,transId, crgCfgReq)
+S16 rgCOMCfgReq(inst,transId, crgCfgReq)
Inst inst;
CrgCfgTransId transId;
CrgCfgReqInfo *crgCfgReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeSCellCfgReq
+S16 RgPrgPMacSMacUeSCellCfgReq
(
Pst *pst,
RgPrgUeSCellCfgInfo *ueSCellCb
)
#else
-PUBLIC S16 RgPrgPMacSMacUeSCellCfgReq(pst, ueSCellCb)
+S16 RgPrgPMacSMacUeSCellCfgReq(pst, ueSCellCb)
Pst *pst;
RgPrgUeSCellCfgInfo *ueSCellCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgPrgSMacPMacCfgCfm
+S16 RgPrgSMacPMacCfgCfm
(
Pst *pst,
RgPrgCfgCfmInfo *cfgCfm
)
#else
-PUBLIC S16 RgPrgSMacPMacCfgCfm(pst, cfgCfm)
+S16 RgPrgSMacPMacCfgCfm(pst, cfgCfm)
Pst *pst;
RgPrgCfgCfmInfo *cfgCfm;
#endif
* @return ROK is SUCCESS
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeSCellDelReq
+S16 RgPrgPMacSMacUeSCellDelReq
(
Pst *pst,
RgPrgUeSCellDelInfo *ueSCellDelInfo
)
#else
-PUBLIC S16 RgPrgPMacSMacUeSCellDelReq(pst, ueSCellDelInfo)
+S16 RgPrgPMacSMacUeSCellDelReq(pst, ueSCellDelInfo)
Pst *pst;
RgPrgUeSCellDelInfo *ueSCellDelInfo;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMInitCell
+S16 rgDBMInitCell
(
RgCellCb *cellCb
)
#else
-PUBLIC S16 rgDBMInitCell(cellCb)
+S16 rgDBMInitCell(cellCb)
RgCellCb *cellCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMDeInitUeCbLst
+S16 rgDBMDeInitUeCbLst
(
RgCellCb *cellCb
)
#else
-PUBLIC S16 rgDBMDeInitUeCbLst(cellCb)
+S16 rgDBMDeInitUeCbLst(cellCb)
RgCellCb *cellCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMDeInitSpsUeCbLst
+S16 rgDBMDeInitSpsUeCbLst
(
RgCellCb *cellCb
)
#else
-PUBLIC S16 rgDBMDeInitSpsUeCbLst(cellCb)
+S16 rgDBMDeInitSpsUeCbLst(cellCb)
RgCellCb *cellCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMInsUeCb
+S16 rgDBMInsUeCb
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC S16 rgDBMInsUeCb(cellCb, ueCb)
+S16 rgDBMInsUeCb(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMInsSpsUeCb
+S16 rgDBMInsSpsUeCb
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC S16 rgDBMInsSpsUeCb(cellCb, ueCb)
+S16 rgDBMInsSpsUeCb(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC RgUeCb* rgDBMGetUeCb
+RgUeCb* rgDBMGetUeCb
(
RgCellCb *cellCb,
CmLteRnti ueId
)
#else
-PUBLIC RgUeCb* rgDBMGetUeCb(cellCb, ueId)
+RgUeCb* rgDBMGetUeCb(cellCb, ueId)
RgCellCb *cellCb;
CmLteRnti ueId;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC RgUeCb* rgDBMGetSpsUeCb
+RgUeCb* rgDBMGetSpsUeCb
(
RgCellCb *cellCb,
CmLteRnti spsRnti
)
#else
-PUBLIC RgUeCb* rgDBMGetSpsUeCb(cellCb, spsRnti)
+RgUeCb* rgDBMGetSpsUeCb(cellCb, spsRnti)
RgCellCb *cellCb;
CmLteRnti spsRnti;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC RgUeCb* rgDBMGetNextUeCb
+RgUeCb* rgDBMGetNextUeCb
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC RgUeCb* rgDBMGetNextUeCb(cellCb, ueCb)
+RgUeCb* rgDBMGetNextUeCb(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC RgUeCb* rgDBMGetNextSpsUeCb
+RgUeCb* rgDBMGetNextSpsUeCb
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC RgUeCb* rgDBMGetNextSpsUeCb(cellCb, ueCb)
+RgUeCb* rgDBMGetNextSpsUeCb(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMDelUeCb
+S16 rgDBMDelUeCb
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC S16 rgDBMDelUeCb(cellCb, ueCb)
+S16 rgDBMDelUeCb(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMDelSpsUeCb
+S16 rgDBMDelSpsUeCb
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC S16 rgDBMDelSpsUeCb(cellCb, ueCb)
+S16 rgDBMDelSpsUeCb(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgDBMInitUe
+Void rgDBMInitUe
(
RgUeCb *ueCb
)
#else
-PUBLIC Void rgDBMInitUe(ueCb)
+Void rgDBMInitUe(ueCb)
RgUeCb *ueCb;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMFreeCmnLcLst
+Void rgDBMFreeCmnLcLst
(
RgCellCb *cellCb
)
#else
-PUBLIC Void rgDBMFreeCmnLcLst(cellCb)
+Void rgDBMFreeCmnLcLst(cellCb)
RgCellCb *cellCb;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMInsDlDedLcCb
+Void rgDBMInsDlDedLcCb
(
RgUeCb *ueCb,
CmLteLcId idx
)
#else
-PUBLIC Void rgDBMInsDlDedLcCb(ueCb, idx)
+Void rgDBMInsDlDedLcCb(ueCb, idx)
RgUeCb *ueCb;
CmLteLcId idx;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMDelDlDedLcCb
+Void rgDBMDelDlDedLcCb
(
RgUeCb *ueCb,
RgDlLcCb *dlLcCb
)
#else
-PUBLIC Void rgDBMDelDlDedLcCb(ueCb, dlLcCb)
+Void rgDBMDelDlDedLcCb(ueCb, dlLcCb)
RgUeCb *ueCb;
RgDlLcCb *dlLcCb;
#endif
* @return RgDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb
+RgDlLcCb* rgDBMGetDlDedLcCb
(
RgUeCb *ueCb,
CmLteLcId idx
)
#else
-PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb(ueCb, idx)
+RgDlLcCb* rgDBMGetDlDedLcCb(ueCb, idx)
RgUeCb *ueCb;
CmLteLcId idx;
#endif
**/
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC Void rgDBMInsUlDedLcCb
+Void rgDBMInsUlDedLcCb
(
RgUeCb *ueCb,
CmLteLcId idx,
U8 qci
)
#else
-PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
+Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
RgUeCb *ueCb;
CmLteLcId idx;
LteLcgId gId;
#endif
#else
#ifdef ANSI
-PUBLIC Void rgDBMInsUlDedLcCb
+Void rgDBMInsUlDedLcCb
(
RgUeCb *ueCb,
CmLteLcId idx,
LteLcgId gId
)
#else
-PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId)
+Void rgDBMInsUlDedLcCb(ueCb, idx, gId)
RgUeCb *ueCb;
CmLteLcId idx;
LteLcgId gId;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMUpdUlDedLcCb
+Void rgDBMUpdUlDedLcCb
(
RgUeCb *ueCb,
RgUlLcCb *ulLcCb,
LteLcgId gId
)
#else
-PUBLIC Void rgDBMUpdUlDedLcCb(ueCb, ulLcCb, gId)
+Void rgDBMUpdUlDedLcCb(ueCb, ulLcCb, gId)
RgUeCb *ueCb;
RgUlLcCb *ulLcCb;
LteLcgId gId;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMDelUlDedLcCb
+Void rgDBMDelUlDedLcCb
(
RgUeCb *ueCb,
RgUlLcCb *ulLcCb
)
#else
-PUBLIC Void rgDBMDelUlDedLcCb(ueCb, ulLcCb)
+Void rgDBMDelUlDedLcCb(ueCb, ulLcCb)
RgUeCb *ueCb;
RgUlLcCb *ulLcCb;
#endif
* @return RgUlLcCb*
**/
#ifdef ANSI
-PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb
+RgUlLcCb* rgDBMGetUlDedLcCb
(
RgUeCb *ueCb,
CmLteLcId idx
)
#else
-PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb(ueCb, idx)
+RgUlLcCb* rgDBMGetUlDedLcCb(ueCb, idx)
RgUeCb *ueCb;
CmLteLcId idx;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDBMChkCmnLcCb
+S16 rgDBMChkCmnLcCb
(
RgCellCb *cellCb,
CmLteLcId lcId
)
#else
-PUBLIC S16 rgDBMChkCmnLcCb(cellCb, lcId)
+S16 rgDBMChkCmnLcCb(cellCb, lcId)
RgCellCb *cellCb;
CmLteLcId lcId;
#endif
* @return RgBcchBchLcCb*
**/
#ifdef ANSI
-PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch
+RgBcchBchLcCb* rgDBMGetBcchOnBch
(
RgCellCb *cellCb
)
#else
-PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch(cellCb)
+RgBcchBchLcCb* rgDBMGetBcchOnBch(cellCb)
RgCellCb *cellCb;
#endif
{
* @return RgBcchDlschLcCb*
**/
#ifdef ANSI
-PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch
+RgBcchDlschLcCb* rgDBMGetBcchOnDlsch
(
RgCellCb *cellCb,
CmLteLcId lcId
)
#else
-PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(cellCb,lcId)
+RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(cellCb,lcId)
RgCellCb *cellCb;
CmLteLcId lcId;
#endif
* @return RgPcchLcCb*
**/
#ifdef ANSI
-PUBLIC RgPcchLcCb* rgDBMGetPcch
+RgPcchLcCb* rgDBMGetPcch
(
RgCellCb *cellCb
)
#else
-PUBLIC RgPcchLcCb* rgDBMGetPcch(cellCb)
+RgPcchLcCb* rgDBMGetPcch(cellCb)
RgCellCb *cellCb;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMInsBcchOnBch
+Void rgDBMInsBcchOnBch
(
RgCellCb *cellCb,
CmLteLcId idx
)
#else
-PUBLIC Void rgDBMInsBcchOnBch(cellCb, idx)
+Void rgDBMInsBcchOnBch(cellCb, idx)
RgCellCb *cellCb;
CmLteLcId idx;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMInsBcchOnDlsch
+Void rgDBMInsBcchOnDlsch
(
RgCellCb *cellCb,
CmLteLcId idx
)
#else
-PUBLIC Void rgDBMInsBcchOnDlsch(cellCb, idx)
+Void rgDBMInsBcchOnDlsch(cellCb, idx)
RgCellCb *cellCb;
CmLteLcId idx;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMInsPcch
+Void rgDBMInsPcch
(
RgCellCb *cellCb,
CmLteLcId idx
)
#else
-PUBLIC Void rgDBMInsPcch(cellCb, idx)
+Void rgDBMInsPcch(cellCb, idx)
RgCellCb *cellCb;
CmLteLcId idx;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgDBMInsUeCbInRachLst
+Void rgDBMInsUeCbInRachLst
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC Void rgDBMInsUeCbInRachLst(cellCb, ueCb)
+Void rgDBMInsUeCbInRachLst(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst
+RgUeCb* rgDBMGetUeCbFromRachLst
(
RgCellCb *cellCb,
CmLteRnti key
)
#else
-PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst(cellCb, key)
+RgUeCb* rgDBMGetUeCbFromRachLst(cellCb, key)
RgCellCb *cellCb;
CmLteRnti key;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst
+RgUeCb* rgDBMGetNextUeCbFromRachLst
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst(cellCb, ueCb)
+RgUeCb* rgDBMGetNextUeCbFromRachLst(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC Void rgDBMDelUeCbFromRachLst
+Void rgDBMDelUeCbFromRachLst
(
RgCellCb *cellCb,
RgUeCb *ueCb
)
#else
-PUBLIC Void rgDBMDelUeCbFromRachLst(cellCb, ueCb)
+Void rgDBMDelUeCbFromRachLst(cellCb, ueCb)
RgCellCb *cellCb;
RgUeCb *ueCb;
#endif
RgTfuDatReqPduInfo *datReq));
#ifdef L2_OPTMZ
-PUBLIC S16 rgDHMFreeHqProcTB
+S16 rgDHMFreeHqProcTB
(
RgDlHqProcCb *hqP,
U8 tbIndex
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMHqEntInit
+S16 rgDHMHqEntInit
(
Inst inst,
RgDlHqEnt *hqE,
U8 maxHqProcs
)
#else
-PUBLIC S16 rgDHMHqEntInit(inst,hqE, maxHqProcs)
+S16 rgDHMHqEntInit(inst,hqE, maxHqProcs)
Inst inst,
RgDlHqEnt *hqE;
U8 maxHqProcs;
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMUeReset
+Void rgDHMUeReset
(
RgCellCb *cell,
RgDlHqEnt *hqE
)
#else
-PUBLIC Void rgDHMUeReset(cell, hqE)
+Void rgDHMUeReset(cell, hqE)
RgCellCb *cell;
RgDlHqEnt *hqE;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMHdlBufFree
+Void rgDHMHdlBufFree
(
Inst inst,
Buffer **mBuf
)
#else
-PUBLIC Void rgDHMHdlBufFree(Inst inst, Buffer **mBuf)
+Void rgDHMHdlBufFree(Inst inst, Buffer **mBuf)
Inst inst;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMFreeTbBufs
+Void rgDHMFreeTbBufs
(
Inst inst
)
#else
-PUBLIC Void rgDHMFreeTbBufs(inst)
+Void rgDHMFreeTbBufs(inst)
Inst inst;
#endif
{
} /* rgDHMFreeTbBufs */
#ifdef ANSI
-PUBLIC Void rgDHMFreeAllTbBufs
+Void rgDHMFreeAllTbBufs
(
Inst inst
)
#else
-PUBLIC Void rgDHMFreeAllTbBufs(inst)
+Void rgDHMFreeAllTbBufs(inst)
Inst inst;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMRlsHqProcTB
+S16 rgDHMRlsHqProcTB
(
RgCellCb *cell,
RgDlHqProcCb *hqP,
U8 tbIndex
)
#else
-PUBLIC S16 rgDHMRlsHqProcTB(cell, hqP, tbIndex)
+S16 rgDHMRlsHqProcTB(cell, hqP, tbIndex)
RgCellCb *cell;
RgDlHqProcCb *hqP;
U8 tbIndex;
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMGetHqProcFrmId
+S16 rgDHMGetHqProcFrmId
(
RgUeCb *ue,
U8 idx,
RgDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgDHMGetHqProcFrmId(ue, idx, hqP)
+S16 rgDHMGetHqProcFrmId(ue, idx, hqP)
RgUeCb *ue;
U8 idx;
RgDlHqProcCb **hqP;
* -#RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDHMSndDatReq
+S16 rgDHMSndDatReq
(
RgCellCb *cellCb,
RgDlSf *dlSf,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMSndDatReq(cellCb, dlSf, datInfo, hqP, err)
+S16 rgDHMSndDatReq(cellCb, dlSf, datInfo, hqP, err)
RgCellCb *cellCb;
RgDlSf *dlSf;
RgTfuDatReqInfo *datInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDHMHndlDedDatReq
+S16 rgDHMHndlDedDatReq
(
Inst inst,
RgDlHqProcCb *hqProc,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMHndlDedDatReq(inst,hqProc, datReq, dlSf, err)
+S16 rgDHMHndlDedDatReq(inst,hqProc, datReq, dlSf, err)
Inst inst;
RgDlHqProcCb *hqProc;
RgRguDDatReqPerUe *datReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDHMHndlCmnDatReq
+S16 rgDHMHndlCmnDatReq
(
Inst inst,
RgDlHqProcCb *hqProc,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMHndlCmnDatReq(inst,hqProc, datReq, err)
+S16 rgDHMHndlCmnDatReq(inst,hqProc, datReq, err)
Inst inst;
RgDlHqProcCb *hqProc;
RgRguCmnDatReq *datReq;
**/
RgUeCb *gUe =NULLP;
#ifdef ANSI
-PUBLIC S16 rgDHMSndConsolidatedStaInd
+S16 rgDHMSndConsolidatedStaInd
(
RgCellCb *cell,
RgInfUeInfo *ueInfo,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err)
+S16 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err)
RgCellCb *cell;
RgInfUeInfo *ueInfo;
CmLteTimingInfo timingInfo;
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMFreeHqProcTB
+S16 rgDHMFreeHqProcTB
(
RgDlHqProcCb *hqP,
U8 tbIndex
)
#else
-PUBLIC S16 rgDHMFreeHqProcTB(hqP, tbIndex)
+S16 rgDHMFreeHqProcTB(hqP, tbIndex)
RgDlHqProcCb *hqP;
U8 tbIndex;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMFreeUe
+Void rgDHMFreeUe
(
Inst inst,
RgDlHqEnt *hqE
)
#else
-PUBLIC Void rgDHMFreeUe(inst,hqE)
+Void rgDHMFreeUe(inst,hqE)
Inst inst;
RgDlHqEnt *hqE;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRstHqEntReq
+S16 RgSchMacRstHqEntReq
(
Pst* pst,
RgInfResetHqEnt* hqEntInfo
)
#else
-PUBLIC S16 RgSchMacRstHqEntReq(pst, hqEntInfo)
+S16 RgSchMacRstHqEntReq(pst, hqEntInfo)
Pst* pst;
RgInfResetHqEnt* hqEntInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRlsHqReq
+S16 RgSchMacRlsHqReq
(
Pst *pst,
RgInfRlsHqInfo *rlshqUeInfo
)
#else
-PUBLIC S16 RgSchMacRlsHqReq(pst, rlshqUeInfo)
+S16 RgSchMacRlsHqReq(pst, rlshqUeInfo)
Pst *pst;
RgInfRlsHqInfo *rlshqUeInfo;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDUXDemuxData
+S16 rgDUXDemuxData
(
Inst inst,
RgMacPdu *pdu,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDUXDemuxData(inst,pdu, ceInfo, mBuf, err)
+S16 rgDUXDemuxData(inst,pdu, ceInfo, mBuf, err)
Inst inst;
RgMacPdu *pdu;
RgInfCeInfo *ceInfo;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgActvTsk
+S16 rgActvTsk
(
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 rgActvTsk(pst, mBuf)
+S16 rgActvTsk(pst, mBuf)
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
case ENTNH:
rgHdlNHEvents(pst, mBuf);
break;
- case ENTKW:
+ case ENTRLC:
rgHdlKWEvents(pst, mBuf);
break;
- case ENTTF:
+ case ENTLWRMAC:
rgHdlTFEvents(pst, mBuf);
break;
- case ENTRG: /* When scheduler instance sends msg to MAC */
+ case ENTMAC: /* When scheduler instance sends msg to MAC */
rgHdlRGEvents(pst, mBuf);
break;
default:
*/
#ifdef ANSI
-PUBLIC Void rgGetSId
+Void rgGetSId
(
SystemId *s /* system id */
)
#else
-PUBLIC Void rgGetSId(s)
+Void rgGetSId(s)
SystemId *s; /* system id */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 rgL2mCreateMeasCb
+S16 rgL2mCreateMeasCb
(
RgCellCb *cell,
RgInfL2MeasReq *measInfo,
RgErrInfo *err
)
#else
-PUBLIC S16 rgL2mCreateMeasCb(cell, measInfo, measType, err)
+S16 rgL2mCreateMeasCb(cell, measInfo, measType, err)
RgCellCb *cell;
RgInfL2MeasReq *measInfo;
U8 measType;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgL2mMeasReq
+S16 rgL2mMeasReq
(
RgCellCb *cell,
RgInfL2MeasReq *measInfo,
RgErrInfo *err
)
#else
-PUBLIC S16 rgL2mMeasReq(cell, measInfo, err)
+S16 rgL2mMeasReq(cell, measInfo, err)
RgCellCb *cell;
RgInfL2MeasReq *measInfo;
RgErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacL2MeasReq
+S16 RgSchMacL2MeasReq
(
Pst *pst, /* post structure */
RgInfL2MeasReq *measInfo /* Meas Req Info */
)
#else
-PUBLIC S16 RgSchMacL2MeasReq(pst, measInfo)
+S16 RgSchMacL2MeasReq(pst, measInfo)
Pst *pst; /* post structure */
RgInfL2MeasReq *measInfo; /* Meas Req Info */
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacL2MeasStopReq
+S16 RgSchMacL2MeasStopReq
(
Pst *pst, /* post structure */
RgInfL2MeasStopReq *measInfo /* Meas Req Info */
)
#else
-PUBLIC S16 RgSchMacL2MeasStopReq(pst, measInfo)
+S16 RgSchMacL2MeasStopReq(pst, measInfo)
Pst *pst; /* post structure */
RgInfL2MeasStopReq *measInfo; /* Meas Req Info */
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacL2MeasSendReq
+S16 RgSchMacL2MeasSendReq
(
Pst *pst, /* post structure */
RgInfL2MeasSndReq *measInfo /* Meas Req Info */
)
#else
-PUBLIC S16 RgSchMacL2MeasSendReq(pst, measInfo)
+S16 RgSchMacL2MeasSendReq(pst, measInfo)
Pst *pst; /* post structure */
RgInfL2MeasSndReq *measInfo; /* Meas Req Info */
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgL2Meas
+S16 rgL2Meas
(
RgCellCb *cell
)
#else
-PUBLIC S16 rgL2Meas(cell)
+S16 rgL2Meas(cell)
RgCellCb *cell;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgLIMTfuBndReq
+S16 rgLIMTfuBndReq
(
Inst inst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 rgLIMTfuBndReq(inst,suId, spId)
+S16 rgLIMTfuBndReq(inst,suId, spId)
Inst inst;
SuId suId;
SpId spId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgLIMTfuUbndReq
+S16 rgLIMTfuUbndReq
(
Inst inst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 rgLIMTfuUbndReq(inst,spId, reason)
+S16 rgLIMTfuUbndReq(inst,spId, reason)
Inst inst;
SpId spId;
Reason reason;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuBndCfm
+S16 RgLiTfuBndCfm
(
Pst *pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgLiTfuBndCfm(pst, suId, status)
+S16 RgLiTfuBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuDatInd
+S16 RgLiTfuDatInd
(
Pst *pst,
SuId suId,
TfuDatIndInfo *datInd
)
#else
-PUBLIC S16 RgLiTfuDatInd(pst, suId, datInd)
+S16 RgLiTfuDatInd(pst, suId, datInd)
Pst *pst;
SuId suId;
TfuDatIndInfo *datInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgLIMTfuDatReq
+S16 rgLIMTfuDatReq
(
Inst inst,
TfuDatReqInfo *datReq
)
#else
-PUBLIC S16 rgLIMTfuDatReq(inst,datReq)
+S16 rgLIMTfuDatReq(inst,datReq)
Inst inst;
TfuDatReqInfo *datReq;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgLIMTfuDelDatReq
+S16 rgLIMTfuDelDatReq
(
Inst inst,
TfuDelDatReqInfo *delDatReq
)
#else
-PUBLIC S16 rgLIMTfuDatReq(inst,delDatReq)
+S16 rgLIMTfuDatReq(inst,delDatReq)
Inst inst;
TfuDelDatReqInfo *delDatReq;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuNonRtInd
+S16 RgLiTfuNonRtInd
(
Pst *pst,
SuId suId
)
#else
-PUBLIC S16 RgLiTfuNonRtInd(pst, suId)
+S16 RgLiTfuNonRtInd(pst, suId)
Pst *pst;
SuId suId;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgActvInit
+S16 rgActvInit
(
Ent entity, /* entity */
Inst inst, /* instance */
Reason reason /* reason */
)
#else
-PUBLIC S16 rgActvInit(entity, inst, region, reason)
+S16 rgActvInit(entity, inst, region, reason)
Ent entity; /* entity */
Inst inst; /* instance */
Region region; /* region */
lwrMacCb.phyState = PHY_STATE_IDLE;
/* Initialize Scheduler as well */
- schActvInit(ENTRG, (DEFAULT_CELLS + SCH_INST_START), DFLT_REGION, PWR_UP);
+ schActvInit(ENTMAC, (DEFAULT_CELLS + SCH_INST_START), DFLT_REGION, PWR_UP);
/* Initialize lower mac */
lwrMacInit();
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgCfgReq
+S16 RgMiLrgCfgReq
(
Pst *pst, /* post structure */
RgMngmt *cfg /* config structure */
)
#else
-PUBLIC S16 RgMiLrgCfgReq(pst, cfg)
+S16 RgMiLrgCfgReq(pst, cfg)
Pst *pst; /* post structure */
RgMngmt *cfg; /* config structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgStsReq
+S16 RgMiLrgStsReq
(
Pst *pst, /* post structure */
RgMngmt *sts /* statistics structure */
)
#else
-PUBLIC S16 RgMiLrgStsReq(pst, sts)
+S16 RgMiLrgStsReq(pst, sts)
Pst *pst; /* post structure */
RgMngmt *sts; /* statistics structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgStaReq
+S16 RgMiLrgStaReq
(
Pst *pst, /* post structure */
RgMngmt *sta /* status structure */
)
#else
-PUBLIC S16 RgMiLrgStaReq(pst, sta)
+S16 RgMiLrgStaReq(pst, sta)
Pst *pst; /* post structure */
RgMngmt *sta; /* status structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgCntrlReq
+S16 RgMiLrgCntrlReq
(
Pst *pst, /* post structure */
RgMngmt *cntrl /* control structure */
)
#else
-PUBLIC S16 RgMiLrgCntrlReq(pst, cntrl)
+S16 RgMiLrgCntrlReq(pst, cntrl)
Pst *pst; /* post structure */
RgMngmt *cntrl; /* control structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgLMMStartTmr
+S16 rgLMMStartTmr
(
Inst inst,
S16 tmrEvnt, /* Timer Event */
PTR cb /* Entry for which Timer Expired */
)
#else
-PUBLIC S16 rgLMMStartTmr(tmrEvnt, tmrVal, cb)
+S16 rgLMMStartTmr(tmrEvnt, tmrVal, cb)
Inst inst;
S16 tmrEvnt; /* Timer Event */
U32 tmrVal; /* Wait Time */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgLMMStopTmr
+S16 rgLMMStopTmr
(
Inst inst, /* Scheduler instance */
S16 tmrEvnt, /* Timer Event */
PTR cb /* Entry for which Timer Expired */
)
#else
-PUBLIC S16 rgLMMStopTmr(inst,tmrEvnt, cb)
+S16 rgLMMStopTmr(inst,tmrEvnt, cb)
Inst inst; /* Scheduler instance */
S16 tmrEvnt; /* Timer Event */
PTR cb; /* Entry for which Timer Expired */
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgLMMTmrExpiry
+S16 rgLMMTmrExpiry
(
PTR cb, /* Pointer to timer control block */
S16 tmrEvnt /* Timer Event */
)
#else
-PUBLIC S16 rgLMMTmrExpiry(cb,tmrEvnt)
+S16 rgLMMTmrExpiry(cb,tmrEvnt)
PTR cb; /* Pointer to timer control block */
S16 tmrEvnt; /* Timer Event */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgLMMStaInd
+S16 rgLMMStaInd
(
Inst inst,
U16 category,
RgUstaDgn *dgn
)
#else
-PUBLIC S16 rgLMMStaInd(inst,category, event, cause, dgn)
+S16 rgLMMStaInd(inst,category, event, cause, dgn)
Inst inst;
U16 category;
U16 event;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgLMMTrcInd
+Void rgLMMTrcInd
(
Inst inst,
Buffer *srcMbuf, /* Message Buffer */
U8 event /* event */
)
#else
-PUBLIC Void rgLMMTrcInd(inst,srcMbuf,event)
+Void rgLMMTrcInd(inst,srcMbuf,event)
Inst inst;
Buffer *srcMbuf; /* Message Buffer */
U8 event; /* event */
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgLMMBndCfm
+S16 rgLMMBndCfm
(
Pst *pst, /* Post Structure */
SuId suId, /* Service user ID */
U8 status /* Status */
)
#else
-PUBLIC S16 rgLMMBndCfm(pst,suId,status)
+S16 rgLMMBndCfm(pst,suId,status)
Pst *pst; /* Post Structure */
SuId suId; /* Service user ID */
U8 status; /* Status */
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgActvTmr
+S16 rgActvTmr
(
Ent ent,
Inst inst
)
#else
-PUBLIC S16 rgActvTmr(ent, inst)
+S16 rgActvTmr(ent, inst)
Ent ent;
Inst inst;
#endif
U32 padSize = 0;
#endif
#ifdef ANSI
-PUBLIC S16 rgMUXAddPadd
+S16 rgMUXAddPadd
(
Inst inst,
MsgLen *schdTbSz,
RgErrInfo *err
)
#else
-PUBLIC S16 rgMUXAddPadd(inst,schdTbSz, sduBuf, isRar, err)
+S16 rgMUXAddPadd(inst,schdTbSz, sduBuf, isRar, err)
Inst inst;
MsgLen *schdTbSz;
Buffer *sduBuf;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgMUXBldPdu
+S16 rgMUXBldPdu
(
Inst inst,
RgBldPduInfo *pdu,
RgErrInfo *err
)
#else
-PUBLIC S16 rgMUXBldPdu(inst, pdu, txPdu, err)
+S16 rgMUXBldPdu(inst, pdu, txPdu, err)
Inst inst;
RgBldPduInfo *pdu;
Buffer **txPdu;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgMUXBldPdu
+S16 rgMUXBldPdu
(
Inst inst,
RgBldPduInfo *pdu,
RgErrInfo *err
)
#else
-PUBLIC S16 rgMUXBldPdu(inst, pdu, tb, err)
+S16 rgMUXBldPdu(inst, pdu, tb, err)
Inst inst;
RgBldPduInfo *pdu;
RgTfuDatReqTbInfo *tb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgMUXBldRarPdu
+S16 rgMUXBldRarPdu
(
RgCellCb *cell,
RgInfRaRntiInfo *alloc,
RgErrInfo *err
)
#else
-PUBLIC S16 rgMUXBldRarPdu(cell, alloc, txPdu, err)
+S16 rgMUXBldRarPdu(cell, alloc, txPdu, err)
RgCellCb *cell;
RgInfRaRntiInfo *alloc;
Buffer **txPdu;
*
**********************************************************/
#ifdef ANSI
-PUBLIC U16 rgMUXCalcRiv
+U16 rgMUXCalcRiv
(
U8 bw,
U8 rbStart,
U8 numRb
)
#else
-PUBLIC U16 rgMUXCalcRiv(bw, rbStart, numRb)
+U16 rgMUXCalcRiv(bw, rbStart, numRb)
U8 bw;
U8 rbStart;
U8 numRb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq
+S16 RgPrgPMacSMacUeSCellLchModReq
(
Pst *pst,
RgPrgUeSCellLchModInfo *lchCfgCb
)
#else
-PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq(pst, lchCfgCb)
+S16 RgPrgPMacSMacUeSCellLchModReq(pst, lchCfgCb)
Pst *pst;
RgPrgUeSCellLchModInfo *lchCfgCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgPomSndUeSCellLchDelToSmac
+S16 rgPomSndUeSCellLchDelToSmac
(
Inst inst,
CrgDel *lcDel,
Bool *isCfmRqrd
)
#else
-PUBLIC S16 rgPomSndUeSCellLchDelToSmac(inst,lcDel,isCfmRqrd)
+S16 rgPomSndUeSCellLchDelToSmac(inst,lcDel,isCfmRqrd)
Inst inst;
CrgDel *lcDel;
Bool *isCfmRqrd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgPomSndUeSCellLchModToSmac
+S16 rgPomSndUeSCellLchModToSmac
(
Inst inst,
RgCellCb *cell,
Bool *isCfmRqrd
)
#else
-PUBLIC S16 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lchRecfg, isCfmRqrd)
+S16 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lchRecfg, isCfmRqrd)
Inst inst;
RgCellCb *cell;
RgUeCb *ue;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgPomSndUeSCellLchAddToSmac
+S16 rgPomSndUeSCellLchAddToSmac
(
Inst inst,
RgCellCb *cell,
Bool *isCfmRqrd
)
#else
-PUBLIC S16 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lchCfg, isCfmRqrd)
+S16 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lchCfg, isCfmRqrd)
Inst inst;
RgCellCb *cell;
RgUeCb *ue;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq
+S16 RgPrgPMacSMacUeSCellLchDelReq
(
Pst *pst,
RgPrgUeSCellLchDelInfo *delLcCb
)
#else
-PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq(pst, delLcCb)
+S16 RgPrgPMacSMacUeSCellLchDelReq(pst, delLcCb)
Pst *pst;
RgPrgUeSCellLchDelInfo *delLcCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq
+S16 RgPrgPMacSMacUeSCellLchAddReq
(
Pst *pst,
RgPrgUeSCellLchAddInfo *lchCfgCb
)
#else
-PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq(pst, lchCfgCb)
+S16 RgPrgPMacSMacUeSCellLchAddReq(pst, lchCfgCb)
Pst *pst;
RgPrgUeSCellLchAddInfo *lchCfgCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgPomVldtAddLch
+S16 rgPomVldtAddLch
(
Inst inst,
RgPrgUeSCellLchAddInfo *lcCfg,
RgUeCb **ue
)
#else
-PUBLIC S16 rgPomVldtAddLch(inst,lcCfg, cell, ue)
+S16 rgPomVldtAddLch(inst,lcCfg, cell, ue)
Inst inst;
RgPrgUeSCellLchAddInfo *lcCfg;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgPomUeSCellLcAdd
+S16 rgPomUeSCellLcAdd
(
Inst inst,
RgCellCb *cell,
RgPrgUeSCellLchAddInfo *lcCfg
)
#else
-PUBLIC S16 rgPomUeSCellLcAdd(inst,cell, ue, lcCfg)
+S16 rgPomUeSCellLcAdd(inst,cell, ue, lcCfg)
Inst inst;
RgCellCb *cell;
RgUeCb *ue;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgPomVltdModLch
+S16 rgPomVltdModLch
(
Inst inst,
RgPrgUeSCellLchModInfo *lchCfgCb,
RgUlLcCb **ulLc
)
#else
-PUBLIC S16 rgPomVltdModLch(inst, lchCfgCb, cell, ue, ulLc)
+S16 rgPomVltdModLch(inst, lchCfgCb, cell, ue, ulLc)
Inst inst;
RgPrgUeSCellLchModInfo *lchCfgCb;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgPomUeSCellLcMod
+S16 rgPomUeSCellLcMod
(
Inst inst,
RgUeCb *ue,
RgPrgUeSCellLchModInfo *lchCfgCb
)
#else
-PUBLIC S16 rgPomUeSCellLcMod(inst,cell, ue, ulLc, lchCfgCb)
+S16 rgPomUeSCellLcMod(inst,cell, ue, ulLc, lchCfgCb)
Inst inst;
RgUeCb *ue;
RgUlLcCb *ulLc;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgPomVltdDelLch
+S16 rgPomVltdDelLch
(
Inst inst,
RgPrgUeSCellLchDelInfo *delLcCb,
RgDlLcCb **dlLc
)
#else
-PUBLIC S16 rgPomVltdDelLch(inst, delLcCb, cell, ue, ulLc, dlLc)
+S16 rgPomVltdDelLch(inst, delLcCb, cell, ue, ulLc, dlLc)
Inst inst;
RgPrgUeSCellLchDelInfo *delLcCb;
RgCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgPomUeSCellLcDel
+S16 rgPomUeSCellLcDel
(
Inst inst,
RgPrgUeSCellLchDelInfo *delLcCb,
RgDlLcCb *dlLc
)
#else
-PUBLIC S16 rgPomUeSCellLcDel(inst,delLcCb,ue,ulLc,dlLc)
+S16 rgPomUeSCellLcDel(inst,delLcCb,ue,ulLc,dlLc)
Inst inst;
RgPrgUeSCellLchDelInfo *delLcCb;
RgUeCb *ue;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkPrgPMacSMacUeSCellCfgReq
+S16 cmPkPrgPMacSMacUeSCellCfgReq
(
Pst *pst,
RgPrgUeSCellCfgInfo *ueSCellCfgInfo
)
#else
-PUBLIC S16 cmPkPrgPMacSMacUeSCellCfgReq(pst, ueSCellCfgInfo)
+S16 cmPkPrgPMacSMacUeSCellCfgReq(pst, ueSCellCfgInfo)
Pst *pst;
RgPrgUeSCellCfgInfo *ueSCellCfgInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellCfgReq
+S16 cmUnpkPrgPMacSMacUeSCellCfgReq
(
RgPrgUeSCellCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellCfgReq(func, pst, mBuf)
+S16 cmUnpkPrgPMacSMacUeSCellCfgReq(func, pst, mBuf)
RgPrgUeSCellCfgReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkPrgSMacPMacCfgCfm
+S16 cmPkPrgSMacPMacCfgCfm
(
Pst *pst,
RgPrgCfgCfmInfo *cfgCfm
)
#else
-PUBLIC S16 cmPkPrgSMacPMacCfgCfm(pst, cfgCfm)
+S16 cmPkPrgSMacPMacCfgCfm(pst, cfgCfm)
Pst *pst;
RgPrgCfgCfmInfo *cfgCfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPrgSMacPMacCfgCfm
+S16 cmUnpkPrgSMacPMacCfgCfm
(
RgSMacPMacCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPrgSMacPMacCfgCfm(func, pst, mBuf)
+S16 cmUnpkPrgSMacPMacCfgCfm(func, pst, mBuf)
RgSMacPMacCfgCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkPrgPMacSMacUeSCellDelReq
+S16 cmPkPrgPMacSMacUeSCellDelReq
(
Pst *pst,
RgPrgUeSCellDelInfo *ueSCellDelInfo
)
#else
-PUBLIC S16 cmPkPrgPMacSMacUeSCellDelReq(pst, ueSCellDelInfo)
+S16 cmPkPrgPMacSMacUeSCellDelReq(pst, ueSCellDelInfo)
Pst *pst;
RgPrgUeSCellDelInfo *ueSCellDelInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellDelReq
+S16 cmUnpkPrgPMacSMacUeSCellDelReq
(
RgUeSCellDelReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellDelReq(func, pst, mBuf)
+S16 cmUnpkPrgPMacSMacUeSCellDelReq(func, pst, mBuf)
RgUeSCellDelReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkPrgPMacSMacUeSCellLchAddReq
+S16 cmPkPrgPMacSMacUeSCellLchAddReq
(
Pst *pst,
RgPrgUeSCellLchAddInfo *lchCfgInfo,
)
#else
-PUBLIC S16 cmPkPrgPMacSMacUeSCellLchAddReq(pst, lchCfgInfo)
+S16 cmPkPrgPMacSMacUeSCellLchAddReq(pst, lchCfgInfo)
Pst *pst;
RgPrgUeSCellLchAddInfo *lchCfgInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellLchAddReq
+S16 cmUnpkPrgPMacSMacUeSCellLchAddReq
(
RgPrgUeSCellLchAddInfo func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellLchAddReq(func, pst, mBuf)
+S16 cmUnpkPrgPMacSMacUeSCellLchAddReq(func, pst, mBuf)
RgPrgUeSCellLchAddInfo func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkPrgPMacSMacUeSCellLchDelReq
+S16 cmPkPrgPMacSMacUeSCellLchDelReq
(
Pst *pst,
RgPrgUeSCellLchDelInfo *delLcCb
)
#else
-PUBLIC S16 cmPkPrgPMacSMacUeSCellLchDelReq(pst, delLcCb)
+S16 cmPkPrgPMacSMacUeSCellLchDelReq(pst, delLcCb)
Pst *pst;
RgPrgUeSCellLchDelInfo *delLcCb;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkPrgPMacSMacUeSCellLchModReq
+S16 cmPkPrgPMacSMacUeSCellLchModReq
(
Pst *pst,
RgPrgUeSCellLchModInfo *lchCfgInfo
)
#else
-PUBLIC S16 cmPkPrgPMacSMacUeSCellLchModReq(pst, lchCfgInfo)
+S16 cmPkPrgPMacSMacUeSCellLchModReq(pst, lchCfgInfo)
Pst *pst;
RgPrgUeSCellLchModInfo *lchCfgInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellLchModReq
+S16 cmUnpkPrgPMacSMacUeSCellLchModReq
(
RgPrgUeScellModLchReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPrgPMacSMacAddLchCfgReq(func, pst, mBuf)
+S16 cmUnpkPrgPMacSMacAddLchCfgReq(func, pst, mBuf)
RgPrgUeScellModLchReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellLchDelReq
+S16 cmUnpkPrgPMacSMacUeSCellLchDelReq
(
RgPrgUeScellDelLchReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPrgPMacSMacUeSCellLchDelReq(func, pst, mBuf)
+S16 cmUnpkPrgPMacSMacUeSCellLchDelReq(func, pst, mBuf)
RgPrgUeScellDelLchReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeSCellCfg
+S16 RgPrgPMacSMacUeSCellCfg
(
Pst *pst,
RgPrgUeSCellCfgInfo *ueSCellCfgInfo
)
#else
-PUBLIC S16 RgPrgPMacSMacUeSCellCfg(pst, ueSCellCfgInfo)
+S16 RgPrgPMacSMacUeSCellCfg(pst, ueSCellCfgInfo)
Pst *pst;
RgPrgUeSCellCfgInfo *ueSCellCfgInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgPrgSMacPMacCfg
+S16 RgPrgSMacPMacCfg
(
Pst *pst,
RgPrgCfgCfmInfo *cfgCfm
)
#else
-PUBLIC S16 RgPrgSMacPMacCfg(pst, cfgCfm)
+S16 RgPrgSMacPMacCfg(pst, cfgCfm)
Pst *pst;
RgPrgCfgCfmInfo *cfgCfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeSCellDel
+S16 RgPrgPMacSMacUeSCellDel
(
Pst *pst,
RgPrgUeSCellDelInfo *ueSCellDelInfo
)
#else
-PUBLIC S16 RgPrgPMacSMacUeSCellDel(pst, ueSCellDelInfo)
+S16 RgPrgPMacSMacUeSCellDel(pst, ueSCellDelInfo)
Pst *pst;
RgPrgUeSCellDelInfo *ueSCellDelInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeScellLchMod
+S16 RgPrgPMacSMacUeScellLchMod
(
Pst *pst,
RgPrgUeSCellLchModInfo *lchCfgInfo
)
#else
-PUBLIC S16 RgPrgPMacSMacUeScellLchMod(pst, lchCfgInfo)
+S16 RgPrgPMacSMacUeScellLchMod(pst, lchCfgInfo)
Pst *pst;
RgPrgUeSCellLchModInfo *lchCfgInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeScellLchDel
+S16 RgPrgPMacSMacUeScellLchDel
(
Pst *pst,
RgPrgUeSCellLchDelInfo *delLcCb
)
#else
-PUBLIC S16 RgPrgPMacSMacUeScellLchDel(pst, delLcCb)
+S16 RgPrgPMacSMacUeScellLchDel(pst, delLcCb)
Pst *pst;
RgPrgUeSCellLchDelInfo *delLcCb;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgPrgPMacSMacUeScellLchAdd
+S16 RgPrgPMacSMacUeScellLchAdd
(
Pst *pst,
RgPrgUeSCellLchAddInfo *lchCfgInfo
)
#else
-PUBLIC S16 RgPrgPMacSMacUeScellLchAdd(pst, lchCfgInfo)
+S16 RgPrgPMacSMacUeScellLchAdd(pst, lchCfgInfo)
Pst *pst;
RgPrgUeSCellLchAddInfo *lchCfgInfo;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuBndReq
+S16 RgLiTfuBndReq
(
Pst * pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 RgLiTfuBndReq(pst, suId, spId)
+S16 RgLiTfuBndReq(pst, suId, spId)
Pst * pst;
SuId suId;
SpId spId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuSchBndReq
+S16 RgLiTfuSchBndReq
(
Pst * pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 RgLiTfuSchBndReq(pst, suId, spId)
+S16 RgLiTfuSchBndReq(pst, suId, spId)
Pst * pst;
SuId suId;
SpId spId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuUbndReq
+S16 RgLiTfuUbndReq
(
Pst * pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 RgLiTfuUbndReq(pst, spId, reason)
+S16 RgLiTfuUbndReq(pst, spId, reason)
Pst * pst;
SpId spId;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuSchUbndReq
+S16 RgLiTfuSchUbndReq
(
Pst * pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 RgLiTfuSchUbndReq(pst, spId, reason)
+S16 RgLiTfuSchUbndReq(pst, spId, reason)
Pst * pst;
SpId spId;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuRecpReq
+S16 RgLiTfuRecpReq
(
Pst * pst,
SpId spId,
TfuRecpReqInfo * recpReq
)
#else
-PUBLIC S16 RgLiTfuRecpReq(pst, spId, recpReq)
+S16 RgLiTfuRecpReq(pst, spId, recpReq)
Pst * pst;
SpId spId;
TfuRecpReqInfo * recpReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuCntrlReq
+S16 RgLiTfuCntrlReq
(
Pst * pst,
SpId spId,
TfuCntrlReqInfo * cntrlReq
)
#else
-PUBLIC S16 RgLiTfuCntrlReq(pst, spId, cntrlReq)
+S16 RgLiTfuCntrlReq(pst, spId, cntrlReq)
Pst * pst;
SpId spId;
TfuCntrlReqInfo * cntrlReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuDatReq
+S16 RgLiTfuDatReq
(
Pst * pst,
SpId spId,
TfuDatReqInfo * datReq
)
#else
-PUBLIC S16 RgLiTfuDatReq(pst, spId, datReq)
+S16 RgLiTfuDatReq(pst, spId, datReq)
Pst * pst;
SpId spId;
TfuDatReqInfo * datReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgLiTfuDelDatReq
+S16 RgLiTfuDelDatReq
(
Pst * pst,
SpId spId,
TfuDelDatReqInfo * delDatReq
)
#else
-PUBLIC S16 RgLiTfuDelDatReq(pst, spId, delDatReq)
+S16 RgLiTfuDelDatReq(pst, spId, delDatReq)
Pst * pst;
SpId spId;
TfuDelDatReqInfo * delDatReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuBndReq
+S16 PtLiTfuBndReq
(
Pst * pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 PtLiTfuBndReq(pst, suId, spId)
+S16 PtLiTfuBndReq(pst, suId, spId)
Pst * pst;
SuId suId;
SpId spId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuSchBndReq
+S16 PtLiTfuSchBndReq
(
Pst * pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 PtLiTfuSchBndReq(pst, suId, spId)
+S16 PtLiTfuSchBndReq(pst, suId, spId)
Pst * pst;
SuId suId;
SpId spId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuUbndReq
+S16 PtLiTfuUbndReq
(
Pst * pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 PtLiTfuUbndReq(pst, spId, reason)
+S16 PtLiTfuUbndReq(pst, spId, reason)
Pst * pst;
SpId spId;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuSchUbndReq
+S16 PtLiTfuSchUbndReq
(
Pst * pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 PtLiTfuSchUbndReq(pst, spId, reason)
+S16 PtLiTfuSchUbndReq(pst, spId, reason)
Pst * pst;
SpId spId;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuRecpReq
+S16 PtLiTfuRecpReq
(
Pst * pst,
SpId spId,
TfuRecpReqInfo * recpReq
)
#else
-PUBLIC S16 PtLiTfuRecpReq(pst, spId, recpReq)
+S16 PtLiTfuRecpReq(pst, spId, recpReq)
Pst * pst;
SpId spId;
TfuRecpReqInfo * recpReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuCntrlReq
+S16 PtLiTfuCntrlReq
(
Pst * pst,
SpId spId,
TfuCntrlReqInfo * cntrlReq
)
#else
-PUBLIC S16 PtLiTfuCntrlReq(pst, spId, cntrlReq)
+S16 PtLiTfuCntrlReq(pst, spId, cntrlReq)
Pst * pst;
SpId spId;
TfuCntrlReqInfo * cntrlReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuDatReq
+S16 PtLiTfuDatReq
(
Pst * pst,
SpId spId,
TfuDatReqInfo * datReq
)
#else
-PUBLIC S16 PtLiTfuDatReq(pst, spId, datReq)
+S16 PtLiTfuDatReq(pst, spId, datReq)
Pst * pst;
SpId spId;
TfuDatReqInfo * datReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 PtLiTfuDelDatReq
+S16 PtLiTfuDelDatReq
(
Pst * pst,
SpId spId,
TfuDelDatReqInfo * delDatReq
)
#else
-PUBLIC S16 PtLiTfuDelDatReq(pst, spId, delDatReq)
+S16 PtLiTfuDelDatReq(pst, spId, delDatReq)
Pst * pst;
SpId spId;
TfuDelDatReqInfo * DelDatReq;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgCfgCfm
+S16 RgMiLrgCfgCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* config confirm structure */
)
#else
-PUBLIC S16 RgMiLrgCfgCfm(pst, cfm)
+S16 RgMiLrgCfgCfm(pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* config confirm structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchCfgCfm
+S16 RgMiLrgSchCfgCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* config confirm structure */
)
#else
-PUBLIC S16 RgMiLrgSchCfgCfm(pst, cfm)
+S16 RgMiLrgSchCfgCfm(pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* config confirm structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgStsCfm
+S16 RgMiLrgStsCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* statistics confirm structure */
)
#else
-PUBLIC S16 RgMiLrgStsCfm(pst, cfm)
+S16 RgMiLrgStsCfm(pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* statistics confirm structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgStaCfm
+S16 RgMiLrgStaCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* status confirm structure */
)
#else
-PUBLIC S16 RgMiLrgStaCfm(pst, cfm)
+S16 RgMiLrgStaCfm(pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* status confirm structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgCntrlCfm
+S16 RgMiLrgCntrlCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* control confirm structure */
)
#else
-PUBLIC S16 RgMiLrgCntrlCfm(pst, cfm)
+S16 RgMiLrgCntrlCfm(pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* control confirm structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchCntrlCfm
+S16 RgMiLrgSchCntrlCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* control confirm structure */
)
#else
-PUBLIC S16 RgMiLrgSchCntrlCfm(pst, cfm)
+S16 RgMiLrgSchCntrlCfm(pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* control confirm structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgStaInd
+S16 RgMiLrgStaInd
(
Pst *pst, /* post structure */
RgMngmt *usta /* status indication structure */
)
#else
-PUBLIC S16 RgMiLrgStaInd(pst, usta)
+S16 RgMiLrgStaInd(pst, usta)
Pst *pst; /* post structure */
RgMngmt *usta; /* status indication structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchStaInd
+S16 RgMiLrgSchStaInd
(
Pst *pst, /* post structure */
RgMngmt *usta /* status indication structure */
)
#else
-PUBLIC S16 RgMiLrgSchStaInd(pst, usta)
+S16 RgMiLrgSchStaInd(pst, usta)
Pst *pst; /* post structure */
RgMngmt *usta; /* status indication structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgTrcInd
+S16 RgMiLrgTrcInd
(
Pst *pst, /* post structure */
RgMngmt *trc, /* Trace event */
Buffer *mBuf /* Trace message */
)
#else
-PUBLIC S16 RgMiLrgTrcInd(pst, trc, mBuf)
+S16 RgMiLrgTrcInd(pst, trc, mBuf)
Pst *pst; /* post structure */
RgMngmt *trc; /* Trace event */
Buffer *mBuf; /* Trace message */
/* TODO: Function header */
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasCfm
+S16 RgMiLrgSchL2MeasCfm
(
Pst *pst, /* post structure */
LrgSchMeasCfmInfo *cfm /* Meas Cfm Info */
)
#else
-PUBLIC S16 RgMiLrgSchL2MeasCfm(pst, cfm)
+S16 RgMiLrgSchL2MeasCfm(pst, cfm)
Pst *pst; /* post structure */
LrgSchMeasCfmInfo *cfm; /* Meas Cfm Info */
#endif
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasStopCfm
+S16 RgMiLrgSchL2MeasStopCfm
(
Pst *pst, /* post structure */
LrgSchMeasCfmInfo *cfm /* Meas Cfm Info */
)
#else
-PUBLIC S16 RgMiLrgSchL2MeasStopCfm(pst, cfm)
+S16 RgMiLrgSchL2MeasStopCfm(pst, cfm)
Pst *pst; /* post structure */
LrgSchMeasCfmInfo *cfm; /* Meas Cfm Info */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgCfgCfm
+S16 PtMiLrgCfgCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* Config Confirm */
)
#else
-PUBLIC S16 PtMiLrgCfgCfm (pst, cfm)
+S16 PtMiLrgCfgCfm (pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* Config Confirm */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgSchCfgCfm
+S16 PtMiLrgSchCfgCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* Config Confirm */
)
#else
-PUBLIC S16 PtMiLrgSchCfgCfm (pst, cfm)
+S16 PtMiLrgSchCfgCfm (pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* Config Confirm */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgStsCfm
+S16 PtMiLrgStsCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* Statistics Confirm */
)
#else
-PUBLIC S16 PtMiLrgStsCfm (pst, cfm)
+S16 PtMiLrgStsCfm (pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* Statistics Confirm */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgStaCfm
+S16 PtMiLrgStaCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* Status Confirm */
)
#else
-PUBLIC S16 PtMiLrgStaCfm (pst, cfm)
+S16 PtMiLrgStaCfm (pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* Status Confirm */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgStaInd
+S16 PtMiLrgStaInd
(
Pst *pst, /* post structure */
RgMngmt *usta /* Status Indication */
)
#else
-PUBLIC S16 PtMiLrgStaInd (pst, usta)
+S16 PtMiLrgStaInd (pst, usta)
Pst *pst; /* post structure */
RgMngmt *usta; /* Status indication */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgSchStaInd
+S16 PtMiLrgSchStaInd
(
Pst *pst, /* post structure */
RgMngmt *usta /* Status Indication */
)
#else
-PUBLIC S16 PtMiLrgSchStaInd (pst, usta)
+S16 PtMiLrgSchStaInd (pst, usta)
Pst *pst; /* post structure */
RgMngmt *usta; /* Status indication */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgCntrlCfm
+S16 PtMiLrgCntrlCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* Control Confirm */
)
#else
-PUBLIC S16 PtMiLrgCntrlCfm (pst, cfm)
+S16 PtMiLrgCntrlCfm (pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* Control Confirm */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgSchCntrlCfm
+S16 PtMiLrgSchCntrlCfm
(
Pst *pst, /* post structure */
RgMngmt *cfm /* Control Confirm */
)
#else
-PUBLIC S16 PtMiLrgSchCntrlCfm (pst, cfm)
+S16 PtMiLrgSchCntrlCfm (pst, cfm)
Pst *pst; /* post structure */
RgMngmt *cfm; /* Control Confirm */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgTrcInd
+S16 PtMiLrgTrcInd
(
Pst *pst, /* post structure */
RgMngmt *trc, /* Trace Event */
Buffer *mBuf /* Trace message */
)
#else
-PUBLIC S16 PtMiLrgTrcInd (pst, trc,mBuf)
+S16 PtMiLrgTrcInd (pst, trc,mBuf)
Pst *pst; /* post structure */
RgMngmt *trc; /* Trace Event */
Buffer *mBuf; /* Trace message */
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgSchL2MeasCfm
+S16 PtMiLrgSchL2MeasCfm
(
Pst *pst, /* post structure */
LrgSchMeasCfmInfo *cfm /* Measurement Confirm */
)
#else
-PUBLIC S16 PtMiLrgSchL2MeasCfm(pst, cfm)
+S16 PtMiLrgSchL2MeasCfm(pst, cfm)
Pst *pst; /* post structure */
LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtMiLrgSchL2MeasStopCfm
+S16 PtMiLrgSchL2MeasStopCfm
(
Pst *pst, /* post structure */
LrgSchMeasCfmInfo *cfm /* Measurement Confirm */
)
#else
-PUBLIC S16 PtMiLrgSchL2MeasStopCfm(pst, cfm)
+S16 PtMiLrgSchL2MeasStopCfm(pst, cfm)
Pst *pst; /* post structure */
LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
#endif
S16 RgUiRguFlowCntrlInd(Pst* pst, SuId suId, RguFlowCntrlInd *flowCntrlInd);
#ifdef LTE_L2_MEAS
#ifdef MAC_RLC_HARQ_STA_RBUF
-PUBLIC S16 RgUiRguHqStaIndRbuf ARGS((Pst* pst,SuId suId,RguHarqStatusInd *harqStatusInd));
+S16 RgUiRguHqStaIndRbuf ARGS((Pst* pst,SuId suId,RguHarqStatusInd *harqStatusInd));
#endif
#endif
#endif /*--#ifdef PTRGUIRGR--*/
#ifdef PTRGUIRGM
-PUBLIC S16 PtUiRgmPrbRprtInd ARGS((Pst* pst, SuId suId, RgmPrbRprtInd *prbRprtInd));
-PUBLIC S16 PtUiRgmBndCfm ARGS((Pst* pst, SuId suId, U8 status));
-PUBLIC S16 PtUiRgmTransModeInd ARGS((Pst* pst, SuId suId, RgmTransModeInd *transModeInd));
+S16 PtUiRgmPrbRprtInd ARGS((Pst* pst, SuId suId, RgmPrbRprtInd *prbRprtInd));
+S16 PtUiRgmBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+S16 PtUiRgmTransModeInd ARGS((Pst* pst, SuId suId, RgmTransModeInd *transModeInd));
#endif
-PUBLIC S16 RgUiRgmSendPrbRprtInd ARGS((Pst* pst, SuId suId, RgmPrbRprtInd *prbRprtInd));
-PUBLIC S16 RgUiRgmChangeTransModeInd ARGS((Pst* pst, SuId suId, RgmTransModeInd *transModeInd));
+S16 RgUiRgmSendPrbRprtInd ARGS((Pst* pst, SuId suId, RgmPrbRprtInd *prbRprtInd));
+S16 RgUiRgmChangeTransModeInd ARGS((Pst* pst, SuId suId, RgmTransModeInd *transModeInd));
-PUBLIC S16 RgUiRguFlowCntrlInd ARGS((Pst* pst, SuId suId, RguFlowCntrlInd *flowCntrlInd));
+S16 RgUiRguFlowCntrlInd ARGS((Pst* pst, SuId suId, RguFlowCntrlInd *flowCntrlInd));
/* Added for sending TTI tick to RRM */
/** @brief TTI indication from MAC to RRM */
PRIVATE CONSTANT RgrTtiInd RgUiRgrTtiIndMt[RG_MAX_RGR_USR] =
PtUiRguBndCfm,
#endif
#ifdef KW
- KwLiRguBndCfm,
+ RlcLiRguBndCfm,
#else
PtUiRguBndCfm,
#endif
PtUiRguCDatInd,
#endif
#ifdef KW
- KwLiRguCDatInd,
+ RlcLiRguCDatInd,
#else
PtUiRguCDatInd,
#endif
PtUiRguDDatInd,
#endif
#ifdef KW
- KwLiRguDDatInd,
+ RlcLiRguDDatInd,
#else
PtUiRguDDatInd,
#endif
PtUiRguHqStaInd,
#endif
#ifdef KW
- KwLiRguHqStaInd,
+ RlcLiRguHqStaInd,
#else
PtUiRguHqStaInd,
#endif
PtUiRguFlowCntrlInd,
#endif
#ifdef KW
- KwLiRguFlowCntrlInd,
+ RlcLiRguFlowCntrlInd,
#else
PtUiRguFlowCntrlInd,
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrBndCfm
+S16 RgUiRgrBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgUiRgrBndCfm(pst, suId, status)
+S16 RgUiRgrBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgmBndCfm
+S16 RgUiRgmBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgUiRgmBndCfm(pst, suId, status)
+S16 RgUiRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrTtiInd
+S16 RgUiRgrTtiInd
(
Pst* pst,
SuId suId,
RgrTtiIndInfo *ttiInd
)
#else
-PUBLIC S16 RgUiRgrTtiInd(pst, suId, ttiInd)
+S16 RgUiRgrTtiInd(pst, suId, ttiInd)
Pst* pst;
SuId suId;
RgrTtiIndInfo *ttiInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrCfgCfm
+S16 RgUiRgrCfgCfm
(
Pst* pst,
RgrCfgTransId transId,
U8 status
)
#else
-PUBLIC S16 RgUiRgrCfgCfm(pst, transId, status)
+S16 RgUiRgrCfgCfm(pst, transId, status)
Pst* pst;
RgrCfgTransId transId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiCrgBndCfm
+S16 RgUiCrgBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgUiCrgBndCfm(pst, suId, status)
+S16 RgUiCrgBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiCrgCfgCfm
+S16 RgUiCrgCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgUiCrgCfgCfm(pst, suId, transId, status)
+S16 RgUiCrgCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CrgCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguBndCfm
+S16 RgUiRguBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgUiRguBndCfm(pst, suId, status)
+S16 RgUiRguBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
}
-PUBLIC int macDDatIndSnt;
-PUBLIC int macCDatIndSnt;
+int macDDatIndSnt;
+int macCDatIndSnt;
\f
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguCDatInd
+S16 RgUiRguCDatInd
(
Pst* pst,
SuId suId,
RguCDatIndInfo * datInd
)
#else
-PUBLIC S16 RgUiRguCDatInd(pst, suId, datInd)
+S16 RgUiRguCDatInd(pst, suId, datInd)
Pst* pst;
SuId suId;
RguCDatIndInfo * datInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguDDatInd
+S16 RgUiRguDDatInd
(
Pst* pst,
SuId suId,
RguDDatIndInfo * datInd
)
#else
-PUBLIC S16 RgUiRguDDatInd(pst, suId, datInd)
+S16 RgUiRguDDatInd(pst, suId, datInd)
Pst* pst;
SuId suId;
RguDDatIndInfo * datInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguCStaInd
+S16 RgUiRguCStaInd
(
Pst* pst,
SuId suId,
RguCStaIndInfo * staInd
)
#else
-PUBLIC S16 RgUiRguCStaInd(pst, suId, staInd)
+S16 RgUiRguCStaInd(pst, suId, staInd)
Pst* pst;
SuId suId;
RguCStaIndInfo * staInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguDStaInd
+S16 RgUiRguDStaInd
(
Pst* pst,
SuId suId,
RguDStaIndInfo * staInd
)
#else
-PUBLIC S16 RgUiRguDStaInd(pst, suId, staInd)
+S16 RgUiRguDStaInd(pst, suId, staInd)
Pst* pst;
SuId suId;
RguDStaIndInfo * staInd;
#ifdef LTE_L2_MEAS
/* TODO: Function header */
#ifdef ANSI
-PUBLIC S16 RgUiRguHqStaInd
+S16 RgUiRguHqStaInd
(
Pst* pst,
SuId suId,
RguHarqStatusInd *harqStatusInd
)
#else
-PUBLIC S16 RgUiRguHqStaInd(pst, suId, harqStatusInd)
+S16 RgUiRguHqStaInd(pst, suId, harqStatusInd)
Pst* pst;
SuId suId;
RguHarqStatusInd *harqStatusInd;
#endif /* LTE_L2_MEAS */
#ifdef ANSI
-PUBLIC S16 RgUiRguFlowCntrlInd
+S16 RgUiRguFlowCntrlInd
(
Pst* pst,
SuId suId,
RguFlowCntrlInd *flowCntrlInd
)
#else
-PUBLIC S16 RgUiRguFlowCntrlInd(pst, suId, harqStatusInd)
+S16 RgUiRguFlowCntrlInd(pst, suId, harqStatusInd)
Pst* pst;
SuId suId;
RguFlowCntrlInd *flowCntrlInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrSiCfgCfm
+S16 RgUiRgrSiCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgUiRgrSiCfgCfm(pst, suId, transId, status)
+S16 RgUiRgrSiCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrWarningSiCfgCfm
+S16 RgUiRgrWarningSiCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgUiRgrWarningSiCfgCfm(pst, suId, transId, siId,status)
+S16 RgUiRgrWarningSiCfgCfm(pst, suId, transId, siId,status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrStaInd
+S16 RgUiRgrStaInd
(
Pst* pst,
SuId suId,
RgrStaIndInfo *staInd
)
#else
-PUBLIC S16 RgUiRgrStaInd(pst, suId, staInd)
+S16 RgUiRgrStaInd(pst, suId, staInd)
Pst* pst;
SuId suId;
RgrStaIndInfo *staInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrLoadInfInd
+S16 RgUiRgrLoadInfInd
(
Pst* pst,
SuId suId,
RgrLoadInfIndInfo *loadInfInd
)
#else
-PUBLIC S16 RgUiRgrLoadInfInd(pst, suId, loadInfInd)
+S16 RgUiRgrLoadInfInd(pst, suId, loadInfInd)
Pst* pst;
SuId suId;
RgrLoadInfIndInfo *loadInfInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrUeStaInd
+S16 RgUiRgrUeStaInd
(
Pst *pst,
SuId suId,
RgrUeStaIndInfo *ueStaInd
)
#else
-PUBLIC S16 RgUiRgrUeStaInd(pst, suId, ueStaInd)
+S16 RgUiRgrUeStaInd(pst, suId, ueStaInd)
Pst *pst;
SuId suId;
RgrUeStaIndInfo *ueStaInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiCrgBndCfm
+S16 PtUiCrgBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiCrgBndCfm(pst, suId, status)
+S16 PtUiCrgBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiCrgCfgCfm
+S16 PtUiCrgCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiCrgCfgCfm(pst, suId, transId, status)
+S16 PtUiCrgCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CrgCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRguBndCfm
+S16 PtUiRguBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiRguBndCfm(pst, suId, status)
+S16 PtUiRguBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRguCDatInd
+S16 PtUiRguCDatInd
(
Pst* pst,
SuId suId,
RguCDatIndInfo * datInd
)
#else
-PUBLIC S16 PtUiRguCDatInd(pst, suId, datInd)
+S16 PtUiRguCDatInd(pst, suId, datInd)
Pst* pst;
SuId suId;
RguCDatIndInfo * datInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRguDDatInd
+S16 PtUiRguDDatInd
(
Pst* pst,
SuId suId,
RguDDatIndInfo * datInd
)
#else
-PUBLIC S16 PtUiRguDDatInd(pst, suId, datInd)
+S16 PtUiRguDDatInd(pst, suId, datInd)
Pst* pst;
SuId suId;
RguDDatIndInfo * datInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRguCStaInd
+S16 PtUiRguCStaInd
(
Pst* pst,
SuId suId,
RguCStaIndInfo * staInd
)
#else
-PUBLIC S16 PtUiRguCStaInd(pst, suId, staInd)
+S16 PtUiRguCStaInd(pst, suId, staInd)
Pst* pst;
SuId suId;
RguCStaIndInfo * staInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRguDStaInd
+S16 PtUiRguDStaInd
(
Pst* pst,
SuId suId,
RguDStaIndInfo * staInd
)
#else
-PUBLIC S16 PtUiRguDStaInd(pst, suId, staInd)
+S16 PtUiRguDStaInd(pst, suId, staInd)
Pst* pst;
SuId suId;
RguDStaIndInfo * staInd;
#ifdef LTE_L2_MEAS
/* TODO: Function Header */
#ifdef ANSI
-PUBLIC S16 PtUiRguHqStaInd
+S16 PtUiRguHqStaInd
(
Pst* pst,
SuId suId,
RguHarqStatusInd *harqStatusInd
)
#else
-PUBLIC S16 PtUiRguHqStaInd(pst, suId, harqStatusInd)
+S16 PtUiRguHqStaInd(pst, suId, harqStatusInd)
Pst* pst;
SuId suId;
RguHarqStatusInd *harqStatusInd;
#endif /* LTE_L2_MEAS */
#ifdef ANSI
-PUBLIC S16 PtUiRguFlowCntrlInd
+S16 PtUiRguFlowCntrlInd
(
Pst* pst,
SuId suId,
RguFlowCntrlInd *flowCntrlInd
)
#else
-PUBLIC S16 PtUiRguFlowCntrlInd(pst, suId, flowCntrlInd)
+S16 PtUiRguFlowCntrlInd(pst, suId, flowCntrlInd)
Pst* pst;
SuId suId;
RguHarqStatusInd *flowCntrlInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrBndCfm
+S16 PtUiRgrBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiRgrBndCfm(pst, suId, status)
+S16 PtUiRgrBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrTtiInd
+S16 PtUiRgrTtiInd
(
Pst* pst,
SuId suId,
RgrTtiIndInfo *ttiInd
)
#else
-PUBLIC S16 PtUiRgrTtiInd(pst, suId, ttiInd)
+S16 PtUiRgrTtiInd(pst, suId, ttiInd)
Pst* pst;
SuId suId;
RgrTtiIndInfo *ttiInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrCfgCfm
+S16 PtUiRgrCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiRgrCfgCfm(pst, suId, transId, status)
+S16 PtUiRgrCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrSiCfgCfm
+S16 PtUiRgrSiCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiRgrSiCfgCfm(pst, suId, transId, status)
+S16 PtUiRgrSiCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrWarningSiCfgCfm
+S16 PtUiRgrWarningSiCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
+S16 PtUiRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrStaInd
+S16 PtUiRgrStaInd
(
Pst* pst,
SuId suId,
RgrStaIndInfo *staInd
)
#else
-PUBLIC S16 PtUiRgrStaInd(pst, suId, staInd)
+S16 PtUiRgrStaInd(pst, suId, staInd)
Pst* pst;
SuId suId;
RgrStaIndInfo *staInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrLoadInfInd
+S16 PtUiRgrLoadInfInd
(
Pst* pst,
SuId suId,
RgrLoadInfIndInfo *loadInfInd
)
#else
-PUBLIC S16 PtUiRgrLoadInfInd(pst, suId, loadInfInd)
+S16 PtUiRgrLoadInfInd(pst, suId, loadInfInd)
Pst* pst;
SuId suId;
RgrLoadInfIndInfo *loadInfInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgrUeStaInd
+S16 PtUiRgrUeStaInd
(
Pst* pst,
SuId suId,
RgrUeStaIndInfo *ueStaInd
)
#else
-PUBLIC S16 PtUiRgrUeStaInd(pst, suId, ueStaInd)
+S16 PtUiRgrUeStaInd(pst, suId, ueStaInd)
Pst* pst;
SuId suId;
RgrUeStaIndInfo *ueStaInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgmBndCfm
+S16 PtUiRgmBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 PtUiRgmBndCfm(pst, suId, status)
+S16 PtUiRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgmPrbRprtInd
+S16 PtUiRgmPrbRprtInd
(
Pst* pst,
SuId suId,
RgmPrbRprtInd *prbRprtInd
)
#else
-PUBLIC S16 PtUiRgmPrbRprtInd(pst, suId, prbRprtInd)
+S16 PtUiRgmPrbRprtInd(pst, suId, prbRprtInd)
Pst* pst;
SuId suId;
RgmPrbRprtInd *prbRprtInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 PtUiRgmTransModeInd
+S16 PtUiRgmTransModeInd
(
Pst* pst,
SuId suId,
RgmTransModeInd *transModeInd
)
#else
-PUBLIC S16 PtUiRgmTransModeInd(pst, suId, transModeInd)
+S16 PtUiRgmTransModeInd(pst, suId, transModeInd)
Pst* pst;
SuId suId;
RgmTransModeInd *transModeInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgmSendPrbRprtInd
+S16 RgUiRgmSendPrbRprtInd
(
Pst* pst,
SuId suId,
RgmPrbRprtInd *prbRprtInd
)
#else
-PUBLIC S16 RgUiRgmSendPrbRprtInd(pst, suId, prbRprtInd)
+S16 RgUiRgmSendPrbRprtInd(pst, suId, prbRprtInd)
Pst* pst;
SuId suId;
RgmPrbRprtInd *prbRprtInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgmChangeTransModeInd
+S16 RgUiRgmChangeTransModeInd
(
Pst* pst,
SuId suId,
RgmTransModeInd *transModeInd
)
#else
-PUBLIC S16 RgUiRgmChangeTransModeInd(pst, suId, transModeInd)
+S16 RgUiRgmChangeTransModeInd(pst, suId, transModeInd)
Pst* pst;
SuId suId;
RgmTransModeInd *transModeInd;
#endif
#ifdef RLC_MAC_DAT_REQ_RBUF
#ifdef ANSI
-PUBLIC S16 rgDlDatReqBatchProc
+S16 rgDlDatReqBatchProc
(
Void
)
#else
-PUBLIC S16 rgDlDatReqBatchProc()
+S16 rgDlDatReqBatchProc()
Void;
#endif
{
/* Read from Ring Buffer and process PDCP packets */
U8 rngBufDeqIndx = 0;
- PRIVATE Pst rgDDatRbfuPst ={1,1,ENTRG,0,ENTKW,1,PRIOR0,RTESPEC,EVTRGUDDATREQ,0,0,2,0};
- PRIVATE Pst rgCDatRbfuPst ={1,1,ENTRG,0,ENTKW,1,PRIOR0,RTESPEC,EVTRGUCDATREQ,0,0,2,0};
+ PRIVATE Pst rgDDatRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUDDATREQ,0,0,2,0};
+ PRIVATE Pst rgCDatRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUCDATREQ,0,0,2,0};
Void *elmIndx = NULLP;
RguInfoRingElem *datReqRing=NULLP;
elmIndx = SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ);
#ifdef RLC_MAC_STA_RSP_RBUF
#ifdef ANSI
-PUBLIC S16 rgDlStaRspBatchProc
+S16 rgDlStaRspBatchProc
(
Void
)
#else
-PUBLIC S16 rgDlStaRspBatchProc()
+S16 rgDlStaRspBatchProc()
Void;
#endif
{
/* Read from Ring Buffer and process PDCP packets */
U8 rngBufDeqIndx = 0;
- PRIVATE Pst rgDStaRbfuPst ={1,1,ENTRG,0,ENTKW,1,PRIOR0,RTESPEC,EVTRGUDSTARSP,0,0,2,0};
- PRIVATE Pst rgCStaRbfuPst ={1,1,ENTRG,0,ENTKW,1,PRIOR0,RTESPEC,EVTRGUCSTARSP,0,0,2,0};
+ PRIVATE Pst rgDStaRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUDSTARSP,0,0,2,0};
+ PRIVATE Pst rgCStaRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUCSTARSP,0,0,2,0};
Void *elmIndx = NULLP;
RguInfoRingElem *staRspRing=NULLP;
#ifdef LTE_L2_MEAS
#ifdef MAC_RLC_HARQ_STA_RBUF
#ifdef ANSI
-PUBLIC S16 RgUiRguHqStaIndRbuf
+S16 RgUiRguHqStaIndRbuf
(
Pst* pst,
SuId suId,
RguHarqStatusInd *harqStatusInd
)
#else
-PUBLIC S16 RgUiRguHqStaIndRbuf(pst, suId, harqStatusInd)
+S16 RgUiRguHqStaIndRbuf(pst, suId, harqStatusInd)
Pst* pst;
SuId suId;
RguHarqStatusInd *harqStatusInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgRAMFreeUeCb
+Void rgRAMFreeUeCb
(
Inst inst,
RgUeCb *ue
)
#else
-PUBLIC Void rgRAMFreeUeCb(inst,ue)
+Void rgRAMFreeUeCb(inst,ue)
Inst inst;
RgUeCb *ue;
#endif
* @return RgUeCb*
**/
#ifdef ANSI
-PUBLIC RgUeCb* rgRAMCreateUeCb
+RgUeCb* rgRAMCreateUeCb
(
RgCellCb *cell,
CmLteRnti tmpCrnti,
RgErrInfo *err
)
#else
-PUBLIC RgUeCb* rgRAMCreateUeCb(cell, tmpCrnti, insert, err)
+RgUeCb* rgRAMCreateUeCb(cell, tmpCrnti, insert, err)
RgCellCb *cell;
CmLteRnti tmpCrnti;
Bool insert;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgRAMFreeCell
+S16 rgRAMFreeCell
(
RgCellCb *cell
)
#else
-PUBLIC S16 rgRAMFreeCell(cell)
+S16 rgRAMFreeCell(cell)
RgCellCb *cell;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgHndlRaResp
+S16 rgHndlRaResp
(
RgCellCb *cell,
CmLteTimingInfo timingInfo,
RgErrInfo *err
)
#else
-PUBLIC S16 rgHndlRaResp(cell, timingInfo, rarInfo, err)
+S16 rgHndlRaResp(cell, timingInfo, rarInfo, err)
RgCellCb *cell;
CmLteTimingInfo timingInfo;
RgInfRarInfo *rarInfo;
#ifdef LTEMAC_DLUE_TMGOPTMZ
PRIVATE S16 rgROMUpdDlSfRemDataCnt ARGS((RgCellCb *cellCb,
RgDlSf *dlSf));
-PUBLIC S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf,
+S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf,
RgCellCb *cellCb,
RgErrInfo *err));
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgROMDedDatReq
+S16 rgROMDedDatReq
(
Inst inst,
RgRguDedDatReq *datReq
)
#else
-PUBLIC S16 rgROMDedDatReq(inst,datReq)
+S16 rgROMDedDatReq(inst,datReq)
Inst inst;
RgRguDedDatReq *datReq;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgROMCmnDatReq
+S16 rgROMCmnDatReq
(
Inst inst,
RgRguCmnDatReq *datReq
)
#else
-PUBLIC S16 rgROMCmnDatReq(inst,datReq)
+S16 rgROMCmnDatReq(inst,datReq)
Inst inst;
RgRguCmnDatReq *datReq;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgROMDedStaRsp
+S16 rgROMDedStaRsp
(
Inst inst,
RgRguDedStaRsp *staRsp
)
#else
-PUBLIC S16 rgROMDedStaRsp(inst,staRsp)
+S16 rgROMDedStaRsp(inst,staRsp)
Inst inst;
RgRguDedStaRsp *staRsp;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgROMCmnStaRsp
+S16 rgROMCmnStaRsp
(
Inst inst,
RgRguCmnStaRsp *staRsp
)
#else
-PUBLIC S16 rgROMCmnStaRsp(inst,staRsp)
+S16 rgROMCmnStaRsp(inst,staRsp)
Inst inst;
RgRguCmnStaRsp *staRsp;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgROML2MUlThrpMeasReq
+S16 rgROML2MUlThrpMeasReq
(
Inst inst,
RgRguL2MUlThrpMeasReq *measReq
)
#else
-PUBLIC S16 rgROML2MUlThrpMeasReq(inst,measReq)
+S16 rgROML2MUlThrpMeasReq(inst,measReq)
Inst inst;
RgRguL2MUlThrpMeasReq *measReq;
#endif
PRIVATE S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf, RgCellCb *cellCb,
RgErrInfo *err));
#else
-PUBLIC S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
+S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
RgErrInfo *err));
#endif
PRIVATE S16 rgTOMProcCrntiCEInDatInd ARGS((
U16 slot
));
-PUBLIC S16 rgHndlFlowCntrl
+S16 rgHndlFlowCntrl
(
RgCellCb *cell,
RgInfSfAlloc *sfInfo
}
/* global variables */
-PUBLIC U32 rgUlrate_tfu;
+U32 rgUlrate_tfu;
#ifdef EMTC_ENABLE
EXTERN U32 grgUlrate_tfu;
#endif
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgTOMUtlProcDlSf
+S16 rgTOMUtlProcDlSf
(
RgDlSf *dlSf,
RgCellCb *cellCb,
RgErrInfo *err
)
#else
-PUBLIC S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
+S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
RgDlSf *dlSf;
RgCellCb *cellCb;
RgErrInfo *err;
}
#ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
{
- extern S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId,
+ extern S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
- if(ROK == kwProcDlStatusPdu(&(cellCb->rguDlSap->sapCfg.sapPst),
+ if(ROK == rlcProcDlStatusPdu(&(cellCb->rguDlSap->sapCfg.sapPst),
cellCb->rguDlSap->sapCfg.suId,
cellCb->cellId,ueCb->ueId,sdu->lcId,sdu->mBuf))
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgTOMDatInd
+S16 rgTOMDatInd
(
Inst inst,
TfuDatIndInfo *datInd
)
#else
-PUBLIC S16 rgTOMDatInd(inst,datInd)
+S16 rgTOMDatInd(inst,datInd)
Inst inst;
TfuDatIndInfo *datInd;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgTOMRlsSf
+Void rgTOMRlsSf
(
Inst inst,
RgDlSf *dlSf
)
#else
-PUBLIC Void rgTOMRlsSf(dlSf)
+Void rgTOMRlsSf(dlSf)
Inst inst;
RgDlSf *dlSf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgHndlFlowCntrl
+S16 rgHndlFlowCntrl
(
RgCellCb *cell,
RgInfSfAlloc *sfInfo
)
#else
-PUBLIC S16 rgHndlFlowCntrl(cell, sfInfo)
+S16 rgHndlFlowCntrl(cell, sfInfo)
RgCellCb *cell;
RgInfSfAlloc *sfInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacSfAllocReq
+S16 RgSchMacSfAllocReq
(
Pst *pst,
RgInfSfAlloc *sfInfo
)
#else
-PUBLIC S16 RgSchMacSfAllocReq(pst, sfInfo)
+S16 RgSchMacSfAllocReq(pst, sfInfo)
Pst *pst;
RgInfSfAlloc *sfInfo;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgUHMCrgUeCfg
+Void rgUHMCrgUeCfg
(
RgCellCb *cellCb,
RgUeCb *ueCb,
CrgUeCfg *ueCfg
)
#else
-PUBLIC Void rgUHMCrgUeCfg(cellCb, ueCb, ueCfg)
+Void rgUHMCrgUeCfg(cellCb, ueCb, ueCfg)
RgCellCb *cellCb;
RgUeCb *ueCb;
CrgUeCfg *ueCfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgUHMCrgUeRecfg
+Void rgUHMCrgUeRecfg
(
RgCellCb *cellCb,
RgUeCb *ueCb,
CrgUeRecfg *ueRecfg
)
#else
-PUBLIC Void rgUHMCrgUeRecfg(cellCb, ueCb, ueRecfg)
+Void rgUHMCrgUeRecfg(cellCb, ueCb, ueRecfg)
RgCellCb *cellCb;
RgUeCb *ueCb;
CrgUeRecfg *ueRecfg;
/* forward references */
#if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
-PUBLIC S16 rgBatchProc(Void);
+S16 rgBatchProc(Void);
#endif
-PUBLIC U8 rgRguDlSap;
-PUBLIC U8 rgRguUlSap;
+U8 rgRguDlSap;
+U8 rgRguUlSap;
/**
* @brief Handler for Bind request.
*
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguBndReq
+S16 RgUiRguBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 RgUiRguBndReq(pst, suId, spId)
+S16 RgUiRguBndReq(pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguUbndReq
+S16 RgUiRguUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 RgUiRguUbndReq(pst, spId, reason)
+S16 RgUiRguUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgUIMRguBndCfm
+S16 rgUIMRguBndCfm
(
Inst inst,
SpId spId,
U8 status
)
#else
-PUBLIC S16 rgUIMRguBndCfm(inst,spId, status)
+S16 rgUIMRguBndCfm(inst,spId, status)
Inst inst;
SpId spId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguDDatReq
+S16 RgUiRguDDatReq
(
Pst *pst,
SpId spId,
RguDDatReqInfo *datReq
)
#else
-PUBLIC S16 RgUiRguDDatReq(pst, spId, datReq)
+S16 RgUiRguDDatReq(pst, spId, datReq)
Pst *pst;
SpId spId;
RguDDatReqInfo *datReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguCDatReq
+S16 RgUiRguCDatReq
(
Pst *pst,
SpId spId,
RguCDatReqInfo *datReq
)
#else
-PUBLIC S16 RgUiRguCDatReq(pst, spId, datReq)
+S16 RgUiRguCDatReq(pst, spId, datReq)
Pst *pst;
SpId spId;
RguCDatReqInfo *datReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguDStaRsp
+S16 RgUiRguDStaRsp
(
Pst *pst,
SpId spId,
RguDStaRspInfo *staRsp
)
#else
-PUBLIC S16 RgUiRguDStaRsp(pst, spId, staRsp)
+S16 RgUiRguDStaRsp(pst, spId, staRsp)
Pst *pst;
SpId spId;
RguDStaRspInfo *staRsp;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguCStaRsp
+S16 RgUiRguCStaRsp
(
Pst *pst,
SpId spId,
RguCStaRspInfo *staRsp
)
#else
-PUBLIC S16 RgUiRguCStaRsp(pst, spId, staRsp)
+S16 RgUiRguCStaRsp(pst, spId, staRsp)
Pst *pst;
SpId spId;
RguCStaRspInfo *staRsp;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRguL2MUlThrpMeasReq
+S16 RgUiRguL2MUlThrpMeasReq
(
Pst *pst,
SpId spId,
RguL2MUlThrpMeasReqInfo *measReq
)
#else
-PUBLIC S16 RgUiRguL2MUlThrpMeasReq(pst, spId, measReq)
+S16 RgUiRguL2MUlThrpMeasReq(pst, spId, measReq)
Pst *pst;
SpId spId;
RguL2MUlThrpMeasReqInfo *measReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgUIMSndDedStaInd
+S16 rgUIMSndDedStaInd
(
Inst inst,
RgUpSapCb *rguSap,
RgRguDedStaInd *staInd
)
#else
-PUBLIC S16 rgUIMSndDedStaInd(inst,rguSap,staInd)
+S16 rgUIMSndDedStaInd(inst,rguSap,staInd)
Inst inst;
RgUpSapCb *rguSap;
RgRguDedStaInd *staInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgUIMSndCmnStaInd
+S16 rgUIMSndCmnStaInd
(
Inst inst,
RgUpSapCb *rguDlSap,
RgRguCmnStaInd *staInd
)
#else
-PUBLIC S16 rgUIMSndCmnStaInd(inst,rguDlSap,staInd)
+S16 rgUIMSndCmnStaInd(inst,rguDlSap,staInd)
Inst inst,
RgUpSapCb *rguDlSap,
RgRguCmnStaInd *staInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgUIMSndDedDatInd
+S16 rgUIMSndDedDatInd
(
Inst inst,
RgUpSapCb *rguUlSap,
RgRguDedDatInd *datInd
)
#else
-PUBLIC S16 rgUIMSndDedDatInd(datInd)
+S16 rgUIMSndDedDatInd(datInd)
Inst inst;
RgUpSapCb *rguUlSap;
RgRguDedDatInd *datInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgUIMSndCmnDatInd
+S16 rgUIMSndCmnDatInd
(
Inst inst,
RgUpSapCb *rguUlSap,
RgRguCmnDatInd *datInd
)
#else
-PUBLIC S16 rgUIMSndCmnDatInd(datInd)
+S16 rgUIMSndCmnDatInd(datInd)
Inst inst;
RgUpSapCb *rguUlSap;
RgRguCmnDatInd *datInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiCrgBndReq
+S16 RgUiCrgBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 RgUiCrgBndReq(pst, suId, spId)
+S16 RgUiCrgBndReq(pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiCrgUbndReq
+S16 RgUiCrgUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 RgUiCrgUbndReq(pst, spId, reason)
+S16 RgUiCrgUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgUIMCrgBndCfm
+S16 rgUIMCrgBndCfm
(
Inst inst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rgUIMCrgBndCfm(inst,suId, status)
+S16 rgUIMCrgBndCfm(inst,suId, status)
Inst inst;
SuId suId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiCrgCfgReq
+S16 RgUiCrgCfgReq
(
Pst *pst,
SpId spId,
CrgCfgReqInfo *cfgReqInfo
)
#else
-PUBLIC S16 RgUiCrgCfgReq(pst, spId, transId, cfgReqInfo)
+S16 RgUiCrgCfgReq(pst, spId, transId, cfgReqInfo)
Pst *pst;
SpId spId;
CrgCfgTransId transId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgUIMCrgCfgCfm
+S16 rgUIMCrgCfgCfm
(
Inst inst,
CrgCfgTransId transId,
U8 status
)
#else
-PUBLIC S16 rgUIMCrgCfgCfm(inst,transId, status)
+S16 rgUIMCrgCfgCfm(inst,transId, status)
Inst inst;
CrgCfgTransId transId;
U8 status;
#if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
#ifdef ANSI
-PUBLIC S16 rgBatchProc
+S16 rgBatchProc
(
Void
)
#else
-PUBLIC S16 rgBatchProc()
+S16 rgBatchProc()
Void;
#endif
{
/* Fill pst */
pst.srcProcId = 1;
pst.dstProcId = 1;
- pst.dstEnt = ENTRG;
+ pst.dstEnt = ENTMAC;
pst.dstInst = 0;
- pst.srcEnt = ENTKW;
+ pst.srcEnt = ENTRLC;
pst.srcInst = 1;
pst.prior = PRIOR0;
pst.route = RTESPEC;
RgInfRlsRnti *rlsRnti
));
-PUBLIC S16 rgDelUeFrmAllSCell ARGS((
+S16 rgDelUeFrmAllSCell ARGS((
RgCellCb *cell,
RgUeCb *ue
));
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgAllocShrablSBuf
+S16 rgAllocShrablSBuf
(
Inst inst,
Data **pData, /* Pointer of the data to be returned */
Size size /* size */
)
#else
-PUBLIC S16 rgAllocShrablSBuf(inst,pData, size)
+S16 rgAllocShrablSBuf(inst,pData, size)
Inst inst;
Data **pData; /* Pointer of the data to be returned */
Size size; /* size */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgAllocSBuf
+S16 rgAllocSBuf
(
Inst inst,
Data **pData, /* Pointer of the data to be returned */
Size size /* size */
)
#else
-PUBLIC S16 rgAllocSBuf(inst,pData, size)
+S16 rgAllocSBuf(inst,pData, size)
Inst inst;
Data **pData; /* Pointer of the data to be returned */
Size size; /* size */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgFreeSharableSBuf
+Void rgFreeSharableSBuf
(
Inst inst,
Data **data, /* address of pointer to data */
Size size /* size */
)
#else
-PUBLIC Void rgFreeSharableSBuf(inst,data, size)
+Void rgFreeSharableSBuf(inst,data, size)
Inst inst;
Data **data; /* address of pointer to data */
Size size; /* size */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgFreeSBuf
+Void rgFreeSBuf
(
Inst inst,
Data **data, /* address of pointer to data */
Size size /* size */
)
#else
-PUBLIC Void rgFreeSBuf(inst,data, size)
+Void rgFreeSBuf(inst,data, size)
Inst inst;
Data **data; /* address of pointer to data */
Size size; /* size */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgGetMsg
+S16 rgGetMsg
(
Inst inst,
Buffer **mBuf /* Message Buffer pointer be returned */
)
#else
-PUBLIC S16 rgGetMsg(inst,mBuf)
+S16 rgGetMsg(inst,mBuf)
Inst inst;
Buffer **mBuf; /* Message Buffer pointer be returned */
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgFillDgnParams
+Void rgFillDgnParams
(
Inst inst,
RgUstaDgn *dgn,
U8 dgnType
)
#else
-PUBLIC Void rgFillDgnParams(inst,dgn, dgnType)
+Void rgFillDgnParams(inst,dgn, dgnType)
Inst inst;
RgUstaDgn *dgn;
U8 dgnType;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgUpdtRguDedSts
+Void rgUpdtRguDedSts
(
Inst inst,
RgUpSapCb *rguDlSap,
RgRguDedDatReq *datReq /* DatReq pointer */
)
#else
-PUBLIC Void rgUpdtRguDedSts(inst,rguDlSap,stsType, datReq)
+Void rgUpdtRguDedSts(inst,rguDlSap,stsType, datReq)
Inst inst;
RgUpSapCb *rguDlSap;
U8 stsType; /* Statistics type to update */
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgUpdtRguCmnSts
+Void rgUpdtRguCmnSts
(
Inst inst,
RgUpSapCb *rguDlSap,
U8 stsType /* Statistics type to update */
)
#else
-PUBLIC Void rgUpdtRguCmnSts(inst,rguDlSap,stsType)
+Void rgUpdtRguCmnSts(inst,rguDlSap,stsType)
Inst inst;
RgUpSapCb *rguDlSap;
U8 stsType; /* Statistics type to update */
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgUpdtCellCnt
+Void rgUpdtCellCnt
(
Inst inst,
U8 updtType
)
#else
-PUBLIC Void rgUpdtCellCnt(inst,updtType)
+Void rgUpdtCellCnt(inst,updtType)
Inst inst;
U8 updtType;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgUpdtUeCnt
+Void rgUpdtUeCnt
(
Inst inst,
U8 updtType
)
#else
-PUBLIC Void rgUpdtUeCnt (inst,updtType)
+Void rgUpdtUeCnt (inst,updtType)
Inst inst;
U8 updtType;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 rgAllocEventMem
+S16 rgAllocEventMem
(
Inst inst,
Ptr *memPtr,
Size memSize
)
#else
-PUBLIC S16 rgAllocEventMem(inst,memPtr, memSize)
+S16 rgAllocEventMem(inst,memPtr, memSize)
Inst inst;
Ptr *memPtr;
Size memSize;
*
*/
#ifdef ANSI
-PUBLIC S16 rgGetEventMem
+S16 rgGetEventMem
(
Inst inst,
Ptr *ptr,
Ptr memCp
)
#else
-PUBLIC S16 rgGetEventMem(inst,ptr, len, memCp)
+S16 rgGetEventMem(inst,ptr, len, memCp)
Inst inst;
Ptr *ptr;
Size len;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgGetPstToInst
+Void rgGetPstToInst
(
Pst *pst,
Inst srcInst,
Inst dstInst
)
#else
-PUBLIC Void rgGetPstToInst (pst, srcInst, dstInst)
+Void rgGetPstToInst (pst, srcInst, dstInst)
Pst *pst;
Inst srcInst;
Inst dstInst;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgSchMacLcgRegReq
+S16 RgSchMacLcgRegReq
(
Pst *pst,
RgInfLcgRegReq *lcgRegReq
)
#else
-PUBLIC S16 RgSchMacLcgRegReq (pst, lcgRegReq)
+S16 RgSchMacLcgRegReq (pst, lcgRegReq)
Pst *pst;
RgInfLcgRegReq *lcgRegReq;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgSchMacUlSpsResetReq
+S16 RgSchMacUlSpsResetReq
(
Pst *pst,
RgInfUlSpsReset *ulSpsResetInfo
)
#else
-PUBLIC S16 RgSchMacUlSpsResetReq (pst, lcInfo)
+S16 RgSchMacUlSpsResetReq (pst, lcInfo)
Pst *pst;
RgInfUlSpsReset *ulSpsResetInfo;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgSchMacSpsLcRegReq
+S16 RgSchMacSpsLcRegReq
(
Pst *pst,
RgInfSpsLcInfo *lcInfo
)
#else
-PUBLIC S16 RgSchMacSpsLcRegReq (pst, lcInfo)
+S16 RgSchMacSpsLcRegReq (pst, lcInfo)
Pst *pst;
RgInfSpsLcInfo *lcInfo;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 RgSchMacSpsLcDeregReq
+S16 RgSchMacSpsLcDeregReq
(
Pst *pst,
CmLteCellId cellId,
CmLteRnti crnti
)
#else
-PUBLIC S16 RgSchMacSpsLcDeregReq (pst, cellId, crnti)
+S16 RgSchMacSpsLcDeregReq (pst, cellId, crnti)
Pst *pst;
CmLteCellId cellId;
CmLteRnti crnti;
* @return ROK is SUCCESS
**/
#ifdef ANSI
-PUBLIC S16 rgDelUeFrmAllSCell
+S16 rgDelUeFrmAllSCell
(
RgCellCb *cell,
RgUeCb *ue
)
#else
-PUBLIC S16 rgDelUeFrmAllSCell(cell, ue)
+S16 rgDelUeFrmAllSCell(cell, ue)
RgCellCb *cell;
RgUeCb *ue;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgUtlVltdAddSCellCfg
+S16 rgUtlVltdAddSCellCfg
(
RgPrgUeSCellCfgInfo *ueSCellCb,
RgCellCb *cell,
Inst inst
)
#else
-PUBLIC S16 rgUtlVltdAddSCellCfg(ueSCellCb, cell, inst)
+S16 rgUtlVltdAddSCellCfg(ueSCellCb, cell, inst)
RgPrgUeSCellCfgInfo *ueSCellCb;
RgCellCb *cell;
Inst inst;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRlsRntiReq
+S16 RgSchMacRlsRntiReq
(
Pst *pst,
RgInfRlsRnti *rlsRnti
)
#else
-PUBLIC S16 RgSchMacRlsRntiReq(pst, rlsRnti)
+S16 RgSchMacRlsRntiReq(pst, rlsRnti)
Pst *pst;
RgInfRlsRnti *rlsRnti;
#endif
#ifdef L2_OPTMZ
#ifdef ANSI
-PUBLIC Bool RgUtlIsTbMuxed
+Bool RgUtlIsTbMuxed
(
TfuDatReqTbInfo *tb
)
#else
-PUBLIC Bool RgUtlIsTbMuxed()
+Bool RgUtlIsTbMuxed()
TfuDatReqTbInfo *tb
#endif
{
#include "rl_common.h"
#include "du_log.h"
\f
-#define KWLAYERNAME "LTE RLC" /* Layer Name */
+#define RLCLAYERNAME "LTE RLC" /* Layer Name */
#define EKWxxx 1
#define EMG099 1
#define EMG104 4
/* RLC-SPLIT Activity */
-#define KW_ONE 1
-#define KW_BIT0 0x01
-#define KW_BIT1 0x02
-#define KW_BIT2 0x04
-#define KW_BIT3 0x08
+#define RLC_ONE 1
+#define RLC_BIT0 0x01
+#define RLC_BIT1 0x02
+#define RLC_BIT2 0x04
+#define RLC_BIT3 0x08
-#define KW_2K_BYTE 2048
+#define RLC_2K_BYTE 2048
/* RLC RB flag bits */
-#define KW_RB_REESTABLISH_DL KW_BIT0
-#define KW_RB_REESTABLISH_UL KW_BIT1
-#define KW_RB_DELETE_DL KW_BIT2
-#define KW_RB_DELETE_UL KW_BIT3
+#define RLC_RB_REESTABLISH_DL RLC_BIT0
+#define RLC_RB_REESTABLISH_UL RLC_BIT1
+#define RLC_RB_DELETE_DL RLC_BIT2
+#define RLC_RB_DELETE_UL RLC_BIT3
-#define KW_MOD_1024 0x3FF /* used for MOD 1024 */
+#define RLC_MOD_1024 0x3FF /* used for MOD 1024 */
\f
* SAP States
************************************************************************/
-#define KW_SAP_NOT_CFG 0 /*!< SAP Not Configured */
-#define KW_SAP_CFG 1 /*!< SAP Configured but not not bound */
-#define KW_SAP_BND 2 /*!< SAP Bound */
-#define KW_SAP_BINDING 3 /*!< SAP Bind initiated */
-#define KW_SAP_UBND 4 /*!< SAP Unbind */
+#define RLC_SAP_NOT_CFG 0 /*!< SAP Not Configured */
+#define RLC_SAP_CFG 1 /*!< SAP Configured but not not bound */
+#define RLC_SAP_BND 2 /*!< SAP Bound */
+#define RLC_SAP_BINDING 3 /*!< SAP Bind initiated */
+#define RLC_SAP_UBND 4 /*!< SAP Unbind */
-#define KW_MAX_SAP_BND_RETRY 3 /*!< Maximum SAP Bin Retries */
+#define RLC_MAX_SAP_BND_RETRY 3 /*!< Maximum SAP Bin Retries */
-#define KW_MAX_UE 0xffffffff /*!< Maximum number of UEs. */
+#define RLC_MAX_UE 0xffffffff /*!< Maximum number of UEs. */
/* Maximum number of Saps */
-#define KW_MAX_UDXSAPS 1 /*!< Maximum number of UDX Saps */
-#define KW_MAX_KWUSAPS 2 /*!< Maximum number of KWU Saps. */
-#define KW_MAX_CKWSAPS 1 /*!< Maximum number of CKW Saps. */
+#define RLC_MAX_UDXSAPS 1 /*!< Maximum number of UDX Saps */
+#define RLC_MAX_KWUSAPS 2 /*!< Maximum number of KWU Saps. */
+#define RLC_MAX_CKWSAPS 1 /*!< Maximum number of CKW Saps. */
/*MCELL changes*/
-#define KW_MAX_RGUSAPS 4//5 /*!< Maximum number of RGU Saps. */
+#define RLC_MAX_RGUSAPS 4//5 /*!< Maximum number of RGU Saps. */
-#define KW_MAX_RGUSAP_TMR 1 /*!< Maximum number of RGU SAP Timers. */
+#define RLC_MAX_RGUSAP_TMR 1 /*!< Maximum number of RGU SAP Timers. */
-#define KW_UI_RRC 0 /*!< Upper interface RRC sap Id. */
-#define KW_UI_PDCP 1 /*!< Upper interface PDCP sap Id. */
+#define RLC_UI_RRC 0 /*!< Upper interface RRC sap Id. */
+#define RLC_UI_PDCP 1 /*!< Upper interface PDCP sap Id. */
#ifdef LTE_L2_MEAS
/* TODO. This works for FDD only. For TDD the array dimension
* should be changed according to the number of Harq Procs */
-#define KW_MAX_TB_PER_UE 64 /*!< Maximum number of tbCb for UE */
-#define KW_INVALID_TBID KW_MAX_TB_PER_UE
+#define RLC_MAX_TB_PER_UE 64 /*!< Maximum number of tbCb for UE */
+#define RLC_INVALID_TBID RLC_MAX_TB_PER_UE
#endif
/*******************************************************************************
* Memory related Defines
cmMemset((U8 *)(_buf), 0, _size); \
}
-#define KW_RMV_SDU(_cb,_sduQ,_sdu) \
+#define RLC_RMV_SDU(_cb,_sduQ,_sdu) \
{ \
SPutMsg(_sdu->mBuf); \
cmLListDelFrm(_sduQ,&_sdu->lstEnt); \
- RLC_FREE_WC(_cb,_sdu, sizeof(KwSdu)); \
+ RLC_FREE_WC(_cb,_sdu, sizeof(RlcSdu)); \
}
#define RLC_FREE(_cb,_buf, _size) \
#define RLC_ALLOC_WC(_cb,_buf, _size) \
SGetSBuf(_cb->init.region, _cb->init.pool, (Data **)&_buf, (Size) _size)
-#define KW_RMV_SDU(_cb,_sduQ,_sdu) \
+#define RLC_RMV_SDU(_cb,_sduQ,_sdu) \
{ \
if(_sdu->mBuf) \
{ \
SPutMsg(_sdu->mBuf); \
} \
cmLListDelFrm(_sduQ,&_sdu->lstEnt); \
- RLC_FREE(_cb,_sdu, sizeof(KwSdu)); \
+ RLC_FREE(_cb,_sdu, sizeof(RlcSdu)); \
}
#define RLC_FREE(_cb,_buf, _size) \
#define RLC_FREE_BUF_WC(_buf) SPutMsg((_buf));
-#define KW_MEM_CPY(_dst, _src, _size) cmMemcpy((U8*)_dst, (U8 *)_src, _size);
+#define RLC_MEM_CPY(_dst, _src, _size) cmMemcpy((U8*)_dst, (U8 *)_src, _size);
-#define KW_MEM_ZERO(_buf, _size) cmMemset((U8 *)(_buf), 0, _size);
+#define RLC_MEM_ZERO(_buf, _size) cmMemset((U8 *)(_buf), 0, _size);
-#define KW_GET_MEM_REGION(_cb) (_cb->init.region)
+#define RLC_GET_MEM_REGION(_cb) (_cb->init.region)
-#define KW_GET_MEM_POOL(_cb) (_cb->init.pool)
+#define RLC_GET_MEM_POOL(_cb) (_cb->init.pool)
-#define KW_GET_MEM_POOL_ADDRESS(_cb) (&_cb->init.pool)
+#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);
/* Send an alarm for sapId events */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-#define KW_GETSDUIDX(_sduIdx) \
+#define RLC_GETSDUIDX(_sduIdx) \
{\
- _sduIdx = (((_sduIdx)+1) % KW_L2MEAS_MAX_OUTSTNGSDU);\
+ _sduIdx = (((_sduIdx)+1) % RLC_L2MEAS_MAX_OUTSTNGSDU);\
}
-#define KW_SEND_SAPID_ALARM(_cb,_sapId, _evnt, _cause) \
+#define RLC_SEND_SAPID_ALARM(_cb,_sapId, _evnt, _cause) \
{ \
- kwLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, _sapId, 0, 0); \
+ rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, _sapId, 0, 0); \
}
-#define KW_SEND_UEID_ALARM(_cb,_ueId, _qci, _evnt, _cause) \
+#define RLC_SEND_UEID_ALARM(_cb,_ueId, _qci, _evnt, _cause) \
{ \
- kwLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, 0, _ueId, _qci); \
+ rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, 0, _ueId, _qci); \
}
#else /* LTE_L2_MEAS */
-#define KW_SEND_SAPID_ALARM(_cb,_sapId, _evnt, _cause) \
+#define RLC_SEND_SAPID_ALARM(_cb,_sapId, _evnt, _cause) \
{ \
- kwLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, _sapId, 0); \
+ rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, _sapId, 0); \
}
-#define KW_SEND_UEID_ALARM(_cb,_ueId, _evnt, _cause) \
+#define RLC_SEND_UEID_ALARM(_cb,_ueId, _evnt, _cause) \
{ \
- kwLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, 0, _ueId); \
+ rlcLmmSendAlarm(_cb,LCM_CATEGORY_INTERFACE, _evnt, _cause, 0, _ueId); \
}
#endif /* LTE_L2_MEAS */
******************************************************************************/
/* RLC Configuration parameters */
-#define KW_MAX_UL_LI (2 * KW_MAX_LI)
-/*macro KW_MAX_DL_LI is moved to kw_env.h file */
-#define KW_MAX_DAT KW_MAXIMUM_DAT
-/*macro KW_MAX_PDU is moved to kw_env.h file */
-#define KW_MAX_RB_PER_CELL 10
-#define KW_MAX_SRB_PER_UE 3
-#define KW_MAX_DRB_PER_UE 32
-#define KW_MAX_LCH_PER_UE 12
-#define KW_MAX_LCH_PER_CELL 6
-#define KW_MAX_NUM_RB 24
-#define KW_MAX_UE 0xffffffff
-#define KW_UE_LIST_BUCKET_SIZE 128
-#define KW_CELL_LIST_BUCKET_SIZE 10
-#define KW_TRANS_ID_LST_BKT_SIZE 10
-#define KW_MAX_RB 32
+#define RLC_MAX_UL_LI (2 * RLC_MAX_LI)
+/*macro RLC_MAX_DL_LI is moved to kw_env.h file */
+#define RLC_MAX_DAT RLC_MAXIMUM_DAT
+/*macro RLC_MAX_PDU is moved to kw_env.h file */
+#define RLC_MAX_RB_PER_CELL 10
+#define RLC_MAX_SRB_PER_UE 3
+#define RLC_MAX_DRB_PER_UE 32
+#define RLC_MAX_LCH_PER_UE 12
+#define RLC_MAX_LCH_PER_CELL 6
+#define RLC_MAX_NUM_RB 24
+#define RLC_MAX_UE 0xffffffff
+#define RLC_UE_LIST_BUCKET_SIZE 128
+#define RLC_CELL_LIST_BUCKET_SIZE 10
+#define RLC_TRANS_ID_LST_BKT_SIZE 10
+#define RLC_MAX_RB 32
/* Direction defines */
-#define KW_DIR_UL 1 /*!< Unlink direction */
-#define KW_DIR_DL 2 /*!< Downlink direction */
-#define KW_DIR_BOTH 3 /*!< Both Downlink and Unlink */
+#define RLC_DIR_UL 1 /*!< Unlink direction */
+#define RLC_DIR_DL 2 /*!< Downlink direction */
+#define RLC_DIR_BOTH 3 /*!< Both Downlink and Unlink */
-#define KW_DEF_SEQ_NUM 0 /**< Sequence number to pick in case of duplicate
+#define RLC_DEF_SEQ_NUM 0 /**< Sequence number to pick in case of duplicate
entries in hash list searches*/
/**
- * @def KW_MIN
+ * @def RLC_MIN
*
* Macro to find the miniumum of two numbers
*
* @param[in] y Second number
*
*/
-#define KW_MIN(x,y) (x) < (y) ? (x) : (y)
+#define RLC_MIN(x,y) (x) < (y) ? (x) : (y)
/**
* @def RLC_GET_RLCCB
*/
#define RLC_GET_RLCCB(_inst) rlcCb[_inst]
-#define KW_ADD_SDU 1 /*!< Add SDU. */
-#define KW_DEL_SDU 2 /*!< Delete SDU. */
+#define RLC_ADD_SDU 1 /*!< Add SDU. */
+#define RLC_DEL_SDU 2 /*!< Delete SDU. */
-#define KW_CFM_NOK 0 /*!< Do not send DatCfm */
-#define KW_CFM_OK 1 /*!< Send DatCfm */
+#define RLC_CFM_NOK 0 /*!< Do not send DatCfm */
+#define RLC_CFM_OK 1 /*!< Send DatCfm */
/* Set the unsolictated Status flag */
-#define KW_SET_USTA_FLAG(_rlcCb, _value) \
+#define RLC_SET_USTA_FLAG(_rlcCb, _value) \
{ \
_rlcCb->init.usta = _value; \
}
/* Macros to get the init parameters */
-#define KW_GET_DBG_MASK(_rlcCb) (_rlcCb->init.dbgMask)
-#define KW_GET_LMPST_MEM_POOL(_rlcCb) (_rlcCb->init.lmPst.pool)
-#define KW_GET_LMPST_MEM_REGION(_rlcCb) (_rlcCb->init.lmPst.region)
+#define RLC_GET_DBG_MASK(_rlcCb) (_rlcCb->init.dbgMask)
+#define RLC_GET_LMPST_MEM_POOL(_rlcCb) (_rlcCb->init.lmPst.pool)
+#define RLC_GET_LMPST_MEM_REGION(_rlcCb) (_rlcCb->init.lmPst.region)
/* Macros for configuration module */
-#define KW_CFG_FILL_CFG_CFM(_entCfm, _rbId, _rbType, _status, _reason) \
+#define RLC_CFG_FILL_CFG_CFM(_entCfm, _rbId, _rbType, _status, _reason) \
{ \
_entCfm->rbId = _rbId; \
_entCfm->rbType = _rbType; \
}
/**
- * @def KW_VALIDATE_UE_RBID
+ * @def RLC_VALIDATE_UE_RBID
*
* This macro validates whether the _rbId passed is valid or not. It checks
* if the _rbId is within the maximum value depending on the _rbType.
* @param[in] _rbId RB Id of the RB to be validated
*
*/
-#define KW_VALIDATE_UE_RBID(_rbType, _rbId) \
- ((_rbType == CM_LTE_SRB && _rbId < KW_MAX_SRB_PER_UE) || \
- (_rbType == CM_LTE_DRB && _rbId < KW_MAX_DRB_PER_UE))
+#define RLC_VALIDATE_UE_RBID(_rbType, _rbId) \
+ ((_rbType == CM_LTE_SRB && _rbId < RLC_MAX_SRB_PER_UE) || \
+ (_rbType == CM_LTE_DRB && _rbId < RLC_MAX_DRB_PER_UE))
/*******************************************************************************
* UIM Defines
******************************************************************************/
#if (ERRCLASS & ERRCLS_INT_PAR)
-#define KW_VALDATE_SAP(_cb,_chkSpId, _sap, _ret) \
+#define RLC_VALDATE_SAP(_cb,_chkSpId, _sap, _ret) \
{ \
if (_chkSpId != _sap->spId) \
{ \
- KWLOGERROR(_cb,ERRCLS_DEBUG, EKWxxx, (ErrVal) RFAILED, \
+ RLCLOGERROR(_cb,ERRCLS_DEBUG, EKWxxx, (ErrVal) RFAILED, \
"Sap Id Validation Failed."); \
_ret = RFAILED; \
} \
/* SAP state validation */ \
- if(_sap->state != KW_SAP_BND) \
+ if(_sap->state != RLC_SAP_BND) \
{ \
- KWLOGERROR(_cb,ERRCLS_INT_PAR, EKWXXX, (ErrVal) RFAILED, \
+ RLCLOGERROR(_cb,ERRCLS_INT_PAR, EKWXXX, (ErrVal) RFAILED, \
"Sap State Invalid."); \
- KW_SEND_SAPID_ALARM(_cb,0, LCM_EVENT_UI_INV_EVT, LCM_CAUSE_INV_STATE); \
+ RLC_SEND_SAPID_ALARM(_cb,0, LCM_EVENT_UI_INV_EVT, LCM_CAUSE_INV_STATE); \
_ret = RFAILED; \
} \
}
#else /* ERRCLASS & ERRCLS_INT_PAR */
-#define KW_VALDATE_SAP(_cb,_chkSpId, _sap, _ret) \
+#define RLC_VALDATE_SAP(_cb,_chkSpId, _sap, _ret) \
{ \
/* SAP state validation */ \
- if(_sap->state != KW_SAP_BND) \
+ if(_sap->state != RLC_SAP_BND) \
{ \
- KWLOGERROR(_cb,ERRCLS_INT_PAR, EKWXXX, (ErrVal) RFAILED, \
+ RLCLOGERROR(_cb,ERRCLS_INT_PAR, EKWXXX, (ErrVal) RFAILED, \
"Sap State Invalid."); \
- KW_SEND_SAPID_ALARM(_cb,0, LCM_EVENT_UI_INV_EVT, LCM_CAUSE_INV_STATE); \
+ RLC_SEND_SAPID_ALARM(_cb,0, LCM_EVENT_UI_INV_EVT, LCM_CAUSE_INV_STATE); \
_ret = RFAILED; \
} \
}
/*******************************************************************************
* Timer Defines
******************************************************************************/
-#define KW_TMR_LEN 10
-#define KW_MAX_UM_TMR 1
-#define KW_MAX_AM_TMR 3
-#define KW_EVT_UMUL_REORD_TMR 1
-#define KW_EVT_AMUL_REORD_TMR 2
-#define KW_EVT_AMUL_STA_PROH_TMR 3
-#define KW_EVT_AMDL_POLL_RETX_TMR 4
-#define KW_EVT_WAIT_BNDCFM 5
+#define RLC_TMR_LEN 10
+#define RLC_MAX_UM_TMR 1
+#define RLC_MAX_AM_TMR 3
+#define RLC_EVT_UMUL_REORD_TMR 1
+#define RLC_EVT_AMUL_REORD_TMR 2
+#define RLC_EVT_AMUL_STA_PROH_TMR 3
+#define RLC_EVT_AMDL_POLL_RETX_TMR 4
+#define RLC_EVT_WAIT_BNDCFM 5
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-#define KW_EVT_L2_TMR 6
+#define RLC_EVT_L2_TMR 6
#endif /* LTE_L2_MEAS */
/*******************************************************************************
* DBM Defines
******************************************************************************/
/**
- * @def KW_DBM_GET_RBCB_FROM_UECB
+ * @def RLC_DBM_GET_RBCB_FROM_UECB
*
* This macro makes _rbCb point to the RB in _ueCb based on the passed
* _rbId and _rbType. _rbCb can point to NULLP
* @param[out] _rbCb Pointer to the found RbCb
*
*/
-#define KW_DBM_GET_RBCB_FROM_UECB(_rbId, _rbType, _ueCb, _rbCb) \
+#define RLC_DBM_GET_RBCB_FROM_UECB(_rbId, _rbType, _ueCb, _rbCb) \
(_rbCb) = ((_rbType) == CM_LTE_SRB) ? (_ueCb)->srbCb[(_rbId)] : \
(_ueCb)->drbCb[(_rbId)];
/**
- * @def KW_DBM_GET_CELL_RBCB
+ * @def RLC_DBM_GET_CELL_RBCB
*
* This macro makes _rbCb point to the RB in the _rbCbLst.
* _rbCb can point to NULLP
* @param[out] _rbCb Pointer to the found RbCb
*
*/
-#define KW_DBM_GET_CELL_RBCB(_rbId, _rbCbLst, _rbCb) \
+#define RLC_DBM_GET_CELL_RBCB(_rbId, _rbCbLst, _rbCb) \
(_rbCb) = (_rbCbLst)[(_rbId)];
/*******************************************************************************
* UMM Defines
******************************************************************************/
-#define KW_UMDL rbCb->m.umDl
-#define KW_UMUL rbCb->m.umUl
+#define RLC_UMDL rbCb->m.umDl
+#define RLC_UMUL rbCb->m.umUl
/* Sequence Number length defines */
-#define KW_UM_CFG_5BIT_SN_LEN 1 /**< UM 5-bit Sequence number length
+#define RLC_UM_CFG_5BIT_SN_LEN 1 /**< UM 5-bit Sequence number length
in bytes*/
-#define KW_UM_CFG_10BIT_SN_LEN 2 /**< UM 10-bit Sequence number length
+#define RLC_UM_CFG_10BIT_SN_LEN 2 /**< UM 10-bit Sequence number length
in bytes*/
/* 5GNR */
/* Sequence Number length defines */
-#define KW_AM_CFG_12BIT_SN_LEN 1 /**< AM 12-bit Sequence number length
+#define RLC_AM_CFG_12BIT_SN_LEN 1 /**< AM 12-bit Sequence number length
in bytes*/
-#define KW_AM_CFG_18BIT_SN_LEN 2 /**< AM 18-bit Sequence number length
+#define RLC_AM_CFG_18BIT_SN_LEN 2 /**< AM 18-bit Sequence number length
in bytes*/
/**
- * @def KW_RMV_MAC_HDR_SZ
+ * @def RLC_RMV_MAC_HDR_SZ
*
* If PDU size is greater than 127, MAC header would be 3 bytes else 2 bytes
*
* @param[in,out] _pduSz Size of the pdu
*
*/
-#define KW_RMV_MAC_HDR_SZ(_pduSz) (_pduSz) -= ((_pduSz) > 127) ? 3 : 2;
+#define RLC_RMV_MAC_HDR_SZ(_pduSz) (_pduSz) -= ((_pduSz) > 127) ? 3 : 2;
/**
- * @def KW_UM_GET_VALUE
+ * @def RLC_UM_GET_VALUE
*
* This macro is used to calculate the value of UM state variables used
* in comparisons. VR(UH) - UM Window Size is taken as the base modulus.
* @param[in] _kwUmUl Um Uplink control block
*
*/
-#define KW_UM_GET_VALUE(_val,_kwUmUl) \
+#define RLC_UM_GET_VALUE(_val,_kwUmUl) \
(((_val) - ((_kwUmUl).vrUh - (_kwUmUl).umWinSz)) & ((_kwUmUl).modBitMask))
/*******************************************************************************
#define AMUL rbCb->m.amUl
/* PDU Types */
-#define KW_DATA_PDU 1
-#define KW_CNTRL_PDU 0
-
-#define KW_FI_FIRST_SEG 0x02
-#define KW_FI_LAST_SEG 0x01
-#define KW_SI_FIRST_SEG 0x01
-#define KW_SI_LAST_SEG 0x02
-#define KW_SI_MID_SEG 0x03
-
-#define KW_POLL_SET 0x40 /* 01000000 */
-#define KW_POLL_UNSET 0xbf /* 10111111 */
-#define KW_AM_WIN_SZ 512
-#define KW_MAX_NACK_CNT 100
-/*KW_MAX_CNTRL_FIELDS (Maximum size of Status Pdu)
+#define RLC_DATA_PDU 1
+#define RLC_CNTRL_PDU 0
+
+#define RLC_FI_FIRST_SEG 0x02
+#define RLC_FI_LAST_SEG 0x01
+#define RLC_SI_FIRST_SEG 0x01
+#define RLC_SI_LAST_SEG 0x02
+#define RLC_SI_MID_SEG 0x03
+
+#define RLC_POLL_SET 0x40 /* 01000000 */
+#define RLC_POLL_UNSET 0xbf /* 10111111 */
+#define RLC_AM_WIN_SZ 512
+#define RLC_MAX_NACK_CNT 100
+/*RLC_MAX_CNTRL_FIELDS (Maximum size of Status Pdu)
* = MAX_NACK_CNT * sizeof(NACK_SN,E1,E2,E3,soStart,soEnd, nackRange)
* for 18 bit SN + Fixed Header*/
-#define KW_MAX_CNTRL_FIELDS ((KW_MAX_NACK_CNT * 8) + 3)
+#define RLC_MAX_CNTRL_FIELDS ((RLC_MAX_NACK_CNT * 8) + 3)
/* Each LI(Length Indicator) holds approx 1+1/2 byte and some other fields thus keeping Header Size equal to twice of MAX LI */
/* 5GNR_RLC: Need to change value of HDRSZ as per number of PDUs going in one datReq */
-#define KW_MAX_HDRSZ 5
-#define KW_AM_PDU_FIXED_HDRSZ 2
-#define KW_AM_PDU_12BIT_SN_HDRSZ 2
-#define KW_AM_PDU_18BIT_SN_HDRSZ 3
-#define KW_AM_SEG_12BIT_SN_WITH_SO_HDRSZ 4
-#define KW_AM_SEG_18BIT_SN_WITH_SO_HDRSZ 5
-#define KW_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ 2
-#define KW_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ 3
-#define KW_EXTN_HDRSZ 2
-#define KW_CNTRL_PDU_FIXED_HDRSZ 3
-#define KW_MAC_HDR_SZ2 2
-#define KW_MAC_HDR_SZ3 3
-#define KW_BYTE_LEN 8
-#define KW_2BYTE_LEN 16
-#define KW_E1_LEN 1
-#define KW_NACK_E1E2_LEN 12
-#define KW_SO_LEN 15
-#define KW_DC_LEN 1
-#define KW_CPT_LEN 3
-#define KW_RF_LEN 1
-#define KW_P_LEN 1
-#define KW_FI_LEN 2
-#define KW_SI_LEN 2
-#define KW_E_LEN 1
-#define KW_SN_LEN 10
-#define KW_SN_LEN_12BITS 12
-#define KW_SN_LEN_18BITS 18
-#define KW_LSF_LEN 1
-#define KW_LI_LEN 11
-#define KW_STA_PDU_R_BITS_ACKSN_12BITS 7 /* 5GNR : Num Reserved bits in STATUS PDU */
-#define KW_STA_PDU_R_BITS_ACKSN_18BITS 1
-#define KW_STA_PDU_R_BITS_NACKSN_12BITS 1
-#define KW_STA_PDU_R_BITS_NACKSN_18BITS 3
-#define KW_NACK_RANGE_LEN 8
-#define KW_SO_LEN_5GNR 16
-
-#define KW_DC_POS 0x80
-#define KW_DC_SHT 7
-#define KW_POLL_POS 0x40 /* 5GNR */
-#define KW_POLL_SHT 6 /* 5GNR */
-#define KW_SI_POS 0x30 /* 5GNR */
-#define KW_SI_SHT 4 /* 5GNR */
-#define KW_SN_POS_12BIT 0x0F
-#define KW_SN_POS_18BIT 0x03
-#define KW_AM_GET_WIN_SZ(_snLen) ((KW_AM_CFG_12BIT_SN_LEN == (_snLen)) ? (2048) : (131072)) /* 5GNR */
-#define KW_RCV_BUF_BIN_SIZE 512 /* Could be increased to avoid the search time.
+#define RLC_MAX_HDRSZ 5
+#define RLC_AM_PDU_FIXED_HDRSZ 2
+#define RLC_AM_PDU_12BIT_SN_HDRSZ 2
+#define RLC_AM_PDU_18BIT_SN_HDRSZ 3
+#define RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ 4
+#define RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ 5
+#define RLC_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ 2
+#define RLC_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ 3
+#define RLC_EXTN_HDRSZ 2
+#define RLC_CNTRL_PDU_FIXED_HDRSZ 3
+#define RLC_MAC_HDR_SZ2 2
+#define RLC_MAC_HDR_SZ3 3
+#define RLC_BYTE_LEN 8
+#define RLC_2BYTE_LEN 16
+#define RLC_E1_LEN 1
+#define RLC_NACK_E1E2_LEN 12
+#define RLC_SO_LEN 15
+#define RLC_DC_LEN 1
+#define RLC_CPT_LEN 3
+#define RLC_RF_LEN 1
+#define RLC_P_LEN 1
+#define RLC_FI_LEN 2
+#define RLC_SI_LEN 2
+#define RLC_E_LEN 1
+#define RLC_SN_LEN 10
+#define RLC_SN_LEN_12BITS 12
+#define RLC_SN_LEN_18BITS 18
+#define RLC_LSF_LEN 1
+#define RLC_LI_LEN 11
+#define RLC_STA_PDU_R_BITS_ACKSN_12BITS 7 /* 5GNR : Num Reserved bits in STATUS PDU */
+#define RLC_STA_PDU_R_BITS_ACKSN_18BITS 1
+#define RLC_STA_PDU_R_BITS_NACKSN_12BITS 1
+#define RLC_STA_PDU_R_BITS_NACKSN_18BITS 3
+#define RLC_NACK_RANGE_LEN 8
+#define RLC_SO_LEN_5GNR 16
+
+#define RLC_DC_POS 0x80
+#define RLC_DC_SHT 7
+#define RLC_POLL_POS 0x40 /* 5GNR */
+#define RLC_POLL_SHT 6 /* 5GNR */
+#define RLC_SI_POS 0x30 /* 5GNR */
+#define RLC_SI_SHT 4 /* 5GNR */
+#define RLC_SN_POS_12BIT 0x0F
+#define RLC_SN_POS_18BIT 0x03
+#define RLC_AM_GET_WIN_SZ(_snLen) ((RLC_AM_CFG_12BIT_SN_LEN == (_snLen)) ? (2048) : (131072)) /* 5GNR */
+#define RLC_RCV_BUF_BIN_SIZE 512 /* Could be increased to avoid the search time.
with the memory trade-off */
-#define KW_TX_BUF_BIN_SIZE 512 /* Could be increased to avoid the search time.
+#define RLC_TX_BUF_BIN_SIZE 512 /* Could be increased to avoid the search time.
with the memory trade-off */
-#define KW_SDU_LST 1
-#define KW_SEG_LST 2
-#define KW_RETX_LST 3
-#define KW_ALL_BYTES_MISSING 0xffff
+#define RLC_SDU_LST 1
+#define RLC_SEG_LST 2
+#define RLC_RETX_LST 3
+#define RLC_ALL_BYTES_MISSING 0xffff
-#define KW_MAX_PDU_MAP 30 /*!< Maximum PDU Map. */
+#define RLC_MAX_PDU_MAP 30 /*!< Maximum PDU Map. */
-#define KW_LLIST_FIRST_SDU(lstCp, nod) \
+#define RLC_LLIST_FIRST_SDU(lstCp, nod) \
{ \
CmLList *tmpNode; \
/*CM_LLIST_FIRST_NODE(&(lstCp), tmpNode);*/ \
/*if (tmpNode != NULLP)*/ \
if((tmpNode=cmLListFirst(&lstCp))) \
- nod = (KwSdu *)tmpNode->node; \
+ nod = (RlcSdu *)tmpNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_FIRST_SEG(lstCp, nod) \
+#define RLC_LLIST_FIRST_SEG(lstCp, nod) \
{ \
CmLList *tmpNode; \
/*CM_LLIST_FIRST_NODE(&(lstCp), tmpNode);*/ \
/*if (tmpNode != NULLP)*/ \
if((tmpNode=cmLListFirst(&lstCp))) \
- nod = (KwSeg *)tmpNode->node; \
+ nod = (RlcSeg *)tmpNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_FIRST_RETX(lstCp, nod) \
+#define RLC_LLIST_FIRST_RETX(lstCp, nod) \
{ \
CmLList *tmpNode; \
/*CM_LLIST_FIRST_NODE(&(lstCp), tmpNode);*/ \
/*if (tmpNode != NULLP)*/ \
if((tmpNode=cmLListFirst(&lstCp))) \
- nod = (KwRetx *)tmpNode->node; \
+ nod = (RlcRetx *)tmpNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_NEXT_SDU(lstCp, nod) \
+#define RLC_LLIST_NEXT_SDU(lstCp, nod) \
{ \
CmLList *tmpNode; \
/*CM_LLIST_NEXT_NODE(&(lstCp), tmpNode);*/ \
/*if (tmpNode != NULLP) */ \
if((tmpNode = cmLListNext(&lstCp))) \
- nod = (KwSdu *)tmpNode->node; \
+ nod = (RlcSdu *)tmpNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_NEXT_SEG(lstCp, nod) \
+#define RLC_LLIST_NEXT_SEG(lstCp, nod) \
{ \
CmLList *tmpNode; \
(lstCp).crnt = &((nod)->lstEnt); \
/*CM_LLIST_NEXT_NODE(&(lstCp), tmpNode);*/ \
/*if (tmpNode != NULLP)*/ \
if((tmpNode = cmLListNext(&lstCp))) \
- nod = (KwSeg *)tmpNode->node; \
+ nod = (RlcSeg *)tmpNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_NEXT_RETX(lstCp, nod) \
+#define RLC_LLIST_NEXT_RETX(lstCp, nod) \
{ \
CmLList *tmpNode; \
/*CM_LLIST_NEXT_NODE(&(lstCp), tmpNode);*/ \
/*if (tmpNode != NULLP) */ \
if ((tmpNode = cmLListNext(&lstCp))) \
- nod = (KwRetx *)tmpNode->node; \
+ nod = (RlcRetx *)tmpNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_LAST_RETX(lstCp, nod) \
+#define RLC_LLIST_LAST_RETX(lstCp, nod) \
{ \
CmLList *tempNode = NULLP; \
cmLListLast(&lstCp); \
tempNode = cmLListCrnt(&lstCp); \
if (tempNode != NULLP) \
- nod = (KwRetx *)tempNode->node; \
+ nod = (RlcRetx *)tempNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_LAST_SEG(lstCp, nod) \
+#define RLC_LLIST_LAST_SEG(lstCp, nod) \
{ \
CmLList *tempNode = NULLP; \
cmLListLast(&lstCp); \
tempNode = cmLListCrnt(&lstCp); \
if (tempNode != NULLP) \
- nod = (KwSeg *)tempNode->node; \
+ nod = (RlcSeg *)tempNode->node; \
else \
nod = NULLP; \
}
-#define KW_LLIST_LAST_SDU(lstCp, nod) \
+#define RLC_LLIST_LAST_SDU(lstCp, nod) \
{ \
CmLList *tempNode = NULLP; \
cmLListLast(&lstCp); \
tempNode = cmLListCrnt(&lstCp); \
if (tempNode != NULLP) \
- nod = (KwSdu *)tempNode->node; \
+ nod = (RlcSdu *)tempNode->node; \
else \
nod = NULLP; \
}
cmLListInsCrnt(&lstCp, nodeToIns); \
}
-#define KW_LLIST_DEL_RECBUF(_recBuf) \
+#define RLC_LLIST_DEL_RECBUF(_recBuf) \
{ \
- KwSeg *_seg = NULLP; \
- KW_LLIST_FIRST_SEG(_recBuf->segLst, _seg); \
+ RlcSeg *_seg = NULLP; \
+ RLC_LLIST_FIRST_SEG(_recBuf->segLst, _seg); \
while (_seg) \
{ \
cmLListDelFrm(&_recBuf->segLst, &_seg->lstEnt); \
- RLC_FREE(_seg, sizeof(KwSeg)); \
- KW_LLIST_NEXT_SEG(_recBuf->segLst, _seg); \
+ RLC_FREE(_seg, sizeof(RlcSeg)); \
+ RLC_LLIST_NEXT_SEG(_recBuf->segLst, _seg); \
} \
}
}
/**
- * @def KW_AM_IS_TRANS_WIN_STALLED
+ * @def RLC_AM_IS_TRANS_WIN_STALLED
*
* This macro is used to check if the AM transmit window is stalled or not.
* The tramist window is stalled when the distance between txNext and txNextAck
* @param[in] _amDl AM Downlink control block
*
*/
-#define KW_AM_IS_TRANS_WIN_STALLED(_amDl) \
- ((((_amDl)->txNext - (_amDl)->txNextAck) & _amDl->snModMask) >= (KW_AM_GET_WIN_SZ(_amDl->snLen)))
+#define RLC_AM_IS_TRANS_WIN_STALLED(_amDl) \
+ ((((_amDl)->txNext - (_amDl)->txNextAck) & _amDl->snModMask) >= (RLC_AM_GET_WIN_SZ(_amDl->snLen)))
#ifdef TENB_STATS
-#define KW_AM_TRANS_WIN_SIZE(_amDl) \
+#define RLC_AM_TRANS_WIN_SIZE(_amDl) \
(((_amDl)->txNext - (_amDl)->txNextAck) & _amDl->snModMask)
#endif
-#define KW_AM_IS_POLL_BIT_SET(_amDl) \
+#define RLC_AM_IS_POLL_BIT_SET(_amDl) \
(AMDL.pollSn == ((AMDL.txNext - 1) & AMDL.snModMask))
-#define KW_FILL_CNTRL_INFO(cntrlInfo, _val, _len, _idx, _eb)\
+#define RLC_FILL_CNTRL_INFO(cntrlInfo, _val, _len, _idx, _eb)\
{ \
cntrlInfo.val = _val; \
cntrlInfo.len = _len; \
cntrlInfo.idx = _idx; \
cntrlInfo.emtBits = _eb; \
}
-#define KW_FILL_PREV_IDX(cntrlInfo, _e1Idx, _e1eb, _idx, _eb) \
+#define RLC_FILL_PREV_IDX(cntrlInfo, _e1Idx, _e1eb, _idx, _eb) \
{ \
_e1Idx = cntrlInfo.e1Idx; \
_e1eb = cntrlInfo.e1eb; \
_eb = cntrlInfo.emtBits; \
}
-#define KW_FILL_HDR_ARGS(hdrInfo, _val, _len) \
+#define RLC_FILL_HDR_ARGS(hdrInfo, _val, _len) \
{ \
hdrInfo.val = _val; \
hdrInfo.len = _len; \
/* kw003.201 - This macro provides the header size other than the */
/* fixed header of 2 bytes for each AMD PDU or 4 bytes*/
/* for an AM PDU segment */
-#define KW_AM_EXTN_HDRSZ(_numLi, _eHdrSz) \
+#define RLC_AM_EXTN_HDRSZ(_numLi, _eHdrSz) \
{ \
if ((_numLi - 1) % 2) \
{ \
}
/* Update poll bit in the buffer */
-#define KW_UPD_POLL_BIT(_gCb, _retx, _poll) \
+#define RLC_UPD_POLL_BIT(_gCb, _retx, _poll) \
{ \
U8 fHdr; \
\
SRemPreMsg((Data *)&fHdr, _retx->seg); \
if (_poll == TRUE) \
{ \
- fHdr = fHdr | KW_POLL_SET; \
+ fHdr = fHdr | RLC_POLL_SET; \
} \
else \
{ \
- fHdr = fHdr & KW_POLL_UNSET; \
+ fHdr = fHdr & RLC_POLL_UNSET; \
} \
/* Concatenated updated hdr to the mBuf */ \
SAddPreMsg ((Data)fHdr, _retx->seg); \
_retx->amHdr.p = _poll; \
}
-#define KW_AM_ELIMINATE_EXTN_HDR(_pduSz, _sduSz, _numLi) \
+#define RLC_AM_ELIMINATE_EXTN_HDR(_pduSz, _sduSz, _numLi) \
{ \
if ( (_pduSz > _sduSz) && (_sduSz < 2048) ) \
{ \
} \
}
/**
- * @def KW_AM_CHK_SN_WITHIN_RECV_WINDOW
+ * @def RLC_AM_CHK_SN_WITHIN_RECV_WINDOW
*
* This macro is used to check if a Sequence Number falls within the AM
* reception window or not.
* @param[in] _amUl AM Uplink control block
*
*/
-#define KW_AM_CHK_SN_WITHIN_RECV_WINDOW(_sn, _amUl) \
+#define RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(_sn, _amUl) \
((((_sn) - (_amUl->rxNext)) & (_amUl->snModMask)) < (((_amUl->vrMr) - (_amUl->rxNext)) & (_amUl->snModMask)))
-#define KW_POWER(x, y) x << (y-1);
+#define RLC_POWER(x, y) x << (y-1);
#ifndef L2_OPTMZ
-#define kwCpyMsg(_cb,x, y) \
- (SAddMsgRef((x), KW_GET_MEM_REGION(_cb), KW_GET_MEM_POOL(_cb), (y)))
+#define rlcCpyMsg(_cb,x, y) \
+ (SAddMsgRef((x), RLC_GET_MEM_REGION(_cb), RLC_GET_MEM_POOL(_cb), (y)))
#else
/* L2 optimization for mUe/Tti: Removing dup buf*/
-#define kwCpyMsg(_cb,x, y) \
- (SIncMsgRef((x), KW_GET_MEM_REGION(_cb), KW_GET_MEM_POOL(_cb), (y)))
+#define rlcCpyMsg(_cb,x, y) \
+ (SIncMsgRef((x), RLC_GET_MEM_REGION(_cb), RLC_GET_MEM_POOL(_cb), (y)))
#endif
// printf("Copy Msg %x \n",x);
/*******************************************************************************
* Debugging Defines
******************************************************************************/
-#define KW_DBG_SUB_MASK DBGMASK_MI /**< Use for sub-mask */
-#define KW_DBGMASK_DETAIL (KW_DBG_SUB_MASK << 0) /**< Parameters, It will give
+#define RLC_DBG_SUB_MASK DBGMASK_MI /**< Use for sub-mask */
+#define RLC_DBGMASK_DETAIL (RLC_DBG_SUB_MASK << 0) /**< Parameters, It will give
in depth info */
-#define KW_DBGMASK_BRIEF (KW_DBG_SUB_MASK << 1) /**< Info, It will give info at
+#define RLC_DBGMASK_BRIEF (RLC_DBG_SUB_MASK << 1) /**< Info, It will give info at
entry and exit places along
with certain state changes */
-#define KW_DBGMASK_ERROR (KW_DBG_SUB_MASK << 2) /**< Error information */
-#define KW_DBGMASK_FATAL (KW_DBG_SUB_MASK << 3) /**< FATAL errors like memory
+#define RLC_DBGMASK_ERROR (RLC_DBG_SUB_MASK << 2) /**< Error information */
+#define RLC_DBGMASK_FATAL (RLC_DBG_SUB_MASK << 3) /**< FATAL errors like memory
resource failure etc., */
-#define KW_DBG_MDL_MASK (KW_DBG_SUB_MASK << 4)
-
-#define KW_DBGMASK_TM (KW_DBG_MDL_MASK << 0) /**< TM */
-#define KW_DBGMASK_UM (KW_DBG_MDL_MASK << 1) /**< UM */
-#define KW_DBGMASK_AM (KW_DBG_MDL_MASK << 2) /**< AM */
-#define KW_DBGMASK_DL (KW_DBG_MDL_MASK << 3) /**< DL */
-#define KW_DBGMASK_UL (KW_DBG_MDL_MASK << 4) /**< UL */
-#define KW_DBGMASK_CFG (KW_DBG_MDL_MASK << 5) /**< CFG */
-#define KW_DBGMASK_LMM (KW_DBG_MDL_MASK << 6) /**< LMM */
-#define KW_DBGMASK_INF (KW_DBG_MDL_MASK << 7) /**< UI, LI */
-#define KW_DBGMASK_DUT (KW_DBG_MDL_MASK << 8) /**< DBM, UTL, TMR */
-#define KW_DBGMASK_MBUF_PRNT (KW_DBG_MDL_MASK << 9) /**< MBUF, useful in
+#define RLC_DBG_MDL_MASK (RLC_DBG_SUB_MASK << 4)
+
+#define RLC_DBGMASK_TM (RLC_DBG_MDL_MASK << 0) /**< TM */
+#define RLC_DBGMASK_UM (RLC_DBG_MDL_MASK << 1) /**< UM */
+#define RLC_DBGMASK_AM (RLC_DBG_MDL_MASK << 2) /**< AM */
+#define RLC_DBGMASK_DL (RLC_DBG_MDL_MASK << 3) /**< DL */
+#define RLC_DBGMASK_UL (RLC_DBG_MDL_MASK << 4) /**< UL */
+#define RLC_DBGMASK_CFG (RLC_DBG_MDL_MASK << 5) /**< CFG */
+#define RLC_DBGMASK_LMM (RLC_DBG_MDL_MASK << 6) /**< LMM */
+#define RLC_DBGMASK_INF (RLC_DBG_MDL_MASK << 7) /**< UI, LI */
+#define RLC_DBGMASK_DUT (RLC_DBG_MDL_MASK << 8) /**< DBM, UTL, TMR */
+#define RLC_DBGMASK_MBUF_PRNT (RLC_DBG_MDL_MASK << 9) /**< MBUF, useful in
integrated
testing */
-#define KW_DBGMASK_MEM_INFO (KW_DBG_MDL_MASK << 10) /**< Print SSI memory
+#define RLC_DBGMASK_MEM_INFO (RLC_DBG_MDL_MASK << 10) /**< Print SSI memory
information*/
-#define KW_DBGMASK_UDX (KW_DBG_MDL_MASK << 11) /**< UDX interface */
+#define RLC_DBGMASK_UDX (RLC_DBG_MDL_MASK << 11) /**< UDX interface */
#ifdef DEBUGP
-#define KW_PRNT_BORDER \
+#define RLC_PRNT_BORDER \
do \
{ \
- KW_PRNT((_kwPBuf, "\n==========================\n")); \
+ RLC_PRNT((_kwPBuf, "\n==========================\n")); \
}while(0)
-#define KW_PRNT_HLINE(_cb,_pMsg) \
+#define RLC_PRNT_HLINE(_cb,_pMsg) \
{ \
sprintf((_cb)->init.prntBuf, "[RLC_LAYER: %s:%d]::", __FILE__, __LINE__); \
SPrint((_cb)->init.prntBuf); \
- KW_PRNT_TSTAMP(_cb); \
+ RLC_PRNT_TSTAMP(_cb); \
sprintf((_cb)->init.prntBuf, _pMsg); \
SPrint((_cb)->init.prntBuf); \
}
-#define KW_PRNT(_cb,_prntbuf) \
+#define RLC_PRNT(_cb,_prntbuf) \
{ \
sprintf _prntbuf; \
SPrint(_cb->init.prntBuf); \
}
-#define KW_PRINT_TO_BUFFER(_cb,...) \
+#define RLC_PRINT_TO_BUFFER(_cb,...) \
{ \
snprintf((_cb)->init.prntBuf, PRNTSZE, "[%s]::", __func__); \
SPrint((_cb)->init.prntBuf); \
SPrint(_cb->init.prntBuf); \
}
-#define KW_PRNT_TSTAMP(_cb) \
+#define RLC_PRNT_TSTAMP(_cb) \
{ \
S8 _buf[60]; \
DateTime dt; \
sprintf(_buf, "date: %02d/%02d/%04d time: %02d:%02d:%02d", \
(int)dt.month,(int)dt.day,(int)dt.year + 1900, \
(int)dt.hour,(int)dt.min,(int)dt.sec); \
- KW_PRNT(_cb,(_cb->init.prntBuf,("[%s]", _buf))); \
+ RLC_PRNT(_cb,(_cb->init.prntBuf,("[%s]", _buf))); \
}
-#define KW_PRNT_MBUF(_cb,_mBufPtr) \
+#define RLC_PRNT_MBUF(_cb,_mBufPtr) \
do \
{ \
- if(_cb->init.dbgMask & (KW_DBGMASK_MBUF_PRNT)) \
+ if(_cb->init.dbgMask & (RLC_DBGMASK_MBUF_PRNT)) \
{ \
- KW_PRNT_HLINE(_cb,("\nMessage Buffer Contents:\n")); \
+ RLC_PRNT_HLINE(_cb,("\nMessage Buffer Contents:\n")); \
SPrntMsg ((Buffer *)_mBufPtr, 0, 0); \
} \
}while(0)
-#define KW_PRNT_MEMINFO(_cb) \
+#define RLC_PRNT_MEMINFO(_cb) \
do \
{ \
U32 _memInfo; \
- if(_cb->init.dbgMask & (KW_DBGMASK_MEM_INFO)) \
+ if(_cb->init.dbgMask & (RLC_DBGMASK_MEM_INFO)) \
{ \
- KW_PRNT_HLINE(_cb,("\nMemory Information:\n")); \
+ RLC_PRNT_HLINE(_cb,("\nMemory Information:\n")); \
SRegInfoShow(0, &_memInfo); \
} \
}while(0)
-#define KWDBGP_INTERNAL(_cb,_mask,...) \
+#define RLCDBGP_INTERNAL(_cb,_mask,...) \
do \
{ \
if (!((_cb->init.dbgMask & _mask) ^ _mask)) \
{ \
- KW_PRINT_TO_BUFFER(_cb, __VA_ARGS__); \
+ RLC_PRINT_TO_BUFFER(_cb, __VA_ARGS__); \
} \
}while(0)
-#define KWDBGP_ERROR(_cb, ...) \
- KWDBGP_INTERNAL(_cb,(KW_DBGMASK_ERROR | KW_MODULE),__VA_ARGS__)
+#define RLCDBGP_ERROR(_cb, ...) \
+ RLCDBGP_INTERNAL(_cb,(RLC_DBGMASK_ERROR | RLC_MODULE),__VA_ARGS__)
-#define KWDBGP_DETAIL(_cb, ...) \
- KWDBGP_INTERNAL(_cb,(KW_DBGMASK_DETAIL | KW_MODULE),__VA_ARGS__)
+#define RLCDBGP_DETAIL(_cb, ...) \
+ RLCDBGP_INTERNAL(_cb,(RLC_DBGMASK_DETAIL | RLC_MODULE),__VA_ARGS__)
-#define KWDBGP_BRIEF(_cb, ...) \
- KWDBGP_INTERNAL(_cb,(KW_DBGMASK_BRIEF | KW_MODULE),__VA_ARGS__)
+#define RLCDBGP_BRIEF(_cb, ...) \
+ RLCDBGP_INTERNAL(_cb,(RLC_DBGMASK_BRIEF | RLC_MODULE),__VA_ARGS__)
#else /* DEBUGP */
-#define KW_PRNT_HLINE(_cb,_pMsg)
-#define KW_PRNT(_cb,_prntbuf)
-#define KW_PRNT_TSTAMP(_cb)
-#define KW_PRNT_MBUF(_cb,_mBufPtr)
-#define KW_PRNT_MEMINFO(_cb)
-#define KWDBGP(_cb,_mask, _arg)
-#define KWDBGP_ERROR(_cb, ...)
-#define KWDBGP_DETAIL(_cb, ...)
-#define KWDBGP_BRIEF(_cb, ...)
+#define RLC_PRNT_HLINE(_cb,_pMsg)
+#define RLC_PRNT(_cb,_prntbuf)
+#define RLC_PRNT_TSTAMP(_cb)
+#define RLC_PRNT_MBUF(_cb,_mBufPtr)
+#define RLC_PRNT_MEMINFO(_cb)
+#define RLCDBGP(_cb,_mask, _arg)
+#define RLCDBGP_ERROR(_cb, ...)
+#define RLCDBGP_DETAIL(_cb, ...)
+#define RLCDBGP_BRIEF(_cb, ...)
#endif /* DEBUGP */
/*******************************************************************************
* LMM Defines
******************************************************************************/
-#define KW_LMM_RB_STS_INC(_cb) (_cb)->genSts.numOfRb++;
+#define RLC_LMM_RB_STS_INC(_cb) (_cb)->genSts.numOfRb++;
-#define KW_LMM_RB_STS_DEC(_cb) (_cb)->genSts.numOfRb--;
+#define RLC_LMM_RB_STS_DEC(_cb) (_cb)->genSts.numOfRb--;
#if defined(SS_MULTICORE_SUPPORT) && defined(SS_M_PROTO_REGION)
-#define KW_FILL_SAP_HELPER(_Sap, _cfg, _gCb)\
+#define RLC_FILL_SAP_HELPER(_Sap, _cfg, _gCb)\
{\
_Sap->pst.selector = _cfg->selector; \
_Sap->pst.route = _cfg->route; \
_Sap->pst.srcInst = _gCb->init.inst; \
_Sap->pst.event = EVTNONE; \
_Sap->spId = _cfg->sapId; \
- _Sap->state = KW_SAP_CFG; \
+ _Sap->state = RLC_SAP_CFG; \
}
#else /* defined(SS_MULTICORE_SUPPORT) && defined(SS_M_PROTO_REGION) */
-#define KW_FILL_SAP_HELPER(_Sap, _cfg, _gCb)\
+#define RLC_FILL_SAP_HELPER(_Sap, _cfg, _gCb)\
{\
_Sap->pst.selector = _cfg->selector; \
_Sap->pst.route = _cfg->route; \
_Sap->pst.srcInst = _gCb->init.inst;\
_Sap->pst.event = EVTNONE;\
_Sap->spId = _cfg->sapId;\
- _Sap->state = KW_SAP_CFG;\
+ _Sap->state = RLC_SAP_CFG;\
}
#endif
/*******************************************************************************
* UDX Defines
******************************************************************************/
-#define KW_GET_DL_SAPCB(_cb, _rbCb) (_cb->u.dlCb->udxDlSap + _rbCb->udxSapId)
-#define KW_GET_UDX_SAP(_cb) (_cb->u.ulCb->udxUlSap)
+#define RLC_GET_DL_SAPCB(_cb, _rbCb) (_cb->u.dlCb->udxDlSap + _rbCb->udxSapId)
+#define RLC_GET_UDX_SAP(_cb) (_cb->u.ulCb->udxUlSap)
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-#define KW_L2_MAX_TIMERS 1
-#define KW_QCI_LIST_BUCKET_SIZE 10
-#define KW_TB_LIST_BUCKET_SIZE 10
-#define KW_MAX_L2MEAS_EVT 10
+#define RLC_L2_MAX_TIMERS 1
+#define RLC_QCI_LIST_BUCKET_SIZE 10
+#define RLC_TB_LIST_BUCKET_SIZE 10
+#define RLC_MAX_L2MEAS_EVT 10
/* L2 Measurement index to be used in rbCb to store measData */
-#define KW_L2MEAS_ACT_UE 0
-#define KW_L2MEAS_DL_DELAY 1
-#define KW_L2MEAS_DL_DISC 2
-#define KW_L2MEAS_UU_LOSS 3
-#define KW_L2MEAS_DL_IP 4
-#define KW_L2MEAS_UL_IP 5
+#define RLC_L2MEAS_ACT_UE 0
+#define RLC_L2MEAS_DL_DELAY 1
+#define RLC_L2MEAS_DL_DISC 2
+#define RLC_L2MEAS_UU_LOSS 3
+#define RLC_L2MEAS_DL_IP 4
+#define RLC_L2MEAS_UL_IP 5
#endif /* LTE_L2_MEAS */
-#define KW_RDWR_LOCK(_lockPtr)
-#define KW_RDWR_UNLOCK(_lockPtr)
-#define KW_TIME_DIFF(t1,t2) \
+#define RLC_RDWR_LOCK(_lockPtr)
+#define RLC_RDWR_UNLOCK(_lockPtr)
+#define RLC_TIME_DIFF(t1,t2) \
(t1<t2 ? ((0xffffffff - t2) + t1 ): (t1 - t2))
#endif /* __KWH__ */
#endif /* __cplusplus */
/** @brief Local typedefs */
-typedef U32 KwSn; /*!< Sequence Number length */
+typedef U32 RlcSn; /*!< Sequence Number length */
typedef RguDDatIndInfo KwDatIndInfo;
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-typedef struct kwSduSnMap KwSduSnMap;
+typedef struct rlcSduSnMap RlcSduSnMap;
typedef RguLchMapInfo KwLchMapInfo;
#endif /* LTE_L2_MEAS */
* - numLi : Number of length indicators in the following array (li)
* - li : Length indicators
*/
-typedef struct kwUmHdr
+typedef struct rlcUmHdr
{
U8 fi; /*!< Framing Info */
- KwSn sn; /*!< Sequence number */
+ RlcSn sn; /*!< Sequence number */
U16 numLi; /*!< Number of LIs */
- U16 li[KW_MAX_UL_LI]; /*!< Array of LIs */
-}KwUmHdr;
+ U16 li[RLC_MAX_UL_LI]; /*!< Array of LIs */
+}RlcUmHdr;
/**
* @brief Structure to hold an Acknowledged Mode header
* - numLi : Number of length indicators in the following array (li)
* - li : Length indicators
*/
-typedef struct kwAmHdr
+typedef struct rlcAmHdr
{
U8 dc; /*!< Data/Control PDU */
U8 p; /*!< Poll bit */
U8 si; /*!< Segmentation Info: 5GNR */
- KwSn sn; /*!< Sequence number */
+ RlcSn sn; /*!< Sequence number */
U32 so; /*!< Segment offset */
-}KwAmHdr;
+}RlcAmHdr;
/* structures used for encoding/decoding the headers */
-typedef struct kwCntrlInfo
+typedef struct rlcCntrlInfo
{
U16 val;
U8 len;
U16 e1Idx;
U16 e2Idx;
U8 e1eb;
-}KwCntrlInfo;
+}RlcCntrlInfo;
-typedef struct kwHdrInfo
+typedef struct rlcHdrInfo
{
U32 val;
U8 len;
U16 idx;
U8 pEb;
U8 pLen;
-}KwHdrInfo;
+}RlcHdrInfo;
-typedef struct kwExtHdr
+typedef struct rlcExtHdr
{
U32 val;
U16 len;
U8 hdr;
U8 pLen;
-}KwExtHdr;
+}RlcExtHdr;
/**
* @brief Structure to hold information about a Logical channel
* - lChId : Logical channel Id
* - lChType : Logical channel type
*/
-typedef struct kwLchInfo
+typedef struct rlcLchInfo
{
CmLteLcId lChId; /*!< Logical channel Id */
CmLteLcType lChType; /*!< Logical channel type */
-}KwLchInfo;
+}RlcLchInfo;
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-/** @struct KwL2Cntr
+/** @struct RlcL2Cntr
* RLC L2 Counter */
-typedef struct kwL2Cntr
+typedef struct rlcL2Cntr
{
struct
{
U32 numSdus;
}dlPjSduDelay;
U32 totDrbsPerQci; /*!< Total Count of DRB's for this QCI */
-}KwL2Cntr;
+}RlcL2Cntr;
-struct kwSduSnMap
+struct rlcSduSnMap
{
CmLList lstEnt;
Bool failMarked;
Bool fullySent;
U32 sduId;
U16 numSn;
- U16 snList[KW_MAX_PDU_MAP];
+ U16 snList[RLC_MAX_PDU_MAP];
U16 harqAck;
U16 reqSent;
U16 rspRcvd;
};
-typedef struct kwSnSduMap
+typedef struct rlcSnSduMap
{
U16 sn;
CmLteLcId lChId; /*!< Logical channel Id */
#ifdef LTE_RLC_R9
Bool isBurstSplitted; /*!< true: burst for this LCH is splitted */
#endif /* LTE_RLC_R9 */
- KwSduSnMap *sduList[KW_MAX_DL_LI];
-}KwSnSduMap;
+ RlcSduSnMap *sduList[RLC_MAX_DL_LI];
+}RlcSnSduMap;
-typedef struct kwTbSnMap
+typedef struct rlcTbSnMap
{
CmHashListEnt hlTbEnt;
U32 tbId;
U16 prevNumSn;
U16 numSn;
- KwSnSduMap snSduMap[RGU_MAX_PDU * RGU_MAX_LC];
-}KwTbSnMap;
+ RlcSnSduMap snSduMap[RGU_MAX_PDU * RGU_MAX_LC];
+}RlcTbSnMap;
-typedef struct kwL2MeasCbUeMeasInfo
+typedef struct rlcL2MeasCbUeMeasInfo
{
CmLteRnti ueId; /*!< UE ID (Used only for IP Throughput
in UL/DL */
Bool isValid; /*! < is this UE entry valid */
U8 numLcId; /*!< Holds the number of LCh for which Ul Ip
measurement is ON */
- U8 lcId[KW_MAX_LCH_PER_UE]; /*!< Holds the list of LCh for which Ul ip
+ U8 lcId[RLC_MAX_LCH_PER_UE]; /*!< Holds the list of LCh for which Ul ip
measurement is ON */
- KwL2Cntr measData[LKW_MAX_QCI];
+ RlcL2Cntr measData[LKW_MAX_QCI];
U16 numQci; /*!< number of valid qcI */
U8 qci[LKW_MAX_QCI]; /*!< list of valid qcI */
-}KwL2MeasCbUeMeasInfo;
+}RlcL2MeasCbUeMeasInfo;
-typedef struct kwL2MeasCbIpThMeas
+typedef struct rlcL2MeasCbIpThMeas
{
U8 numUes;
U8 totNumQci;
U8 totQci[LKW_MAX_QCI];
- KwL2MeasCbUeMeasInfo ueInfoLst[LKW_MAX_UE]; /*Added for handling meas for multiple ues*/
-}KwL2MeasCbIpThMeas;
+ RlcL2MeasCbUeMeasInfo ueInfoLst[LKW_MAX_UE]; /*Added for handling meas for multiple ues*/
+}RlcL2MeasCbIpThMeas;
-typedef struct kwL2MeasCbNonIpThMeas
+typedef struct rlcL2MeasCbNonIpThMeas
{
U16 numSamples; /*!< Number of samples to take on numActUe */
U16 numQci; /*!< number of valid qcI */
U8 qci[LKW_MAX_QCI]; /*!< list of valid qcI */
- KwL2Cntr measData[LKW_MAX_QCI]; /*!< Measurement CB */
-}KwL2MeasCbNonIpThMeas;
+ RlcL2Cntr measData[LKW_MAX_QCI]; /*!< Measurement CB */
+}RlcL2MeasCbNonIpThMeas;
-typedef union kwL2MeasCbIpNonIpThMeasVal
+typedef union rlcL2MeasCbIpNonIpThMeasVal
{
- KwL2MeasCbIpThMeas ipThMeas;
- KwL2MeasCbNonIpThMeas nonIpThMeas;
-}KwL2MeasCbIpNonIpThMeasVal;
+ RlcL2MeasCbIpThMeas ipThMeas;
+ RlcL2MeasCbNonIpThMeas nonIpThMeas;
+}RlcL2MeasCbIpNonIpThMeasVal;
-/** @struct KwL2MeasCb
+/** @struct RlcL2MeasCb
* RLC L2 Measurement CB */
-typedef struct kwL2MeasCb
+typedef struct rlcL2MeasCb
{
U8 measType; /*!< Bit-wise set measurement types */
- KwL2MeasCbIpNonIpThMeasVal val; /* Union of IP tpt or non-ip tpt */
-}KwL2MeasCb;
+ RlcL2MeasCbIpNonIpThMeasVal val; /* Union of IP tpt or non-ip tpt */
+}RlcL2MeasCb;
-/** @struct KwL2MeasEvtCb
+/** @struct RlcL2MeasEvtCb
* RLC L2 Measurement Evt CB */
-typedef struct kwL2MeasEvtCb
+typedef struct rlcL2MeasEvtCb
{
U32 transId; /*!< TransId of Measurement Req */
U32 cbIdx; /*!< TransId of Measurement Req */
CmTimer l2Tmr; /* NOT USED */ /*!< L2 Timer per request */
TmrCfg l2TmrCfg; /* NOT USED */ /*!< Time period of measurement */
- KwL2MeasCb measCb; /*!< Measurement CB */
+ RlcL2MeasCb measCb; /*!< Measurement CB */
EpcTime startTime; /* NOT USED */ /*!< start time when meas starts*/
-}KwL2MeasEvtCb;
+}RlcL2MeasEvtCb;
-/** @struct KwL2MeasRbCb
+/** @struct RlcL2MeasRbCb
* RLC L2 Measurement Rb CB */
-typedef struct kwL2MeasRbCb
+typedef struct rlcL2MeasRbCb
{
U8 measOn; /*!< Measurements that are running */
- KwL2Cntr *l2Sts[KW_MAX_L2MEAS_EVT]; /*!< L2 Mesurement statistics */
-}KwL2MeasRbCb;
+ RlcL2Cntr *l2Sts[RLC_MAX_L2MEAS_EVT]; /*!< L2 Mesurement statistics */
+}RlcL2MeasRbCb;
-/** @struct KwL2Cb
+/** @struct RlcL2Cb
* RLC L2 CB */
-typedef struct kwL2Cb
+typedef struct rlcL2Cb
{
- U16 kwNumMeas; /*!< Number of measurements going on */
- KwL2MeasEvtCb kwL2EvtCb[LKW_MAX_L2MEAS]; /*!< Pointers to Measurement Cb */
+ U16 rlcNumMeas; /*!< Number of measurements going on */
+ RlcL2MeasEvtCb rlcL2EvtCb[LKW_MAX_L2MEAS]; /*!< Pointers to Measurement Cb */
U8 measOn[LKW_MAX_QCI]; /*!< Measurement on */
U32 numActUe[LKW_MAX_QCI]; /*!< Measurement on */
-}KwL2Cb;
+}RlcL2Cb;
typedef enum _dlIpThrputState
}DlIpThrputState;
/**
-* @struct kwL2MeasSduLst
+* @struct rlcL2MeasSduLst
* Structure to hold parameters of
* burst sdus in DL for a RB */
-typedef struct kwOutStngSduInfo
+typedef struct rlcOutStngSduInfo
{
U32 sduId; /*!< SDU Id of sdu */
MsgLen sduLen; /*!< Size of sdu */
U32 numTb; /*!< Hold the number of TBs for this sdu in DL */
-}KwOutStngSduInfo;
+}RlcOutStngSduInfo;
/**
-* @struct kwL2MeasDlIpTh
+* @struct rlcL2MeasDlIpTh
* Structure to hold parameters for DL ip
* throughput for a RB */
-typedef struct kwL2MeasDlIpTh
+typedef struct rlcL2MeasDlIpTh
{
Bool isBurstAct; /*!< Set to TRUE when burst is active in DL */
U64 burstStartTime; /*!< Holds the starting time of the burst */
U32 burstEndSduId; /*!< Sdu ID when burst ends */
U8 lastSduIdx; /*!< Holds the index of last outStanding sdu */
- KwOutStngSduInfo outStngSduArr[KW_L2MEAS_MAX_OUTSTNGSDU];/*!< Hold the burst sdu information */
-}KwL2MeasDlIpTh;
+ RlcOutStngSduInfo outStngSduArr[RLC_L2MEAS_MAX_OUTSTNGSDU];/*!< Hold the burst sdu information */
+}RlcL2MeasDlIpTh;
/**
-* @struct kwL2MeasIpThruput
+* @struct rlcL2MeasIpThruput
* Structure to hold parameters for UL/DL ip
* throughput for a RB */
-typedef struct kwL2MeasIpThruput
+typedef struct rlcL2MeasIpThruput
{
U32 dataVol; /*!< Holds volume of new data in bytes
for UL IP throughput */
U32 ttiCnt; /*!< Holds ttiCnt received from MAC in UL */
U32 prevTtiCnt; /*!< Holds previous ttiCnt received from MAC in UL */
- KwL2MeasDlIpTh dlIpTh;
-}KwL2MeasIpThruput;
+ RlcL2MeasDlIpTh dlIpTh;
+}RlcL2MeasIpThruput;
#endif /* LTE_L2_MEAS */
* - ueId : UE Id
* - cellId : Cell Id
*/
-typedef struct kwUeKey
+typedef struct rlcUeKey
{
CmLteRnti ueId; /*!< UE Id */
CmLteCellId cellId; /*!< Cell Id */
-}KwUeKey;
+}RlcUeKey;
/**
* @brief Structure to hold an information about the CKW SAP
* - state : State of the SAP
* - sts : SAP specific statistics
*/
-typedef struct kwCkwSapCb
+typedef struct rlcCkwSapCb
{
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
SuId suId; /*!< Service user Id */
U8 state; /*!< Sap Status */
- KwCkwCntSts sts; /*!< Statistics */
-}KwCkwSapCb;
+ RlcCkwCntSts sts; /*!< Statistics */
+}RlcCkwSapCb;
/**
* @brief Structure to hold an information about the KWU SAP
* - state : State of the SAP
* - sts : SAP specific statistics
*/
-typedef struct kwKwuSapCb
+typedef struct rlcKwuSapCb
{
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
SuId suId; /*!< Service user Id */
U8 state; /*!< Sap Status */
- KwKwuSapSts sts; /*!< Statistics */
-}KwKwuSapCb;
+ RlcKwuSapSts sts; /*!< Statistics */
+}RlcKwuSapCb;
/**
* @brief Structure to hold an information about the RGU SAP
* - bndTmrInt : Timer Interval
* - retryCnt : Bind Retry Count
*/
-typedef struct kwRguSapCb
+typedef struct rlcRguSapCb
{
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
CmTimer bndTmr; /*!< Bind Timer */
U16 bndTmrInt; /*!< Timer Interval */
U8 retryCnt; /*!< Bind Retry Count */
-}KwRguSapCb;
+}RlcRguSapCb;
/**
* @brief Structure to hold an information about the UDX UL SAP
* - bndTmrInt : Timer Interval
* - retryCnt : Bind Retry Count
*/
-typedef struct kwUdxUlSapCb
+typedef struct rlcUdxUlSapCb
{
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
CmTimer bndTmr; /*!< Bind Timer */
U16 bndTmrInt; /*!< Timer Interval */
U8 retryCnt; /*!< Bind Retry Count */
-}KwUdxUlSapCb;
+}RlcUdxUlSapCb;
/**
* @brief Structure to hold an information about the UDX DL SAP
* - suId : Service user Id
* - state : State of the SAP
*/
-typedef struct kwUdxDlSapCb
+typedef struct rlcUdxDlSapCb
{
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
SuId suId; /*!< Service user Id */
U8 state; /*!< Sap Status */
-}KwUdxDlSapCb;
+}RlcUdxDlSapCb;
/**
* @brief Structure to hold info about memory to be freed
* @details
* - numKwuSaps : Number of RLC KWU Saps
* - numUdxSaps : Number of RLC UDX Saps
- * - kwuDlSap : Pointer to the array of KWU SAPS
+ * - rlcKwuDlSap : Pointer to the array of KWU SAPS
* - udxDlSap : Pointer to the array of UDX SAPS
* - rguDlSap : RGU Sap Control Block
* - cellLstCp : Hashlist of CellCb
{
U8 numKwuSaps; /*!< Number of RLC Data Saps */
U8 numUdxSaps; /*!< Number of RLC Data Saps */
- KwKwuSapCb *kwuDlSap; /*!< KWU Sap Control Block */
- KwUdxDlSapCb *udxDlSap; /*!< UDX DL Sap Control Block */
- KwRguSapCb *rguDlSap; /*!< RGU Sap Control Block */
+ RlcKwuSapCb *rlcKwuDlSap; /*!< KWU Sap Control Block */
+ RlcUdxDlSapCb *udxDlSap; /*!< UDX DL Sap Control Block */
+ RlcRguSapCb *rguDlSap; /*!< RGU Sap Control Block */
CmHashListCp cellLstCp; /*!< Hashlist of CellCb */
CmHashListCp ueLstCp; /*!< Hashlist of UeCb */
RlcDlDataToBeFreed toBeFreed; /*!< Pointer to data to be freed */
Bool shutdownReceived; /*!< Request for shutdown recevied */
Bool eventInQueue; /*!< Event exists in queue or not */
#ifdef LTE_L2_MEAS
- KwL2Cb kwL2Cb; /*!< Control Block for L2 Measurements in RLC */
+ RlcL2Cb rlcL2Cb; /*!< Control Block for L2 Measurements in RLC */
#endif /* LTE_L2_MEAS */
}RlcDlCb;
* - numKwuSaps : Number of RLC KWU Saps
* - numUdxSaps : Number of RLC UDX Saps
* - udxUlSap : Pointer to the array of UDX SAPS
- * - kwuUlSap : Pointer to the array of KWU SAPS
+ * - rlcKwuUlSap : Pointer to the array of KWU SAPS
* - rguUlSap : RGU Sap Control Block
* - cellLstCp : Hashlist of CellCb
* - ueLstCp : Hashlist of UeCb
*/
typedef struct rlcUlCb
{
- KwCkwSapCb ckwSap; /*!< CKW Sap Conrol Block */
+ RlcCkwSapCb ckwSap; /*!< CKW Sap Conrol Block */
U8 numKwuSaps; /*!< Number of RLC Data Saps */
U8 numUdxSaps; /*!< Number of RLC Data Saps */
- KwUdxUlSapCb *udxUlSap; /*!< UDX DL Sap Control Block */
- KwKwuSapCb *kwuUlSap; /*!< KWU Sap Control Block */
- KwRguSapCb *rguUlSap; /*!< RGU Sap Control Block */
+ RlcUdxUlSapCb *udxUlSap; /*!< UDX DL Sap Control Block */
+ RlcKwuSapCb *rlcKwuUlSap; /*!< KWU Sap Control Block */
+ RlcRguSapCb *rguUlSap; /*!< RGU Sap Control Block */
CmHashListCp cellLstCp; /*!< Hashlist of CellCb */
CmHashListCp ueLstCp; /*!< Hashlist of UeCb */
CmHashListCp transIdLstCp; /*!< Hashlist of cfg trans */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- KwL2Cb kwL2Cb; /*!< Control Block for L2 Measurements in RLC */
+ RlcL2Cb rlcL2Cb; /*!< Control Block for L2 Measurements in RLC */
#endif /* LTE_L2_MEAS */
}RlcUlCb;
* - genSts : General Statistics
* - trcLen : Trace Length
* - trcMask : Trace Mask
- * - kwTq : Timer queue
- * - kwTqCp : Timer queue control point
+ * - rlcTq : Timer queue
+ * - rlcTqCp : Timer queue control point
* - u : Union depending on whether the instance is UL or DL
* - ulCb : UL instance Control Block
* - dlCb : DL instance Control Block
typedef struct rlcCb
{
TskInit init; /*!< Task Initialization Info */
- KwGenCfg genCfg; /*!< General Configuration Structure */
- KwGenSts genSts; /*!< General Statistics */
+ RlcGenCfg genCfg; /*!< General Configuration Structure */
+ RlcGenSts genSts; /*!< General Statistics */
S16 trcLen; /*!< Trace Length */
U8 trcMask; /*!< Trace Mask */
- CmTqType kwTq[KW_TMR_LEN]; /*!< Timer queue */
- CmTqCp kwTqCp; /*!< Timer queue control point */
+ CmTqType rlcTq[RLC_TMR_LEN]; /*!< Timer queue */
+ CmTqCp rlcTqCp; /*!< Timer queue control point */
union
{
RlcUlCb *ulCb; /*!< Ul Control Block */
/****************************************************************************
* EXTERN Declarations
***************************************************************************/
-EXTERN S16 kwGetSId ARGS((SystemId *s));
+EXTERN S16 rlcGetSId ARGS((SystemId *s));
-EXTERN Void kwTmrExpiry ARGS((PTR cb, S16 tmrEvnt));
+EXTERN Void rlcTmrExpiry ARGS((PTR cb, S16 tmrEvnt));
-EXTERN S16 kwLmmSendTrc ARGS ((RlcCb *gCb, Event event, Buffer *mBuf));
+EXTERN S16 rlcLmmSendTrc ARGS ((RlcCb *gCb, Event event, Buffer *mBuf));
-EXTERN Void kwStartTmr ARGS((RlcCb *gCb, PTR cb, S16 tmrEvnt));
+EXTERN Void rlcStartTmr ARGS((RlcCb *gCb, PTR cb, S16 tmrEvnt));
-EXTERN Void kwStopTmr ARGS((RlcCb *gCb, PTR cb, U8 tmrType));
+EXTERN Void rlcStopTmr ARGS((RlcCb *gCb, PTR cb, U8 tmrType));
-EXTERN Bool kwChkTmr ARGS((RlcCb *gCb,PTR cb, S16 tmrEvnt));
+EXTERN Bool rlcChkTmr ARGS((RlcCb *gCb,PTR cb, S16 tmrEvnt));
#ifdef LTE_L2_MEAS
-EXTERN Void kwLmmSendAlarm ARGS (( RlcCb *gCb,
+EXTERN Void rlcLmmSendAlarm ARGS (( RlcCb *gCb,
U16 category,
U16 event,
U16 cause,
U32 ueId,
U8 qci));
-EXTERN S16 KwMiRlcDlL2MeasReq ARGS (( Pst *pst, KwL2MeasReqEvt *measReqEvt ));
-EXTERN S16 KwMiRlcDlL2MeasSendReq ARGS((Pst *pst,U8 measType));
-EXTERN S16 KwMiRlcDlL2MeasStopReq ARGS((Pst *pst,U8 measType));
-EXTERN S16 KwMiRlcUlL2MeasReq ARGS (( Pst *pst, KwL2MeasReqEvt *measReqEvt ));
-EXTERN S16 KwMiRlcUlL2MeasSendReq ARGS((Pst *pst,U8 measType));
-EXTERN S16 KwMiRlcUlL2MeasStopReq ARGS((Pst *pst,U8 measType));
-EXTERN Void kwUtlPlcMeasDatInL2Sts ARGS((KwL2Cntr *measData,
- KwL2MeasRbCb *rbL2Cb,
+EXTERN S16 RlcMiRlcDlL2MeasReq ARGS (( Pst *pst, RlcL2MeasReqEvt *measReqEvt ));
+EXTERN S16 RlcMiRlcDlL2MeasSendReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 RlcMiRlcDlL2MeasStopReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 RlcMiRlcUlL2MeasReq ARGS (( Pst *pst, RlcL2MeasReqEvt *measReqEvt ));
+EXTERN S16 RlcMiRlcUlL2MeasSendReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 RlcMiRlcUlL2MeasStopReq ARGS((Pst *pst,U8 measType));
+EXTERN Void rlcUtlPlcMeasDatInL2Sts ARGS((RlcL2Cntr *measData,
+ RlcL2MeasRbCb *rbL2Cb,
U8 measType));
#else /* LTE_L2_MEAS */
-EXTERN Void kwLmmSendAlarm ARGS ((RlcCb *gCb,
+EXTERN Void rlcLmmSendAlarm ARGS ((RlcCb *gCb,
U16 category,
U16 event,
U16 cause,
//UDAY
#ifdef L2_OPTMZ
-extern U32 kwAmmStaPduList[512];
- U32 kwAmmStaPduListCnt = 0;
+extern U32 rlcAmmStaPduList[512];
+ U32 rlcAmmStaPduListCnt = 0;
#endif
/** @file gp_amm_dl.c
@brief RLC Acknowledged Mode Downlink Module
**/
-#define KW_MODULE (KW_DBGMASK_AM | KW_DBGMASK_DL)
+#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_DL)
-U32 kwStatusPduCnt, kwStatusAckCnt, kwStatusNcnt, kwSduSndCnt;
+U32 rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt;
/* local defines */
/* local externs */
/* forward references */
-EXTERN Void kwAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
+EXTERN Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwUdxStaPdu *pStaPdu));
+ RlcUdxStaPdu *pStaPdu));
/* public variable declarations */
/* private variable declarations */
-#define KW_AM_RMV_HDR(_gCb, _rbCb, _retx) do { \
+#define RLC_AM_RMV_HDR(_gCb, _rbCb, _retx) do { \
if ((_retx)->yetToConst == FALSE) \
{\
Buffer *_pduInfo; \
/* private function declarations */
-PRIVATE Void kwResegRetxPdus ARGS ((RlcCb *gCb,
+PRIVATE Void rlcResegRetxPdus ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwDatReq *kwDatReq));
+ RlcDatReq *rlcDatReq));
-PRIVATE Void kwRemRetxPdu ARGS ((RlcCb *gCb,
+PRIVATE Void rlcRemRetxPdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwRetx *retx));
+ RlcRetx *retx));
-PRIVATE Void kwAmmCreateStatusPdu ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmCreateStatusPdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwDatReq *kwDatReq));
+ RlcDatReq *rlcDatReq));
-PRIVATE Void kwAmmDlMarkPduForReTx ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmDlMarkPduForReTx ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwRetx *retx));
+ RlcRetx *retx));
-PRIVATE Void kwAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb,
+PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwSn sn,
+ RlcSn sn,
KwuDatCfmInfo **datCfm));
-PRIVATE Void kwAmmDlSetTxNextAck ARGS((KwAmDl *amDl, KwSn sn));
+PRIVATE Void rlcAmmDlSetTxNextAck ARGS((RlcAmDl *amDl, RlcSn sn));
-PRIVATE Void kwAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb,
+PRIVATE Void rlcAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwSn mAckSn));
+ RlcSn mAckSn));
-PRIVATE Void kwAssembleSdus ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAssembleSdus ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwDatReq *kwDatReq));
+ RlcDatReq *rlcDatReq));
-PRIVATE Bool kwAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb,
+PRIVATE Bool rlcAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
Bool newPdu,
MsgLen bufSz));
-PRIVATE Void kwAmmCreatePdu ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmCreatePdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwAmHdr *amHdr,
+ RlcAmHdr *amHdr,
RlcDlPduInfo *pduInfo,
Buffer *pdu));
-PRIVATE Void kwAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, KwRetx *retx));
+PRIVATE Void rlcAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, RlcRetx *retx));
-PRIVATE Void kwGetNxtRetx ARGS ((RlcCb *gCb, KwRetx **retx));
+PRIVATE Void rlcGetNxtRetx ARGS ((RlcCb *gCb, RlcRetx **retx));
-PRIVATE Void kwConstructAmHdr ARGS ((KwAmHdr *amHdr,
+PRIVATE Void rlcConstructAmHdr ARGS ((RlcAmHdr *amHdr,
U8 *hdr,
U8 snLen,
U16 *idx));
-PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwSn mAckSn,
+ RlcSn mAckSn,
CmLList *retx,
KwuDatCfmInfo **datCfm));
-PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb,
- KwAmDl *amDl,
- KwRetx **retx,
- KwSn sn));
+PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb,
+ RlcAmDl *amDl,
+ RlcRetx **retx,
+ RlcSn sn));
-PRIVATE Void kwAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb,
+PRIVATE Void rlcAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwSduMap *sduMap,
+ RlcSduMap *sduMap,
KwuDatCfmInfo **datCfm));
-PRIVATE Void kwAmmAddPduToRetxLst ARGS((KwAmDl *amDl,
- KwRetx *retx));
+PRIVATE Void rlcAmmAddPduToRetxLst ARGS((RlcAmDl *amDl,
+ RlcRetx *retx));
-PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS(
+PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS(
(
RlcCb *gCb,
-KwAmDl *amDl,
-KwRetx **retx,
+RlcAmDl *amDl,
+RlcRetx **retx,
RlcDlPduInfo *pduInfo
));
-PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf ARGS(
+PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf ARGS(
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwNackInfo *nackSnInfo,
-KwRetx **retx,
+RlcNackInfo *nackSnInfo,
+RlcRetx **retx,
KwuDatCfmInfo **datCfm
));
-PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn ARGS(
+PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn ARGS(
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwNackInfo *nackSnInfo,
+ RlcNackInfo *nackSnInfo,
CmLList **retxNode,
KwuDatCfmInfo **datCfm
));
PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ARGS(
(
-KwAmDl *amDl,
-KwNackInfo *nackInfo,
+RlcAmDl *amDl,
+RlcNackInfo *nackInfo,
CmLList *retxNode,
-KwNackInfo *nackSnInfo,
+RlcNackInfo *nackSnInfo,
U8 idx
));
-PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS(
+PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS(
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwSn sn,
-KwSn mNackSn,
+RlcSn sn,
+RlcSn mNackSn,
CmLList **retxNode,
KwuDatCfmInfo **datCfm
));
AM Module contains the following funcitons:
- - kwAmmQSdu
- - kwAmmProcessSdus
- - kwAmmDlAssembleCntrlInfo
- - kwResegRetxPdus
- - kwAssembleSdus
- - kwAmmDlCheckAndSetPoll
- - kwAmmProcessPdus
+ - rlcAmmQSdu
+ - rlcAmmProcessSdus
+ - rlcAmmDlAssembleCntrlInfo
+ - rlcResegRetxPdus
+ - rlcAssembleSdus
+ - rlcAmmDlCheckAndSetPoll
+ - rlcAmmProcessPdus
- rlcDlmHndlStaRsp
- kwTriggerStatus
- kwReassembleSdus
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwAmmSendDStaRsp
+Void rlcAmmSendDStaRsp
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwAmDl *amDl
+RlcAmDl *amDl
)
#else
-PUBLIC Void kwAmmSendDStaRsp(gCb, rbCb, amDl)
+Void rlcAmmSendDStaRsp(gCb, rbCb, amDl)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwAmDl *amDl;
+RlcAmDl *amDl;
#endif
{
- S32 bo = kwAmmCalculateBo(amDl);
+ S32 bo = rlcAmmCalculateBo(amDl);
if(bo)
{
- kwUtlSndDStaRsp(gCb, rbCb, bo, amDl->estHdrSz, amDl->cntrlBo ?TRUE:FALSE,amDl->cntrlBo);
+ rlcUtlSndDStaRsp(gCb, rbCb, bo, amDl->estHdrSz, amDl->cntrlBo ?TRUE:FALSE,amDl->cntrlBo);
}
RETVOID;
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlCheckAndStopPollTmr
+PRIVATE Void rlcAmmDlCheckAndStopPollTmr
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwSn mAckSn
+RlcSn mAckSn
)
#else
-PRIVATE Void kwAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn)
+PRIVATE Void rlcAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwSn mAckSn;
+RlcSn mAckSn;
#endif
{
- KwSn mPollSn;
+ RlcSn mPollSn;
MODAMT(rbCb->m.amDl.pollSn, mPollSn, rbCb->m.amDl.txNextAck,rbCb->m.amDl.snModMask);
if (mPollSn <= mAckSn)
{
- if (kwChkTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR))
+ if (rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
{
- kwStopTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
}
}
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlSetTxNextAck
+PRIVATE Void rlcAmmDlSetTxNextAck
(
-KwAmDl *amDl,
-KwSn sn
+RlcAmDl *amDl,
+RlcSn sn
)
#else
-PRIVATE Void kwAmmDlSetTxNextAck(amDl, sn)
-KwAmDl *amDl;
-KwSn sn
+PRIVATE Void rlcAmmDlSetTxNextAck(amDl, sn)
+RlcAmDl *amDl;
+RlcSn sn
#endif
{
amDl->txNextAck = sn;
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlProcessSuccessfulReTx
+PRIVATE Void rlcAmmDlProcessSuccessfulReTx
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwRetx *retx,
+RlcRetx *retx,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void kwAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm)
+PRIVATE Void rlcAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwRetx *retx;
+RlcRetx *retx;
KwuDatCfmInfo **datCfm;
#endif
{
- kwAmmDlCheckIsSDUDelivered(gCb, rbCb, &(retx->sduMap), datCfm);
+ rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, &(retx->sduMap), datCfm);
- kwRemRetxPdu(gCb, rbCb, retx);
+ rlcRemRetxPdu(gCb, rbCb, retx);
RETVOID;
}
* This function is used to move the PDU from the txBuf to re-transmit buffer
*
* @param[in]RlcCb *gCb RLC instance control block
- * @param[in]KwAmDl *amDl AM Downlink Control Block
- * @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by
+ * @param[in]RlcAmDl *amDl AM Downlink Control Block
+ * @param[in]RlcRetx **retx node in the reTx buffer to be moved to, allocated by
* this function
* @param[in]RlcDlPduInfo *pduInfo TX PDU which needs to be moved
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer
+PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer
(
RlcCb *gCb,
-KwAmDl *amDl,
-KwRetx **retx,
+RlcAmDl *amDl,
+RlcRetx **retx,
RlcDlPduInfo *pduInfo
)
#else
-PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo)
+PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo)
RlcCb *gCb;
-KwAmDl *amDl;
-KwRetx **retx;
+RlcAmDl *amDl;
+RlcRetx **retx;
RlcDlPduInfo *pduInfo;
#endif
{
- TRC2(kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer);
+ TRC2(rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer);
- RLC_ALLOC_WC(gCb,*retx, sizeof(KwRetx));
+ RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
(*retx)->lstEnt.next = 0;
(*retx)->lstEnt.prev = 0;
/* copy the sdu maps */
- KW_MEM_CPY(&((*retx)->sduMap),
+ RLC_MEM_CPY(&((*retx)->sduMap),
&pduInfo->sduMap,
- sizeof(KwSduMap));
+ sizeof(RlcSduMap));
- KW_MEM_CPY(&((*retx)->amHdr), &pduInfo->amHdr, sizeof(KwAmHdr));
- kwAmmAddPduToRetxLst(amDl, (*retx));
+ RLC_MEM_CPY(&((*retx)->amHdr), &pduInfo->amHdr, sizeof(RlcAmHdr));
+ rlcAmmAddPduToRetxLst(amDl, (*retx));
/* Update the BO appropriately */
amDl->retxBo += (*retx)->segSz;
gRlcStats.amRlcStats.numDLRetransPdus++;
RETVOID;
-} /*kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
+} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
/**
* @brief Function to handle Status of Sdu byte segment for a nackSn
*
* @param[in]RlcCb *gCb RLC instance control block
* @param[in]RlcDlRbCb *rbCb AM Downlink Control Block
- * @param[in]KwNackInfo *nackSnInfo Nack Information of a NACK_SN
- * @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by
+ * @param[in]RlcNackInfo *nackSnInfo Nack Information of a NACK_SN
+ * @param[in]RlcRetx **retx node in the reTx buffer to be moved to, allocated by
* this function
* @param[in]KwuDatCfmInfo **datCfm Ptr to datCfm
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf
+PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwNackInfo *nackSnInfo,
-KwRetx **retx,
+RlcNackInfo *nackSnInfo,
+RlcRetx **retx,
KwuDatCfmInfo ** datCfm
)
#else
-PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm)
+PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm)
(
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwNackInfo *nackSnInfo;
-KwRetx **retx;
+RlcNackInfo *nackSnInfo;
+RlcRetx **retx;
KwuDatCfmInfo **datCfm;
)
#endif
{
- KwTx *txBuf=NULLP;
+ RlcTx *txBuf=NULLP;
CmLList *lnk;
CmLList *nextLnk;
- TRC2(kwAmmDlHndlStatus4SduByteSegInTxBuf)
+ TRC2(rlcAmmDlHndlStatus4SduByteSegInTxBuf)
- txBuf = kwUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
+ txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
if (txBuf == NULLP)
{
RETVOID;
while(lnk)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(lnk->node);
- KwSn pduSoEnd = (pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1);
+ RlcSn pduSoEnd = (pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1);
/* If So of Sdu byte segment(pduInfo/seg) is < status pdu
soStart that means it's ACKED*/
if(pduSoEnd < nackSnInfo->soStart)
{
- kwAmmDlCheckIsSDUDelivered(gCb,
+ rlcAmmDlCheckIsSDUDelivered(gCb,
rbCb,
&(pduInfo->sduMap),
datCfm);
else if (pduSoEnd <= nackSnInfo->soEnd)
{
/* Move Sdu byte segment from TX buf to retx buf*/
- kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb,
+ rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb,
&rbCb->m.amDl,
retx,
pduInfo);
if(!txBuf->pduLst.count)
{
/*No more Sdu byte segment are left. Hence delete txBuf*/
- kwUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb);
+ rlcUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb);
}
RETVOID;
*
* @param[in]RlcCb *gCb RLC instance control block
* @param[in]RlcDlRbCb *rbCb AM Downlink Control Block
- * @param[in]KwNackInfo *nackSnInfo Nack Information of a NACK_SN
- * @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by
+ * @param[in]RlcNackInfo *nackSnInfo Nack Information of a NACK_SN
+ * @param[in]RlcRetx **retx node in the reTx buffer to be moved to, allocated by
* this function
* @param[in]KwuDatCfmInfo **datCfm Ptr to datCfm
*
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn
+PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwNackInfo *nackSnInfo,
+ RlcNackInfo *nackSnInfo,
CmLList **retxNode,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm)
+PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm)
(
RlcCb *gCb;
RlcDlRbCb *rbCb;
- KwNackInfo *nackSnInfo;
+ RlcNackInfo *nackSnInfo;
CmLList **retxNode;
KwuDatCfmInfo **datCfm;
)
#endif
{
- KwTx *txBuf;
- KwRetx *retx;
+ RlcTx *txBuf;
+ RlcRetx *retx;
- TRC2(kwAmmDlUpdateTxAndReTxBufForNackSn)
+ TRC2(rlcAmmDlUpdateTxAndReTxBufForNackSn)
/* Now process the NACK_SN received. Now the NACK_SN is */
/* either the first element of RETX or is in TX array */
/* if the NACK_SN is in the transmit buffer, move it to the re-
transmit buffer */
- txBuf = kwUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
+ txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
if (txBuf != NULLP)
{
if(nackSnInfo->isSegment)
/* Go through all the AMD PDUs of a particular SN
and check if segment is ACKED if yes then mark succesfully sent,
if segment is NACKed then move it to to retx lst */
- kwAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, &retx, datCfm);
+ rlcAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, &retx, datCfm);
}
else
{
/*e2= 0 and e3= 0: Move complete PDU from TX buf to retx buf*/
- kwAmmDlMoveFrmTxtoRetxBuffer(gCb,
+ rlcAmmDlMoveFrmTxtoRetxBuffer(gCb,
&rbCb->m.amDl,
&retx,
nackSnInfo->sn);
this NACK_SN */
while (*retxNode)
{
- retx = (KwRetx *)((*retxNode)->node);
+ retx = (RlcRetx *)((*retxNode)->node);
if (retx->amHdr.sn != nackSnInfo->sn)
{
break;
((retx->soEnd < nackSnInfo->soStart) /*|| (retx->amHdr.so > soEnd)*/))
{
RLOG_ARG3(L_DEBUG, DBG_RBID, rbCb->rlcId.rbId,
- "kwHndlStaRsp: Handle ACK for byte segment, Its "
+ "rlcHndlStaRsp: Handle ACK for byte segment, Its "
"sn = %d UEID:%d CELLID:%d",
nackSnInfo->sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
(*retxNode) = (*retxNode)->next;
- kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
+ rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
}
else if((!nackSnInfo->isSegment) || (retx->soEnd <= nackSnInfo->soEnd))
{
(*retxNode) = (*retxNode)->next;
/* Mark the retx PDU we found for further retransmission */
- kwAmmDlMarkPduForReTx(gCb, rbCb, retx);
+ rlcAmmDlMarkPduForReTx(gCb, rbCb, retx);
}
else
{
* @details
* This function is used to get nack Sn information from nackRange index
*
-* @param[in]KwAmDl *amDl,
-* @param[in]KwUdxStaPdu *StaPdu,
-* @param[in]KwNackInfo *nackSnInfo,
-* @param[in]KwRetx *retx;
-* @param[in]KwSn sn,
+* @param[in]RlcAmDl *amDl,
+* @param[in]RlcUdxStaPdu *StaPdu,
+* @param[in]RlcNackInfo *nackSnInfo,
+* @param[in]RlcRetx *retx;
+* @param[in]RlcSn sn,
* @param[in]U8 idx
*
* @return Void
#ifdef ANSI
PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx
(
-KwAmDl *amDl,
-KwNackInfo *nackInfo,
+RlcAmDl *amDl,
+RlcNackInfo *nackInfo,
CmLList *retxNode,
-KwNackInfo *nackSnInfo,
+RlcNackInfo *nackSnInfo,
U8 idx
)
#else
PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
(
-KwAmDl *amDl;
-KwNackInfo *nackInfo;
+RlcAmDl *amDl;
+RlcNackInfo *nackInfo;
CmLList *retxNode;
-KwNackInfo *nackSnInfo;
+RlcNackInfo *nackSnInfo;
U8 idx;
)
#endif
{
- KwTx *txBuf;
- KwRetx *retx;
+ RlcTx *txBuf;
+ RlcRetx *retx;
CmLList *node;
TRC2(RlcDlAmmGetNackSnInfoFrmNackRangeIdx)
nackSnInfo->soEnd = 0;
RETVOID;
}
- txBuf = kwUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn);
+ txBuf = rlcUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn);
if(txBuf != NULLP)
{
node = txBuf->pduLst.first;
{
while (retxNode)
{
- retx = (KwRetx *)(retxNode->node);
+ retx = (RlcRetx *)(retxNode->node);
if(retx->amHdr.sn != nackSnInfo->sn)
{
break;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwAmmDlHndlStatusPdu
+Void rlcAmmDlHndlStatusPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwUdxStaPdu *pStaPdu
+RlcUdxStaPdu *pStaPdu
)
#else
-PUBLIC Void kwAmmDlHndlStatusPdu(gCb, rbCb, pStaPdu)
+Void rlcAmmDlHndlStatusPdu(gCb, rbCb, pStaPdu)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwUdxStaPdu *pStaPdu;
+RlcUdxStaPdu *pStaPdu;
#endif
{
- KwSn mAckSn;
+ RlcSn mAckSn;
S32 oldRetxBo;
CmLList *retxNode;
KwuDatCfmInfo* datCfm;
- KwKwuSapCb *kwuSap;
- KwSn mTxNext;
+ RlcKwuSapCb *rlckwuSap;
+ RlcSn mTxNext;
- TRC2(kwAmmDlHndlStatusPdu)
- kwStatusPduCnt++;
+ TRC2(rlcAmmDlHndlStatusPdu)
+ rlcStatusPduCnt++;
- kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
+ rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
/* store the re-transmission bo, to check if it changes due to the
processing of the status pdu */
oldRetxBo = AMDL.retxBo;
/* Allocate memory for datCfm Info */
- RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (datCfm == NULLP)
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
RETVOID;
}
#endif /* ERRCLASS & ERRCLS_RES */
AMDL.txNextAck,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
-/* RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */
- RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+/* RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */
+ RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
RETVOID;
}
/* Venki - stopping the poll retx timer */
/*Stop PollRetx Tmr */
- kwAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn);
+ rlcAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn);
/* Set the first node in retx list to retxNode */
retxNode = AMDL.retxLst.first;
/* If NACK exists in control PDU */
if (pStaPdu->nackCnt)
{
- KwSn sn;
- KwNackInfo nackSnInfo;
- KwSn mNackSn;
- KwSn txNextAck;
- KwSn transWinStartSn = AMDL.txNextAck; /*used to track the SN from which
+ RlcSn sn;
+ RlcNackInfo nackSnInfo;
+ RlcSn mNackSn;
+ RlcSn txNextAck;
+ RlcSn transWinStartSn = AMDL.txNextAck; /*used to track the SN from which
to start processing the transmission
buffer */
U32 idx = 0;
/* if any NACKs then txNextAck should be equal to the first NACK_SN*/
txNextAck = pStaPdu->nackInfo[0].sn;
- kwStatusNcnt += pStaPdu->nackCnt;
+ rlcStatusNcnt += pStaPdu->nackCnt;
/* For NACKs */
while (idx < pStaPdu->nackCnt)
nackSnInfo.sn = pStaPdu->nackInfo[idx].sn;
RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId,
- "kwHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d",
+ "rlcHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d",
nackSnInfo.sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
"Status Pdu is not correct UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
RETVOID;
}
/* clear all the SNs < NACK_SN from re-transmission list */
- kwAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn,
+ rlcAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn,
&retxNode, &datCfm);
if(!nackSnInfo.nackRange)
{
- kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, &retxNode, &datCfm);
+ rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, &retxNode, &datCfm);
gRlcStats.amRlcStats.numRlcAmCellNackRx++;
}
else
RlcDlAmmGetNackSnInfoFrmNackRangeIdx(&AMDL, &pStaPdu->nackInfo[idx],
retxNode, &nackSnInfo, idx1);
- kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo,
+ rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo,
&retxNode, &datCfm);
nackSnInfo.sn = ((nackSnInfo.sn + 1) & (AMDL.snModMask));
gRlcStats.amRlcStats.numRlcAmCellNackRx++;
/* Remove the PDUs with are further acked by the ACK_SN after taking
care of all the NACK_SN related acknowledgments*/
- kwAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm);
+ rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm);
/* Update txNextAck */
- kwAmmDlSetTxNextAck(&AMDL,txNextAck);
+ rlcAmmDlSetTxNextAck(&AMDL,txNextAck);
}
else
{
- kwStatusAckCnt++;
+ rlcStatusAckCnt++;
/* For All ACKs */
RLOG_ARG2(L_UNUSED,DBG_RBID, rbCb->rlcId.rbId,
- "kwHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
+ "rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
/* For the remaining ACKs after last nackSn */
- kwAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm);
+ rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm);
/* update txNextAck */
- kwAmmDlSetTxNextAck(&AMDL, pStaPdu->ackSn);
+ rlcAmmDlSetTxNextAck(&AMDL, pStaPdu->ackSn);
}
if(datCfm->numSduIds != 0)
rbCb->rlcId.cellId);
datCfm->numSduIds = 1024;
}
- kwSduSndCnt += datCfm->numSduIds;
+ rlcSduSndCnt += datCfm->numSduIds;
/* Sap control block */
- KwUiKwuDatCfm(&kwuSap->pst, kwuSap->suId, datCfm);
+ RlcUiKwuDatCfm(&rlckwuSap->pst, rlckwuSap->suId, datCfm);
}
else
{
- RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
}
/* Fix for memory corruption */
- KW_LLIST_FIRST_RETX(AMDL.retxLst, AMDL.nxtRetx);
+ RLC_LLIST_FIRST_RETX(AMDL.retxLst, AMDL.nxtRetx);
/* BO update, if retransmission BO has changed. AMDL.retxBo would have
canged inside the above called functions */
if (oldRetxBo != AMDL.retxBo)
{
- kwAmmSendDStaRsp(gCb, rbCb, &AMDL);
+ rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
}
RETVOID;
* Calculated bo
*/
#ifdef ANSI
-PUBLIC S32 kwAmmCalculateBo
+S32 rlcAmmCalculateBo
(
-KwAmDl *amDl
+RlcAmDl *amDl
)
#else
-PUBLIC S32 kwAmmCalculateBo(amDl)
-KwAmDl *amDl;
+S32 rlcAmmCalculateBo(amDl)
+RlcAmDl *amDl;
#endif
{
S32 bo;
bo = amDl->cntrlBo + amDl->retxBo;
/* if window is not stalled then add the transmit bo also */
- if (! KW_AM_IS_TRANS_WIN_STALLED(amDl))
+ if (! RLC_AM_IS_TRANS_WIN_STALLED(amDl))
{
bo += amDl->bo;
}
* SDU queue of the corresponding RbCb. It also updates the BO and report the
* same to MAC.
* - Allocate memory for and assign received buffer to the SDU
- * - Add SDU in the sduQ of KwAmDl
+ * - Add SDU in the sduQ of RlcAmDl
* - Calculate bo with the buffer received
* - Accumulate bo with retransmission bo and control pdu's bo if available
* - Estimate the header size for the bo; Fill in StaRspInfo and send it
* -# RETVOID
*/
#ifdef ANSI
-PUBLIC Void kwAmmQSdu
+Void rlcAmmQSdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatReqInfo *datReq
)
#else
-PUBLIC Void kwAmmQSdu(gCb, rbCb, mBuf, datReq)
+Void rlcAmmQSdu(gCb, rbCb, mBuf, datReq)
RlcCb *gCb;
RlcDlRbCb *rbCb;
Buffer *mBuf;
KwuDatReqInfo *datReq;
#endif
{
- KwSdu *sdu;
+ RlcSdu *sdu;
#ifdef LTE_L2_MEAS
#ifndef L2_L3_SPLIT
#ifdef TENB_STATS
- U32 kwWinSz;
+ U32 rlcWinSz;
#endif
#endif
#endif
- TRC2(kwAmmQSdu)
+ TRC2(rlcAmmQSdu)
/* Allocate sdu */
- RLC_ALLOC_WC(gCb,sdu, sizeof(KwSdu));
+ RLC_ALLOC_WC(gCb,sdu, sizeof(RlcSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (sdu == NULLP)
}
#endif /* ERRCLASS & ERRCLS_RES */
- KW_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb);
+ RLC_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb);
/* Discard new changes starts */
- kwUtlGetCurrTime(&sdu->arrTime);
+ rlcUtlGetCurrTime(&sdu->arrTime);
/* Discard new changes ends */
/* Assign values to sdu */
SFndLenMsg(mBuf, &sdu->sduSz);
if (AMDL.nxtTx == NULLP)
{
RLOG_ARG2(L_UNUSED,DBG_RBID, rbCb->rlcId.rbId,
- "kwAmmQSdu: Received SDU will be transmitted next"
+ "rlcAmmQSdu: Received SDU will be transmitted next"
"UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
{
rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxPktsInSduQ = AMDL.sduQ.count;
}
- kwWinSz = KW_AM_TRANS_WIN_SIZE(&AMDL);
- if (kwWinSz > rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz)
+ rlcWinSz = RLC_AM_TRANS_WIN_SIZE(&AMDL);
+ if (rlcWinSz > rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz)
{
- rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz = kwWinSz;
+ rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz = rlcWinSz;
}
}
#endif
#endif
/* Update BO and estimate header size for the current BO */
AMDL.bo = AMDL.bo + sdu->sduSz;
- if(AMDL.snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if(AMDL.snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
AMDL.estHdrSz += 2;
}
(rbCb->ueCb->numActRb[rbCb->qci] == 0))
{
rbCb->ueCb->numActRb[rbCb->qci]++;
- gCb.kwL2Cb.numActUe[rbCb->qci]++;
+ gCb.rlcL2Cb.numActUe[rbCb->qci]++;
}
#endif
if(!rlcDlUtlIsReestInProgress(rbCb))
{
- kwAmmSendDStaRsp(gCb, rbCb, &AMDL);
+ rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
}
RETVOID;
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlAssembleCntrlInfo
+PRIVATE Void rlcAmmDlAssembleCntrlInfo
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwDatReq *kwDatReq
+RlcDatReq *rlcDatReq
)
#else
-PRIVATE Void kwAmmDlAssembleCntrlInfo(gCb, rbCb, kwDatReq)
+PRIVATE Void rlcAmmDlAssembleCntrlInfo(gCb, rbCb, rlcDatReq)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwDatReq *kwDatReq;
+RlcDatReq *rlcDatReq;
#endif
{
- KwUdxDlSapCb *sapCb;
+ RlcUdxDlSapCb *sapCb;
MsgLen macHdrEstmt;
- TRC2(kwAmmDlAssembleCntrlInfo)
+ TRC2(rlcAmmDlAssembleCntrlInfo)
macHdrEstmt = (rbCb->m.amDl.cntrlBo < 256) ?
- KW_MAC_HDR_SZ2 : KW_MAC_HDR_SZ3;
+ RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3;
/* Eliminate fixed hdr size (14bits including ACK_SN) */
- if (kwDatReq->pduSz >= (KW_CNTRL_PDU_FIXED_HDRSZ + macHdrEstmt))
+ if (rlcDatReq->pduSz >= (RLC_CNTRL_PDU_FIXED_HDRSZ + macHdrEstmt))
{
/* Check the TB size whether it is sufficcient enough to fit the
status Pdu into it otherwise make arrangement such that it can fit
into in a way of possible NACks*/
/* ccpu00135743 : fix for MAC Hdr size calc */
- kwDatReq->pduSz -= macHdrEstmt;
+ rlcDatReq->pduSz -= macHdrEstmt;
/* Create the status Pdu with the required NACKs */
- kwAmmCreateStatusPdu(gCb,rbCb,kwDatReq);
+ rlcAmmCreateStatusPdu(gCb,rbCb,rlcDatReq);
- sapCb = KW_GET_DL_SAPCB(gCb, rbCb);
+ sapCb = RLC_GET_DL_SAPCB(gCb, rbCb);
rlcDlUdxStaProhTmrStart(&(gCb->u.dlCb->udxDlSap->pst),
sapCb->suId, &(rbCb->rlcId));
/* Update number of pdus in pduInfo */
- kwDatReq->pduInfo.mBuf[kwDatReq->pduInfo.numPdu] = AMDL.mBuf;
- kwDatReq->pduInfo.numPdu++;
+ rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = AMDL.mBuf;
+ rlcDatReq->pduInfo.numPdu++;
gRlcStats.amRlcStats.numDLStaPduSent++;
RLC_FREE_SHRABL_BUF(gCb->u.dlCb->udxDlSap->pst.region,
gCb->u.dlCb->udxDlSap->pst.pool,
AMDL.pStaPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
AMDL.pStaPdu = NULLP;
AMDL.mBuf = NULLP;
* set for the data PDU and returns PDU(s) and updated BO with
* estimated header size to be sent to MAC.
*
- * - Check if the control BO is available and call kwAssembleCntrlInfo
+ * - Check if the control BO is available and call rlcAssembleCntrlInfo
* to assemble control Information
* - Check if the pdu size is available to form PDUs from retransmission
- * buffer and call kwResegRetxPdus
+ * buffer and call rlcResegRetxPdus
* - Check if the pdu size is available and assemble SDUs from sduQ
- * if exist, using kwAssembleSdus
+ * if exist, using rlcAssembleSdus
* - PDU Info and bo are filled in and then sent to MAC from the
* utility function
*
*
*/
#ifdef ANSI
-PUBLIC Void kwAmmProcessSdus
+Void rlcAmmProcessSdus
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwDatReq *kwDatReq,
+RlcDatReq *rlcDatReq,
Bool fillCtrlPdu
)
#else
-PUBLIC Void kwAmmProcessSdus(gCb, rbCb, kwDatReq,fillCtrlPdu)
+Void rlcAmmProcessSdus(gCb, rbCb, rlcDatReq,fillCtrlPdu)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwDatReq *kwDatReq;
+RlcDatReq *rlcDatReq;
Bool fillCtrlPdu;
#endif
{
- TRC2(kwAmmProcessSdus)
+ TRC2(rlcAmmProcessSdus)
/* Assemble control information. fillCtrlPdu parameter check is added for CA
#endif
)
{
- kwDatReq->boRep.staPduPrsnt = TRUE;
- kwDatReq->boRep.staPduBo = AMDL.cntrlBo;
+ rlcDatReq->boRep.staPduPrsnt = TRUE;
+ rlcDatReq->boRep.staPduBo = AMDL.cntrlBo;
if (AMDL.pStaPdu != NULLP)
{
- kwAmmDlAssembleCntrlInfo (gCb, rbCb, kwDatReq);
+ rlcAmmDlAssembleCntrlInfo (gCb, rbCb, rlcDatReq);
}
else
{
}
/* Retransmit PDUs /portions of PDUs available in retxLst */
- if ((kwDatReq->pduSz > 0) && (AMDL.nxtRetx != NULLP))
+ if ((rlcDatReq->pduSz > 0) && (AMDL.nxtRetx != NULLP))
{
- kwResegRetxPdus (gCb,rbCb, kwDatReq);
+ rlcResegRetxPdus (gCb,rbCb, rlcDatReq);
}
/* Assemble SDUs to form new PDUs */
- if ((kwDatReq->pduSz > 0) && (AMDL.nxtTx != 0))
+ if ((rlcDatReq->pduSz > 0) && (AMDL.nxtTx != 0))
{
- kwAssembleSdus(gCb,rbCb, kwDatReq);
+ rlcAssembleSdus(gCb,rbCb, rlcDatReq);
}
if (AMDL.nxtRetx != NULLP)
{
- kwDatReq->boRep.oldestSduArrTime = AMDL.nxtRetx->sduMap.sdu->arrTime;
+ rlcDatReq->boRep.oldestSduArrTime = AMDL.nxtRetx->sduMap.sdu->arrTime;
}
else if (AMDL.nxtTx != NULLP)
{
- kwDatReq->boRep.oldestSduArrTime = AMDL.nxtTx->arrTime;
+ rlcDatReq->boRep.oldestSduArrTime = AMDL.nxtTx->arrTime;
}
/* Accumulate bo */
- kwDatReq->boRep.bo = kwAmmCalculateBo(&AMDL);
- kwDatReq->boRep.staPduBo = AMDL.cntrlBo;
+ rlcDatReq->boRep.bo = rlcAmmCalculateBo(&AMDL);
+ rlcDatReq->boRep.staPduBo = AMDL.cntrlBo;
/* Hdr estimation is moved to kwAmmCreatePDu */
- kwDatReq->boRep.estHdrSz = AMDL.estHdrSz;
+ rlcDatReq->boRep.estHdrSz = AMDL.estHdrSz;
- if(kwDatReq->pduSz > 0)
+ if(rlcDatReq->pduSz > 0)
{
- gRlcStats.amRlcStats.numDLBytesUnused += kwDatReq->pduSz;
+ gRlcStats.amRlcStats.numDLBytesUnused += rlcDatReq->pduSz;
}
RETVOID;
}
*
*/
#ifdef ANSI
-PRIVATE Void kwSplitPdu
+PRIVATE Void rlcSplitPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwRetx *crnt,
-KwRetx *next,
+RlcRetx *crnt,
+RlcRetx *next,
U16 size
)
#else
-PRIVATE Void kwSplitPdu(gCb, rbCb, crnt, next, size)
+PRIVATE Void rlcSplitPdu(gCb, rbCb, crnt, next, size)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwRetx *crnt;
-KwRetx *next;
+RlcRetx *crnt;
+RlcRetx *next;
U16 size;
#endif
{
U8 si;
- KwAmDl *amDl = &AMDL;
+ RlcAmDl *amDl = &AMDL;
- TRC2(kwSplitPdu)
+ TRC2(rlcSplitPdu)
/* Set the SN for the new segment */
next->amHdr.sn = crnt->amHdr.sn;
/* Set the protocol specific fields appropriately */
si = crnt->amHdr.si;
- crnt->amHdr.si = si | KW_SI_FIRST_SEG;
- next->amHdr.si = si | KW_SI_LAST_SEG;
+ crnt->amHdr.si = si | RLC_SI_FIRST_SEG;
+ next->amHdr.si = si | RLC_SI_LAST_SEG;
crnt->amHdr.p = 0;
next->pendingReTrans = crnt->pendingReTrans;
/* Compute the header size and update the BO appropriately */
- if(amDl->snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if(amDl->snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
- next->hdrSz = KW_AM_SEG_12BIT_SN_WITH_SO_HDRSZ;
- if(crnt->amHdr.si == KW_SI_FIRST_SEG)
+ next->hdrSz = RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ;
+ if(crnt->amHdr.si == RLC_SI_FIRST_SEG)
{
- crnt->hdrSz = KW_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ;
+ crnt->hdrSz = RLC_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ;
}
else
{
- crnt->hdrSz = KW_AM_SEG_12BIT_SN_WITH_SO_HDRSZ;
+ crnt->hdrSz = RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ;
}
}
else
{
- next->hdrSz = KW_AM_SEG_18BIT_SN_WITH_SO_HDRSZ;
- if(crnt->amHdr.si == KW_SI_FIRST_SEG)
+ next->hdrSz = RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ;
+ if(crnt->amHdr.si == RLC_SI_FIRST_SEG)
{
- crnt->hdrSz = KW_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ;
+ crnt->hdrSz = RLC_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ;
}
else
{
- crnt->hdrSz = KW_AM_SEG_18BIT_SN_WITH_SO_HDRSZ;
+ crnt->hdrSz = RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ;
}
}
* - While pdusize is available and retxBuf has data (pdu or portion
* of pdu) to be sent, form the pdu as it is if it matches with the
* pdusize else segment the PDUs/portion of PDUs
- * - Call kwAmmDlCheckAndSetPoll function to check and set the poll bit as
+ * - Call rlcAmmDlCheckAndSetPoll function to check and set the poll bit as
* required
* - Concatenate data and header info and fill pduInfo
* - Update retxCnt and send indication to PDCP if it reaches maxRetx
*
*/
#ifdef ANSI
-PRIVATE Void kwResegRetxPdus
+PRIVATE Void rlcResegRetxPdus
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwDatReq *kwDatReq
+RlcDatReq *rlcDatReq
)
#else
-PRIVATE Void kwResegRetxPdus(gCb, rbCb, kwDatReq)
+PRIVATE Void rlcResegRetxPdus(gCb, rbCb, rlcDatReq)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwDatReq *kwDatReq;
+RlcDatReq *rlcDatReq;
#endif
{
- KwAmDl *amDl;
- KwRetx *retx;
- U8 hdr[KW_MAX_HDRSZ];
+ RlcAmDl *amDl;
+ RlcRetx *retx;
+ U8 hdr[RLC_MAX_HDRSZ];
U16 idx;
Buffer *pdu;
MsgLen pduSz;
#ifdef LTE_L2_MEAS
U16 sduIdx;
- KwL2MeasTb *l2MeasTb;
- KwlchInfo *lchInfo;
+ RlcL2MeasTb *l2MeasTb;
+ RlclchInfo *lchInfo;
U8 numSdus;
#endif
- TRC2(kwResegRetxPdus)
+ TRC2(rlcResegRetxPdus)
amDl = &AMDL;
#ifdef LTE_L2_MEAS
/* TODO : This shoould be taken care in new Trasmissions */
/* This lchInfo should be retrieved there */
- l2MeasTb = kwUtlGetCurMeasTb(gCb, rbCb);
+ l2MeasTb = rlcUtlGetCurMeasTb(gCb, rbCb);
if (l2MeasTb == NULLP)
{
RETVOID;
/* TODO : This lcid needs to be searched in case of normal Tx */
/* In retx here, its fine as this will be higher priority */
lchInfo = &l2MeasTb->lchInfo[l2MeasTb->numLchInfo];
- if (l2MeasTb->numLchInfo >= KW_MAX_ACTV_DRB)
+ if (l2MeasTb->numLchInfo >= RLC_MAX_ACTV_DRB)
{
RETVOID;
}
lchInfo->numSdus = 0;
#endif
- while ((kwDatReq->pduSz > 0) && (amDl->nxtRetx != NULLP)&&
- (kwDatReq->pduInfo.numPdu < KW_MAX_PDU))
+ while ((rlcDatReq->pduSz > 0) && (amDl->nxtRetx != NULLP)&&
+ (rlcDatReq->pduInfo.numPdu < RLC_MAX_PDU))
{
U16 tmpSz;
/* kw003.201 : Add header size to seg size to determine if the */
/* the segment can be completed within the allocation */
/* kw003.201 - Eliminate MAC Header Size based on bites needed */
- tmpSz = KW_MIN((retx->segSz + retx->hdrSz), kwDatReq->pduSz);
+ tmpSz = RLC_MIN((retx->segSz + retx->hdrSz), rlcDatReq->pduSz);
pduSz = (retx->segSz + retx->hdrSz);
/* 5GNR_RLC: length field in 5GNR MAC Hdr is 8/16 btis*/
- kwDatReq->pduSz -= (tmpSz < 255) ? KW_MAC_HDR_SZ2 : KW_MAC_HDR_SZ3;
+ rlcDatReq->pduSz -= (tmpSz < 255) ? RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3;
/* kw003.201 - We should have at least one more than basic header */
- if (kwDatReq->pduSz <= retx->hdrSz)
+ if (rlcDatReq->pduSz <= retx->hdrSz)
{
RETVOID;
}
- kwGetNxtRetx(gCb, &(amDl->nxtRetx));
+ rlcGetNxtRetx(gCb, &(amDl->nxtRetx));
/* Send retx buf without segmentation */
- if (kwDatReq->pduSz >= pduSz)
+ if (rlcDatReq->pduSz >= pduSz)
{
U8 pollBit;
RLOG_ARG2(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwResegRetxPdus: Send retx buf without segmentation "
+ "rlcResegRetxPdus: Send retx buf without segmentation "
"UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
if (retx->yetToConst)
{
/* Construct hdr with the available hdr values */
- kwConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx);
+ rlcConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx);
/* Add header to the pdu/segment */
SAddPreMsgMultInOrder(hdr, idx + 1, retx->seg);
retx->yetToConst = FALSE;
/* kw003.201 - Check if poll bit needs to be set. Retx size does */
/* not affect the poll bit so it is being passed as zero */
- pollBit = kwAmmDlCheckAndSetPoll(gCb,rbCb, FALSE, 0);
- KW_UPD_POLL_BIT(gCb, retx, pollBit);
+ pollBit = rlcAmmDlCheckAndSetPoll(gCb,rbCb, FALSE, 0);
+ RLC_UPD_POLL_BIT(gCb, retx, pollBit);
- kwDatReq->pduSz -= pduSz;
+ rlcDatReq->pduSz -= pduSz;
AMDL.estHdrSz -= retx->hdrSz;
#ifdef LTE_L2_MEAS
{
numSdus = 0;
for (sduIdx = lchInfo->numSdus ;
- ((numSdus < retx->numSdu) && (sduIdx < KW_L2MEAS_SDUIDX)) ;
+ ((numSdus < retx->numSdu) && (sduIdx < RLC_L2MEAS_SDUIDX)) ;
sduIdx++, numSdus++)
{
lchInfo->sduInfo[sduIdx].arvlTime = retx->sduMap[numSdus].sdu->arrTime;
}
else
{
- KwRetx *tNode;
+ RlcRetx *tNode;
/* Segment this pdu / portion of pdu. Insert this segment into */
/* retxLst and update offset */
RLOG_ARG2(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwResegRetxPdus: Segment retx buf UEID:%d CELLID:%d",
+ "rlcResegRetxPdus: Segment retx buf UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
/* Eliminate fixed header size if the pdu is segmented for the */
/* first time */
- if(amDl->snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if(amDl->snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
- if(retx->amHdr.si < KW_SI_LAST_SEG)
+ if(retx->amHdr.si < RLC_SI_LAST_SEG)
{
- kwDatReq->pduSz -= KW_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ;
+ rlcDatReq->pduSz -= RLC_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ;
}
else
{
- kwDatReq->pduSz -= KW_AM_SEG_12BIT_SN_WITH_SO_HDRSZ;
+ rlcDatReq->pduSz -= RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ;
}
}
else
{
- if(retx->amHdr.si < KW_SI_LAST_SEG)
+ if(retx->amHdr.si < RLC_SI_LAST_SEG)
{
- kwDatReq->pduSz -= KW_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ;
+ rlcDatReq->pduSz -= RLC_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ;
}
else
{
- kwDatReq->pduSz -= KW_AM_SEG_18BIT_SN_WITH_SO_HDRSZ;
+ rlcDatReq->pduSz -= RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ;
}
}
- if (kwDatReq->pduSz <= 0)
+ if (rlcDatReq->pduSz <= 0)
{
RETVOID;
}
/* Allocate memory for tracking a new segment */
- RLC_ALLOC_WC(gCb,tNode, sizeof(KwRetx));
+ RLC_ALLOC_WC(gCb,tNode, sizeof(RlcRetx));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tNode == NULLP)
{
tNode->lstEnt.prev = 0;
/* Segment header and data */
- KW_AM_RMV_HDR(gCb, rbCb, retx);
+ RLC_AM_RMV_HDR(gCb, rbCb, retx);
/* kw003.201 - Split the payload and update other fields */
- kwSplitPdu(gCb,rbCb, retx, tNode, kwDatReq->pduSz);
+ rlcSplitPdu(gCb,rbCb, retx, tNode, rlcDatReq->pduSz);
#ifdef LTE_L2_MEAS
numSdus = 0;
/* ccpu00143043 */
sduIdx = lchInfo->numSdus;
for (numSdus = 0, sduIdx = lchInfo->numSdus;
- ((numSdus < retx->numSdu) && (sduIdx < KW_L2MEAS_SDUIDX));
+ ((numSdus < retx->numSdu) && (sduIdx < RLC_L2MEAS_SDUIDX));
numSdus++, sduIdx++)
{
lchInfo->sduInfo[sduIdx].arvlTime =
}
#endif
/* Construct hdr with the available hdr values */
- kwConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx);
+ rlcConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx);
SAddPreMsgMultInOrder(hdr, idx + 1, retx->seg);
retx->hdrSz = idx + 1;
/* Poll bit need not be set for this seg, since its second */
/* half remains in retxLst */
- KW_UPD_POLL_BIT(gCb, retx, FALSE);
+ RLC_UPD_POLL_BIT(gCb, retx, FALSE);
retx->yetToConst = FALSE;
- kwDatReq->pduSz = 0;
+ rlcDatReq->pduSz = 0;
}
- kwCpyMsg(gCb,retx->seg, &pdu);
+ rlcCpyMsg(gCb,retx->seg, &pdu);
/* Update pduInfo */
- kwDatReq->pduInfo.mBuf[kwDatReq->pduInfo.numPdu] = pdu;
- kwDatReq->pduInfo.numPdu++;
+ rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = pdu;
+ rlcDatReq->pduInfo.numPdu++;
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.pdusRetx += 1;
gRlcStats.amRlcStats.numRlcAmCellRetxPdu++;
}
#ifndef ALIGN_64BIT
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwResegRetxPdus: retxBo after resegmentation = %ld"
+ "rlcResegRetxPdus: retxBo after resegmentation = %ld"
"UEID:%d CELLID:%d",
amDl->retxBo,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#else
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwResegRetxPdus: retxBo after resegmentation = %d "
+ "rlcResegRetxPdus: retxBo after resegmentation = %d "
"UEID:%d CELLID:%d",
amDl->retxBo,
rbCb->rlcId.ueId,
* - While pdusize is available, segment/concatenate SDUs or else if it
* matches the pdu size form PDUs accordingly.
* - RLC header and MAC header size are eliminated while forming the PDUs
- * - Call kwAmmDlCheckAndSetPoll function to check and set the poll bit
+ * - Call rlcAmmDlCheckAndSetPoll function to check and set the poll bit
* as required
* - Concatenate data and header info and fill pduInfo
*
*
*/
#ifdef ANSI
-PRIVATE Void kwAssembleSdus
+PRIVATE Void rlcAssembleSdus
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwDatReq *kwDatReq
+RlcDatReq *rlcDatReq
)
#else
-PRIVATE Void kwAssembleSdus (gCb, rbCb, kwDatReq)
+PRIVATE Void rlcAssembleSdus (gCb, rbCb, rlcDatReq)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwDatReq *kwDatReq;
+RlcDatReq *rlcDatReq;
#endif
{
Buffer *pdu = NULLP;
- MsgLen macGrntSz = kwDatReq->pduSz;
- KwAmDl *amDl = &AMDL;
- KwSdu *sdu = amDl->nxtTx;
- KwSduMap sduMap;
+ MsgLen macGrntSz = rlcDatReq->pduSz;
+ RlcAmDl *amDl = &AMDL;
+ RlcSdu *sdu = amDl->nxtTx;
+ RlcSduMap sduMap;
Bool nxtTxUpd = FALSE;
KwuDiscSduInfo *discSduInfo = NULLP;
- KwKwuSapCb* kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
+ RlcKwuSapCb* rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
#ifdef LTE_L2_MEAS
- KwContSduLst contSduLst; /*Contained sduLst */
+ RlcContSduLst contSduLst; /*Contained sduLst */
S32 dataVol = amDl->bo;
- U32 *totMacGrant = &kwDatReq->totMacGrant;
- KwL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh;
+ U32 *totMacGrant = &rlcDatReq->totMacGrant;
+ RlcL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh;
U8 *sduIdx = &dlIpThPut->lastSduIdx;
Bool newIdx;
Bool isSduSegmented;
S32 oldBo;
- KwlchInfo lchInfo;
- KwlchInfo *dstLchInfo;
+ RlclchInfo lchInfo;
+ RlclchInfo *dstLchInfo;
U32 segSduCnt = 0;
U32 lchIdx;
U32 numSdus = 0;
U32 currSduIdx = 0;
- KwL2MeasTb *l2MeasTb;
+ RlcL2MeasTb *l2MeasTb;
#endif
/* Discard new changes starts */
Ticks timeDiff = 0;
Ticks curTime = 0;
U8 numNewPdu = 0;
- KwTx *txBuf = NULLP;
+ RlcTx *txBuf = NULLP;
/* Discard new changes ends */
VOLATILE U32 startTime = 0;
U32 hdrEstmt;
U32 fixedHdrSz;
U32 pduSz;
- KwAmHdr *amHdr = NULLP;
+ RlcAmHdr *amHdr = NULLP;
RlcDlPduInfo *pduInfo = NULLP;
- TRC2(kwAssembleSdus)
+ TRC2(rlcAssembleSdus)
#ifdef LTE_L2_MEAS
#endif
/* Discard new changes starts */
/* Allocate memory for discSdu Info */
- RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
- kwuSap->pst.pool,
+ RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region,
+ rlckwuSap->pst.pool,
discSduInfo,
sizeof(KwuDiscSduInfo));
discSduInfo->numSduIds = 0;
discSduInfo->rlcId = rbCb->rlcId;
- kwUtlGetCurrTime(&curTime);
+ rlcUtlGetCurrTime(&curTime);
amDl->sduQ.crnt = &sdu->lstEnt;
/* Eliminate fixed header size */
- /*5GNR: value of KW_AM_PDU_FIXED_HDRSZ will be 2 or 3 depending on SN Size*/
- if(amDl->snLen == KW_AM_CFG_12BIT_SN_LEN)
+ /*5GNR: value of RLC_AM_PDU_FIXED_HDRSZ will be 2 or 3 depending on SN Size*/
+ if(amDl->snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
- fixedHdrSz = KW_AM_PDU_12BIT_SN_HDRSZ;
+ fixedHdrSz = RLC_AM_PDU_12BIT_SN_HDRSZ;
}
else
{
- fixedHdrSz = KW_AM_PDU_18BIT_SN_HDRSZ;
+ fixedHdrSz = RLC_AM_PDU_18BIT_SN_HDRSZ;
}
while ((macGrntSz > fixedHdrSz) && (sdu != NULLP) &&
- (kwDatReq->pduInfo.numPdu < KW_MAX_PDU) &&
- (numNewPdu < KW_MAX_NEW_DL_PDU))
+ (rlcDatReq->pduInfo.numPdu < RLC_MAX_PDU) &&
+ (numNewPdu < RLC_MAX_NEW_DL_PDU))
{
#ifdef LTE_L2_MEAS
isSduSegmented = sdu->mode.am.isSegmented;
(rbCb->rlcId.rbType == CM_LTE_DRB))
{
//leftAmSdus[rbCb->qci]--;
- timeDiff = KW_TIME_DIFF(curTime,sdu->arrTime);
+ timeDiff = RLC_TIME_DIFF(curTime,sdu->arrTime);
if (timeDiff > rbCb->discTmrInt)
{
CmLList* nxtNode;
/*starting Task*/
SStartTask(&startTime, PID_RLC_AMM_DISC_SDUS);
#ifdef LTE_L2_MEAS
- KW_UPD_L2_DL_DISC_SDU_STS(gCb,rbCb);
+ RLC_UPD_L2_DL_DISC_SDU_STS(gCb,rbCb);
/* TODO need to send disc cfm to pdcp */
#endif
/* Update bo for boReport */
cmLListDelFrm(&amDl->sduQ, &sdu->lstEnt);
- kwUtlAddSduToBeFreedQueue(gCb, sdu);
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlAddSduToBeFreedQueue(gCb, sdu);
+ rlcUtlRaiseDlCleanupEvent(gCb);
/* We need to restore the crnt in the linked list which
* would have become NULL in the DelFrm above */
amDl->sduQ.crnt = nxtNode;
if(nxtNode)
- sdu = (KwSdu*)nxtNode->node;
+ sdu = (RlcSdu*)nxtNode->node;
else
sdu = NULLP;
/** kw003.201 - Check for window stall when you are
* creating a new PDU
*/
- if (KW_AM_IS_TRANS_WIN_STALLED(amDl))
+ if (RLC_AM_IS_TRANS_WIN_STALLED(amDl))
{
//int *a = NULLP;
printf("\n Window stalled \n");
/* Eliminate MAC header */
/* ccpu00135743 : Fix for MAC Hdr size calculation */
/*5GNR: value of mac hdr length field changed to 8/16bits */
- pduSz = KW_MIN(macGrntSz, (sdu->sduSz + hdrEstmt));
- hdrEstmt += (pduSz < 255) ? KW_MAC_HDR_SZ2 : KW_MAC_HDR_SZ3;
+ pduSz = RLC_MIN(macGrntSz, (sdu->sduSz + hdrEstmt));
+ hdrEstmt += (pduSz < 255) ? RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3;
macGrntSz -= hdrEstmt;
/* kw005.201 Check for PDU Size is large enough.
if (!sdu->mode.am.isSegmented)
{
/* Update txBuf */
- RLC_ALLOC_WC(gCb,txBuf, sizeof(KwTx));
+ RLC_ALLOC_WC(gCb,txBuf, sizeof(RlcTx));
cmLListInit(&txBuf->pduLst);
}
#endif /* ERRCLASS & ERRCLS_RES */
- kwUtlStoreTxBuf(amDl->txBufLst, txBuf, amDl->txNext);
+ rlcUtlStoreTxBuf(amDl->txBufLst, txBuf, amDl->txNext);
}
else
{
- txBuf = kwUtlGetTxBuf(amDl->txBufLst, amDl->txNext);
+ txBuf = rlcUtlGetTxBuf(amDl->txBufLst, amDl->txNext);
}
RLC_ALLOC_WC(gCb,pduInfo, sizeof(RlcDlPduInfo));
{
/*5GNR RLC: SN should be same for all segment of a SDU*/
pduInfo->amHdr.sn = sdu->mode.am.sn;
- pduInfo->amHdr.si = KW_SI_LAST_SEG; /* binary 10 */
+ pduInfo->amHdr.si = RLC_SI_LAST_SEG; /* binary 10 */
pduInfo->amHdr.so = sdu->actSz - sdu->sduSz;
sdu->mode.am.isSegmented = FALSE;
}
amHdr = &pduInfo->amHdr;
/* Create PDU with hdr and data */
- kwAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu);
+ rlcAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu);
- //printf("\n Segmentation not required case: numPdu %d pdu %p \n",kwDatReq->pduInfo.numPdu, pdu);
+ //printf("\n Segmentation not required case: numPdu %d pdu %p \n",rlcDatReq->pduInfo.numPdu, pdu);
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, kwDatReq, TRUE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, rlcDatReq, TRUE);
#endif /* LTE_L2_MEAS */
/* kw005.201 ccpu00117318, updating the statistics */
- kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId);
+ rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId);
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb))
{
if(isSduSegmented)
{
}
else
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.am.sduId, newIdx);
/* Update the arrival time for each SDU */
/* ccpu00143043 */
- if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX)
+ if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX)
{
lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime;
lchInfo.numSdus++;
Buffer *remSeg = NULLP;
- //printf("\n SDU segmentation case: numPdu %d pdu %p \n", kwDatReq->pduInfo.numPdu, pdu);
+ //printf("\n SDU segmentation case: numPdu %d pdu %p \n", rlcDatReq->pduInfo.numPdu, pdu);
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rbCb) ||
- KW_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(gCb,rbCb) ||
- KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb) )
+ if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rbCb) ||
+ RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(gCb,rbCb) ||
+ RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb) )
{
/* If actual size of the sdu is equal to msgLen
* then it is first segment of the SDU */
if(sdu->actSz == sdu->sduSz)
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
else
{
*sduIdx = dlIpThPut->lastSduIdx;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.am.sduId, newIdx);
- if(KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb))
{
/* If actual size of the sdu is equal to msgLen
* then it is first segment of the SDU */
/*5GNR RLC: SN should be same for all segment of a SDU.
* Sdu was already segmented and segmenting again*/
pduInfo->amHdr.sn = sdu->mode.am.sn;
- pduInfo->amHdr.si = KW_SI_MID_SEG; /* binary 11 */
+ pduInfo->amHdr.si = RLC_SI_MID_SEG; /* binary 11 */
pduInfo->amHdr.so = sdu->actSz - sdu->sduSz;
//printf("\n 5GNRLOG: mid segment of lcId %d SduId %u So %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
else
{
/*5GNR RLC: This means it is the first*/
- pduInfo->amHdr.si = KW_SI_FIRST_SEG; /* binary 01 */
+ pduInfo->amHdr.si = RLC_SI_FIRST_SEG; /* binary 01 */
/*5GNR_RLC: Store SN so that in sub-seqent SDU segments will use this SN*/
sdu->mode.am.sn = pduInfo->amHdr.sn;
pduInfo->amHdr.so = 0;
amHdr = &pduInfo->amHdr;
/* Create PDU with hdr and data */
- kwAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu);
+ rlcAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu);
sdu->mode.am.isSegmented = TRUE;
sdu->sduSz -= macGrntSz;
sduMap.sduSz = macGrntSz;
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, kwDatReq, FALSE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, rlcDatReq, FALSE);
#endif /* LTE_L2_MEAS */
amDl->nxtTx = sdu;
sduMap.sdu = sdu;
/* Update pduInfo */
- kwDatReq->pduInfo.mBuf[kwDatReq->pduInfo.numPdu] = pdu;
- kwDatReq->pduInfo.numPdu++;
+ rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = pdu;
+ rlcDatReq->pduInfo.numPdu++;
numNewPdu++;
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.pdusSent++;
gRlcStats.amRlcStats.numRlcAmCellSduBytesTx = gRlcStats.amRlcStats.numRlcAmCellSduBytesTx + sduMap.sduSz;
/* Update the RLC Tx buffer with the new PDU info */
- KW_MEM_CPY(&pduInfo->sduMap, &sduMap, sizeof(KwSduMap));
+ RLC_MEM_CPY(&pduInfo->sduMap, &sduMap, sizeof(RlcSduMap));
pdu = NULLP;
macGrntSz -= sduMap.sduSz;
/* Get next sdu for assembly */
- KW_LLIST_NEXT_SDU(amDl->sduQ, sdu);
+ RLC_LLIST_NEXT_SDU(amDl->sduQ, sdu);
} /*End of pduSz loop */
- kwDatReq->pduSz = macGrntSz;
+ rlcDatReq->pduSz = macGrntSz;
/* Updating nxtTx to sdu in the Q */
if (!nxtTxUpd)
amDl->nxtTx = sdu;
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) &&
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) &&
(rbCb->rlcId.rbType == CM_LTE_DRB))
{
numSdus = 0;
currSduIdx = 0;
- l2MeasTb = kwUtlGetCurMeasTb(gCb, rbCb);
- kwUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant);
+ l2MeasTb = rlcUtlGetCurMeasTb(gCb, rbCb);
+ rlcUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant);
if ((lchInfo.numSdus != 0) && (l2MeasTb != NULLP))
{
for (lchIdx = 0; ((lchIdx < l2MeasTb->numLchInfo)
- && (lchIdx < KW_MAX_ACTV_DRB )); lchIdx++)
+ && (lchIdx < RLC_MAX_ACTV_DRB )); lchIdx++)
{
if (l2MeasTb->lchInfo[lchIdx].lcId == rbCb->lch.lChId)
{
break;
}
}
- if (lchIdx < KW_MAX_ACTV_DRB)
+ if (lchIdx < RLC_MAX_ACTV_DRB)
{
if (lchIdx == l2MeasTb->numLchInfo)
{
}
dstLchInfo = &l2MeasTb->lchInfo[lchIdx];
currSduIdx = l2MeasTb->lchInfo[lchIdx].numSdus;
- while ((numSdus < lchInfo.numSdus) && (currSduIdx < KW_L2MEAS_SDUIDX))
+ while ((numSdus < lchInfo.numSdus) && (currSduIdx < RLC_L2MEAS_SDUIDX))
{
dstLchInfo->sduInfo[currSduIdx].arvlTime = lchInfo.sduInfo[numSdus].arvlTime;
dstLchInfo->sduInfo[currSduIdx].isRetxPdu = FALSE;
if(discSduInfo->numSduIds != 0)
{
/* Sap control block */
- KwUiKwuDiscSduCfm(&kwuSap->pst, kwuSap->suId, discSduInfo);
+ RlcUiKwuDiscSduCfm(&rlckwuSap->pst, rlckwuSap->suId, discSduInfo);
}
else
{
- RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo));
}
#ifndef ALIGN_64BIT
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAssembleSdus: BO after assembly = %ld UEID:%d CELLID:%d",
+ "rlcAssembleSdus: BO after assembly = %ld UEID:%d CELLID:%d",
amDl->bo,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#else
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
+ "rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
amDl->bo,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
*
*/
#ifdef ANSI
-PRIVATE Bool kwAmmDlCheckAndSetPoll
+PRIVATE Bool rlcAmmDlCheckAndSetPoll
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
MsgLen bufSz
)
#else
-PRIVATE Bool kwAmmDlCheckAndSetPoll(gCb, rbCb, newPdu, bufSz)
+PRIVATE Bool rlcAmmDlCheckAndSetPoll(gCb, rbCb, newPdu, bufSz)
RlcCb *gCb;
RlcDlRbCb *rbCb;
Bool newPdu;
#endif
{
Bool pollBit = FALSE;
- KwAmDl *amDl = &(rbCb->m.amDl);
+ RlcAmDl *amDl = &(rbCb->m.amDl);
- TRC2(kwAmmDlCheckAndSetPoll)
+ TRC2(rlcAmmDlCheckAndSetPoll)
/* If it's a new PDU increment PDU without poll and bytes without poll
/* Check if both tx/retx buffer are empty or if tx window is stalled */
if (((amDl->nxtTx == NULLP) && (amDl->nxtRetx == NULLP)) ||
- KW_AM_IS_TRANS_WIN_STALLED(amDl))
+ RLC_AM_IS_TRANS_WIN_STALLED(amDl))
{
pollBit = TRUE;
}
amDl->pollSn = (amDl->txNext - 1) & amDl->snModMask;
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
+ "rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
amDl->pollSn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
* then starting the timer. Fixes crs
* ccpu00117216 and ccpu00118284 .
* */
- if( TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMDL_POLL_RETX_TMR) )
+ if( TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR) )
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
}
- kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
}
return (pollBit);
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmCreatePdu
+PRIVATE Void rlcAmmCreatePdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
RlcDlPduInfo *pduInfo,
Buffer *pdu
)
#else
-PRIVATE Void kwAmmCreatePdu(gCb, rbCb, pduInfo, amHdr, pdu)
+PRIVATE Void rlcAmmCreatePdu(gCb, rbCb, pduInfo, amHdr, pdu)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
RlcDlPduInfo *pduInfo;
Buffer *pdu;
#endif
{
- U8 hdr[KW_MAX_HDRSZ];
+ U8 hdr[RLC_MAX_HDRSZ];
U16 idx;
- KwTx *txBuf;
+ RlcTx *txBuf;
MsgLen pduSz;
- KwAmDl *amDl = &(rbCb->m.amDl);
+ RlcAmDl *amDl = &(rbCb->m.amDl);
- TRC2(kwAmmCreatePdu)
+ TRC2(rlcAmmCreatePdu)
/* Update sn */
amHdr->sn = amDl->txNext;
/*5GNR RLC: Increment txNext only if no segmentation of it is a last segment */
- if((!amHdr->si) || (amHdr->si == KW_SI_LAST_SEG))
+ if((!amHdr->si) || (amHdr->si == RLC_SI_LAST_SEG))
{
//printf("\n 5GNRLOG: no segment/last seg SDU with lcId %d Sn %u txNext %u So %u\n",
// rbCb->lch.lChId, amHdr->sn, amDl->txNext, amHdr->so);
SFndLenMsg(pdu, &pduSz);
/* passing newPDU = TRUE*/
- amHdr->p = kwAmmDlCheckAndSetPoll(gCb,rbCb, TRUE, pduSz);
+ amHdr->p = rlcAmmDlCheckAndSetPoll(gCb,rbCb, TRUE, pduSz);
/* Construct header with the available hdr Info, set isSegment to FALSE */
- kwConstructAmHdr(amHdr, hdr, amDl->snLen, &idx);
+ rlcConstructAmHdr(amHdr, hdr, amDl->snLen, &idx);
/* Concatenate hdr and data */
SAddPreMsgMultInOrder(hdr, idx+1, pdu);
- txBuf = kwUtlGetTxBuf(amDl->txBufLst, amHdr->sn);
- kwCpyMsg(gCb,pdu,&(pduInfo->pdu));
+ txBuf = rlcUtlGetTxBuf(amDl->txBufLst, amHdr->sn);
+ rlcCpyMsg(gCb,pdu,&(pduInfo->pdu));
pduInfo->pduSz = pduSz;
pduInfo->hdrSz = idx+1;
/* Reestimate estHdrSz for mid and last seg */
if(amHdr->si & 0x1)
{
- amDl->estHdrSz += ((amHdr->si == KW_SI_MID_SEG)? pduInfo->hdrSz : (pduInfo->hdrSz + 2));
+ amDl->estHdrSz += ((amHdr->si == RLC_SI_MID_SEG)? pduInfo->hdrSz : (pduInfo->hdrSz + 2));
}
cmLListAdd2Tail(&txBuf->pduLst, &pduInfo->lstEnt);
*
*/
#ifdef ANSI
-PRIVATE Void kwRemRetxPdu
+PRIVATE Void rlcRemRetxPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwRetx *retx
+RlcRetx *retx
)
#else
-PRIVATE Void kwRemRetxPdu(gCb, rbCb, retx)
+PRIVATE Void rlcRemRetxPdu(gCb, rbCb, retx)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwRetx *retx;
+RlcRetx *retx;
#endif
{
- TRC2(kwRemRetxPdu)
+ TRC2(rlcRemRetxPdu)
cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
AMDL.estHdrSz -= retx->hdrSz;
}
- kwUtlAddReTxPduToBeFreedQueue(gCb, retx);
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlAddReTxPduToBeFreedQueue(gCb, retx);
+ rlcUtlRaiseDlCleanupEvent(gCb);
RETVOID;
}
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlMarkPduForReTx
+PRIVATE Void rlcAmmDlMarkPduForReTx
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwRetx *retx
+RlcRetx *retx
)
#else
-PRIVATE Void kwAmmDlMarkPduForReTx(*gCb, rbCb, retx)
+PRIVATE Void rlcAmmDlMarkPduForReTx(*gCb, rbCb, retx)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwRetx *retx;
+RlcRetx *retx;
#endif
{
- TRC2(kwAmmDlMarkPduForReTx)
+ TRC2(rlcAmmDlMarkPduForReTx)
if (AMDL.maxReTxReached == TRUE)
{
RETVOID;
rbCb->m.amDl.cntrlBo = 0;
rbCb->m.amDl.retxBo = 0;
/* Sending BO update to SCH */
- kwUtlSndDStaRsp(gCb, rbCb, 0,0,0,0);
- kwAmmSndStaInd(gCb, rbCb, retx);
+ rlcUtlSndDStaRsp(gCb, rbCb, 0,0,0,0);
+ rlcAmmSndStaInd(gCb, rbCb, retx);
gRlcStats.amRlcStats.numDLMaxRetx++;
}
- kwRemRetxPdu(gCb,rbCb, retx);
+ rlcRemRetxPdu(gCb,rbCb, retx);
RETVOID;
}
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlCheckIsSDUDelivered
+PRIVATE Void rlcAmmDlCheckIsSDUDelivered
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwSduMap *sduMap,
+RlcSduMap *sduMap,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void kwAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm)
+PRIVATE Void rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwSduMap *sduMap;
+RlcSduMap *sduMap;
KwuDatCfmInfo **datCfm;
#endif
{
- KwSdu *sdu;
+ RlcSdu *sdu;
- TRC2(kwAmmDlCheckIsSDUDelivered)
+ TRC2(rlcAmmDlCheckIsSDUDelivered)
sdu = sduMap->sdu;
* send so many confirms in one go
* Confrims to PDCP are being dropped in this case
*/
- KwKwuSapCb *kwuSap;
- kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
- KwUiKwuDatCfm(&kwuSap->pst, kwuSap->suId, *datCfm);
+ RlcKwuSapCb *rlckwuSap;
+ rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
+ RlcUiKwuDatCfm(&rlckwuSap->pst, rlckwuSap->suId, *datCfm);
- RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, *datCfm, sizeof(KwuDatCfmInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, *datCfm, sizeof(KwuDatCfmInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*datCfm == NULLP)
/* Remove SDU from the sduQ */
cmLListDelFrm(&AMDL.sduQ, &sdu->lstEnt);
- kwUtlAddSduToBeFreedQueue(gCb, sdu);
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlAddSduToBeFreedQueue(gCb, sdu);
+ rlcUtlRaiseDlCleanupEvent(gCb);
}
RETVOID;
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlProcessSuccessfulTxPdu
+PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwSn sn,
+RlcSn sn,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void kwAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm)
+PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwSn sn;
+RlcSn sn;
KwuDatCfmInfo **datCfm;
#endif
{
- TRC2(kwAmmDlProcessSuccessfulTxPdu)
+ TRC2(rlcAmmDlProcessSuccessfulTxPdu)
CmLList *pduNode;
- KwTx *txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn);
+ RlcTx *txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
if (txBuf == NULLP)
{
while(pduNode)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pduNode->node);
- kwAmmDlCheckIsSDUDelivered(gCb,
+ rlcAmmDlCheckIsSDUDelivered(gCb,
rbCb,
&(pduInfo->sduMap),
datCfm);
pduNode = pduNode->next;
}
- kwUtlAddTxPduToBeFreedQueue(gCb, txBuf);
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlAddTxPduToBeFreedQueue(gCb, txBuf);
+ rlcUtlRaiseDlCleanupEvent(gCb);
/* so that it is not processed again */
- kwUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb);
+ rlcUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb);
RETVOID;
}
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmSndStaInd
+PRIVATE Void rlcAmmSndStaInd
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwRetx *retx
+RlcRetx *retx
)
#else
-PRIVATE Void kwAmmSndStaInd(gCb, rbCb, retx)
+PRIVATE Void rlcAmmSndStaInd(gCb, rbCb, retx)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwRetx *retx;
+RlcRetx *retx;
#endif
{
KwuStaIndInfo *staInd;
- KwKwuSapCb *kwuSap;
+ RlcKwuSapCb *rlckwuSap;
- TRC2(kwAmmSndStaInd);
+ TRC2(rlcAmmSndStaInd);
/* Sap control block */
- kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
+ rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
/* Allocate memory for staInd Info */
- RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, staInd, sizeof(KwuStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, staInd, sizeof(KwuStaIndInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (staInd == NULLP)
#endif /* ERRCLASS & ERRCLS_RES */
/* Fill staInd Info */
- KW_MEM_CPY(&staInd->rlcId, &rbCb->rlcId, sizeof(CmLteRlcId));
+ RLC_MEM_CPY(&staInd->rlcId, &rbCb->rlcId, sizeof(CmLteRlcId));
staInd->numSdu = 1;
staInd->sduId[0] = retx->sduMap.sdu->mode.am.sduId;
#ifdef KW_PDCP
#else
- KwUiKwuStaInd(&kwuSap->pst, kwuSap->suId, staInd);
+ RlcUiKwuStaInd(&rlckwuSap->pst, rlckwuSap->suId, staInd);
#endif /* KW_PDCP */
RETVOID;
*
*/
#ifdef ANSI
-PRIVATE Void kwGetNxtRetx
+PRIVATE Void rlcGetNxtRetx
(
RlcCb *gCb,
-KwRetx **retx
+RlcRetx **retx
)
#else
-PRIVATE Void kwGetNxtRetx(gCb, retx)
+PRIVATE Void rlcGetNxtRetx(gCb, retx)
RlcCb *gCb;
-KwRetx **retx;
+RlcRetx **retx;
#endif
{
CmLList *tNode;
- TRC2(kwGetNxtRetx);
+ TRC2(rlcGetNxtRetx);
do
{
if (tNode)
{
- *retx = (KwRetx *)tNode->node;
+ *retx = (RlcRetx *)tNode->node;
}
else
{
*
*/
#ifdef ANSI
-PUBLIC Void kwAmmDlReEstablish
+Void rlcAmmDlReEstablish
(
RlcCb *gCb,
CmLteRlcId rlcId,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmDlReEstablish(gCb, rlcId, rbCb)
+Void rlcAmmDlReEstablish(gCb, rlcId, rbCb)
RlcCb *gCb;
CmLteRlcId rlcId;
RlcDlRbCb *rbCb;
/* create a new AM DL RB, reset it and replace in the UeCb*/
RlcDlUeCb *ueCb;
RlcDlRbCb *resetRb;
- KwAmDl* newAmDl;
- KwAmDl* oldAmDl;
+ RlcAmDl* newAmDl;
+ RlcAmDl* oldAmDl;
RLC_ALLOC(gCb, resetRb, sizeof(RlcDlRbCb));
/* ccpu00135170 Removing KLOCK warning */
RETVOID;
}
- KW_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb));
- RLC_MEM_SET(&resetRb->m.amDl, 0 , sizeof(KwAmDl));
+ RLC_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb));
+ RLC_MEM_SET(&resetRb->m.amDl, 0 , sizeof(RlcAmDl));
/* AGHOSH changes start */
/* restore the old AM values */
cmInitTimers(&(resetRb->m.amDl.pollRetxTmr), 1);
/* AGHOSH changes end */
- if (ROK != kwDbmFetchDlUeCb(gCb,rlcId.ueId, rlcId.cellId, &ueCb))
+ if (ROK != rlcDbmFetchDlUeCb(gCb,rlcId.ueId, rlcId.cellId, &ueCb))
{
RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId.cellId,
"UeId [%d]: UeCb not found RBID;%d",
U32 hashIndex;
RLC_ALLOC(gCb,
resetRb->m.amDl.txBufLst,
- (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
- for(hashIndex = 0; hashIndex < KW_TX_BUF_BIN_SIZE; hashIndex++)
+ (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ for(hashIndex = 0; hashIndex < RLC_TX_BUF_BIN_SIZE; hashIndex++)
{
cmLListInit(&(resetRb->m.amDl.txBufLst[hashIndex]));
}
#endif
/* send the old rb of deletion */
- kwAmmFreeDlRbCb(gCb,rbCb);
+ rlcAmmFreeDlRbCb(gCb,rbCb);
/* TODO: for now we are re-settting the re-establishment flag here
* -# RFAILED In case the SDU is not found or already mapped
*/
#ifdef ANSI
-PUBLIC S16 kwAmmDiscSdu
+S16 rlcAmmDiscSdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
U32 sduId
)
#else
-PUBLIC S16 kwAmmDiscSdu(gCb, rbCb, sduId)
+S16 rlcAmmDiscSdu(gCb, rbCb, sduId)
RlcCb *gCb;
RlcDlRbCb *rbCb;
U32 sduId;
#endif
{
- TRC2(kwAmmDiscSdu);
- return RFAILED;
+ TRC2(rlcAmmDiscSdu);
+ return (RFAILED);
}
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwAmmPollRetxTmrExp
+Void rlcAmmPollRetxTmrExp
(
RlcCb *gCb,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmPollRetxTmrExp(gCb, rbCb)
+Void rlcAmmPollRetxTmrExp(gCb, rbCb)
RlcCb *gCb;
RlcDlRbCb *rbCb;
#endif
{
- KwRetx *retx;
- KwAmDl *amDl = &(rbCb->m.amDl);
- KwSn sn;
- KwTx *txBuf;
- TRC2(kwAmmPollRetxTmrExp);
+ RlcRetx *retx;
+ RlcAmDl *amDl = &(rbCb->m.amDl);
+ RlcSn sn;
+ RlcTx *txBuf;
+ TRC2(rlcAmmPollRetxTmrExp);
/* kw003.201 - Correcting the logic for determmining whether to do */
}
if (((amDl->nxtTx == NULLP) && (amDl->nxtRetx == NULLP)) ||
- KW_AM_IS_TRANS_WIN_STALLED(amDl))
+ RLC_AM_IS_TRANS_WIN_STALLED(amDl))
{
sn = (amDl->txNext - 1) & amDl->snModMask;
- txBuf = kwUtlGetTxBuf(amDl->txBufLst, sn);
+ txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn);
if (txBuf != NULLP)
{
- kwAmmDlMoveFrmTxtoRetxBuffer(gCb,amDl, &retx, sn);
+ rlcAmmDlMoveFrmTxtoRetxBuffer(gCb,amDl, &retx, sn);
if (AMDL.nxtRetx == NULLP)
{
AMDL.nxtRetx = retx;
}
- kwAmmSendDStaRsp(gCb, rbCb, &AMDL);
+ rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
RETVOID;
}
/* Get the last node in retxLst */
- KW_LLIST_LAST_RETX(amDl->retxLst, retx);
+ RLC_LLIST_LAST_RETX(amDl->retxLst, retx);
/* Unset wtForAck flag for the NACK PDUs */
if (retx != NULLP)
{
- kwAmmDlMarkPduForReTx(gCb, rbCb, retx);
- kwAmmSendDStaRsp(gCb, rbCb, &AMDL);
+ rlcAmmDlMarkPduForReTx(gCb, rbCb, retx);
+ rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
}
}
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn
+PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwSn mAckSn,
+RlcSn mAckSn,
CmLList *retxNode,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm)
+PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwSn mAckSn;
+RlcSn mAckSn;
CmLList *retxNode;
KwuDatCfmInfo **datCfm;
#endif
{
- KwSn mSn;
- KwSn sn;
- KwRetx *retx;
- KwTx *txBuf;
+ RlcSn mSn;
+ RlcSn sn;
+ RlcRetx *retx;
+ RlcTx *txBuf;
- TRC2(kwAmmDlUpdateTxAndReTxBufForAckSn);
+ TRC2(rlcAmmDlUpdateTxAndReTxBufForAckSn);
/* Remove pdus/segs from retxLst */
while (retxNode)
{
- retx = (KwRetx *)(retxNode->node);
+ retx = (RlcRetx *)(retxNode->node);
retxNode = retxNode->next;
MODAMT(retx->amHdr.sn, mSn, AMDL.txNextAck,AMDL.snModMask);
if (mSn < mAckSn)
{
- kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
+ rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
}
}
sn = AMDL.txNextAck;
while(mSn < mAckSn)
{
- txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn);
+ txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
if (txBuf != NULLP)
{
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
+ "rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
"with sn = %ld UEID:%ld CELLID:%ld",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- kwAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm);
+ rlcAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm);
}
sn = (sn + 1) & AMDL.snModMask;
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn
+PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwSn sn,
-KwSn mNackSn,
+RlcSn sn,
+RlcSn mNackSn,
CmLList **retxNode,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm)
+PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwSn sn;
-KwSn mNackSn;
+RlcSn sn;
+RlcSn mNackSn;
CmLList **retxNode;
KwuDatCfmInfo **datCfm;
#endif
{
- KwSn mSn;
- KwRetx *retx;
- KwTx *txBuf=NULLP;
+ RlcSn mSn;
+ RlcRetx *retx;
+ RlcTx *txBuf=NULLP;
- TRC2(kwAmmDlUpdTxAndReTxBufForLessThanNackSn);
+ TRC2(rlcAmmDlUpdTxAndReTxBufForLessThanNackSn);
while (*retxNode)
{
- retx = (KwRetx *)((*retxNode)->node);
+ retx = (RlcRetx *)((*retxNode)->node);
MODAMT(retx->amHdr.sn, mSn, AMDL.txNextAck,AMDL.snModMask);
if (mSn < mNackSn)
{
(*retxNode) = (*retxNode)->next;
- kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
+ rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
}
else
{
{
/* this if check seems redundant,why should mSn ever be mTxSn
(which actually is VT(A) */
- txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn);
+ txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
if ((txBuf != NULLP))
{
RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId,
- "kwHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
+ "rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
/* Remove pdus from txBuf */
- kwAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm);
+ rlcAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm);
}
sn = (sn + 1) & AMDL.snModMask;
*
*/
#ifdef ANSI
-PRIVATE Void kwConstructAmHdr
+PRIVATE Void rlcConstructAmHdr
(
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
U8 *hdr,
U8 snLen,
U16 *idx
)
#else
-PRIVATE Void kwConstructAmHdr(amHdr, hdr, snLen, idx)
-KwAmHdr *amHdr;
+PRIVATE Void rlcConstructAmHdr(amHdr, hdr, snLen, idx)
+RlcAmHdr *amHdr;
U8 *hdr;
U8 snLen;
U16 *idx;
#endif
{
- TRC2(kwConstructAmHdr);
+ TRC2(rlcConstructAmHdr);
*idx = 0;
- hdr[0] = KW_DATA_BITMASK;
+ hdr[0] = RLC_DATA_BITMASK;
hdr[0] = hdr[0] | (amHdr->p << 6);
hdr[0] = hdr[0] | ((amHdr->si & 0x3) << 4);
- if(snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if(snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
hdr[0] = hdr[0] | (U8)((amHdr->sn & 0xF00) >> 8);
hdr[1] = (U8)(amHdr->sn & 0x0FF);
(*idx)++;
}
- if ((amHdr->si == KW_SI_MID_SEG) || (amHdr->si == KW_SI_LAST_SEG))
+ if ((amHdr->si == RLC_SI_MID_SEG) || (amHdr->si == RLC_SI_LAST_SEG))
{
(*idx)++;
hdr[(*idx)] = (U8)((amHdr->so & 0xFF00)>> 8);
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmAddPduToRetxLst
+PRIVATE Void rlcAmmAddPduToRetxLst
(
-KwAmDl *amDl,
-KwRetx *retx
+RlcAmDl *amDl,
+RlcRetx *retx
)
#else
-PRIVATE Void kwAmmAddPduToRetxLst(amDl, retx)
-KwAmDl *amDl;
-KwRetx *retx;
+PRIVATE Void rlcAmmAddPduToRetxLst(amDl, retx)
+RlcAmDl *amDl;
+RlcRetx *retx;
#endif
{
CmLList *node;
- KwRetx *tRetx;
- KwSn tMSn;
- KwSn retxMSn;
+ RlcRetx *tRetx;
+ RlcSn tMSn;
+ RlcSn retxMSn;
- TRC2(kwAmmAddPduToRetxLst);
+ TRC2(rlcAmmAddPduToRetxLst);
node = amDl->retxLst.last;
MODAMT(retx->amHdr.sn, retxMSn, amDl->txNextAck,amDl->snModMask);
while(node != NULLP)
{
- tRetx = (KwRetx *)(node->node);
+ tRetx = (RlcRetx *)(node->node);
MODAMT(tRetx->amHdr.sn, tMSn, amDl->txNextAck,amDl->snModMask);
if (tMSn > retxMSn)
{
*/
#ifdef ANSI
-PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer
+PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer
(
RlcCb *gCb,
-KwAmDl *amDl,
-KwRetx **retx,
-KwSn sn
+RlcAmDl *amDl,
+RlcRetx **retx,
+RlcSn sn
)
#else
-PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn)
+PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn)
RlcCb *gCb;
-KwAmDl *amDl;
-KwRetx **retx;
-KwSn sn;
+RlcAmDl *amDl;
+RlcRetx **retx;
+RlcSn sn;
#endif
{
- KwTx* txBuf = kwUtlGetTxBuf(amDl->txBufLst, sn);
- TRC2(kwAmmDlMoveFrmTxtoRetxBuffer);
+ RlcTx* txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn);
+ TRC2(rlcAmmDlMoveFrmTxtoRetxBuffer);
if (txBuf == NULLP)
{
while(txBuf->pduLst.first)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node);
- RLC_ALLOC_WC(gCb,*retx, sizeof(KwRetx));
+ RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
#endif /* ERRCLASS & ERRCLS_RES */
/* Move Sdu byte segment from TX buf to retx buf*/
- kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb,
+ rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb,
amDl,
retx,
pduInfo);
RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
/* Remove PDU from txBuf */
- kwUtlDelTxBuf(amDl->txBufLst, txBuf,gCb);
+ rlcUtlDelTxBuf(amDl->txBufLst, txBuf,gCb);
RETVOID;
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwAmmFreeDlRbCb
+Void rlcAmmFreeDlRbCb
(
RlcCb *gCb,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmFreeDlRbCb(gCb,rbCb)
+Void rlcAmmFreeDlRbCb(gCb,rbCb)
RlcCb *gCb;
RlcDlRbCb *rbCb;
#endif
{
/* stop the re-transmission timer */
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMDL_POLL_RETX_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
}
/* store the entire Rb pointer */
/* the sdu queue */
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.amDl.sduQ));
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlRaiseDlCleanupEvent(gCb);
RETVOID;
}
*
* @param[in] gCb RLC instance control block
* @param[in] rbCb Downlink RB control block
- * @param[in] kwDatReq The data to be passed to MAC
+ * @param[in] rlcDatReq The data to be passed to MAC
*
* @return Void
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmCreateStatusPdu
+PRIVATE Void rlcAmmCreateStatusPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwDatReq *kwDatReq
+RlcDatReq *rlcDatReq
)
#else
-PRIVATE Void kwAmmCreateStatusPdu(gCb, rbCb, kwDatReq)
+PRIVATE Void rlcAmmCreateStatusPdu(gCb, rbCb, rlcDatReq)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwDatReq *kwDatReq;
+RlcDatReq *rlcDatReq;
#endif
{
- KwSn sn; /* sequence number */
- KwSn ack_sn; /* Ack sequence number */
+ RlcSn sn; /* sequence number */
+ RlcSn ack_sn; /* Ack sequence number */
Buffer *mBuf; /* control pdu buffer */
MsgLen cntrlPduSz; /* control pdu size */
- U8 cntrlPdu[KW_MAX_CNTRL_FIELDS]; /* control pdu to be added to mBuf */
- KwUdxDlStaPdu *pStaPdu;
+ U8 cntrlPdu[RLC_MAX_CNTRL_FIELDS]; /* control pdu to be added to mBuf */
+ RlcUdxDlStaPdu *pStaPdu;
U16 bytesToEncode = 0; /* bytes required to encode the STATUS PDU */
U16 encIdx = 0;
U16 prevEncIdx = 0;
- KwNackInfo *kwNackInfo;
+ RlcNackInfo *rlcNackInfo;
U16 nkCnt = 0;
- TRC2(kwAmmCreateStatusPdu)
+ TRC2(rlcAmmCreateStatusPdu)
pStaPdu = AMDL.pStaPdu;
ack_sn = pStaPdu->ackSn;
- if (rbCb->m.amDl.snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if (rbCb->m.amDl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
/* If alteast one NACK SN Info then set the E1 field */
{
sn = pStaPdu->nackInfo[nkCnt].sn;
- kwNackInfo = &(pStaPdu->nackInfo[nkCnt]);
+ rlcNackInfo = &(pStaPdu->nackInfo[nkCnt]);
bytesToEncode += 2; /* 2 Octets for NACK SN */
/* Check if E2 : isSegment is set */
- if (kwNackInfo->isSegment)
+ if (rlcNackInfo->isSegment)
{
bytesToEncode += 4; /* 4 Octets: SOstart, SOend */
}
/* Check if E3 : nackRange is set */
- if (kwNackInfo->nackRange)
+ if (rlcNackInfo->nackRange)
{
bytesToEncode += 1; /* 1 Octet: NACK range */
}
/* Check if this NACK info can be accomodated in the Grant */
- if( kwDatReq->pduSz >= bytesToEncode)
+ if( rlcDatReq->pduSz >= bytesToEncode)
{
/* If there is a NACK SN before this then set its
E1 bit */
/* Next Octet */
cntrlPdu[encIdx + 1] = (sn & 0xF) << 4;
- if (kwNackInfo->isSegment)
+ if (rlcNackInfo->isSegment)
{
/*Set E2 Bit */
cntrlPdu[encIdx + 1] |= 0x4;
/* Add soStart and soEnd */
/* SOstart */
- cntrlPdu[encIdx + 2] = (kwNackInfo->soStart) >> 8;
- cntrlPdu[encIdx + 3] = kwNackInfo->soStart & 0xFF;
+ cntrlPdu[encIdx + 2] = (rlcNackInfo->soStart) >> 8;
+ cntrlPdu[encIdx + 3] = rlcNackInfo->soStart & 0xFF;
/* SOend */
- cntrlPdu[encIdx + 4] = (kwNackInfo->soEnd) >> 8;
- cntrlPdu[encIdx + 5] = kwNackInfo->soEnd & 0xFF;
+ cntrlPdu[encIdx + 4] = (rlcNackInfo->soEnd) >> 8;
+ cntrlPdu[encIdx + 5] = rlcNackInfo->soEnd & 0xFF;
}
- if (kwNackInfo->nackRange)
+ if (rlcNackInfo->nackRange)
{
/*Set E3 Bit */
cntrlPdu[encIdx + 1] |= 0x2;
- if(kwNackInfo->isSegment)
+ if(rlcNackInfo->isSegment)
{
- cntrlPdu[encIdx + 6] = kwNackInfo->nackRange;
+ cntrlPdu[encIdx + 6] = rlcNackInfo->nackRange;
}
else
{
- cntrlPdu[encIdx + 2] = kwNackInfo->nackRange;
+ cntrlPdu[encIdx + 2] = rlcNackInfo->nackRange;
}
}
/* Set ACK SN now */
else
{
- ack_sn = kwNackInfo->sn;
+ ack_sn = rlcNackInfo->sn;
/* Not even one nack can be accomodated */
if (nkCnt == 0)
{
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAssembleCntrlInfo: ACK PDU's SN = %d"
+ "rlcAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d",
ack_sn,
rbCb->rlcId.ueId,
}
}
- else if (rbCb->m.amDl.snLen == KW_AM_CFG_18BIT_SN_LEN)
+ else if (rbCb->m.amDl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
{
/* If alteast one NACK SN Info then set the E1 field */
if (pStaPdu->nackCount)
{
sn = pStaPdu->nackInfo[nkCnt].sn;
- kwNackInfo = &(pStaPdu->nackInfo[nkCnt]);
+ rlcNackInfo = &(pStaPdu->nackInfo[nkCnt]);
bytesToEncode += 3; /* 3 Octets for NACK SN */
/* Check if E2 : isSegment is set */
- if (kwNackInfo->isSegment)
+ if (rlcNackInfo->isSegment)
{
bytesToEncode += 4; /* 4 Octets: SOstart, SOend */
}
/* Check if E3 : nackRange is set */
- if (kwNackInfo->nackRange)
+ if (rlcNackInfo->nackRange)
{
bytesToEncode += 1; /* 1 Octet: NACK range */
}
/* Check if this NACK info can be accomodated in the Grant */
- if( kwDatReq->pduSz >= bytesToEncode)
+ if( rlcDatReq->pduSz >= bytesToEncode)
{
/* If there is a NACK SN before this then set its
E1 bit */
/* Next Octet */
cntrlPdu[encIdx + 2] = (U8)((sn & 0x3)<< 6);
- if (kwNackInfo->isSegment)
+ if (rlcNackInfo->isSegment)
{
/* NACKSN E1 E2 E3 R R R */
/*Set E2 Bit */
/* Add soStart and soEnd */
/* SOstart */
- cntrlPdu[encIdx + 3] = (kwNackInfo->soStart) >> 8;
- cntrlPdu[encIdx + 4] = (U8)kwNackInfo->soStart;
+ cntrlPdu[encIdx + 3] = (rlcNackInfo->soStart) >> 8;
+ cntrlPdu[encIdx + 4] = (U8)rlcNackInfo->soStart;
/* SOend */
- cntrlPdu[encIdx + 5] = (kwNackInfo->soEnd) >> 8;
- cntrlPdu[encIdx + 6] = (U8)(kwNackInfo->soEnd);
+ cntrlPdu[encIdx + 5] = (rlcNackInfo->soEnd) >> 8;
+ cntrlPdu[encIdx + 6] = (U8)(rlcNackInfo->soEnd);
}
- if (kwNackInfo->nackRange)
+ if (rlcNackInfo->nackRange)
{
/* NACKSN E1 E2 E3 R R R */
/*Set E3 Bit */
cntrlPdu[encIdx + 2] |= 0x08;
- if (kwNackInfo->isSegment)
+ if (rlcNackInfo->isSegment)
{
- cntrlPdu[encIdx + 7] = kwNackInfo->nackRange;
+ cntrlPdu[encIdx + 7] = rlcNackInfo->nackRange;
}
else
{
- cntrlPdu[encIdx + 3] = kwNackInfo->nackRange;
+ cntrlPdu[encIdx + 3] = rlcNackInfo->nackRange;
}
}
/* Set ACK SN now */
else
{
- ack_sn = kwNackInfo->sn;
+ ack_sn = rlcNackInfo->sn;
/* Not even one nack can be accomodated */
if (nkCnt == 0)
{
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAssembleCntrlInfo: ACK PDU's SN = %d"
+ "rlcAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d",
ack_sn,
rbCb->rlcId.ueId,
{
/* ERROR Log */
RLOG_ARG3(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
- "kwAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! UEID:%d CELLID:%d",
+ "rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! UEID:%d CELLID:%d",
rbCb->m.amDl.snLen,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#ifndef L2_OPTMZ
- SGetMsg(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb),&mBuf);
+ SGetMsg(RLC_GET_MEM_REGION(gCb), RLC_GET_MEM_POOL(gCb),&mBuf);
#else
- mBuf = (Buffer *)kwAmmStaPduList[kwAmmStaPduListCnt++];
+ mBuf = (Buffer *)rlcAmmStaPduList[rlcAmmStaPduListCnt++];
SResetMBuf(mBuf);
- if(kwAmmStaPduListCnt > 511)
- kwAmmStaPduListCnt = 0;
+ if(rlcAmmStaPduListCnt > 511)
+ rlcAmmStaPduListCnt = 0;
#endif
cntrlPduSz = encIdx;
SAddPstMsgMult (cntrlPdu, cntrlPduSz, mBuf);
- kwDatReq->pduSz -= cntrlPduSz;
+ rlcDatReq->pduSz -= cntrlPduSz;
/* Add mBuf to AMDL.mBuf */
AMDL.mBuf = mBuf;
#ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
-S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId,
+S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
#ifdef ANSI
(
RlcCb *gCb,
Buffer *pdu,
-KwExtHdr *hdrInfo
+RlcExtHdr *hdrInfo
)
#else
PRIVATE Void rgAmmExtractElmnt(gCb, pdu, hdrInfo)
RlcCb *gCb;
Buffer *pdu;
-KwExtHdr *hdrInfo;
+RlcExtHdr *hdrInfo;
#endif
{
U8 hdr;
/* U8 rLen1 = 0; */
U16 tVal;
- TRC2(kwAmmExtractElmnt);
+ TRC2(rlcAmmExtractElmnt);
hdr = hdrInfo->hdr;
tHdr = hdr;
if (len <= 8)
{
- val = tHdr >> (KW_BYTE_LEN - (len));
+ val = tHdr >> (RLC_BYTE_LEN - (len));
hdr = hdr << len;
pLen -= len;
}
{
fLen = pLen;
val = tHdr;
- val = val >> (KW_BYTE_LEN - fLen);
+ val = val >> (RLC_BYTE_LEN - fLen);
val = val << (len - fLen);
rLen = len - fLen;
SRemPreMsg(&hdr, pdu);
tHdr = hdr;
if (rLen <= 8)
{
- hdr = hdr >> (KW_BYTE_LEN - rLen);
+ hdr = hdr >> (RLC_BYTE_LEN - rLen);
val = val | hdr;
hdr = tHdr << rLen;
- pLen = (KW_BYTE_LEN - rLen);
+ pLen = (RLC_BYTE_LEN - rLen);
}
else
{
- rLen = rLen - KW_BYTE_LEN;
+ rLen = rLen - RLC_BYTE_LEN;
tVal = hdr;
tVal = tVal << rLen;
val = val | tVal;
SRemPreMsg(&hdr, pdu);
tHdr = hdr;
- hdr = hdr >> (KW_BYTE_LEN - rLen);
+ hdr = hdr >> (RLC_BYTE_LEN - rLen);
val = val | hdr;
hdr = tHdr << rLen;
- pLen = (KW_BYTE_LEN - rLen);
+ pLen = (RLC_BYTE_LEN - rLen);
}
}
#endif
{
U8 e1;
- KwExtHdr hdrInfo;
- KwUdxStaPdu *pStaPdu;
+ RlcExtHdr hdrInfo;
+ RlcUdxStaPdu *pStaPdu;
U8 e3; /* NACK RANGE : 5GNR */
U32 snLen;
U32 snRange;
TRC2(rgAmmUlHndlStatusPdu)
- KWDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n");
+ RLCDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n");
- KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr));
+ RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract the Control PDU */
hdrInfo.hdr = (*fByte << 1);
/* D/C has been shifted in the calling function */
if (hdrInfo.hdr & 0xE0)
{
- KWDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n");
+ RLCDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n");
RETVOID;
}
RLC_ALLOC_SHRABL_BUF(udxPst->region,
udxPst->pool,
pStaPdu,
- sizeof(KwUdxStaPdu));
+ sizeof(RlcUdxStaPdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
/* Memory allocation failure can not be expected */
}
#endif
- if (rbCb->m.amDl.snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if (rbCb->m.amDl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
snLen = 12;
- resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_12BITS;
- resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_12BITS;
+ resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_12BITS;
+ resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_12BITS;
}
- else if (rbCb->m.amDl.snLen == KW_AM_CFG_18BIT_SN_LEN)
+ else if (rbCb->m.amDl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
{
snLen = 18;
- resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_18BITS;
- resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_18BITS;
+ resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_18BITS;
+ resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_18BITS;
}
else
{
- snLen = KW_SN_LEN;
+ snLen = RLC_SN_LEN;
resrvdBitsAckSn = 0;
resrvdBitsAckSn = 0;
}
pStaPdu->nackCnt = 0;
/* For CPT */
- hdrInfo.hdr = hdrInfo.hdr << KW_CPT_LEN;
+ hdrInfo.hdr = hdrInfo.hdr << RLC_CPT_LEN;
/* ACK Sn */
- hdrInfo.len = KW_SN_LEN;
+ hdrInfo.len = RLC_SN_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->ackSn = hdrInfo.val;
/* Check if NACK Exists */
- hdrInfo.len = KW_E1_LEN;
+ hdrInfo.len = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e1 = (U8)hdrInfo.val;
- KWDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: ACK SN = %d \n", pStaPdu->ackSn);
+ RLCDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: ACK SN = %d \n", pStaPdu->ackSn);
/* Extract the Reserved Bits after ACK SN field */
hdrInfo.len = resrvdBitsAckSn;
/* If NACK exists in control PDU */
/* For ACKs and NACKs */
- while (e1 && (pStaPdu->nackCnt < KW_MAX_NACK_CNT))
+ while (e1 && (pStaPdu->nackCnt < RLC_MAX_NACK_CNT))
{
hdrInfo.len = snLen;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].sn = hdrInfo.val;
- hdrInfo.len = KW_E1_LEN;
+ hdrInfo.len = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e1 = (U8)hdrInfo.val;
/* Extract e2 */
- /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is
+ /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
/* e2 = (U8) hdrInfo.val;*/
pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val;
/* Extract e3 : 5GNR */
- /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is
+ /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e3 = (U8) hdrInfo.val;
/* Test for resegmentation */
if (pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment)
{
- hdrInfo.len = KW_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
+ hdrInfo.len = RLC_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = hdrInfo.val;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd = hdrInfo.val;
- KWDBGP_DETAIL(gCb,
+ RLCDBGP_DETAIL(gCb,
"rgAmmUlHndlStatusPdu: soStart and soEnd = %d %d \n",
pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd);
if (e3)
{
/* Extract NACK range field */
- hdrInfo.len = KW_NACK_RANGE_LEN;
+ hdrInfo.len = RLC_NACK_RANGE_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
snRange = (U8)hdrInfo.val;
/* In case we have reached the MAX NACK CNT, then we should modify the ACK_SN
to the last NACK SN + 1 and discard the original ACK_SN*/
- if(pStaPdu->nackCnt == KW_MAX_NACK_CNT)
+ if(pStaPdu->nackCnt == RLC_MAX_NACK_CNT)
{
- pStaPdu->ackSn = (pStaPdu->nackInfo[KW_MAX_NACK_CNT-1].sn + 1) & amDl->snModMask;
+ pStaPdu->ackSn = (pStaPdu->nackInfo[RLC_MAX_NACK_CNT-1].sn + 1) & amDl->snModMask;
}
RETVOID;
}
-PUBLIC S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId,
+S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu)
{
RlcDlRbCb *rbCb = NULLP;
gCb = RLC_GET_RLCCB(1); /* DL RLC instance */
- if( ROK != kwDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb)))
+ if( ROK != rlcDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb)))
{
printf("\n RLC UECb Not found...\n");
return RFAILED;
return RFAILED;
}
- if(KW_CNTRL_PDU == ((fByte & KW_DC_POS) >> KW_DC_SHT))
+ if(RLC_CNTRL_PDU == ((fByte & RLC_DC_POS) >> RLC_DC_SHT))
{
SRemPreMsg(&temp, rlcSdu);
dlRlcPst.selector = 1;/* LWLC*/
/** @file gp_amm_ul.c
@brief RLC Acknowledged Mode Uplink Module
**/
-#define KW_MODULE (KW_DBGMASK_AM | KW_DBGMASK_UL) /* for debugging purpose */
+#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_UL) /* for debugging purpose */
/* private function declarations */
-PRIVATE Void kwAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
+PRIVATE Void rlcAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
-PRIVATE S16 kwAmmExtractHdr ARGS ((RlcCb *gCb,
+PRIVATE S16 rlcAmmExtractHdr ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
- KwAmHdr *amHdr,
+ RlcAmHdr *amHdr,
U8 *fByte));
-PRIVATE Bool kwAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
+PRIVATE Bool rlcAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
Buffer *pdu,
RlcUlRbCb *rbCb,
- KwAmHdr *amHdr));
+ RlcAmHdr *amHdr));
-PRIVATE Void kwAmmTriggerStatus ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmTriggerStatus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwSn sn,
+ RlcSn sn,
Bool discFlg));
-PRIVATE S16 kwAmmUlReassembleSdus ARGS ((RlcCb *gCb,
+PRIVATE S16 rlcAmmUlReassembleSdus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwAmRecBuf *recBuf));
+ RlcAmRecBuf *recBuf));
-PRIVATE Void kwAmmProcPduOrSeg ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmProcPduOrSeg ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwAmHdr *amHdr,
+ RlcAmHdr *amHdr,
Buffer *pdu));
-PRIVATE Void kwAmmUpdExpByteSeg ARGS ((RlcCb *gCb,KwAmUl *amUl, KwSeg* newSeg));
+PRIVATE Void rlcAmmUpdExpByteSeg ARGS ((RlcCb *gCb,RlcAmUl *amUl, RlcSeg* newSeg));
-PRIVATE Void kwAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, KwExtHdr *hdrInfo));
+PRIVATE Void rlcAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo));
-PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *cntrlPdu,
U8 *fByte));
AM Module contains the following funcitons:
- - kwAmmProcessSdus
- - kwAmmUlAssembleCntrlInfo
- - kwResegRetxPdus
- - kwAssembleSdus
+ - rlcAmmProcessSdus
+ - rlcAmmUlAssembleCntrlInfo
+ - rlcResegRetxPdus
+ - rlcAssembleSdus
- kwChkandSetPoll
- - kwAmmProcessPdus
- - kwAmmUlHndlStatusPdu
- - kwAmmTriggerStatus
- - kwAmmUlReassembleSdus
+ - rlcAmmProcessPdus
+ - rlcAmmUlHndlStatusPdu
+ - rlcAmmTriggerStatus
+ - rlcAmmUlReassembleSdus
*******************************************************************************/
/** @addtogroup ammode */
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmUlSetNackInfo
+PRIVATE S16 rlcAmmUlSetNackInfo
(
RlcUlRbCb *rbCb,
-KwSn sn,
+RlcSn sn,
Bool isSegment,
U16 soStart,
U16 soEnd,
-KwUdxDlStaPdu *statusPdu,
-KwSn *prevNackSn
+RlcUdxDlStaPdu *statusPdu,
+RlcSn *prevNackSn
)
#else
-PRIVATE S16 kwAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn)
+PRIVATE S16 rlcAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn)
RlcUlRbCb *rbCb;
-KwSn sn;
+RlcSn sn;
Bool isSegment;
U16 soStart;
U16 soEnd;
-KwUdxDlStaPdu *statusPdu,
-KwSn *prevNackSn;
+RlcUdxDlStaPdu *statusPdu,
+RlcSn *prevNackSn;
#endif
{
- KwNackInfo *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount);
+ RlcNackInfo *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount);
S16 sizeToBeEncd = 0; /* Status PDu size to be encoded */
- TRC2(kwAmmUlSetNackInfo)
+ TRC2(rlcAmmUlSetNackInfo)
/* In following cases we should increment the nackCnt & fill new NACK_SN info:
* 1) First NACK_SN of the statusdPdu
*/
if((*prevNackSn == 0xffffffff) || ((((*prevNackSn) + 1) & AMUL.snModMask) != sn) ||
(((*prevNackSn) == sn) && (((nackInfo->soEnd + 1) != soStart))) ||
- ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != KW_ALL_BYTES_MISSING)))
+ ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != RLC_ALL_BYTES_MISSING)))
{
if(nackInfo->nackRange)
{
if(isSegment)
{
- sizeToBeEncd += ((AMUL.snLen == KW_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
+ sizeToBeEncd += ((AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
}
else
{
- sizeToBeEncd += ((AMUL.snLen == KW_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */
+ sizeToBeEncd += ((AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */
}
}
else
}
else if(nackInfo->isSegment)
{
- nackInfo->soEnd = KW_ALL_BYTES_MISSING;
+ nackInfo->soEnd = RLC_ALL_BYTES_MISSING;
}
else
{
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmUlAssembleCntrlInfo
+PRIVATE Void rlcAmmUlAssembleCntrlInfo
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PRIVATE Void kwAmmUlAssembleCntrlInfo(gCb, rbCb)
+PRIVATE Void rlcAmmUlAssembleCntrlInfo(gCb, rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwUdxDlStaPdu *pStatusPdu;
- KwNackInfo *nackInfo;
- KwSn sn; /* sequence number */
- KwSn mSn; /* Mod val of sequence number */
- KwSn rxHighestStatus; /* Mod val of rxHighestStatus */
- KwSeg *seg; /* pdu segment */
+ RlcUdxDlStaPdu *pStatusPdu;
+ RlcNackInfo *nackInfo;
+ RlcSn sn; /* sequence number */
+ RlcSn mSn; /* Mod val of sequence number */
+ RlcSn rxHighestStatus; /* Mod val of rxHighestStatus */
+ RlcSeg *seg; /* pdu segment */
U16 nackCnt = 0; /* Index for staPdu */
U16 seqSo; /* segmment offset */
- KwUdxUlSapCb *sapCb;
+ RlcUdxUlSapCb *sapCb;
U16 staPduEncSize = 3; /* size that would be of the encoded
STATUS PDU, it is in bits; 15 for
first fixed part of STATUS PDU */
- KwAmRecBuf *recBuf = NULLP;
- KwSn prevNackSn = 0xffffffff;
+ RlcAmRecBuf *recBuf = NULLP;
+ RlcSn prevNackSn = 0xffffffff;
- TRC2(kwAmmUlAssembleCntrlInfo)
+ TRC2(rlcAmmUlAssembleCntrlInfo)
- sapCb = KW_GET_UDX_SAP(gCb);
+ sapCb = RLC_GET_UDX_SAP(gCb);
RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
/* Memory allocation failure can not be expected */
MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
MODAMR(AMUL.rxHighestStatus, rxHighestStatus, AMUL.rxNext, AMUL.snModMask);
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
while (mSn < rxHighestStatus )
{
/* For missing PDUs */
- if ((NULLP == recBuf) && nackCnt < KW_MAX_NACK_CNT )
+ if ((NULLP == recBuf) && nackCnt < RLC_MAX_NACK_CNT )
{
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
"Missing PDU's SN = %d UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- staPduEncSize += kwAmmUlSetNackInfo(rbCb,
+ staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
sn,
FALSE, /* isSegment */
0, /* SOStart */
with soStart and soEnd info to staPdu */
seqSo = 0;
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
- while (seg != NULLP && nackCnt < KW_MAX_NACK_CNT)
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ while (seg != NULLP && nackCnt < RLC_MAX_NACK_CNT)
{
/* For missing byte segments */
if (seg->amHdr.so != seqSo)
{
- staPduEncSize += kwAmmUlSetNackInfo(rbCb,
+ staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
sn,
TRUE,
seqSo,
}
seqSo = seg->soEnd + 1;
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
}
/* Check if the last segment is missing */
- KW_LLIST_LAST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_LAST_SEG(recBuf->segLst, seg);
if ((seg != NULLP) &&
- (seg->amHdr.si != KW_SI_LAST_SEG && nackCnt < KW_MAX_NACK_CNT))
+ (seg->amHdr.si != RLC_SI_LAST_SEG && nackCnt < RLC_MAX_NACK_CNT))
{
- staPduEncSize += kwAmmUlSetNackInfo(rbCb,
+ staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
sn,
TRUE,
seqSo,
- KW_ALL_BYTES_MISSING,
+ RLC_ALL_BYTES_MISSING,
pStatusPdu,
&prevNackSn);
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlAssembleCntrlInfo: Missing (last) byte "
+ "rlcAmmUlAssembleCntrlInfo: Missing (last) byte "
"segment's SN:%d UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
"soStart and soEnd = %d, %d UEID:%d CELLID:%d",
seqSo,
- KW_ALL_BYTES_MISSING,
+ RLC_ALL_BYTES_MISSING,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
/* Get the received Buffer the updated/next SN */
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
/* Find the next missing sequence number if nackCnt reaches maximum and
still Reordering window has some missing AMDPDUs / AMDPDU segments. The
next missing sequence number will be considered as the ack sequnece
number in the status pdu.*/
- if((nackCnt == KW_MAX_NACK_CNT) &&
+ if((nackCnt == RLC_MAX_NACK_CNT) &&
((recBuf == NULLP) ||
((recBuf->pdu == NULLP) &&
(recBuf->segLst.count > 0))))
}
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
+ "rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d",
pStatusPdu->ackSn,
rbCb->rlcId.ueId,
RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
}
RETVOID;
#endif
#ifdef T2K_TRIGGER_RLC_REEST
-PUBLIC U32 drpRlcDrbPack;
+U32 drpRlcDrbPack;
#endif
/**
* @brief Handler to process the PDUs received from MAC and send it to PDCP
*/
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC Void kwAmmProcessPdus
+Void rlcAmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
U32 ttiCnt
)
#else
-PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo)
+Void rlcAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo)
RlcCb *gCb;
RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
#endif
#else
#ifdef ANSI
-PUBLIC Void kwAmmProcessPdus
+Void rlcAmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo
)
#else
-PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo)
+Void rlcAmmProcessPdus(gCb, rbCb, pduInfo)
RlcCb *gCb;
RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
#endif
{
Buffer *pdu;
- KwAmUl *amUl;
- KwAmHdr amHdr;
+ RlcAmUl *amUl;
+ RlcAmHdr amHdr;
U8 numPdu = 0;
U8 numPduToProcess;
- KwSn sn;
- KwSn tSn;
- KwSn mSn;
+ RlcSn sn;
+ RlcSn tSn;
+ RlcSn mSn;
U8 fByte;
Bool discFlg;
#ifdef LTE_L2_MEAS_RLC
MsgLen rlcSduSz; /*Holds length of Rlc Sdu*/
#endif /* LTE_L2_MEAS */
- TRC2(kwAmmProcessPdus)
+ TRC2(rlcAmmProcessPdus)
amUl = &AMUL;
- numPduToProcess = KW_MIN(pduInfo->numPdu, RGU_MAX_PDU);
+ numPduToProcess = RLC_MIN(pduInfo->numPdu, RGU_MAX_PDU);
RLOG_ARG4(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
"numPdu[%ld],numPduToProcess[%ld] UEID:%ld CELLID:%ld",
numPdu,
#endif
#endif
/* Extract AM PDU/SEG header Info */
- KW_MEM_ZERO(&amHdr, sizeof(KwAmHdr));
+ RLC_MEM_ZERO(&amHdr, sizeof(RlcAmHdr));
/* Avoided the allocation of amHdr and sending
a single pointer */
- if (kwAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK)
+ if (rlcAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK)
{
RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
"Header Extraction Failed UEID:%d CELLID:%d",
/* Check if its a control PDU */
if (amHdr.dc == 0)
{
- kwAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
+ rlcAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
RLC_FREE_BUF(pdu);
continue;
}
- if((amHdr.si == KW_SI_LAST_SEG) && (!amHdr.so))
+ if((amHdr.si == RLC_SI_LAST_SEG) && (!amHdr.so))
{
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Dropping PDU because SO can't be zero for last segment sn:%u "
+ "rlcAmmProcessPdus: Dropping PDU because SO can't be zero for last segment sn:%u "
"UEID:%d CELLID:%d",
amHdr.sn,
rbCb->rlcId.ueId,
#endif
/* Reordering data PDU */
sn = amHdr.sn;
- if (kwAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE)
+ if (rlcAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE)
{
- KwAmRecBuf *recBuf;
+ RlcAmRecBuf *recBuf;
Bool tmrRunning;
- KwSn tVrMr;
- KwSn mrxNextHighestRcvd;
+ RlcSn tVrMr;
+ RlcSn mrxNextHighestRcvd;
#ifdef LTE_L2_MEAS
- kwUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt);
+ rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt);
#endif /* LTE_L2_MEAS */
/* Update rxNextHighestRcvd */
amUl->rxNextHighestRcvd = ((sn + 1) & (amUl->snModMask));
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
+ "rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
amUl->rxNextHighestRcvd,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
if ((NULLP != recBuf) && ( recBuf->allRcvd))
{
/* deliver the reassembled RLC SDU to upper layer,
But not removed from the table */
- kwAmmUlReassembleSdus(gCb, rbCb, recBuf);
+ rlcAmmUlReassembleSdus(gCb, rbCb, recBuf);
recBuf->isDelvUpperLayer = TRUE;
MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
{
tSn = (sn + 1) & (amUl->snModMask) ; /* MOD (2 Pwr SN LEN- 1) */
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
/* Scan through till the upper edge of the window */
MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask);
while (mSn <= tVrMr)
if ((NULLP == recBuf) || (!recBuf->allRcvd))
{
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Updated rxHighestStatus:%d "
+ "rlcAmmProcessPdus: Updated rxHighestStatus:%d "
"UEID:%d CELLID:%d",
tSn,
rbCb->rlcId.ueId,
break;
}
tSn = (tSn + 1) & (amUl->snModMask); /* MOD (2 Pwr SN LEN- 1) */
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
mSn++;
}
}
if (sn == amUl->rxNext)
{
tSn = sn;
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask);
/* Scan through till the upper edge of the window */
while (mSn <= tVrMr)
/* RecBuf should remove from table
since PDU is already sent to upper layer */
recBuf->isDelvUpperLayer = FALSE;
- kwUtlDelRecBuf(amUl->recBufLst, recBuf, gCb);
+ rlcUtlDelRecBuf(amUl->recBufLst, recBuf, gCb);
}
else
{
amUl->rxNext = tSn;
- amUl->vrMr = (amUl->rxNext + (KW_AM_GET_WIN_SZ(amUl->snLen))) & (amUl->snModMask);
+ amUl->vrMr = (amUl->rxNext + (RLC_AM_GET_WIN_SZ(amUl->snLen))) & (amUl->snModMask);
break;
}
tSn = (tSn + 1) & (amUl->snModMask);
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
mSn++;
}
}
}
/* Check if reOrdTmr is running and update rxNextStatusTrig accordingly */
- tmrRunning = kwChkTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
if (tmrRunning)
{
- Bool snInWin = KW_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl);
+ Bool snInWin = RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl);
if ( (amUl->rxNextStatusTrig == amUl->rxNext) || ( (!snInWin) &&
(amUl->rxNextStatusTrig != amUl->vrMr) ) )
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
tmrRunning = FALSE;
}
}
{
if (amUl->rxNextHighestRcvd > amUl->rxNext)
{
- kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Updated rxNextStatusTrig = %d UEID:%d CELLID:%d",
+ "rlcAmmProcessPdus: Updated rxNextStatusTrig = %d UEID:%d CELLID:%d",
amUl->rxNextStatusTrig,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
if (amHdr.p)
{
- kwAmmTriggerStatus(gCb,rbCb, sn, discFlg);
+ rlcAmmTriggerStatus(gCb,rbCb, sn, discFlg);
}
}
#ifdef LTE_L2_MEAS
- kwUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
+ rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
#endif /* LTE_L2_MEAS */
gCb->genSts.pdusRecv += pduInfo->numPdu;
if (amUl->gatherStaPduInfo)
{
- kwAmmUlAssembleCntrlInfo(gCb,rbCb);
+ rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
}
RETVOID;
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmExtractHdr
+PRIVATE S16 rlcAmmExtractHdr
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
U8 *fByte
)
#else
-PRIVATE S16 kwAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte)
+PRIVATE S16 rlcAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *pdu;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
U8 *fByte;
#endif
{
U8 snByte;
- KwSn sn = 0;
+ RlcSn sn = 0;
MsgLen pduSz;
- KwExtHdr hdrInfo;
+ RlcExtHdr hdrInfo;
- TRC2(kwAmmExtractHdr)
+ TRC2(rlcAmmExtractHdr)
- KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr));
+ RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract fixed part of the header */
SFndLenMsg(pdu,&pduSz);
SRemPreMsg(fByte, pdu);
- amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT;
- if (KW_CNTRL_PDU == amHdr->dc)
+ amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
+ if (RLC_CNTRL_PDU == amHdr->dc)
{
//printf ("++++++++++++ 5GNRLOG HDR extracted CTRL : \n");
return ROK;
}
- amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT;
+ amHdr->p = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT;
- amHdr->si = (*fByte & KW_SI_POS) >> KW_SI_SHT;
+ amHdr->si = (*fByte & RLC_SI_POS) >> RLC_SI_SHT;
/* 12 BIT SN */
- if (rbCb->m.amUl.snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
SRemPreMsg(&snByte, pdu);
- sn = (KwSn)(((*fByte & KW_SN_POS_12BIT) << KW_BYTE_LEN ) | snByte);
+ sn = (RlcSn)(((*fByte & RLC_SN_POS_12BIT) << RLC_BYTE_LEN ) | snByte);
amHdr->sn = sn;
}
- else if (rbCb->m.amUl.snLen == KW_AM_CFG_18BIT_SN_LEN)
+ else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
{
SRemPreMsg(&snByte, pdu);
- sn = (KwSn)(((*fByte & KW_SN_POS_18BIT) << KW_BYTE_LEN ) | snByte);
+ sn = (RlcSn)(((*fByte & RLC_SN_POS_18BIT) << RLC_BYTE_LEN ) | snByte);
SRemPreMsg(&snByte, pdu);
- sn = ((sn << KW_BYTE_LEN) | snByte);
+ sn = ((sn << RLC_BYTE_LEN) | snByte);
amHdr->sn = sn;
}
if ((amHdr->si != 0) && (amHdr->si != 0x01))
{
- hdrInfo.len = KW_SO_LEN_5GNR;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_SO_LEN_5GNR;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
amHdr->so = hdrInfo.val;
pduSz -= 2;
}
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmExtractHdrOld
+PRIVATE S16 rlcAmmExtractHdrOld
(
RlcCb *gCb,
Buffer *pdu,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
U8 *fByte
)
#else
-PRIVATE S16 kwAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
+PRIVATE S16 rlcAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
RlcCb *gCb;
Buffer *pdu;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
U8 *fByte;
#endif
{
U16 sn;
MsgLen pduSz;
MsgLen totalSz = 0;
- KwExtHdr hdrInfo;
+ RlcExtHdr hdrInfo;
- TRC2(kwAmmExtractHdrOld)
+ TRC2(rlcAmmExtractHdrOld)
- KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr));
+ RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract fixed part of the header */
SFndLenMsg(pdu,&pduSz);
SRemPreMsg(fByte, pdu);
- amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT;
- if (KW_CNTRL_PDU == amHdr->dc)
+ amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
+ if (RLC_CNTRL_PDU == amHdr->dc)
{
return ROK;
}
/* kw002.201 : Changed the extraction of hdr elements to avoid */
/* function calls */
- amHdr->rf = (*fByte & KW_RF_POS) >> KW_RF_SHT;
- amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT;
- amHdr->fi = (*fByte & KW_FI_POS) >> KW_FI_SHT;
- e = amHdr->e = (*fByte & KW_E_POS)>> KW_E_SHT;
-
+ amHdr->rf = (*fByte & RLC_RF_POS) >> RLC_RF_SHT;
+ amHdr->p = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT;
+ amHdr->fi = (*fByte & RLC_FI_POS) >> RLC_FI_SHT;
+ e = amHdr->e = (*fByte & RLC_E_POS)>> RLC_E_SHT;
+
SRemPreMsg(&snByte, pdu);
- sn = (U16)(((*fByte & KW_SN_POS) << KW_BYTE_LEN ) | snByte);
+ sn = (U16)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
amHdr->sn = sn;
if (amHdr->rf == 1)
{
/* Extract extn part of the header */
- hdrInfo.len = KW_LSF_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_LSF_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
amHdr->lsf = (U8)hdrInfo.val;
- hdrInfo.len = KW_SO_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_SO_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
amHdr->so = hdrInfo.val;
pduSz -= 2;
}
amHdr->numLi = 0;
/* Extract LIs */
- while (e && (amHdr->numLi < KW_MAX_UL_LI))
+ while (e && (amHdr->numLi < RLC_MAX_UL_LI))
{
- hdrInfo.len = KW_E_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_E_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
e = amHdr->e = (U8)hdrInfo.val;
/* Extract LI value*/
- hdrInfo.len = KW_LI_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_LI_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
/* li = hdrInfo.val;*/
/* check if LI is zero */
totalSz += hdrInfo.val; /* incrment the size by LI value */
}
- /*ccpu00122597:PDU is dropped if liCnt exceeds KW_MAX_LI*/
- if(e && (amHdr->numLi >= KW_MAX_UL_LI))
+ /*ccpu00122597:PDU is dropped if liCnt exceeds RLC_MAX_LI*/
+ if(e && (amHdr->numLi >= RLC_MAX_UL_LI))
{
RLOG2(L_ERROR,"LI Count [%u] exceeds Max LI Count[%u]",
- amHdr->numLi, KW_MAX_UL_LI);
+ amHdr->numLi, RLC_MAX_UL_LI);
return RFAILED;
}
* @brief Private handler to process the status PDU
*
* @details
- * Private handler invokded by kwAmmProcessPdus to process the
+ * Private handler invokded by rlcAmmProcessPdus to process the
* control PDU (status report) received from its peer RLC entity.
*
* - Decode the values from the received control pdu
- * - Create a KwUdxStaPdu structure, copy the values onto it and
+ * - Create a RlcUdxStaPdu structure, copy the values onto it and
* send it to the DL instance for further processing
*
* @param[in] gCb RLC instance control block
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmUlHndlStatusPdu
+PRIVATE Void rlcAmmUlHndlStatusPdu
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
U8 *fByte
)
#else
-PRIVATE Void kwAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte)
+PRIVATE Void rlcAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *cntrlPdu;
#endif
{
U8 e1;
- KwExtHdr hdrInfo;
- KwUdxStaPdu *pStaPdu;
- KwUdxUlSapCb *sapCb;
+ RlcExtHdr hdrInfo;
+ RlcUdxStaPdu *pStaPdu;
+ RlcUdxUlSapCb *sapCb;
U8 e3; /* NACK RANGE : 5GNR */
U32 snLen;
U32 snRange;
U32 resrvdBitsAckSn=0;
U32 resrvdBitsNackSn=0;
- TRC2(kwAmmUlHndlStatusPdu)
+ TRC2(rlcAmmUlHndlStatusPdu)
- KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr));
+ RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract the Control PDU */
hdrInfo.hdr = (*fByte << 1);
RETVOID;
}
- sapCb = KW_GET_UDX_SAP(gCb);
+ sapCb = RLC_GET_UDX_SAP(gCb);
RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStaPdu,
- sizeof(KwUdxStaPdu));
+ sizeof(RlcUdxStaPdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
/* Memory allocation failure can not be expected */
}
#endif
- if (rbCb->m.amUl.snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
snLen = 12;
- resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_12BITS;
- resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_12BITS;
+ resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_12BITS;
+ resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_12BITS;
}
- else if (rbCb->m.amUl.snLen == KW_AM_CFG_18BIT_SN_LEN)
+ else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
{
snLen = 18;
- resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_18BITS;
- resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_18BITS;
+ resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_18BITS;
+ resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_18BITS;
}
else
{
- snLen = KW_SN_LEN;
+ snLen = RLC_SN_LEN;
resrvdBitsAckSn = 0;
resrvdBitsAckSn = 0;
}
pStaPdu->nackCnt = 0;
/* For CPT */
- hdrInfo.hdr = hdrInfo.hdr << KW_CPT_LEN;
+ hdrInfo.hdr = hdrInfo.hdr << RLC_CPT_LEN;
/* ACK Sn */
hdrInfo.len = snLen;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->ackSn = hdrInfo.val;
//printf ("++++++++++++ 5GNRLOG HNDL STATUS acksn %d : \n", pStaPdu->ackSn);
/* Check if NACK Exists */
- hdrInfo.len = KW_E1_LEN;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_E1_LEN;
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e1 = (U8)hdrInfo.val;
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
+ "rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
pStaPdu->ackSn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
/* Extract the Reserved Bits after ACK SN field */
hdrInfo.len = resrvdBitsAckSn;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
/* If NACK exists in control PDU */
/* For ACKs and NACKs */
- while (e1 && (pStaPdu->nackCnt < KW_MAX_NACK_CNT))
+ while (e1 && (pStaPdu->nackCnt < RLC_MAX_NACK_CNT))
{
hdrInfo.len = snLen;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].sn = hdrInfo.val;
- hdrInfo.len = KW_E1_LEN;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_E1_LEN;
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e1 = (U8)hdrInfo.val;
/* Extract e2 */
- /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is
+ /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
/* e2 = (U8) hdrInfo.val;*/
/* Store e2 value */
pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val;
/* Extract e3 : 5GNR */
- /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is
+ /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e3 = (U8) hdrInfo.val;
/* Extract Reserved Bits after NACK SN */
hdrInfo.len = resrvdBitsNackSn;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
/* Test for resegmentation */
if (pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment)
{
- hdrInfo.len = KW_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = hdrInfo.val;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd = hdrInfo.val;
RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
+ "rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
"UEID:%d CELLID:%d",
pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd,
if (e3)
{
/* Extract NACK range field */
- hdrInfo.len = KW_NACK_RANGE_LEN;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_NACK_RANGE_LEN;
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
snRange = (U8)hdrInfo.val;
pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
/* In case we have reached the MAX NACK CNT, then we should modify the ACK_SN
to the last NACK SN + 1 and discard the original ACK_SN*/
- if(pStaPdu->nackCnt == KW_MAX_NACK_CNT)
+ if(pStaPdu->nackCnt == RLC_MAX_NACK_CNT)
{
- pStaPdu->ackSn = (pStaPdu->nackInfo[KW_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask);
+ pStaPdu->ackSn = (pStaPdu->nackInfo[RLC_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask);
}
* @brief Private handler to release all stored segments
*
* @details
- * Private handler invokded by kwAmmUlPlacePduInRecBuf to release the
+ * Private handler invokded by rlcAmmUlPlacePduInRecBuf to release the
* stored segements in case a complete PDU is received later.
*
* @param[in] gCb RLC instance control block
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmUlRlsAllSegs
+PRIVATE Void rlcAmmUlRlsAllSegs
(
RlcCb *gCb,
-KwAmRecBuf *recBuf
+RlcAmRecBuf *recBuf
)
#else
-PRIVATE Void kwAmmUlRlsAllSegs(gCb,recBuf)
+PRIVATE Void rlcAmmUlRlsAllSegs(gCb,recBuf)
RlcCb *gCb;
-KwAmRecBuf *recBuf;
+RlcAmRecBuf *recBuf;
#endif
{
- KwSeg *seg;
+ RlcSeg *seg;
- TRC2(kwAmmUlRlsAllSegs)
+ TRC2(rlcAmmUlRlsAllSegs)
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
while (seg != NULLP)
{
RLC_FREE_BUF_WC(seg->seg);
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- RLC_FREE_WC(gCb,seg, sizeof(KwSeg));
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_FREE_WC(gCb,seg, sizeof(RlcSeg));
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
RETVOID;
* @brief Private handler to store the received segment
*
* @details
- * Private handler invokded by kwAmmUlPlacePduInRecBuf to add a received
+ * Private handler invokded by rlcAmmUlPlacePduInRecBuf to add a received
* segment in reception buffer of a RBCB.
* - It is responsible for detecting duplicate segments
* - Adding it at appropriate position in the received buffer
* -#FALSE Possibly a duplicate segment
*/
#ifdef ANSI
-PRIVATE Bool kwAmmAddRcvdSeg
+PRIVATE Bool rlcAmmAddRcvdSeg
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
Buffer *pdu,
U16 pduSz
)
#else
-PRIVATE Bool kwAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz)
+PRIVATE Bool rlcAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
Buffer *pdu;
U16 pduSz;
#endif
{
- KwAmRecBuf *recBuf = NULLP;
- KwSeg *seg;
- KwSeg *tseg;
+ RlcAmRecBuf *recBuf = NULLP;
+ RlcSeg *seg;
+ RlcSeg *tseg;
U16 soEnd; /* Holds the SoEnd of received segment */
U16 expSo = 0; /* Expected SO */
- TRC2(kwAmmAddRcvdSeg)
+ TRC2(rlcAmmAddRcvdSeg)
soEnd = amHdr->so + pduSz - 1;
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, amHdr->sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, amHdr->sn);
if (NULLP == recBuf)
{
- RLC_ALLOC(gCb,recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb,recBuf, sizeof(RlcAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
- kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
+ rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
}
else
{
recBuf->isDelvUpperLayer = FALSE;
/* kw003.201 - Move past the segments that are different than the */
/* one received. */
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
while ((seg != NULLP) && (seg->amHdr.so < amHdr->so))
{
expSo = seg->amHdr.so + seg->segSz;
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
}
/* The received segment should start after the end of previous seg */
/* If we have come this far, we have to add this segment to the */
/* reception buffer as we either have eliminated duplicates or */
/* have found none. */
- RLC_ALLOC_WC(gCb,tseg, sizeof(KwSeg));
+ RLC_ALLOC_WC(gCb,tseg, sizeof(RlcSeg));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tseg == NULLP)
{
tseg->seg = pdu;
tseg->segSz = pduSz;
- KW_MEM_CPY(&tseg->amHdr, amHdr, sizeof(KwAmHdr));
+ RLC_MEM_CPY(&tseg->amHdr, amHdr, sizeof(RlcAmHdr));
recBuf->amHdr.si = amHdr->si;
recBuf->amHdr.sn = amHdr->sn;
tseg->soEnd = soEnd;
cmLListInsCrnt(&recBuf->segLst, &tseg->lstEnt);
}
tseg->lstEnt.node = (PTR)tseg;
- kwAmmUpdExpByteSeg(gCb,&AMUL,tseg);
+ rlcAmmUpdExpByteSeg(gCb,&AMUL,tseg);
return (TRUE);
}
*
*/
#ifdef ANSI
-PRIVATE Bool kwAmmUlPlacePduInRecBuf
+PRIVATE Bool rlcAmmUlPlacePduInRecBuf
(
RlcCb *gCb,
Buffer *pdu,
RlcUlRbCb *rbCb,
-KwAmHdr *amHdr
+RlcAmHdr *amHdr
)
#else
-PRIVATE Bool kwAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr)
+PRIVATE Bool rlcAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr)
RlcCb *gCb;
Buffer *pdu;
RlcUlRbCb *rbCb;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
#endif
{
- KwSn sn;
+ RlcSn sn;
MsgLen pduSz;
- KwAmUl *amUl = &(rbCb->m.amUl);
+ RlcAmUl *amUl = &(rbCb->m.amUl);
- TRC2(kwAmmUlPlacePduInRecBuf)
+ TRC2(rlcAmmUlPlacePduInRecBuf)
sn = amHdr->sn;
gCb->genSts.bytesRecv += pduSz;
gRlcStats.amRlcStats.numRlcAmCellSduBytesRx += pduSz;
- if (!KW_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
+ if (!RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
{
gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx++;
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlPlacePduInRecBuf: SN %d outside the window"
+ "rlcAmmUlPlacePduInRecBuf: SN %d outside the window"
"UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
if (amHdr->si == 0)
{
- KwAmRecBuf *recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn);
+ RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
/* We received a complete PDU. Either we already have it, in which */
/* case we just ignore the new PDU and discard it. Otherwise, */
/* store the received PDU in the reception buffer */
if (NULLP == recBuf)
{
- RLC_ALLOC(gCb, recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb, recBuf, sizeof(RlcAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
- kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
+ rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
}
else if (recBuf->allRcvd != TRUE)
{
- kwAmmUlRlsAllSegs(gCb,recBuf);
+ rlcAmmUlRlsAllSegs(gCb,recBuf);
}
else
{
recBuf->pduSz = pduSz;
recBuf->allRcvd = TRUE;
gRlcStats.amRlcStats.numRlcAmCellSduRx++;
- KW_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(KwAmHdr));
+ RLC_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(RlcAmHdr));
return (TRUE);
}
else
{
/* We received a segment. We need to add that to the existing */
/* segments, if any. */
- return (kwAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
+ return (rlcAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
}
}
* @brief Private handler to trigger status report
*
* @details
- * Private handler invokded by kwAmmProcessPdus to check if the
+ * Private handler invokded by rlcAmmProcessPdus to check if the
* status report need to be sent, and update the status trigger
* flag accordingly based on status prohibit timer.
*
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmTriggerStatus
+PRIVATE Void rlcAmmTriggerStatus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwSn sn,
+RlcSn sn,
Bool discFlg
)
#else
-PRIVATE Void kwAmmTriggerStatus(gCb,rbCb, sn, discFlg)
+PRIVATE Void rlcAmmTriggerStatus(gCb,rbCb, sn, discFlg)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwSn sn;
+RlcSn sn;
Bool discFlg;
#endif
{
Bool tmrRunning;
- KwSn tSn;
- KwSn tVrMr;
- KwSn trxHighestStatus;
- KwAmUl *amUl = &(rbCb->m.amUl);
+ RlcSn tSn;
+ RlcSn tVrMr;
+ RlcSn trxHighestStatus;
+ RlcAmUl *amUl = &(rbCb->m.amUl);
- TRC2(kwAmmTriggerStatus)
+ TRC2(rlcAmmTriggerStatus)
MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
if ((discFlg) || (tSn < trxHighestStatus) || (tSn >= tVrMr))
{
RLOG_ARG2(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
+ "rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
amUl->gatherStaPduInfo = FALSE;
/* Check if staProhTmr is running */
- tmrRunning = kwChkTmr(gCb,(PTR) rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
if (!tmrRunning)
{
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmProcPduOrSeg
+PRIVATE Void rlcAmmProcPduOrSeg
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
Buffer *pdu
)
#else
-PRIVATE Void kwAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu)
+PRIVATE Void rlcAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
Buffer *pdu;
#endif
{
- TRC2(kwAmmProcPduOrSeg)
+ TRC2(rlcAmmProcPduOrSeg)
if ((AMUL.expSn != amHdr->sn) || (AMUL.expSo != amHdr->so))
{
RLC_FREE_BUF(AMUL.partialSdu);
}
- //if (amHdr->fi & KW_FI_FIRST_SEG)
+ //if (amHdr->fi & RLC_FI_FIRST_SEG)
if (amHdr->si == 0x01)
{/* first Segment of the SDU */
if (AMUL.partialSdu != NULLP)
if (pdu != NULLP)
{
AMUL.partialSdu = NULLP;
- kwUtlSndDatInd(gCb,rbCb, pdu);
+ rlcUtlSndDatInd(gCb,rbCb, pdu);
}
RETVOID;
* @brief Private handler to reassemble SDUs
*
* @details
- * Private handler invokded by kwAmmProcessPdus with the PDU
+ * Private handler invokded by rlcAmmProcessPdus with the PDU
* from the reception buffer in sequence to reassemble SDUs and
* send it to PDCP.
*
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmUlReassembleSdus
+PRIVATE S16 rlcAmmUlReassembleSdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwAmRecBuf *recBuf
+RlcAmRecBuf *recBuf
)
#else
-PRIVATE S16 kwAmmUlReassembleSdus(gCb, rbCb, recBuf)
+PRIVATE S16 rlcAmmUlReassembleSdus(gCb, rbCb, recBuf)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwAmRecBuf *recBuf;
+RlcAmRecBuf *recBuf;
#endif
{
- KwSeg *seg;
+ RlcSeg *seg;
- TRC2(kwAmmUlReassembleSdus)
+ TRC2(rlcAmmUlReassembleSdus)
//if (recBuf->amHdr.rf == 0)
if (recBuf->amHdr.si == 0)
{
/* This is a PDU */
- kwAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu);
+ rlcAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu);
/* Assign NULLP to recBuf->pdu as this PDU is sent to PDCP */
recBuf->pdu = NULLP;
AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
else
{
/* This is a set of segments */
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
AMUL.expSn = recBuf->amHdr.sn;
AMUL.expSo = 0;
while(seg)
{
- kwAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg);
+ rlcAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg);
AMUL.expSo = seg->soEnd + 1;
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- RLC_FREE_WC(gCb, seg, sizeof(KwSeg));
+ RLC_FREE_WC(gCb, seg, sizeof(RlcSeg));
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
AMUL.expSo = 0;
*
*/
#ifdef ANSI
-PUBLIC Void kwAmmUlReEstablish
+Void rlcAmmUlReEstablish
(
RlcCb *gCb,
CmLteRlcId rlcId,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
+Void rlcAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
RlcCb *gCb;
CmLteRlcId rlcId;
Bool sendReEst;
RlcUlRbCb *rbCb;
#endif
{
- KwSn sn;
- KwSn mSn;
- KwSn mVrMr;
+ RlcSn sn;
+ RlcSn mSn;
+ RlcSn mVrMr;
#ifndef KW_PDCP
- KwKwuSapCb *kwKwSap;
+ RlcKwuSapCb *rlcKwuSap;
#endif
- KwAmRecBuf *recBuf = NULLP;
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmUlReEstablish);
+ TRC2(rlcAmmUlReEstablish);
sn = AMUL.rxNext;
/* Reassemble SDUs from PDUs with SN less than upper edge of the window */
while (mSn < mVrMr)
{
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
if (NULLP != recBuf)
{
if (recBuf->allRcvd == TRUE)
{
- kwAmmUlReassembleSdus(gCb,rbCb, recBuf);
+ rlcAmmUlReassembleSdus(gCb,rbCb, recBuf);
}
else
{
RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments*/
- kwAmmUlRlsAllSegs(gCb,recBuf);
+ rlcAmmUlRlsAllSegs(gCb,recBuf);
}
- kwUtlDelRecBuf(AMUL.recBufLst, recBuf, gCb);
+ rlcUtlDelRecBuf(AMUL.recBufLst, recBuf, gCb);
}
sn = (sn + 1) & (AMUL.snModMask); /* MOD 1024 */
MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
/* Discard remaining PDUs and bytesegments in recBuf */
/* Stop all timers and reset variables */
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
}
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_STA_PROH_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
}
AMUL.rxNext = 0;
AMUL.rxNextHighestRcvd = 0;
AMUL.rxNextStatusTrig = 0;
- rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask);
+ rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask);
AMUL.rxHighestStatus = 0;
AMUL.staTrg = FALSE;
AMUL.gatherStaPduInfo = FALSE;
{
RLC_FREE_BUF(AMUL.partialSdu);
}
- kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP;
+ rlcKwuSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
if(sendReEst)
{
- KwUiKwuReEstCmpInd(&kwKwSap->pst, kwKwSap->suId, rlcId);
+ RlcUiKwuReEstCmpInd(&rlcKwuSap->pst, rlcKwuSap->suId, rlcId);
rbCb->m.amUl.isOutOfSeq = FALSE;
}
*/
#ifdef ANSI
-PUBLIC Void kwAmmReOrdTmrExp
+Void rlcAmmReOrdTmrExp
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmReOrdTmrExp(rbCb)
+Void rlcAmmReOrdTmrExp(rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwAmUl *amUl = &(rbCb->m.amUl);
- KwSn sn;
- KwSn mSn;
- KwSn mVrMr;
- KwSn mrxHighestStatus;
- KwSn mrxNextHighestRcvd;
+ RlcAmUl *amUl = &(rbCb->m.amUl);
+ RlcSn sn;
+ RlcSn mSn;
+ RlcSn mVrMr;
+ RlcSn mrxHighestStatus;
+ RlcSn mrxNextHighestRcvd;
Bool tmrRunning = FALSE;
- KwAmRecBuf *recBuf = NULLP;
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmReOrdTmrExp);
+ TRC2(rlcAmmReOrdTmrExp);
/* Update rxHighestStatus */
MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
MODAMR(amUl->vrMr, mVrMr, amUl->rxNext, amUl->snModMask);
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
while (mSn < mVrMr)
{
amUl->gatherStaPduInfo = FALSE;
/* Check if staProhTmr is running */
- tmrRunning = kwChkTmr(gCb,(PTR) rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
if (!tmrRunning)
{
gRlcStats.amRlcStats.numULReOrdTimerExpires++;
amUl->gatherStaPduInfo = TRUE;
- kwAmmUlAssembleCntrlInfo(gCb, rbCb);
+ rlcAmmUlAssembleCntrlInfo(gCb, rbCb);
}
break;
MODAMR(amUl->rxHighestStatus, mrxHighestStatus, amUl->rxNext, amUl->snModMask);
if (mrxNextHighestRcvd > mrxHighestStatus)
{
- kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
}
RETVOID;
-} /* kwAmmReOrdTmrExp */
+} /* rlcAmmReOrdTmrExp */
/**
* @brief Handler for status prohibit timer expiry
*/
#ifdef ANSI
-PUBLIC Void kwAmmStaProTmrExp
+Void rlcAmmStaProTmrExp
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmStaProTmrExp(gCb, rbCb)
+Void rlcAmmStaProTmrExp(gCb, rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwAmUl *amUl = &(rbCb->m.amUl);
+ RlcAmUl *amUl = &(rbCb->m.amUl);
- TRC2(kwAmmStaProTmrExp);
+ TRC2(rlcAmmStaProTmrExp);
amUl->gatherStaPduInfo = FALSE;
{
amUl->gatherStaPduInfo = TRUE;
/* kw002.201 : Sending StaRsp after StaProhibit tmr expiry */
- kwAmmUlAssembleCntrlInfo(gCb,rbCb);
+ rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
}
RETVOID;
-} /* kwAmmStaProTmrExp */
+} /* rlcAmmStaProTmrExp */
/**
* @brief Handler to extract an element of AM Header
*/
#ifdef ANSI
-PRIVATE Void kwAmmExtractElmnt
+PRIVATE Void rlcAmmExtractElmnt
(
RlcCb *gCb,
Buffer *pdu,
-KwExtHdr *hdrInfo
+RlcExtHdr *hdrInfo
)
#else
-PRIVATE Void kwAmmExtractElmnt(gCb, pdu, hdrInfo)
+PRIVATE Void rlcAmmExtractElmnt(gCb, pdu, hdrInfo)
RlcCb *gCb;
Buffer *pdu;
-KwExtHdr *hdrInfo;
+RlcExtHdr *hdrInfo;
#endif
{
U8 hdr;
/* U8 rLen1 = 0; */
U16 tVal;
- TRC2(kwAmmExtractElmnt);
+ TRC2(rlcAmmExtractElmnt);
hdr = hdrInfo->hdr;
tHdr = hdr;
if (len <= 8)
{
- val = tHdr >> (KW_BYTE_LEN - (len));
+ val = tHdr >> (RLC_BYTE_LEN - (len));
hdr = hdr << len;
pLen -= len;
}
{
fLen = pLen;
val = tHdr;
- val = val >> (KW_BYTE_LEN - fLen);
+ val = val >> (RLC_BYTE_LEN - fLen);
val = val << (len - fLen);
rLen = len - fLen;
SRemPreMsg(&hdr, pdu);
tHdr = hdr;
if (rLen <= 8)
{
- hdr = hdr >> (KW_BYTE_LEN - rLen);
+ hdr = hdr >> (RLC_BYTE_LEN - rLen);
val = val | hdr;
hdr = tHdr << rLen;
- pLen = (KW_BYTE_LEN - rLen);
+ pLen = (RLC_BYTE_LEN - rLen);
}
else
{
- rLen = rLen - KW_BYTE_LEN;
+ rLen = rLen - RLC_BYTE_LEN;
tVal = hdr;
tVal = tVal << rLen;
val = val | tVal;
SRemPreMsg(&hdr, pdu);
tHdr = hdr;
- hdr = hdr >> (KW_BYTE_LEN - rLen);
+ hdr = hdr >> (RLC_BYTE_LEN - rLen);
val = val | hdr;
hdr = tHdr << rLen;
- pLen = (KW_BYTE_LEN - rLen);
+ pLen = (RLC_BYTE_LEN - rLen);
}
}
*/
#ifdef ANSI
-PRIVATE Void kwAmmUpdExpByteSeg
+PRIVATE Void rlcAmmUpdExpByteSeg
(
RlcCb *gCb,
-KwAmUl *amUl,
-KwSeg *seg
+RlcAmUl *amUl,
+RlcSeg *seg
)
#else
-PRIVATE Void kwAmmUpdExpByteSeg(gCb, amUl, seg)
+PRIVATE Void rlcAmmUpdExpByteSeg(gCb, amUl, seg)
RlcCb *gCb;
-KwAmUl *amUl;
-KwSeg *seg;
+RlcAmUl *amUl;
+RlcSeg *seg;
#endif
{
U16 newExpSo; /* The new expected SO */
- KwSn sn = seg->amHdr.sn;
+ RlcSn sn = seg->amHdr.sn;
Bool lstRcvd=FALSE;
- KwAmRecBuf *recBuf = NULLP;
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmUpdExpByteSeg);
+ TRC2(rlcAmmUpdExpByteSeg);
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
if ((recBuf == NULLP) || (recBuf && (seg->amHdr.so != recBuf->expSo)))
{
RETVOID;
lstRcvd = TRUE;
}
/* kw003.201 - This should update seg with the one after newSeg */
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
while(seg)
{
/* keep going ahead as long as the expectedSo match with the header so
newExpSo = seg->soEnd + 1;
recBuf->expSo = newExpSo;
//lstRcvd = seg->amHdr.lsf;
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
}
else
{
* @return void
*/
#ifdef ANSI
-PUBLIC Void kwAmmFreeUlRbCb
+Void rlcAmmFreeUlRbCb
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmFreeUlRbCb(gCb,rbCb)
+Void rlcAmmFreeUlRbCb(gCb,rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwSn curSn = 0; /* Sequence number of PDU */
- KwSn windSz; /* PDU window size */
- KwAmRecBuf *recBuf = NULLP;
+ RlcSn curSn = 0; /* Sequence number of PDU */
+ RlcSn windSz; /* PDU window size */
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmFreeUlRbCb)
+ TRC2(rlcAmmFreeUlRbCb)
- windSz = (KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
+ windSz = (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
}
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_STA_PROH_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
}
while( ( curSn < windSz ) hence changing to do while */
do
{
- recBuf = kwUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn);
+ recBuf = rlcUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn);
if ( recBuf != NULLP )
{
if (recBuf->pdu != NULLP)
RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments */
- kwAmmUlRlsAllSegs(gCb,recBuf);
- kwUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb);
+ rlcAmmUlRlsAllSegs(gCb,recBuf);
+ rlcUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb);
}
curSn++;
}while ( curSn < windSz );
#ifndef LTE_TDD
- RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
rbCb->m.amUl.recBufLst = NULLP;
#endif
RLC_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
}
RETVOID;
-} /* kwAmmFreeUlRbCb */
+} /* rlcAmmFreeUlRbCb */
/*@}*/
#include "kw_udx.x"
#include "kw_dl.x"
-#define KW_MODULE KW_DBGMASK_CFG
+#define RLC_MODULE RLC_DBGMASK_CFG
/*Added for adding new Ue in onging L2 Meas*/
#ifdef LTE_L2_MEAS
/**
* -# RFAILED
*
*/
-PRIVATE S16 kwHdlMeasDlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
+PRIVATE S16 rlcHdlMeasDlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
{
- KwL2MeasEvtCb *measEvtCb = NULLP;
- KwL2MeasCb *measCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasCb *measCb = NULLP;
U16 cntr;
U16 ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(gCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]);
measCb = &(measEvtCb->measCb);
* -# RFAILED
*
*/
-PRIVATE S16 kwDelFrmDlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
+PRIVATE S16 rlcDelFrmDlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
{
- KwL2MeasEvtCb *measEvtCb = NULLP;
- KwL2MeasCb *measCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasCb *measCb = NULLP;
U16 cntr;
U16 ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &gCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr];
+ measEvtCb = &gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr];
measCb = &(measEvtCb->measCb);
}
-PRIVATE S16 kwAddToDlL2Meas(RlcCb *gCb, RlcDlRbCb *kwRbCb,U8 cellId,U8 ueId)
+PRIVATE S16 rlcAddToDlL2Meas(RlcCb *gCb, RlcDlRbCb *rlcRbCb,U8 cellId,U8 ueId)
{
- KwL2MeasEvtCb *measEvtCb = NULLP;
- KwL2MeasCb *measCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasCb *measCb = NULLP;
U16 cntr;
U16 cntr1;
U16 ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &gCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr];
+ measEvtCb = &gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr];
measCb = &(measEvtCb->measCb);
freeIdx = gCb->genCfg.maxUe;
for(cntr1 =0;((cntr1 < measCb->val.nonIpThMeas.numQci) &&
(cntr1 < LKW_MAX_QCI));cntr1++)
{
- if(measCb->val.nonIpThMeas.qci[cntr1] != kwRbCb->qci)
+ if(measCb->val.nonIpThMeas.qci[cntr1] != rlcRbCb->qci)
{
- measCb->val.nonIpThMeas.qci[cntr1] = kwRbCb->qci;
- gCb->u.dlCb->kwL2Cb.measOn[kwRbCb->qci] |=measCb->measType;
+ measCb->val.nonIpThMeas.qci[cntr1] = rlcRbCb->qci;
+ gCb->u.dlCb->rlcL2Cb.measOn[rlcRbCb->qci] |=measCb->measType;
break;
}
}
}
- if(((kwRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE))
+ if(((rlcRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE))
{
if (measCb->measType & LKW_L2MEAS_ACT_UE)
{
- if((kwRbCb->mode == CM_LTE_MODE_UM) &&
- (kwRbCb->dir & KW_DIR_DL ))
+ if((rlcRbCb->mode == CM_LTE_MODE_UM) &&
+ (rlcRbCb->dir & RLC_DIR_DL ))
{
- if (kwRbCb->m.umDl.sduQ.count)
+ if (rlcRbCb->m.umDl.sduQ.count)
{
- if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
+ if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
{
- kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
- gCb->u.dlCb->kwL2Cb.numActUe[kwRbCb->qci]++;
+ rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
+ gCb->u.dlCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
}
}
}
- else if (kwRbCb->mode == CM_LTE_MODE_AM)
+ else if (rlcRbCb->mode == CM_LTE_MODE_AM)
{
- if ((kwRbCb->m.amDl.cntrlBo) ||
- (kwRbCb->m.amDl.retxBo) ||
- (kwRbCb->m.amDl.bo))
+ if ((rlcRbCb->m.amDl.cntrlBo) ||
+ (rlcRbCb->m.amDl.retxBo) ||
+ (rlcRbCb->m.amDl.bo))
{
- if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
+ if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
{
- kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
- gCb->u.dlCb->kwL2Cb.numActUe[kwRbCb->qci]++;
+ rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
+ gCb->u.dlCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
}
}
}
ueIdx = freeIdx;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE;
- cmMemset((U8 *)&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(KwL2Cntr) *LKW_MAX_QCI));
+ cmMemset((U8 *)&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;
for (qciIdx =0; ((qciIdx < *numQci) &&
(qciIdx < LKW_MAX_QCI)) ; qciIdx++)
{
- if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == kwRbCb->qci)
+ if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == rlcRbCb->qci)
{
break;
}
/* Fix Klock Warning */
if ((qciIdx == *numQci) && (qciIdx < LKW_MAX_QCI))
{
- measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = kwRbCb->qci;
+ measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = rlcRbCb->qci;
(*numQci)++;
}
- kwUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[kwRbCb->qci],
- &kwRbCb->rbL2Cb, measCb->measType);
+ rlcUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[rlcRbCb->qci],
+ &rlcRbCb->rbL2Cb, measCb->measType);
}
else if (measCb->measType &
(LKW_L2MEAS_DL_DISC | LKW_L2MEAS_DL_DELAY | LKW_L2MEAS_UU_LOSS))
{
- kwUtlPlcMeasDatInL2Sts(&measCb->val.nonIpThMeas.measData[kwRbCb->qci],
- &kwRbCb->rbL2Cb, measCb->measType);
- measCb->val.nonIpThMeas.qci[kwRbCb->qci] = kwRbCb->qci;
- measCb->val.nonIpThMeas.measData[kwRbCb->qci].totDrbsPerQci++;
+ rlcUtlPlcMeasDatInL2Sts(&measCb->val.nonIpThMeas.measData[rlcRbCb->qci],
+ &rlcRbCb->rbL2Cb, measCb->measType);
+ measCb->val.nonIpThMeas.qci[rlcRbCb->qci] = rlcRbCb->qci;
+ measCb->val.nonIpThMeas.measData[rlcRbCb->qci].totDrbsPerQci++;
}
- kwRbCb->rbL2Cb.measOn |= measCb->measType;
+ rlcRbCb->rbL2Cb.measOn |= measCb->measType;
}
return ROK;
-}/*kwAddToDlL2Meas*/
+}/*rlcAddToDlL2Meas*/
#endif /*LTE_L2_MEAS*/
\f
/**
rbCb->lch.lChType = entCfg->lCh[0].type;
rbCb->dir = entCfg->dir;
rbCb->m.umDl.snLen = entCfg->m.umInfo.dl.snLen;
- if (entCfg->m.umInfo.dl.snLen == KW_UM_CFG_5BIT_SN_LEN)
+ if (entCfg->m.umInfo.dl.snLen == RLC_UM_CFG_5BIT_SN_LEN)
rbCb->m.umDl.modBitMask = 0x1f;
else
rbCb->m.umDl.modBitMask = 0x3ff;
* indx = 0 as Down Link */
rbCb->lch.lChId = entCfg->lCh[0].lChId;
rbCb->lch.lChType = entCfg->lCh[0].type;
- rbCb->dir = KW_DIR_BOTH;
+ rbCb->dir = RLC_DIR_BOTH;
rbCb->m.amDl.pollPdu = entCfg->m.amInfo.dl.pollPdu;
rbCb->m.amDl.pollByte = entCfg->m.amInfo.dl.pollByte;
rbCb->m.amDl.maxRetx = entCfg->m.amInfo.dl.maxRetx;
rbCb->m.amDl.pollRetxTmrInt = entCfg->m.amInfo.dl.pollRetxTmr;
rbCb->m.amDl.snLen = entCfg->m.amInfo.dl.snLen;
- if(KW_AM_CFG_12BIT_SN_LEN == rbCb->m.amDl.snLen)
+ if(RLC_AM_CFG_12BIT_SN_LEN == rbCb->m.amDl.snLen)
{
- rbCb->m.amDl.snModMask = (1 << KW_SN_LEN_12BITS) - 1; /* 5GNR */
+ rbCb->m.amDl.snModMask = (1 << RLC_SN_LEN_12BITS) - 1; /* 5GNR */
}
else
{
- rbCb->m.amDl.snModMask = (1 << KW_SN_LEN_18BITS) - 1; /* 5GNR */
+ rbCb->m.amDl.snModMask = (1 << RLC_SN_LEN_18BITS) - 1; /* 5GNR */
}
cmInitTimers(&(rbCb->m.amDl.pollRetxTmr), 1);
U32 hashIndex;
RLC_ALLOC(gCb,
rbCb->m.amDl.txBufLst,
- (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
- for(hashIndex = 0; hashIndex < KW_TX_BUF_BIN_SIZE; hashIndex++)
+ (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ for(hashIndex = 0; hashIndex < RLC_TX_BUF_BIN_SIZE; hashIndex++)
{
cmLListInit(&(rbCb->m.amDl.txBufLst[hashIndex]));
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgAddDlRb
+S16 rlcCfgAddDlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 rlcCfgAddDlRb(gCb,ueId, cellId, entCfg, entCfm)
+S16 rlcCfgAddDlRb(gCb,ueId, cellId, entCfg, entCfm)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
{
RlcDlUeCb *ueCb = NULLP; /* UE Control Block */
RlcDlCellCb *cellCb; /* Cell Control Block */
- RlcDlRbCb *kwRbCb; /* KW RB Control Block */
+ RlcDlRbCb *rlcRbCb; /* KW RB Control Block */
U8 reason; /* Rb Identifier */
TRC3(rlcCfgAddDlRb)
if (cellId == 0)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
RLOG_ARG1(L_ERROR,DBG_RBID,entCfg->rbId,
"Add DLRb,CellId is 0 for UEID:%d",
}
if ((entCfg->rguSapId >= gCb->genCfg.maxRguSaps) || (entCfg->rguSapId < 0))
{
- KWDBGP_ERROR(gCb, "rlcCfgAddDlRb(ueId(%u), cellId(%u), Invalid rguSapId (%d)\n",
+ RLCDBGP_ERROR(gCb, "rlcCfgAddDlRb(ueId(%u), cellId(%u), Invalid rguSapId (%d)\n",
ueId, cellId, entCfg->rguSapId);
return RFAILED;
}
/* Process Adding new RB */
if (ueId == 0)
{
- if(entCfg->rbId >= KW_MAX_RB_PER_CELL)
+ if(entCfg->rbId >= RLC_MAX_RB_PER_CELL)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG3(L_ERROR,DBG_RBID,entCfg->rbId,
"Invalid RbId ,Max is [%d] CELLID:%d UEID:%d",
- KW_MAX_RB_PER_CELL,
+ RLC_MAX_RB_PER_CELL,
cellId,
ueId);
return RFAILED;
(entCfg->entMode == CM_LTE_MODE_TM))
{
/* Cell CB present */
- kwDbmFetchDlCellCb(gCb, cellId, &cellCb);
+ rlcDbmFetchDlCellCb(gCb, cellId, &cellCb);
if(cellCb)
{
/* Get rbCb from cellCb->rbCb List */
if (( cellCb->rbCb[entCfg->rbId] != NULLP))
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_PRSNT);
RLOG_ARG2(L_WARNING, DBG_CELLID,cellId,
else /* Cell CB UNKNOWN */
{
/* Create CELL CB */
- if ( ROK != kwDbmCreateDlCellCb(gCb,cellId, &cellCb))
+ if ( ROK != rlcDbmCreateDlCellCb(gCb,cellId, &cellCb))
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_CREAT_FAIL);
RLOG_ARG2(L_ERROR,DBG_CELLID,cellId,
ueId,
entCfg->rbId);
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_LCHID);
return RFAILED;
}
/* Create RB CB */
- RLC_ALLOC(gCb,kwRbCb, sizeof (RlcDlRbCb));
- if (!kwRbCb)
+ RLC_ALLOC(gCb,rlcRbCb, sizeof (RlcDlRbCb));
+ if (!rlcRbCb)
{
RLOG_ARG2(L_FATAL,DBG_UEID,ueId,
"Memory allocation failed for rbId:%d CELLID:%d",
entCfg->rbId,
ueId);
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_CREAT_FAIL);
return RFAILED;
}
- kwRbCb->rlcId.rbId = entCfg->rbId;
- cellCb->rbCb[entCfg->rbId] = kwRbCb;
- KW_LMM_RB_STS_INC(gCb);
- cellCb->lCh[entCfg->lCh[0].lChId - 1].dlRbCb = kwRbCb;
+ rlcRbCb->rlcId.rbId = entCfg->rbId;
+ cellCb->rbCb[entCfg->rbId] = rlcRbCb;
+ RLC_LMM_RB_STS_INC(gCb);
+ cellCb->lCh[entCfg->lCh[0].lChId - 1].dlRbCb = rlcRbCb;
}
else
{
reason= (entCfg->entMode != CM_LTE_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
CKW_CFG_REAS_LCHTYPE_MIS;
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, reason);
return RFAILED;
}
}
else
{
- if (!(KW_VALIDATE_UE_RBID(entCfg->rbType, entCfg->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(entCfg->rbType, entCfg->rbId)))
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG2(L_ERROR,DBG_RBID, entCfg->rbId,
"Invalid RbId for RbType[%d] UEID:%d",
(entCfg->entMode != CM_LTE_MODE_TM))
{
/* UE CB present */
- if ( kwDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb) == ROK)
+ if ( rlcDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb) == ROK)
{
/* Get rbCb from ueCb->rbCb list */
- KW_DBM_GET_RBCB_FROM_UECB(entCfg->rbId, entCfg->rbType, ueCb, kwRbCb);
+ RLC_DBM_GET_RBCB_FROM_UECB(entCfg->rbId, entCfg->rbType, ueCb, rlcRbCb);
- if(( kwRbCb != NULLP))
+ if(( rlcRbCb != NULLP))
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_PRSNT);
RLOG_ARG2(L_WARNING, DBG_UEID, ueId,
"CellId[%u]:rbId [%d] already exists",
else /* UE CB UNKNOWN */
{
/* Create UE CB */
- if ( kwDbmCreateDlUeCb(gCb,ueId, cellId, &ueCb) != ROK)
+ if ( rlcDbmCreateDlUeCb(gCb,ueId, cellId, &ueCb) != ROK)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_UE_CREAT_FAIL);
RLOG_ARG2(L_WARNING, DBG_CELLID,cellId,
"UeId [%u]:ueCb Creation Failed RBID:%d",
(entCfg->lCh[1].lChId <= 0)))
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_LCHID);
return RFAILED;
}
/* Create RB CB */
- RLC_ALLOC(gCb,kwRbCb, sizeof (RlcDlRbCb));
- if (kwRbCb == NULL)
+ RLC_ALLOC(gCb,rlcRbCb, sizeof (RlcDlRbCb));
+ if (rlcRbCb == NULL)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_CREAT_FAIL);
RLOG_ARG2(L_FATAL,DBG_UEID,ueId,
"Memory allocation failed RBID:%d CELLID:%d",
}
/* copy the RB Cb into UECb */
- kwRbCb->rlcId.rbId = entCfg->rbId;
+ rlcRbCb->rlcId.rbId = entCfg->rbId;
if(entCfg->rbType == CM_LTE_SRB)
- ueCb->srbCb[entCfg->rbId] = kwRbCb;
+ ueCb->srbCb[entCfg->rbId] = rlcRbCb;
else
- ueCb->drbCb[entCfg->rbId] = kwRbCb;
+ ueCb->drbCb[entCfg->rbId] = rlcRbCb;
- KW_LMM_RB_STS_INC(gCb);
+ RLC_LMM_RB_STS_INC(gCb);
}
else
}
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK, reason);
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK, reason);
return RFAILED;
}
}
- kwRbCb->rlcId.cellId = cellId;
- kwRbCb->rlcId.ueId = ueId;
- kwRbCb->rlcId.rbType = entCfg->rbType;
- kwRbCb->inst = gCb->init.inst;
+ rlcRbCb->rlcId.cellId = cellId;
+ rlcRbCb->rlcId.ueId = ueId;
+ rlcRbCb->rlcId.rbType = entCfg->rbType;
+ rlcRbCb->inst = gCb->init.inst;
#ifdef TENB_MULT_CELL_SUPPRT
- kwRbCb->rguSapId = entCfg->rguSapId;
+ rlcRbCb->rguSapId = entCfg->rguSapId;
#endif
/* Fill RB CB */
- if (rlcCfgFillDlRbCb(gCb,kwRbCb, ueCb, entCfg) != ROK)
+ if (rlcCfgFillDlRbCb(gCb,rlcRbCb, ueCb, entCfg) != ROK)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_CREAT_FAIL);
/* Delete RB CB created */
- RLC_FREE(gCb,kwRbCb, sizeof(RlcDlRbCb));
+ RLC_FREE(gCb,rlcRbCb, sizeof(RlcDlRbCb));
RLOG_ARG2(L_ERROR,DBG_RBID, entCfg->rbId,
"Filling of RbCb failed UEID:%d CELLID:%d",
ueId,
cellId);
return RFAILED;
}
- kwRbCb->qci = entCfg->qci;
+ rlcRbCb->qci = entCfg->qci;
#ifdef LTE_L2_MEAS
- kwRbCb->ueCb = ueCb;
+ rlcRbCb->ueCb = ueCb;
if (entCfg->lCh[0].type == CM_LTE_LCH_DTCH)
{
/* ccpu00129778 */
- kwAddToDlL2Meas(gCb, kwRbCb,cellId,ueId);
+ rlcAddToDlL2Meas(gCb, rlcRbCb,cellId,ueId);
}
#endif /* LTE_L2_MEAS */
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
return ROK;
}
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgReCfgDlRb
+S16 rlcCfgReCfgDlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 rlcCfgReCfgDlRb(gCb,ueId, cellId, entCfg, entCfm)
+S16 rlcCfgReCfgDlRb(gCb,ueId, cellId, entCfg, entCfm)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
/* Check for UeCb or CellCb */
if (ueId == 0)
{
- if(entCfg->rbId >= KW_MAX_RB_PER_CELL)
+ if(entCfg->rbId >= RLC_MAX_RB_PER_CELL)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG3(L_ERROR,DBG_RBID,entCfg->rbId,
"Invalid RbId , Max is [%d] UEID:%d CELLID:%d",
- KW_MAX_RB_PER_CELL,
+ RLC_MAX_RB_PER_CELL,
ueId,
cellId);
return RFAILED;
}
/* Get cellCb */
- kwDbmFetchDlCellCb(gCb,cellId, &cellCb);
+ rlcDbmFetchDlCellCb(gCb,cellId, &cellCb);
if(!cellCb)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
RLOG_ARG3(L_ERROR,DBG_CELLID,cellId,
"CellCb not found ueId:%d RBID:%d CELLID:%d",
}
/* Get rbCb */
- KW_DBM_GET_CELL_RBCB(entCfg->rbId, cellCb->rbCb, rbCb);
+ RLC_DBM_GET_CELL_RBCB(entCfg->rbId, cellCb->rbCb, rbCb);
if (!rbCb)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG2(L_ERROR,DBG_UEID,ueId,
"CELLID:%d RBID:%d not found",
if (ret != ROK)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm,
+ RLC_CFG_FILL_CFG_CFM(entCfm,
entCfg->rbId,
entCfg->rbType,
CKW_CFG_CFM_NOK,
}
else
{
- if (!(KW_VALIDATE_UE_RBID(entCfg->rbType, entCfg->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(entCfg->rbType, entCfg->rbId)))
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG3(L_ERROR,DBG_UEID,ueId,
"CELLID:%d Invalid RBID:%d for RbType[%d]",
return RFAILED;
}
/* Get ueCb */
- ret = kwDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb);
+ ret = rlcDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb);
if (ret != ROK)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
RLOG_ARG2(L_ERROR,DBG_CELLID, cellId,
"UEID:%d UeCb not found RBID:%d",
}
/* Get rbCb */
- KW_DBM_GET_RBCB_FROM_UECB(entCfg->rbId, entCfg->rbType, ueCb, rbCb);
+ RLC_DBM_GET_RBCB_FROM_UECB(entCfg->rbId, entCfg->rbType, ueCb, rbCb);
if ( rbCb == NULLP)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG2(L_ERROR, DBG_UEID,ueId,
"CELLID:%d RBID:%d not found",
if (ret != CKW_CFG_REAS_NONE)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
ret);
RLOG_ARG2(L_ERROR,DBG_UEID,ueId,
"CELLID:%d RBID:%d updation failed",
}
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
return ROK;
}
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgDelDlRb
+S16 rlcCfgDelDlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 rlcCfgDelRb(gCb,ueId, cellId, entCfg, entCfm)
+S16 rlcCfgDelRb(gCb,ueId, cellId, entCfg, entCfm)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
S16 ret; /* Return Value */
RlcDlUeCb *ueCb; /* UE Control Block */
RlcDlCellCb *cellCb; /* UE Control Block */
- RlcDlRbCb *kwRbCb; /* KW RB Control Block */
+ RlcDlRbCb *rlcRbCb; /* KW RB Control Block */
TRC3(rlcCfgDelDlRb)
/* Get cellCb and delete rbCb from it */
if (ueId == 0)
{
- if(entCfg->rbId >= KW_MAX_RB_PER_CELL)
+ if(entCfg->rbId >= RLC_MAX_RB_PER_CELL)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG3(L_ERROR,DBG_RBID,entCfg->rbId ,
"Invalid RbId, Max is [%d] UEID:%d CELLID:%d",
- KW_MAX_RB_PER_CELL,
+ RLC_MAX_RB_PER_CELL,
ueId,
cellId);
return RFAILED;
}
/* Get cellCb */
- kwDbmFetchDlCellCb(gCb,cellId, &cellCb);
+ rlcDbmFetchDlCellCb(gCb,cellId, &cellCb);
if (!cellCb)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG2(L_ERROR,DBG_CELLID,cellId,
"CellCb not found UEID:%d RBID:%d",
}
/* Get rbCb */
- KW_DBM_GET_CELL_RBCB(entCfg->rbId, cellCb->rbCb, kwRbCb);
+ RLC_DBM_GET_CELL_RBCB(entCfg->rbId, cellCb->rbCb, rlcRbCb);
- if ( kwRbCb == NULLP)
+ if ( rlcRbCb == NULLP)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG2(L_ERROR, DBG_UEID,ueId,
"CellId[%u]:RbId[%d] not found",
/* Assign NULLP to dlRbCb/ulRbCb.
* Delete Hashlist allocated for it if any */
- cellCb->lCh[kwRbCb->lch.lChId - 1].dlRbCb = NULLP;
- RLC_FREE(gCb,kwRbCb, sizeof(RlcDlRbCb)); /*Vartika: Mem leak fix */
+ cellCb->lCh[rlcRbCb->lch.lChId - 1].dlRbCb = NULLP;
+ RLC_FREE(gCb,rlcRbCb, sizeof(RlcDlRbCb)); /*Vartika: Mem leak fix */
}
/* Get ueCb and delete rbCb from it */
else
{
- if (!(KW_VALIDATE_UE_RBID(entCfg->rbType, entCfg->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(entCfg->rbType, entCfg->rbId)))
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG3(L_ERROR,DBG_RBID, entCfg->rbId,
"Invalid RbId for RbType[%d] UEID:%d CELLID:%d",
}
/* Get ueCb */
- ret = kwDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb);
+ ret = rlcDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb);
if (ret != ROK)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
RLOG_ARG2(L_ERROR,DBG_CELLID, cellId,
"UeId [%d]: UeCb not found RBID:%d",
}
/* Get rbCb */
- KW_DBM_GET_RBCB_FROM_UECB(entCfg->rbId, entCfg->rbType, ueCb, kwRbCb);
+ RLC_DBM_GET_RBCB_FROM_UECB(entCfg->rbId, entCfg->rbType, ueCb, rlcRbCb);
- if ( kwRbCb == NULLP)
+ if ( rlcRbCb == NULLP)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG2(L_ERROR, DBG_UEID,ueId,
"CellId[%u]:RbId[%d] not found",
return (ret);
}
- ueCb->lCh[kwRbCb->lch.lChId - 1].dlRbCb = NULLP;
+ ueCb->lCh[rlcRbCb->lch.lChId - 1].dlRbCb = NULLP;
#ifdef LTE_L2_MEAS
- KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, kwRbCb);
+ RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, rlcRbCb);
#endif
/* Free the Buffers of RbCb */
- if( CM_LTE_MODE_UM == kwRbCb->mode)
+ if( CM_LTE_MODE_UM == rlcRbCb->mode)
{
- kwUmmFreeDlRbCb(gCb,kwRbCb);
+ rlcUmmFreeDlRbCb(gCb,rlcRbCb);
/* Delete RbCb */
- RLC_FREE(gCb,kwRbCb, sizeof(RlcDlRbCb));
+ RLC_FREE(gCb,rlcRbCb, sizeof(RlcDlRbCb));
}
- else if( CM_LTE_MODE_AM == kwRbCb->mode)
+ else if( CM_LTE_MODE_AM == rlcRbCb->mode)
{
- kwAmmFreeDlRbCb(gCb,kwRbCb);
+ rlcAmmFreeDlRbCb(gCb,rlcRbCb);
}
/* Assign NULLP to rbCb in rbCbLst */
}
}
- KW_LMM_RB_STS_DEC(gCb);
+ RLC_LMM_RB_STS_DEC(gCb);
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK,
CKW_CFG_REAS_NONE);
return (ret);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgReEstDlRb
+S16 rlcCfgReEstDlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 rlcCfgReEstDlRb(gCb,ueId, cellId,sndReEstInd,entCfg, entCfm)
+S16 rlcCfgReEstDlRb(gCb,ueId, cellId,sndReEstInd,entCfg, entCfm)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
rlcId.rbId = entCfg->rbId;
rlcId.rbType = entCfg->rbType;
- kwDbmFetchDlRbCbByRbId(gCb,&rlcId, &rbCb);
+ rlcDbmFetchDlRbCbByRbId(gCb,&rlcId, &rbCb);
if (rbCb == NULLP)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, rlcId.rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, rlcId.rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_RB_UNKWN);
RLOG_ARG2(L_ERROR, DBG_UEID,ueId,
"CellId[%u]:RbId[%d] not found",
case CM_LTE_MODE_AM:
{
- kwAmmDlReEstablish(gCb, rlcId, rbCb);
+ rlcAmmDlReEstablish(gCb, rlcId, rbCb);
break;
}
}
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
return ROK;
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgDelDlUe
+S16 rlcCfgDelDlUe
(
RlcCb *gCb,
CmLteRnti ueId,
RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 rlcCfgDelDlUe(ueId, cellId, entCfg, entCfm)
+S16 rlcCfgDelDlUe(ueId, cellId, entCfg, entCfm)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
if ( ueId == 0 )
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
RLOG_ARG2(L_ERROR,DBG_RBID,entCfg->rbId,
"ueId(%d), cellId(%d)",
}
/* Fetch Ue Cb */
- ret = kwDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb);
+ ret = rlcDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb);
if (ret != ROK)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_UE_UNKWN);
RLOG_ARG2(L_ERROR,DBG_CELLID, cellId,
"UEID:%d UeCb not found RBID:%d",
}
#ifdef LTE_L2_MEAS
- kwDelFrmDlL2Meas(gCb,cellId,ueId);
- kwDbmDelAllDlL2MeasTbFrmUe(gCb,ueCb);
+ rlcDelFrmDlL2Meas(gCb,cellId,ueId);
+ rlcDbmDelAllDlL2MeasTbFrmUe(gCb,ueCb);
#endif
/* Delete Ue Cb */
- kwDbmDelDlUeCb(gCb,ueCb, FALSE);
+ rlcDbmDelDlUeCb(gCb,ueCb, FALSE);
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
return ROK;
* -#RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgDelDlCell
+S16 rlcCfgDelDlCell
(
RlcCb *gCb,
CmLteCellId cellId,
RlcEntCfgCfmInfo *entCfm
)
#else
-PUBLIC S16 rlcCfgDelCell(gCb,cellId, entCfg, entCfm)
+S16 rlcCfgDelCell(gCb,cellId, entCfg, entCfm)
RlcCb *gCb;
CmLteCellId cellId;
RlcEntCfgInfo *entCfg;
if ( cellId == 0 )
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
RLOG_ARG1(L_DEBUG,DBG_RBID,entCfg->rbId,
"cellId is 0 (%d) ",
}
/* Fetch Ue Cb */
- kwDbmFetchDlCellCb(gCb,cellId, &cellCb);
+ rlcDbmFetchDlCellCb(gCb,cellId, &cellCb);
if (!cellCb)
{
/* Fill entCfm structure */
- KW_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_NOK,
CKW_CFG_REAS_CELL_UNKWN);
RLOG_ARG1(L_ERROR, DBG_CELLID,cellId,
"CellCb not found for RBID:%d",
}
/* Delete Ue Cb */
- kwDbmDelDlCellCb(gCb,cellCb);
+ rlcDbmDelDlCellCb(gCb,cellCb);
/* Fill entCfm structure */
/* kw005.201 added support for L2 Measurement */
- KW_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_OK,
+ RLC_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_OK,
CKW_CFG_REAS_NONE);
return ROK;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgDlUeIdChng
+S16 rlcCfgDlUeIdChng
(
RlcCb *gCb,
CkwUeInfo *ueInfo,
CmStatus *status
)
#else
-PUBLIC S16 rlcCfgDlUeIdChng(gCb,ueInfo,newUeInfo,status)
+S16 rlcCfgDlUeIdChng(gCb,ueInfo,newUeInfo,status)
RlcCb *gCb;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
return RFAILED;
}
- if(ROK == kwDbmFetchDlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
+ if(ROK == rlcDbmFetchDlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
{
RLOG_ARG1(L_ERROR, DBG_CELLID, newUeInfo->cellId,
"NewUeId[%d]:ueCb already exists",
return RFAILED;
}
- if(ROK != kwDbmFetchDlUeCb(gCb,ueInfo->ueId, ueInfo->cellId, &ueCb))
+ if(ROK != rlcDbmFetchDlUeCb(gCb,ueInfo->ueId, ueInfo->cellId, &ueCb))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueInfo->cellId,
}
#ifdef LTE_L2_MEAS
- kwHdlMeasDlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
+ rlcHdlMeasDlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
#endif
if(ROK != cmHashListDelete(&(gCb->u.dlCb->ueLstCp), (PTR) ueCb))
{
#include "l2_tenb_stats.x" /* Total EnodeB Stats declarations */
#endif
#endif
-PUBLIC S16 kwValidateRbCfgParams (RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
+S16 rlcValidateRbCfgParams (RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
RlcEntCfgInfo *cfgToValidate, CmStatus *status);
-#define KW_MODULE KW_DBGMASK_CFG
+#define RLC_MODULE RLC_DBGMASK_CFG
#ifdef LTE_L2_MEAS
/**
*
* -# RFAILED
*
*/
-PRIVATE S16 kwHdlMeasUlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
+PRIVATE S16 rlcHdlMeasUlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
{
- KwL2MeasCb *measCb = NULLP;
+ RlcL2MeasCb *measCb = NULLP;
U16 cntr;
U16 ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
+ measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
if( measCb->measType & LKW_L2MEAS_UL_IP)
{
* -# RFAILED
*
*/
-PRIVATE S16 kwDelFrmUlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
+PRIVATE S16 rlcDelFrmUlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
{
- KwL2MeasCb *measCb = NULLP;
+ RlcL2MeasCb *measCb = NULLP;
U16 cntr;
U16 ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
+ measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
if( measCb->measType & LKW_L2MEAS_UL_IP)
for (myIdx = 0; myIdx < measCb->val.ipThMeas.numUes; myIdx++)
{
ueCb = NULL;
- ret = kwDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb);
+ ret = rlcDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb);
}
}
}
-PRIVATE S16 kwAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *kwRbCb,U8 cellId,U8 ueId)
+PRIVATE S16 rlcAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *rlcRbCb,U8 cellId,U8 ueId)
{
- KwL2MeasCb *measCb = NULLP;
+ RlcL2MeasCb *measCb = NULLP;
U16 cntr;
U16 cntr1;
U16 ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
+ measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
freeIdx = gCb->genCfg.maxUe;
{
for(cntr1 =0;cntr1<measCb->val.nonIpThMeas.numQci;cntr1++)
{
- if(measCb->val.nonIpThMeas.qci[cntr1] != kwRbCb->qci)
+ if(measCb->val.nonIpThMeas.qci[cntr1] != rlcRbCb->qci)
{
- measCb->val.nonIpThMeas.qci[cntr1] = kwRbCb->qci;
- gCb->u.ulCb->kwL2Cb.measOn[kwRbCb->qci] |=measCb->measType;
+ measCb->val.nonIpThMeas.qci[cntr1] = rlcRbCb->qci;
+ gCb->u.ulCb->rlcL2Cb.measOn[rlcRbCb->qci] |=measCb->measType;
break;
}
}
}
- if(((kwRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE))
+ if(((rlcRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE))
{
#ifdef LTE_L2_MEAS_RLC
if (measCb->measType & LKW_L2MEAS_ACT_UE)
{
- if((kwRbCb->mode == CM_LTE_MODE_UM) &&
- (kwRbCb->dir & KW_DIR_DL ))
+ if((rlcRbCb->mode == CM_LTE_MODE_UM) &&
+ (rlcRbCb->dir & RLC_DIR_DL ))
{
- if (kwRbCb->m.um.umDl.sduQ.count)
+ if (rlcRbCb->m.um.umDl.sduQ.count)
{
- if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
+ if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
{
- kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
- gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++;
+ rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
+ gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
}
}
}
- else if (kwRbCb->mode == CM_LTE_MODE_AM)
+ else if (rlcRbCb->mode == CM_LTE_MODE_AM)
{
- if ((kwRbCb->m.am.amDl.cntrlBo) ||
- (kwRbCb->m.am.amDl.retxBo) ||
- (kwRbCb->m.am.amDl.bo))
+ if ((rlcRbCb->m.am.amDl.cntrlBo) ||
+ (rlcRbCb->m.am.amDl.retxBo) ||
+ (rlcRbCb->m.am.amDl.bo))
{
- if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
+ if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
{
- kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
- gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++;
+ rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
+ gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
}
}
}
ueIdx = freeIdx;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE;
- cmMemset((U8 *)&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(KwL2Cntr) *LKW_MAX_QCI));
+ cmMemset((U8 *)&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;
for (qciIdx =0; qciIdx < *numQci; qciIdx++)
{
- if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == kwRbCb->qci)
+ if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == rlcRbCb->qci)
{
break;
}
if (qciIdx == *numQci)
{
- measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = kwRbCb->qci;
+ measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = rlcRbCb->qci;
(*numQci)++;
}
\f
- kwUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[kwRbCb->qci],
- &kwRbCb->rbL2Cb, measCb->measType);
+ rlcUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[rlcRbCb->qci],
+ &rlcRbCb->rbL2Cb, measCb->measType);
}
- kwRbCb->rbL2Cb.measOn |= measCb->measType;
+ rlcRbCb->rbL2Cb.measOn |= measCb->measType;
}
- return ROK;
-}/*kwAddToDlL2Meas*/
+ return (ROK);
+}/*rlcAddToDlL2Meas*/
#endif /*LTE_L2_MEAS*/
\f
/**
* indx = 1 as Up Link */
rbCb->lch.lChId = entCfg->lCh[1].lChId;
rbCb->lch.lChType = entCfg->lCh[1].type;
- rbCb->dir = KW_DIR_BOTH;
+ rbCb->dir = RLC_DIR_BOTH;
rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr;
rbCb->m.amUl.reOrdTmrInt = entCfg->m.amInfo.ul.reOrdTmr;
rbCb->m.amUl.snLen = entCfg->m.amInfo.ul.snLen; /* 5GNR */
- if(KW_AM_CFG_12BIT_SN_LEN == rbCb->m.amUl.snLen)
+ if(RLC_AM_CFG_12BIT_SN_LEN == rbCb->m.amUl.snLen)
{
- rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_12BITS) - 1; /* 5GNR */
+ rbCb->m.amUl.snModMask = (1 << RLC_SN_LEN_12BITS) - 1; /* 5GNR */
}
else
{
- rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_18BITS) - 1; /* 5GNR */
+ rbCb->m.amUl.snModMask = (1 << RLC_SN_LEN_18BITS) - 1; /* 5GNR */
}
cmInitTimers(&(rbCb->m.amUl.reOrdTmr), 1);
cmInitTimers(&(rbCb->m.amUl.staProhTmr), 1);
- rbCb->m.amUl.vrMr = rbCb->m.amUl.rxNext + (KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen));
+ rbCb->m.amUl.vrMr = rbCb->m.amUl.rxNext + (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen));
ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwValidateRbCfgParams
+S16 rlcValidateRbCfgParams
(
RlcCb *gCb,
CmLteRnti ueId,
CmStatus *status
)
#else
-PUBLIC S16 kwValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status)
+S16 rlcValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
}
if ((cfgToValidate->rguSapId >= gCb->genCfg.maxRguSaps) || (cfgToValidate->rguSapId < 0))
{
- KWDBGP_ERROR(gCb, "kwValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
+ RLCDBGP_ERROR(gCb, "rlcValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
ueId, cellId, cfgToValidate->rguSapId);
status->reason = CKW_CFG_REAS_INVALID_RGUSAP;
return RFAILED;
return RFAILED;
}
if((cfgToValidate->entMode == CM_LTE_MODE_UM) &&
- (cfgToValidate->m.umInfo.ul.snLen != KW_UM_CFG_5BIT_SN_LEN) &&
- (cfgToValidate->m.umInfo.ul.snLen != KW_UM_CFG_10BIT_SN_LEN))
+ (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_5BIT_SN_LEN) &&
+ (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_10BIT_SN_LEN))
{
RLOG_ARG2(L_ERROR,DBG_UEID,ueId,
"CellId[%u]:UM Mode RB[%d],Invalid SN Len[%d]",
/* Process Adding new RB */
if (ueId == 0)
{
- if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
+ if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
}
else
{
- if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
{
if (ueId == 0)
{
- if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
+ if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
}
else
{
- if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateUlRb
+S16 rlcCfgValidateUlRb
(
RlcCb *gCb,
RlcEntCfgInfo *cfgToValidate,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
+S16 rlcCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
RlcCb *gCb;
RlcEntCfgInfo *cfgToValidate;
RlcUlEntTmpData *cfgEntData;
cfgTmpData->cellId,
cfgToValidate->cfgType);
- if(ROK != kwValidateRbCfgParams(gCb,
+ if(ROK != rlcValidateRbCfgParams(gCb,
cfgTmpData->ueId,
cfgTmpData->cellId,
cfgToValidate,
{
/* Cell Cb is added if it not present , it is not roll backed if the
* configuration fails */
- kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
+ rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
if(!cfgTmpData->cellCb)
{
/* cell cb does not exist we need to create a new one */
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL;
return RFAILED;
}
- kwDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
+ rlcDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
}
else
{
{
/* Ue Cb is added if it not present , it is not roll backed if the
* configuration fails */
- kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
+ rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
if(!cfgTmpData->ueCb)
{
RLC_ALLOC(gCb,cfgTmpData->ueCb, sizeof(RlcUlUeCb));
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL;
return RFAILED;
}
- kwDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
+ rlcDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
}
else
{
- KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
+ RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
cfgToValidate->rbType,
cfgTmpData->ueCb,
cfgEntData->rbCb);
U16 winLen;
- cfgEntData->rbCb->m.umUl.umWinSz = KW_POWER(2,
+ cfgEntData->rbCb->m.umUl.umWinSz = RLC_POWER(2,
((cfgToValidate->m.umInfo.ul.snLen *5)-1));
winLen = cfgEntData->rbCb->m.umUl.umWinSz << 1;
RLC_ALLOC(gCb,
cfgEntData->rbCb->m.umUl.recBuf,
- (winLen * sizeof(KwUmRecBuf*)));
+ (winLen * sizeof(RlcUmRecBuf*)));
}
else if(CM_LTE_MODE_AM == cfgToValidate->entMode)
{
U32 hashIndex;
RLC_ALLOC(gCb,
cfgEntData->rbCb->m.amUl.recBufLst,
- (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
- for(hashIndex = 0; hashIndex < KW_RCV_BUF_BIN_SIZE; hashIndex++)
+ (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
+ for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++)
{
cmLListInit(&(cfgEntData->rbCb->m.amUl.recBufLst[hashIndex]));
}
if (cfgTmpData->ueId == 0)
{
/* Try to get the CellCb if it already exists */
- kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
+ rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
if(!cfgTmpData->cellCb)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,cfgTmpData->cellId,
}
else
{
- kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
+ rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
if(!cfgTmpData->ueCb)
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
}
/* Get rbCb */
- KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
+ RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
cfgToValidate->rbType,
cfgTmpData->ueCb,
cfgEntData->rbCb);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgRollBackUlRb
+S16 rlcCfgRollBackUlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC S16 rlcCfgRollBackUlRb(gCb, cfg, cfgEntData)
+S16 rlcCfgRollBackUlRb(gCb, cfg, cfgEntData)
(
RlcCb *gCb;
CmLteRnti ueId;
{
RLC_FREE(gCb,
cfgEntData->rbCb->m.umUl.recBuf,
- (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(KwUmRecBuf*));
+ (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(RlcUmRecBuf*));
}
else if(CM_LTE_MODE_AM == cfg->entMode)
{
#ifndef LTE_TDD
- RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
#endif
}
RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyUlRb
+Void rlcCfgApplyUlRb
(
RlcCb *gCb,
RlcEntCfgInfo *cfgToAply,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void rlcCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
+Void rlcCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
(
RlcCb *gCb;
RlcEntCfgInfo *cfgToAply;
}
}
- KW_LMM_RB_STS_INC(gCb);
+ RLC_LMM_RB_STS_INC(gCb);
cfgEntData->rbCb->rlcId.cellId = cfgTmpData->cellId;
cfgEntData->rbCb->rlcId.ueId = cfgTmpData->ueId;
if (cfgToAply->lCh[1].type == CM_LTE_LCH_DTCH)
{
/* ccpu00129778 */
- kwAddToUlL2Meas(gCb, cfgEntData->rbCb,
+ rlcAddToUlL2Meas(gCb, cfgEntData->rbCb,
cfgTmpData->cellId,cfgTmpData->ueId);
}
#endif /* LTE_L2_MEAS */
/* Free the Buffers of RbCb */
if( CM_LTE_MODE_UM == cfgEntData->rbCb->mode )
{
- kwUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
+ rlcUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
}
else if(CM_LTE_MODE_AM == cfgEntData->rbCb->mode)
{
- kwAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
+ rlcAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
}
/* Assign NULLP to rbCb in rbCbLst */
/* Delete RbCb */
RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
- KW_LMM_RB_STS_DEC(gCb);
+ RLC_LMM_RB_STS_DEC(gCb);
break;
}
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateDelUlUe
+S16 rlcCfgValidateDelUlUe
(
RlcCb *gCb,
RlcEntCfgInfo *cfgToValidate,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
+S16 rlcCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
RlcCb *gCb;
RlcEntCfgInfo *cfgToValidate;
RlcUlEntTmpData *cfgEntData;
}
/* Fetch Ue Cb */
- if(ROK != kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
+ if(ROK != rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
"UeId [%d]: UeCb not found",
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyDelUlUe
+Void rlcCfgApplyDelUlUe
(
RlcCb *gCb,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void rlcCfgApplyDelUlUe(gCb, cfgTmpData)
+Void rlcCfgApplyDelUlUe(gCb, cfgTmpData)
(
RlcCb *gCb;
RlcUlCfgTmpData *cfgTmpData;
TRC3(rlcCfgApplyDelUlUe)
#ifdef LTE_L2_MEAS
- kwDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
+ rlcDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
#endif
- kwDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
+ rlcDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
RETVOID;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateDelUlCell
+S16 rlcCfgValidateDelUlCell
(
RlcCb *gCb,
CmLteCellId cellId,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
+S16 rlcCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
RlcCb *gCb;
CmLteCellId cellId;
RlcEntCfgInfo *cfgToValidate;
}
/* Fetch Cell Cb */
- kwDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
+ rlcDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
if (!cfgTmpData->cellCb)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;;
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyDelUlCell
+Void rlcCfgApplyDelUlCell
(
RlcCb *gCb,
RlcUlCfgTmpData *cfgInfo
)
#else
-PUBLIC Void rlcCfgApplyDelUlCell(gCb, cfgEntData)
+Void rlcCfgApplyDelUlCell(gCb, cfgEntData)
(
RlcCb *gCb;
RlcUlCfgTmpData *cfgInfo;
{
TRC3(rlcCfgApplyDelUlCell)
- kwDbmDelUlCellCb(gCb,cfgInfo->cellCb);
+ rlcDbmDelUlCellCb(gCb,cfgInfo->cellCb);
RETVOID;
}
\f
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateReEstRb
+S16 rlcCfgValidateReEstRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC S16 rlcCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
+S16 rlcCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
rlcId.rbId = cfgToValidate->rbId;
rlcId.rbType = cfgToValidate->rbType;
- kwDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
+ rlcDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
if (cfgEntData->rbCb == NULLP)
{
RLOG_ARG2(L_WARNING, DBG_UEID,ueId,
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyReEstUlRb
+Void rlcCfgApplyReEstUlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC Void rlcCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
+Void rlcCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
(
RlcCb *gCb;
CmLteRnti ueId;
{
case CM_LTE_MODE_TM:
{
- kwTmmUlReEstablish(gCb,cfgEntData->rbCb);
+ rlcTmmUlReEstablish(gCb,cfgEntData->rbCb);
break;
}
case CM_LTE_MODE_UM:
{
- kwUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
+ rlcUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
break;
}
case CM_LTE_MODE_AM:
{
- kwAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
+ rlcAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
break;
}
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateUeIdChng
+S16 rlcCfgValidateUeIdChng
(
RlcCb *gCb,
CkwUeInfo *ueInfo,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
+S16 rlcCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
RlcCb *gCb;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
return RFAILED;
}
- if(ROK == kwDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
+ if(ROK == rlcDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
{
RLOG_ARG1(L_ERROR, DBG_CELLID, newUeInfo->cellId,
"NewUeId[%d]:ueCb already exists",
return RFAILED;
}
- if(ROK != kwDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
+ if(ROK != rlcDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
&cfgTmpData->ueCb))
{
RLOG_ARG1(L_ERROR,DBG_CELLID, ueInfo->cellId,
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyUlUeIdChng
+Void rlcCfgApplyUlUeIdChng
(
RlcCb *gCb,
CkwUeInfo *ueInfo,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void rlcCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
+Void rlcCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
(
RlcCb *gCb;
CkwUeInfo *ueInfo,
TRC3(rlcCfgApplyUlUeIdChng)
#ifdef LTE_L2_MEAS
- kwHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
+ rlcHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
#endif
cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) cfgTmpData->ueCb);
/* update the hash key with new values */
Desc: Source code for Database Module functions such as,
- - kwDbmInit
+ - rlcDbmInit
- kwDbmDeInit
- kwDbmCreateRbCb
- kwDbmFetchRbCb
* @file gp_dbm_dl.c
* @brief RLC Downlink database module
*/
-#define KW_MODULE KW_DBGMASK_DUT
+#define RLC_MODULE RLC_DBGMASK_DUT
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwDbmDlInit
+S16 rlcDbmDlInit
(
RlcCb *gCb
)
#else
-PUBLIC S16 kwDbmDlInit(gCb)
+S16 rlcDbmDlInit(gCb)
RlcCb *gCb;
#endif
{
- TRC3(kwDbmDlInit)
+ TRC3(rlcDbmDlInit)
/* Initialize ueCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.dlCb->ueLstCp),
- (U16) KW_UE_LIST_BUCKET_SIZE,
+ (U16) RLC_UE_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) FALSE,
(U16) CM_HASH_KEYTYPE_CONID,
- KW_GET_MEM_REGION(gCb),
- KW_GET_MEM_POOL(gCb)))
+ RLC_GET_MEM_REGION(gCb),
+ RLC_GET_MEM_POOL(gCb)))
{
RLOG0(L_ERROR, "UeLstCp Initialization Failed");
return RFAILED;
/* Initialize cellCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.dlCb->cellLstCp),
- (U16) KW_CELL_LIST_BUCKET_SIZE,
+ (U16) RLC_CELL_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) FALSE,
(U16) CM_HASH_KEYTYPE_CONID,
- KW_GET_MEM_REGION(gCb),
- KW_GET_MEM_POOL(gCb)))
+ RLC_GET_MEM_REGION(gCb),
+ RLC_GET_MEM_POOL(gCb)))
{
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
RLOG0(L_ERROR, "CellLstCp Initialization Failed");
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
/* Initialize qcI Hash List */
- if(ROK != cmHashListInit(&(rlcCb.kwL2Cb.qciHlCp),
- (U16) KW_QCI_LIST_BUCKET_SIZE,
+ if(ROK != cmHashListInit(&(rlcCb.rlcL2Cb.qciHlCp),
+ (U16) RLC_QCI_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) TRUE,
(U16) CM_HASH_KEYTYPE_DEF,
{
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
- RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for rlcCb.qciHlCp");
+ RLOG0(L_ERROR, "rlcDbmInit: cmHashListInit Failed for rlcCb.qciHlCp");
return RFAILED;
}
/* Initialize tbHlCp Hash List */
- if(ROK != cmHashListInit(&(rlcCb.kwL2Cb.tbHlCp),
- (U16) KW_TB_LIST_BUCKET_SIZE,
+ if(ROK != cmHashListInit(&(rlcCb.rlcL2Cb.tbHlCp),
+ (U16) RLC_TB_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) FALSE,
(U16) CM_HASH_KEYTYPE_DEF,
rlcCb.init.region,
rlcCb.init.pool))
{
- cmHashListDeinit(&rlcCb.kwL2Cb.qciHlCp);
+ cmHashListDeinit(&rlcCb.rlcL2Cb.qciHlCp);
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
- RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for rlcCb.tbHlCp");
+ RLOG0(L_ERROR, "rlcDbmInit: cmHashListInit Failed for rlcCb.tbHlCp");
return RFAILED;
}
#endif /* LTE_L2_MEAS */
return ROK;
-} /* kwDbmDlInit */
+} /* rlcDbmDlInit */
\f
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmDlDeInit
+Void rlcDbmDlDeInit
(
RlcCb *gCb
)
#else
-PUBLIC Void kwDbmDlDeInit(gCb)
+Void rlcDbmDlDeInit(gCb)
RlcCb *gCb;
#endif
{
- TRC3(kwDbmDlDeInit);
+ TRC3(rlcDbmDlDeInit);
/* De Initialize ueCb Hash List */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
/* De Initialize qciCb Hash List */
- cmHashListDeinit(&(rlcCb.kwL2Cb.qciHlCp));
+ cmHashListDeinit(&(rlcCb.rlcL2Cb.qciHlCp));
/* De Initialize tbHlCp Hash List */
- cmHashListDeinit(&(rlcCb.kwL2Cb.tbHlCp));
+ cmHashListDeinit(&(rlcCb.rlcL2Cb.tbHlCp));
#endif /* LTE_L2_MEAS */
RETVOID;
-} /* kwDbmDlDeInit */
+} /* rlcDbmDlDeInit */
\f
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmFetchDlRbCbByRbId
+Void rlcDbmFetchDlRbCbByRbId
(
RlcCb *gCb,
CmLteRlcId *rlcId,
RlcDlRbCb **rbCb
)
#else
-PUBLIC Void kwDbmFetchDlRbCbByRbId(gCb, rlcId, rbCb)
+Void rlcDbmFetchDlRbCbByRbId(gCb, rlcId, rbCb)
RlcCb *gCb;
CmLteRlcId *rlcId;
RlcDlRbCb **rbCb;
#endif
{
- TRC3(kwDbmFetchDlRbCbByRbId)
+ TRC3(rlcDbmFetchDlRbCbByRbId)
*rbCb= NULLP;
{
RlcDlCellCb *cellCb;
- if(rlcId->rbId >= KW_MAX_RB_PER_CELL)
+ if(rlcId->rbId >= RLC_MAX_RB_PER_CELL)
{
RLOG_ARG3(L_ERROR,DBG_RBID,rlcId->rbId ,
"Invalid RbId, Max is [%d] UEID:%d CELLID:%d",
- KW_MAX_RB_PER_CELL,
+ RLC_MAX_RB_PER_CELL,
rlcId->ueId,
rlcId->cellId);
RETVOID;
}
- kwDbmFetchDlCellCb(gCb,rlcId->cellId, &cellCb);
+ rlcDbmFetchDlCellCb(gCb,rlcId->cellId, &cellCb);
if(!cellCb)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,rlcId->cellId,
else
{
RlcDlUeCb *ueCb;
- if (!(KW_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
{
RLOG_ARG3(L_ERROR,DBG_RBID, rlcId->rbId,
"Invalid RbId for RbType[%d] RBID:%d CELLID:%d",
RETVOID;
}
- if (ROK != kwDbmFetchDlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb))
+ if (ROK != rlcDbmFetchDlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb))
{
RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId->cellId,
"UeId [%d]: UeCb not found RBID:%d",
RETVOID;
}
- KW_DBM_GET_RBCB_FROM_UECB(rlcId->rbId, rlcId->rbType, ueCb, *rbCb);
+ RLC_DBM_GET_RBCB_FROM_UECB(rlcId->rbId, rlcId->rbType, ueCb, *rbCb);
}
RETVOID;
-} /* kwDbmFetchDlRbCbByRbId */
+} /* rlcDbmFetchDlRbCbByRbId */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmFetchDlRbCbFromLchId
+Void rlcDbmFetchDlRbCbFromLchId
(
RlcCb *gCb,
CmLteRnti ueId,
RlcDlRbCb **rbCb
)
#else
-PUBLIC Void kwDbmFetchDlRbCbFromLchId(gCb, ueId, cellId, lcId, rbCb)
+Void rlcDbmFetchDlRbCbFromLchId(gCb, ueId, cellId, lcId, rbCb)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
{
RlcDlUeCb *ueCb;
- TRC3(kwDbmFetchDlRbCbFromLchId)
+ TRC3(rlcDbmFetchDlRbCbFromLchId)
/* Check for UE CB or CELL CB */
{
RlcDlCellCb *cellCb;
- kwDbmFetchDlCellCb(gCb, cellId, &cellCb);
+ rlcDbmFetchDlCellCb(gCb, cellId, &cellCb);
if(!cellCb)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,"CellCb not found UEID:%d",ueId);
RETVOID;
}
- if (kwDbmFetchDlUeCb(gCb, ueId, cellId, &ueCb) != ROK)
+ if (rlcDbmFetchDlUeCb(gCb, ueId, cellId, &ueCb) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cellId,"UeId [%d]: UeCb not found",ueId);
RETVOID;
*rbCb = ueCb->lCh[lcId - 1].dlRbCb;
RETVOID;
-} /* kwDbmFetchDlRbCbFromLchId */
+} /* rlcDbmFetchDlRbCbFromLchId */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelAllDlRb
+Void rlcDbmDelAllDlRb
(
RlcCb *gCb,
RlcDlRbCb **rbCbLst,
U8 numRbCb
)
#else
-PUBLIC Void kwDbmDelAllDlRb(gCb, rbCbLst, numRbCb)
+Void rlcDbmDelAllDlRb(gCb, rbCbLst, numRbCb)
RlcCb *gCb;
RlcDlRbCb **rbCbLst;
U8 numRbCb;
{
U32 idx;
- TRC3(kwDbmDelAllDlRb)
+ TRC3(rlcDbmDelAllDlRb)
for (idx = 0; idx < numRbCb; idx++)
if (rbCbLst[idx] != NULLP)
{
#ifdef LTE_L2_MEAS
- KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, (rbCbLst[idx]));
+ RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, (rbCbLst[idx]));
#endif
if( CM_LTE_MODE_UM == rbCbLst[idx]->mode)
{
- kwUmmFreeDlRbCb(gCb,rbCbLst[idx]);
+ rlcUmmFreeDlRbCb(gCb,rbCbLst[idx]);
RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcDlRbCb));
}
else if( CM_LTE_MODE_AM == rbCbLst[idx]->mode)
{
- kwAmmFreeDlRbCb(gCb,rbCbLst[idx]);
+ rlcAmmFreeDlRbCb(gCb,rbCbLst[idx]);
}
/* ccpu00136940 */
else if(CM_LTE_MODE_TM == rbCbLst[idx]->mode)
}
RETVOID;
-} /* kwDbmDelAllDlRb */
+} /* rlcDbmDelAllDlRb */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwDbmCreateDlUeCb
+S16 rlcDbmCreateDlUeCb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcDlUeCb **ueCb
)
#else
-PUBLIC S16 kwDbmCreateDlUeCb(gCb,ueId, cellId, ueCb)
+S16 rlcDbmCreateDlUeCb(gCb,ueId, cellId, ueCb)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
{
RlcDlUeCb *tUeCb;
- TRC3(kwDbmCreateDlUeCb)
+ TRC3(rlcDbmCreateDlUeCb)
RLC_ALLOC(gCb,*ueCb, sizeof(RlcDlUeCb));
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwDbmFetchDlUeCb
+S16 rlcDbmFetchDlUeCb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcDlUeCb **ueCb
)
#else
-PUBLIC S16 kwDbmFetchDlUeCb(gCb,ueId, cellId, ueCb)
+S16 rlcDbmFetchDlUeCb(gCb,ueId, cellId, ueCb)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
#endif
{
- TRC3(kwDbmFetchDlUeCb)
+ TRC3(rlcDbmFetchDlUeCb)
return (cmHashListFind(&(gCb->u.dlCb->ueLstCp),
(U8 *)&(ueId),
sizeof(CmLteRnti),
- KW_DEF_SEQ_NUM,
+ RLC_DEF_SEQ_NUM,
(PTR *) ueCb));
-} /* kwDbmFetchDlUeCb */
+} /* rlcDbmFetchDlUeCb */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelDlUeCb
+Void rlcDbmDelDlUeCb
(
RlcCb *gCb,
RlcDlUeCb *ueCb,
Bool abortFlag
)
#else
-PUBLIC Void kwDbmDelDlUeCb(gCb,eCb, abortFlag)
+Void rlcDbmDelDlUeCb(gCb,eCb, abortFlag)
RlcCb *gCb;
RlcDlUeCb *ueCb;
Bool abortFlag;
#endif
{
- TRC3(kwDbmDelDlUeCb)
+ TRC3(rlcDbmDelDlUeCb)
#if (!defined(KW_PDCP) || !(defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))
defined(PJ_CMP_ASYNC)))*/
/* Delete all logical channels */
- KW_MEM_ZERO(ueCb->lCh,sizeof(RlcDlLch) * KW_MAX_LCH_PER_UE);
+ RLC_MEM_ZERO(ueCb->lCh,sizeof(RlcDlLch) * RLC_MAX_LCH_PER_UE);
/* Delete all SRB RbCbs in UeCb */
- kwDbmDelAllDlRb(gCb,ueCb->srbCb, KW_MAX_SRB_PER_UE);
+ rlcDbmDelAllDlRb(gCb,ueCb->srbCb, RLC_MAX_SRB_PER_UE);
/* Delete all DRB RbCbs in UeCb */
- kwDbmDelAllDlRb(gCb,ueCb->drbCb, KW_MAX_DRB_PER_UE);
+ rlcDbmDelAllDlRb(gCb,ueCb->drbCb, RLC_MAX_DRB_PER_UE);
/* Delete ueCb entry from ueLstCp */
if(ROK != cmHashListDelete(&(gCb->u.dlCb->ueLstCp), (PTR) ueCb))
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelAllDlUe
+Void rlcDbmDelAllDlUe
(
RlcCb *gCb
)
#else
-PUBLIC Void kwDbmDelAllDlUe(gCb)
+Void rlcDbmDelAllDlUe(gCb)
RlcCb *gCb;
#endif
{
RlcDlUeCb *ueCb = NULLP;
- TRC3(kwDbmDelAllDlUe)
+ TRC3(rlcDbmDelAllDlUe)
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
(PTR *)&ueCb))
{
/* Delete ueCb */
- kwDbmDelDlUeCb(gCb,ueCb, TRUE);
+ rlcDbmDelDlUeCb(gCb,ueCb, TRUE);
ueCb = NULLP;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC Void kwDbmDelAllDlL2MeasTbFrmUe
+Void rlcDbmDelAllDlL2MeasTbFrmUe
(
RlcCb *gCb,
RlcDlUeCb *ueCb
)
#else
-PUBLIC Void kwDbmDelAllDlL2MeasTbFrmUe(gCb,ueCb)
+Void rlcDbmDelAllDlL2MeasTbFrmUe(gCb,ueCb)
RlcCb *gCb;
RlcDlUeCb *ueCb;
#endif
{
U8 tbIdx;
- KwL2MeasTb *l2MeasTb = NULLP;
- for(tbIdx = 0; tbIdx < KW_MAX_TB_PER_UE; tbIdx++)
+ RlcL2MeasTb *l2MeasTb = NULLP;
+ for(tbIdx = 0; tbIdx < RLC_MAX_TB_PER_UE; tbIdx++)
{
l2MeasTb = ueCb->l2MeasTbCb[tbIdx];
if(l2MeasTb != NULLP)
{
- RLC_FREE(gCb,l2MeasTb, sizeof(KwL2MeasTb));
+ RLC_FREE(gCb,l2MeasTb, sizeof(RlcL2MeasTb));
ueCb->l2MeasTbCb[tbIdx] = NULLP;
}
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwDbmCreateDlCellCb
+S16 rlcDbmCreateDlCellCb
(
RlcCb *gCb,
CmLteCellId cellId,
RlcDlCellCb **cellCb
)
#else
-PUBLIC S16 kwDbmCreateDlCellCb(gCb,cellId, cellCb)
+S16 rlcDbmCreateDlCellCb(gCb,cellId, cellCb)
RlcCb *gCb;
CmLteCellId cellId;
RlcDlCellCb **cellCb;
{
RlcDlCellCb *tCellCb;
- TRC3(kwDbmCreateDlCellCb)
+ TRC3(rlcDbmCreateDlCellCb)
RLC_ALLOC(gCb,*cellCb, sizeof(RlcDlCellCb));
#if (ERRCLASS & ERRCLS_ADD_RES)
return RFAILED;
}
- return ROK;
-} /* kwDbmCreateDlCellCb */
+ return (ROK);
+} /* rlcDbmCreateDlCellCb */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwDbmFetchDlCellCb
+S16 rlcDbmFetchDlCellCb
(
RlcCb *gCb,
CmLteCellId cellId,
RlcDlCellCb **cellCb
)
#else
-PUBLIC S16 kwDbmFetchDlCellCb(gCb,cellId, cellCb)
+S16 rlcDbmFetchDlCellCb(gCb,cellId, cellCb)
RlcCb *gCb;
CmLteCellId cellId;
RlcDlCellCb **cellCb;
#endif
{
- TRC3(kwDbmFetchDlCellCb)
+ TRC3(rlcDbmFetchDlCellCb)
*cellCb = NULLP;
if(ROK != cmHashListFind(&(gCb->u.dlCb->cellLstCp),
(U8 *)&(cellId),
sizeof(CmLteCellId),
- KW_DEF_SEQ_NUM,
+ RLC_DEF_SEQ_NUM,
(PTR*) cellCb))
{
RLOG_ARG0(L_ERROR,DBG_CELLID, cellId,"CellCb not found");
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelDlCellCb
+Void rlcDbmDelDlCellCb
(
RlcCb *gCb,
RlcDlCellCb *cellCb
)
#else
-PUBLIC Void kwDbmDelDlCellCb(gCb,cellCb)
+Void rlcDbmDelDlCellCb(gCb,cellCb)
RlcCb *gCb;
RlcDlCellCb *cellCb;
#endif
{
- TRC3(kwDbmDelDlCellCb)
+ TRC3(rlcDbmDelDlCellCb)
/* Delete all rbCbs in cellCb */
- kwDbmDelAllDlRb(gCb,cellCb->rbCb, KW_MAX_RB_PER_CELL);
+ rlcDbmDelAllDlRb(gCb,cellCb->rbCb, RLC_MAX_RB_PER_CELL);
/* Delete cellCb entry in hash list cellLstCp */
if(ROK != cmHashListDelete(&(gCb->u.dlCb->cellLstCp), (PTR) cellCb))
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelAllDlCell
+Void rlcDbmDelAllDlCell
(
RlcCb *gCb
)
#else
-PUBLIC Void kwDbmDelAllDlCell(gCb)
+Void rlcDbmDelAllDlCell(gCb)
RlcCb *gCb;
#endif
{
RlcDlCellCb *cellCb = NULLP;
- TRC3(kwDbmDelAllDlCell)
+ TRC3(rlcDbmDelAllDlCell)
/* Until no more cellCb is ueLstCp hash list get and delete cellCb */
(PTR) cellCb,
(PTR *)&cellCb))
{
- kwDbmDelDlCellCb(gCb, cellCb);
+ rlcDbmDelDlCellCb(gCb, cellCb);
cellCb = NULLP;
}
RETVOID;
-} /* kwDbmDelAllDlCell */
+} /* rlcDbmDelAllDlCell */
\f
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC S16 kwDbmDlShutdown
+S16 rlcDbmDlShutdown
(
RlcCb *gCb
)
#else
-PUBLIC S16 kwDbmDlShutdown(gCb)
+S16 rlcDbmDlShutdown(gCb)
RlcCb *gCb;
#endif
{
- TRC3(kwDbmDlShutdown)
+ TRC3(rlcDbmDlShutdown)
- kwDbmDelAllDlCell(gCb);
+ rlcDbmDelAllDlCell(gCb);
- kwDbmDelAllDlUe(gCb);
+ rlcDbmDelAllDlUe(gCb);
- kwDbmDlDeInit(gCb);
+ rlcDbmDlDeInit(gCb);
return ROK;
* @brief RLC Uplink database module
*/
-#define KW_MODULE KW_DBGMASK_DUT
+#define RLC_MODULE RLC_DBGMASK_DUT
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwDbmUlInit
+S16 rlcDbmUlInit
(
RlcCb *gCb
)
#else
-PUBLIC S16 kwDbmUlInit(gCb)
+S16 rlcDbmUlInit(gCb)
RlcCb *gCb;
#endif
{
/* Initialize ueCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.ulCb->ueLstCp),
- (U16) KW_UE_LIST_BUCKET_SIZE,
+ (U16) RLC_UE_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) FALSE,
(U16) CM_HASH_KEYTYPE_CONID,
- KW_GET_MEM_REGION(gCb),
- KW_GET_MEM_POOL(gCb)))
+ RLC_GET_MEM_REGION(gCb),
+ RLC_GET_MEM_POOL(gCb)))
{
RLOG0(L_ERROR, "UeLstCp Initialization Failed");
return RFAILED;
/* Initialize cellCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.ulCb->cellLstCp),
- (U16) KW_CELL_LIST_BUCKET_SIZE,
+ (U16) RLC_CELL_LIST_BUCKET_SIZE,
(U16) 0,
(Bool) FALSE,
(U16) CM_HASH_KEYTYPE_CONID,
- KW_GET_MEM_REGION(gCb),
- KW_GET_MEM_POOL(gCb)))
+ RLC_GET_MEM_REGION(gCb),
+ RLC_GET_MEM_POOL(gCb)))
{
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
RLOG0(L_ERROR, "CellLstCp Initialization Failed");
}
if(ROK != cmHashListInit(&(gCb->u.ulCb->transIdLstCp),
- (U16) KW_TRANS_ID_LST_BKT_SIZE,
+ (U16) RLC_TRANS_ID_LST_BKT_SIZE,
(U16) 0,
(Bool) FALSE,
(U16) CM_HASH_KEYTYPE_CONID,
- KW_GET_MEM_REGION(gCb),
- KW_GET_MEM_POOL(gCb)))
+ RLC_GET_MEM_REGION(gCb),
+ RLC_GET_MEM_POOL(gCb)))
{
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
cmHashListDeinit(&gCb->u.ulCb->cellLstCp);
/* Initialize qcI Hash List */
#endif /* LTE_L2_MEAS */
- return ROK;
-} /* kwDbmUlInit */
+ return (ROK);
+} /* rlcDbmUlInit */
\f
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmUlDeInit
+Void rlcDbmUlDeInit
(
RlcCb *gCb
)
#else
-PUBLIC Void kwDbmUlDeInit(gCb)
+Void rlcDbmUlDeInit(gCb)
RlcCb *gCb;
#endif
{
- TRC3(kwDbmUlDeInit);
+ TRC3(rlcDbmUlDeInit);
/* De Initialize ueCb Hash List */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
/* De Initialize qciCb Hash List */
- cmHashListDeinit(&(rlcCb.kwL2Cb.qciHlCp));
+ cmHashListDeinit(&(rlcCb.rlcL2Cb.qciHlCp));
#endif /* LTE_L2_MEAS */
RETVOID;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmFetchUlRbCbByRbId
+Void rlcDbmFetchUlRbCbByRbId
(
RlcCb *gCb,
CmLteRlcId *rlcId,
RlcUlRbCb **rbCb
)
#else
-PUBLIC Void kwDbmFetchUlRbCbByRbId(gCb, rlcId, rbCb)
+Void rlcDbmFetchUlRbCbByRbId(gCb, rlcId, rbCb)
RlcCb *gCb;
CmLteRlcId *rlcId;
RlcUlRbCb **rbCb;
#endif
{
- TRC3(kwDbmFetchUlRbCbByRbId)
+ TRC3(rlcDbmFetchUlRbCbByRbId)
*rbCb= NULLP;
{
RlcUlCellCb *cellCb;
- if(rlcId->rbId >= KW_MAX_RB_PER_CELL)
+ if(rlcId->rbId >= RLC_MAX_RB_PER_CELL)
{
RLOG_ARG3(L_ERROR,DBG_RBID,rlcId->rbId ,
"Invalid RbId, cellId:%d UEID:%d Max is [%d]",
rlcId->cellId,
rlcId->ueId,
- KW_MAX_RB_PER_CELL);
+ RLC_MAX_RB_PER_CELL);
RETVOID;
}
- kwDbmFetchUlCellCb(gCb,rlcId->cellId, &cellCb);
+ rlcDbmFetchUlCellCb(gCb,rlcId->cellId, &cellCb);
if(!cellCb)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,rlcId->cellId,
{
RlcUlUeCb *ueCb;
- if (!(KW_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
{
RLOG_ARG3(L_ERROR,DBG_RBID, rlcId->rbId,
"Invalid RbId for RbType[%d] CELLID:%d UEID:%d",
RETVOID;
}
- if (kwDbmFetchUlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb) != ROK)
+ if (rlcDbmFetchUlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb) != ROK)
{
RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId->cellId,
"UeId [%d]: UeCb not found RBID:%d",
RETVOID;
}
- KW_DBM_GET_RBCB_FROM_UECB(rlcId->rbId, rlcId->rbType, ueCb, *rbCb);
+ RLC_DBM_GET_RBCB_FROM_UECB(rlcId->rbId, rlcId->rbType, ueCb, *rbCb);
}
RETVOID;
-} /* kwDbmFetchUlRbCbByRbId */
+} /* rlcDbmFetchUlRbCbByRbId */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmFetchUlRbCbFromLchId
+Void rlcDbmFetchUlRbCbFromLchId
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlRbCb **rbCb
)
#else
-PUBLIC Void kwDbmFetchUlRbCbFromLchId(gCb, ueId, cellId, lcId, rbCb)
+Void rlcDbmFetchUlRbCbFromLchId(gCb, ueId, cellId, lcId, rbCb)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
{
RlcUlUeCb *ueCb;
- TRC3(kwDbmFetchUlRbCbFromLchId)
+ TRC3(rlcDbmFetchUlRbCbFromLchId)
*rbCb = NULLP;
{
RlcUlCellCb *cellCb;
- kwDbmFetchUlCellCb(gCb,cellId, &cellCb);
+ rlcDbmFetchUlCellCb(gCb,cellId, &cellCb);
if(!cellCb)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,"CellCb not found UEID:%d",ueId);
RETVOID;
}
- if (kwDbmFetchUlUeCb(gCb,ueId, cellId, &ueCb) != ROK)
+ if (rlcDbmFetchUlUeCb(gCb,ueId, cellId, &ueCb) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cellId,"UeId [%d]: UeCb not found",ueId);
RETVOID;
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelAllUlRb
+Void rlcDbmDelAllUlRb
(
RlcCb *gCb,
RlcUlRbCb **rbCbLst,
U8 numRbCb
)
#else
-PUBLIC Void kwDbmDelAllUlRb(gCb, rbCbLst, numRbCb)
+Void rlcDbmDelAllUlRb(gCb, rbCbLst, numRbCb)
RlcCb *gCb;
RlcUlRbCb **rbCbLst;
U8 numRbCb;
{
U32 idx; /* Index */
- TRC3(kwDbmDelAllUlRb)
+ TRC3(rlcDbmDelAllUlRb)
for (idx = 0; idx < numRbCb; idx++)
/* Free the Buffers of RbCb */
if( CM_LTE_MODE_UM == rbCbLst[idx]->mode )
{
- kwUmmFreeUlRbCb(gCb,rbCbLst[idx]);
+ rlcUmmFreeUlRbCb(gCb,rbCbLst[idx]);
}
else if(CM_LTE_MODE_AM == rbCbLst[idx]->mode)
{
- kwAmmFreeUlRbCb(gCb,rbCbLst[idx]);
+ rlcAmmFreeUlRbCb(gCb,rbCbLst[idx]);
}
RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcUlRbCb));
*
*/
#ifdef ANSI
-PUBLIC S16 kwDbmAddUlUeCb
+S16 rlcDbmAddUlUeCb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlUeCb *ueCb
)
#else
-PUBLIC S16 kwDbmAddUlUeCb(gCb, ueId, cellId, ueCb)
+S16 rlcDbmAddUlUeCb(gCb, ueId, cellId, ueCb)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
RlcUlUeCb *ueCb;
#endif
{
- TRC3(kwDbmAddUlUeCb)
+ TRC3(rlcDbmAddUlUeCb)
ueCb->ueId = ueId;
*
*/
#ifdef ANSI
-PUBLIC S16 kwDbmAddUlTransaction
+S16 rlcDbmAddUlTransaction
(
RlcCb *gCb,
RlcUlCfgTmpData *cfg
)
#else
-PUBLIC S16 kwDbmAddUlTransaction(gCb, cfg)
+S16 rlcDbmAddUlTransaction(gCb, cfg)
RlcCb *gCb;
RlcUlCfgTmpData *cfg;
#endif
{
- TRC3(kwDbmAddUlTransaction)
+ TRC3(rlcDbmAddUlTransaction)
#ifndef ALIGN_64BIT
RLOG1(L_DEBUG, "(transId(%ld)", cfg->transId);
*
*/
#ifdef ANSI
-PUBLIC S16 kwDbmFindUlTransaction
+S16 rlcDbmFindUlTransaction
(
RlcCb *gCb,
U32 transId,
RlcUlCfgTmpData **cfg
)
#else
-PUBLIC S16 kwDbmFindUlTransaction(gCb, cfg)
+S16 rlcDbmFindUlTransaction(gCb, cfg)
RlcCb *gCb;
U32 transId;
RlcUlCfgTmpData **cfg;
#endif
{
- TRC3(kwDbmFindUlTransaction)
+ TRC3(rlcDbmFindUlTransaction)
if(ROK != cmHashListFind(&(gCb->u.ulCb->transIdLstCp),
(U8 *) &transId,
sizeof (transId),
- KW_DEF_SEQ_NUM,(PTR *) cfg))
+ RLC_DEF_SEQ_NUM,(PTR *) cfg))
{
RLOG1(L_ERROR,"TransId [%ld] not found",transId);
return RFAILED;
*
*/
#ifdef ANSI
-PUBLIC S16 kwDbmDelUlTransaction
+S16 rlcDbmDelUlTransaction
(
RlcCb *gCb,
RlcUlCfgTmpData *cfg
)
#else
-PUBLIC S16 kwDbmDelUlTransaction(gCb, cfg)
+S16 rlcDbmDelUlTransaction(gCb, cfg)
RlcCb *gCb;
RlcUlCfgTmpData *cfg;
#endif
{
- TRC3(kwDbmDelUlTransaction)
+ TRC3(rlcDbmDelUlTransaction)
if(cmHashListDelete(&(gCb->u.ulCb->transIdLstCp),(PTR) (cfg)) != ROK)
*
*/
#ifdef ANSI
-PUBLIC S16 kwDbmDelAllUlTransactions
+S16 rlcDbmDelAllUlTransactions
(
RlcCb *gCb
)
#else
-PUBLIC S16 kwDbmDelAllUlTransactions(gCb)
+S16 rlcDbmDelAllUlTransactions(gCb)
RlcCb *gCb;
#endif
{
(PTR) cfg,
(PTR *)&cfg))
{
- if(kwDbmDelUlTransaction(gCb, cfg) != ROK)
+ if(rlcDbmDelUlTransaction(gCb, cfg) != ROK)
{
return RFAILED;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwDbmFetchUlUeCb
+S16 rlcDbmFetchUlUeCb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlUeCb **ueCb
)
#else
-PUBLIC S16 kwDbmFetchUlUeCb(gCb,ueId, cellId, ueCb)
+S16 rlcDbmFetchUlUeCb(gCb,ueId, cellId, ueCb)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
RlcUlUeCb **ueCb;
#endif
{
- TRC3(kwDbmFetchUlUeCb)
+ TRC3(rlcDbmFetchUlUeCb)
return (cmHashListFind(&(gCb->u.ulCb->ueLstCp),
(U8 *)&(ueId), sizeof(CmLteRnti),
- KW_DEF_SEQ_NUM,
+ RLC_DEF_SEQ_NUM,
(PTR *) ueCb));
}
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelUlUeCb
+Void rlcDbmDelUlUeCb
(
RlcCb *gCb,
RlcUlUeCb *ueCb,
Bool abortFlag
)
#else
-PUBLIC Void kwDbmDelUlUeCb(gCb,eCb, abortFlag)
+Void rlcDbmDelUlUeCb(gCb,eCb, abortFlag)
RlcCb *gCb;
RlcUlUeCb *ueCb;
Bool abortFlag;
#endif
{
- TRC3(kwDbmDelUlUeCb)
+ TRC3(rlcDbmDelUlUeCb)
#if (!defined(KW_PDCP) || !(defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))
#endif /* (!defined(KW_PDCP) || ! (defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))*/
/* Delete all logical channels */
- KW_MEM_ZERO(ueCb->lCh,sizeof(RlcUlLch) * KW_MAX_LCH_PER_UE);
+ RLC_MEM_ZERO(ueCb->lCh,sizeof(RlcUlLch) * RLC_MAX_LCH_PER_UE);
/* Delete all SRB RbCbs in UeCb */
- kwDbmDelAllUlRb(gCb,ueCb->srbCb, KW_MAX_SRB_PER_UE);
+ rlcDbmDelAllUlRb(gCb,ueCb->srbCb, RLC_MAX_SRB_PER_UE);
/* Delete all DRB RbCbs in UeCb */
- kwDbmDelAllUlRb(gCb,ueCb->drbCb, KW_MAX_DRB_PER_UE);
+ rlcDbmDelAllUlRb(gCb,ueCb->drbCb, RLC_MAX_DRB_PER_UE);
/* Delete ueCb entry from ueLstCp */
if(ROK != cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) ueCb))
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelAllUlUe
+Void rlcDbmDelAllUlUe
(
RlcCb *gCb
)
#else
-PUBLIC Void kwDbmDelAllUlUe(gCb)
+Void rlcDbmDelAllUlUe(gCb)
RlcCb *gCb;
#endif
{
RlcUlUeCb *ueCb = NULLP; /* UE Control Block */
- TRC3(kwDbmDelAllUlUe)
+ TRC3(rlcDbmDelAllUlUe)
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
(PTR) ueCb,
(PTR *)&ueCb))
{
- kwDbmDelUlUeCb(gCb,ueCb, TRUE);
+ rlcDbmDelUlUeCb(gCb,ueCb, TRUE);
ueCb = NULLP;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwDbmAddUlCellCb
+S16 rlcDbmAddUlCellCb
(
RlcCb *gCb,
CmLteCellId cellId,
RlcUlCellCb *cellCb
)
#else
-PUBLIC S16 kwDbmAddUlCellCb(gCb, cellId, cellCb)
+S16 rlcDbmAddUlCellCb(gCb, cellId, cellCb)
RlcCb *gCb;
CmLteCellId cellId;
RlcUlCellCb *cellCb;
{
RlcUlCellCb *tCellCb;
- TRC3(kwDbmAddUlCellCb)
+ TRC3(rlcDbmAddUlCellCb)
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmFetchUlCellCb
+Void rlcDbmFetchUlCellCb
(
RlcCb *gCb,
CmLteCellId cellId,
RlcUlCellCb **cellCb
)
#else
-PUBLIC Void kwDbmFetchUlCellCb(gCb, cellId, cellCb)
+Void rlcDbmFetchUlCellCb(gCb, cellId, cellCb)
RlcCb *gCb;
CmLteCellId cellId;
RlcUlCellCb **cellCb;
#endif
{
- TRC3(kwDbmFetchUlCellCb)
+ TRC3(rlcDbmFetchUlCellCb)
*cellCb = NULLP;
if(ROK != cmHashListFind(&(gCb->u.ulCb->cellLstCp),
(U8 *)&(cellId),sizeof(CmLteCellId),
- KW_DEF_SEQ_NUM, (PTR*) cellCb))
+ RLC_DEF_SEQ_NUM, (PTR*) cellCb))
{
RLOG_ARG0(L_ERROR,DBG_CELLID, cellId,"CellCb not found");
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelUlCellCb
+Void rlcDbmDelUlCellCb
(
RlcCb *gCb,
RlcUlCellCb *cellCb
)
#else
-PUBLIC Void kwDbmDelUlCellCb(gCb, cellCb)
+Void rlcDbmDelUlCellCb(gCb, cellCb)
RlcCb *gCb;
RlcUlCellCb *cellCb;
#endif
{
- TRC3(kwDbmDelUlCellCb)
+ TRC3(rlcDbmDelUlCellCb)
/* Delete all rbCbs in cellCb */
- kwDbmDelAllUlRb(gCb,cellCb->rbCb, KW_MAX_RB_PER_CELL);
+ rlcDbmDelAllUlRb(gCb,cellCb->rbCb, RLC_MAX_RB_PER_CELL);
/* Delete cellCb entry in hash list cellLstCp */
if(ROK != cmHashListDelete(&(gCb->u.ulCb->cellLstCp), (PTR) cellCb))
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDbmDelAllUlCell
+Void rlcDbmDelAllUlCell
(
RlcCb *gCb
)
#else
-PUBLIC Void kwDbmDelAllUlCell(gCb)
+Void rlcDbmDelAllUlCell(gCb)
RlcCb *gCb;
#endif
{
RlcUlCellCb *cellCb = NULLP; /* Cell Control Block */
- TRC3(kwDbmDelAllUlCell)
+ TRC3(rlcDbmDelAllUlCell)
/* Until no more cellCb is ueLstCp hash list get and delete cellCb */
(PTR) cellCb,
(PTR *)&cellCb))
{
- kwDbmDelUlCellCb(gCb,cellCb);
+ rlcDbmDelUlCellCb(gCb,cellCb);
cellCb = NULLP;
}
*
*/
#ifdef ANSI
-PUBLIC Void kwDbmUlShutdown
+Void rlcDbmUlShutdown
(
RlcCb *gCb
)
#else
-PUBLIC Void kwDbmUlShutdown(gCb)
+Void rlcDbmUlShutdown(gCb)
RlcCb *gCb;
#endif
{
- TRC3(kwDbmUlShutdown)
+ TRC3(rlcDbmUlShutdown)
- kwDbmDelAllUlCell(gCb);
+ rlcDbmDelAllUlCell(gCb);
- kwDbmDelAllUlUe(gCb);
+ rlcDbmDelAllUlUe(gCb);
- kwDbmUlDeInit(gCb);
+ rlcDbmUlDeInit(gCb);
RETVOID;
}
#ifndef __KW_DLH__
#define __KW_DLH__
-#define KW_DL_INST 1
-#define KW_MAX_RNG_DEQ_INDX 8
+#define RLC_DL_INST 1
+#define RLC_MAX_RNG_DEQ_INDX 8
/* Below are the status used within RLC */
-#define KW_SDU_OPAT_NOUPDATE 0
-#define KW_SDU_OPAT_UPD_TX 1
-#define KW_SDU_OPAT_UPD_RETX 2
+#define RLC_SDU_OPAT_NOUPDATE 0
+#define RLC_SDU_OPAT_UPD_TX 1
+#define RLC_SDU_OPAT_UPD_RETX 2
/* Below are the status which needs to be updated to MAC */
-#define KW_RGU_SDU_OPAT_NOUPDATE 0
-#define KW_RGU_SDU_OPAT_UPDATE 1
-#define KW_RGU_SDU_OPAT_BREACH 2
+#define RLC_RGU_SDU_OPAT_NOUPDATE 0
+#define RLC_RGU_SDU_OPAT_UPDATE 1
+#define RLC_RGU_SDU_OPAT_BREACH 2
/* PDB Values for various QCI bearers : This value is considered
after taking into account a 20ms delay at the network */
-#define KW_PDB_VALUE_FOR_QCI1 80
-#define KW_PDB_VALUE_FOR_QCI2 130
-#define KW_PDB_VALUE_FOR_QCI3 30
-#define KW_PDB_VALUE_FOR_QCI4 280
-#define KW_PDB_VALUE_FOR_QCI5 80
-#define KW_PDB_VALUE_FOR_QCI6 280
-#define KW_PDB_VALUE_FOR_QCI7 80
-#define KW_PDB_VALUE_FOR_QCI8 280
-#define KW_PDB_VALUE_FOR_QCI9 280
+#define RLC_PDB_VALUE_FOR_QCI1 80
+#define RLC_PDB_VALUE_FOR_QCI2 130
+#define RLC_PDB_VALUE_FOR_QCI3 30
+#define RLC_PDB_VALUE_FOR_QCI4 280
+#define RLC_PDB_VALUE_FOR_QCI5 80
+#define RLC_PDB_VALUE_FOR_QCI6 280
+#define RLC_PDB_VALUE_FOR_QCI7 80
+#define RLC_PDB_VALUE_FOR_QCI8 280
+#define RLC_PDB_VALUE_FOR_QCI9 280
-#define KW_DATA_BITMASK 0x80 /* Data bitmask is used to fill D/C bit for data*/
+#define RLC_DATA_BITMASK 0x80 /* Data bitmask is used to fill D/C bit for data*/
/**
- * @def KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB
+ * @def RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB
*
* This macro is used to check if DL IP throughput measurement is ON
* or off for the passed rb
*
*/
#ifdef LTE_L2_MEAS
-#define KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(_gCb, _rbCb) \
+#define RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(_gCb, _rbCb) \
((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
- (_gCb->u.dlCb->kwL2Cb.measOn[_rbCb->qci]))
+ (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci]))
-#define KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb) \
+#define RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb) \
((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
- (_gCb->u.dlCb->kwL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_IP) && \
+ (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_IP) && \
(_rbCb->rbL2Cb.measOn & LKW_L2MEAS_DL_IP))
-#define KW_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb) \
+#define RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb) \
((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
- (_gCb->u.dlCb->kwL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_DELAY))
+ (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_DELAY))
-#define KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(_gCb, _rbCb) \
+#define RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(_gCb, _rbCb) \
((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
- (_gCb->u.dlCb->kwL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_UU_LOSS))
-#define KW_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _kwRbCb, _delay) \
+ (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_UU_LOSS))
+#define RLC_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _rlcRbCb, _delay) \
{ \
- if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DELAY)) \
+ if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) && \
+ ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DELAY)) \
{ \
- (_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DELAY]->dlPjSduDelay.sduDelay += _delay; \
- (_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DELAY]->dlPjSduDelay.numSdus++; \
+ (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DELAY]->dlPjSduDelay.sduDelay += _delay; \
+ (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DELAY]->dlPjSduDelay.numSdus++; \
} \
}
-#define KW_UPD_L2_UU_LOSS_PKTS(_rlcCb, _kwRbCb, _val) \
+#define RLC_UPD_L2_UU_LOSS_PKTS(_rlcCb, _rlcRbCb, _val) \
{ \
- if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
+ if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) && \
+ ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
{ \
- (_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_UU_LOSS]->uuLoss.dLoss += _val; \
+ (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_UU_LOSS]->uuLoss.dLoss += _val; \
} \
}
-#define KW_UPD_L2_UU_LOSS_POS_PKTS(_rlcCb,_kwRbCb,_val) \
+#define RLC_UPD_L2_UU_LOSS_POS_PKTS(_rlcCb,_rlcRbCb,_val) \
{ \
- if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
+ if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) && \
+ ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_UU_LOSS)) \
{ \
- (_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_UU_LOSS]->uuLoss.posPkts += _val; \
+ (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_UU_LOSS]->uuLoss.posPkts += _val; \
} \
}
/* Discard new changes starts */
-#define KW_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_kwRbCb) \
+#define RLC_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_rlcRbCb) \
{ \
- if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
+ if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) && \
+ ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
{ \
- (_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DISC]->dlDisc.discSdus++; \
+ (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DISC]->dlDisc.discSdus++; \
} \
}
-#define KW_UPD_L2_DL_TOT_SDU_STS(_rlcCb,_kwRbCb) \
+#define RLC_UPD_L2_DL_TOT_SDU_STS(_rlcCb,_rlcRbCb) \
{ \
- if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
+ if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) && \
+ ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
{ \
- (_kwRbCb)->rbL2Cb.l2Sts[KW_L2MEAS_DL_DISC]->dlDisc.totSdus++; \
+ (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DISC]->dlDisc.totSdus++; \
} \
}
-#define KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _kwRbCb) \
+#define RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _rlcRbCb) \
{ \
- if(((_kwRbCb)->rlcId.rbType == CM_LTE_DRB) && \
- ((_rlcCb)->u.dlCb->kwL2Cb.measOn[_kwRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
+ if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) && \
+ ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
{ \
U32 idx1; \
for (idx1 = 0; idx1 < LKW_MAX_L2MEAS; idx1++) \
{ \
- if(_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.measType & LKW_L2MEAS_DL_DISC) \
+ if(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.measType & LKW_L2MEAS_DL_DISC) \
{ \
- if(_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci > 0) \
+ if(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci > 0) \
{ \
- _rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci--; \
- if (_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci].totDrbsPerQci == 0) \
+ _rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci--; \
+ if (_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci == 0) \
{ \
- _rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.qci[(_kwRbCb)->qci] = 0; \
- cmMemset((U8 *)&_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci], 0, \
- sizeof(_rlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_kwRbCb)->qci])); \
+ _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, \
+ sizeof(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci])); \
} \
} \
} \
} \
}
#else
-#define KW_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _kwRbCb, _delay)
-#define KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb)
-#define KW_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb)
-#define KW_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_kwRbCb)
-#define KW_UPD_L2_DL_TOT_SDU_STS(_rlcCb, _kwRbCb)
-#define KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _kwRbCb)
+#define RLC_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _rlcRbCb, _delay)
+#define RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb)
+#define RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb)
+#define RLC_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_rlcRbCb)
+#define RLC_UPD_L2_DL_TOT_SDU_STS(_rlcCb, _rlcRbCb)
+#define RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _rlcRbCb)
#endif
* @details
* - sn : Sequence number of the AM pdu
*/
-typedef struct kwPduMap
+typedef struct rlcPduMap
{
- KwSn sn; /*!< Mapped PDU's SN */
-}KwPduMap;
+ RlcSn sn; /*!< Mapped PDU's SN */
+}RlcPduMap;
/**
* @brief Structure to hold information regarding a SDU received from PDCP
* - rcvdSz : Length of this SDU which is received by the peer
* - isSegmented : Whether this SDU is segmented into multiple PDUs
*/
-typedef struct kwSdu
+typedef struct rlcSdu
{
CmLList lstEnt; /*!< List entry for SDU */
Buffer *mBuf; /*!< SDU buffer */
MsgLen actSz; /*!< Actual buffer Size */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- KwSduSnMap *snMap; /*!< Sdu and the list of SN it maps to */
+ RlcSduSnMap *snMap; /*!< Sdu and the list of SN it maps to */
#endif /* LTE_L2_MEAS */
union
U32 sduId; /*!< SDU Identifier */
MsgLen rcvdSz; /*!< Recvd SDU Size from peer */
Bool isSegmented; /*!< Is SDU segmented */
- KwSn sn; /*!< SN assigned to this SDU*/
+ RlcSn sn; /*!< SN assigned to this SDU*/
}am; /*!< SDU for AM mode */
}mode; /*!< RLC mode specific SDUs */
/* Discard new changes starts */
Ticks arrTime; /*!< Arrival time of the PDCP PDU at RLC */
/* Discard new changes ends */
-}KwSdu;
+}RlcSdu;
/** @addtogroup tmmode */
/*@{*/
* @details
* - sduQ : Queue of SDUs
*/
-typedef struct kwTm
+typedef struct rlcTm
{
CmLListCp sduQ; /*!< SDU queue for TM */
-}KwTm;
+}RlcTm;
/*@}*/
/**
* - estHdrSz : Size for all the headers as estimated by RLC
* - staPduPrst : Whether RLC wants to send a STATUS PDU or not
*/
-typedef struct kwBoRep
+typedef struct rlcBoRep
{
S32 bo; /*!< Buffer occupancy */
U16 estHdrSz; /*!< Estimated header size for the bo */
Bool staPduPrsnt; /*!< Indicate control bo present or not */
U32 staPduBo; /*!< Indicate bo for control PDU */
U32 oldestSduArrTime;
-} KwBoRep;
+} RlcBoRep;
/**
* @brief Structure to hold information sent to MAC in a Data Request
* - pduInfo : Information about each PDU
* - boRep : Current buffer occupancy report
*/
-typedef struct kwDatReq
+typedef struct rlcDatReq
{
MsgLen pduSz; /*!< PDU(s) size indicated by MAC */
KwPduInfo pduInfo; /*!< PDU Information for lChs within UE */
- KwBoRep boRep; /*!< BO report */
+ RlcBoRep boRep; /*!< BO report */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
KwLchMapInfo lchMapInfo; /*!< Logical channel mapping info */
U32 totMacGrant;
#endif /* LTE_L2_MEAS */
-}KwDatReq;
+}RlcDatReq;
/** @defgroup ummode UM Module Info
*/
* - numLi : Number of length indicators to be sent in the next pdu
* - li : Values of the lenght indicators
*/
-typedef struct kwUmDl
+typedef struct rlcUmDl
{
CmLListCp sduQ; /*!< SDU queue for UM */
U8 snLen; /*!< Sequence number length */
S32 bo; /*!< Buffer occupancy */
S32 estHdrSz; /*!< Estimated header size for BO */
- KwSn vtUs; /*!< VT(US) */
+ RlcSn vtUs; /*!< VT(US) */
U16 modBitMask; /*!< Bitmask for modulus to wrap around vars*/
U16 numLi; /*!< Number of LIs */
- U16 li[KW_MAX_LI]; /*!< Length Indicator array */
-}KwUmDl;
+ U16 li[RLC_MAX_LI]; /*!< Length Indicator array */
+}RlcUmDl;
/**
* @brief Structure to hold information about which SDUs a PDU/segment carries
* - sduSz : Size of the SDU or part of it
* - sdu : Pointer to the SDU
*/
-typedef struct kwSduMap
+typedef struct rlcSduMap
{
/*MsgLen actSz;*/ /*!< SDU Size */
MsgLen sduSz; /*!< SDU Size */
/*Bool isSegmented;*/ /*!< Flag to indicate if the SDU is segmented */
- KwSdu* sdu; /*!< Pointer to the associated SDU */
-}KwSduMap;
+ RlcSdu* sdu; /*!< Pointer to the associated SDU */
+}RlcSduMap;
/**
* @brief Structure to hold info about a PDU/segment to be re-transmitted
* - numSdu : Number of SDUs this PDU/segment carries
* - sduMap : Infomation about the SDUs this node carries
*/
-typedef struct kwRetx
+typedef struct rlcRetx
{
CmLList lstEnt; /*!< List entry for Retransmission PDU */
Buffer *seg; /*!< Buffer of PDU or Segment */
MsgLen segSz; /*!< Segment Size */
MsgLen hdrSz; /*!< Header size for the segment */
- KwAmHdr amHdr; /*!< AM header Info */
+ RlcAmHdr amHdr; /*!< AM header Info */
U16 soEnd; /*!< Segment Offset End */
- KwSn retxCnt; /*!< Retransmission count */
+ RlcSn retxCnt; /*!< Retransmission count */
Bool yetToConst; /*!< Yet to construct seg flag */
Bool pendingReTrans; /*!< Is node waiting for re-transmission */
- KwSduMap sduMap; /*!< SDU mapped with PDU */
-}KwRetx;
+ RlcSduMap sduMap; /*!< SDU mapped with PDU */
+}RlcRetx;
/**
* @brief Structure to hold a RLC AM PDU Information
* - pduSz : The length of the segment in bytes
* - hdrSz : Header size of this PDU
* - amHdr : The AM Header for the PDU segment
- * - KwSduMap :SDU map info for this PDU
+ * - RlcSduMap :SDU map info for this PDU
*
*/
typedef struct rlcDlPduInfo
Buffer *pdu; /*!< Buffer of PDU */
MsgLen pduSz; /*!< PDU Size */
MsgLen hdrSz; /*!< Header size for the segment */
- KwAmHdr amHdr; /*!< AM header Info */
- KwSduMap sduMap; /*!< SDU info for this PDU */
+ RlcAmHdr amHdr; /*!< AM header Info */
+ RlcSduMap sduMap; /*!< SDU info for this PDU */
}RlcDlPduInfo;
* - rlsLnk : Link to store on release list, used for
* - pduLst : It contains all PDUs of a particular SN
*/
-typedef struct kwTx
+typedef struct rlcTx
{
CmLList lnk; /**< Link to the TX buffer list*/
- KwSn sn; /*!< SN of this RLC SDU */
+ RlcSn sn; /*!< SN of this RLC SDU */
CmLList rlsLnk; /*!< Lnk to store on release lst */
CmLListCp pduLst; /*!< It contains all PDUs of a particular SN*/
-}KwTx;
+}RlcTx;
/** @addtogroup ammode */
/*@{*/
* - pStaPdu : Stores the control pdu (information required to
* create the STATUS PDU) passed from AM uplink
*/
-typedef struct kwAmDl
+typedef struct rlcAmDl
{
CmLListCp sduQ; /*!< SDU queue */
- KwSdu *nxtTx; /*!< Next SDU to be transmitted */
+ RlcSdu *nxtTx; /*!< Next SDU to be transmitted */
CmTimer pollRetxTmr; /*!< T_poll_retransmit Timer */
U16 pollRetxTmrInt; /*!< Timer Interval */
S16 pollPdu; /*!< Poll_PDU */
U32 estHdrSz; /*!< Estimated header size for the BO */
S32 bo; /*!< BO of new PDUs */
#ifndef LTE_TDD
- CmLListCp *txBufLst; /*!< Transmission buffer list of type KwTx */
+ CmLListCp *txBufLst; /*!< Transmission buffer list of type RlcTx */
#else
-// KwTx *txBuf[1024]; /*!< Transmission buffer */
+// RlcTx *txBuf[1024]; /*!< Transmission buffer */
#endif
CmLListCp retxLst; /*!< Retransmission PDU list */
- KwRetx *nxtRetx; /*!< Next node to be retransmitted */
- KwSn txNext; /*!< 5GNR: TX_Next, in LTE VT(S) */
- KwSn txNextAck; /*!< 5GNR: TX_Next_Ack, in LTE VT(A)*/
+ RlcRetx *nxtRetx; /*!< Next node to be retransmitted */
+ RlcSn txNext; /*!< 5GNR: TX_Next, in LTE VT(S) */
+ RlcSn txNextAck; /*!< 5GNR: TX_Next_Ack, in LTE VT(A)*/
S16 pduWoPoll; /*!< PDU without poll bit counter */
S32 byteWoPoll; /*!< Byte without poll bit counter */
- KwSn pollSn; /*!< Poll SN */
+ RlcSn pollSn; /*!< Poll SN */
Buffer *mBuf; /*!< this can be removed later
Stores the Control Pdu */
Bool maxReTxReached; /*!< Set when the DL MAX Retx exceeded */
- KwUdxDlStaPdu* pStaPdu; /*!< The Control Pdu passed from UL*/
+ RlcUdxDlStaPdu* pStaPdu; /*!< The Control Pdu passed from UL*/
U8 snLen; /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
U32 snModMask; /*!< (2 Pwr SnLen - 1): 5GNR RLC */
-}KwAmDl;
+}RlcAmDl;
/*@}*/
* Used to find the instance from the Radio Bearer for
* memory needs as different instances might have
* different memory.
- * - kwuSapId : KWU SAP identifier
+ * - k1wuSapId : KWU SAP identifier
* - udxSapId : UDX SAP idenrifier
* - transId : Stores the transaction identifier used to communicate
* with MAC, the same value as sent by MAC is passed back
U8 qci; /*!< qci of the RB */
#ifdef LTE_L2_MEAS
RlcDlUeCb *ueCb; /*!< Pointer to UeCb */
- KwL2MeasRbCb rbL2Cb; /*!< RB measurement L2 Cb */
+ RlcL2MeasRbCb rbL2Cb; /*!< RB measurement L2 Cb */
CmLListCp sduSnMapQ; /*!< SDU SN map queue for UM */
- KwL2MeasIpThruput l2MeasIpThruput; /*!< Holds related parameter for
+ RlcL2MeasIpThruput l2MeasIpThruput; /*!< Holds related parameter for
DL/UL ip throughput>*/
#endif
seconds for an PDCP SDU for this RB */
/* Discard new changes ends */
CmLteRlcId rlcId; /*!< RLC Identifier */
- KwLchInfo lch; /*!< Logical Channel Info */
+ RlcLchInfo lch; /*!< Logical Channel Info */
CmLteRlcMode mode; /*!< Entity Mode */
U8 dir; /*!< Direction for UL/DL */
Inst inst; /*!< Tapa Instance where rb created */
- SpId kwuSapId; /*!< KWU sap Id, to get the KwuSapCb */
+ SpId k1wuSapId; /*!< KWU sap Id, to get the KwuSapCb */
SpId udxSapId; /*!< UDX sap Id, to get the UdxSapCb */
U32 transId; /*!< Transaction Id for RLC */
Bool reestInProgress; /*!< Is reestablishment in progress */
SpId rguSapId; /*!< RGU Instance SAP corresponding to this RB */
union
{
- KwTm tm; /*!< TM mode specific elements */
- KwUmDl umDl; /*!< UM downlink elements */
- KwAmDl amDl; /*!< AM downlink elements */
+ RlcTm tm; /*!< TM mode specific elements */
+ RlcUmDl umDl; /*!< UM downlink elements */
+ RlcAmDl amDl; /*!< AM downlink elements */
}m; /*!< RLC mode specific Info */
CmLList rlsLnk; /*!< Link to add to release list */
Bool cleanupStarted; /*!< Whether cleanup of RB is in progress or not */
{
CmHashListEnt cellHlEnt; /*!< Hash list entry for CellCb */
CmLteCellId cellId; /*!< Cell Id */
- RlcDlRbCb *rbCb[KW_MAX_RB_PER_CELL]; /*!< RbCbs within a Cell */
- RlcDlLch lCh[KW_MAX_LCH_PER_CELL]; /*!< Array of Logical channels */
+ RlcDlRbCb *rbCb[RLC_MAX_RB_PER_CELL]; /*!< RbCbs within a Cell */
+ RlcDlLch lCh[RLC_MAX_LCH_PER_CELL]; /*!< Array of Logical channels */
}RlcDlCellCb;
#ifdef LTE_L2_MEAS
-/** @struct KwContSduLst
+/** @struct RlcContSduLst
* Structure contains list of rbId and index to KwOutStngSduLst
*/
-typedef struct kwContSduLst
+typedef struct rlcContSduLst
{
CmLteLcId lcId; /*!< Holds the lcId of rbCb */
U8 numSdus; /*!< Number sdus in sduIdx array */
- U8 sduIdx[KW_L2MEAS_MAX_OUTSTNGSDU]; /*!< Hold the index to KwOutStngSduLst */
-}KwContSduLst;
-typedef struct kwSduInfo
+ U8 sduIdx[RLC_L2MEAS_MAX_OUTSTNGSDU]; /*!< Hold the index to KwOutStngSduLst */
+}RlcContSduLst;
+typedef struct rlcSduInfo
{
Bool isRetxPdu;
Ticks arvlTime; /* stores the the arrival time of each PDCP PDU */
-}KwSduInfo;
+}RlcSduInfo;
-typedef struct kwlchInfo
+typedef struct rlclchInfo
{
CmLteLcId lcId; /*!< Holds the lcId of rbCb */
U8 numSdus; /*!< Number sdus belonged to the this LC */
- KwSduInfo sduInfo[KW_L2MEAS_SDUIDX];
-}KwlchInfo;
+ RlcSduInfo sduInfo[RLC_L2MEAS_SDUIDX];
+}RlclchInfo;
-/** @struct KwL2MeasTb
+/** @struct RlcL2MeasTb
* Structure containes list of rbId and index to KwOutStngSduLst
*/
-typedef struct kwL2MeasTb
+typedef struct rlcL2MeasTb
{
U8 numLcId; /* number of logical channels in this TbCb */
- KwContSduLst sduInfo[KW_MAX_ACTV_DRB]; /*!< Contained sduLst for
+ RlcContSduLst sduInfo[RLC_MAX_ACTV_DRB]; /*!< Contained sduLst for
outstanding sdu */
U8 numLchInfo;
- KwlchInfo lchInfo[KW_MAX_ACTV_DRB]; /* Holds the LC info details
+ RlclchInfo lchInfo[RLC_MAX_ACTV_DRB]; /* Holds the LC info details
used for DL delay L2 Meas*/
U32 txSegSduCnt; /*!< This holds the no.of partially
transmitted SDU per TB which can be used for UU loss Meas*/
-}KwL2MeasTb;
+}RlcL2MeasTb;
#endif
/**
CmHashListEnt ueHlEnt; /*!< Hash list entry for UeCb */
CmLteRnti ueId; /*!< UE Id */
CmLteCellId cellId; /*!< Cell Id */
- RlcDlRbCb *srbCb[KW_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */
- RlcDlRbCb *drbCb[KW_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */
- RlcDlLch lCh[KW_MAX_LCH_PER_UE]; /*!< Array of Logical channels */
+ RlcDlRbCb *srbCb[RLC_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */
+ RlcDlRbCb *drbCb[RLC_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */
+ RlcDlLch lCh[RLC_MAX_LCH_PER_UE]; /*!< Array of Logical channels */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
U16 numActRb[LKW_MAX_QCI]; /*!< number of RBs Active */
U8 tbIdx; /*!< TBIDx for measTbCb */
- KwL2MeasTb *l2MeasTbCb[KW_MAX_TB_PER_UE]; /*!< Array of Measurement tbCb */
+ RlcL2MeasTb *l2MeasTbCb[RLC_MAX_TB_PER_UE]; /*!< Array of Measurement tbCb */
#endif /* LTE_L2_MEAS */
#ifdef TENB_STATS
TSL2UeStatsCb *tenbStats; /*!< UE Stats Holder */
/****************************************************************************
* DBM module Functions
***************************************************************************/
-EXTERN S16 kwDbmDlInit ARGS ((RlcCb *gCb));
+EXTERN S16 rlcDbmDlInit ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmDlDeInit ARGS ((RlcCb *gCb));
+EXTERN Void rlcDbmDlDeInit ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmCreateDlUeCb ARGS ((RlcCb *gCb,
+EXTERN S16 rlcDbmCreateDlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
RlcDlUeCb **ueCb));
-EXTERN S16 kwDbmFetchDlUeCb ARGS ((RlcCb *gCb,
+EXTERN S16 rlcDbmFetchDlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
RlcDlUeCb **ueCb));
-EXTERN Void kwDbmDelDlUeCb ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmDelDlUeCb ARGS ((RlcCb *gCb,
RlcDlUeCb *ueCb,
Bool abortFlag));
-EXTERN Void kwDbmDelAllDlUe ARGS ((RlcCb *gCb));
+EXTERN Void rlcDbmDelAllDlUe ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmCreateDlCellCb ARGS ((RlcCb *gCb,
+EXTERN S16 rlcDbmCreateDlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
RlcDlCellCb **cellCb));
-EXTERN S16 kwDbmFetchDlCellCb ARGS ((RlcCb *gCb,
+EXTERN S16 rlcDbmFetchDlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
RlcDlCellCb **cellCb));
-EXTERN Void kwDbmDelDlCellCb ARGS ((RlcCb *gCb, RlcDlCellCb *cellCb));
+EXTERN Void rlcDbmDelDlCellCb ARGS ((RlcCb *gCb, RlcDlCellCb *cellCb));
-EXTERN Void kwDbmDelAllDlCell ARGS ((RlcCb *gCb));
+EXTERN Void rlcDbmDelAllDlCell ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmFetchDlRbCbByRbId ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmFetchDlRbCbByRbId ARGS ((RlcCb *gCb,
CmLteRlcId *rlcId,
RlcDlRbCb **rbCb));
-EXTERN Void kwDbmFetchDlRbCbFromLchId ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmFetchDlRbCbFromLchId ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
CmLteLcId lcId,
RlcDlRbCb **rbCb));
-EXTERN Void kwDbmDelAllDlRb ARGS ((RlcCb *gCb, RlcDlRbCb **rbCbLst, U8 numRbCb));
+EXTERN Void rlcDbmDelAllDlRb ARGS ((RlcCb *gCb, RlcDlRbCb **rbCbLst, U8 numRbCb));
-EXTERN S16 kwDbmDlShutdown ARGS ((RlcCb *gCb));
+EXTERN S16 rlcDbmDlShutdown ARGS ((RlcCb *gCb));
-EXTERN Void kwUtlGetCurrTime ARGS((U32 *time));
-EXTERN PUBLIC Void kwUtlTrigPdbFlowCntrl ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 pktAdmitCnt ));
+EXTERN Void rlcUtlGetCurrTime ARGS((U32 *time));
+EXTERN Void rlcUtlTrigPdbFlowCntrl ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 pktAdmitCnt ));
#ifdef LTE_L2_MEAS
-EXTERN Void kwDbmDelAllDlL2MeasTbFrmUe ARGS ((RlcCb *gCb, RlcDlUeCb *ueCb));
+EXTERN Void rlcDbmDelAllDlL2MeasTbFrmUe ARGS ((RlcCb *gCb, RlcDlUeCb *ueCb));
#endif
/****************************************************************************
* Transparent Mode Functions
***************************************************************************/
-EXTERN Void kwTmmQSdu ARGS ((RlcCb *gCb,
+EXTERN Void rlcTmmQSdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatReqInfo *datReqInfo,
Buffer *mBuf));
-EXTERN Void kwTmmSndToLi ARGS ((RlcCb *gCb,
+EXTERN Void rlcTmmSndToLi ARGS ((RlcCb *gCb,
SuId suId,
RlcDlRbCb *rbCb,
RguCStaIndInfo *staInd));
/****************************************************************************
* Unacknowledged Mode Functions
***************************************************************************/
-EXTERN Void kwUmmQSdu ARGS ((RlcCb *gCb,
+EXTERN Void rlcUmmQSdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatReqInfo *datReq,
Buffer *mBuf));
-EXTERN Void kwUmmDiscSdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
+EXTERN Void rlcUmmDiscSdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
EXTERN Void rlcDlUmmReEstablish ARGS ((RlcCb *gCb,
CmLteRlcId rlcId,
Bool sndReEst,
RlcDlRbCb *rbCb));
-EXTERN Void kwUmmProcessSdus ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb,KwDatReq *datReq));
+EXTERN Void rlcUmmProcessSdus ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb,RlcDatReq *datReq));
-EXTERN Void kwUmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
+EXTERN Void rlcUmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
/****************************************************************************
* Acknowledged Mode Functions
***************************************************************************/
-EXTERN S32 kwAmmCalculateBo ARGS ((KwAmDl *amDl));
+EXTERN S32 rlcAmmCalculateBo ARGS ((RlcAmDl *amDl));
-EXTERN Void kwAmmSendDStaRsp ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, KwAmDl *amDl));
+EXTERN Void rlcAmmSendDStaRsp ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmDl *amDl));
-EXTERN Void kwAmmQSdu ARGS((RlcCb *gCb,
+EXTERN Void rlcAmmQSdu ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *mBuf,
KwuDatReqInfo *datReq));
-EXTERN Void kwAmmProcessSdus ARGS((RlcCb *gCb,
+EXTERN Void rlcAmmProcessSdus ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwDatReq *kwDatReq,
+ RlcDatReq *rlcDatReq,
Bool staPduPres));
-EXTERN Void kwAmmDlReEstablish ARGS((RlcCb *gCb,
+EXTERN Void rlcAmmDlReEstablish ARGS((RlcCb *gCb,
CmLteRlcId rlcId,
RlcDlRbCb *rbCb));
-EXTERN Void kwAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
+EXTERN Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- KwUdxStaPdu *pStaPdu));
+ RlcUdxStaPdu *pStaPdu));
-EXTERN S16 kwAmmDiscSdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
+EXTERN S16 rlcAmmDiscSdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
-EXTERN Void kwAmmPollRetxTmrExp ARGS((RlcCb *gCB, RlcDlRbCb *rbCb));
+EXTERN Void rlcAmmPollRetxTmrExp ARGS((RlcCb *gCB, RlcDlRbCb *rbCb));
-EXTERN Void kwAmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
+EXTERN Void rlcAmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
/****************************************************************************
* Utility Functions
***************************************************************************/
-EXTERN Void kwUtlStoreTxBuf ARGS ((CmLListCp *txBufLst,
- KwTx *txBuf,
- KwSn sn
+EXTERN Void rlcUtlStoreTxBuf ARGS ((CmLListCp *txBufLst,
+ RlcTx *txBuf,
+ RlcSn sn
));
-EXTERN KwTx* kwUtlGetTxBuf ARGS ((CmLListCp *txBufLst,
- KwSn sn
+EXTERN RlcTx* rlcUtlGetTxBuf ARGS ((CmLListCp *txBufLst,
+ RlcSn sn
));
-EXTERN Void kwUtlDelTxBuf ARGS ((CmLListCp *txBufLst,
- KwTx *txBuf,
+EXTERN Void rlcUtlDelTxBuf ARGS ((CmLListCp *txBufLst,
+ RlcTx *txBuf,
RlcCb *gCb
));
-EXTERN Void kwUtlRemovTxBuf ARGS ((CmLListCp *txBufLst,
- KwTx *txBuf,
+EXTERN Void rlcUtlRemovTxBuf ARGS ((CmLListCp *txBufLst,
+ RlcTx *txBuf,
RlcCb *gCb
));
-EXTERN S16 kwUtlSndDStaRsp ARGS ((RlcCb *gCb,
+EXTERN S16 rlcUtlSndDStaRsp ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
S32 bo,
S32 estHdrSz,
U32 staPduBo));
#ifdef LTE_L2_MEAS_RLC
-EXTERN Void kwUtlEmptySduQ ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, CmLListCp *sduQ));
+EXTERN Void rlcUtlEmptySduQ ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, CmLListCp *sduQ));
#else /* LTE_L2_MEAS */
-EXTERN Void kwUtlEmptySduQ ARGS ((RlcCb *gCb,CmLListCp *sduQ));
+EXTERN Void rlcUtlEmptySduQ ARGS ((RlcCb *gCb,CmLListCp *sduQ));
#endif /* LTE_L2_MEAS */
-EXTERN Void kwUtlCalcLiForSdu ARGS ((RlcCb *gCb,
+EXTERN Void rlcUtlCalcLiForSdu ARGS ((RlcCb *gCb,
U16 numLi,
MsgLen msgLen,
S16 *pduSz));
-EXTERN S16 kwUtlSndToLi ARGS ((RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo));
+EXTERN S16 rlcUtlSndToLi ARGS ((RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo));
-EXTERN Void kwUtlIncrementKwuStsSduTx ARGS((KwKwuSapCb *kwuSap));
+EXTERN Void rlcUtlIncrementKwuStsSduTx ARGS((RlcKwuSapCb *rlckwuSap));
-EXTERN Void kwUtlIncrementGenStsBytesAndPdusSent ARGS((KwGenSts *genSts,
+EXTERN Void rlcUtlIncrementGenStsBytesAndPdusSent ARGS((RlcGenSts *genSts,
Buffer *pdu));
-EXTERN Void kwUtlFreeDlMemory ARGS ((RlcCb *gCb));
+EXTERN Void rlcUtlFreeDlMemory ARGS ((RlcCb *gCb));
-EXTERN Void kwUtlInitToBeFreed ARGS ((RlcCb *gCb, RlcDlDataToBeFreed *toBeFreed));
+EXTERN Void rlcUtlInitToBeFreed ARGS ((RlcCb *gCb, RlcDlDataToBeFreed *toBeFreed));
-EXTERN Void kwUtlInitializeSelfPst ARGS((RlcCb *gCb));
+EXTERN Void rlcUtlInitializeSelfPst ARGS((RlcCb *gCb));
-EXTERN Void kwUtlRaiseDlCleanupEvent ARGS((RlcCb *gCb));
+EXTERN Void rlcUtlRaiseDlCleanupEvent ARGS((RlcCb *gCb));
-EXTERN Void kwUtlAddSduToBeFreedQueue ARGS((RlcCb *gCb, KwSdu *sdu));
+EXTERN Void rlcUtlAddSduToBeFreedQueue ARGS((RlcCb *gCb, RlcSdu *sdu));
-EXTERN Void kwUtlAddReTxPduToBeFreedQueue ARGS((RlcCb *gCb, KwRetx *retx));
+EXTERN Void rlcUtlAddReTxPduToBeFreedQueue ARGS((RlcCb *gCb, RlcRetx *retx));
-EXTERN Void kwUtlAddTxPduToBeFreedQueue ARGS((RlcCb *gCb, KwTx *pdu));
+EXTERN Void rlcUtlAddTxPduToBeFreedQueue ARGS((RlcCb *gCb, RlcTx *pdu));
#ifdef LTE_L2_MEAS
-EXTERN S16 kwUtlL2MeasDlInit ARGS((RlcCb *gCb));
+EXTERN S16 rlcUtlL2MeasDlInit ARGS((RlcCb *gCb));
#endif
/****************************************************************************
EXTERN Void rlcDlUtlSetReestInProgressForRB ARGS (( RlcCb *gCb, RlcDlRbCb *rbCb));
#ifdef LTE_L2_MEAS
-EXTERN Void kwUtlUpdateContainedSduLst ARGS ((
+EXTERN Void rlcUtlUpdateContainedSduLst ARGS ((
U8 sduIdx,
-KwContSduLst *contSduLst
+RlcContSduLst *contSduLst
));
-EXTERN Void kwUtlUpdateOutStandingSduLst ARGS ((
-KwL2MeasDlIpTh *dlIpThPut,
+EXTERN Void rlcUtlUpdateOutStandingSduLst ARGS ((
+RlcL2MeasDlIpTh *dlIpThPut,
U8 sduIdx,
MsgLen sduLen,
U32 sduId,
Bool newIdx
));
-EXTERN Void kwUtlUpdateBurstSdus ARGS((
+EXTERN Void rlcUtlUpdateBurstSdus ARGS((
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwContSduLst *contSduLst,
+RlcContSduLst *contSduLst,
S32 dataVol,
U32 schPduSz
));
-EXTERN KwL2MeasTb * kwUtlGetCurMeasTb ARGS((
+EXTERN RlcL2MeasTb * rlcUtlGetCurMeasTb ARGS((
RlcCb *gCb,
RlcDlRbCb *rbCb
));
-EXTERN S16 kwUtlSndDlL2MeasNCfm ARGS((RlcCb *gCb,
- KwL2MeasReqEvt *measReqEvt,
- KwL2MeasCfmEvt *measCfmEvt));
+EXTERN S16 rlcUtlSndDlL2MeasNCfm ARGS((RlcCb *gCb,
+ RlcL2MeasReqEvt *measReqEvt,
+ RlcL2MeasCfmEvt *measCfmEvt));
-EXTERN S16 kwUtlSndDlL2MeasCfm ARGS ((RlcCb *gCb, KwL2MeasEvtCb *measEvtCb));
+EXTERN S16 rlcUtlSndDlL2MeasCfm ARGS ((RlcCb *gCb, RlcL2MeasEvtCb *measEvtCb));
-EXTERN S16 kwUtlProcHarqInd ARGS (( RlcCb *gCb, RguHarqStatusInd *staInd, RlcDlUeCb *ueCb,
+EXTERN S16 rlcUtlProcHarqInd ARGS (( RlcCb *gCb, RguHarqStatusInd *staInd, RlcDlUeCb *ueCb,
U8 tbIdx));
-EXTERN Void kwUtlResetDlL2MeasInKwRb ARGS ((RlcCb *gCb,
- KwL2MeasCb *measCb,
+EXTERN Void rlcUtlResetDlL2MeasInRlcRb ARGS ((RlcCb *gCb,
+ RlcL2MeasCb *measCb,
U8 measType));
-EXTERN S16 KwMiLkwL2MeasStopCfm ARGS((Pst *pst, U8 measType,U8 status));
+EXTERN S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, U8 measType,U8 status));
-EXTERN S16 kwUtlValidateIpThL2Meas ARGS((KwL2MeasReqEvt *measReqEvt,
- KwL2MeasCfmEvt *measCfmEvt));
+EXTERN S16 rlcUtlValidateIpThL2Meas ARGS((RlcL2MeasReqEvt *measReqEvt,
+ RlcL2MeasCfmEvt *measCfmEvt));
-EXTERN S16 kwFetchLchInfo ARGS ((KwL2MeasReqEvt *measReqEvt,
- KwL2MeasCfmEvt *measCfmEvt,
+EXTERN S16 rlcFetchLchInfo ARGS ((RlcL2MeasReqEvt *measReqEvt,
+ RlcL2MeasCfmEvt *measCfmEvt,
U16 ueId,
CmLteLcId *lChId,
U8 *numLch));
-EXTERN S16 kwUtlNotifyMacUlIp ARGS ((KwL2MeasCb *measCb,U16 ueIdx, Bool enable,
+EXTERN S16 rlcUtlNotifyMacUlIp ARGS ((RlcL2MeasCb *measCb,U16 ueIdx, Bool enable,
CmLteLcId *lChId, U8 *numLCh));
#endif
-EXTERN Void kwUtlFreeDlMem ARGS(( Void));
+EXTERN Void rlcUtlFreeDlMem ARGS(( Void));
#ifdef __cplusplus
}
#endif /* __cplusplus */
#include "kw_dl.x"
#include "ctf.h"
-PUBLIC S16 kwUtlDlBatchProcPkts(Void);
-PUBLIC S16 rlcDlBatchProc(Void);
+S16 rlcUtlDlBatchProcPkts(Void);
+S16 rlcDlBatchProc(Void);
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
U32 isDatReqProcessed;
-PUBLIC void kwUtlDlBatchProcHqStaInd ARGS ((Void));
+void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
#endif
#if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
#endif
//UDAY
#ifdef L2_OPTMZ
-U32 kwAmmStaPduList[512] = {0};
+U32 rlcAmmStaPduList[512] = {0};
EXTERN S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
#endif
-PUBLIC S16 rlcDlInitExt ARGS (( Void ));
+S16 rlcDlInitExt ARGS (( Void ));
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 rlcDlInitExt
+S16 rlcDlInitExt
(
)
#else
-PUBLIC S16 rlcDlInitExt()
+S16 rlcDlInitExt()
#endif
{
TRC2(rlcDlInitExt);
*
*/
#ifdef ANSI
-PUBLIC S16 rlcDlActvInit
+S16 rlcDlActvInit
(
Ent ent, /* entity */
Inst inst, /* instance */
Reason reason /* reason */
)
#else
-PUBLIC S16 rlcDlActvInit(ent, inst, region, reason)
+S16 rlcDlActvInit(ent, inst, region, reason)
Ent ent; /* entity */
Inst inst; /* instance */
Region region; /* region */
SGetMsg(1, 0 , &mBuf);
ssGetDBufOfSize(1 , 1800, &bufPtr);
SUpdMsg(mBuf, bufPtr, 0);
- kwAmmStaPduList[i] = (U32)mBuf;
+ rlcAmmStaPduList[i] = (U32)mBuf;
}
#endif
/* call external function for intialization */
pthread_t gRlcTId = 0;
#endif
#ifdef ANSI
-PUBLIC S16 rlcDlActvTsk
+S16 rlcDlActvTsk
(
Pst *pst, /* pst structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 rlcDlActvTsk(pst, mBuf)
+S16 rlcDlActvTsk(pst, mBuf)
Pst *pst; /* pst structure */
Buffer *mBuf; /* message buffer */
#endif
#ifdef LCLKW
case LKW_EVT_CFG_REQ:
{
- ret = unpackRlcConfigReq(KwMiRlcConfigReq, pst, mBuf);
+ ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
break;
}
case LKW_EVT_CNTRL_REQ:
{
- ret = cmUnpkLkwCntrlReq(KwMiLkwCntrlReq, pst, mBuf);
+ ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
break;
}
case LKW_EVT_STS_REQ:
{
- ret = cmUnpkLkwStsReq(KwMiLkwStsReq, pst, mBuf);
+ ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
break;
}
case LKW_EVT_STA_REQ:
{
- ret = cmUnpkLkwStaReq(KwMiLkwStaReq, pst, mBuf);
+ ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
break;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LCKWU
case KWU_EVT_DAT_REQ: /* Data request */
{
- ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+ ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
break;
}
#endif /* LCKWU */
break;
}
- case ENTKW:
+ case ENTRLC:
{
switch(pst->event)
#endif /* LCCKW */
case UDX_EVT_DL_CLEANUP_MEM:
{
- kwUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
+ rlcUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
break;
}
#ifdef LCKWU
case KWU_EVT_BND_REQ: /* Bind request */
{
- ret = cmUnpkKwuBndReq(KwUiKwuBndReq, pst, mBuf );
+ ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
break;
}
case KWU_EVT_UBND_REQ: /* Unbind request */
{
- ret = cmUnpkKwuUbndReq(KwUiKwuUbndReq, pst, mBuf );
+ ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
break;
}
#ifdef L2_L3_SPLIT
case KWU_EVT_CPLANE_DAT_REQ: /* C-Plane Data request */
{
- ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+ ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
break;
}
#else
case KWU_EVT_DAT_REQ: /* Data request */
{
- ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+ ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
break;
}
#endif
case KWU_EVT_DISC_SDU_REQ: /* Discard SDU request */
{
- ret = cmUnpkKwuDiscSduReq(KwUiKwuDiscSduReq, pst, mBuf);
+ ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
break;
}
#ifdef LCKWU
case KWU_EVT_BND_REQ: /* Bind request */
{
- ret = cmUnpkKwuBndReq(KwUiKwuBndReq, pst, mBuf );
+ ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
break;
}
case KWU_EVT_UBND_REQ: /* Unbind request */
{
- ret = cmUnpkKwuUbndReq(KwUiKwuUbndReq, pst, mBuf );
+ ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
break;
}
#ifdef L2_L3_SPLIT
case KWU_EVT_CPLANE_DAT_REQ: /* C-Plane Data request */
case KWU_EVT_UPLANE_DAT_REQ: /* U-Plane Data request */
{
- ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+ ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
break;
}
#else
case KWU_EVT_DAT_REQ: /* Data request */
{
- ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+ ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
break;
}
#endif
case KWU_EVT_DISC_SDU_REQ: /* Discard SDU request */
{
- ret = cmUnpkKwuDiscSduReq(KwUiKwuDiscSduReq, pst, mBuf);
+ ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
break;
}
break;
}
- case ENTRG:
+ case ENTMAC:
{
switch(pst->event)
{
#ifdef LCRGU
case EVTRGUBNDCFM: /* Bind request */
{
- ret = cmUnpkRguBndCfm(KwLiRguBndCfm, pst, mBuf );
+ ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
break;
}
case EVTSCHREP: /* Dedicated Channel Status Response */
#ifdef LTE_L2_MEAS
case EVTRGUHQSTAIND: /* Harq status indication */
{
- ret = cmUnpkRguHqStaInd(KwLiRguHqStaInd, pst, mBuf);
+ ret = cmUnpkRguHqStaInd(RlcLiRguHqStaInd, pst, mBuf);
break;
}
#endif
case EVTRGUFLOWCNTRLIND:
{
- ret = cmUnpkRguFlowCntrlInd(KwLiRguFlowCntrlInd,pst,mBuf);
+ ret = cmUnpkRguFlowCntrlInd(RlcLiRguFlowCntrlInd,pst,mBuf);
break;
}
#endif /* LCRGU */
break;
}
#ifdef SS_RBUF
- case ENTTF:
+ case ENTLWRMAC:
{
switch(pst->event)
{
case EVTCTFBTCHPROCTICK:
{
- kwUtlDlBatchProcPkts();
+ rlcUtlDlBatchProcPkts();
break;
}
}
#if (defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
//RlcDlHarqStaBatchProc();
- kwUtlDlBatchProcHqStaInd();
+ rlcUtlDlBatchProcHqStaInd();
#endif
#ifndef KWSELFPSTDLCLEAN
/* Revanth_chg */
/* Moving Cleanup from self post event to TTI event */
- kwUtlFreeDlMem();
+ rlcUtlFreeDlMem();
#endif
ODU_PUT_MSG(mBuf);
#define __KWENVH__
#define MAX_RLC_INSTANCES 2
-#define KW_MAX_LI KWU_MAX_STA_IND_SDU
+#define RLC_MAX_LI KWU_MAX_STA_IND_SDU
-#define KW_MAX_DL_LI 28
-#define KW_MAX_NEW_DL_PDU 16
+#define RLC_MAX_DL_LI 28
+#define RLC_MAX_NEW_DL_PDU 16
/* kw003.201 Adding new environment variables */
/* This parameter is utilized when KW_BG_DL_PROC enbled. This parameter */
/* defines how many PDUs may be released in one go without affecting */
/* TTI response time */
/* kw004.201 modifed the value from 20 to 15 */
-#define KW_AM_MAX_PDUS_RLS 1
+#define RLC_AM_MAX_PDUS_RLS 1
/* This parameter governs maximum number of PDUs to processed at a */
/* given point when KW_BG_UL_PROC is enabled. */
/* kw004.201 modifed the value from 20 to 5 */
-#define KW_AM_MAX_UL_PDUS 1
+#define RLC_AM_MAX_UL_PDUS 1
-#define KW_AM_UM_MAX_UL_SDUS 1
-#define KW_AM_UM_MAX_DL_SDUS 300
+#define RLC_AM_UM_MAX_UL_SDUS 1
+#define RLC_AM_UM_MAX_DL_SDUS 300
#ifdef SPLIT_RLC_DL_TASK
-#define KW_MAX_TO_BE_FREED 60
+#define RLC_MAX_TO_BE_FREED 60
#else
-#define KW_MAX_TO_BE_FREED 10
+#define RLC_MAX_TO_BE_FREED 10
#endif
/* Number of packets queued in SDU Q after which overload
* START is signalled to PDCP for an UM bearer */
-#define KW_UM_RB_OVERLOAD_HIGH_THRES 512
+#define RLC_UM_RB_OVERLOAD_HIGH_THRES 512
/* Number of packets queued in SDU Q after which overload
* STOP is signalled to PDCP for an UM bearer */
-#define KW_UM_RB_OVERLOAD_LOW_THRES 300
+#define RLC_UM_RB_OVERLOAD_LOW_THRES 300
/* Value of this macro can be in the range of 1 to RGU_MAX_PDU */
-#define KW_MAX_PDU 16
+#define RLC_MAX_PDU 16
#ifdef LTE_L2_MEAS
/* This value is decided on the assumption that there will be maximum 3 active DRB at a time */
-#define KW_MAX_ACTV_DRB 2
+#define RLC_MAX_ACTV_DRB 2
/* Assumption is that all UEs wont have all RBs with max SDU: if greater, will be ignored */
-#define KW_L2MEAS_SDUIDX ((KW_MAX_DL_LI/4)*KW_MAX_ACTV_DRB)
+#define RLC_L2MEAS_SDUIDX ((RLC_MAX_DL_LI/4)*RLC_MAX_ACTV_DRB)
/* Number of out standing SDUS in one RbCb : This would be sufficient but anything more will be discarded for counters */
-#define KW_L2MEAS_MAX_OUTSTNGSDU 31
+#define RLC_L2MEAS_MAX_OUTSTNGSDU 31
#endif
#define __KW_ERR_H__
#if (ERRCLASS & ERRCLS_INT_PAR)
-#define KWLOGERROR(cb,errCls, errCode, errVal, errDesc) \
+#define RLCLOGERROR(cb,errCls, errCode, errVal, errDesc) \
SLogError(cb->init.ent, cb->init.inst, cb->init.procId, \
__FILE__, __LINE__, errCls, errCode, errVal, errDesc)
-#define KW_GET_AND_VALIDATE_KWUSAP(_spId, _kwuSap, _errCode, _fn) \
+#define RLC_GET_AND_VALIDATE_KWUSAP(_spId, _rlckwuSap, _errCode, _fn) \
{ \
S16 _ret; \
_ret = RFAILED; \
- _kwuSap = NULLP; \
+ _rlckwuSap = NULLP; \
if((_spId < (S16) rlcCb.genCfg.maxKwuSaps) && (_spId >= 0)) \
{ \
- _kwuSap = rlcCb.kwuSap + _spId; \
- if((_kwuSap != NULLP) && (_kwuSap->state == KW_SAP_BND)) \
+ _rlckwuSap = rlcCb.rlckwuSap + _spId; \
+ if((_rlckwuSap != NULLP) && (_rlckwuSap->state == RLC_SAP_BND)) \
{ \
_ret = ROK; \
} \
} \
if(_ret != ROK) \
{ \
- KWLOGERROR(ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId, \
- "KwUiKwuBndReq: KWU SAP State is Invalid during Bind Req"); \
- KW_SEND_SAPID_ALARM(spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);\
+ RLCLOGERROR(ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId, \
+ "RlcUiKwuBndReq: KWU SAP State is Invalid during Bind Req"); \
+ RLC_SEND_SAPID_ALARM(spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);\
return RFAILED; \
} \
}
#else
-#define KW_GET_AND_VALIDATE_KWUSAP(_spId, _kwuSap, _errCode, _fn) \
- _kwuSap = rlcCb.kwuSap + _spId;
-#define KWLOGERROR(cb, errCls, errCode, errVal, errDesc)
+#define RLC_GET_AND_VALIDATE_KWUSAP(_spId, _rlckwuSap, _errCode, _fn) \
+ _rlckwuSap = rlcCb.rlckwuSap + _spId;
+#define RLCLOGERROR(cb, errCls, errCode, errVal, errDesc)
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
-#define KW_GET_AND_VALIDATE_CKWSAP(_cb,_ckwSap, _errCode, _fn) \
+#define RLC_GET_AND_VALIDATE_CKWSAP(_cb,_ckwSap, _errCode, _fn) \
{ \
S16 _ret; \
_ret = RFAILED; \
- if((_ckwSap != NULLP) && (_ckwSap->state == KW_SAP_BND)) \
+ if((_ckwSap != NULLP) && (_ckwSap->state == RLC_SAP_BND)) \
{ \
_ret = ROK; \
} \
if(_ret != ROK) \
{ \
- KWLOGERROR(_cb,ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId,\
- "KwUiCkwBndReq: CKW SAP State is Invalid during Bind Req");\
- KW_SEND_SAPID_ALARM(_cb,spId, LKW_EVENT_CKW_BND_REQ, LCM_CAUSE_INV_STATE);\
+ RLCLOGERROR(_cb,ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId,\
+ "RlcUiCkwBndReq: CKW SAP State is Invalid during Bind Req");\
+ RLC_SEND_SAPID_ALARM(_cb,spId, LKW_EVENT_CKW_BND_REQ, LCM_CAUSE_INV_STATE);\
return RFAILED; \
} \
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
-#define KW_GET_AND_VALIDATE_UDXSAP(_cb,_udxSap, _errCode, _fn) \
+#define RLC_GET_AND_VALIDATE_UDXSAP(_cb,_udxSap, _errCode, _fn) \
{ \
S16 _ret; \
_ret = RFAILED; \
- if((_udxSap != NULLP) && (_udxSap->state == KW_SAP_BND)) \
+ if((_udxSap != NULLP) && (_udxSap->state == RLC_SAP_BND)) \
{ \
_ret = ROK; \
} \
if(_ret != ROK) \
{ \
- KWLOGERROR(_cb,ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId,\
- "KwUiCkwBndReq: UDX SAP State is Invalid during Bind Req");\
- KW_SEND_SAPID_ALARM(_cb,spId, LKW_EVENT_UDX_BND_REQ, LCM_CAUSE_INV_STATE);\
+ RLCLOGERROR(_cb,ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId,\
+ "RlcUiCkwBndReq: UDX SAP State is Invalid during Bind Req");\
+ RLC_SEND_SAPID_ALARM(_cb,spId, LKW_EVENT_UDX_BND_REQ, LCM_CAUSE_INV_STATE);\
return RFAILED; \
} \
}
\f
/* local defines */
-#define KWSWMV 2 /* rlc - main version */
-#define KWSWMR 1 /* rlc - main revision */
-#define KWSWBV 0 /* rlc - branch version */
-#define KWSWBR 5 /* rlc - kw005.201 patch level */
-#define KWSWPN "1000371" /* rlc - part number */
+#define RLCSWMV 2 /* rlc - main version */
+#define RLCSWMR 1 /* rlc - main revision */
+#define RLCSWBV 0 /* rlc - branch version */
+#define RLCSWBR 5 /* rlc - kw005.201 patch level */
+#define RLCSWPN "1000371" /* rlc - part number */
/* local typedefs */
EXTERN "C" {
#endif /* CPLUSPLUS */
-EXTERN S16 kwGetSId ARGS((SystemId *s));
+EXTERN S16 rlcGetSId ARGS((SystemId *s));
#ifdef __cplusplus
}
#endif /* CPLUSPLUS */
/* copyright banner */
-PUBLIC CONSTANT Txt kwBan1[] =
+CONSTANT Txt rlcBan1[] =
{"(c) COPYRIGHT 1989-2002, Trillium Digital Systems, Inc."};
-PUBLIC CONSTANT Txt kwBan2[] =
+CONSTANT Txt rlcBan2[] =
{" All rights reserved."};
/* system id */
PRIVATE CONSTANT SystemId sId ={
- KWSWMV, /* rlc - main version */
- KWSWMR, /* rlc - main revision */
- KWSWBV, /* rlc - branch version */
- KWSWBR, /* rlc - branch revision */
- KWSWPN /* rlc - part number */
+ RLCSWMV, /* rlc - main version */
+ RLCSWMR, /* rlc - main revision */
+ RLCSWBV, /* rlc - branch version */
+ RLCSWBR, /* rlc - branch revision */
+ RLCSWPN /* rlc - part number */
};
/*
*/
#ifdef ANSI
-PUBLIC S16 kwGetSId
+S16 rlcGetSId
(
SystemId *s /* system id */
)
#else
-PUBLIC S16 kwGetSId(s)
+S16 rlcGetSId(s)
SystemId *s; /* system id */
#endif
{
- TRC2(kwGetSId);
+ TRC2(rlcGetSId);
s->mVer = sId.mVer;
s->mRev = sId.mRev;
return (TRUE);
-} /* end of kwGetSId */
+} /* end of rlcGetSId */
\f
/********************************************************************30**
Desc: Source code for RLC Lower Interface Module.
This file contains following functions
- --KwLiRguBndCfm
- --KwLiRguCDatInd
- --KwLiRguDDatInd
- --KwLiRguCStaInd
- --KwLiRguDStaInd
- --KwLiRguHqStaInd
+ --RlcLiRguBndCfm
+ --RlcLiRguCDatInd
+ --RlcLiRguDDatInd
+ --RlcLiRguCStaInd
+ --RlcLiRguDStaInd
+ --RlcLiRguHqStaInd
File: kw_lim.c
* @brief RLC Lower Interface module
*/
-#define KW_MODULE KW_DBGMASK_INF
+#define RLC_MODULE RLC_DBGMASK_INF
\f
/* header (.h) include files */
*
* @details
* This function handles the bind confirmation received from MAC. If the
- * bind was successful changes the state of the SAP to KW_SAP_BND
- * else KW_SAP_CFG. Sends an alarm to LM in any case
+ * bind was successful changes the state of the SAP to RLC_SAP_BND
+ * else RLC_SAP_CFG. Sends an alarm to LM in any case
*
* @param[in] pst Post structure
* @param[in] suId Service User ID
*
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguBndCfm
+S16 RlcLiRguBndCfm
(
Pst *pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 KwLiRguBndCfm (pst, suId, status)
+S16 RlcLiRguBndCfm (pst, suId, status)
Pst *pst;
SuId suId;
U8 status;
{
U16 event; /* Event */
U16 cause; /* Cause */
- KwRguSapCb *rguSap; /* RGU SAP Control Block */
+ RlcRguSapCb *rguSap; /* RGU SAP Control Block */
RlcCb *tRlcCb;
- TRC3(KwLiRguBndCfm)
+ TRC3(RlcLiRguBndCfm)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- RLOG2(L_DEBUG,"KwLiRguBndCfm(suId(%d), status(%d)", suId, status);
+ RLOG2(L_DEBUG,"RlcLiRguBndCfm(suId(%d), status(%d)", suId, status);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (tRlcCb->init.cfgDone != TRUE)
{
RLOG0(L_FATAL,"General configuration not done");
- KW_SEND_SAPID_ALARM(tRlcCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
return RFAILED;
}
{
RLOG0(L_ERROR, "Invalid suId");
- KW_SEND_SAPID_ALARM(tRlcCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
return RFAILED;
}
rguSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
&(tRlcCb->u.dlCb->rguDlSap[suId]) : &(tRlcCb->u.ulCb->rguUlSap[suId]);
- RLOG1(L_DEBUG, "KwLiRguBndCfm: For RGU SAP state=%d", rguSap->state)
+ RLOG1(L_DEBUG, "RlcLiRguBndCfm: For RGU SAP state=%d", rguSap->state)
switch (rguSap->state)
{
- case KW_SAP_BINDING:
+ case RLC_SAP_BINDING:
{
- kwStopTmr (tRlcCb,(PTR)rguSap, KW_EVT_WAIT_BNDCFM);
+ rlcStopTmr (tRlcCb,(PTR)rguSap, RLC_EVT_WAIT_BNDCFM);
rguSap->retryCnt = 0;
if (status == CM_BND_OK)
{
- rguSap->state = KW_SAP_BND;
+ rguSap->state = RLC_SAP_BND;
event = LCM_EVENT_BND_OK;
cause = LKW_CAUSE_SAP_BNDENB;
}
else
{
- rguSap->state = KW_SAP_CFG;
+ rguSap->state = RLC_SAP_CFG;
event = LCM_EVENT_BND_FAIL;
cause = LKW_CAUSE_UNKNOWN;
}
}
/* Send an alarm with proper event and cause */
- KW_SEND_SAPID_ALARM(tRlcCb, suId, event, cause);
+ RLC_SEND_SAPID_ALARM(tRlcCb, suId, event, cause);
- return ROK;
-} /* KwLiRguBndCfm */
+ return (ROK);
+} /* RlcLiRguBndCfm */
/**
* @brief Handler to process PDU received from MAC
SCpyFixMsg(ulData->pduInfo[idx].pduBuf, cLchUlDat->pdu, 0, \
ulData->pduInfo[idx].pduLen, (MsgLen *)©Len);
- KwLiRguCDatInd(pst, 0, cLchUlDat);
+ RlcLiRguCDatInd(pst, 0, cLchUlDat);
}
else
{
}
}
dLchUlDat->numLch = numDLch;
- KwLiRguDDatInd(pst, 0, dLchUlDat);
+ RlcLiRguDDatInd(pst, 0, dLchUlDat);
}
}/* End of RlcProcUlData */
-PUBLIC int rlcDDatIndRcvd;
-PUBLIC int rlcCDatIndRcvd;
+int rlcDDatIndRcvd;
+int rlcCDatIndRcvd;
/**
* @brief Handler to process PDU received from MAC for common logical channels.
*
*
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguCDatInd
+S16 RlcLiRguCDatInd
(
Pst *pst,
SuId suId,
RguCDatIndInfo *datInd
)
#else
-PUBLIC S16 KwLiRguCDatInd(pst,suId,datInd)
+S16 RlcLiRguCDatInd(pst,suId,datInd)
Pst *pst;
SuId suId;
RguCDatIndInfo *datInd;
RlcCb *tRlcCb;
rlcCDatIndRcvd++;
- TRC3(KwLiRguCDatInd)
+ TRC3(RlcLiRguCDatInd)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
/* kw006.201 ccpu00120058, Added array boundary condition check */
#if (ERRCLASS & ERRCLS_DEBUG)
- if(KW_MAX_LCH_PER_CELL <= datInd->lcId)
+ if(RLC_MAX_LCH_PER_CELL <= datInd->lcId)
{
RLOG_ARG1(L_ERROR,DBG_LCID,datInd->lcId, "Invalid LcId, Max is [%d]",
- KW_MAX_LCH_PER_CELL);
+ RLC_MAX_LCH_PER_CELL);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
/* Fetch RbCb from lcId */
- kwDbmFetchUlRbCbFromLchId(tRlcCb, datInd->rnti, datInd->cellId, datInd->lcId, &rbCb);
+ rlcDbmFetchUlRbCbFromLchId(tRlcCb, datInd->rnti, datInd->cellId, datInd->lcId, &rbCb);
if (!rbCb)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,datInd->cellId, "LcId [%d] not found",
/* Dispatch to TM Module */
#ifdef CCPU_OPT
- kwTmmRcvFrmLi(tRlcCb, rbCb, datInd->rnti, datInd->pdu);
+ rlcTmmRcvFrmLi(tRlcCb, rbCb, datInd->rnti, datInd->pdu);
#else /* CCPU_OPT */
- kwTmmRcvFrmLi(tRlcCb, rbCb, datInd->pdu);
+ rlcTmmRcvFrmLi(tRlcCb, rbCb, datInd->pdu);
#endif /* CCPU_OPT */
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- return ROK;
-} /* KwLiRguCDatInd */
+ return (ROK);
+} /* RlcLiRguCDatInd */
/**
* @brief Handler to process PDU received from MAC for
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguDDatInd
+S16 RlcLiRguDDatInd
(
Pst *pst,
SuId suId,
RguDDatIndInfo *datInd
)
#else
-PUBLIC S16 KwLiRguDDatInd(pst, suId, datInd)
+S16 RlcLiRguDDatInd(pst, suId, datInd)
Pst *pst;
SuId suId;
RguDDatIndInfo *datInd;
#endif
{
- TRC3(KwLiRguDDatInd)
+ TRC3(RlcLiRguDDatInd)
rlcDDatIndRcvd++;
#if (ERRCLASS & ERRCLS_INT_PAR)
#if (ERRCLASS & ERRCLS_DEBUG)
if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- RLOG1(L_DEBUG,"KwLiRguDDatInd(pst, suId(%d))recieved in DL Inst",suId);
+ RLOG1(L_DEBUG,"RlcLiRguDDatInd(pst, suId(%d))recieved in DL Inst",suId);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
return RFAILED;
}
#endif
- kwUtlRcvFrmLi(RLC_GET_RLCCB(pst->dstInst),datInd);
+ rlcUtlRcvFrmLi(RLC_GET_RLCCB(pst->dstInst),datInd);
#ifndef SS_RBUF
#ifdef SS_LOCKLESS_MEMORY
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
#endif
#endif
- return ROK;
-} /* KwLiRguDDatInd */
+ return (ROK);
+} /* RlcLiRguDDatInd */
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-PUBLIC uint16_t RlcMacProcSchedRep(Pst *pst, SuId suId, RlcMacSchedRepInfo *schRep)
+uint16_t RlcMacProcSchedRep(Pst *pst, SuId suId, RlcMacSchedRepInfo *schRep)
{
U8 idx; /* Iterator */
U8 nmbDLch = 0; /* Number of dedicated logical channles */
//cLchSchInfo->transId = schRep->timeToTx; /* TODO : fill transId suing timeToTx */
cLchSchInfo->rnti = schRep->rnti;
- KwLiRguCStaInd(pst, suId, cLchSchInfo);
+ RlcLiRguCStaInd(pst, suId, cLchSchInfo);
}
else
if(nmbDLch)
{
dLchSchInfo->staInd[0].staIndTb[0].nmbLch = nmbDLch;
- KwLiRguDStaInd(pst, suId, dLchSchInfo);
+ RlcLiRguDStaInd(pst, suId, dLchSchInfo);
}
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRepInfo));
*
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguCStaInd
+S16 RlcLiRguCStaInd
(
Pst *pst,
SuId suId,
RguCStaIndInfo *staInd
)
#else
-PUBLIC S16 KwLiRguCStaInd(pst,suId,staInd)
+S16 RlcLiRguCStaInd(pst,suId,staInd)
Pst *pst;
SuId suId;
RguCStaIndInfo *staInd;
RlcDlRbCb *rbCb;
RlcCb *tRlcCb;
- TRC3(KwLiRguCStaInd)
+ TRC3(RlcLiRguCStaInd)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
{
- KWLOGERROR(tRlcCb,
+ RLCLOGERROR(tRlcCb,
ERRCLS_INT_PAR,
EKW040,
(ErrVal) suId,
- "KwLiRguCStaInd: Invalid RGU suId\n");
- return RFAILED;
+ "RlcLiRguCStaInd: Invalid RGU suId\n");
+ return (RFAILED);
}
if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
/* kw006.201 ccpu00120058, added boundary condition check */
#if (ERRCLASS & ERRCLS_DEBUG)
- if(KW_MAX_LCH_PER_CELL < staInd->lcId)
+ if(RLC_MAX_LCH_PER_CELL < staInd->lcId)
{
RLOG_ARG2(L_ERROR,DBG_LCID,staInd->lcId,
"Invalid LcId, Max is [%d] CELLID:%d",
- KW_MAX_LCH_PER_CELL,
+ RLC_MAX_LCH_PER_CELL,
staInd->cellId);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
/* Fertch RbCb from lcId */
- kwDbmFetchDlRbCbFromLchId(tRlcCb,0, staInd->cellId, staInd->lcId, &rbCb);
+ rlcDbmFetchDlRbCbFromLchId(tRlcCb,0, staInd->cellId, staInd->lcId, &rbCb);
if(!rbCb)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,staInd->cellId,
if(tRlcCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(tRlcCb,EVTRGUCSTAIND, NULLP);
+ rlcLmmSendTrc(tRlcCb,EVTRGUCSTAIND, NULLP);
}
- kwTmmSndToLi(tRlcCb, suId, rbCb, staInd);
+ rlcTmmSndToLi(tRlcCb, suId, rbCb, staInd);
#ifndef SS_RBUF
#ifdef SS_LOCKLESS_MEMORY
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
#else
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
#endif
- return ROK;
-} /* KwLiRguCStaInd */
+ return (ROK);
+} /* RlcLiRguCStaInd */
/**
* @brief Handler for trigerring the data transfer from RLC to MAC
*
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguDStaInd
+S16 RlcLiRguDStaInd
(
Pst *pst,
SuId suId,
RguDStaIndInfo *staInd
)
#else
-PUBLIC S16 KwLiRguDStaInd(pst, suId, staInd)
+S16 RlcLiRguDStaInd(pst, suId, staInd)
Pst *pst;
SuId suId;
RguDStaIndInfo *staInd;
#endif
{
RlcCb *gCb;
- TRC3(KwLiRguDStaInd)
+ TRC3(RlcLiRguDStaInd)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
}
if ((suId >= gCb->genCfg.maxRguSaps) || (suId < 0))
{
- KWLOGERROR(gCb,
+ RLCLOGERROR(gCb,
ERRCLS_INT_PAR,
EKW040,
(ErrVal) suId,
- "KwLiRguDStaInd: Invalid RGU suId\n");
- return RFAILED;
+ "RlcLiRguDStaInd: Invalid RGU suId\n");
+ return (RFAILED);
}
#endif
- kwUtlSndToLi(gCb, suId, staInd);
+ rlcUtlSndToLi(gCb, suId, staInd);
/* kw002.201 :Freeing from proper region */
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
- return ROK;
-} /* KwLiRguDStaInd */
+ return (ROK);
+} /* RlcLiRguDStaInd */
/**
* @brief Handler for handling the flow cntrl Ind from MAC
*
* @details
* This function receives the flow control indication from
- * MAC and calls kwUtlTrigPdbFlowCntrl
+ * MAC and calls rlcUtlTrigPdbFlowCntrl
*
* @param[in] pst Post structure
* @param[in] suId Service User ID
*
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguFlowCntrlInd
+S16 RlcLiRguFlowCntrlInd
(
Pst *pst,
SuId suId,
RguFlowCntrlInd *flowCntrlInd
)
#else
-PUBLIC S16 KwLiRguFlowCntrlInd(pst, suId, flowCntrlInd)
+S16 RlcLiRguFlowCntrlInd(pst, suId, flowCntrlInd)
Pst *pst;
SuId suId;
RguFlowCntrlInd *flowCntrlInd;
for (lcIdx = 0; lcIdx < flowCntrlInd->ueFlowCntrlInfo[idx].numLcs; lcIdx++)
{
RguLcFlowCntrlInfo *lcInfo = &(flowCntrlInd->ueFlowCntrlInfo[idx].lcInfo[lcIdx]);
- kwDbmFetchDlRbCbFromLchId(tRlcCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb);
+ rlcDbmFetchDlRbCbFromLchId(tRlcCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb);
if (rbCb)
{
if (lcInfo->pktAdmitCnt == 0) /* Special case */
{
- kwUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
+ rlcUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
continue;
}
if (rbCb->mode == CM_LTE_MODE_AM)
continue;
}
}
- kwUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
+ rlcUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
}
}
}
*
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguHqStaInd
+S16 RlcLiRguHqStaInd
(
Pst *pst,
SuId suId,
RguHarqStatusInd *staInd
)
#else
-PUBLIC S16 KwLiRguHqStaInd(pst,suId,staInd)
+S16 RlcLiRguHqStaInd(pst,suId,staInd)
Pst *pst;
SuId suId;
RguHarqStatusInd *staInd;
#endif
{
- KwUeKey ueKey;
+ RlcUeKey ueKey;
S16 ret;
RlcDlUeCb *ueCb;
U8 tbIdx;
RlcCb *tRlcCb;
- TRC3(KwLiRguHqStaInd)
+ TRC3(RlcLiRguHqStaInd)
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
ueKey.cellId = staInd->cellId;
ueKey.ueId = staInd->ueId;
- ret = kwDbmFetchDlUeCb(tRlcCb, ueKey.ueId, ueKey.cellId, &ueCb);
+ ret = rlcDbmFetchDlUeCb(tRlcCb, ueKey.ueId, ueKey.cellId, &ueCb);
if (ret != ROK )
{
return RFAILED;
}
- /*Call kwUtlProcHarqInd as many times as number of Tbs present*/
+ /*Call rlcUtlProcHarqInd as many times as number of Tbs present*/
for ( tbIdx = 0; tbIdx < staInd->numTbs; tbIdx++)
{
- kwUtlProcHarqInd(tRlcCb, staInd, ueCb, tbIdx);
+ rlcUtlProcHarqInd(tRlcCb, staInd, ueCb, tbIdx);
}
- return ROK;
-} /* KwLiRguHqStaInd */
+ return (ROK);
+} /* RlcLiRguHqStaInd */
#endif /* LTE_L2_MEAS */
#ifdef __cplusplus
Desc: It contains the following common functions for processing
the all the external interfaces.
- -- KwMiRlcConfigReq
- -- KwMiRlcConfigCfm
- -- KwMiLkwCntrlReq
- -- KwMiLkwCntrlCfm
- -- KwMiLkwStaReq
- -- KwMiLkwStaCfm
- -- KwMiLkwStaInd
- -- KwMiLkwStsReq
- -- KwMiLkwStsCfm
- -- KwMiLkwTrcInd
+ -- RlcMiRlcConfigReq
+ -- RlcMiRlcConfigCfm
+ -- RlcMiLkwCntrlReq
+ -- RlcMiLkwCntrlCfm
+ -- RlcMiLkwStaReq
+ -- RlcMiLkwStaCfm
+ -- RlcMiLkwStaInd
+ -- RlcMiLkwStsReq
+ -- RlcMiLkwStsCfm
+ -- RlcMiLkwTrcInd
File: kw_lmm.c
#include "kw_dl.x"
#include "kw_ul.x"
-#define KW_MODULE KW_DBGMASK_LMM
+#define RLC_MODULE RLC_DBGMASK_LMM
RLCStats gRlcStats;
\f
/*********************************************************************
* Forward Declaration of LKW Porting Functions
********************************************************************/
-PUBLIC RlcCb *rlcCb[MAX_RLC_INSTANCES];
-EXTERN S16 kwActvTmr ARGS ((Ent ent, Inst inst));
+RlcCb *rlcCb[MAX_RLC_INSTANCES];
+EXTERN S16 rlcActvTmr ARGS ((Ent ent, Inst inst));
-PRIVATE Void kwLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,KwMngmt *cfm,U8 type,
+PRIVATE Void rlcLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,RlcMngmt *cfm,U8 type,
Header *hdr));
-PRIVATE S16 kwLmmGenCfg ARGS ((RlcCb *gCb, KwGenCfg *cfg));
-PRIVATE S16 kwLmmCfgKwuSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmCfgUdxSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmCfgCkwSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmCfgRguSap ARGS ((RlcCb *gCb,KwSapCfg *cfg));
-PRIVATE S16 kwLmmGenCntrl ARGS ((RlcCb *gCb,KwMngmt *cntrl));
-PRIVATE S16 kwLmmUdxSapCntrl ARGS ((RlcCb *gCb,KwMngmt *cntrl));
-PRIVATE S16 kwLmmLSapCntrl ARGS ((RlcCb *gCb,KwMngmt *cntrl));
-PRIVATE S16 kwLmmGetKwuSapSta ARGS ((RlcCb *gCb,KwKwuSapSta *sta));
-PRIVATE S16 kwLmmGetRguSapSta ARGS ((RlcCb *gCb,KwRguSapSta *sta));
-PRIVATE S16 kwLmmGetCkwCntSapSta ARGS ((RlcCb *gCb,KwCkwCntSapSta *sta));
-PRIVATE S16 kwLmmGetGenSts ARGS ((RlcCb *gCb,KwGenSts *sts,Action action));
-PRIVATE S16 kwLmmGetSapSts ARGS ((RlcCb *gCb,KwMngmt *sts,Elmnt elmnt,Action
+PRIVATE S16 rlcLmmGenCfg ARGS ((RlcCb *gCb, RlcGenCfg *cfg));
+PRIVATE S16 rlcLmmCfgKwuSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+PRIVATE S16 rlcLmmCfgUdxSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+PRIVATE S16 rlcLmmCfgCkwSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+PRIVATE S16 rlcLmmCfgRguSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
+PRIVATE S16 rlcLmmGenCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
+PRIVATE S16 rlcLmmUdxSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
+PRIVATE S16 rlcLmmLSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
+PRIVATE S16 rlcLmmGetKwuSapSta ARGS ((RlcCb *gCb,RlcKwuSapSta *sta));
+PRIVATE S16 rlcLmmGetRguSapSta ARGS ((RlcCb *gCb,RlcRguSapSta *sta));
+PRIVATE S16 rlcLmmGetCkwCntSapSta ARGS ((RlcCb *gCb,RlcCkwCntSapSta *sta));
+PRIVATE S16 rlcLmmGetGenSts ARGS ((RlcCb *gCb,RlcGenSts *sts,Action action));
+PRIVATE S16 rlcLmmGetSapSts ARGS ((RlcCb *gCb,RlcMngmt *sts,Elmnt elmnt,Action
action));
\f
* LCM_REASON_HASHING_FAILED
*/
#ifdef ANSI
-PRIVATE S16 kwLmmGenCfg
+PRIVATE S16 rlcLmmGenCfg
(
RlcCb *gCb,
-KwGenCfg *cfg
+RlcGenCfg *cfg
)
#else
-PRIVATE S16 kwLmmGenCfg(gCB,cfg)
+PRIVATE S16 rlcLmmGenCfg(gCB,cfg)
RlcCb *gCb;
-KwGenCfg *cfg;
+RlcGenCfg *cfg;
#endif
{
- Size kwSapSize;
- Size kwUdxSapSize;
+ Size rlcSapSize;
+ Size rlcUdxSapSize;
S16 ret;
- CmTqCp *kwTqCp;
+ CmTqCp *rlcTqCp;
Size rguSapSize;
- TRC2(kwLmmGenCfg)
+ TRC2(rlcLmmGenCfg)
- if(cfg->maxUe > KW_MAX_UE)
+ if(cfg->maxUe > RLC_MAX_UE)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
RLOG2(L_ERROR, "Invalid maxUe : Max [%lu] Received [%lu]",
- KW_MAX_UE,
+ RLC_MAX_UE,
cfg->maxUe);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
return (LCM_REASON_INVALID_PAR_VAL);
}
- if(cfg->maxKwuSaps > KW_MAX_KWUSAPS)
+ if(cfg->maxKwuSaps > RLC_MAX_KWUSAPS)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
RLOG2(L_ERROR, "Invalid maxKwuSaps : Max [%lu] Received [%lu]",
- KW_MAX_KWUSAPS,
+ RLC_MAX_KWUSAPS,
cfg->maxKwuSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
return (LCM_REASON_INVALID_PAR_VAL);
}
- if(cfg->maxUdxSaps > KW_MAX_UDXSAPS)
+ if(cfg->maxUdxSaps > RLC_MAX_UDXSAPS)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
RLOG2(L_ERROR, "Invalid maxUduSaps : Max [%lu] Received [%lu]",
- KW_MAX_UDXSAPS,
+ RLC_MAX_UDXSAPS,
cfg->maxUdxSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
return (LCM_REASON_INVALID_PAR_VAL);
}
- if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > KW_MAX_RGUSAPS))
+ if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > RLC_MAX_RGUSAPS))
{
gCb->genCfg = *cfg;
/* Timer Queue Control point initialization */
- kwTqCp = &(gCb->kwTqCp);
- kwTqCp->tmrLen = KW_TMR_LEN;
- kwTqCp->nxtEnt = 0;
+ rlcTqCp = &(gCb->rlcTqCp);
+ rlcTqCp->tmrLen = RLC_TMR_LEN;
+ rlcTqCp->nxtEnt = 0;
if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
}
/* allocate memory to the KWU sap's */
- kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
- (Size)sizeof(KwKwuSapCb));
+ rlcSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
+ (Size)sizeof(RlcKwuSapCb));
- RLC_ALLOC(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_ALLOC(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if(gCb->u.dlCb->kwuDlSap == NULLP)
+ if(gCb->u.dlCb->rlcKwuDlSap == NULLP)
{
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
gCb->u.dlCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
- kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
- (Size)sizeof(KwUdxDlSapCb));
+ rlcUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
+ (Size)sizeof(RlcUdxDlSapCb));
- RLC_ALLOC(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
+ RLC_ALLOC(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.dlCb->udxDlSap == NULLP)
{
- RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
- (Size)sizeof(KwRguSapCb));
+ (Size)sizeof(RlcRguSapCb));
RLC_ALLOC(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.dlCb->rguDlSap == NULLP)
{
- RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
- RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
- "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
+ RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
+ "rlcLmmGenCfg: SgetSBuf Failed for rguSap...!");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Initialize the Ue and Cell hash list */
- ret = kwDbmDlInit(gCb);
+ ret = rlcDbmDlInit(gCb);
if (ret != ROK)
{
- RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
- RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"RLC DL Initialization failed");
/* Register the timer */
/*Pradeep: changing the SRegTmrMt() to SRegTmr()*/
if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
- kwActvTmr) != ROK)
+ rlcActvTmr) != ROK)
{
- RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
- RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
}
#endif
/* initializations for background processing of freeing memory */
- kwUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
- kwUtlInitializeSelfPst(gCb);
+ rlcUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
+ rlcUtlInitializeSelfPst(gCb);
if(SGetMsg(gCb->init.region,
gCb->init.pool,
&(gCb->u.dlCb->selfPstMBuf)) != ROK)
{
- RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
- RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
}
#ifdef LTE_L2_MEAS
- kwUtlL2MeasDlInit(gCb);
+ rlcUtlL2MeasDlInit(gCb);
#endif
}
else if(gCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
}
/* allocate memory to the KWU sap's */
- kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
- (Size)sizeof(KwKwuSapCb));
+ rlcSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
+ (Size)sizeof(RlcKwuSapCb));
- RLC_ALLOC(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_ALLOC(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if(gCb->u.ulCb->kwuUlSap == NULLP)
+ if(gCb->u.ulCb->rlcKwuUlSap == NULLP)
{
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
gCb->u.ulCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
/* allocate memory to the KWU sap's */
- kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
- (Size)sizeof(KwUdxUlSapCb));
+ rlcUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
+ (Size)sizeof(RlcUdxUlSapCb));
- RLC_ALLOC(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
+ RLC_ALLOC(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if(gCb->u.ulCb->kwuUlSap == NULLP)
+ if(gCb->u.ulCb->rlcKwuUlSap == NULLP)
{
- RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
- (Size)sizeof(KwRguSapCb));
+ (Size)sizeof(RlcRguSapCb));
RLC_ALLOC(gCb,gCb->u.ulCb->rguUlSap, rguSapSize);
#if (ERRCLASS & ERRCLS_INT_PAR)
if(gCb->u.ulCb->rguUlSap == NULLP)
{
- RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
- RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
- "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
+ RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
+ "rlcLmmGenCfg: SgetSBuf Failed for rguSap...!");
return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Initialize the Ue and Cell hash list */
- ret = kwDbmUlInit(gCb);
+ ret = rlcDbmUlInit(gCb);
if (ret != ROK)
{
- RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
- RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
- RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"RLC DL Initialization failed");
}
/* Register the timer */
#if 0
if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
- kwActvTmr) != ROK)
+ rlcActvTmr) != ROK)
{
- RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
- RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
- RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
return (LCM_REASON_REGTMR_FAIL);
}
#endif
#ifdef LTE_L2_MEAS
- kwUtlL2MeasUlInit(gCb);
+ rlcUtlL2MeasUlInit(gCb);
#endif
}
else
return (LCM_REASON_INVALID_PAR_VAL);
}
/* Timer Initialization */
- gCb->kwTqCp.tmrLen = KW_TMR_LEN;
+ gCb->rlcTqCp.tmrLen = RLC_TMR_LEN;
- cmMemset((U8*)gCb->kwTq, NULLP, sizeof(CmTqType) * KW_TMR_LEN);
+ cmMemset((U8*)gCb->rlcTq, NULLP, sizeof(CmTqType) * RLC_TMR_LEN);
- KW_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
+ RLC_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
gCb->init.lmPst.srcProcId = gCb->init.procId;
gCb->init.lmPst.srcEnt = gCb->init.ent;
/**
* @brief
- * Sends confirmation message to LM Called by KwMiRlcConfigReq function
+ * Sends confirmation message to LM Called by RlcMiRlcConfigReq function
*
* @param[in] gCb RLC Instance Control Block
* @param[in] pst Post structure
* -# ROK
*/
#ifdef ANSI
-PRIVATE Void kwLmmSendCfm
+PRIVATE Void rlcLmmSendCfm
(
RlcCb *gCb,
Pst *pst,
-KwMngmt *cfm,
+RlcMngmt *cfm,
U8 type,
Header *hdr
)
#else
-PRIVATE Void kwLmmSendCfm(gCb,pst, cfm, type, hdr)
+PRIVATE Void rlcLmmSendCfm(gCb,pst, cfm, type, hdr)
RlcCb gCb;
Pst *pst;
-KwMngmt *cfm;
+RlcMngmt *cfm;
U8 type;
Header *hdr;
#endif
{
Pst rPst; /* Reply post structure */
- TRC2(kwLmmSendCfm);
+ TRC2(rlcLmmSendCfm);
RLC_MEM_SET(&rPst, 0, sizeof(Pst));
switch(type)
{
case TCFG:
- KwMiRlcConfigCfm(&rPst,cfm);
+ RlcMiRlcConfigCfm(&rPst,cfm);
break;
case TCNTRL:
SGetDateTime(&(cfm->t.cntrl.dt));
- KwMiLkwCntrlCfm(&rPst,cfm);
+ RlcMiLkwCntrlCfm(&rPst,cfm);
break;
case TSTS:
SGetDateTime(&(cfm->t.sts.dt));
- KwMiLkwStsCfm(&rPst,0,cfm);
+ RlcMiLkwStsCfm(&rPst,0,cfm);
break;
case TSSTA:
SGetDateTime(&(cfm->t.ssta.dt));
- KwMiLkwStaCfm(&rPst,cfm);
+ RlcMiLkwStaCfm(&rPst,cfm);
break;
default:
#if (ERRCLASS & ERRCLS_INT_PAR)
*/
#ifdef ANSI
-PUBLIC S16 KwMiRlcConfigReq
+S16 RlcMiRlcConfigReq
(
Pst *pst,
-KwMngmt *cfg
+RlcMngmt *cfg
)
#else
-PUBLIC S16 KwMiRlcConfigReq (pst, cfg)
+S16 RlcMiRlcConfigReq (pst, cfg)
Pst *pst;
-KwMngmt *cfg;
+RlcMngmt *cfg;
#endif
{
Reason reason; /* failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(KwMiRlcConfigReq);
+ TRC3(RlcMiRlcConfigReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return (RFAILED);
}
#endif
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return (RFAILED);
}
/* check configuration is done or not */
if ((tRlcCb->init.cfgDone != TRUE) &&
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return (RFAILED);
}
- RLOG1(L_DEBUG, "KwMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
+ RLOG1(L_DEBUG, "RlcMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
switch(cfg->hdr.elmId.elmnt)
{
case STGEN:
{
- reason = kwLmmGenCfg(tRlcCb,&cfg->t.cfg.s.gen);
+ reason = rlcLmmGenCfg(tRlcCb,&cfg->t.cfg.s.gen);
break;
}
case STKWUSAP:
{
- reason = kwLmmCfgKwuSap(tRlcCb,&cfg->t.cfg.s.sap);
+ reason = rlcLmmCfgKwuSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
case STCKWSAP:
{
- reason = kwLmmCfgCkwSap(tRlcCb,&cfg->t.cfg.s.sap);
+ reason = rlcLmmCfgCkwSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
case STRGUSAP:
{
- reason = kwLmmCfgRguSap(tRlcCb,&cfg->t.cfg.s.sap);
+ reason = rlcLmmCfgRguSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
case STUDXSAP:
{
- reason = kwLmmCfgUdxSap(tRlcCb,&cfg->t.cfg.s.sap);
+ reason = rlcLmmCfgUdxSap(tRlcCb,&cfg->t.cfg.s.sap);
break;
}
default:
{
cfg->cfm.status = LCM_PRIM_OK;
cfg->cfm.reason = LCM_REASON_NOT_APPL;
- kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- return ROK;
+ rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return (ROK);
}
else
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = reason;
- kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
+ return (RFAILED);
}
}
/**
* @brief
* The layer manager initiates and uses the management-control procedure to
- * control RLC elements.The RLC control request primitive (KwMiLkwCntrlReq)
+ * control RLC elements.The RLC control request primitive (RlcMiLkwCntrlReq)
* can be called more than once and at any time after the
* management-configuration procedure.The control request primitive
- * is confirmed by a KwMiLkwCntrlCfm primitive.
+ * is confirmed by a RlcMiLkwCntrlCfm primitive.
*
* @details
* This function implements the following logic:
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwCntrlReq
+S16 RlcMiLkwCntrlReq
(
Pst *pst,
-KwMngmt *cntrl
+RlcMngmt *cntrl
)
#else
-PUBLIC S16 KwMiLkwCntrlReq(pst, cntrl)
+S16 RlcMiLkwCntrlReq(pst, cntrl)
Pst *pst;
-KwMngmt *cntrl;
+RlcMngmt *cntrl;
#endif
{
Reason reason; /* failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(KwMiLkwCntrlReq)
+ TRC3(RlcMiLkwCntrlReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ return (RFAILED);
}
#endif
{
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ return (RFAILED);
}
if (!(tRlcCb->init.cfgDone))
{
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ return (RFAILED);
}
- RLOG1(L_DEBUG, "KwMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
+ RLOG1(L_DEBUG, "RlcMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
/* In normal cases, LCM_REASON_NOT_APPL is returned in cfm.
* In all error cases appropriate reason is returned
case STGEN:
{
/* general control */
- reason = kwLmmGenCntrl(tRlcCb,cntrl);
+ reason = rlcLmmGenCntrl(tRlcCb,cntrl);
break;
}
case STRGUSAP:
{
/* Lower SAP control */
- reason = kwLmmLSapCntrl(tRlcCb,cntrl);
+ reason = rlcLmmLSapCntrl(tRlcCb,cntrl);
break;
}
case STUDXSAP:
{
/* Udx Sap cntrl */
- reason = kwLmmUdxSapCntrl(tRlcCb,cntrl);
+ reason = rlcLmmUdxSapCntrl(tRlcCb,cntrl);
break;
}
default:
cntrl->cfm.reason = reason;
}
- kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
+ rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
return ROK;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwStaReq
+S16 RlcMiLkwStaReq
(
Pst *pst,
-KwMngmt *sta
+RlcMngmt *sta
)
#else
-PUBLIC S16 KwMiLkwStaReq(pst, sta)
+S16 RlcMiLkwStaReq(pst, sta)
Pst *pst;
-KwMngmt *sta;
+RlcMngmt *sta;
#endif
{
- KwMngmt rSta; /* Status */
+ RlcMngmt rSta; /* Status */
Reason reason; /* Failure reason */
RlcCb *tRlcCb=NULLP;
- TRC3(KwMiLkwStaReq);
+ TRC3(RlcMiLkwStaReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
sta->cfm.status = LCM_PRIM_NOK;
sta->cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
+ return (RFAILED);
}
#endif
sta->cfm.status = LCM_PRIM_NOK;
sta->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
+ return (RFAILED);
}
RLOG1(L_DEBUG, "Status request for elmId(%d))", sta->hdr.elmId.elmnt);
reason = LCM_REASON_NOT_APPL;
- RLC_MEM_SET(&rSta, 0, sizeof(KwMngmt));
+ RLC_MEM_SET(&rSta, 0, sizeof(RlcMngmt));
switch (sta->hdr.elmId.elmnt)
{
case STSID:
{
reason = LCM_REASON_NOT_APPL;
- kwGetSId(&rSta.t.ssta.s.sysId);
+ rlcGetSId(&rSta.t.ssta.s.sysId);
break;
}
case STKWUSAP:
{
- KW_MEM_CPY (&rSta.t.ssta.s.kwuSap,
- &sta->t.ssta.s.kwuSap,
- sizeof (KwKwuSapSta));
+ RLC_MEM_CPY (&rSta.t.ssta.s.rlckwuSap,
+ &sta->t.ssta.s.rlckwuSap,
+ sizeof (RlcKwuSapSta));
- reason = kwLmmGetKwuSapSta (tRlcCb,&rSta.t.ssta.s.kwuSap);
+ reason = rlcLmmGetKwuSapSta (tRlcCb,&rSta.t.ssta.s.rlckwuSap);
break;
}
case STRGUSAP:
{
- KW_MEM_CPY (&rSta.t.ssta.s.rguSap,
+ RLC_MEM_CPY (&rSta.t.ssta.s.rguSap,
&sta->t.ssta.s.rguSap,
- sizeof (KwRguSapSta));
+ sizeof (RlcRguSapSta));
- reason = kwLmmGetRguSapSta (tRlcCb,&rSta.t.ssta.s.rguSap);
+ reason = rlcLmmGetRguSapSta (tRlcCb,&rSta.t.ssta.s.rguSap);
break;
}
case STCKWSAP:
{
- KW_MEM_CPY (&rSta.t.ssta.s.ckwSap,
+ RLC_MEM_CPY (&rSta.t.ssta.s.ckwSap,
&sta->t.ssta.s.ckwSap,
- sizeof (KwCkwCntSapSta));
+ sizeof (RlcCkwCntSapSta));
- reason = kwLmmGetCkwCntSapSta (tRlcCb,&rSta.t.ssta.s.ckwSap);
+ reason = rlcLmmGetCkwCntSapSta (tRlcCb,&rSta.t.ssta.s.ckwSap);
break;
}
default:
rSta.cfm.status = LCM_PRIM_NOK;
rSta.cfm.reason = reason;
}
- kwLmmSendCfm(tRlcCb,pst, &rSta, TSSTA, &sta->hdr);
+ rlcLmmSendCfm(tRlcCb,pst, &rSta, TSSTA, &sta->hdr);
return ROK;
}
* - get the general statistics from the KW control block;
* - if (action = RESET)
* - reset the general statistic field in the RlCb;
- * - call KwMiLkwStsCfm to send statistics back to layer manager;
+ * - call RlcMiLkwStsCfm to send statistics back to layer manager;
* - case STCKWSAP
* - case STKWUSAP
* - case STRGUSAP
* - get the SAP specific statistics from KW control block;
* - if (action = RESET)
* - reset the general statistic field in the RlCb;
- * - call KwMiLkwStsCfm to send statistics to the layer manager;
+ * - call RlcMiLkwStsCfm to send statistics to the layer manager;
* -end switch;
*
* @param[in] pst post structure
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwStsReq
+S16 RlcMiLkwStsReq
(
Pst *pst,
Action action,
-KwMngmt *sts
+RlcMngmt *sts
)
#else
-PUBLIC S16 KwMiLkwStsReq (pst, action, sts)
+S16 RlcMiLkwStsReq (pst, action, sts)
Pst *pst;
Action action;
-KwMngmt *sts;
+RlcMngmt *sts;
#endif
{
- KwMngmt rSts; /* Statistics */
+ RlcMngmt rSts; /* Statistics */
Reason reason; /* Reason for failure */
RlcCb *tRlcCb=NULLP;
- TRC3(KwMiLkwStsReq);
+ TRC3(RlcMiLkwStsReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check if the instance is configured */
rSts.cfm.status = LCM_PRIM_NOK;
rSts.cfm.reason = LCM_REASON_INVALID_INSTANCE;
- kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
+ return (RFAILED);
}
#endif
rSts.cfm.status = LCM_PRIM_NOK;
rSts.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
- kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
- return RFAILED;
+ rlcLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
+ return (RFAILED);
}
- RLOG2(L_DEBUG, "KwMiLkwStsReq(elmId(%d),action(%d))",
+ RLOG2(L_DEBUG, "RlcMiLkwStsReq(elmId(%d),action(%d))",
action,
sts->hdr.elmId.elmnt);
- RLC_MEM_SET(&rSts, 0, sizeof(KwMngmt));
+ RLC_MEM_SET(&rSts, 0, sizeof(RlcMngmt));
switch (sts->hdr.elmId.elmnt)
{
case STGEN:
{
- reason = kwLmmGetGenSts(tRlcCb,&rSts.t.sts.s.gen, action);
+ reason = rlcLmmGetGenSts(tRlcCb,&rSts.t.sts.s.gen, action);
break;
}
case STKWUSAP:
{
if( sts->hdr.elmId.elmnt == STKWUSAP)
{
- /* kw005.201, modified the element of kwuSap from suId to spId */
- rSts.t.sts.s.kwuSap.spId = sts->t.sts.s.kwuSap.spId;
+ /* kw005.201, modified the element of rlckwuSap from suId to spId */
+ rSts.t.sts.s.rlckwuSap.spId = sts->t.sts.s.rlckwuSap.spId;
}
- reason = kwLmmGetSapSts(tRlcCb,&rSts, sts->hdr.elmId.elmnt, action);
+ reason = rlcLmmGetSapSts(tRlcCb,&rSts, sts->hdr.elmId.elmnt, action);
break;
}
default:
rSts.cfm.status = LCM_PRIM_NOK;
rSts.cfm.reason = reason;
}
- kwLmmSendCfm(tRlcCb,pst, &rSts, TSTS, &sts->hdr);
+ rlcLmmSendCfm(tRlcCb,pst, &rSts, TSTS, &sts->hdr);
return ROK;
}
measurement confirm is sent.
- Accept only one set of measurements.
-- Allocate and initialise KwL2MeasEvtCb.
+- Allocate and initialise RlcL2MeasEvtCb.
- Validate if the measurement is already in progress.
- Loop through the existing measEvtCb with matching measType
- Check if measurement is running for any qci present in the measReq
- If present, move the qCi to list of invalid qCIs.
-- Set KwL2MeasEvtCb.measOn to TRUE for QCIs to be measured.
+- Set RlcL2MeasEvtCb.measOn to TRUE for QCIs to be measured.
- For the number of measurements requested.
- For all Ues with RBs matching qCI.
- Add RbCb to the RB linked list.
- - Set kwRbCb.measOn to measurement type.
+ - Set rlcRbCb.measOn to measurement type.
- If Meas type is DL_DELAY
- Update COUNT to startCount.
- Start l2Timer
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwL2MeasReq
+S16 RlcMiLkwL2MeasReq
(
Pst *pst,
-KwL2MeasReqEvt *measReqEvt
+RlcL2MeasReqEvt *measReqEvt
)
#else
-PUBLIC S16 KwMiLkwL2MeasReq (pst, measReqEvt)
+S16 RlcMiLkwL2MeasReq (pst, measReqEvt)
Pst *pst;
-KwL2MeasReqEvt *measReqEvt;
+RlcL2MeasReqEvt *measReqEvt;
#endif
{
S16 ret = ROK;
U16 cntr;
U8 measType;
- KwL2MeasCfmEvt measCfmEvt;
+ RlcL2MeasCfmEvt measCfmEvt;
RlcCb *tRlcCb;
- TRC3(KwMiLkwL2MeasReq);
+ TRC3(RlcMiLkwL2MeasReq);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* Initialize measCfmEvt */
- KW_MEM_ZERO(&measCfmEvt, sizeof(KwL2MeasCfmEvt));
+ RLC_MEM_ZERO(&measCfmEvt, sizeof(RlcL2MeasCfmEvt));
/* validate the received measReqEvt */
/*LTE_L2_MEAS_PHASE2*/
if(measReqEvt->measPeriod != 0)
if((measReqEvt->measReq.measType & LKW_L2MEAS_DL_IP)||
(measReqEvt->measReq.measType & LKW_L2MEAS_UL_IP))
{
- ret = kwUtlValidateIpThL2Meas(measReqEvt, &measCfmEvt);
+ ret = rlcUtlValidateIpThL2Meas(measReqEvt, &measCfmEvt);
}
if(ret != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- kwUtlSndUlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
- RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
+ rlcUtlSndUlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
+ RLC_FREE(tRlcCb, measReqEvt, sizeof(RlcL2MeasReqEvt))
return RFAILED;
}
}
measCfmEvt.measType = measType;
measCfmEvt.status.status = LCM_PRIM_NOK;
measCfmEvt.status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- kwUtlSndDlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
- RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
+ rlcUtlSndDlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
+ RLC_FREE(tRlcCb, measReqEvt, sizeof(RlcL2MeasReqEvt))
return ROK;
}
{
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tRlcCb->u.ulCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
+ tRlcCb->u.ulCb->rlcL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
}
}
(LKW_L2MEAS_DL_IP | LKW_L2MEAS_DL_DISC |
LKW_L2MEAS_DL_DELAY | LKW_L2MEAS_UU_LOSS))
{
- KwL2MeasReqEvt *measEvt;
+ RlcL2MeasReqEvt *measEvt;
Pst *udxPst;
- udxPst = &(KW_GET_UDX_SAP(tRlcCb)->pst);
+ udxPst = &(RLC_GET_UDX_SAP(tRlcCb)->pst);
RLC_ALLOC_SHRABL_BUF(udxPst->region,
udxPst->pool,
measEvt,
- sizeof(KwL2MeasReqEvt));
+ sizeof(RlcL2MeasReqEvt));
#if (ERRCLASS & ERRCLS_ADD_RES) /* KW_FIX */
if(measEvt == NULLP)
return RFAILED;
}
#endif
- cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(KwL2MeasReqEvt));
+ cmMemcpy((Void*)measEvt, (Void*)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
DL to send the confirmation to LM*/
/* The interface for sending a confirmation back does not exist today;
it needs to be created when the need arises */
- rlcUlUdxL2MeasReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measEvt);
+ rlcUlUdxL2MeasReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measEvt);
}
/* We need to copy the transId for sending back confirms later */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- KwL2MeasEvtCb* measEvtCb = &(tRlcCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
+ RlcL2MeasEvtCb* measEvtCb = &(tRlcCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
measEvtCb->transId= measReqEvt->transId;
}
}
- /*RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt));*/
+ /*RLC_FREE(tRlcCb, measReqEvt, sizeof(RlcL2MeasReqEvt));*/
return (ret);
-} /* KwMiLkwL2MeasReq */
+} /* RlcMiLkwL2MeasReq */
/**
@brief
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwL2MeasStopReq
+S16 RlcMiLkwL2MeasStopReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 KwMiLkwL2MeasStopReq (pst, measType)
+S16 RlcMiLkwL2MeasStopReq (pst, measType)
Pst *pst;
U8 measType;
#endif
{
S16 ret = ROK;
- KwL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
U16 cntr;
U8 status = ROK;
RlcCb *tRlcCb;
- TRC3(KwMiLkwL2MeasStopReq);
+ TRC3(RlcMiLkwL2MeasStopReq);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* reset the counter values for the measurement that is stopped */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tRlcCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
- kwUtlResetUlL2MeasInKwRb(tRlcCb, &measEvtCb->measCb, measType);
+ rlcUtlResetUlL2MeasInRlcRb(tRlcCb, &measEvtCb->measCb, measType);
}
}
{
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tRlcCb->u.ulCb->kwL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
+ tRlcCb->u.ulCb->rlcL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
}
}
|| (measType & LKW_L2MEAS_DL_DELAY))
{
/*Redirect the request to DL task */
- rlcUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measType);
+ rlcUlUdxL2MeasStopReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measType);
/*return ROK;*/
}
- /*cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
+ /*cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
status = LCM_PRIM_OK;
- KwMiLkwL2MeasStopCfm(&tRlcCb->genCfg.lmPst, measType,status);
+ RlcMiLkwL2MeasStopCfm(&tRlcCb->genCfg.lmPst, measType,status);
return (ret);
}
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwL2MeasSendReq
+S16 RlcMiLkwL2MeasSendReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 KwMiLkwL2MeasSendReq (pst, measType)
+S16 RlcMiLkwL2MeasSendReq (pst, measType)
Pst *pst;
U8 measType;
#endif
{
/*S16 ret = ROK;*/
- KwL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
U16 cntr;
RlcCb *tRlcCb;
- TRC3(KwMiLkwL2MeasSendReq);
+ TRC3(RlcMiLkwL2MeasSendReq);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* In case of addition of any new measType here ,appropriate handling
- * has to be done in RLC DL (kwUtlSndDlL2MeasCfm)*/
+ * has to be done in RLC DL (rlcUtlSndDlL2MeasCfm)*/
if(measType &
(LKW_L2MEAS_DL_DISC | LKW_L2MEAS_DL_DELAY
| LKW_L2MEAS_UU_LOSS| LKW_L2MEAS_DL_IP))
{
/*Redirect the request to DL task */
- rlcUlUdxL2MeasSendReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measType);
+ rlcUlUdxL2MeasSendReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measType);
/* L2 MEAS AGHOSH */
/*return ROK;*/
}
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tRlcCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]);
/* L2 MEAS AGHOSH */
if(measEvtCb->measCb.measType & measType)
{
- kwUtlHdlL2TmrExp(tRlcCb, measEvtCb);
+ rlcUtlHdlL2TmrExp(tRlcCb, measEvtCb);
}
}
* -# LCM_REASON_RECONFIG_FAIL
*/
#ifdef ANSI
-PRIVATE S16 kwLmmCfgKwuSap
+PRIVATE S16 rlcLmmCfgKwuSap
(
RlcCb *gCb,
-KwSapCfg *cfg
+RlcSapCfg *cfg
)
#else
-PRIVATE S16 kwLmmCfgKwuSap(gCb,cfg)
+PRIVATE S16 rlcLmmCfgKwuSap(gCb,cfg)
RlcCb *gCb;
-KwSapCfg *cfg;
+RlcSapCfg *cfg;
#endif
{
- KwKwuSapCb *kwuSapCb;
- TRC2(kwLmmCfgKwuSap)
+ RlcKwuSapCb *rlcKwuSapCb;
+ TRC2(rlcLmmCfgKwuSap)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
- (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + cfg->sapId):
- (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + cfg->sapId);
+ rlcKwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
+ (RlcKwuSapCb*)(gCb->u.dlCb->rlcKwuDlSap + cfg->sapId):
+ (RlcKwuSapCb*)(gCb->u.ulCb->rlcKwuUlSap + cfg->sapId);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check for reconfiguration */
- if (kwuSapCb->state != KW_SAP_NOT_CFG)
+ if (rlcKwuSapCb->state != RLC_SAP_NOT_CFG)
{
- RLOG2(L_ERROR,"RLC Mode [%d] : Invalid kwuSap State [%d]",
- gCb->genCfg.rlcMode, kwuSapCb->state);
+ RLOG2(L_ERROR,"RLC Mode [%d] : Invalid rlckwuSap State [%d]",
+ gCb->genCfg.rlcMode, rlcKwuSapCb->state);
/* reconfiguration not allowed */
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
- KW_FILL_SAP_HELPER(kwuSapCb, cfg, gCb);
+ RLC_FILL_SAP_HELPER(rlcKwuSapCb, cfg, gCb);
return (LCM_REASON_NOT_APPL);
}
* -# LCM_REASON_RECONFIG_FAIL
*/
#ifdef ANSI
-PRIVATE S16 kwLmmCfgCkwSap
+PRIVATE S16 rlcLmmCfgCkwSap
(
RlcCb *gCb,
-KwSapCfg *cfg
+RlcSapCfg *cfg
)
#else
-PRIVATE S16 kwLmmCfgCkwSap(gCb,cfg)
+PRIVATE S16 rlcLmmCfgCkwSap(gCb,cfg)
RlcCb *gCb;
-KwSapCfg *cfg;
+RlcSapCfg *cfg;
#endif
{
- KwCkwSapCb *ckwSap;
+ RlcCkwSapCb *ckwSap;
- TRC2(kwLmmCfgCkwSap)
+ TRC2(rlcLmmCfgCkwSap)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate config parameters */
- if ((cfg->sapId >= KW_MAX_CKWSAPS) || (cfg->sapId < 0) )
+ if ((cfg->sapId >= RLC_MAX_CKWSAPS) || (cfg->sapId < 0) )
{
return (LCM_REASON_INVALID_PAR_VAL);
}
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check for reconfiguration */
- if(ckwSap->state != KW_SAP_NOT_CFG)
+ if(ckwSap->state != RLC_SAP_NOT_CFG)
{
- RLOG1(L_ERROR,"Invalid kwuSap State [%d]",ckwSap->state);
+ RLOG1(L_ERROR,"Invalid rlckwuSap State [%d]",ckwSap->state);
return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
- KW_FILL_SAP_HELPER(ckwSap, cfg, gCb);
+ RLC_FILL_SAP_HELPER(ckwSap, cfg, gCb);
return (LCM_REASON_NOT_APPL);
}
* -# LCM_REASON_RECONFIG_FAIL
*/
#ifdef ANSI
-PRIVATE S16 kwLmmCfgUdxSap
+PRIVATE S16 rlcLmmCfgUdxSap
(
RlcCb *gCb,
-KwSapCfg *cfg
+RlcSapCfg *cfg
)
#else
-PRIVATE S16 kwLmmCfgUdxSap(gCb,cfg)
+PRIVATE S16 rlcLmmCfgUdxSap(gCb,cfg)
RlcCb *gCb;
-KwSapCfg *cfg;
+RlcSapCfg *cfg;
#endif
{
- KwUdxDlSapCb *udxDlSap;
- KwUdxUlSapCb *udxUlSap;
+ RlcUdxDlSapCb *udxDlSap;
+ RlcUdxUlSapCb *udxUlSap;
- TRC2(kwLmmCfgUdxSap);
+ TRC2(rlcLmmCfgUdxSap);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
- if((cfg->sapId >= KW_MAX_UDXSAPS) || (cfg->sapId < 0))
+ if((cfg->sapId >= RLC_MAX_UDXSAPS) || (cfg->sapId < 0))
{
return (LCM_REASON_INVALID_PAR_VAL);
}
udxDlSap = (gCb->u.dlCb->udxDlSap + cfg->sapId);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check for reconfiguration */
- if(udxDlSap->state != KW_SAP_NOT_CFG)
+ if(udxDlSap->state != RLC_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid udxDlSap State [%d]",udxDlSap->state);
return (LCM_REASON_RECONFIG_FAIL);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
- KW_FILL_SAP_HELPER(udxDlSap, cfg, gCb);
+ RLC_FILL_SAP_HELPER(udxDlSap, cfg, gCb);
}
else
{
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check for reconfiguration */
- if(udxUlSap->state != KW_SAP_NOT_CFG)
+ if(udxUlSap->state != RLC_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid udxUlSap State [%d]", udxUlSap->state);
return (LCM_REASON_RECONFIG_FAIL);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
- KW_FILL_SAP_HELPER(udxUlSap, cfg, gCb);
+ RLC_FILL_SAP_HELPER(udxUlSap, cfg, gCb);
udxUlSap->bndTmrInt = cfg->bndTmrIntvl;
udxUlSap->retryCnt = 0;
* -# LCM_REASON_RECONFIG_FAIL
*/
#ifdef ANSI
-PRIVATE S16 kwLmmCfgRguSap
+PRIVATE S16 rlcLmmCfgRguSap
(
RlcCb *gCb,
-KwSapCfg *cfg
+RlcSapCfg *cfg
)
#else
-PRIVATE S16 kwLmmCfgRguSap(gCb,cfg)
+PRIVATE S16 rlcLmmCfgRguSap(gCb,cfg)
RlcCb *gCb;
-KwSapCfg *cfg;
+RlcSapCfg *cfg;
#endif
{
- KwRguSapCb *rguSap;
+ RlcRguSapCb *rguSap;
- TRC2(kwLmmCfgRguSap);
+ TRC2(rlcLmmCfgRguSap);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
if((cfg->sapId >= gCb->genCfg.maxRguSaps) || \
(cfg->sapId < 0))
{
- KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
- "kwLmmCfgRguSap: Invalid RGU sapId\n");
+ RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
+ "rlcLmmCfgRguSap: Invalid RGU sapId\n");
return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Check for reconfiguration */
- if(rguSap->state != KW_SAP_NOT_CFG)
+ if(rguSap->state != RLC_SAP_NOT_CFG)
{
RLOG2(L_ERROR,"RLC Mode [%d]: Invalid rguSap State [%d]",
gCb->genCfg.rlcMode, rguSap->state);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
- KW_FILL_SAP_HELPER(rguSap, cfg, gCb);
+ RLC_FILL_SAP_HELPER(rguSap, cfg, gCb);
rguSap->suId = cfg->sapId;
rguSap->bndTmrInt = cfg->bndTmrIntvl;
rguSap->retryCnt = 0;
- rguSap->state = KW_SAP_CFG;
+ rguSap->state = RLC_SAP_CFG;
cmInitTimers(&(rguSap->bndTmr), 1);
* -# LCM_REASON_INVALID_ACTION
*/
#ifdef ANSI
-PRIVATE S16 kwLmmValidateGenCntrl
+PRIVATE S16 rlcLmmValidateGenCntrl
(
-KwMngmt *cntrl
+RlcMngmt *cntrl
)
#else
-PRIVATE S16 kwLmmValidateGenCntrl(cntrl)
-KwMngmt *cntrl;
+PRIVATE S16 rlcLmmValidateGenCntrl(cntrl)
+RlcMngmt *cntrl;
#endif
{
S16 reason; /* reason for failure */
U8 sAction; /* subaction field */
- TRC2(kwLmmValidateGenCntrl);
+ TRC2(rlcLmmValidateGenCntrl);
reason = LCM_REASON_NOT_APPL;
sAction = cntrl->t.cntrl.subAction;
/**
* @brief
- * it deregisters the timers and deregisters the kwuSap Control blocks
+ * it deregisters the timers and deregisters the rlckwuSap Control blocks
*
* @param[in] gCb RLC Instance Control Block
*
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwLmmCleanGblRsrcs
+PRIVATE Void rlcLmmCleanGblRsrcs
(
RlcCb *gCb
)
#else
-PRIVATE Void kwLmmCleanGblRsrcs(gCb)
+PRIVATE Void rlcLmmCleanGblRsrcs(gCb)
RlcCb *gCb;
#endif
{
- Size kwSapSize;
- Size kwUdxSapSize;
+ Size rlcSapSize;
+ Size rlcUdxSapSize;
- TRC2(kwLmmCleanGblRsrcs)
+ TRC2(rlcLmmCleanGblRsrcs)
if (gCb->init.cfgDone)
{
/* Deregister the timers */
/*Pradeep: changing the SDeregTmrMt() to SDeregTmr*/
(Void) SDeregTmrMt(gCb->init.ent, gCb->init.inst,
- (S16)gCb->genCfg.timeRes, kwActvTmr);
+ (S16)gCb->genCfg.timeRes, rlcActvTmr);
/*(Void) SDeregTmr(gCb->init.ent, gCb->init.inst,
- (S16)gCb->genCfg.timeRes, kwActvTmr);*/
+ (S16)gCb->genCfg.timeRes, rlcActvTmr);*/
- kwSapSize = (Size)(gCb->genCfg.maxKwuSaps * sizeof(KwKwuSapCb));
+ rlcSapSize = (Size)(gCb->genCfg.maxKwuSaps * sizeof(RlcKwuSapCb));
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxDlSapCb));
+ rlcUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(RlcUdxDlSapCb));
if (gCb->u.dlCb)
{
gCb->u.dlCb->shutdownReceived = TRUE;
- kwUtlFreeDlMemory(gCb);
- if (gCb->u.dlCb->kwuDlSap != NULLP)
+ rlcUtlFreeDlMemory(gCb);
+ if (gCb->u.dlCb->rlcKwuDlSap != NULLP)
{
- RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
}
if(gCb->u.dlCb->udxDlSap != NULLP)
{
- RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
+ RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
}
if(gCb->u.dlCb->rguDlSap != NULLP)
}
else
{
- kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxUlSapCb));
+ rlcUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(RlcUdxUlSapCb));
if (gCb->u.ulCb)
{
- if (gCb->u.ulCb->kwuUlSap != NULLP)
+ if (gCb->u.ulCb->rlcKwuUlSap != NULLP)
{
- RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
}
if(gCb->u.ulCb->udxUlSap != NULLP)
{
- RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
+ RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
}
if(gCb->u.ulCb->rguUlSap != NULLP)
* -# LCM_REASON_HASHING_FAILED
*/
#ifdef ANSI
-PRIVATE S16 kwLmmShutdown
+PRIVATE S16 rlcLmmShutdown
(
RlcCb *gCb
)
#else
-PRIVATE S16 kwLmmShutdown(gCb)
+PRIVATE S16 rlcLmmShutdown(gCb)
RlcCb *gCb;
#endif
{
- KwRguSapCb *rguSap;
+ RlcRguSapCb *rguSap;
U32 idx;
- TRC2(kwLmmShutdown)
+ TRC2(rlcLmmShutdown)
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
{
rguSap = &(gCb->u.dlCb->rguDlSap[idx]);
- if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
+ if ((rguSap->state == RLC_SAP_BND) || (rguSap->state == RLC_SAP_BINDING))
{
- KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
+ RlcLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
}
}
}
for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
{
rguSap = &(gCb->u.ulCb->rguUlSap[idx]);
- if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
+ if ((rguSap->state == RLC_SAP_BND) || (rguSap->state == RLC_SAP_BINDING))
{
- KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
+ RlcLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
}
}
}
if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- kwDbmDlShutdown(gCb);
+ rlcDbmDlShutdown(gCb);
}
else
{
- kwDbmUlShutdown(gCb);
+ rlcDbmUlShutdown(gCb);
}
- kwLmmCleanGblRsrcs(gCb);
+ rlcLmmCleanGblRsrcs(gCb);
- RLC_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
+ RLC_MEM_SET (&(gCb->genSts), 0, sizeof (RlcGenSts));
return (LCM_REASON_NOT_APPL);
}
* -# LCM_REASON_INVALID_ACTION
*/
#ifdef ANSI
-PRIVATE S16 kwLmmGenCntrl
+PRIVATE S16 rlcLmmGenCntrl
(
RlcCb *gCb,
-KwMngmt *cntrl
+RlcMngmt *cntrl
)
#else
-PRIVATE S16 kwLmmGenCntrl(gCb,cntrl)
+PRIVATE S16 rlcLmmGenCntrl(gCb,cntrl)
RlcCb *gCb;
-KwMngmt *cntrl;
+RlcMngmt *cntrl;
#endif
{
- KwTrcCntrl *trcCntrl; /* trace */
+ RlcTrcCntrl *trcCntrl; /* trace */
#ifdef DEBUGP
- KwDbgCntrl *dbgCntrl; /* debug */
+ RlcDbgCntrl *dbgCntrl; /* debug */
#endif /* DEBUGP */
S16 reason; /* reason for failure */
- TRC2(kwLmmGenCntrl);
+ TRC2(rlcLmmGenCntrl);
/* Validate control parameters */
- reason = kwLmmValidateGenCntrl (cntrl);
+ reason = rlcLmmValidateGenCntrl (cntrl);
if (reason != LCM_REASON_NOT_APPL)
{
{
case SAUSTA:
{
- KW_SET_USTA_FLAG(gCb, TRUE);
+ RLC_SET_USTA_FLAG(gCb, TRUE);
break;
}
case SADBG:
{
#ifdef DEBUGP
dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
- KW_GET_DBG_MASK(gCb) |= dbgCntrl->dbgMask;
+ RLC_GET_DBG_MASK(gCb) |= dbgCntrl->dbgMask;
#endif /* DEBUGP */
break;
}
{
#ifdef DEBUGP
dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
- KW_GET_DBG_MASK(gCb) &= ~(dbgCntrl->dbgMask);
+ RLC_GET_DBG_MASK(gCb) &= ~(dbgCntrl->dbgMask);
#endif /* DEBUGP */
}
break;
}
case ASHUTDOWN:
{
- reason = kwLmmShutdown(gCb);
+ reason = rlcLmmShutdown(gCb);
break;
}
}
* -# LCM_REASON_INVALID_ACTION
*/
#ifdef ANSI
-PRIVATE S16 kwLmmUdxSapCntrl
+PRIVATE S16 rlcLmmUdxSapCntrl
(
RlcCb *gCb,
-KwMngmt *cntrl
+RlcMngmt *cntrl
)
#else
-PRIVATE S16 kwLmmUdxSapCntrl(gCb,cntrl)
+PRIVATE S16 rlcLmmUdxSapCntrl(gCb,cntrl)
RlcCb *gCb;
-KwMngmt *cntrl;
+RlcMngmt *cntrl;
#endif
{
- TRC2(kwLmmUdxSapCntrl)
+ TRC2(rlcLmmUdxSapCntrl)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
}
/* validate SuId */
if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
- (cntrl->t.cntrl.s.sapCntrl.suId >= KW_MAX_UDXSAPS))
+ (cntrl->t.cntrl.s.sapCntrl.suId >= RLC_MAX_UDXSAPS))
{
return (LCM_REASON_INVALID_SAP);
}
#define UDX_SAP gCb->u.ulCb->udxUlSap[cntrl->t.cntrl.s.sapCntrl.suId]
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate SAP */
- if(UDX_SAP.state == KW_SAP_NOT_CFG)
+ if(UDX_SAP.state == RLC_SAP_NOT_CFG)
{
RLOG0(L_ERROR,"udxUlSap not configured yet");
return (LCM_REASON_INVALID_STATE);
{
case ABND:
{
- if(UDX_SAP.state != KW_SAP_BND)
+ if(UDX_SAP.state != RLC_SAP_BND)
{
/* start timer to wait for bind confirm */
- kwStartTmr(gCb,(PTR)(&UDX_SAP), KW_EVT_WAIT_BNDCFM);
- UDX_SAP.state = KW_SAP_BINDING;
+ rlcStartTmr(gCb,(PTR)(&UDX_SAP), RLC_EVT_WAIT_BNDCFM);
+ UDX_SAP.state = RLC_SAP_BINDING;
rlcUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
}
else
case AUBND:
{
/* make the state of UDXSAP configured but not bound */
- UDX_SAP.state = KW_SAP_CFG;
+ UDX_SAP.state = RLC_SAP_CFG;
rlcUlUdxUbndReq(&(UDX_SAP.pst), UDX_SAP.spId, 0);
}
break;
* -# LCM_REASON_INVALID_ACTION
*/
#ifdef ANSI
-PRIVATE S16 kwLmmLSapCntrl
+PRIVATE S16 rlcLmmLSapCntrl
(
RlcCb *gCb,
-KwMngmt *cntrl
+RlcMngmt *cntrl
)
#else
-PRIVATE S16 kwLmmLSapCntrl(gCb,cntrl)
+PRIVATE S16 rlcLmmLSapCntrl(gCb,cntrl)
RlcCb *gCb;
-KwMngmt *cntrl;
+RlcMngmt *cntrl;
#endif
{
- KwRguSapCb *rguSap; /* rgu sap pointer */
+ RlcRguSapCb *rguSap; /* rgu sap pointer */
- TRC2(kwLmmLSapCntrl)
+ TRC2(rlcLmmLSapCntrl)
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate SuId */
if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
(cntrl->t.cntrl.s.sapCntrl.suId >= gCb->genCfg.maxRguSaps))
{
- KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
- "kwLmmLSapCntrl: Invalid RGU suId\n");
+ RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
+ "rlcLmmLSapCntrl: Invalid RGU suId\n");
return (LCM_REASON_INVALID_SAP);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate SAP */
- if(rguSap->state == KW_SAP_NOT_CFG)
+ if(rguSap->state == RLC_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
return (LCM_REASON_INVALID_STATE);
{
case ABND:
{
- if(rguSap->state != KW_SAP_BND)
+ if(rguSap->state != RLC_SAP_BND)
{
/* start timer to wait for bind confirm */
- kwStartTmr(gCb,(PTR)(rguSap), KW_EVT_WAIT_BNDCFM);
- rguSap->state = KW_SAP_BINDING;
+ rlcStartTmr(gCb,(PTR)(rguSap), RLC_EVT_WAIT_BNDCFM);
+ rguSap->state = RLC_SAP_BINDING;
rguSap->spId = cntrl->t.cntrl.s.sapCntrl.spId;
rguSap->suId = cntrl->t.cntrl.s.sapCntrl.suId;
- KwLiRguBndReq(&(rguSap->pst), rguSap->suId, rguSap->spId);
+ RlcLiRguBndReq(&(rguSap->pst), rguSap->suId, rguSap->spId);
}
else
{
case AUBND:
{
/* make the state of RGUSAP is configure but not bound */
- rguSap->state = KW_SAP_CFG;
- KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
+ rguSap->state = RLC_SAP_CFG;
+ RlcLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
}
break;
default:
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
#ifdef ANSI
-PRIVATE S16 kwLmmGetKwuSapSta
+PRIVATE S16 rlcLmmGetKwuSapSta
(
RlcCb *gCb,
-KwKwuSapSta *sta
+RlcKwuSapSta *sta
)
#else
-PRIVATE S16 kwLmmGetKwuSapSta(gCb,sta)
+PRIVATE S16 rlcLmmGetKwuSapSta(gCb,sta)
RlcCb *gCb;
-KwKwuSapSta *sta;
+RlcKwuSapSta *sta;
#endif
{
- KwKwuSapCb *kwSapCb;
+ RlcKwuSapCb *rlcKwSapCb;
- TRC2(kwLmmGetKwuSapSta);
+ TRC2(rlcLmmGetKwuSapSta);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
#endif
/* Get Sap control block */
- kwSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
- (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + sta->spId):
- (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + sta->spId);
+ rlcKwSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
+ (RlcKwuSapCb*)(gCb->u.dlCb->rlcKwuDlSap + sta->spId):
+ (RlcKwuSapCb*)(gCb->u.ulCb->rlcKwuUlSap + sta->spId);
- sta->state = kwSapCb->state;
+ sta->state = rlcKwSapCb->state;
return (LCM_REASON_NOT_APPL);
}
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
#ifdef ANSI
-PRIVATE S16 kwLmmGetRguSapSta
+PRIVATE S16 rlcLmmGetRguSapSta
(
RlcCb *gCb,
-KwRguSapSta *sta
+RlcRguSapSta *sta
)
#else
-PRIVATE S16 kwLmmGetRguSapSta(gCb,sta)
+PRIVATE S16 rlcLmmGetRguSapSta(gCb,sta)
RlcCb *gCb;
-KwRguSapSta *sta;
+RlcRguSapSta *sta;
#endif
{
- TRC2(kwLmmGetRguSapSta);
+ TRC2(rlcLmmGetRguSapSta);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate the protocol parameters */
- if((sta->suId >= KW_MAX_RGUSAPS) || (sta->suId < 0))
+ if((sta->suId >= RLC_MAX_RGUSAPS) || (sta->suId < 0))
{
return (LCM_REASON_INVALID_PAR_VAL);
}
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
#ifdef ANSI
-PRIVATE S16 kwLmmGetCkwCntSapSta
+PRIVATE S16 rlcLmmGetCkwCntSapSta
(
RlcCb *gCb,
-KwCkwCntSapSta *sta
+RlcCkwCntSapSta *sta
)
#else
-PRIVATE S16 kwLmmGetCkwCntSapSta(gCb,sta)
+PRIVATE S16 rlcLmmGetCkwCntSapSta(gCb,sta)
rlcCb *gCb,
-KwCkwCntSapSta *sta;
+RlcCkwCntSapSta *sta;
#endif
{
- TRC2(kwLmmGetCkwCntSapSta);
+ TRC2(rlcLmmGetCkwCntSapSta);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate config parameters */
- if ((sta->spId >= KW_MAX_CKWSAPS ) ||
+ if ((sta->spId >= RLC_MAX_CKWSAPS ) ||
(sta->spId < 0 ) ||
(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL))
{
* -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
*/
#ifdef ANSI
-PRIVATE S16 kwLmmGetGenSts
+PRIVATE S16 rlcLmmGetGenSts
(
RlcCb *gCb,
-KwGenSts *sts,
+RlcGenSts *sts,
Action action
)
#else
-PRIVATE S16 kwLmmGetGenSts(gCb,sts, action)
+PRIVATE S16 rlcLmmGetGenSts(gCb,sts, action)
RlcCb *gCb;
-KwGenSts *sts;
+RlcGenSts *sts;
Action action;
#endif
{
- TRC2(kwLmmGetGenSts);
+ TRC2(rlcLmmGetGenSts);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Validate protocol parameters */
if(action == LKW_ZEROSTS)
{
- RLC_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
+ RLC_MEM_SET (&(gCb->genSts), 0, sizeof (RlcGenSts));
}
return (LCM_REASON_NOT_APPL);
* -# LCM_REASON_INVALID_PAR_VAL (FAIL)
*/
#ifdef ANSI
-PRIVATE S16 kwLmmGetSapSts
+PRIVATE S16 rlcLmmGetSapSts
(
RlcCb *gCb,
-KwMngmt *sts,
+RlcMngmt *sts,
Elmnt elmnt,
Action action
)
#else
-PRIVATE S16 kwLmmGetSapSts(sts, elmnt, action)
+PRIVATE S16 rlcLmmGetSapSts(sts, elmnt, action)
RlcCb *gCb;
-KwMngmt *sts;
+RlcMngmt *sts;
Elmnt elmnt;
Action action;
#endif
{
- TRC2(kwLmmGetSapSts);
+ TRC2(rlcLmmGetSapSts);
/* Validate protocol parameters */
if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
{
case STKWUSAP:
{
- KwKwuSapSts *kwuSap;
- KwKwuSapCb *kwuSapCb;
- kwuSap = &sts->t.sts.s.kwuSap;
+ RlcKwuSapSts *rlckwuSap;
+ RlcKwuSapCb *rlcKwuSapCb;
+ rlckwuSap = &sts->t.sts.s.rlckwuSap;
/* Get Sap control block */
- /* kw005.201, modified the element of kwuSap from suId to spId */
- kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
- (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + kwuSap->spId):
- (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + kwuSap->spId);
+ /* kw005.201, modified the element of rlckwuSap from suId to spId */
+ rlcKwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
+ (RlcKwuSapCb*)(gCb->u.dlCb->rlcKwuDlSap + rlckwuSap->spId):
+ (RlcKwuSapCb*)(gCb->u.ulCb->rlcKwuUlSap + rlckwuSap->spId);
- *kwuSap = kwuSapCb->sts;
+ *rlckwuSap = rlcKwuSapCb->sts;
if (action == LKW_ZEROSTS)
{
- RLC_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
+ RLC_MEM_SET (&rlcKwuSapCb->sts, 0, sizeof (RlcKwuSapSts));
}
break;
}
/* kw005.201 removed RGUSAP statistics support */
case STCKWSAP:
{
- KwCkwCntSts *ckwSap;
+ RlcCkwCntSts *ckwSap;
ckwSap = &sts->t.sts.s.ckwSap;
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
if (action == LKW_ZEROSTS)
{
- RLC_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (KwCkwCntSts));
+ RLC_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (RlcCkwCntSts));
}
break;
}
*/
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC Void kwLmmSendAlarm
+Void rlcLmmSendAlarm
(
RlcCb *gCb,
U16 category,
U8 qci
)
#else
-PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId, qci)
+Void rlcLmmSendAlarm(category, event, cause, suId, ueId, qci)
RlcCb *gCb;
U16 category;
U16 event;
#endif
#else /* LTE_L2_MEAS */
#ifdef ANSI
-PUBLIC Void kwLmmSendAlarm
+Void rlcLmmSendAlarm
(
RlcCb *gCb,
U16 category,
U32 ueId
)
#else
-PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId)
+Void rlcLmmSendAlarm(category, event, cause, suId, ueId)
RlcCb *gCb;
U16 category;
U16 event;
#endif
#endif /* LTE_L2_MEAS */
{
- KwMngmt usta; /* Rlc Management Structure */
+ RlcMngmt usta; /* Rlc Management Structure */
- TRC2(kwLmmSendAlarm);
+ TRC2(rlcLmmSendAlarm);
if(gCb->init.usta == FALSE)
{
/* update the date and time */
(Void) SGetDateTime(&usta.t.usta.alarm.dt);
- KwMiLkwStaInd(&(gCb->init.lmPst), &usta);
+ RlcMiLkwStaInd(&(gCb->init.lmPst), &usta);
RETVOID;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwLmmSendTrc
+S16 rlcLmmSendTrc
(
RlcCb *gCb,
Event event,
Buffer *mBuf
)
#else
-PUBLIC S16 kwLmmSendTrc(gCb,event, mBuf)
+S16 rlcLmmSendTrc(gCb,event, mBuf)
RlcCb *gCb;
Event event;
Buffer *mBuf;
#endif
{
- KwMngmt trc; /* RLC management control block */
+ RlcMngmt trc; /* RLC management control block */
Buffer *dstMbuf;
MsgLen bufLen;
Data *tempBuf;
MsgLen tempCnt;
Pst pst;
- TRC2(kwLmmSendTrc)
+ TRC2(rlcLmmSendTrc)
- RLOG2(L_DEBUG, "kwLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
+ RLOG2(L_DEBUG, "rlcLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
event,
gCb->trcLen);
- cmMemset((U8 *)&trc, 0, sizeof(KwMngmt));
+ cmMemset((U8 *)&trc, 0, sizeof(RlcMngmt));
pst = gCb->init.lmPst;
return RFAILED;
}
/* Send Trace Indication to Layer manager */
- KwMiLkwTrcInd(&pst, &trc, dstMbuf);
+ RlcMiLkwTrcInd(&pst, &trc, dstMbuf);
}
/* check if only a specified number of bytes are to be sent */
else if(gCb->trcLen > 0)
}
/* Send Trace Indication to Layer manager */
- KwMiLkwTrcInd(&pst, &trc, dstMbuf);
+ RlcMiLkwTrcInd(&pst, &trc, dstMbuf);
}
else
{
#if (ERRCLASS & ERRCLS_INT_PAR)
if(tempBuf == NULLP)
{
- (Void) SPutSMem(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb));
+ (Void) SPutSMem(RLC_GET_MEM_REGION(gCb), RLC_GET_MEM_POOL(gCb));
RLOG0(L_FATAL,"Memory Allocation failed");
return (LCM_REASON_MEM_NOAVAIL);
/* Free the memory allocated for tempBuf */
RLC_FREE(gCb,tempBuf, gCb->trcLen);
/* Send Trace Indication to Layer manager */
- KwMiLkwTrcInd(&pst, &trc, dstMbuf);
+ RlcMiLkwTrcInd(&pst, &trc, dstMbuf);
}
}
}
else
{
- KwMiLkwTrcInd(&pst, &trc, mBuf);
+ RlcMiLkwTrcInd(&pst, &trc, mBuf);
}
return ROK;
*/
#ifdef ANSI
-PUBLIC S16 kwActvTmr
+S16 rlcActvTmr
(
Ent ent,
Inst inst
)
#else
-PUBLIC S16 kwActvTmr(ent,inst)
+S16 rlcActvTmr(ent,inst)
Ent ent;
Inst inst;
#endif
{
RlcCb *gCb;
- TRC2(kwActvTmr)
+ TRC2(rlcActvTmr)
if (inst >= MAX_RLC_INSTANCES)
{
return (RFAILED);
}
gCb = RLC_GET_RLCCB(inst);
- cmPrcTmr(&(gCb->kwTqCp), gCb->kwTq, (PFV) kwTmrExpiry);
- return ROK;
+ cmPrcTmr(&(gCb->rlcTqCp), gCb->rlcTq, (PFV) rlcTmrExpiry);
+ return (ROK);
-} /* end of kwActvTmr */
+} /* end of rlcActvTmr */
/********************************************************************30**
#ifdef RLC_MAC_DAT_REQ_RBUF
-PUBLIC S16 kwLiRguDatReqRbuf(Pst *Post,SpId spId,Void *datReq);
+S16 rlcLiRguDatReqRbuf(Pst *Post,SpId spId,Void *datReq);
#endif
#ifdef RLC_MAC_STA_RSP_RBUF
-PUBLIC S16 kwLiRguStaRspRbuf(Pst *Post,SpId spId,Void *staRsp);
+S16 rlcLiRguStaRspRbuf(Pst *Post,SpId spId,Void *staRsp);
#endif
#if defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)
EXTERN S16 RlcDlHarqStaBatchProc (Void);
/* RGU Bind Request primitive */
-PUBLIC RguBndReq kwLiRguBndReqMt[] =
+RguBndReq kwLiRguBndReqMt[] =
{
#ifdef LCKWLIRGU
cmPkRguBndReq, /* 0 - loosely coupled */
/* RGU Unbind Request primitive */
-PUBLIC RguBndReq kwLiRguUbndReqMt[] =
+RguBndReq kwLiRguUbndReqMt[] =
{
#ifdef LCKWLIRGU
cmPkRguUbndReq, /* 0 - loosely coupled */
/* RGU Dedicated Channel Data Request primitive */
-PUBLIC RlcMacDlData rlcMacSendDlDataOpts[] =
+RlcMacDlData rlcMacSendDlDataOpts[] =
{
#ifdef EGTP_TEST
macStubSendDlData,
/* RLC logical Channel Status primitive */
-PUBLIC RlcMacBoStatus rlcMacSendBOStatusOpts[] =
+RlcMacBoStatus rlcMacSendBOStatusOpts[] =
{
#ifdef EGTP_TEST
macStubBOStatus,
#ifdef LTE_RLC_R9
/* RGU L2 Measurement Ul Ip Throughput Measurement Request primitive */
-PUBLIC RguL2MUlThrpMeasReq kwLiRguL2MUlThrpMeasReqMt[] =
+RguL2MUlThrpMeasReq kwLiRguL2MUlThrpMeasReqMt[] =
{
#ifdef LCKWLIRGU
cmPkRguL2MUlThrpMeasReq, /* 0 - loosely coupled */
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguBndReq
+S16 RlcLiRguBndReq
(
Pst *post, /* post structure */
SuId suId, /* Service User Id */
SpId spId /* Service Provider Id */
)
#else
-PUBLIC S16 KwLiRguBndReq(post, suId, spId)
+S16 RlcLiRguBndReq(post, suId, spId)
Pst *post; /* post structure */
SuId suId; /* Service User Id */
SpId spId; /* Service Provider Id */
#endif
{
- TRC3(KwLiRguBndReq)
+ TRC3(RlcLiRguBndReq)
/* jump to specific primitive depending on configured selector */
(*kwLiRguBndReqMt[post->selector])(post, suId, spId);
return ROK;
-} /* end of KwLiRguBndReq */
+} /* end of RlcLiRguBndReq */
\f
/**
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguUbndReq
+S16 RlcLiRguUbndReq
(
Pst *post,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 KwLiRguUbndReq(post, spId, reason)
+S16 RlcLiRguUbndReq(post, spId, reason)
Pst *post;
SpId spId;
Reason reason;
#endif
{
- TRC3(KwLiRguUbndReq)
+ TRC3(RlcLiRguUbndReq)
/* jump to specific primitive depending on configured selector */
(*kwLiRguUbndReqMt[post->selector])(post, spId, reason);
return ROK;
-} /* end of KwLiRguUbndReq */
+} /* end of RlcLiRguUbndReq */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 RlcMacSendDlData
+S16 RlcMacSendDlData
(
Pst *post,
SpId spId,
RlcMacData *dlData
)
#else
-PUBLIC S16 RlcMacSendDlData(post, spId, dlData)
+S16 RlcMacSendDlData(post, spId, dlData)
Pst *post;
SpId spId;
RlcMacData *dlData;
TRC3(RlcMacSendDlData)
#ifdef RLC_MAC_DAT_REQ_RBUF
post->event=EVTRGUDDATREQ;
- if((kwLiRguDatReqRbuf(post, spId, datReq)) != ROK)
+ if((rlcLiRguDatReqRbuf(post, spId, datReq)) != ROK)
{
SPutStaticBuffer(post->region, post->pool,
#endif
return ROK;
-} /* end of KwLiRguDDatReq */
+} /* end of RlcLiRguDDatReq */
\f
*
*/
#ifdef ANSI
-PUBLIC S16 RlcMacSendBOStatus
+S16 RlcMacSendBOStatus
(
Pst *post,
SpId spId,
RlcMacBOStatus *boSta
)
#else
-PUBLIC S16 RlcMacSendBOStatus(post, spId, staRsp)
+S16 RlcMacSendBOStatus(post, spId, staRsp)
Pst *post;
SpId spId;
RlcMacBOStatus *boSta;
TRC3(RlcMacSendBOStatus)
#if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
post->event= EVTRGUDSTARSP;
- if((kwLiRguStaRspRbuf(post, spId, staRsp)) != ROK)
+ if((rlcLiRguStaRspRbuf(post, spId, staRsp)) != ROK)
{
return RFAILED;
}
*
*/
#ifdef ANSI
-PUBLIC S16 KwLiRguL2MUlThrpMeasReq
+S16 RlcLiRguL2MUlThrpMeasReq
(
Pst *post,
SpId spId,
RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq
)
#else
-PUBLIC S16 KwLiRguL2MUlThrpMeasReq(post, spId, l2mUlThrpMeasReq)
+S16 RlcLiRguL2MUlThrpMeasReq(post, spId, l2mUlThrpMeasReq)
Pst *post;
SpId spId;
RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq;
#endif
{
- TRC3(KwLiRguL2MUlThrpMeasReq)
+ TRC3(RlcLiRguL2MUlThrpMeasReq)
/* jump to specific primitive depending on configured selector */
(*kwLiRguL2MUlThrpMeasReqMt[post->selector])(post, spId, l2mUlThrpMeasReq);
return ROK;
-} /* end of KwLiRguL2MUlThrpMeasReq */
+} /* end of RlcLiRguL2MUlThrpMeasReq */
#endif /* LTE_RLC_R9 */
#endif /* LTE_L2_MEAS */
#ifdef MAC_RLC_UL_RBUF
-PUBLIC S16 rlcUlBatchProc ARGS ((Void));
-EXTERN Void kwUtlFreeUlRBuf ARGS((void));
+S16 rlcUlBatchProc ARGS ((Void));
+EXTERN Void rlcUtlFreeUlRBuf ARGS((void));
#ifdef ANSI
-PUBLIC S16 rlcUlBatchProc
+S16 rlcUlBatchProc
(
Void
)
#else
-PUBLIC S16 rlcUlBatchProc()
+S16 rlcUlBatchProc()
Void;
#endif
{
/* Read from Ring Buffer and process PDCP packets */
RguDDatIndInfo *datInd;
Void *elmIndx = NULLP;
- PRIVATE Pst rlcUlRbfuPst={1,1,ENTKW,0,ENTRG,0,PRIOR0,RTESPEC,EVTRLCULDAT,0,0,0,0};
+ PRIVATE Pst rlcUlRbfuPst={1,1,ENTRLC,0,ENTMAC,0,PRIOR0,RTESPEC,EVTRLCULDAT,0,0,0,0};
/* Read from Ring Buffer and process PDCP packets */
#ifndef SS_RBUF
SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].nPktProc++;;//Number of pkt processed in tti
if(datInd != NULLP)
{
- KwLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
+ RlcLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
}
else
{
while(NULLP != elmIndx)
{
datInd = (RguDDatIndInfo *)elmIndx;
- KwLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
+ RlcLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
elmIndx = NULLP;
datInd = NULLP;
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlFreeUlRBuf(void)
+Void rlcUtlFreeUlRBuf(void)
#else
-PUBLIC Void kwUtlFreeUlRBuf()
+Void rlcUtlFreeUlRBuf()
#endif
{
RguDDatIndInfo *datInd;
U8 numLch;
U8 numPdu;
- TRC2(kwUtlFreeUlRBuf)
+ TRC2(rlcUtlFreeUlRBuf)
/* Free SS_RNG_BUF_ULMAC_TO_ULRLC */
while((SDeqSRngBuf (SS_RNG_BUF_ULMAC_TO_ULRLC, &elem) == ROK))
{
#endif
#ifdef RLC_MAC_STA_RSP_RBUF
#ifdef ANSI
-PUBLIC S16 kwLiRguStaRspRbuf
+S16 rlcLiRguStaRspRbuf
(
Pst *post,
SpId spId,
Void *staRsp
)
#else
-PUBLIC S16 kwLiRguStaRspRbuf(post, spId, staRsp)
+S16 rlcLiRguStaRspRbuf(post, spId, staRsp)
Pst *post;
SpId spId;
Void *staRsp;
#endif
#ifdef RLC_MAC_DAT_REQ_RBUF
#ifdef ANSI
-PUBLIC S16 kwLiRguDatReqRbuf
+S16 rlcLiRguDatReqRbuf
(
Pst *post,
SpId spId,
Void *datReq
)
#else
-PUBLIC S16 kwLiRguDatReqRbuf(post, spId, datReq)
+S16 rlcLiRguDatReqRbuf(post, spId, datReq)
Pst *post;
SpId spId;
Void *datReq;
#ifdef PTKWLKW
/* portable functions */
-PRIVATE S16 PtMiRlcConfigCfm ARGS((Pst *pst, KwMngmt *cfm));
-PRIVATE S16 PtMiLkwCntrlCfm ARGS((Pst *pst, KwMngmt *cfm));
-PRIVATE S16 PtMiLkwStaInd ARGS((Pst *pst, KwMngmt *usta));
+PRIVATE S16 PtMiRlcConfigCfm ARGS((Pst *pst, RlcMngmt *cfm));
+PRIVATE S16 PtMiLkwCntrlCfm ARGS((Pst *pst, RlcMngmt *cfm));
+PRIVATE S16 PtMiLkwStaInd ARGS((Pst *pst, RlcMngmt *usta));
-PRIVATE S16 PtMiLkwStaCfm ARGS((Pst *pst, KwMngmt *cfm));
+PRIVATE S16 PtMiLkwStaCfm ARGS((Pst *pst, RlcMngmt *cfm));
PRIVATE S16 PtMiLkwStsCfm ARGS((Pst *pst, Action action,
- KwMngmt *cfm));
-PRIVATE S16 PtMiLkwTrcInd ARGS((Pst *pst, KwMngmt *trc,
+ RlcMngmt *cfm));
+PRIVATE S16 PtMiLkwTrcInd ARGS((Pst *pst, RlcMngmt *trc,
Buffer *mBuf));
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-PRIVATE S16 PtMiLkwL2MeasCfm ARGS((Pst *pst, KwL2MeasCfmEvt *measEvt));
+PRIVATE S16 PtMiLkwL2MeasCfm ARGS((Pst *pst, RlcL2MeasCfmEvt *measEvt));
PRIVATE S16 PtMiLkwL2MeasStopCfm ARGS((Pst *pst, U8 measType,U8 status));
#endif /* LTE_L2_MEAS */
#endif /* PTKWLKW */
********************************************************************/
/* Configuration confirmation primitive */
-PRIVATE RlcConfigCfm kwMiRlcConfigCfmMt[MAXKWMI] =
+PRIVATE RlcConfigCfm rlcMiRlcConfigCfmMt[MAXKWMI] =
{
#ifdef LCKWMILKW
packRlcConfigCfm, /* 0 - loosely coupled - fc */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-PRIVATE CONSTANT LkwL2MeasCfm KwMiLkwL2MeasCfmMt[] =
+PRIVATE CONSTANT LkwL2MeasCfm rlcMiLkwL2MeasCfmMt[] =
{
#ifdef LCKWMILKW
cmPkLkwL2MeasCfm,
PtMiLkwL2MeasCfm,
#endif
};
-PRIVATE CONSTANT LkwL2MeasStopCfm KwMiLkwL2MeasStopCfmMt[] =
+PRIVATE CONSTANT LkwL2MeasStopCfm RlcMiLkwL2MeasStopCfmMt[] =
{
#ifdef LCKWMILKW
cmPkLkwL2MeasStopCfm,
***************************************************************************/
/**
@brief
- This function is called by the KwMiRlcConfigReq function for responding
- to configuration requests.The cfm field in the KwMngmt structure contains
+ This function is called by the RlcMiRlcConfigReq function for responding
+ to configuration requests.The cfm field in the RlcMngmt structure contains
the response value.
- This function calls the mapping matrix for sending the configuration
*/
#ifdef ANSI
-PUBLIC S16 KwMiRlcConfigCfm
+S16 RlcMiRlcConfigCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* Layer Management structure */
+RlcMngmt *cfm /* Layer Management structure */
)
#else
-PUBLIC S16 KwMiRlcConfigCfm(pst, cfm)
+S16 RlcMiRlcConfigCfm(pst, cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* Layer Management structure */
+RlcMngmt *cfm; /* Layer Management structure */
#endif
{
- TRC3(KwMiRlcConfigCfm);
+ TRC3(RlcMiRlcConfigCfm);
/* jump to specific primitive depending on configured selector */
- (*kwMiRlcConfigCfmMt[pst->selector])(pst, cfm);
+ (*rlcMiRlcConfigCfmMt[pst->selector])(pst, cfm);
return ROK;
}
/**
@brief
- This function is called by the KwMiLkwCntrlReq function to send a control confirm to the layer management module.
+ This function is called by the RlcMiLkwCntrlReq function to send a control confirm to the layer management module.
- This function calls the mapping matrix for sending the control confirmation.
- Actual function called depends on the coupling of the LKW interface.
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwCntrlCfm
+S16 RlcMiLkwCntrlCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* configure */
+RlcMngmt *cfm /* configure */
)
#else
-PUBLIC S16 KwMiLkwCntrlCfm(pst, cfm)
+S16 RlcMiLkwCntrlCfm(pst, cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* confirm */
+RlcMngmt *cfm; /* confirm */
#endif
{
- TRC3(KwMiLkwCntrlCfm)
+ TRC3(RlcMiLkwCntrlCfm)
/* jump to specific primitive depending on configured selector */
(*kwMiLkwCntrlCfmMt[pst->selector])(pst, cfm);
return ROK;
-} /* end of KwMiLkwCntrlCfm */
+} /* end of RlcMiLkwCntrlCfm */
/**
@brief
the layer manager API provided.
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwStaInd
+S16 RlcMiLkwStaInd
(
Pst *pst, /* post structure */
-KwMngmt *usta /* unsolicited status */
+RlcMngmt *usta /* unsolicited status */
)
#else
-PUBLIC S16 KwMiLkwStaInd(pst, usta)
+S16 RlcMiLkwStaInd(pst, usta)
Pst *pst; /* post structure */
-KwMngmt *usta; /* unsolicited status */
+RlcMngmt *usta; /* unsolicited status */
#endif
{
- TRC3(KwMiLkwStaInd);
+ TRC3(RlcMiLkwStaInd);
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStaIndMt[pst->selector])(pst, usta);
- return ROK;
-} /* end of KwMiLkwStaInd */
+ return (ROK);
+} /* end of RlcMiLkwStaInd */
/**
@brief
- - This function is called by the KwMiLkwStaReq function to send
+ - This function is called by the RlcMiLkwStaReq function to send
the requested status information to the layer manager.
- This function calls the mapping matrix for sending the status
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwStaCfm
+S16 RlcMiLkwStaCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* solicited status confirmation */
+RlcMngmt *cfm /* solicited status confirmation */
)
#else
-PUBLIC S16 KwMiLkwStaCfm(pst, cfm)
+S16 RlcMiLkwStaCfm(pst, cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* solicited status confirmation */
+RlcMngmt *cfm; /* solicited status confirmation */
#endif
{
- TRC3(KwMiLkwStaCfm);
+ TRC3(RlcMiLkwStaCfm);
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStaCfmMt[pst->selector])(pst, cfm);
return ROK;
-} /* end of KwMiLkwStaCfm */
+} /* end of RlcMiLkwStaCfm */
/**
@brief
- - This function is called by the KwMiLkwStsReq function for responding
+ - This function is called by the RlcMiLkwStsReq function for responding
to statistics requests.
- This function calls the mapping matrix for sending the statistics
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwStsCfm
+S16 RlcMiLkwStsCfm
(
Pst *pst, /* post structure */
Action action, /* action */
-KwMngmt *cfm /* statistics confirmation */
+RlcMngmt *cfm /* statistics confirmation */
)
#else
-PUBLIC S16 KwMiLkwStsCfm(pst, action, cfm)
+S16 RlcMiLkwStsCfm(pst, action, cfm)
Pst *pst; /* post structure */
Action action; /* action */
-KwMngmt *cfm; /* statistics confirmation */
+RlcMngmt *cfm; /* statistics confirmation */
#endif
{
- TRC3(KwMiLkwStsCfm);
+ TRC3(RlcMiLkwStsCfm);
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStsCfmMt[pst->selector])(pst, action, cfm);
return ROK;
-} /* end of KwMiLkwStsCfm */
+} /* end of RlcMiLkwStsCfm */
/**
@brief
*/
#ifdef ANSI
-PUBLIC S16 KwMiLkwTrcInd
+S16 RlcMiLkwTrcInd
(
Pst *pst, /* post structure */
-KwMngmt *trc, /* trace indication */
+RlcMngmt *trc, /* trace indication */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 KwMiLkwTrcInd(pst, trc, mBuf)
+S16 RlcMiLkwTrcInd(pst, trc, mBuf)
Pst *pst; /* post structure */
-KwMngmt *trc; /* trace indication */
+RlcMngmt *trc; /* trace indication */
Buffer *mBuf; /* message buffer */
#endif
{
- TRC3(KwMiLkwTrcInd);
+ TRC3(RlcMiLkwTrcInd);
/* jump to specific primitive depending on configured selector */
(*kwMiLkwTrcIndMt[pst->selector])(pst, trc, mBuf);
return ROK;
-} /* end of KwMiLkwTrcInd */
+} /* end of RlcMiLkwTrcInd */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC S16 KwMiLkwL2MeasCfm
+S16 RlcMiLkwL2MeasCfm
(
Pst * pst,
-KwL2MeasCfmEvt *measEvt
+RlcL2MeasCfmEvt *measEvt
)
#else
-PUBLIC S16 KwMiLkwL2MeasCfm(pst, measEvt)
+S16 RlcMiLkwL2MeasCfm(pst, measEvt)
Pst * pst;
-KwL2MeasCfmEvt *measEvt;
+RlcL2MeasCfmEvt *measEvt;
#endif
{
- TRC3(KwMiLkwL2MeasCfm)
+ TRC3(RlcMiLkwL2MeasCfm)
- (*KwMiLkwL2MeasCfmMt[pst->selector])(pst, measEvt);
+ (*rlcMiLkwL2MeasCfmMt[pst->selector])(pst, measEvt);
return ROK;
}
#ifdef ANSI
-PUBLIC S16 KwMiLkwL2MeasStopCfm
+S16 RlcMiLkwL2MeasStopCfm
(
Pst *pst,
U8 measType,
U8 status
)
#else
-PUBLIC S16 KwMiLkwL2MeasStopCfm(pst, measType,status)
+S16 RlcMiLkwL2MeasStopCfm(pst, measType,status)
Pst *pst;
U8 measType;
U8 status;
#endif
{
- TRC3(KwMiLkwL2MeasStopCfm)
+ TRC3(RlcMiLkwL2MeasStopCfm)
- (*KwMiLkwL2MeasStopCfmMt[pst->selector])(pst, measType,status);
+ (*RlcMiLkwL2MeasStopCfmMt[pst->selector])(pst, measType,status);
return ROK;
*/
#ifdef ANSI
-PUBLIC S16 PtMiRlcConfigCfm
+S16 PtMiRlcConfigCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* Layer Management structure */
+RlcMngmt *cfm /* Layer Management structure */
)
#else
-PUBLIC S16 PtMiRlcConfigCfm(pst, cfm)
+S16 PtMiRlcConfigCfm(pst, cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* Layer Management structure */
+RlcMngmt *cfm; /* Layer Management structure */
#endif
{
TRC3(PtMiRlcConfigCfm)
PRIVATE S16 PtMiLkwCntrlCfm
(
Pst *pst, /* Post structure */
-KwMngmt *cfm /* Layer Management structure */
+RlcMngmt *cfm /* Layer Management structure */
)
#else
PRIVATE S16 PtMiLkwCntrlCfm(pst, cfm)
Pst *pst; /* Post structure */
-KwMngmt *cfm; /* Layer Management structure */
+RlcMngmt *cfm; /* Layer Management structure */
#endif
{
TRC3(PtMiLkwCntrlCfm);
PRIVATE S16 PtMiLkwStaInd
(
Pst *pst, /* post structure */
-KwMngmt *usta /* unsolicited status */
+RlcMngmt *usta /* unsolicited status */
)
#else
PRIVATE S16 PtMiLkwStaInd(pst, usta)
Pst *pst; /* post structure */
-KwMngmt *usta; /* unsolicited status */
+RlcMngmt *usta; /* unsolicited status */
#endif
{
TRC3(PtMiLkwStaInd)
PRIVATE S16 PtMiLkwStaCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* solicited status confirmation */
+RlcMngmt *cfm /* solicited status confirmation */
)
#else
PRIVATE S16 PtMiLkwStaCfm(pst, cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* solicited status confirmation */
+RlcMngmt *cfm; /* solicited status confirmation */
#endif
{
TRC3(PtMiLkwStaCfm)
(
Pst *pst, /* post structure */
Action action, /* action */
-KwMngmt *cfm /* statistics confirmation */
+RlcMngmt *cfm /* statistics confirmation */
)
#else
PRIVATE S16 PtMiLkwStsCfm(pst, action, cfm)
Pst *pst; /* post structure */
Action action; /* action */
-KwMngmt *cfm; /* statistics confirmation */
+RlcMngmt *cfm; /* statistics confirmation */
#endif
{
TRC3(PtMiLkwStsCfm)
PRIVATE S16 PtMiLkwTrcInd
(
Pst *pst, /* post structure */
-KwMngmt *trc, /* trace indication */
+RlcMngmt *trc, /* trace indication */
Buffer *mBuf /* message buffer */
)
#else
PRIVATE S16 PtMiLkwTrcInd(pst, trc, mBuf)
Pst *pst; /* post structure */
-KwMngmt *trc; /* trace indication */
+RlcMngmt *trc; /* trace indication */
Buffer *mBuf; /* message buffer */
#endif
{
PRIVATE S16 PtMiLkwL2MeasCfm
(
Pst * pst,
-KwL2MeasCfmEvt * measEvt
+RlcL2MeasCfmEvt * measEvt
)
#else
PRIVATE S16 PtMiLkwL2MeasCfm(pst, measEvt)
Pst * pst;
-KwL2MeasCfmEvt * measEvt;
+RlcL2MeasCfmEvt * measEvt;
#endif
{
* Forward Declartion for KWU Porting Functions
********************************************************************/
#if defined(PDCP_RLC_DL_RBUF) || defined(SS_RBUF)
-PUBLIC S16 rlcDlBatchProc ARGS ((Void));
-PUBLIC S16 kwUtlDlFreeRlcRBuf ARGS((Void));
-EXTERN void kwUtlDlBatchProcHqStaInd ARGS ((Void));
-EXTERN Void kwUtlFreeDlMem ARGS((Void));
+S16 rlcDlBatchProc ARGS ((Void));
+S16 rlcUtlDlFreeRlcRBuf ARGS((Void));
+EXTERN void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
+EXTERN Void rlcUtlFreeDlMem ARGS((Void));
EXTERN SsRngBufCnt rngCb;
-EXTERN S16 kwUtlDlBatchProcPkts ARGS((Void));
+EXTERN S16 rlcUtlDlBatchProcPkts ARGS((Void));
#endif
#if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
-PUBLIC S16 rlcDlBatchProcSplit ARGS((Void));
+S16 rlcDlBatchProcSplit ARGS((Void));
#endif
\f
/* KWU Bind Confirm primitive */
-PUBLIC KwuBndCfm kwUiKwuBndCfmMt[] =
+KwuBndCfm kwUiKwuBndCfmMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuBndCfm, /* 0 - loosely coupled */
/* KWU Data Indication primitive */
-PUBLIC KwuDatInd kwUiKwuDatIndMt[] =
+KwuDatInd kwUiKwuDatIndMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuDatInd, /* 0 - loosely coupled */
};
#ifndef KW_PDCP
-PUBLIC KwuDatCfm kwUiKwuDatCfmMt[] =
+KwuDatCfm kwUiKwuDatCfmMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuDatCfm, /* 0 - loosely coupled */
/* KWU AM Status Indication primitive */
-PUBLIC KwuStaInd kwUiKwuStaIndMt[] =
+KwuStaInd kwUiKwuStaIndMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuStaInd, /* 0 - loosely coupled */
#endif /*TENB_ACC*/
};
-PUBLIC KwuReEstCmpInd kwUiKwuReEstCmpIndMt[] =
+KwuReEstCmpInd kwUiKwuReEstCmpIndMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuReEstCmpInd, /* 0 - loosely coupled */
};
/* kw005.201 added support for L2 measurement */
-PUBLIC KwuDiscSduCfm kwUiKwuDiscSduCfmMt[] =
+KwuDiscSduCfm kwUiKwuDiscSduCfmMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuDiscSduCfm, /* 0 - loosely coupled */
#endif /* PJ */
#endif /*TENB_ACC*/
};
-PUBLIC KwuFlowCntrlInd kwUiKwuFlowCntrlIndMt[] =
+KwuFlowCntrlInd kwUiKwuFlowCntrlIndMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuFlowCntrlInd, /* 0 - loosely coupled */
#endif /* LCKWUIKWU */
};
#ifdef LTE_L2_MEAS
-PUBLIC KwuDatAckInd kwUiKwuDatAckIndMt[] =
+KwuDatAckInd kwUiKwuDatAckIndMt[] =
{
#ifdef LCKWUIKWU
cmPkKwuDatAckInd, /* 0 - loosely coupled */
*
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuBndCfm
+S16 RlcUiKwuBndCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
U8 status /* Status */
)
#else
-PUBLIC S16 KwUiKwuBndCfm(pst, suId, status)
+S16 RlcUiKwuBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
U8 status; /* Status */
#endif
{
- TRC3(KwUiKwuBndCfm)
+ TRC3(RlcUiKwuBndCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuBndCfmMt[pst->selector])(pst, suId, status);
return ROK;
-} /* end of KwUiKwuBndCfm */
+} /* end of RlcUiKwuBndCfm */
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuDatInd
+S16 RlcUiKwuDatInd
(
Pst *pst,
KwuDatIndInfo *datInd,
Buffer *mBuf
)
#else
-PUBLIC S16 KwUiKwuDatInd(pst, datInd, mBuf)
+S16 RlcUiKwuDatInd(pst, datInd, mBuf)
Pst *pst;
KwuDatIndInfo *datInd;
Buffer *mBuf;
#endif
{
- TRC3(KwUiKwuDatInd)
+ TRC3(RlcUiKwuDatInd)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatIndMt[pst->selector])(pst, datInd, mBuf);
return ROK;
-} /* end of KwUiKwuDatInd */
+} /* end of RlcUiKwuDatInd */
- PUBLIC int rlcDatCfmsSent = 0;
+ int rlcDatCfmsSent = 0;
\f
#ifndef KW_PDCP
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuDatCfm
+S16 RlcUiKwuDatCfm
(
Pst *pst,
SuId suId,
KwuDatCfmInfo *datCfm
)
#else
-PUBLIC S16 KwUiKwuDatCfm(pst, suId, datCfm)
+S16 RlcUiKwuDatCfm(pst, suId, datCfm)
Pst *pst;
SuId suId;
KwuDatCfmInfo *datCfm;
#endif
{
rlcDatCfmsSent++;
- TRC3(KwUiKwuDatCfm)
+ TRC3(RlcUiKwuDatCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatCfmMt[pst->selector])(pst, suId, datCfm);
return ROK;
-} /* end of KwUiKwuDatCfm */
+} /* end of RlcUiKwuDatCfm */
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuStaInd
+S16 RlcUiKwuStaInd
(
Pst *pst,
SuId suId,
KwuStaIndInfo *staInd
)
#else
-PUBLIC S16 KwUiKwuStaInd(pst, suId, staInd)
+S16 RlcUiKwuStaInd(pst, suId, staInd)
Pst *pst;
SuId suId;
KwuStaIndInfo *staInd;
#endif
{
- TRC3(KwUiKwuStaInd)
+ TRC3(RlcUiKwuStaInd)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuStaIndMt[pst->selector])(pst, suId, staInd);
return ROK;
-} /* end of KwUiKwuStaInd */
+} /* end of RlcUiKwuStaInd */
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuReEstCmpInd
+S16 RlcUiKwuReEstCmpInd
(
Pst *pst,
SuId suId,
CmLteRlcId rlcId
)
#else
-PUBLIC S16 KwUiKwuReEstCmpInd(pst, suId, rlcId)
+S16 RlcUiKwuReEstCmpInd(pst, suId, rlcId)
Pst *pst;
SuId suId;
CmLteRlcId rlcId;
#endif
{
- TRC3(KwUiKwuReEstCmpInd)
- RLOG0(L_DEBUG, "In KwUiKwuReEstCmpInd");
+ TRC3(RlcUiKwuReEstCmpInd)
+ RLOG0(L_DEBUG, "In RlcUiKwuReEstCmpInd");
/* jump to specific primitive depending on configured selector */
(*kwUiKwuReEstCmpIndMt[pst->selector])(pst, suId, rlcId);
return ROK;
-} /* end of KwUiKwuReEstCmpInd */
+} /* end of RlcUiKwuReEstCmpInd */
/* kw005.201 added support for L2 Measurement */
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuDiscSduCfm
+S16 RlcUiKwuDiscSduCfm
(
Pst *pst,
SuId suId,
KwuDiscSduInfo *discCfm
)
#else
-PUBLIC S16 KwUiKwuDiscSduCfm(pst, suId, discCfm)
+S16 RlcUiKwuDiscSduCfm(pst, suId, discCfm)
Pst *pst;
SuId suId;
KwuDiscSduInfo *discCfm;
#endif
{
- TRC3(KwUiKwuDiscSduCfm)
+ TRC3(RlcUiKwuDiscSduCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDiscSduCfmMt[pst->selector])(pst, suId, discCfm);
return ROK;
-} /* end of KwUiKwuDiscSduCfm */
+} /* end of RlcUiKwuDiscSduCfm */
/**
*
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuFlowCntrlInd
+S16 RlcUiKwuFlowCntrlInd
(
Pst *pst,
SuId suId,
KwuFlowCntrlIndInfo *flowCntrlIndInfo
)
#else
-PUBLIC S16 KwUiKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
+S16 RlcUiKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
Pst *pst;
SuId suId;
KwuFlowCntrlIndInfo *flowCntrlIndInfo;
#endif
{
- TRC3(KwUiKwuFlowCntrlInd)
+ TRC3(RlcUiKwuFlowCntrlInd)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuFlowCntrlIndMt[pst->selector])(pst, suId, flowCntrlIndInfo);
return ROK;
-} /* end of KwUiKwuFlowCntrlInd */
+} /* end of RlcUiKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuDatAckInd
+S16 RlcUiKwuDatAckInd
(
Pst *pst,
SuId suId,
KwuDatAckInfo *datAckInd
)
#else
-PUBLIC S16 KwUiKwuDatAckInd(pst, suId, datAckInd)
+S16 RlcUiKwuDatAckInd(pst, suId, datAckInd)
Pst *pst;
SuId suId;
KwuDatAckInfo *datAckInd;
#endif
{
- TRC3(KwUiKwuDatAckInd)
+ TRC3(RlcUiKwuDatAckInd)
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatAckIndMt[pst->selector])(pst, suId, datAckInd);
return ROK;
-} /* end of KwUiKwuDatAckInd */
+} /* end of RlcUiKwuDatAckInd */
#endif /* LTE_L2_MEAS */
#endif /* KW_PDCP */
/* CKW Bind Confirm primitive */
-PUBLIC CkwBndCfm kwUiCkwBndCfmMt[] =
+CkwBndCfm kwUiCkwBndCfmMt[] =
{
#ifdef LCKWUICKW
cmPkCkwBndCfm, /* 0 - loosely coupled */
/* CKW Configuration confirm primitive */
-PUBLIC RlcCfgCfm kwUiRlcCfgCfmMt[] =
+RlcCfgCfm kwUiRlcCfgCfmMt[] =
{
#ifdef LCKWUICKW
cmPkRlcCfgCfm, /* 0 - loosely coupled */
#endif /* NH */
};
-PUBLIC CkwUeIdChgCfm kwUiCkwUeIdChgCfmMt[] =
+CkwUeIdChgCfm kwUiCkwUeIdChgCfmMt[] =
{
#ifdef LCKWUICKW
cmPkCkwUeIdChgCfm, /* 0 - loosely coupled */
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 KwUiCkwBndCfm
+S16 RlcUiCkwBndCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
U8 status /* Status */
)
#else
-PUBLIC S16 KwUiCkwBndCfm(pst, suId, status)
+S16 RlcUiCkwBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
U8 status; /* Status */
#endif
{
- TRC3(KwUiCkwBndCfm)
+ TRC3(RlcUiCkwBndCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiCkwBndCfmMt[pst->selector])(pst, suId, status);
return ROK;
-} /* end of KwUiCkwBndCfm */
+} /* end of RlcUiCkwBndCfm */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 KwUiRlcCfgCfm
+S16 RlcUiRlcCfgCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
RlcCfgCfmInfo *cfmInfo /* Configuration Confirm */
)
#else
-PUBLIC S16 KwUiRlcCfgCfm(pst, suId, cfmInfo)
+S16 RlcUiRlcCfgCfm(pst, suId, cfmInfo)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
RlcCfgCfmInfo *cfmInfo; /* Configuration Confirm */
#endif
{
- TRC3(KwUiRlcCfgCfm)
+ TRC3(RlcUiRlcCfgCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiRlcCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
return ROK;
-} /* end of KwUiRlcCfgCfm */
+} /* end of RlcUiRlcCfgCfm */
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 KwUiCkwUeIdChgCfm
+S16 RlcUiCkwUeIdChgCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
CmStatus status
)
#else
-PUBLIC S16 KwUiCkwUeIdChgCfm(pst, suId, transId,ueInfo,status)
+S16 RlcUiCkwUeIdChgCfm(pst, suId, transId,ueInfo,status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
U32 transId;
CmStatus status;
#endif
{
- TRC3(KwUiCkwUeIdChgCfm)
+ TRC3(RlcUiCkwUeIdChgCfm)
/* jump to specific primitive depending on configured selector */
(*kwUiCkwUeIdChgCfmMt[pst->selector])(pst, suId, transId, ueInfo, status);
return ROK;
-} /* end of KwUiRlcCfgCfm */
+} /* end of RlcUiRlcCfgCfm */
#if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 rlcDlBatchProcSplit
+S16 rlcDlBatchProcSplit
(
Void
)
#else
-PUBLIC S16 rlcDlBatchProcSplit()
+S16 rlcDlBatchProcSplit()
Void;
#endif
{
datReq = (RxmBufReq *)elmIndx;
if(datReq->mBuf != NULLP)
{
- cmUnpkKwuDatReq(KwUiKwuDatReq, &datReq->pst, datReq->mBuf);
+ cmUnpkKwuDatReq(RlcUiKwuDatReq, &datReq->pst, datReq->mBuf);
}
else
{
RLOG0(L_ERROR, "mBuf is NULL");
if(datReq->mBuf)
- cmUnpkKwuDatReq(KwUiKwuDatReq, &datReq->pst, datReq->mBuf);
+ cmUnpkKwuDatReq(RlcUiKwuDatReq, &datReq->pst, datReq->mBuf);
}
SsRngInfoTbl[SS_RNG_BUF_RX_TO_DLRLC].nPktProc++;//Number of pkt processed in tti
#if defined(PDCP_RLC_DL_RBUF) || defined(SS_RBUF)
#ifdef ANSI
-PUBLIC S16 rlcDlBatchProc
+S16 rlcDlBatchProc
(
Void
)
#else
-PUBLIC S16 rlcDlBatchProc()
+S16 rlcDlBatchProc()
Void;
#endif
{
/* Memory regions different for BRCM and Intel */
/*dstProcId,srcProcId,dstEnt,dstInst,srcEnt,srcInst,prior,route,event,region,pool,selector*/
#ifdef SS_RBUF
- PRIVATE Pst rlcDlRbfuPst ={1,1,ENTKW,1,ENTPJ,1,PRIOR0,RTESPEC,KWU_EVT_DAT_REQ,1,1,0,0};
+ PRIVATE Pst rlcDlRbfuPst ={1,1,ENTRLC,1,ENTPJ,1,PRIOR0,RTESPEC,KWU_EVT_DAT_REQ,1,1,0,0};
#else
- PRIVATE Pst rlcDlRbfuPst ={1,1,ENTKW,1,ENTPJ,1,PRIOR0,RTESPEC,KWU_EVT_DAT_REQ,2,1,0,0};
+ PRIVATE Pst rlcDlRbfuPst ={1,1,ENTRLC,1,ENTPJ,1,PRIOR0,RTESPEC,KWU_EVT_DAT_REQ,2,1,0,0};
#endif
Void *elmIndx = NULLP;
KwuDatReqDetl *kwuDatReqDetl = NULLP;
SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].nPktProc++;;//Number of pkt processed in tti
if(kwuDatReqDetl->mBuf != NULLP)
{
- KwUiKwuDatReq(&rlcDlRbfuPst, kwuDatReqDetl->spId, &datReq, kwuDatReqDetl->mBuf);
+ RlcUiKwuDatReq(&rlcDlRbfuPst, kwuDatReqDetl->spId, &datReq, kwuDatReqDetl->mBuf);
}
SRngIncrRIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
rngBufDeqIndx++;
#ifdef ANSI
-PUBLIC S16 kwUtlDlBatchProcPkts
+S16 rlcUtlDlBatchProcPkts
(
Void
)
#else
-PUBLIC S16 kwUtlDlBatchProcPkts
+S16 rlcUtlDlBatchProcPkts
Void;
#endif
{
rlcDlBatchProc();
#ifdef SS_RBUF
#ifdef LTE_L2_MEAS
- kwUtlDlBatchProcHqStaInd();
+ rlcUtlDlBatchProcHqStaInd();
#endif
- kwUtlFreeDlMem();
+ rlcUtlFreeDlMem();
#endif
return ROK;
}
#ifdef ANSI
-PUBLIC S16 kwUtlDlFreeRlcRBuf
+S16 rlcUtlDlFreeRlcRBuf
(
Void
)
#else
-PUBLIC S16 kwUtlDlFreeRlcRBuf
+S16 rlcUtlDlFreeRlcRBuf
Void;
#endif
{
#endif
#ifdef TENB_STATS
-PUBLIC TSL2CellStatsCb* l2CellStats[L2_STATS_MAX_CELLS];
-PUBLIC TSL2UeStatsCb* l2UeStats[L2_STATS_MAX_UES];
-PUBLIC CmLListCp freeL2UeStatsLst; /*!< Free Pool of UE stats Blocks */
-PUBLIC CmLListCp inUseL2UeStatsLst;/*!< In Use Pool of UE stats Blocks */
+TSL2CellStatsCb* l2CellStats[L2_STATS_MAX_CELLS];
+TSL2UeStatsCb* l2UeStats[L2_STATS_MAX_UES];
+CmLListCp freeL2UeStatsLst; /*!< Free Pool of UE stats Blocks */
+CmLListCp inUseL2UeStatsLst;/*!< In Use Pool of UE stats Blocks */
/*
*
*
*/
#ifdef ANSI
-PUBLIC Void TSL2AllocStatsMem
+Void TSL2AllocStatsMem
(
Region region,
Pool pool
)
#else
-PUBLIC Void TSL2AllocStatsMem(region, pool)
+Void TSL2AllocStatsMem(region, pool)
Region region;
Pool pool;
#endif
*
*/
#ifdef ANSI
-PUBLIC TSL2UeStatsCb* TSL2AllocUeStatsBlk
+TSL2UeStatsCb* TSL2AllocUeStatsBlk
(
U16 rnti
)
#else
-PUBLIC TSL2UeStatsCb* TSL2AllocUeStatsBlk(rnti)
+TSL2UeStatsCb* TSL2AllocUeStatsBlk(rnti)
U16 rnti;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void TSL2DeallocUeStatsBlk
+Void TSL2DeallocUeStatsBlk
(
U16 rnti,
TSL2UeStatsCb *statsCb
)
#else
-PUBLIC Void TSL2DeallocUeStatsBlk(rnti, statsCb)
+Void TSL2DeallocUeStatsBlk(rnti, statsCb)
U16 rnti;
TSL2UeStatsCb *statsCb;
#endif
*
*/
#ifdef ANSI
-PUBLIC TSL2CellStatsCb* TSL2AllocCellStatsBlk
+TSL2CellStatsCb* TSL2AllocCellStatsBlk
(
U32 cellId
)
#else
-PUBLIC TSL2CellStatsCb* TSL2AllocCellStatsBlk(cellId)
+TSL2CellStatsCb* TSL2AllocCellStatsBlk(cellId)
U32 cellId;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void TSL2DeallocCellStatsBlk
+Void TSL2DeallocCellStatsBlk
(
U32 cellId
)
#else
-PUBLIC Void TSL2DeallocCellStatsBlk(cellId)
+Void TSL2DeallocCellStatsBlk(cellId)
U32 cellId;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void TSL2SendStatsToApp
+Void TSL2SendStatsToApp
(
Pst *pst,
SuId suId
)
#else
-PUBLIC Void TSL2SendStatsToApp(pst, suId)
+Void TSL2SendStatsToApp(pst, suId)
Pst *pst;
SuId suId;
#endif
Desc: Source code for RLC Transparent mode assembly and
reassembly.This file contains following functions
- --kwTmmQSdu
- --kwTmmSndToLi
- --kwTmmRcvFrmLi
+ --rlcTmmQSdu
+ --rlcTmmSndToLi
+ --rlcTmmRcvFrmLi
--kwTmmReEstablish
File: kw_tmm_dl.c
#include "kw_udx.x"
#include "kw_dl.x"
-#define KW_MODULE (KW_DBGMASK_TM | KW_DBGMASK_DL)
+#define RLC_MODULE (RLC_DBGMASK_TM | RLC_DBGMASK_DL)
-PRIVATE Void kwTmmSndStaRsp ARGS((RlcCb *gCb, RlcDlRbCb *rbCb,
+PRIVATE Void rlcTmmSndStaRsp ARGS((RlcCb *gCb, RlcDlRbCb *rbCb,
MsgLen bo, KwuDatReqInfo *datReqInfo));
extern U32 rgMacGT ;
/** @addtogroup tmmode */
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Void kwTmmQSdu
+Void rlcTmmQSdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *mBuf
)
#else
-PUBLIC Void kwTmmQSdu(gCb,rbCb,datReqInfo,mBuf)
+Void rlcTmmQSdu(gCb,rbCb,datReqInfo,mBuf)
RlcCb *gCb;
RlcDlRbCb *rbCb;
KwuDatReqInfo *datReqInfo;
Buffer *mBuf;
#endif
{
- KwSdu *sdu;
+ RlcSdu *sdu;
- TRC2(kwTmmQSdu)
+ TRC2(rlcTmmQSdu)
- RLC_ALLOC(gCb,sdu,sizeof(KwSdu));
+ RLC_ALLOC(gCb,sdu,sizeof(RlcSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
cmLListAdd2Tail(&(rbCb->m.tm.sduQ), &(sdu->lstEnt));
sdu->lstEnt.node = (PTR)sdu;
- kwTmmSndStaRsp(gCb, rbCb, sdu->sduSz, datReqInfo);
+ rlcTmmSndStaRsp(gCb, rbCb, sdu->sduSz, datReqInfo);
RETVOID;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Void kwTmmSndToLi
+Void rlcTmmSndToLi
(
RlcCb *gCb,
SuId suId,
RguCStaIndInfo *staInd
)
#else
-PUBLIC Void kwTmmSndToLi(gCb, suId, rbCb, staInd)
+Void rlcTmmSndToLi(gCb, suId, rbCb, staInd)
RlcCb *gCb;
SuId suId;
RlcDlRbCb *rbCb;
#endif
{
CmLList *node; /* Current Link List Node */
- KwSdu *sdu; /* SDU */
+ RlcSdu *sdu; /* SDU */
RlcMacData *dlData;
S16 timeDiff = 0;
Ticks curTime = 0;
- TRC2(kwTmmSndToLi)
+ TRC2(rlcTmmSndToLi)
CM_LLIST_FIRST_NODE(&(rbCb->m.tm.sduQ),
* validated with alloted (sfn,slot)in the MAC layer */
while (node != NULLP)
{
- sdu = (KwSdu *)(node->node);
+ sdu = (RlcSdu *)(node->node);
if ( rbCb->lch.lChType == CM_LTE_LCH_BCCH ||
rbCb->lch.lChType == CM_LTE_LCH_PCCH )
{
rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
RLC_FREE_BUF(sdu->mBuf);
- RLC_FREE(gCb, sdu, sizeof(KwSdu));
+ RLC_FREE(gCb, sdu, sizeof(RlcSdu));
}
else
{
rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
RLC_FREE_BUF(sdu->mBuf);
- RLC_FREE(gCb, sdu, sizeof(KwSdu));
+ RLC_FREE(gCb, sdu, sizeof(RlcSdu));
continue;
}
rbCb->rlcId.cellId);
RETVOID;
}
- sdu = (KwSdu *)node->node;
+ sdu = (RlcSdu *)node->node;
RLC_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap[suId].pst.region,
gCb->u.dlCb->rguDlSap[suId].pst.pool,
gCb->genSts.bytesSent += sdu->sduSz;
gCb->genSts.pdusSent++;
- kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId);
+ rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId);
/* remove SDU from queue */
sdu->mBuf = NULLP;
cmLListDelFrm(&(rbCb->m.tm.sduQ),
&sdu->lstEnt);
- RLC_FREE(gCb,sdu, sizeof(KwSdu));
+ RLC_FREE(gCb,sdu, sizeof(RlcSdu));
/* If trace flag is enabled send the trace indication */
if(gCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(gCb,EVTRLCDLDAT, NULLP);
+ rlcLmmSendTrc(gCb,EVTRLCDLDAT, NULLP);
}
RlcMacSendDlData(&(gCb->u.dlCb->rguDlSap[suId].pst),
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcDlTmmReEstablish
+Void rlcDlTmmReEstablish
(
RlcCb *gCb,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void rlcDlTmmReEstablish(gCb,rbCb)
+Void rlcDlTmmReEstablish(gCb,rbCb)
RlcCb *gCb;
RlcDlRbCb *rbCb;
#endif
#ifdef LTE_L2_MEAS_RLC
- kwUtlEmptySduQ(gCb, rbCb, &rbCb->m.tm.sduQ);
+ rlcUtlEmptySduQ(gCb, rbCb, &rbCb->m.tm.sduQ);
#else
- kwUtlEmptySduQ(gCb,&rbCb->m.tm.sduQ);
+ rlcUtlEmptySduQ(gCb,&rbCb->m.tm.sduQ);
#endif
RETVOID;
*/
#ifdef ANSI
-PRIVATE Void kwTmmSndStaRsp
+PRIVATE Void rlcTmmSndStaRsp
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatReqInfo *datReqInfo
)
#else
-PRIVATE Void kwTmmSndStaRsp(rbCb,bo,datReqInfo)
+PRIVATE Void rlcTmmSndStaRsp(rbCb,bo,datReqInfo)
RlcCb *gCb;
RlcDlRbCb *rbCb;
MsgLen bo;
{
// RguCStaRspInfo *staRspInfo; /* Status Response Information */
RlcMacBOStatus *boStatus; /* Buffer occupancy status information */
- KwRguSapCb *rguSap; /* SAP Information */
+ RlcRguSapCb *rguSap; /* SAP Information */
- TRC3(kwTmmSndStaRsp)
+ TRC3(rlcTmmSndStaRsp)
rguSap = &(gCb->u.dlCb->rguDlSap[rbCb->rguSapId]);
if(gCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(gCb, EVTRLCBOSTA, NULLP);
+ rlcLmmSendTrc(gCb, EVTRLCBOSTA, NULLP);
}
RlcMacSendBOStatus(&rguSap->pst, rguSap->spId, boStatus);
Desc: Source code for RLC Transparent mode assembly and
reassembly.This file contains following functions
- --kwTmmQSdu
- --kwTmmSndToLi
- --kwTmmRcvFrmLi
+ --rlcTmmQSdu
+ --rlcTmmSndToLi
+ --rlcTmmRcvFrmLi
--kwTmmReEstablish
File: kw_tmm_ul.c
EXTERN S16 PjUiPjuDatInd(Pst* pst,SuId suId,CmLtePdcpId * pdcpId,Buffer *mBuf);
#ifdef ANSI
-PUBLIC Void AddUeContext
+Void AddUeContext
(
CmLteRnti crnti,
U8 rrcMsgType
)
#else
-PUBLIC Void AddUeContext(crnti,rrcMsgType)
+Void AddUeContext(crnti,rrcMsgType)
CmLteRnti crnti,
U8 rrcMsgType
#endif
#ifdef PJ
Pst ulPst2 ={100,100,217,0,216,0,PRIOR0,0,68,0,1,0,0};
#endif
- TRC2(kwTmmRcvFrmLi)
+ TRC2(rlcTmmRcvFrmLi)
if(1 == rrcMsgType)
{
RLOG1(L_INFO,"Profiling Framework Sending RRC Connection Req to RRC for UE :%d\n",crnti);
printf("Profiling Framework Sending RRC Connection Req to RRC for UE :%d\n",crnti);
- KwUiKwuDatInd(&ulPst1, datIndInfo, pdu);
+ RlcUiKwuDatInd(&ulPst1, datIndInfo, pdu);
}
else if(2 == rrcMsgType)
{
/** @addtogroup tmmode */
/*@{*/
-#define KW_MODULE (KW_DBGMASK_TM | KW_DBGMASK_UL)
+#define RLC_MODULE (RLC_DBGMASK_TM | RLC_DBGMASK_UL)
/**
* @brief
*/
#ifdef CCPU_OPT
#ifdef ANSI
-PUBLIC Void kwTmmRcvFrmLi
+Void rlcTmmRcvFrmLi
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu
)
#else
-PUBLIC Void kwTmmRcvFrmLi(gCb,rbCb, tCrnti, pdu)
+Void rlcTmmRcvFrmLi(gCb,rbCb, tCrnti, pdu)
RlcCb *gCb;
RlcUlRbCb *rbCb;
CmLteRnti tCrnti;
#endif
#else
#ifdef ANSI
-PUBLIC Void kwTmmRcvFrmLi
+Void rlcTmmRcvFrmLi
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu
)
#else
-PUBLIC Void kwTmmRcvFrmLi(gCb,rbCb, pdu)
+Void rlcTmmRcvFrmLi(gCb,rbCb, pdu)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *pdu;
uint16_t copyLen; /* Number of bytes copied */
Pst pst;
- TRC2(kwTmmRcvFrmLi)
+ TRC2(rlcTmmRcvFrmLi)
gCb->genSts.pdusRecv++;
SFndLenMsg(pdu, (MsgLen *)&msgLen);
if(gCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(gCb, EVENT_UL_RRC_MSG_TRANS_TO_DU, pdu);
+ rlcLmmSendTrc(gCb, EVENT_UL_RRC_MSG_TRANS_TO_DU, pdu);
}
/* Filling UL RRC Message Info */
*
**/
#ifdef ANSI
-PUBLIC Void kwTmmUlReEstablish
+Void rlcTmmUlReEstablish
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwTmmUlReEstablish(rbCb)
+Void rlcTmmUlReEstablish(rbCb)
RlcCb *gCb;
-KwRbCb *rbCb;
+RlcUlRbCb *rbCb;
#endif
{
TRC2(rlcUlTmmReEstablish)
Desc: Source code for timer functions such as,
- - kwStartTmr
- - kwStopTmr
- - kwTmrExpiry
- - kwBndTmrExpiry
+ - rlcStartTmr
+ - rlcStopTmr
+ - rlcTmrExpiry
+ - rlcBndTmrExpiry
File: kw_tmr.c
*/
/**
- * @def KW_TMR_CALCUATE_WAIT
+ * @def RLC_TMR_CALCUATE_WAIT
*
* This macro calculates and assigns wait time based on the value of the
* timer and the timer resolution. Timer value of 0 signifies that the
* @param[in] _timerRes Resolution of the timer
*
*/
-#define KW_TMR_CALCUATE_WAIT(_wait, _tmrVal, _timerRes) \
+#define RLC_TMR_CALCUATE_WAIT(_wait, _tmrVal, _timerRes) \
{ \
(_wait) = ((_tmrVal) * SS_TICKS_SEC)/((_timerRes) * 1000); \
if((0 != (_tmrVal)) && (0 == (_wait))) \
}
/* private function declarations */
-PRIVATE Void kwBndTmrExpiry(PTR cb);
+PRIVATE Void rlcBndTmrExpiry(PTR cb);
/**
* @brief Handler to start timer
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwStartTmr
+Void rlcStartTmr
(
RlcCb *gCb,
PTR cb,
S16 tmrEvnt
)
#else
-PUBLIC Void kwStartTmr (gCb,cb, tmrEvnt)
+Void rlcStartTmr (gCb,cb, tmrEvnt)
RlcCb *gCb;
PTR cb;
S16 tmrEvnt;
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- KwL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
#endif
CmTmrArg arg;
arg.wait = 0;
- TRC2(kwStartTmr)
+ TRC2(rlcStartTmr)
/* kw002.201 Adjusting the wait time as per timeRes configured by layer manager */
switch (tmrEvnt)
{
- case KW_EVT_UMUL_REORD_TMR:
+ case RLC_EVT_UMUL_REORD_TMR:
{
- KwUmUl* umUl = &(((RlcUlRbCb *)cb)->m.umUl);
+ RlcUmUl* umUl = &(((RlcUlRbCb *)cb)->m.umUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
- KW_TMR_CALCUATE_WAIT(arg.wait, umUl->reOrdTmrInt, gCb->genCfg.timeRes);
+ RLC_TMR_CALCUATE_WAIT(arg.wait, umUl->reOrdTmrInt, gCb->genCfg.timeRes);
arg.timers = &umUl->reOrdTmr;
- arg.max = KW_MAX_UM_TMR;
+ arg.max = RLC_MAX_UM_TMR;
break;
}
- case KW_EVT_AMUL_REORD_TMR:
+ case RLC_EVT_AMUL_REORD_TMR:
{
- KwAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
+ RlcAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
- KW_TMR_CALCUATE_WAIT(arg.wait, amUl->reOrdTmrInt, gCb->genCfg.timeRes);
+ RLC_TMR_CALCUATE_WAIT(arg.wait, amUl->reOrdTmrInt, gCb->genCfg.timeRes);
arg.timers = &amUl->reOrdTmr;
- arg.max = KW_MAX_AM_TMR;
+ arg.max = RLC_MAX_AM_TMR;
break;
}
- case KW_EVT_AMUL_STA_PROH_TMR:
+ case RLC_EVT_AMUL_STA_PROH_TMR:
{
- KwAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
+ RlcAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
- KW_TMR_CALCUATE_WAIT(arg.wait,
+ RLC_TMR_CALCUATE_WAIT(arg.wait,
amUl->staProhTmrInt,
gCb->genCfg.timeRes);
arg.timers = &amUl->staProhTmr;
- arg.max = KW_MAX_AM_TMR;
+ arg.max = RLC_MAX_AM_TMR;
break;
}
- case KW_EVT_AMDL_POLL_RETX_TMR:
+ case RLC_EVT_AMDL_POLL_RETX_TMR:
{
- KwAmDl* amDl = &(((RlcDlRbCb *)cb)->m.amDl);
+ RlcAmDl* amDl = &(((RlcDlRbCb *)cb)->m.amDl);
/* kw005.201 Changed wait calculation ccpu00117634*/
- KW_TMR_CALCUATE_WAIT(arg.wait,
+ RLC_TMR_CALCUATE_WAIT(arg.wait,
amDl->pollRetxTmrInt,
gCb->genCfg.timeRes);
arg.timers = &amDl->pollRetxTmr;
- arg.max = KW_MAX_AM_TMR;
+ arg.max = RLC_MAX_AM_TMR;
break;
}
- case KW_EVT_WAIT_BNDCFM:
+ case RLC_EVT_WAIT_BNDCFM:
{
- KwRguSapCb* rguSap = (KwRguSapCb *)cb;
+ RlcRguSapCb* rguSap = (RlcRguSapCb *)cb;
/* kw005.201 Changed wait calculation ccpu00117634*/
- KW_TMR_CALCUATE_WAIT(arg.wait, rguSap->bndTmrInt, gCb->genCfg.timeRes);
+ RLC_TMR_CALCUATE_WAIT(arg.wait, rguSap->bndTmrInt, gCb->genCfg.timeRes);
arg.timers = &rguSap->bndTmr;
- arg.max = KW_MAX_RGUSAP_TMR;
+ arg.max = RLC_MAX_RGUSAP_TMR;
break;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- case KW_EVT_L2_TMR:
+ case RLC_EVT_L2_TMR:
{
- measEvtCb = (KwL2MeasEvtCb *)cb;
+ measEvtCb = (RlcL2MeasEvtCb *)cb;
/* kw005.201 Changed wait calculation ccpu00117634*/
- KW_TMR_CALCUATE_WAIT(arg.wait,
+ RLC_TMR_CALCUATE_WAIT(arg.wait,
measEvtCb->l2TmrCfg.val,
gCb->genCfg.timeRes);
arg.timers = &measEvtCb->l2Tmr;
- arg.max = KW_L2_MAX_TIMERS;
+ arg.max = RLC_L2_MAX_TIMERS;
break;
}
#endif
if(arg.wait != 0)
{
- arg.tqCp = &gCb->kwTqCp;
- arg.tq = gCb->kwTq;
+ arg.tqCp = &gCb->rlcTqCp;
+ arg.tq = gCb->rlcTq;
arg.cb = cb;
arg.evnt = tmrEvnt;
arg.tNum = 0;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwStopTmr
+Void rlcStopTmr
(
RlcCb *gCb,
PTR cb,
U8 tmrType
)
#else
-PUBLIC Void kwStopTmr (gCb, cb, tmrType)
+Void rlcStopTmr (gCb, cb, tmrType)
RlcCb *gCb;
PTR cb;
U8 tmrType;
CmTmrArg arg;
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- KwL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
#endif
- TRC2(kwStopTmr)
+ TRC2(rlcStopTmr)
arg.timers = NULLP;
switch (tmrType)
{
- case KW_EVT_UMUL_REORD_TMR:
+ case RLC_EVT_UMUL_REORD_TMR:
{
arg.timers = &((RlcUlRbCb *)cb)->m.umUl.reOrdTmr;
- arg.max = KW_MAX_UM_TMR;
+ arg.max = RLC_MAX_UM_TMR;
break;
}
- case KW_EVT_AMUL_REORD_TMR:
+ case RLC_EVT_AMUL_REORD_TMR:
{
arg.timers = &((RlcUlRbCb *)cb)->m.amUl.reOrdTmr;
- arg.max = KW_MAX_AM_TMR;
+ arg.max = RLC_MAX_AM_TMR;
break;
}
- case KW_EVT_AMUL_STA_PROH_TMR:
+ case RLC_EVT_AMUL_STA_PROH_TMR:
{
arg.timers = &((RlcUlRbCb *)cb)->m.amUl.staProhTmr;
- arg.max = KW_MAX_AM_TMR;
+ arg.max = RLC_MAX_AM_TMR;
break;
}
- case KW_EVT_AMDL_POLL_RETX_TMR:
+ case RLC_EVT_AMDL_POLL_RETX_TMR:
{
arg.timers = &((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr;
- arg.max = KW_MAX_AM_TMR;
+ arg.max = RLC_MAX_AM_TMR;
break;
}
- case KW_EVT_WAIT_BNDCFM:
+ case RLC_EVT_WAIT_BNDCFM:
{
- arg.timers = &((KwRguSapCb *)cb)->bndTmr;
- arg.max = KW_MAX_RGUSAP_TMR;
+ arg.timers = &((RlcRguSapCb *)cb)->bndTmr;
+ arg.max = RLC_MAX_RGUSAP_TMR;
break;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- case KW_EVT_L2_TMR:
+ case RLC_EVT_L2_TMR:
{
- measEvtCb = (KwL2MeasEvtCb *)cb;
+ measEvtCb = (RlcL2MeasEvtCb *)cb;
arg.timers = &measEvtCb->l2Tmr;
- arg.max = KW_L2_MAX_TIMERS;
+ arg.max = RLC_L2_MAX_TIMERS;
break;
}
#endif
}
if (tmrType != TMR0)
{
- arg.tqCp = &gCb->kwTqCp;
- arg.tq = gCb->kwTq;
+ arg.tqCp = &gCb->rlcTqCp;
+ arg.tq = gCb->rlcTq;
arg.cb = cb;
arg.evnt = tmrType;
arg.wait = 0;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwTmrExpiry
+Void rlcTmrExpiry
(
PTR cb,
S16 tmrEvnt
)
#else
-PUBLIC Void kwTmrExpiry (cb, tmrEvnt)
+Void rlcTmrExpiry (cb, tmrEvnt)
PTR cb;
S16 tmrEvnt;
#endif
{
/* kw005.201 added support for L2 Measurement */
- TRC2(kwTmrExpiry)
+ TRC2(rlcTmrExpiry)
switch (tmrEvnt)
{
- case KW_EVT_UMUL_REORD_TMR:
+ case RLC_EVT_UMUL_REORD_TMR:
{
RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
- kwUmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
+ rlcUmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
- case KW_EVT_AMUL_REORD_TMR:
+ case RLC_EVT_AMUL_REORD_TMR:
{
RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
- kwAmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
+ rlcAmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
- case KW_EVT_AMUL_STA_PROH_TMR:
+ case RLC_EVT_AMUL_STA_PROH_TMR:
{
RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
- kwAmmStaProTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
+ rlcAmmStaProTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
- case KW_EVT_AMDL_POLL_RETX_TMR:
+ case RLC_EVT_AMDL_POLL_RETX_TMR:
{
RlcDlRbCb *dlRbCb = (RlcDlRbCb *)cb;
RlcCb *gCb = RLC_GET_RLCCB(dlRbCb->inst);
- kwAmmPollRetxTmrExp(gCb, dlRbCb);
+ rlcAmmPollRetxTmrExp(gCb, dlRbCb);
gCb->genSts.protTimeOut++;
break;
}
- case KW_EVT_WAIT_BNDCFM:
+ case RLC_EVT_WAIT_BNDCFM:
{
- kwBndTmrExpiry(cb);
+ rlcBndTmrExpiry(cb);
break;
}
/* kw005.201 L2 Measurement support */
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Bool kwChkTmr
+Bool rlcChkTmr
(
RlcCb *gCb,
PTR cb,
S16 tmrEvnt
)
#else
-PUBLIC Bool kwChkTmr(gCb,cb, tmrEvnt)
+Bool rlcChkTmr(gCb,cb, tmrEvnt)
RlcCb *gCb;
PTR cb;
S16 tmrEvnt;
#endif
{
- TRC2(kwChkTmr)
+ TRC2(rlcChkTmr)
switch (tmrEvnt)
{
- case KW_EVT_UMUL_REORD_TMR:
+ case RLC_EVT_UMUL_REORD_TMR:
{
return (((RlcUlRbCb *)cb)->m.umUl.reOrdTmr.tmrEvnt ==
- KW_EVT_UMUL_REORD_TMR);
+ RLC_EVT_UMUL_REORD_TMR);
}
- case KW_EVT_AMUL_REORD_TMR:
+ case RLC_EVT_AMUL_REORD_TMR:
{
return (((RlcUlRbCb *)cb)->m.amUl.reOrdTmr.tmrEvnt ==
- KW_EVT_AMUL_REORD_TMR);
+ RLC_EVT_AMUL_REORD_TMR);
}
- case KW_EVT_AMUL_STA_PROH_TMR:
+ case RLC_EVT_AMUL_STA_PROH_TMR:
{
return (((RlcUlRbCb *)cb)->m.amUl.staProhTmr.tmrEvnt ==
- KW_EVT_AMUL_STA_PROH_TMR);
+ RLC_EVT_AMUL_STA_PROH_TMR);
}
- case KW_EVT_AMDL_POLL_RETX_TMR:
+ case RLC_EVT_AMDL_POLL_RETX_TMR:
{
return (((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr.tmrEvnt ==
- KW_EVT_AMDL_POLL_RETX_TMR);
+ RLC_EVT_AMDL_POLL_RETX_TMR);
}
- case KW_EVT_WAIT_BNDCFM:
+ case RLC_EVT_WAIT_BNDCFM:
{
- return (((KwRguSapCb *)cb)->bndTmr.tmrEvnt == KW_EVT_WAIT_BNDCFM);
+ return (((RlcRguSapCb *)cb)->bndTmr.tmrEvnt == RLC_EVT_WAIT_BNDCFM);
}
default:
{
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwBndTmrExpiry
+PRIVATE Void rlcBndTmrExpiry
(
PTR cb
)
#else
-PRIVATE Void kwBndTmrExpiry(cb)
+PRIVATE Void rlcBndTmrExpiry(cb)
PTR cb;
#endif
{
- KwRguSapCb *rguSapCb;
+ RlcRguSapCb *rguSapCb;
- TRC2(kwBndTmrExpiry)
+ TRC2(rlcBndTmrExpiry)
- rguSapCb = (KwRguSapCb *) cb;
+ rguSapCb = (RlcRguSapCb *) cb;
- if (rguSapCb->state == KW_SAP_BINDING)
+ if (rguSapCb->state == RLC_SAP_BINDING)
{
- if (rguSapCb->retryCnt < KW_MAX_SAP_BND_RETRY)
+ if (rguSapCb->retryCnt < RLC_MAX_SAP_BND_RETRY)
{
/* start timer to wait for bind confirm */
- kwStartTmr(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
+ rlcStartTmr(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
(PTR)rguSapCb,
- KW_EVT_WAIT_BNDCFM);
+ RLC_EVT_WAIT_BNDCFM);
/* Send bind request */
rguSapCb->retryCnt++;
- KwLiRguBndReq (&rguSapCb->pst, rguSapCb->suId, rguSapCb->spId);
+ RlcLiRguBndReq (&rguSapCb->pst, rguSapCb->suId, rguSapCb->spId);
}
else
{
rguSapCb->retryCnt = 0;
- rguSapCb->state = KW_SAP_CFG;
+ rguSapCb->state = RLC_SAP_CFG;
/* Send alarm to the layer manager */
#ifdef LTE_L2_MEAS
- kwLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
+ rlcLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
LCM_CATEGORY_INTERFACE,
LCM_EVENT_BND_FAIL,
LCM_CAUSE_TMR_EXPIRED,
0,
0);
#else
- kwLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
+ rlcLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
LCM_CATEGORY_INTERFACE,
LCM_EVENT_BND_FAIL,
LCM_CAUSE_TMR_EXPIRED,
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxBndReq
+S16 cmPkUdxBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkUdxBndReq(pst, suId, spId)
+S16 cmPkUdxBndReq(pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxUbndReq
+S16 cmPkUdxUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkUdxUbndReq(pst, spId, reason)
+S16 cmPkUdxUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxBndCfm
+S16 cmPkUdxBndCfm
(
Pst *pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkUdxBndCfm(pst, suId, status)
+S16 cmPkUdxBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
U8 status;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxCfgReq
+S16 cmPkUdxCfgReq
(
Pst *pst,
SpId spId,
RlcCfgInfo *cfgInfo
)
#else
-PUBLIC S16 cmPkUdxCfgReq(pst, spId, cfgInfo)
+S16 cmPkUdxCfgReq(pst, spId, cfgInfo)
Pst *pst;
SpId spId;
RlcCfgInfo *cfgInfo;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxCfgCfm
+S16 cmPkUdxCfgCfm
(
Pst *pst,
SuId suId,
RlcCfgCfmInfo *cfgCfmInfo
)
#else
-PUBLIC S16 cmPkUdxCfgCfm(pst, suId, cfgCfmInfo)
+S16 cmPkUdxCfgCfm(pst, suId, cfgCfmInfo)
Pst *pst;
SuId suId;
RlcCfgCfmInfo *cfgCfmInfo;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxUeIdChgReq
+S16 cmPkUdxUeIdChgReq
(
Pst *pst,
SpId spId,
CkwUeInfo *newUeInfo
)
#else
-PUBLIC S16 cmPkUdxUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
+S16 cmPkUdxUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst *pst;
SpId spId;
U32 transId;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxUeIdChgCfm
+S16 cmPkUdxUeIdChgCfm
(
Pst *pst,
SuId suId,
CmStatus status
)
#else
-PUBLIC S16 cmPkUdxUeIdChgCfm(pst, suId, transId, status)
+S16 cmPkUdxUeIdChgCfm(pst, suId, transId, status)
Pst *pst;
SuId suId;
U32 transId;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxStaUpdCfm
+S16 cmPkUdxStaUpdCfm
(
Pst *pst,
SuId suId,
CmLteRlcId *rlcId,
-KwUdxBufLst *pStaPdu
+RlcUdxBufLst *pStaPdu
)
#else
-PUBLIC S16 cmPkUdxStaUpdCfm(pst, suId, rlcId,pStaPdu)
+S16 cmPkUdxStaUpdCfm(pst, suId, rlcId,pStaPdu)
Pst *pst;
SuId suId;
CmLteRlcId *rlcId;
-KwUdxBufLst *pStaPdu;
+RlcUdxBufLst *pStaPdu;
#endif
{
S16 ret1;
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)pStaPdu, sizeof(KwUdxBufLst),mBuf);
+ cmPkUdxStruct((U8 *)pStaPdu, sizeof(RlcUdxBufLst),mBuf);
cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
break;
}
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxStaProhTmrStart
+S16 cmPkUdxStaProhTmrStart
(
Pst *pst,
SpId spId,
CmLteRlcId *rlcId
)
#else
-PUBLIC S16 cmPkUdxStaProhTmrStart(pst, suId, rlcId)
+S16 cmPkUdxStaProhTmrStart(pst, suId, rlcId)
Pst *pst;
SpId spId;
CmLteRlcId *rlcId;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxStaUpdReq
+S16 cmPkUdxStaUpdReq
(
Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxStaPdu *pStaPdu
+RlcUdxStaPdu *pStaPdu
)
#else
-PUBLIC S16 cmPkUdxStaUpdReq(pst, suId, rlcId,pStaPdu)
+S16 cmPkUdxStaUpdReq(pst, suId, rlcId,pStaPdu)
Pst *pst;
SpId spId;
CmLteRlcId *rlcId;
-KwUdxStaPdu *pStaPdu;
+RlcUdxStaPdu *pStaPdu;
#endif
{
S16 ret1;
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)pStaPdu, sizeof(KwUdxStaPdu),mBuf);
+ cmPkUdxStruct((U8 *)pStaPdu, sizeof(RlcUdxStaPdu),mBuf);
cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
- sizeof(KwUdxStaPdu),0);
+ sizeof(RlcUdxStaPdu),0);
break;
}
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxStaPduReq
+S16 cmPkUdxStaPduReq
(
Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxDlStaPdu *pStaPdu
+RlcUdxDlStaPdu *pStaPdu
)
#else
-PUBLIC S16 cmPkUdxStaPduReq(pst, suId, rlcId,pStaPdu)
+S16 cmPkUdxStaPduReq(pst, suId, rlcId,pStaPdu)
Pst *pst;
SpId spId;
CmLteRlcId *rlcId;
-KwUdxDlStaPdu *pStaPdu;
+RlcUdxDlStaPdu *pStaPdu;
#endif
{
S16 ret1;
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)pStaPdu, sizeof(KwUdxDlStaPdu),mBuf);
+ cmPkUdxStruct((U8 *)pStaPdu, sizeof(RlcUdxDlStaPdu),mBuf);
cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
/* Free status Pdu here for LC */
SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
- sizeof(KwUdxDlStaPdu),0);
+ sizeof(RlcUdxDlStaPdu),0);
break;
}
case UDX_SEL_LWLC:
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxL2MeasReq
+S16 cmPkUdxL2MeasReq
(
Pst *pst,
-KwL2MeasReqEvt *measReqEvt
+RlcL2MeasReqEvt *measReqEvt
)
#else
-PUBLIC S16 cmPkUdxL2MeasReq(pst, measReqEvt)
+S16 cmPkUdxL2MeasReq(pst, measReqEvt)
Pst *pst;
-KwL2MeasReqEvt *measReqEvt;
+RlcL2MeasReqEvt *measReqEvt;
#endif
{
S16 ret1;
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)measReqEvt, sizeof(KwL2MeasReqEvt),mBuf);
+ cmPkUdxStruct((U8 *)measReqEvt, sizeof(RlcL2MeasReqEvt),mBuf);
break;
}
case UDX_SEL_LWLC:
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxL2MeasSendReq
+S16 cmPkUdxL2MeasSendReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 cmPkUdxL2MeasSendReq(pst, measReqEvt)
+S16 cmPkUdxL2MeasSendReq(pst, measReqEvt)
Pst *pst;
U8 measType
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkUdxL2MeasStopReq
+S16 cmPkUdxL2MeasStopReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 cmPkUdxL2MeasStopReq(pst, measType)
+S16 cmPkUdxL2MeasStopReq(pst, measType)
Pst *pst;
U8 measType
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxBndReq
+S16 cmUnpkUdxBndReq
(
UdxBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxBndReq(func, pst, mBuf)
+S16 cmUnpkUdxBndReq(func, pst, mBuf)
UdxBndReq func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxUbndReq
+S16 cmUnpkUdxUbndReq
(
UdxUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxUbndReq(func, pst, mBuf)
+S16 cmUnpkUdxUbndReq(func, pst, mBuf)
UdxUbndReq func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxBndCfm
+S16 cmUnpkUdxBndCfm
(
UdxBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxBndCfm(func, pst, mBuf)
+S16 cmUnpkUdxBndCfm(func, pst, mBuf)
UdxBndCfm func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxCfgReq
+S16 cmUnpkUdxCfgReq
(
UdxCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxCfgReq(func, pst, mBuf)
+S16 cmUnpkUdxCfgReq(func, pst, mBuf)
UdxCfgReq func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxCfgCfm
+S16 cmUnpkUdxCfgCfm
(
UdxCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxCfgCfm(func, pst, mBuf)
+S16 cmUnpkUdxCfgCfm(func, pst, mBuf)
UdxCfgCfm func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxUeIdChgReq
+S16 cmUnpkUdxUeIdChgReq
(
UdxUeIdChgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxUeIdChgReq(func, pst, mBuf)
+S16 cmUnpkUdxUeIdChgReq(func, pst, mBuf)
UdxUeIdChgReq func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxUeIdChgCfm
+S16 cmUnpkUdxUeIdChgCfm
(
UdxUeIdChgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxUeIdChgCfm(func, pst, mBuf)
+S16 cmUnpkUdxUeIdChgCfm(func, pst, mBuf)
UdxUeIdChgCfm func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxStaUpdCfm
+S16 cmUnpkUdxStaUpdCfm
(
UdxStaUpdCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxStaUpdCfm(func, pst, mBuf)
+S16 cmUnpkUdxStaUpdCfm(func, pst, mBuf)
UdxStaUpdCfm func;
Pst *pst;
Buffer *mBuf;
{
SuId suId = 0;
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
- KwUdxBufLst *pBufLst = NULLP; /* KW_FIX*/
+ RlcUdxBufLst *pBufLst = NULLP; /* KW_FIX*/
TRC3(cmUnpkUdxStaUpdCfm)
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxStaUpdReq
+S16 cmUnpkUdxStaUpdReq
(
UdxStaUpdReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxStaUpdReq(func, pst, mBuf)
+S16 cmUnpkUdxStaUpdReq(func, pst, mBuf)
UdxStaUpdReq func;
Pst *pst;
Buffer *mBuf;
{
SpId spId = 0;
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
- KwUdxStaPdu *pStaPdu = NULLP; /* KW_FIX */
+ RlcUdxStaPdu *pStaPdu = NULLP; /* KW_FIX */
S16 ret1;
CmLteRlcId tmpRlcId;
case UDX_SEL_LC:
{
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
- sizeof(KwUdxStaPdu),0)) != ROK)
+ sizeof(RlcUdxStaPdu),0)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)pStaPdu, sizeof(KwUdxStaPdu));
- ret1 = cmUnpkUdxStruct(mBuf,sizeof(KwUdxStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
+ ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)pStaPdu, sizeof(RlcUdxStaPdu));
+ ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
rlcId = &tmpRlcId;
break;
}
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxStaPduReq
+S16 cmUnpkUdxStaPduReq
(
UdxStaPduReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxStaPduReq(func, pst, mBuf)
+S16 cmUnpkUdxStaPduReq(func, pst, mBuf)
UdxStaPduReq func;
Pst *pst;
Buffer *mBuf;
SpId spId = 0;
CmLteRlcId tmpRlcId;
CmLteRlcId *rlcId = NULLP; /* KW_FIX */
- KwUdxDlStaPdu *pStaPdu = NULLP; /* KW_FIX */
+ RlcUdxDlStaPdu *pStaPdu = NULLP; /* KW_FIX */
TRC3(cmUnpkUdxStaUpdCfm)
case UDX_SEL_LC:
{
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
- sizeof(KwUdxDlStaPdu),0)) != ROK)
+ sizeof(RlcUdxDlStaPdu),0)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- ret1 = cmUnpkUdxStruct(mBuf,0, (U8 *)pStaPdu, sizeof(KwUdxDlStaPdu));
- ret1 = cmUnpkUdxStruct(mBuf,sizeof(KwUdxDlStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
+ ret1 = cmUnpkUdxStruct(mBuf,0, (U8 *)pStaPdu, sizeof(RlcUdxDlStaPdu));
+ ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxDlStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
rlcId = &tmpRlcId;
break;
}
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxStaProhTmrStart
+S16 cmUnpkUdxStaProhTmrStart
(
UdxStaProhTmrStart func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxStaProhTmrStart(func, pst, mBuf)
+S16 cmUnpkUdxStaProhTmrStart(func, pst, mBuf)
UdxStaProhTmrStart func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxL2MeasReq
+S16 cmUnpkUdxL2MeasReq
(
UdxL2MeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxL2MeasReq(func, pst, mBuf)
+S16 cmUnpkUdxL2MeasReq(func, pst, mBuf)
UdxL2MeasReq func;
Pst *pst;
Buffer *mBuf;
#endif
{
- KwL2MeasReqEvt tmpMeasReqEvt;
- KwL2MeasReqEvt *measReqEvt = NULLP; /* KW_FIX */
+ RlcL2MeasReqEvt tmpMeasReqEvt;
+ RlcL2MeasReqEvt *measReqEvt = NULLP; /* KW_FIX */
TRC3(cmUnpkUdxL2MeasReq)
{
case UDX_SEL_LC:
{
- cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpMeasReqEvt,sizeof(KwL2MeasReqEvt));
+ cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpMeasReqEvt,sizeof(RlcL2MeasReqEvt));
measReqEvt = &tmpMeasReqEvt;
break;
}
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxL2MeasSendReq
+S16 cmUnpkUdxL2MeasSendReq
(
UdxL2MeasSendReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxL2MeasSendReq(func, pst, mBuf)
+S16 cmUnpkUdxL2MeasSendReq(func, pst, mBuf)
UdxL2MeasSendReq func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkUdxL2MeasStopReq
+S16 cmUnpkUdxL2MeasStopReq
(
UdxL2MeasStopReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkUdxL2MeasStopReq(func, pst, mBuf)
+S16 cmUnpkUdxL2MeasStopReq(func, pst, mBuf)
UdxL2MeasSendReq func;
Pst *pst;
Buffer *mBuf;
/* Loose Coupling define */
#define UDX_SEL_LC 0 /*!< Loose Coupling Option */
#define UDX_SEL_LWLC 1
-#define KW_MAX_UDX 3
+#define RLC_MAX_UDX 3
/* CKW Interface defines */
extern "C" {
#endif /* __cplusplus */
-typedef struct kwNackInfo
+typedef struct rlcNackInfo
{
U8 nackRange;
U8 isSegment;
U32 sn; /*!< Nack Sn */
U16 soStart; /*!< Segment offset start */
U16 soEnd; /*!< Segment offset End */
-}KwNackInfo;
+}RlcNackInfo;
-typedef struct kwUdxStaPdu
+typedef struct rlcUdxStaPdu
{
U32 ackSn;
- /* TODO : KW_MAX_NACK_CNT should set to MAx SR delay
+ /* TODO : RLC_MAX_NACK_CNT should set to MAx SR delay
It is tradeoff to consider array based instead of dynamic
as there are chances where we might loose Status information
on spill over*/
U8 nackCnt; /* Cnt of Nacks in the array*/
- KwNackInfo nackInfo[KW_MAX_NACK_CNT];
-}KwUdxStaPdu;
+ RlcNackInfo nackInfo[RLC_MAX_NACK_CNT];
+}RlcUdxStaPdu;
-typedef struct kwUdxBufLst
+typedef struct rlcUdxBufLst
{
CmLListCp rlsTxLst; /*!< Stores to be released Tx PDUs */
CmLListCp rlsRetxLst; /*!< Stores to be released Retx PDUs */
CmLListCp rlsSduLst; /*!< Stores to be released SDUs*/
-}KwUdxBufLst;
+}RlcUdxBufLst;
-typedef struct kwStatusPdu
+typedef struct rlcStatusPdu
{
U32 ackSn;
- KwNackInfo nackInfo[KW_MAX_NACK_CNT];
+ RlcNackInfo nackInfo[RLC_MAX_NACK_CNT];
U16 nackCount;
U16 controlBo;
-}KwUdxDlStaPdu;
+}RlcUdxDlStaPdu;
/* ### Umapathi*/
/**
typedef S16 (*UdxStaUpdReq) ARGS((Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
- KwUdxStaPdu *pStaPdu ));
+ RlcUdxStaPdu *pStaPdu ));
typedef S16 (*UdxUeIdChgReq) ARGS((Pst *pst,
SpId spId,
typedef S16 (*UdxStaUpdCfm) ARGS((Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
- KwUdxBufLst *pBufLst));
+ RlcUdxBufLst *pBufLst));
typedef S16 (*UdxStaPduReq) ARGS((Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
- KwUdxDlStaPdu *pStaPdu));
+ RlcUdxDlStaPdu *pStaPdu));
typedef S16 (*UdxStaProhTmrStart) ARGS((Pst* pst,
SuId suId,
#ifdef LTE_L2_MEAS
typedef S16 (*UdxL2MeasReq) ARGS((Pst* pst,
- KwL2MeasReqEvt *measReqEvt));
+ RlcL2MeasReqEvt *measReqEvt));
typedef S16 (*UdxL2MeasSendReq) ARGS((Pst* pst,
U8 measType));
EXTERN S16 cmPkUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
EXTERN S16 cmPkUdxCfgCfm ARGS(( Pst* pst,SuId suId,RlcCfgCfmInfo *cfmInfo));
EXTERN S16 cmPkUdxStaUpdReq ARGS((Pst* pst,SpId spId,CmLteRlcId *rlcId,
- KwUdxStaPdu *pStaPdu ));
+ RlcUdxStaPdu *pStaPdu ));
EXTERN S16 cmPkUdxUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
EXTERN S16 cmPkUdxUeIdChgCfm ARGS((Pst *pst, SuId suId, U32 transId,
EXTERN S16 cmPkUdxStaUpdCfm ARGS((Pst* pst,SuId suId,CmLteRlcId *rlcId,
- KwUdxBufLst *pBufLst));
+ RlcUdxBufLst *pBufLst));
EXTERN S16 cmPkUdxStaPduReq ARGS(( Pst* pst,SpId spId, CmLteRlcId *rlcId,
- KwUdxDlStaPdu *pStaPdu ));
+ RlcUdxDlStaPdu *pStaPdu ));
EXTERN S16 cmPkUdxStaProhTmrStart ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId));
#ifdef LTE_L2_MEAS
-EXTERN S16 cmPkUdxL2MeasReq ARGS((Pst *pst, KwL2MeasReqEvt *measReqEvt));
+EXTERN S16 cmPkUdxL2MeasReq ARGS((Pst *pst, RlcL2MeasReqEvt *measReqEvt));
EXTERN S16 cmPkUdxL2MeasSendReq ARGS((Pst *pst, U8 measType));
EXTERN S16 cmPkUdxL2MeasStopReq ARGS((Pst *pst, U8 measType));
#endif
EXTERN S16 rlcUlUdxStaUpdReq ARGS((Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
- KwUdxStaPdu *pStaPdu));
+ RlcUdxStaPdu *pStaPdu));
EXTERN S16 rlcDlUdxStaUpdReq ARGS((Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
- KwUdxStaPdu *pStaPdu));
+ RlcUdxStaPdu *pStaPdu));
EXTERN S16 rlcDlUdxStaUpdCfm ARGS((Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
- KwUdxBufLst *pBufLst));
+ RlcUdxBufLst *pBufLst));
EXTERN S16 rlcUlUdxStaUpdCfm ARGS((Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
- KwUdxBufLst *pBufLst));
+ RlcUdxBufLst *pBufLst));
EXTERN S16 rlcUlUdxStaPduReq ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
- KwUdxDlStaPdu *pStaPdu ));
+ RlcUdxDlStaPdu *pStaPdu ));
EXTERN S16 rlcDlUdxStaPduReq ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
- KwUdxDlStaPdu *pStaPdu));
+ RlcUdxDlStaPdu *pStaPdu));
EXTERN S16 rlcDlUdxUeIdChgReq ARGS((Pst *pst,
SpId spId,
EXTERN S16 rlcUlUdxStaUpdCfm ARGS((Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
- KwUdxBufLst *pBufLst));
+ RlcUdxBufLst *pBufLst));
EXTERN S16 rlcDlUdxStaPduReq ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
- KwUdxDlStaPdu *pStaPdu));
+ RlcUdxDlStaPdu *pStaPdu));
EXTERN S16 rlcUlUdxStaProhTmrStart ARGS((Pst *pst,
SpId spId,
CmLteRlcId *rlcId ));
#ifdef LTE_L2_MEAS
-EXTERN S16 rlcDlUdxL2MeasReq ARGS((Pst *pst, KwL2MeasReqEvt *measReqEvt));
+EXTERN S16 rlcDlUdxL2MeasReq ARGS((Pst *pst, RlcL2MeasReqEvt *measReqEvt));
EXTERN S16 rlcDlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
EXTERN S16 rlcDlUdxL2MeasStopReq ARGS((Pst *pst, U8 status));
-EXTERN S16 rlcUlUdxL2MeasReq ARGS((Pst* pst, KwL2MeasReqEvt *measReqEvt));
+EXTERN S16 rlcUlUdxL2MeasReq ARGS((Pst* pst, RlcL2MeasReqEvt *measReqEvt));
EXTERN S16 rlcUlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
#include "kw_dl.x"
-#define KW_MODULE KW_DBGMASK_UDX
+#define RLC_MODULE RLC_DBGMASK_UDX
/* local defines */
EXTERN S16 rlcDlmHndlStaRsp ARGS (( RlcCb *gCb,RlcDlRbCb *rbCb,
- KwUdxStaPdu *pStaPdu, KwUdxBufLst *rlsPduLst));
+ RlcUdxStaPdu *pStaPdu, RlcUdxBufLst *rlsPduLst));
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxBndReq
+S16 rlcDlUdxBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 rlcDlUdxBndReq (pst, suId, spId)
+S16 rlcDlUdxBndReq (pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
#endif
{
- KwUdxDlSapCb *udxSap; /* pointer to session SAP */
+ RlcUdxDlSapCb *udxSap; /* pointer to session SAP */
RlcCb *tRlcCb;
TRC3(rlcDlUdxBndReq);
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KWDBGP_BRIEF(tRlcCb, "rlcDlUdxBndReq(spId(%d), suId(%d))\n",
+ RLCDBGP_BRIEF(tRlcCb, "rlcDlUdxBndReq(spId(%d), suId(%d))\n",
spId, suId);
udxSap = (tRlcCb->u.dlCb->udxDlSap + spId);
switch(udxSap->state)
{
/* SAP is configured but not bound */
- case KW_SAP_CFG:
- case KW_SAP_UBND:
+ case RLC_SAP_CFG:
+ case RLC_SAP_UBND:
{
/* copy bind configuration parameters in SSAP sap */
udxSap->suId = suId;
udxSap->pst.dstInst = pst->srcInst;
/* Update the State */
- udxSap->state = KW_SAP_BND;
+ udxSap->state = RLC_SAP_BND;
RLOG1(L_INFO, "UDX SAP state [%d]", udxSap->state);
break;
}
/* SAP is already bound */
- case KW_SAP_BND:
+ case RLC_SAP_BND:
{
/*
* Sap is already bound check source, destination Entity and
|| udxSap->pst.dstInst != pst->srcInst
|| udxSap->suId != suId)
{
- KW_SEND_SAPID_ALARM(tRlcCb, spId,
+ RLC_SEND_SAPID_ALARM(tRlcCb, spId,
LKW_EVENT_UDX_BND_REQ, LCM_CAUSE_INV_PAR_VAL);
RLOG0(L_ERROR, "UDX SAP already Bound");
default:
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- KW_SEND_SAPID_ALARM(tRlcCb,spId,
+ RLC_SEND_SAPID_ALARM(tRlcCb,spId,
LKW_EVENT_CKW_BND_REQ, LCM_CAUSE_INV_STATE);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLOG0(L_ERROR, "Invalid UDX SAP State in Bind Req");
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxUbndReq
+S16 rlcDlUdxUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 rlcDlUdxUbndReq(pst, spId, reason)
+S16 rlcDlUdxUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
#endif
{
- KwUdxDlSapCb *udxSap;
+ RlcUdxDlSapCb *udxSap;
RlcCb *tRlcCb;
TRC3(rlcDlUdxUbndReq)
udxSap = (tRlcCb->u.dlCb->udxDlSap + spId);
#if (ERRCLASS & ERRCLS_INT_PAR)
- KW_GET_AND_VALIDATE_UDXSAP(tRlcCb,udxSap, EKW208, "KwUiDlUdxndReq");
+ RLC_GET_AND_VALIDATE_UDXSAP(tRlcCb,udxSap, EKW208, "KwUiDlUdxndReq");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- udxSap->state = KW_SAP_CFG;
+ udxSap->state = RLC_SAP_CFG;
return ROK;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxCfgReq
+S16 rlcDlUdxCfgReq
(
Pst *pst,
SpId spId,
RlcCfgInfo *cfg
)
#else
-PUBLIC S16 rlcDlUdxCfgReq(pst, spId, cfg)
+S16 rlcDlUdxCfgReq(pst, spId, cfg)
Pst *pst;
SpId spId;
RlcCfgInfo *cfg;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
pstUdxCfm = &(tRlcCb->u.dlCb->udxDlSap[spId].pst);
- KWDBGP_BRIEF(tRlcCb,"spId(%d)\n", spId);
+ RLCDBGP_BRIEF(tRlcCb,"spId(%d)\n", spId);
/* Allocate memory and memset to 0 for cfmInfo */
RLC_ALLOC_SHRABL_BUF_WC(pstUdxCfm->region,
pstUdxCfm->pool,
{
case CKW_CFG_ADD:
{
- if (entCfg->dir & KW_DIR_DL)
+ if (entCfg->dir & RLC_DIR_DL)
{
/* Add a new RB entity configuration */
if (rlcCfgAddDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
}
case CKW_CFG_MODIFY:
{
- if (entCfg->dir & KW_DIR_DL)
+ if (entCfg->dir & RLC_DIR_DL)
{
/* Re-configure the existing RB entity configuration */
if (rlcCfgReCfgDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
case CKW_CFG_DELETE:
{
- if (entCfg->dir & KW_DIR_DL)
+ if (entCfg->dir & RLC_DIR_DL)
{
/* Delete the existing RB entity configuration */
if (rlcCfgDelDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
case CKW_CFG_REESTABLISH:
{
- if (entCfg->dir & KW_DIR_DL)
+ if (entCfg->dir & RLC_DIR_DL)
{
/*if direction is both then, re-establishment end indication
* should be sent only from the UL instance, only if DIR is
* DL only then DL instance will send indication.*/
Bool sndReEst = TRUE;
- if (entCfg->dir & KW_DIR_UL)
+ if (entCfg->dir & RLC_DIR_UL)
{
sndReEst = FALSE;
}
default:
{
- KW_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,\
+ RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,\
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
RLOG0(L_ERROR, "Invalid CfgType");
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxUeIdChgReq
+S16 rlcDlUdxUeIdChgReq
(
Pst *pst,
SpId spId,
CkwUeInfo *newUeInfo
)
#else
-PUBLIC S16 rlcDlUdxUeIdChgReq(pst,spId,transId,ueInfo,newUeInfo)
+S16 rlcDlUdxUeIdChgReq(pst,spId,transId,ueInfo,newUeInfo)
Pst *pst;
SpId spId;
U32 transId;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#ifndef ALIGN_64BIT
- KWDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%ld))\n",
+ RLCDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%ld))\n",
spId, transId);
#else
- KWDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%d))\n",
+ RLCDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%d))\n",
spId, transId);
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxStaPduReq
+S16 rlcDlUdxStaPduReq
(
Pst *pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxDlStaPdu *pStaPdu
+RlcUdxDlStaPdu *pStaPdu
)
#else
-PUBLIC S16 rlcDlUdxStaPduReq(pst, spId, rlcId, pStaPdu)
+S16 rlcDlUdxStaPduReq(pst, spId, rlcId, pStaPdu)
Pst *pst;
SpId spId;
CmLteRlcId *rlcId;
-KwUdxDlStaPdu *pStaPdu;
+RlcUdxDlStaPdu *pStaPdu;
#endif
{
RlcDlRbCb *rbCb;
tRlcCb = RLC_GET_RLCCB (pst->dstInst);
- kwDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb); /* Fetch DBM RbCb */
+ rlcDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb); /* Fetch DBM RbCb */
if (!rbCb)
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
pStaPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
return RFAILED;
}
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
AMDL.pStaPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
}
AMDL.pStaPdu = pStaPdu;
- kwAmmSendDStaRsp(tRlcCb, rbCb, &AMDL);
+ rlcAmmSendDStaRsp(tRlcCb, rbCb, &AMDL);
return (ROK);
}
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxStaUpdReq
+S16 rlcDlUdxStaUpdReq
(
Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxStaPdu *pStaPdu
+RlcUdxStaPdu *pStaPdu
)
#else
-PUBLIC S16 rlcDlUdxStaUpdReq(pst, spId, rlcId,pStaPdu)
+S16 rlcDlUdxStaUpdReq(pst, spId, rlcId,pStaPdu)
Pst* pst;
SpId spId;
CmLteRlcId *rlcId;
-KwUdxStaPdu *pStaPdu;
+RlcUdxStaPdu *pStaPdu;
#endif
{
RlcCb *tRlcCb;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- kwDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb);
+ rlcDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb);
if (!rbCb)
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
return RFAILED;
}
- kwAmmDlHndlStatusPdu(tRlcCb, rbCb, pStaPdu);
+ rlcAmmDlHndlStatusPdu(tRlcCb, rbCb, pStaPdu);
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
pStaPdu,
- sizeof(KwUdxStaPdu));
+ sizeof(RlcUdxStaPdu));
return ROK;
}
/**
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxL2MeasReq
+S16 rlcDlUdxL2MeasReq
(
Pst *pst,
-KwL2MeasReqEvt *measReqEvt
+RlcL2MeasReqEvt *measReqEvt
)
#else
-PUBLIC S16 rlcDlUdxL2MeasReq (pst, measReqEvt)
+S16 rlcDlUdxL2MeasReq (pst, measReqEvt)
Pst *pst;
-KwL2MeasReqEvt *measReqEvt;
+RlcL2MeasReqEvt *measReqEvt;
#endif
{
U32 cntr;
/* if measurement is for DL IP enable for all QCI */
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tRlcCb->u.dlCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_DL_IP;
+ tRlcCb->u.dlCb->rlcL2Cb.measOn[cntr] |= LKW_L2MEAS_DL_IP;
}
}
else
U32 i;
for(i = 0; i < LKW_MAX_QCI; i++)
{
- tRlcCb->u.dlCb->kwL2Cb.measOn[i] |= measType;
+ tRlcCb->u.dlCb->rlcL2Cb.measOn[i] |= measType;
}
}
/* We need to copy the transId for sending back confirms later */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- KwL2MeasEvtCb* measEvtCb = &(tRlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
+ RlcL2MeasEvtCb* measEvtCb = &(tRlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
measEvtCb->transId= measReqEvt->transId;
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxL2MeasStopReq
+S16 rlcDlUdxL2MeasStopReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 rlcDlUdxL2MeasStopReq (pst, measType)
+S16 rlcDlUdxL2MeasStopReq (pst, measType)
Pst *pst;
U8 measType;
#endif
{
/* S16 ret = ROK;*/
- KwL2MeasEvtCb *measEvtCb = NULLP;
+ RlcL2MeasEvtCb *measEvtCb = NULLP;
U16 cntr;
U8 status = ROK;
-/* KwL2MeasCfmEvt measCfmEvt; */
+/* RlcL2MeasCfmEvt measCfmEvt; */
VOLATILE U32 startTime = 0;
RlcCb *tRlcCb=NULLP;
TRC3(rlcDlUdxMeasStopReq);
SStartTask(&startTime, PID_RLC_MEAS_STOP);
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
-/* cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
+/* cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
/* reset the counters for the measurement type passed */
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tRlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
- kwUtlResetDlL2MeasInKwRb(tRlcCb, &measEvtCb->measCb, measType);
+ rlcUtlResetDlL2MeasInRlcRb(tRlcCb, &measEvtCb->measCb, measType);
}
}
/* switch off the measurements for the type passed */
for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
{
- tRlcCb->u.dlCb->kwL2Cb.measOn[cntr] &= ~measType;
+ tRlcCb->u.dlCb->rlcL2Cb.measOn[cntr] &= ~measType;
}
status = LCM_PRIM_OK;
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxL2MeasSendReq
+S16 rlcDlUdxL2MeasSendReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 rlcDlUdxL2MeasSendReq (pst, measType)
+S16 rlcDlUdxL2MeasSendReq (pst, measType)
Pst *pst;
U8 measType;
#endif
{
- KwL2MeasEvtCb *measEvtCb;
+ RlcL2MeasEvtCb *measEvtCb;
U16 cntr;
VOLATILE U32 startTime = 0;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measEvtCb = &(tRlcCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]);
+ measEvtCb = &(tRlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]);
if(measEvtCb->measCb.measType & measType)
{
/*starting Task*/
SStartTask(&startTime, PID_RLC_MEAS_REPORT);
- kwUtlSndDlL2MeasCfm(tRlcCb, measEvtCb);
+ rlcUtlSndDlL2MeasCfm(tRlcCb, measEvtCb);
/*stopping Task*/
SStopTask(startTime, PID_RLC_MEAS_REPORT);
PRIVATE S16 PtDlUdxUeIdChgCfm ARGS(( Pst *pst, SuId suId,U32 transId,
CmStatus status));
PRIVATE S16 PtDlUdxStaUpdCfm ARGS(( Pst* pst,SuId suId,CmLteRlcId *rlcId,
- KwUdxBufLst *pBufLst));
+ RlcUdxBufLst *pBufLst));
/* UDX Bind Confirm primitive */
/**
Pst* pst,
SuId suId,
CmLteRlcId *rlcId,
-KwUdxBufLst *pBufLst
+RlcUdxBufLst *pBufLst
)
{
TRC3(PtDlUdxStaUpdCfm);
#endif /* KW */
};
-PUBLIC UdxCfgCfm rlcDlUdxCfgCfmMt[UDX_MAX_SEL] =
+UdxCfgCfm rlcDlUdxCfgCfmMt[UDX_MAX_SEL] =
{
#ifdef LCKWULUDX
cmPkUdxCfgCfm, /* 0 - loosely coupled */
#endif /* KW */
};
-PUBLIC UdxUeIdChgCfm rlcDlUdxUeIdChgCfmMt[UDX_MAX_SEL] =
+UdxUeIdChgCfm rlcDlUdxUeIdChgCfmMt[UDX_MAX_SEL] =
{
#ifdef LCKWULUDX
cmPkUdxUeIdChgCfm, /* 0 - loosely coupled */
*
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxBndCfm
+S16 rlcDlUdxBndCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
U8 status /* Status */
)
#else
-PUBLIC S16 rlcDlUdxBndCfm(pst, suId, status)
+S16 rlcDlUdxBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
U8 status; /* Status */
*
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxCfgCfm
+S16 rlcDlUdxCfgCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
RlcCfgCfmInfo *cfmInfo /* Status */
)
#else
-PUBLIC S16 rlcDlUdxCfgCfm(pst, suId, status)
+S16 rlcDlUdxCfgCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
RlcCfgCfmInfo *cfmInfo; /* Status */
*
*/
#ifdef ANSI
-PUBLIC S16 rlcDlUdxUeIdChgCfm
+S16 rlcDlUdxUeIdChgCfm
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
CmStatus status
)
#else
-PUBLIC S16 rlcDlUdxUeIdChgCfm(pst, suId, status)
+S16 rlcDlUdxUeIdChgCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
U32 transId;
#ifdef ANSI
-PUBLIC S16 rlcDlUdxStaProhTmrStart
+S16 rlcDlUdxStaProhTmrStart
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
CmLteRlcId *rlcId
)
#else
-PUBLIC S16 rlcDlUdxStaProhTmrStart(pst, suId, rlcId)
+S16 rlcDlUdxStaProhTmrStart(pst, suId, rlcId)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
CmLteRlcId *rlcId;
PRIVATE S16 PtUlUdxUbndReq ARGS((Pst* pst, SuId suId,Reason reason));
PRIVATE S16 PtUlUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
PRIVATE S16 PtUlUdxStaUpdReq ARGS((Pst* pst,SpId spId,CmLteRlcId *rlcId,
- KwUdxStaPdu *pStaPdu ));
+ RlcUdxStaPdu *pStaPdu ));
PRIVATE S16 PtUlUdxUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
PRIVATE S16 PtUlUdxStaPduReq ARGS(( Pst* pst,SpId spId, CmLteRlcId *rlcId,
- KwUdxDlStaPdu *pStaPdu ));
+ RlcUdxDlStaPdu *pStaPdu ));
#ifdef ANSI
PRIVATE S16 PtUlUdxBndReq
(
Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxDlStaPdu *pStaPdu
+RlcUdxDlStaPdu *pStaPdu
)
{
TRC3(PtUlUdxStaPduReq);
Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxStaPdu *pStaPdu
+RlcUdxStaPdu *pStaPdu
)
#else
PRIVATE S16 PtUlUdxStaUpdReq(pst, rlcId, pStaPdu)
Pst* pst;
SpId spId;
CmLteRlcId *rlcId;
-KwUdxDlStaPdu *pStaPdu;
+RlcUdxDlStaPdu *pStaPdu;
#endif
{
PRIVATE S16 PtUlUdxL2MeasReq
(
Pst* pst,
-KwL2MeasReqEvt *measReqEvt
+RlcL2MeasReqEvt *measReqEvt
)
#else
PRIVATE S16 PtUlUdxL2MeasReq(pst, measReqEvt )
Pst* pst;
-KwL2MeasReqEvt *measReqEvt;
+RlcL2MeasReqEvt *measReqEvt;
#endif
{
};
-PRIVATE CONSTANT UdxStaUpdReq rlcUlUdxStaUpdReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxStaUpdReq rlcUlUdxStaUpdReqMt[RLC_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxStaUpdReq, /* 0 - loosely coupled */
#endif /* KW */
};
-PRIVATE CONSTANT UdxStaPduReq rlcUlUdxStaPduReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxStaPduReq rlcUlUdxStaPduReqMt[RLC_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxStaPduReq, /* 0 - loosely coupled */
#endif /* KW */
};
#ifdef LTE_L2_MEAS
-PRIVATE CONSTANT UdxL2MeasReq rlcUlUdxL2MeasReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxL2MeasReq rlcUlUdxL2MeasReqMt[RLC_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxL2MeasReq, /* 0 - loosely coupled */
#endif /* KW */
};
-PRIVATE CONSTANT UdxL2MeasSendReq rlcUlUdxL2MeasSendReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxL2MeasSendReq rlcUlUdxL2MeasSendReqMt[RLC_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxL2MeasSendReq, /* 0 - loosely coupled */
#endif /* KW */
};
-PRIVATE CONSTANT UdxL2MeasStopReq rlcUlUdxL2MeasStopReqMt[KW_MAX_UDX] =
+PRIVATE CONSTANT UdxL2MeasStopReq rlcUlUdxL2MeasStopReqMt[RLC_MAX_UDX] =
{
#ifdef LCKWULUDX
cmPkUdxL2MeasStopReq, /* 0 - loosely coupled */
*
*/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxBndReq
+S16 rlcUlUdxBndReq
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
SpId spId /* Status */
)
#else
-PUBLIC S16 rlcUlUdxBndReq(pst, suId, status)
+S16 rlcUlUdxBndReq(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
SpId spId; /* Status */
*
*/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxUbndReq
+S16 rlcUlUdxUbndReq
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
Reason reason /* Status */
)
#else
-PUBLIC S16 rlcUlUdxUbndReq(pst, suId, status)
+S16 rlcUlUdxUbndReq(pst, suId, status)
Pst *pst; /* post structure */
SpId spId; /* Service User Id */
Reason Reason; /* Status */
} /* end of rlcDlUdxBndReq */
#ifdef ANSI
-PUBLIC S16 rlcUlUdxCfgReq
+S16 rlcUlUdxCfgReq
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
RlcCfgInfo *cfmInfo /* Config Info */
)
#else
-PUBLIC S16 rlcUlUdxCfgReq(pst, suId, status)
+S16 rlcUlUdxCfgReq(pst, suId, status)
Pst *pst; /* post structure */
SuId spId; /* Service User Id */
RlcCfgInfo *cfmInfo; /* Config Info */
} /* end of rlcDlUdxCfgReq */
#ifdef ANSI
-PUBLIC S16 rlcUlUdxUeIdChgReq
+S16 rlcUlUdxUeIdChgReq
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
CkwUeInfo *newUeInfo /* Config Info */
)
#else
-PUBLIC S16 rlcUlUdxUeIdChgReq(pst, spId,transId, ueInfo, newUeInfo)
+S16 rlcUlUdxUeIdChgReq(pst, spId,transId, ueInfo, newUeInfo)
Pst *pst; /* post structure */
SpId spId; /* Service User Id */
U32 transId; /* transaction Id */
-PUBLIC S16 rlcUlUdxStaPduReq
+S16 rlcUlUdxStaPduReq
(
Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxDlStaPdu *pStaPdu
+RlcUdxDlStaPdu *pStaPdu
)
{
TRC3(rlcUlUdxStaPduReq);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxStaUpdReq
+S16 rlcUlUdxStaUpdReq
(
Pst* pst,
SpId spId,
CmLteRlcId *rlcId,
-KwUdxStaPdu *pStaPdu
+RlcUdxStaPdu *pStaPdu
)
#else
-PUBLIC S16 rlcUlUdxStaUpdReq(pst, rlcId, pStaPdu)
+S16 rlcUlUdxStaUpdReq(pst, rlcId, pStaPdu)
Pst* pst;
SpId spId;
CmLteRlcId *rlcId;
-KwUdxStaPdu *pStaPdu;
+RlcUdxStaPdu *pStaPdu;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxL2MeasReq
+S16 rlcUlUdxL2MeasReq
(
Pst* pst,
-KwL2MeasReqEvt *measReqEvt
+RlcL2MeasReqEvt *measReqEvt
)
#else
-PUBLIC S16 rlcUlUdxL2MeasReq(pst,measReqEvt)
+S16 rlcUlUdxL2MeasReq(pst,measReqEvt)
Pst* pst;
-KwL2MeasReqEvt *measReqEvt;
+RlcL2MeasReqEvt *measReqEvt;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxL2MeasSendReq
+S16 rlcUlUdxL2MeasSendReq
(
Pst* pst,
U8 measType
)
#else
-PUBLIC S16 rlcUlUdxL2MeasSendReq(pst,measReqEvt)
+S16 rlcUlUdxL2MeasSendReq(pst,measReqEvt)
Pst* pst;
U8 measType;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxL2MeasStopReq
+S16 rlcUlUdxL2MeasStopReq
(
Pst* pst,
U8 measType
)
#else
-PUBLIC S16 rlcUlUdxL2MeasStopReq(pst,measReqEvt)
+S16 rlcUlUdxL2MeasStopReq(pst,measReqEvt)
Pst* pst;
U8 measType;
#endif
#include "du_app_rlc_inf.h"
#include "rlc_mgr.h"
-#define KW_MODULE KW_DBGMASK_UDX
+#define RLC_MODULE RLC_DBGMASK_UDX
/* local defines */
/* local externs */
/* forward references */
/* public variable declarations */
-EXTERN S16 kwHdlCrlcUlCfgReq ARGS((RlcCb *gCb,RlcUlCfgTmpData *cfgTmpData,
+EXTERN S16 rlcHdlCrlcUlCfgReq ARGS((RlcCb *gCb,RlcUlCfgTmpData *cfgTmpData,
RlcCfgCfmInfo *cfmInfo, RlcCfgCfmInfo *cfgCfm));
/**
*/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxBndCfm
+S16 rlcUlUdxBndCfm
(
Pst *pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rlcUlUdxBndCfm (pst, suId, status)
+S16 rlcUlUdxBndCfm (pst, suId, status)
Pst *pst;
SuId suId;
U8 status;
{
U16 event;
U16 cause;
- KwUdxUlSapCb *udxSap; /* RGU SAP Control Block */
+ RlcUdxUlSapCb *udxSap; /* RGU SAP Control Block */
RlcCb *tRlcCb;
TRC3(rlcUlUdxBndCfm)
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KWDBGP_BRIEF(tRlcCb, "rlcUlUdxBndCfm(post, suId(%d), status(%d)\n",
+ RLCDBGP_BRIEF(tRlcCb, "rlcUlUdxBndCfm(post, suId(%d), status(%d)\n",
suId, status);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (tRlcCb->init.cfgDone != TRUE)
{
RLOG0(L_FATAL, "General configuration not done");
- KW_SEND_SAPID_ALARM(tRlcCb,suId,
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
return RFAILED;
if (suId < 0)
{
RLOG0(L_ERROR, "Invalid suId");
- KW_SEND_SAPID_ALARM(tRlcCb,suId,
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
return RFAILED;
udxSap = tRlcCb->u.ulCb->udxUlSap + suId;
- KWDBGP_DETAIL(tRlcCb, "KwLiRguBndCfm: For RGU SAP state=%d\n",
+ RLCDBGP_DETAIL(tRlcCb, "RlcLiRguBndCfm: For RGU SAP state=%d\n",
udxSap->state);
/* Check rguSap state */
switch (udxSap->state)
{
- case KW_SAP_BINDING:
+ case RLC_SAP_BINDING:
{
- if(TRUE == kwChkTmr(tRlcCb,(PTR)udxSap,KW_EVT_WAIT_BNDCFM))
+ if(TRUE == rlcChkTmr(tRlcCb,(PTR)udxSap,RLC_EVT_WAIT_BNDCFM))
{
- kwStopTmr (tRlcCb,(PTR)udxSap, KW_EVT_WAIT_BNDCFM);
+ rlcStopTmr (tRlcCb,(PTR)udxSap, RLC_EVT_WAIT_BNDCFM);
}
udxSap->retryCnt = 0;
if (status == CM_BND_OK)
{
- udxSap->state = KW_SAP_BND;
+ udxSap->state = RLC_SAP_BND;
event = LCM_EVENT_BND_OK;
cause = LKW_CAUSE_SAP_BNDENB;
}
else
{
- udxSap->state = KW_SAP_CFG;
+ udxSap->state = RLC_SAP_CFG;
event = LCM_EVENT_BND_FAIL;
cause = LKW_CAUSE_UNKNOWN;
}
break;
}
/* Send an alarm with proper event and cause */
- KW_SEND_SAPID_ALARM(tRlcCb,suId, event, cause);
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId, event, cause);
return ROK;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxCfgCfm
+S16 rlcUlUdxCfgCfm
(
Pst *pst,
SuId suId,
RlcCfgCfmInfo *cfmInfo
)
#else
-PUBLIC S16 rlcUlUdxCfgCfm (pst, suId, cfmInfo)
+S16 rlcUlUdxCfgCfm (pst, suId, cfmInfo)
Pst *pst;
SuId suId;
RlcCfgCfmInfo *cfmInfo;
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KWDBGP_BRIEF(tRlcCb, " suId(%d)\n", suId);
+ RLCDBGP_BRIEF(tRlcCb, " suId(%d)\n", suId);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (suId < 0)
{
RLOG0(L_ERROR, "Invalid suId");
- KW_SEND_SAPID_ALARM(tRlcCb,suId,
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- if(ROK != kwDbmFindUlTransaction(tRlcCb,cfmInfo->transId, &cfgTmpData))
+ if(ROK != rlcDbmFindUlTransaction(tRlcCb,cfmInfo->transId, &cfgTmpData))
{
RLOG0(L_ERROR, "Invalid transId");
RLC_FREE_SHRABL_BUF(pst->region,
return (RFAILED);
}
- if(ROK != kwDbmDelUlTransaction(tRlcCb, cfgTmpData))
+ if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
{
RLC_FREE_SHRABL_BUF(pst->region,
pst->pool,
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- kwHdlCrlcUlCfgReq(tRlcCb,cfgTmpData, cfmInfo, cfgCfm);
+ rlcHdlCrlcUlCfgReq(tRlcCb,cfgTmpData, cfmInfo, cfgCfm);
FILL_PST_RLC_TO_DUAPP(rspPst, tRlcCb->genCfg.lmPst.dstProcId, RLC_UL_INST, EVENT_RLC_UL_UE_CREATE_RSP);
SendRlcUlUeCreateRspToDu(&rspPst, cfgCfm);
*/
#ifdef ANSI
-PUBLIC S16 rlcUlUdxUeIdChgCfm
+S16 rlcUlUdxUeIdChgCfm
(
Pst *pst,
SuId suId,
CmStatus status
)
#else
-PUBLIC S16 rlcUlUdxUeIdChgCfm (pst, suId, cfmInfo)
+S16 rlcUlUdxUeIdChgCfm (pst, suId, cfmInfo)
Pst *pst;
SuId suId;
U32 transId;
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- KWDBGP_BRIEF(tRlcCb, " suId(%d) \n", suId);
+ RLCDBGP_BRIEF(tRlcCb, " suId(%d) \n", suId);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (suId < 0)
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- if(ROK != kwDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
+ if(ROK != rlcDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
{
RLOG0(L_ERROR, "Invalid transId");
return (RFAILED);
}
- if(ROK != kwDbmDelUlTransaction(tRlcCb, cfgTmpData))
+ if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
{
return RFAILED;
}
rlcCfgApplyUlUeIdChng(tRlcCb, cfgTmpData->ueInfo, cfgTmpData->newUeInfo, cfgTmpData);
}
}
- KwUiCkwUeIdChgCfm(&(tRlcCb->u.ulCb->ckwSap.pst),
+ RlcUiCkwUeIdChgCfm(&(tRlcCb->u.ulCb->ckwSap.pst),
tRlcCb->u.ulCb->ckwSap.suId,
transId,cfgTmpData->ueInfo,status);
/* only newUeInfo needs to be freed here, ueInfo would be freed at the
* -# ROK
* -# RFAILED
*/
-PUBLIC S16 rlcUlUdxStaProhTmrStart
+S16 rlcUlUdxStaProhTmrStart
(
Pst* pst,
SuId suId,
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- kwDbmFetchUlRbCbByRbId(tRlcCb, rlcId, &rbCb);
+ rlcDbmFetchUlRbCbByRbId(tRlcCb, rlcId, &rbCb);
if (rbCb == NULLP)
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
}
/* Start staProhTmr */
- kwStartTmr(tRlcCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ rlcStartTmr(tRlcCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
return (ROK);
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwHdlCrlcUlCfgReq
+S16 rlcHdlCrlcUlCfgReq
(
RlcCb *gCb,
RlcUlCfgTmpData *cfgTmpData,
RlcCfgCfmInfo *cfgCfm
)
#else
-PUBLIC S16 kwHdlCrlcUlCfgReq(gCb,cfgTmpData,cfmInfo,cfmInfo)
+S16 rlcHdlCrlcUlCfgReq(gCb,cfgTmpData,cfmInfo,cfmInfo)
RlcCb *gCb;
RlcUlCfgTmpData *cfgTmpData;
RlcCfgCfmInfo *cfmInfo;
case CKW_CFG_MODIFY:
case CKW_CFG_DELETE:
{
- if (entCfg->dir == KW_DIR_UL)
+ if (entCfg->dir == RLC_DIR_UL)
{
- KW_MEM_CPY(entCfgCfm,
+ RLC_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
sizeof(RlcEntCfgCfmInfo));
}
- else if (entCfg->dir == KW_DIR_DL)
+ else if (entCfg->dir == RLC_DIR_DL)
{
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
+ RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
- else if(entCfg->dir == KW_DIR_BOTH)
+ else if(entCfg->dir == RLC_DIR_BOTH)
{
if (entDlCfgCfm->status.status != CKW_CFG_CFM_OK)
{
&cfgTmpData->cfgEntData[idx],
cfgTmpData);
}
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
+ RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
else
{
- KW_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_DIR);
RLOG_ARG2(L_ERROR,DBG_UEID,cfg->ueId,"RBID[%d] direction[%d] is invalid",
entCfg->rbId,entCfg->dir);
case CKW_CFG_REESTABLISH:
{
- if (entCfg->dir == KW_DIR_UL)
+ if (entCfg->dir == RLC_DIR_UL)
{
- KW_MEM_CPY(entCfgCfm,
+ RLC_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
sizeof(RlcEntCfgCfmInfo));
}
- else if (entCfg->dir == KW_DIR_DL)
+ else if (entCfg->dir == RLC_DIR_DL)
{
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
+ RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
else
{
- if (entCfg->dir & KW_DIR_UL)
+ if (entCfg->dir & RLC_DIR_UL)
{
/* Reestablish indication is sent from UL Instance only*/
if (entDlCfgCfm->status.status == CKW_CFG_CFM_OK)
cfg->cellId, TRUE,
&cfgTmpData->cfgEntData[idx]);
}
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
+ RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
}
}
break;
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
{
rlcCfgApplyDelUlUe(gCb, cfgTmpData);
- KW_MEM_CPY(entCfgCfm,
+ RLC_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
sizeof(RlcEntCfgCfmInfo));
}
else
{
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm,
+ RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
sizeof(RlcEntCfgCfmInfo));
}
break;
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
{
rlcCfgApplyDelUlCell(gCb, cfgTmpData);
- KW_MEM_CPY(entCfgCfm,
+ RLC_MEM_CPY(entCfgCfm,
&cfgTmpData->cfgEntData[idx].entUlCfgCfm,
sizeof(RlcEntCfgCfmInfo));
}
else
{
- KW_MEM_CPY(entCfgCfm, entDlCfgCfm,
+ RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
sizeof(RlcEntCfgCfmInfo));
}
break;
}
default:
{
- KW_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
+ RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
RLOG0(L_ERROR,"Invalid configuration type");
Desc: Source code for RLC Upper Interface Module
This file contains following functions
- --KwUiCkwBndReq
- --KwUiCkwUbndReq
+ --RlcUiCkwBndReq
+ --RlcUiCkwUbndReq
--RlcProcCfgReq
- --KwUiKwuBndReq
- --KwUiKwuUbndReq
- --KwUiKwuDatReq
- --KwUiKwuDiscSduReq
+ --RlcUiKwuBndReq
+ --RlcUiKwuUbndReq
+ --RlcUiKwuDatReq
+ --RlcUiKwuDiscSduReq
File: kw_uim.c
* @brief RLC Upper Interface Module
*/
-#define KW_MODULE KW_DBGMASK_INF
+#define RLC_MODULE RLC_DBGMASK_INF
\f
/* header (.h) include files */
*
*/
#ifdef ANSI
-PUBLIC S16 KwUiCkwBndReq
+S16 RlcUiCkwBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 KwUiCkwBndReq (pst, suId, spId)
+S16 RlcUiCkwBndReq (pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
#endif
{
- KwCkwSapCb *ckwSap;
+ RlcCkwSapCb *ckwSap;
RlcCb *tRlcCb;
- TRC3(KwUiCkwBndReq);
+ TRC3(RlcUiCkwBndReq);
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
switch(ckwSap->state)
{
/* SAP is configured but not bound */
- case KW_SAP_CFG:
- case KW_SAP_UBND:
+ case RLC_SAP_CFG:
+ case RLC_SAP_UBND:
{
/* copy bind configuration parameters in SSAP sap */
ckwSap->suId = suId;
ckwSap->pst.dstInst = pst->srcInst;
/* Update the State */
- ckwSap->state = KW_SAP_BND;
+ ckwSap->state = RLC_SAP_BND;
- RLOG1(L_DEBUG, "KwUiCkwBndReq: state (%d)", ckwSap->state);
+ RLOG1(L_DEBUG, "RlcUiCkwBndReq: state (%d)", ckwSap->state);
break;
}
- case KW_SAP_BND:
+ case RLC_SAP_BND:
{
/* Sap is already bound check source, destination Entity and
* Proc Id */
ckwSap->pst.dstInst != pst->srcInst ||
ckwSap->suId != suId)
{
- KW_SEND_SAPID_ALARM(tRlcCb,
+ RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_CKW_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
RLOG0(L_ERROR, "CKW SAP already Bound");
- KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
- return RFAILED;
+ RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
+ return (RFAILED);
}
break;
}
{
#if (ERRCLASS & ERRCLS_INT_PAR)
RLOG0(L_ERROR, "Invalid CKW SAP State in Bind Req");
- KW_SEND_SAPID_ALARM(tRlcCb,
+ RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_CKW_BND_REQ,
LCM_CAUSE_INV_STATE);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
- return RFAILED;
+ RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
+ return (RFAILED);
break;
}
}
- KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_OK);
- return ROK;
+ RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_OK);
+ return (ROK);
}
\f
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiCkwUbndReq
+S16 RlcUiCkwUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 KwUiCkwUbndReq(pst, spId, reason)
+S16 RlcUiCkwUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
{
RlcCb *tRlcCb;
- TRC3(KwUiCkwUbndReq)
+ TRC3(RlcUiCkwUbndReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
UNUSED(reason);
#if (ERRCLASS & ERRCLS_INT_PAR)
- KW_GET_AND_VALIDATE_CKWSAP(tRlcCb,
+ RLC_GET_AND_VALIDATE_CKWSAP(tRlcCb,
(&(tRlcCb->u.ulCb->ckwSap)),
EKW208,
- "KwUiCkwUbndReq");
+ "RlcUiCkwUbndReq");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* disable upper sap (CKW) */
- tRlcCb->u.ulCb->ckwSap.state = KW_SAP_CFG;
+ tRlcCb->u.ulCb->ckwSap.state = RLC_SAP_CFG;
return ROK;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 RlcProcCfgReq
+S16 RlcProcCfgReq
(
Pst *pst,
RlcCfgInfo *cfg
)
#else
-PUBLIC S16 RlcProcCfgReq(pst, cfg)
+S16 RlcProcCfgReq(pst, cfg)
Pst *pst;
RlcCfgInfo *cfg;
#endif
cfgTmpData->cfgInfo = cfg;
- if (kwDbmAddUlTransaction(tRlcCb, cfgTmpData) != ROK)
+ if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData) != ROK)
{
RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
}
rlcUlHdlCfgReq(tRlcCb, cfgTmpData, cfg);
- rlcUlUdxCfgReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),KW_GET_UDX_SAP(tRlcCb)->spId,cfg);
+ rlcUlUdxCfgReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),RLC_GET_UDX_SAP(tRlcCb)->spId,cfg);
return ROK;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiCkwUeIdChgReq
+S16 RlcUiCkwUeIdChgReq
(
Pst *pst,
SpId spId,
CkwUeInfo *newUeInfo
)
#else
-PUBLIC S16 KwUiCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
+S16 RlcUiCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst *pst;
SpId spId;
U32 transId;
RlcCb *tRlcCb;
RlcUlCfgTmpData *cfgTmpData = NULLP;
- TRC3(KwUiCkwUeIdChgReq)
+ TRC3(RlcUiCkwUeIdChgReq)
do
{
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#ifndef ALIGN_64BIT
RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId,
- "KwUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))",
+ "RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))",
spId,
transId);
#else
RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId,
- "KwUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n",
+ "RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n",
spId,
transId);
#endif
cfgTmpData->ueInfo = ueInfo;
cfgTmpData->newUeInfo = newUeInfo;
- if (kwDbmAddUlTransaction(tRlcCb, cfgTmpData))
+ if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData))
{
RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
ret = RFAILED;
"Validation Failure for UeId change");
}
- rlcUlUdxUeIdChgReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),
- KW_GET_UDX_SAP(tRlcCb)->spId,
+ rlcUlUdxUeIdChgReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),
+ RLC_GET_UDX_SAP(tRlcCb)->spId,
transId,
ueInfo,
newUeInfo);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Void rlcUlHdlCfgReq
+Void rlcUlHdlCfgReq
(
RlcCb *gCb,
RlcUlCfgTmpData *cfgTmpData,
RlcCfgInfo *cfg
)
#else
-PUBLIC Void rlcUlHdlCfgReq(gCb, cfgTmpData, cfg)
+Void rlcUlHdlCfgReq(gCb, cfgTmpData, cfg)
RlcCb *gCb;
RlcUlCfgTmpData *cfgTmpData;
RlcCfgInfo *cfg;
case CKW_CFG_DELETE:
{
- if(cfg->entCfg[idx].dir & KW_DIR_UL)
+ if(cfg->entCfg[idx].dir & RLC_DIR_UL)
{
/* Configuration is for UL , thus validating */
if(ROK != rlcCfgValidateUlRb(gCb,
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/*Validation is getting failed so no need to do configuration at DL.
*Set dir as UL, so that no configuration is done at DL */
- cfg->entCfg[idx].dir = KW_DIR_UL;
+ cfg->entCfg[idx].dir = RLC_DIR_UL;
}
}
- if(cfg->entCfg[idx].dir == KW_DIR_UL)
+ if(cfg->entCfg[idx].dir == RLC_DIR_UL)
{
/*If the configuration is for UL only then apply it */
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
}
case CKW_CFG_REESTABLISH:
{
- if(cfg->entCfg[idx].dir & KW_DIR_UL)
+ if(cfg->entCfg[idx].dir & RLC_DIR_UL)
{
if(ROK != rlcCfgValidateReEstRb(gCb,
cfg->ueId,
cfg->cellId,cfg->entCfg[idx].rbId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
- cfg->entCfg[idx].dir = KW_DIR_UL;
+ cfg->entCfg[idx].dir = RLC_DIR_UL;
break;
}
}
- if(cfg->entCfg[idx].dir == KW_DIR_UL)
+ if(cfg->entCfg[idx].dir == RLC_DIR_UL)
{
/*If the configuration is for UL only then apply it */
if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
cfgTmpData->ueId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
- cfg->entCfg[idx].dir = KW_DIR_UL;
+ cfg->entCfg[idx].dir = RLC_DIR_UL;
}
break;
}
"Del UL Cell Validation Failure");
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
- cfg->entCfg[idx].dir = KW_DIR_UL;
+ cfg->entCfg[idx].dir = RLC_DIR_UL;
}
break;
}
*
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuBndReq
+S16 RlcUiKwuBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 KwUiKwuBndReq (pst, suId, spId)
+S16 RlcUiKwuBndReq (pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
#endif
{
- KwKwuSapCb *kwuSap; /* SAP Config Block */
+ RlcKwuSapCb *rlckwuSap; /* SAP Config Block */
RlcCb *tRlcCb;
- TRC3(KwUiKwuBndReq)
+ TRC3(RlcUiKwuBndReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- RLOG2(L_DEBUG, "KwUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
+ RLOG2(L_DEBUG, "RlcUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
/* Validation of input parameters */
#if (ERRCLASS & ERRCLS_INT_PAR)
if(!((spId < (S16) tRlcCb->genCfg.maxKwuSaps) && (spId >=0)))
{
RLOG0(L_ERROR,"Invalid spId");
- KW_SEND_SAPID_ALARM(tRlcCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
+ RLC_SEND_SAPID_ALARM(tRlcCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
return RFAILED;
}
#endif
/* Get Sap control block */
- kwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
- (tRlcCb->u.dlCb->kwuDlSap + spId):
- (tRlcCb->u.ulCb->kwuUlSap + spId);
+ rlckwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
+ (tRlcCb->u.dlCb->rlcKwuDlSap + spId):
+ (tRlcCb->u.ulCb->rlcKwuUlSap + spId);
/* Take action based on the current state of the SAP */
- switch(kwuSap->state)
+ switch(rlckwuSap->state)
{
/* SAP is configured but not bound */
- case KW_SAP_CFG:
- case KW_SAP_UBND:
+ case RLC_SAP_CFG:
+ case RLC_SAP_UBND:
{
/* copy bind configuration parameters in sap */
- kwuSap->suId = suId;
- kwuSap->pst.dstProcId = pst->srcProcId;
- kwuSap->pst.dstEnt = pst->srcEnt;
- kwuSap->pst.dstInst = pst->srcInst;
+ rlckwuSap->suId = suId;
+ rlckwuSap->pst.dstProcId = pst->srcProcId;
+ rlckwuSap->pst.dstEnt = pst->srcEnt;
+ rlckwuSap->pst.dstInst = pst->srcInst;
/* Update the State */
- kwuSap->state = KW_SAP_BND;
+ rlckwuSap->state = RLC_SAP_BND;
- RLOG1(L_DEBUG, "KwUiKwuBndReq: state (%d)", kwuSap->state);
+ RLOG1(L_DEBUG, "RlcUiKwuBndReq: state (%d)", rlckwuSap->state);
break;
}
- case KW_SAP_BND:
+ case RLC_SAP_BND:
{
/* Sap is already bound check source, destination Entity and Proc Id */
- if (kwuSap->pst.dstProcId != pst->srcProcId ||
- kwuSap->pst.dstEnt != pst->srcEnt ||
- kwuSap->pst.dstInst != pst->srcInst ||
- kwuSap->suId != suId)
+ if (rlckwuSap->pst.dstProcId != pst->srcProcId ||
+ rlckwuSap->pst.dstEnt != pst->srcEnt ||
+ rlckwuSap->pst.dstInst != pst->srcInst ||
+ rlckwuSap->suId != suId)
{
- KW_SEND_SAPID_ALARM(tRlcCb,
+ RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_KWU_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
RLOG1(L_ERROR,"RLC Mode [%d] : KWU SAP already Bound",
tRlcCb->genCfg.rlcMode);
- KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_NOK);
- return RFAILED;
+ RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_NOK);
+ return (RFAILED);
}
break;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
RLOG1(L_ERROR,"RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
tRlcCb->genCfg.rlcMode);
- KW_SEND_SAPID_ALARM(tRlcCb,
+ RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_KWU_BND_REQ,
LCM_CAUSE_INV_STATE);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_NOK);
- return RFAILED;
+ RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_NOK);
+ return (RFAILED);
}
}
- KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_OK);
- return ROK;
+ RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_OK);
+ return (ROK);
}
\f
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuUbndReq
+S16 RlcUiKwuUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 KwUiKwuUbndReq(pst, spId, reason)
+S16 RlcUiKwuUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
#endif
{
- KwKwuSapCb *kwuSap; /* KWU SAP control block */
+ RlcKwuSapCb *rlckwuSap; /* KWU SAP control block */
RlcCb *tRlcCb;
- TRC3(KwUiKwuUbndReq)
+ TRC3(RlcUiKwuUbndReq)
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((pst->dstInst >= MAX_RLC_INSTANCES) ||
reason);
/* Get Sap control block */
- kwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
- (tRlcCb->u.dlCb->kwuDlSap + spId):
- (tRlcCb->u.ulCb->kwuUlSap + spId);
+ rlckwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
+ (tRlcCb->u.dlCb->rlcKwuDlSap + spId):
+ (tRlcCb->u.ulCb->rlcKwuUlSap + spId);
- kwuSap->state = KW_SAP_CFG;
+ rlckwuSap->state = RLC_SAP_CFG;
return ROK;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuDatReq
+S16 RlcUiKwuDatReq
(
Pst *pst,
KwuDatReqInfo *datReq,
Buffer *mBuf
)
#else
-PUBLIC S16 KwUiKwuDatReq(pst, datReq, mBuf)
+S16 RlcUiKwuDatReq(pst, datReq, mBuf)
Pst *pst;
KwuDatReqInfo *datReq;
Buffer *mBuf;
RlcDlRbCb *rbCb; /* RB Control Block */
RlcCb *tRlcCb;
- TRC3(KwUiKwuDatReq)
+ TRC3(RlcUiKwuDatReq)
DU_LOG("\nRLC : Received DL Data");
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* Fetch the RbCb */
- kwDbmFetchDlRbCbByRbId(tRlcCb, &datReq->rlcId, &rbCb);
+ rlcDbmFetchDlRbCbByRbId(tRlcCb, &datReq->rlcId, &rbCb);
if(!rbCb)
{
RLOG_ARG2(L_WARNING, DBG_UEID,datReq->rlcId.ueId, "CellId[%u]:DL RbId [%d] not found",
return RFAILED;
}
- kwTmmQSdu(tRlcCb,rbCb, datReq, mBuf);
+ rlcTmmQSdu(tRlcCb,rbCb, datReq, mBuf);
break;
}
case CM_LTE_MODE_UM:
{
- kwUmmQSdu(tRlcCb,rbCb, datReq, mBuf);
+ rlcUmmQSdu(tRlcCb,rbCb, datReq, mBuf);
break;
}
case CM_LTE_MODE_AM:
{
- kwAmmQSdu(tRlcCb,rbCb, mBuf, datReq);
+ rlcAmmQSdu(tRlcCb,rbCb, mBuf, datReq);
break;
}
default:
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 KwUiKwuDiscSduReq
+S16 RlcUiKwuDiscSduReq
(
Pst *pst,
SpId spId,
KwuDiscSduInfo *discSdu
)
#else
-PUBLIC S16 KwUiKwuDiscSduReq(pst, spId, discSdu)
+S16 RlcUiKwuDiscSduReq(pst, spId, discSdu)
Pst *pst;
SpId spId;
KwuDiscSduInfo *discSdu;
#define __KW_ULH__
/**
- * @def KW_MEAS_IS_UL_IP_MEAS_ON_FOR_RB
+ * @def RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB
*
* This macro is used to check if UL IP throughput measurement is ON
* or off for the passed rb
* @param[in] _rbCb RLC uplink control block
*
*/
-#define KW_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb) \
+#define RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb) \
((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
- (_gCb->u.ulCb->kwL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_UL_IP) && \
+ (_gCb->u.ulCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_UL_IP) && \
(_rbCb->rbL2Cb.measOn & LKW_L2MEAS_UL_IP))
#endif /* __KW_ULH__ */
\f
* - umHdr : UM PDU Header Information
* - pduSz : Length of the PDU excluding the header
*/
-typedef struct kwUmRecBuf
+typedef struct rlcUmRecBuf
{
Buffer *pdu; /**< Buffer holding the UM PDU */
- KwUmHdr umHdr; /**< UM PDU Header Information */
+ RlcUmHdr umHdr; /**< UM PDU Header Information */
MsgLen pduSz; /**< PDU Size */
-}KwUmRecBuf;
+}RlcUmRecBuf;
/**
* @brief Structure to hold uplink information in UM mode for a particular RB
* - partialSdu : This is used to store the partially completed SDU.
* It remains till complete SDU is received
*/
-typedef struct kwUmUl
+typedef struct rlcUmUl
{
U8 snLen; /**< Sequence number length */
U8 reOrdTmrInt; /**< Timer Interval */
- KwUmRecBuf **recBuf; /**< Reception buffer */
- KwSn umWinSz; /**< UM window size */
+ RlcUmRecBuf **recBuf; /**< Reception buffer */
+ RlcSn umWinSz; /**< UM window size */
U16 modBitMask; /**< Bitmask for modulus to wrap around variables */
- KwSn sn; /**< Sequence number */
- KwSn vrUr; /**< VR(UR) - Receive state variable */
- KwSn vrUh; /**< VR(UH) - Highest received state variable */
- KwSn vrUx; /**< VR(UX) - Reordering state variable */
+ RlcSn sn; /**< Sequence number */
+ RlcSn vrUr; /**< VR(UR) - Receive state variable */
+ RlcSn vrUh; /**< VR(UH) - Highest received state variable */
+ RlcSn vrUx; /**< VR(UX) - Reordering state variable */
CmTimer reOrdTmr; /**< Reordering Timer */
Buffer *partialSdu; /**< Partial SDU - Remains till the complete SDU
is received */
-}KwUmUl;
+}RlcUmUl;
/*@}*/
/**
* - amHdr : The AM Header for the PDU segment
*
*/
-typedef struct kwSeg
+typedef struct rlcSeg
{
CmLList lstEnt; /**< List entry for PDU segment */
Buffer *seg; /**< PDU segment */
MsgLen segSz; /**< Buffer Size */
U16 soEnd; /**< Segment Offset End */
- KwAmHdr amHdr; /**< AM header */
-}KwSeg;
+ RlcAmHdr amHdr; /**< AM header */
+}RlcSeg;
/*@}*/
* - allRcvd : Whether all the segments for this PDU has been recevied
*
*/
-typedef struct kwAmRecBuf
+typedef struct rlcAmRecBuf
{
CmLList lnk; /**< Link to the receive buffer list */
Buffer *pdu; /**< PDU buffer */
MsgLen pduSz; /**< Buffer Size */
- KwAmHdr amHdr; /**< AM header Info */
+ RlcAmHdr amHdr; /**< AM header Info */
CmLListCp segLst; /**< PDU Segments list */
- KwSeg *expByteSeg; /**< Next expected byte segment */
+ RlcSeg *expByteSeg; /**< Next expected byte segment */
U16 expSo; /**< Next expected seg offset */
Bool allRcvd; /**< All bytes received or not */
Bool isDelvUpperLayer; /**< Is it sent to upper layer */
-}KwAmRecBuf;
+}RlcAmRecBuf;
/** @addtogroup ammode */
/*@{*/
* the STATUS PDU
*
*/
-typedef struct kwAmUl
+typedef struct rlcAmUl
{
#ifndef LTE_TDD
CmLListCp *recBufLst;
#else
-// KwAmRecBuf *recBuf[1024]; /**< Reception buffer */
+// RlcAmRecBuf *recBuf[1024]; /**< Reception buffer */
#endif
- KwSn rxNext; /**< RX_Next:Equvalent to VR(R) in 4G */
- KwSn rxNextHighestRcvd; /**< RX_Next_Highest_Rcvd: Equvalent to VR(H) in 4G */
- KwSn rxNextStatusTrig; /**< rxNextStatusTrig: Equvalent to VR(X) in 4G*/
- KwSn vrMr; /**< VR(MR) */
- KwSn rxHighestStatus; /**< rxHighestStatus: Eqvalent to VR(MS) in 4G*/
+ RlcSn rxNext; /**< RX_Next:Equvalent to VR(R) in 4G */
+ RlcSn rxNextHighestRcvd; /**< RX_Next_Highest_Rcvd: Equvalent to VR(H) in 4G */
+ RlcSn rxNextStatusTrig; /**< rxNextStatusTrig: Equvalent to VR(X) in 4G*/
+ RlcSn vrMr; /**< VR(MR) */
+ RlcSn rxHighestStatus; /**< rxHighestStatus: Eqvalent to VR(MS) in 4G*/
Bool staTrg; /**< Whether status trigger occured */
Buffer *partialSdu; /**< Partially received SDU */
- KwSn expSn; /**< Expected SN for reassembly */
+ RlcSn expSn; /**< Expected SN for reassembly */
U16 expSo; /**< Expected SO for reassembly */
CmTimer staProhTmr; /**< T_status_prohibit Timer */
U16 staProhTmrInt; /**< Timer Interval */
Bool isOutOfSeq; /**< To identify whether packets are Out-Of-Seq or not */
U8 snLen; /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
U32 snModMask; /*!< (2 Pwr SnLen - 1): 5GNR RLC */
-}KwAmUl;
+}RlcAmUl;
/*@}*/
* - inst : Id of RLC instance where this Radio Bearer is present. Used
* to find the instance from the Radio Bearer for memory needs
* as different instances might have different memory.
- * - kwuSapId : KWU SAP identifier
+ * - k1wuSapId : KWU SAP identifier
* - udxSapId : UDX SAP idenrifier
* - transId : Stores the transaction identifier used to communicate
* with MAC, the same value as sent by MAC is passed back
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- KwL2MeasRbCb rbL2Cb; /**< RB measurement L2 Cb */
+ RlcL2MeasRbCb rbL2Cb; /**< RB measurement L2 Cb */
RlcUlUeCb *ueCb; /*!< Pointer to UeCb */
U8 qci; /**< qci of the RB */
- KwL2MeasIpThruput l2MeasIpThruput; /**< Holds related parameter for
+ RlcL2MeasIpThruput l2MeasIpThruput; /**< Holds related parameter for
DL/Ul ip throughput>*/
#endif /* LTE_L2_MEAS */
CmLteRlcId rlcId; /**< RLC Identifier */
- KwLchInfo lch; /**< Logical Channel Info */
+ RlcLchInfo lch; /**< Logical Channel Info */
CmLteRlcMode mode; /**< Entity Mode */
U8 dir; /**< Direction for UL/DL */
Inst inst; /**< Tapa where Rb created Instance id */
- SpId kwuSapId; /**< KWU sap Id, to get the KwuSapCb */
+ SpId k1wuSapId; /**< KWU sap Id, to get the KwuSapCb */
SpId udxSapId; /**< KWU sap Id, to get the KwuSapCb */
U32 transId; /**< Transaction Id for RLC */
union
{
- KwUmUl umUl; /**< UM mode Ul elements */
- KwAmUl amUl; /**< AM mode uplink elements */
+ RlcUmUl umUl; /**< UM mode Ul elements */
+ RlcAmUl amUl; /**< AM mode uplink elements */
}m; /**< RLC mode specific Info */
}RlcUlRbCb;
{
CmHashListEnt cellHlEnt; /**< Hash list entry for CellCb */
CmLteCellId cellId; /**< Cell Id */
- RlcUlRbCb *rbCb[KW_MAX_RB_PER_CELL]; /**< RbCbs within a Cell */
- RlcUlLch lCh[KW_MAX_LCH_PER_CELL]; /**< Logical channels in a cell */
+ RlcUlRbCb *rbCb[RLC_MAX_RB_PER_CELL]; /**< RbCbs within a Cell */
+ RlcUlLch lCh[RLC_MAX_LCH_PER_CELL]; /**< Logical channels in a cell */
Pst selfPstUl;
}RlcUlCellCb;
CmHashListEnt ueHlEnt; /**< Hash list entry for UeCb */
CmLteRnti ueId; /*!< UE Id */
CmLteCellId cellId; /*!< Cell Id */
- RlcUlRbCb *srbCb[KW_MAX_SRB_PER_UE]; /**< SRB RbCbs within an UE */
- RlcUlRbCb *drbCb[KW_MAX_DRB_PER_UE]; /**< DRB RbCbs within an UE */
- RlcUlLch lCh[KW_MAX_LCH_PER_UE]; /**< Logical channels of an UE*/
+ RlcUlRbCb *srbCb[RLC_MAX_SRB_PER_UE]; /**< SRB RbCbs within an UE */
+ RlcUlRbCb *drbCb[RLC_MAX_DRB_PER_UE]; /**< DRB RbCbs within an UE */
+ RlcUlLch lCh[RLC_MAX_LCH_PER_UE]; /**< Logical channels of an UE*/
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
U32 firstPacketTTI; /*!< is first packet of the burst */
* Configuration Functions
***************************************************************************/
-EXTERN S16 kwValidateRbCfgParams ARGS ((RlcCb *gCb,
+EXTERN S16 rlcValidateRbCfgParams ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
RlcEntCfgInfo *cfgToValidate,
/****************************************************************************
* DBM module Functions
***************************************************************************/
-EXTERN S16 kwDbmUlInit ARGS ((RlcCb *gCb));
+EXTERN S16 rlcDbmUlInit ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmUlDeInit ARGS ((RlcCb *gCb));
+EXTERN Void rlcDbmUlDeInit ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmAddUlUeCb ARGS ((RlcCb *gCb,
+EXTERN S16 rlcDbmAddUlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
RlcUlUeCb *ueCb));
-EXTERN S16 kwDbmFetchUlUeCb ARGS ((RlcCb *gCb,
+EXTERN S16 rlcDbmFetchUlUeCb ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
RlcUlUeCb **ueCb));
-EXTERN Void kwDbmDelUlUeCb ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmDelUlUeCb ARGS ((RlcCb *gCb,
RlcUlUeCb *ueCb,
Bool abortFlag));
-EXTERN Void kwDbmDelAllUlUe ARGS ((RlcCb *gCb));
+EXTERN Void rlcDbmDelAllUlUe ARGS ((RlcCb *gCb));
-EXTERN S16 kwDbmAddUlCellCb ARGS ((RlcCb *gCb,
+EXTERN S16 rlcDbmAddUlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
RlcUlCellCb *cellCb));
-EXTERN Void kwDbmFetchUlCellCb ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmFetchUlCellCb ARGS ((RlcCb *gCb,
CmLteCellId cellId,
RlcUlCellCb **cellCb));
-EXTERN Void kwDbmDelUlCellCb ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmDelUlCellCb ARGS ((RlcCb *gCb,
RlcUlCellCb *cellCb));
-EXTERN Void kwDbmDelAllUlCell ARGS ((RlcCb *gCb));
+EXTERN Void rlcDbmDelAllUlCell ARGS ((RlcCb *gCb));
-EXTERN Void kwDbmFetchUlRbCbByRbId ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmFetchUlRbCbByRbId ARGS ((RlcCb *gCb,
CmLteRlcId *rlcId,
RlcUlRbCb **rbCb));
-EXTERN Void kwDbmFetchUlRbCbFromLchId ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmFetchUlRbCbFromLchId ARGS ((RlcCb *gCb,
CmLteRnti ueId,
CmLteCellId cellId,
CmLteLcId lcId,
RlcUlRbCb **rbCb));
-EXTERN Void kwDbmDelAllUlRb ARGS ((RlcCb *gCb,
+EXTERN Void rlcDbmDelAllUlRb ARGS ((RlcCb *gCb,
RlcUlRbCb **rbCbLst,
U8 numRbCb));
-EXTERN S16 kwDbmAddUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
+EXTERN S16 rlcDbmAddUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
-EXTERN S16 kwDbmFindUlTransaction ARGS((RlcCb *gCb,
+EXTERN S16 rlcDbmFindUlTransaction ARGS((RlcCb *gCb,
U32 transId,
RlcUlCfgTmpData **cfg));
-EXTERN S16 kwDbmDelUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
+EXTERN S16 rlcDbmDelUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
-EXTERN S16 kwDbmDelAllUlTransactions ARGS((RlcCb *gCb));
+EXTERN S16 rlcDbmDelAllUlTransactions ARGS((RlcCb *gCb));
-EXTERN Void kwDbmUlShutdown ARGS ((RlcCb *gCb));
+EXTERN Void rlcDbmUlShutdown ARGS ((RlcCb *gCb));
/****************************************************************************
* Transparent Mode Functions
***************************************************************************/
#ifdef CCPU_OPT
-EXTERN PUBLIC Void kwTmmRcvFrmLi ARGS ((RlcCb *gCb,
+EXTERN Void rlcTmmRcvFrmLi ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
CmLteRnti tCrnti,
Buffer *pdu));
#else /* CCPU_OPT */
-EXTERN PUBLIC Void kwTmmRcvFrmLi ARGS ((RlcCb *gCb,
+EXTERN Void rlcTmmRcvFrmLi ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu));
#endif /* CCPU_OPT */
-EXTERN Void kwTmmUlReEstablish ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
+EXTERN Void rlcTmmUlReEstablish ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
/****************************************************************************
* Unacknowledged Mode Functions
***************************************************************************/
#ifdef LTE_L2_MEAS
-EXTERN Void kwUmmProcessPdus ARGS((RlcCb *gCb,
+EXTERN Void rlcUmmProcessPdus ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
U32 ttiCnt));
#else
-EXTERN Void kwUmmProcessPdus ARGS ((RlcCb *gCb,
+EXTERN Void rlcUmmProcessPdus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo));
#endif
-EXTERN Void kwUmmUlReEstablish ARGS ((RlcCb *gCb,
+EXTERN Void rlcUmmUlReEstablish ARGS ((RlcCb *gCb,
CmLteRlcId *rlcId,
RlcUlRbCb *rbCb));
-EXTERN Void kwUmmReOrdTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
+EXTERN Void rlcUmmReOrdTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
-EXTERN Void kwUmmFreeUlRbCb ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
+EXTERN Void rlcUmmFreeUlRbCb ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
/****************************************************************************
* Acknowledged Mode Functions
***************************************************************************/
-EXTERN Void kwAmmUlReEstablish ARGS((RlcCb *gCb,
+EXTERN Void rlcAmmUlReEstablish ARGS((RlcCb *gCb,
CmLteRlcId rlcId,
Bool sndReEst,
RlcUlRbCb *rbCb));
#ifdef LTE_L2_MEAS
-EXTERN Void kwAmmProcessPdus ARGS((RlcCb *gCb,
+EXTERN Void rlcAmmProcessPdus ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
U32 ttiCnt));
#else
-EXTERN Void kwAmmProcessPdus ARGS((RlcCb *gCb,
+EXTERN Void rlcAmmProcessPdus ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo));
#endif
-EXTERN Void kwAmmReOrdTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
+EXTERN Void rlcAmmReOrdTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
-EXTERN Void kwAmmStaProTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
+EXTERN Void rlcAmmStaProTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
-EXTERN Void kwAmmFreeUlRbCb ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
+EXTERN Void rlcAmmFreeUlRbCb ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
/****************************************************************************
* Utility Functions
***************************************************************************/
-EXTERN Void kwUtlStoreRecBuf ARGS ((CmLListCp *recBufLst,
- KwAmRecBuf *recBuf,
- KwSn sn
+EXTERN Void rlcUtlStoreRecBuf ARGS ((CmLListCp *recBufLst,
+ RlcAmRecBuf *recBuf,
+ RlcSn sn
));
-EXTERN KwAmRecBuf* kwUtlGetRecBuf ARGS ((CmLListCp *recBufLst,
- KwSn sn
+EXTERN RlcAmRecBuf* rlcUtlGetRecBuf ARGS ((CmLListCp *recBufLst,
+ RlcSn sn
));
-EXTERN Void kwUtlDelRecBuf ARGS ((CmLListCp *recBufLst,
- KwAmRecBuf *recBuf,
+EXTERN Void rlcUtlDelRecBuf ARGS ((CmLListCp *recBufLst,
+ RlcAmRecBuf *recBuf,
RlcCb *gCb
));
-EXTERN S16 kwUtlRcvFrmLi ARGS ((RlcCb *gCb, KwDatIndInfo *datIndInfo));
+EXTERN S16 rlcUtlRcvFrmLi ARGS ((RlcCb *gCb, KwDatIndInfo *datIndInfo));
-EXTERN S16 kwUtlSndDatInd ARGS ((RlcCb *gCb,RlcUlRbCb *rbCb, Buffer *sdu));
+EXTERN S16 rlcUtlSndDatInd ARGS ((RlcCb *gCb,RlcUlRbCb *rbCb, Buffer *sdu));
#ifdef LTE_L2_MEAS
-EXTERN S16 kwUtlHdlL2TmrExp ARGS (( RlcCb *gCb, KwL2MeasEvtCb *measEvtCb));
+EXTERN S16 rlcUtlHdlL2TmrExp ARGS (( RlcCb *gCb, RlcL2MeasEvtCb *measEvtCb));
-EXTERN Void kwUtlCalUlIpThrPutIncTTI ARGS ((RlcCb *gCb,
+EXTERN Void rlcUtlCalUlIpThrPutIncTTI ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
U32 ttiCnt));
-EXTERN Void kwUtlCalUlIpThrPut ARGS((RlcCb *gCb,
+EXTERN Void rlcUtlCalUlIpThrPut ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
U32 ttiCnt));
-EXTERN S16 kwUtlSndUlL2MeasCfm ARGS ((RlcCb *gCb, KwL2MeasEvtCb *measEvtCb));
+EXTERN S16 rlcUtlSndUlL2MeasCfm ARGS ((RlcCb *gCb, RlcL2MeasEvtCb *measEvtCb));
-EXTERN S16 kwUtlSndUlL2MeasNCfm ARGS ((RlcCb *gCb,
- KwL2MeasReqEvt *measReqEvt,
- KwL2MeasCfmEvt *measCfmEvt));
+EXTERN S16 rlcUtlSndUlL2MeasNCfm ARGS ((RlcCb *gCb,
+ RlcL2MeasReqEvt *measReqEvt,
+ RlcL2MeasCfmEvt *measCfmEvt));
-EXTERN S16 kwUtlL2MeasUlInit ARGS((RlcCb *gCb));
+EXTERN S16 rlcUtlL2MeasUlInit ARGS((RlcCb *gCb));
-EXTERN Void kwUtlResetUlL2MeasInKwRb ARGS((RlcCb *gCb,
- KwL2MeasCb *measCb,
+EXTERN Void rlcUtlResetUlL2MeasInRlcRb ARGS((RlcCb *gCb,
+ RlcL2MeasCb *measCb,
U8 measType));
-EXTERN S16 kwUtlValidateIpThL2Meas ARGS ((KwL2MeasReqEvt *measReqEvt,
- KwL2MeasCfmEvt *measCfmEvt));
+EXTERN S16 rlcUtlValidateIpThL2Meas ARGS ((RlcL2MeasReqEvt *measReqEvt,
+ RlcL2MeasCfmEvt *measCfmEvt));
#endif /* LTE_L2_MEAS */
/****************************************************************************
#include "l2_tenb_stats.x"
#endif
-PUBLIC S16 rlcUlInitExt ARGS (( Void ));
+S16 rlcUlInitExt ARGS (( Void ));
\f
/**
*
*/
#ifdef ANSI
-PUBLIC S16 rlcUlInitExt
+S16 rlcUlInitExt
(
)
#else
-PUBLIC S16 rlcUlInitExt()
+S16 rlcUlInitExt()
#endif
{
TRC2(rlcUlInitExt);
*
*/
#ifdef ANSI
-PUBLIC S16 rlcUlActvInit
+S16 rlcUlActvInit
(
Ent ent, /* entity */
Inst inst, /* instance */
Reason reason /* reason */
)
#else
-PUBLIC S16 rlcUlActvInit(ent, inst, region, reason)
+S16 rlcUlActvInit(ent, inst, region, reason)
Ent ent; /* entity */
Inst inst; /* instance */
Region region; /* region */
*
*/
#ifdef ANSI
-PUBLIC S16 rlcUlActvTsk
+S16 rlcUlActvTsk
(
Pst *pst, /* pst structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 rlcUlActvTsk(pst, mBuf)
+S16 rlcUlActvTsk(pst, mBuf)
Pst *pst; /* pst structure */
Buffer *mBuf; /* message buffer */
#endif
#ifdef LCLKW
case LKW_EVT_CFG_REQ:
{
- ret = unpackRlcConfigReq(KwMiRlcConfigReq, pst, mBuf);
+ ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
break;
}
case LKW_EVT_CNTRL_REQ:
{
- ret = cmUnpkLkwCntrlReq(KwMiLkwCntrlReq, pst, mBuf);
+ ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
break;
}
case LKW_EVT_STS_REQ:
{
- ret = cmUnpkLkwStsReq(KwMiLkwStsReq, pst, mBuf);
+ ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
break;
}
case LKW_EVT_STA_REQ:
{
- ret = cmUnpkLkwStaReq(KwMiLkwStaReq, pst, mBuf);
+ ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
break;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
case LKW_EVT_L2MEAS_REQ:
{
- ret = cmUnpkLkwL2MeasReq(KwMiLkwL2MeasReq, pst, mBuf);
+ ret = cmUnpkLkwL2MeasReq(RlcMiLkwL2MeasReq, pst, mBuf);
break;
}
case LKW_EVT_L2MEAS_SEND_REQ:
{
- ret = cmUnpkLkwL2MeasSendReq(KwMiLkwL2MeasSendReq, pst, mBuf);
+ ret = cmUnpkLkwL2MeasSendReq(RlcMiLkwL2MeasSendReq, pst, mBuf);
break;
}
case LKW_EVT_L2MEAS_STOP_REQ:
{
- ret = cmUnpkLkwL2MeasStopReq(KwMiLkwL2MeasStopReq, pst, mBuf);
+ ret = cmUnpkLkwL2MeasStopReq(RlcMiLkwL2MeasStopReq, pst, mBuf);
break;
}
#endif
break;
}
- case ENTKW:
+ case ENTRLC:
{
switch(pst->event)
{
#ifdef LCCKW
case CKW_EVT_BND_REQ: /* Bind request */
{
- ret = cmUnpkCkwBndReq(KwUiCkwBndReq, pst, mBuf );
+ ret = cmUnpkCkwBndReq(RlcUiCkwBndReq, pst, mBuf );
break;
}
case CKW_EVT_UBND_REQ: /* Unbind request */
{
- ret = cmUnpkCkwUbndReq(KwUiCkwUbndReq, pst, mBuf );
+ ret = cmUnpkCkwUbndReq(RlcUiCkwUbndReq, pst, mBuf );
break;
}
case CKW_EVT_UEIDCHG_REQ: /* Configuration request */
{
- ret = cmUnpkCkwUeIdChgReq(KwUiCkwUeIdChgReq, pst, mBuf);
+ ret = cmUnpkCkwUeIdChgReq(RlcUiCkwUeIdChgReq, pst, mBuf);
break;
}
#ifdef LCKWU
case KWU_EVT_BND_REQ: /* Bind request */
{
- ret = cmUnpkKwuBndReq(KwUiKwuBndReq, pst, mBuf );
+ ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
break;
}
case KWU_EVT_UBND_REQ: /* Unbind request */
{
- ret = cmUnpkKwuUbndReq(KwUiKwuUbndReq, pst, mBuf );
+ ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
break;
}
#endif /* LCKWU */
#ifdef LCKWU
case KWU_EVT_BND_REQ: /* Bind request */
{
- ret = cmUnpkKwuBndReq(KwUiKwuBndReq, pst, mBuf );
+ ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
break;
}
case KWU_EVT_UBND_REQ: /* Unbind request */
{
- ret = cmUnpkKwuUbndReq(KwUiKwuUbndReq, pst, mBuf );
+ ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
break;
}
break;
}
- case ENTRG:
+ case ENTMAC:
{
switch(pst->event)
{
#ifdef LCRGU
case EVTRGUBNDCFM: /* Bind request */
{
- ret = cmUnpkRguBndCfm(KwLiRguBndCfm, pst, mBuf );
+ ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
break;
}
#endif/* End for TENB_T2K3K_SPECIFIC_CHANGES and L2_L3_SPLIT */
#ifndef UL_RLC_NET_CLUSTER
#ifdef TENB_STATS
- case ENTTF:
+ case ENTLWRMAC:
{
switch(pst->event)
{
Desc: Source code for RLC Unacknowledged mode assembly and
reassembly.This file contains following functions
- --kwUmmQSdu
- --kwUmmProcessSdus
- --kwUmmProcessPdus
- --kwUmmReAssembleSdus
+ --rlcUmmQSdu
+ --rlcUmmProcessSdus
+ --rlcUmmProcessPdus
+ --rlcUmmReAssembleSdus
--kwUmmReEstablish
File: kw_umm_dl.c
#include "kw_udx.x"
#include "kw_dl.x"
-#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_DL)
+#define RLC_MODULE (RLC_DBGMASK_UM | RLC_DBGMASK_DL)
/* variables for logging :declared in BRDCM cl */
#ifndef TENB_ACC
extern U32 dlrate_kwu;
#endif
-PRIVATE Void kwUmmEstHdrSz ARGS ((KwUmDl *umUl));
+PRIVATE Void rlcUmmEstHdrSz ARGS ((RlcUmDl *umUl));
-PRIVATE Void kwUmmCreatePdu ARGS ((RlcCb *gCb,
+PRIVATE Void rlcUmmCreatePdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *pdu,
U8 fi,
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmQSdu
+Void rlcUmmQSdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *mBuf
)
#else
-PUBLIC Void kwUmmQSdu(gCb,rbCb,datReq,mBuf)
+Void rlcUmmQSdu(gCb,rbCb,datReq,mBuf)
RlcCb *gCb;
RlcDlRbCb *rbCb;
KwuDatReqInfo *datReq;
#endif
{
MsgLen len; /* SDU buffer length */
- KwSdu *sdu; /* SDU */
+ RlcSdu *sdu; /* SDU */
- TRC2(kwUmmQSdu)
+ TRC2(rlcUmmQSdu)
- KW_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb);
+ RLC_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb);
- RLC_ALLOC_WC(gCb, sdu, (Size)sizeof(KwSdu));
+ RLC_ALLOC_WC(gCb, sdu, (Size)sizeof(RlcSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
#endif /* ERRCLASS & ERRCLS_ADD_RES */
/* Discard new changes starts */
- kwUtlGetCurrTime(&sdu->arrTime);
+ rlcUtlGetCurrTime(&sdu->arrTime);
/* Discard new changes ends */
SFndLenMsg(mBuf,&len);
cmLListAdd2Tail(&(rbCb->m.umDl.sduQ), &sdu->lstEnt);
sdu->lstEnt.node = (PTR)sdu;
- kwUmmEstHdrSz(&rbCb->m.umDl);
+ rlcUmmEstHdrSz(&rbCb->m.umDl);
if(!rlcDlUtlIsReestInProgress(rbCb))
{
- kwUtlSndDStaRsp(gCb,rbCb,rbCb->m.umDl.bo,rbCb->m.umDl.estHdrSz,FALSE,0);
+ rlcUtlSndDStaRsp(gCb,rbCb,rbCb->m.umDl.bo,rbCb->m.umDl.estHdrSz,FALSE,0);
}
/* kw005.201 added support for L2 Measurement */
if((rbCb->rbL2Cb.measOn & LKW_L2MEAS_ACT_UE) &&
(rbCb->ueCb->numActRb[rbCb->qci]++ == 0))
{
- rlcCb.kwL2Cb.numActUe[rbCb->qci]++;
+ rlcCb.rlcL2Cb.numActUe[rbCb->qci]++;
}
#endif
* -# RFAILED If allocation of Sdu fails
*/
#ifdef ANSI
-PUBLIC Void kwUmmProcessSdus
+Void rlcUmmProcessSdus
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwDatReq *datReq
+RlcDatReq *datReq
)
#else
-PUBLIC Void kwUmmProcessSdus(gCb, rbCb, datReq)
+Void rlcUmmProcessSdus(gCb, rbCb, datReq)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwDatReq *datReq;
+RlcDatReq *datReq;
#endif
{
CmLList *firstNode; /* First Node in SDU queue */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- KwContSduLst contSduLst; /*Contained sduLst */
+ RlcContSduLst contSduLst; /*Contained sduLst */
S32 dataVol = rbCb->m.umDl.bo;
U32* totMacGrant= &(datReq->totMacGrant);
- KwL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh;
+ RlcL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh;
U8 *sduIdx = &dlIpThPut->lastSduIdx;
Bool newIdx = FALSE;
S32 oldBo;
- KwlchInfo lchInfo = {0};
+ RlclchInfo lchInfo = {0};
U32 segSduCnt = 0;
#endif
Ticks curTime = 0;
S16 timeDiff = 0;
- KwSdu *sdu;
+ RlcSdu *sdu;
- TRC2(kwUmmProcessSdus)
+ TRC2(rlcUmmProcessSdus)
pdu = NULLP;
#endif
/* Discard new changes starts */
- kwUtlGetCurrTime(&curTime);
+ rlcUtlGetCurrTime(&curTime);
/* ccpu00143043 */
while ((pduSz > 0) && (rbCb->m.umDl.sduQ.count > 0) &&
- (rbCb->m.umDl.numLi < KW_MAX_DL_LI) && (pduInfo->numPdu < KW_MAX_PDU))
+ (rbCb->m.umDl.numLi < RLC_MAX_DL_LI) && (pduInfo->numPdu < RLC_MAX_PDU))
{
CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,firstNode);
- sdu = (KwSdu *)(firstNode->node);
+ sdu = (RlcSdu *)(firstNode->node);
if ((sdu->mode.um.isSegmented == FALSE) && (rbCb->discTmrInt > 0) &&
(rbCb->rlcId.rbType == CM_LTE_DRB))
{
- timeDiff = KW_TIME_DIFF(curTime,sdu->arrTime);
+ timeDiff = RLC_TIME_DIFF(curTime,sdu->arrTime);
if (timeDiff >= rbCb->discTmrInt)
{
#ifdef LTE_L2_MEAS
- KW_UPD_L2_DL_DISC_SDU_STS(gCb, rbCb);
+ RLC_UPD_L2_DL_DISC_SDU_STS(gCb, rbCb);
#endif
rbCb->m.umDl.bo -= sdu->sduSz;
- KW_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
+ RLC_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
continue;
}
}
#endif
if (!pdu)
{
- KW_RMV_MAC_HDR_SZ(pduSz);
+ RLC_RMV_MAC_HDR_SZ(pduSz);
/* account for the RLC header size */
pduSz -= rbCb->m.umDl.snLen;
}
}
- kwUtlCalcLiForSdu(gCb,rbCb->m.umDl.numLi,sdu->sduSz,&pduSz);
+ rlcUtlCalcLiForSdu(gCb,rbCb->m.umDl.numLi,sdu->sduSz,&pduSz);
/* Exact fit scenario :
If the SDU size matches with the PDU size
pduSz = 0;
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb))
{
if(sdu->mode.um.isSegmented)
{
}
else
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.um.sduId, newIdx);
/* ccpu00143043 */
- if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX)
+ if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX)
{
lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime;
lchInfo.sduInfo[lchInfo.numSdus].isRetxPdu = FALSE;
#endif
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
if((rbCb->rbL2Cb.measOn & LKW_L2MEAS_DL_DELAY) ||
(rbCb->rbL2Cb.measOn & LKW_L2MEAS_UU_LOSS))
{
/* ccpu00143043 */
- if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX)
+ if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX)
{
lchInfo.arvlTime[lchInfo.numSdus] = sdu->arrTime;
lchInfo.numSdus++;
}
}
#endif /* LTE_L2_MEAS */
- KW_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); /* kw003.201 */
- kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId);
+ RLC_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); /* kw003.201 */
+ rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId);
- kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
+ rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
pdu = NULLP;
}
set pdu to NULL
else
place the msglen in li array and continue with the next SDU.
- -# If the number of PDUs is more than KW_MAX_PDU, return from
+ -# If the number of PDUs is more than RLC_MAX_PDU, return from
the function even if pduSize > 0.
*/
else if (sdu->sduSz < pduSz)
pduSz -= sdu->sduSz;
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
#endif /* LTE_L2_MEAS */
- if (sdu->sduSz < 2048 && rbCb->m.umDl.numLi < KW_MAX_DL_LI)
+ if (sdu->sduSz < 2048 && rbCb->m.umDl.numLi < RLC_MAX_DL_LI)
{
rbCb->m.umDl.li[(rbCb->m.umDl.numLi)++] = sdu->sduSz;
}
else
{
- kwUmmCreatePdu(gCb, rbCb, pdu, fi, pduInfo);
+ rlcUmmCreatePdu(gCb, rbCb, pdu, fi, pduInfo);
pdu = NULLP;
- if ( pduInfo->numPdu == KW_MAX_PDU)
+ if ( pduInfo->numPdu == RLC_MAX_PDU)
{
/* Could not transmit what MAC asked for because the number
* of PDUs to be transmitted has reached maximum. */
}
}
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) )
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) )
{
if(sdu->mode.um.isSegmented)
{
}
else
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.um.sduId, newIdx);
/* ccpu00143043 */
- if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX)
+ if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX)
{
lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime;
lchInfo.sduInfo[lchInfo.numSdus].isRetxPdu = FALSE;
}
}
#endif
- KW_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu);
+ RLC_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu);
/* kw005.201 ccpu00117318, updating the statistics */
- kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId);
+ rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId);
}
/* Segmentation scenario :
If size of SDU is greater than PDU size
SSegMsg(sdu->mBuf,pduSz,&remSdu);
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
+ if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
{
if(sdu->mode.um.isSegmented)
{
}
else
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.um.sduId, newIdx);
}
- if(KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb))
{
if(sdu->actSz == sdu->sduSz)
{
fi |= 1;
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, datReq, FALSE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, datReq, FALSE);
#endif /* LTE_L2_MEAS */
- kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
+ rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
pdu = NULLP;
}
/* kw005.201 added support for L2 Measurement */
{
if(--(rbCb->ueCb->numActRb[rbCb->qci]) == 0)
{
- rlcCb.kwL2Cb.numActUe[rbCb->qci]--;
+ rlcCb.rlcL2Cb.numActUe[rbCb->qci]--;
}
}
#endif /* LTE_L2_MEAS */
#ifdef LTE_L2_MEAS
- kwUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant);
+ rlcUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant);
/* Need to check into optimizing this code : TODO */
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && (lchInfo.numSdus != 0))
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && (lchInfo.numSdus != 0))
{
- KwL2MeasTb *l2MeasTb = kwUtlGetCurMeasTb(gCb, rbCb);
+ RlcL2MeasTb *l2MeasTb = rlcUtlGetCurMeasTb(gCb, rbCb);
/* ccpu00143043 */
/* Fix Klock warning */
if ((lchInfo.numSdus != 0) && (l2MeasTb != NULLP) &&
- (l2MeasTb->numLchInfo < KW_MAX_ACTV_DRB))
+ (l2MeasTb->numLchInfo < RLC_MAX_ACTV_DRB))
{
- cmMemcpy((U8 *) &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], (U8 *) &lchInfo, sizeof(KwlchInfo));
+ cmMemcpy((U8 *) &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], (U8 *) &lchInfo, sizeof(RlclchInfo));
l2MeasTb->numLchInfo++;
}
l2MeasTb->txSegSduCnt += segSduCnt;
*/
if (pduSz > 0 && pdu)
{
- if (pduInfo->numPdu != KW_MAX_PDU)
+ if (pduInfo->numPdu != RLC_MAX_PDU)
{
rbCb->m.umDl.numLi--;
- kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
+ rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
pdu = NULLP;
}
else
}
}
- kwUmmEstHdrSz(&rbCb->m.umDl);
+ rlcUmmEstHdrSz(&rbCb->m.umDl);
datReq->boRep.bo = rbCb->m.umDl.bo;
datReq->boRep.estHdrSz = rbCb->m.umDl.estHdrSz;
datReq->boRep.staPduPrsnt = FALSE;
if (rbCb->m.umDl.sduQ.count > 0)
{
datReq->boRep.oldestSduArrTime =
- ((KwSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime;
+ ((RlcSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime;
}
RETVOID;
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rlcDlUmmReEstablish
+Void rlcDlUmmReEstablish
(
RlcCb *gCb,
CmLteRlcId rlcId,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void rlcDlUmmReEstablish(gCb, rlcId, rbCb)
+Void rlcDlUmmReEstablish(gCb, rlcId, rbCb)
RlcCb *gCb;
CmLteRlcId rlcId;
Bool sendReEst;
TRC2(rlcDlUmmReEstablish)
- kwUmmFreeDlRbCb(gCb, rbCb);
+ rlcUmmFreeDlRbCb(gCb, rbCb);
rbCb->m.umDl.vtUs = 0;
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwUmmCreatePdu
+PRIVATE Void rlcUmmCreatePdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwPduInfo *datReqPduInfo
)
#else
-PRIVATE Void kwUmmCreatePdu(gCb, rbCb, pdu, fi, datReqPduInfo)
+PRIVATE Void rlcUmmCreatePdu(gCb, rbCb, pdu, fi, datReqPduInfo)
RlcCb *gCb;
RlcDlRbCb *rbCb;
Buffer *pdu;
KwPduInfo *datReqPduInfo
#endif
{
- KwSn sn; /* Sequence Number */
+ RlcSn sn; /* Sequence Number */
U32 liCount; /* LI count */
U8 e = 0; /* Extension Bit */
U32 count; /* Loop Counter */
* size of header = ( NumLi /2 ) * 3 + (NumLi % 2) * 2 + 2;
* where NumLi = Number of Length Indicators to be sent
*/
- U8 hdr[((KW_MAX_DL_LI >> 1) * 3) + ((KW_MAX_DL_LI & 0x01) << 1) + 2];
+ U8 hdr[((RLC_MAX_DL_LI >> 1) * 3) + ((RLC_MAX_DL_LI & 0x01) << 1) + 2];
U32 idx = 0; /* To index to the hdr array */
/* Note: idx is not checked against crossing the hdr array bound as
- * liCount will be < KW_MAX_DL_LI and as per the size calculated above;
+ * liCount will be < RLC_MAX_DL_LI and as per the size calculated above;
* idx cannot cross the array
*/
- TRC2(kwUmmCreatePdu)
+ TRC2(rlcUmmCreatePdu)
/* stats updated before for bytes sent before adding RLC headers */
- kwUtlIncrementGenStsBytesAndPdusSent(&gCb->genSts, pdu);
+ rlcUtlIncrementGenStsBytesAndPdusSent(&gCb->genSts, pdu);
sn = rbCb->m.umDl.vtUs;
liCount = rbCb->m.umDl.numLi;
- if(liCount > KW_MAX_DL_LI)
- liCount = KW_MAX_DL_LI;
+ if(liCount > RLC_MAX_DL_LI)
+ liCount = RLC_MAX_DL_LI;
/* if there are any LI's then set the first E bit */
if(liCount)
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwUmmEstHdrSz
+PRIVATE Void rlcUmmEstHdrSz
(
-KwUmDl *umDl
+RlcUmDl *umDl
)
#else
-PRIVATE Void kwUmmEstHdrSz(umDl)
-KwUmDl *umDl;
+PRIVATE Void rlcUmmEstHdrSz(umDl)
+RlcUmDl *umDl;
#endif
{
/* The header size is estimated as :
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmDiscSdu
+Void rlcUmmDiscSdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
U32 sduId
)
#else
-PUBLIC Void kwUmmDiscSdu(gCb,rbCb,sduId)
+Void rlcUmmDiscSdu(gCb,rbCb,sduId)
RlcCb *gCb;
RlcDlRbCb *rbCb;
U32 sduId;
{
CmLList *tmpNode; /* Temporary Node in SDU queue */
- TRC2(kwUmmDiscSdu)
+ TRC2(rlcUmmDiscSdu)
CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,tmpNode);
if (tmpNode)
{
- KwSdu *sdu = (KwSdu *)tmpNode->node;
+ RlcSdu *sdu = (RlcSdu *)tmpNode->node;
if (sdu->mode.um.sduId == sduId && sdu->mode.um.isSegmented == FALSE)
{
/* kw005.201 added support for L2 Measurement */
- KW_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
+ RLC_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
gCb->genSts.numSduDisc++;
}
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmFreeDlRbCb
+Void rlcUmmFreeDlRbCb
(
RlcCb *gCb,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmFreeDlRbCb(gCb,rbCb)
+Void rlcUmmFreeDlRbCb(gCb,rbCb)
RlcCb *gCb;
RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwUmmFreeDlRbCb)
+ TRC2(rlcUmmFreeDlRbCb)
/* cat the SDU queue to the to be freed list */
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.umDl.sduQ));
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlRaiseDlCleanupEvent(gCb);
RETVOID;
-} /* kwUmmFreeDlRbCb */
+} /* rlcUmmFreeDlRbCb */
/********************************************************************30**
End of file
Desc: Source code for RLC Unacknowledged mode assembly and
reassembly.This file contains following functions
- --kwUmmQSdu
- --kwUmmProcessSdus
- --kwUmmProcessPdus
- --kwUmmReAssembleSdus
+ --rlcUmmQSdu
+ --rlcUmmProcessSdus
+ --rlcUmmProcessPdus
+ --rlcUmmReAssembleSdus
--kwUmmReEstablish
File: kw_umm_ul.c
#include "kw.x" /* RLC layer */
#include "kw_ul.x"
-#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_UL)
+#define RLC_MODULE (RLC_DBGMASK_UM | RLC_DBGMASK_UL)
-PRIVATE S16 kwUmmExtractHdr ARGS ((RlcCb *gCb,
+PRIVATE S16 rlcUmmExtractHdr ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
- KwUmHdr *umHdr));
+ RlcUmHdr *umHdr));
-PRIVATE Void kwUmmReAssembleSdus ARGS ((RlcCb *gCb,
+PRIVATE Void rlcUmmReAssembleSdus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwUmRecBuf *umRecBuf));
+ RlcUmRecBuf *umRecBuf));
#ifndef TENB_ACC
#ifndef LTE_PAL_ENB
*
* @return Void
*/
-PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn)
+PRIVATE Void rlcUmmFindNextVRUR (RlcUmUl* umUl, RlcSn nextSn)
{
- KwSn ur = KW_UM_GET_VALUE(umUl->vrUr, *umUl);
+ RlcSn ur = RLC_UM_GET_VALUE(umUl->vrUr, *umUl);
- KwSn nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl);
+ RlcSn nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
while (ur < nextSnToCompare)
{
break;
}
nextSn = (nextSn + 1) & umUl->modBitMask;
- nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl);
+ nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
}
}
*
* @return Void
*/
-PRIVATE S16 kwUmmCheckSnInReordWindow (KwSn sn,
- CONSTANT KwUmUl* CONSTANT umUl)
+PRIVATE S16 rlcUmmCheckSnInReordWindow (RlcSn sn,
+ CONSTANT RlcUmUl* CONSTANT umUl)
{
- return (KW_UM_GET_VALUE(sn, *umUl) < KW_UM_GET_VALUE(umUl->vrUh, *umUl));
+ return (RLC_UM_GET_VALUE(sn, *umUl) < RLC_UM_GET_VALUE(umUl->vrUh, *umUl));
}
/**
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC Void kwUmmProcessPdus
+Void rlcUmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb, /* Rb Control Block */
U32 ttiCnt /* ttiCnt received from MAC */
)
#else
-PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo,ttiCnt)
+Void rlcUmmProcessPdus(rbCb,pduInfo,ttiCnt)
RlcCb *gCb;
RlcUlRbCb *rbCb; /* Rb Control Block */
KwPduInfo *pduInfo; /* Pdu data and related information */
#endif
#else
#ifdef ANSI
-PUBLIC Void kwUmmProcessPdus
+Void rlcUmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb, /* Rb Control Block */
KwPduInfo *pduInfo /* Pdu data and related information */
)
#else
-PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo)
+Void rlcUmmProcessPdus(rbCb,pduInfo)
RlcCb *gCb;
RlcUlRbCb *rbCb; /* Rb Control Block */
KwPduInfo *pduInfo; /* Pdu data and related information */
#endif
#endif
{
- KwSn *vrUh; /* vr(uh) */
- KwSn *vrUr; /* vr(ur) */
- KwSn *vrUx; /* vr(ux) */
+ RlcSn *vrUh; /* vr(uh) */
+ RlcSn *vrUr; /* vr(ur) */
+ RlcSn *vrUx; /* vr(ux) */
U16 curSn; /* Current Sequence Number */
U32 pduCount; /* PDU count */
U32 count; /* Loop counter */
- KwUmRecBuf **recBuf; /* UM Reception Buffer */
+ RlcUmRecBuf **recBuf; /* UM Reception Buffer */
Bool tmrRunning; /* Boolean for checking Tmr */
/* kw005.201 added support for L2 Measurement */
- TRC2(kwUmmProcessPdus)
+ TRC2(rlcUmmProcessPdus)
count = 0;
while (count < pduCount)
{
- KwSn ur;
- KwSn uh;
- KwSn seqNum;
+ RlcSn ur;
+ RlcSn uh;
+ RlcSn seqNum;
Buffer *pdu = pduInfo->mBuf[count];
- KwUmRecBuf *tmpRecBuf;
+ RlcUmRecBuf *tmpRecBuf;
gCb->genSts.pdusRecv++;
#ifndef RGL_SPECIFIC_CHANGES
#ifndef TENB_ACC
#endif
#endif
/* create a buffer to be later inserted into the reception buffer */
- RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tmpRecBuf == NULLP)
{
extern U32 rlculdrop;
rlculdrop++;
RLC_FREE_BUF(pdu);
- RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
/*Fix for CR ccpu00144030: If threshhold is hit then also count
*should be incrmented */
count++;
#endif
#endif
/* get the pdu header */
- if (kwUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr)))
+ if (rlcUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr)))
{
RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
"Header Extraction Failed UEID:%d CELLID:%d",
/* Header extraction is a problem.
* log an error and free the allocated memory */
/* ccpu00136940 */
- RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
SPutMsg(pdu);
count++;
/* kw005.201 ccpu00117318, updating the statistics */
curSn = tmpRecBuf->umHdr.sn;
/* Check if the PDU should be discarded or not */
- ur = KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL);
- uh = KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL);
- seqNum = KW_UM_GET_VALUE(curSn, KW_UMUL);
+ ur = RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL);
+ uh = RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL);
+ seqNum = RLC_UM_GET_VALUE(curSn, RLC_UMUL);
- if (((ur < seqNum) && (seqNum < uh) && (KW_UMUL.recBuf[curSn])) ||
+ if (((ur < seqNum) && (seqNum < uh) && (RLC_UMUL.recBuf[curSn])) ||
(seqNum < ur))
{
/* PDU needs to be discarded */
rbCb->rlcId.cellId);
RLC_FREE_BUF(pdu);
- RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
count++;
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.unexpPdusRecv++;
#ifdef LTE_L2_MEAS
/* kw006.201 ccpu00120058, reduced code complexity by adding new function */
- kwUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt);
+ rlcUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt);
#endif
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.bytesRecv += recBuf[curSn]->pduSz;
- if (!kwUmmCheckSnInReordWindow(curSn,&KW_UMUL))
+ if (!rlcUmmCheckSnInReordWindow(curSn,&RLC_UMUL))
{ /* currSn is outside re-ordering window */
- *vrUh = (curSn + 1) & KW_UMUL.modBitMask;
+ *vrUh = (curSn + 1) & RLC_UMUL.modBitMask;
/* re-assemble all pdus outside the modified re-ordering window */
/* the first SN is VR(UR) */
- if (!kwUmmCheckSnInReordWindow(*vrUr,&KW_UMUL))
+ if (!rlcUmmCheckSnInReordWindow(*vrUr,&RLC_UMUL))
{
/* TODO : should it be VR(UR) + 1 ?... check, earlier it was so */
- KwSn sn = *vrUr; /* SN's which need to be re-assembled */
- KwSn lowerEdge; /* to hold the lower-edge of the
+ RlcSn sn = *vrUr; /* SN's which need to be re-assembled */
+ RlcSn lowerEdge; /* to hold the lower-edge of the
re-ordering window */
/* The new value ov VR(UR) is the lower end of the window i
* and SN's still this value need to be re-assembled */
- *vrUr = (*vrUh - KW_UMUL.umWinSz) & KW_UMUL.modBitMask;
- lowerEdge = KW_UM_GET_VALUE(*vrUr ,KW_UMUL);
+ *vrUr = (*vrUh - RLC_UMUL.umWinSz) & RLC_UMUL.modBitMask;
+ lowerEdge = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
- while (KW_UM_GET_VALUE(sn, KW_UMUL) < lowerEdge)
+ while (RLC_UM_GET_VALUE(sn, RLC_UMUL) < lowerEdge)
{
if (recBuf[sn])
{
- kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
- RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+ rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
+ RLC_FREE_WC(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
recBuf[sn] = NULLP;
}
- sn = (sn + 1) & KW_UMUL.modBitMask;
+ sn = (sn + 1) & RLC_UMUL.modBitMask;
}
}
}
if (recBuf[*vrUr])
{
- KwSn sn = *vrUr;
- KwSn tSn = KW_UM_GET_VALUE(sn,KW_UMUL);
- KwSn tVrUr;
+ RlcSn sn = *vrUr;
+ RlcSn tSn = RLC_UM_GET_VALUE(sn,RLC_UMUL);
+ RlcSn tVrUr;
/* set VR(UR) to next SN > current VR(UR) which is not received */
- KwSn nextVrUr = (*vrUr + 1) & KW_UMUL.modBitMask;
- kwUmmFindNextVRUR(&KW_UMUL, nextVrUr);
+ RlcSn nextVrUr = (*vrUr + 1) & RLC_UMUL.modBitMask;
+ rlcUmmFindNextVRUR(&RLC_UMUL, nextVrUr);
/* re-assemble SDUs with SN < Vr(UR) */
- tVrUr = KW_UM_GET_VALUE(*vrUr,KW_UMUL);
+ tVrUr = RLC_UM_GET_VALUE(*vrUr,RLC_UMUL);
while (recBuf[sn] && tSn < tVrUr)
{
- kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
- RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+ rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
+ RLC_FREE_WC(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
recBuf[sn] = NULLP;
- sn = (sn + 1) & KW_UMUL.modBitMask;
- tSn = KW_UM_GET_VALUE(sn, KW_UMUL);
+ sn = (sn + 1) & RLC_UMUL.modBitMask;
+ tSn = RLC_UM_GET_VALUE(sn, RLC_UMUL);
}
}
- tmrRunning = kwChkTmr(gCb,(PTR)rbCb, KW_EVT_UMUL_REORD_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_UMUL_REORD_TMR);
if (tmrRunning)
{
- KwSn tVrUx = KW_UM_GET_VALUE(*vrUx, KW_UMUL);
- KwSn tVrUr = KW_UM_GET_VALUE(*vrUr ,KW_UMUL);
+ RlcSn tVrUx = RLC_UM_GET_VALUE(*vrUx, RLC_UMUL);
+ RlcSn tVrUr = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
- KwSn tVrUh = KW_UM_GET_VALUE(*vrUh, KW_UMUL);
+ RlcSn tVrUh = RLC_UM_GET_VALUE(*vrUh, RLC_UMUL);
- S16 ret = kwUmmCheckSnInReordWindow(*vrUx, &KW_UMUL);
+ S16 ret = rlcUmmCheckSnInReordWindow(*vrUx, &RLC_UMUL);
if ( (tVrUx <= tVrUr) || ((!ret) && (tVrUx != tVrUh)))
{
- kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
tmrRunning = FALSE;
}
}
if (!tmrRunning)
{
- if (KW_UM_GET_VALUE(*vrUh, KW_UMUL) > KW_UM_GET_VALUE(*vrUr, KW_UMUL))
+ if (RLC_UM_GET_VALUE(*vrUh, RLC_UMUL) > RLC_UM_GET_VALUE(*vrUr, RLC_UMUL))
{
- kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
*vrUx = *vrUh;
}
}
count++;
}/* end while count < pduCount */
#ifdef LTE_L2_MEAS
- kwUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
+ rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
#endif /* LTE_L2_MEAS */
RETVOID;
}
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwUmmReAssembleSdus
+PRIVATE Void rlcUmmReAssembleSdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwUmRecBuf *umRecBuf
+RlcUmRecBuf *umRecBuf
)
#else
-PRIVATE Void kwUmmReAssembleSdus(gCb,rbCb,umRecBuf)
+PRIVATE Void rlcUmmReAssembleSdus(gCb,rbCb,umRecBuf)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwUmRecBuf *umRecBuf;
+RlcUmRecBuf *umRecBuf;
#endif
{
U32 liCount; /* LI count */
Buffer *remPdu; /* Remaining PDU */
Buffer **partialSdu; /* Partial SDU */
- TRC2(kwUmmReAssembleSdus)
+ TRC2(rlcUmmReAssembleSdus)
liCount = umRecBuf->umHdr.numLi;
RLC_FREE_BUF(sdu);
if (liCount > 0 || !(fi & 1))
{
- kwUtlSndDatInd(gCb,rbCb,*partialSdu);
+ rlcUtlSndDatInd(gCb,rbCb,*partialSdu);
*partialSdu = NULLP;
}
}
if (liCount > 0 || !( fi & 1))
{
- kwUtlSndDatInd(gCb,rbCb,sdu);
+ rlcUtlSndDatInd(gCb,rbCb,sdu);
}
else
{
}
else
{
- kwUtlSndDatInd(gCb, rbCb, sdu);
+ rlcUtlSndDatInd(gCb, rbCb, sdu);
}
}
/*
just send the SDU to the upper layer */
else
{
- kwUtlSndDatInd(gCb, rbCb, sdu);
+ rlcUtlSndDatInd(gCb, rbCb, sdu);
}
}
rbCb->m.umUl.sn = sn;
* - If direction of the RB is downlink :
* Remove all the SDUs in the SDU queue.
* - If direction of the RB is uplink :
- * Call kwUmmReAssembleSdus() for each PDU with SN < VR(UH)
+ * Call rlcUmmReAssembleSdus() for each PDU with SN < VR(UH)
*
* @param[in] gCb RLC Instance control block
* @param[in] rlcID Identity of the RLC entity for which
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmUlReEstablish
+Void rlcUmmUlReEstablish
(
RlcCb *gCb,
CmLteRlcId *rlcId,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmUlReEstablish(gCb, rlcId, rbCb)
+Void rlcUmmUlReEstablish(gCb, rlcId, rbCb)
RlcCb *gCb;
CmLteRlcId *rlcId;
RlcUlRbCb *rbCb;
#endif
{
- KwSn curSn;
- KwSn vrUh;
- KwUmRecBuf **recBuf; /* UM Reception Buffer */
- KwKwuSapCb *kwKwSap; /* KWU SAP Information */
+ RlcSn curSn;
+ RlcSn vrUh;
+ RlcUmRecBuf **recBuf; /* UM Reception Buffer */
+ RlcKwuSapCb *rlcKwSap; /* KWU SAP Information */
- TRC2(kwUmmUlReEstablish)
+ TRC2(rlcUmmUlReEstablish)
curSn = rbCb->m.umUl.vrUr;
- vrUh = KW_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
+ vrUh = RLC_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
recBuf = rbCb->m.umUl.recBuf;
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
}
- while (KW_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh)
+ while (RLC_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh)
{
if ( recBuf[curSn] != NULLP )
{
- kwUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
- RLC_FREE_WC(gCb,recBuf[curSn],sizeof(KwUmRecBuf));
+ rlcUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
+ RLC_FREE_WC(gCb,recBuf[curSn],sizeof(RlcUmRecBuf));
recBuf[curSn] = NULLP;
}
curSn = (curSn + 1) & rbCb->m.umUl.modBitMask;
rbCb->m.umUl.vrUh = 0;
rbCb->m.umUl.vrUx = 0;
- kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP;
+ rlcKwSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
/* In the UM Mode always send reestablish-indication to Upper Latyer*/
- KwUiKwuReEstCmpInd(&kwKwSap->pst, kwKwSap->suId, *rlcId);
+ RlcUiKwuReEstCmpInd(&rlcKwSap->pst, rlcKwSap->suId, *rlcId);
RETVOID;
}
* -# FALSE
*/
#ifdef ANSI
-PRIVATE S16 kwUmmExtractHdr
+PRIVATE S16 rlcUmmExtractHdr
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
-KwUmHdr *umHdr
+RlcUmHdr *umHdr
)
#else
-PRIVATE S16 kwUmmExtractHdr(gCb, rbCb, pdu, umHdr)
+PRIVATE S16 rlcUmmExtractHdr(gCb, rbCb, pdu, umHdr)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *pdu;
-KwUmHdr *umHdr;
+RlcUmHdr *umHdr;
#endif
{
U8 e; /* Extension Bit */
S16 ret; /* Return Value */
#endif
- TRC3(kwUmmExtractHdr)
+ TRC3(rlcUmmExtractHdr)
SFndLenMsg(pdu,&pduSz);
umHdr->numLi = 0;
totalSz = 0;
- while(e && umHdr->numLi < KW_MAX_UL_LI )
+ while(e && umHdr->numLi < RLC_MAX_UL_LI )
{
#if (ERRCLASS & ERRCLS_DEBUG)
ret = SRemPreMsgMult(dst,2,pdu);
e = ((dst[0]) & 0x80) >> 7;
- if ( e && umHdr->numLi < KW_MAX_UL_LI)
+ if ( e && umHdr->numLi < RLC_MAX_UL_LI)
{
U8 tmp = ((dst[1]) & 0x08) >> 3;
umHdr->li[umHdr->numLi] = ( dst[1] & 0x07) << 8;
e = tmp;
}
- } /* while(e && umHdr->numLi < KW_MAX_LI ) */
+ } /* while(e && umHdr->numLi < RLC_MAX_LI ) */
if (e)
{
- /* PDU was constructed with LIs that exceeded KW_MAX_LI */
+ /* PDU was constructed with LIs that exceeded RLC_MAX_LI */
return RFAILED;
}
return ROK;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmReOrdTmrExp
+Void rlcUmmReOrdTmrExp
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmReOrdTmrExp(gCb, rbCb)
+Void rlcUmmReOrdTmrExp(gCb, rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwSn prevVrUr; /* prevVrUr */
+ RlcSn prevVrUr; /* prevVrUr */
- TRC3(kwUmmReOrdTmrExp)
+ TRC3(rlcUmmReOrdTmrExp)
- prevVrUr = KW_UMUL.vrUr;
+ prevVrUr = RLC_UMUL.vrUr;
/* set VR(UR) to SN >= VR(UX) that has not been received */
- kwUmmFindNextVRUR(&KW_UMUL, KW_UMUL.vrUx);
+ rlcUmmFindNextVRUR(&RLC_UMUL, RLC_UMUL.vrUx);
- while (KW_UM_GET_VALUE(prevVrUr,KW_UMUL) <
- KW_UM_GET_VALUE(KW_UMUL.vrUr,KW_UMUL))
+ while (RLC_UM_GET_VALUE(prevVrUr,RLC_UMUL) <
+ RLC_UM_GET_VALUE(RLC_UMUL.vrUr,RLC_UMUL))
{
- if (KW_UMUL.recBuf[prevVrUr])
+ if (RLC_UMUL.recBuf[prevVrUr])
{
- kwUmmReAssembleSdus(gCb, rbCb, KW_UMUL.recBuf[prevVrUr]);
- if(KW_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
+ rlcUmmReAssembleSdus(gCb, rbCb, RLC_UMUL.recBuf[prevVrUr]);
+ if(RLC_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
{
- RLC_FREE_BUF(KW_UMUL.recBuf[prevVrUr]->pdu);
+ RLC_FREE_BUF(RLC_UMUL.recBuf[prevVrUr]->pdu);
}
- RLC_FREE_WC(gCb, KW_UMUL.recBuf[prevVrUr], sizeof(KwUmRecBuf));
- KW_UMUL.recBuf[prevVrUr] = NULLP;
+ RLC_FREE_WC(gCb, RLC_UMUL.recBuf[prevVrUr], sizeof(RlcUmRecBuf));
+ RLC_UMUL.recBuf[prevVrUr] = NULLP;
}
prevVrUr = (prevVrUr + 1) & rbCb->m.umUl.modBitMask;
}
- if (KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL) >
- KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL))
+ if (RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL) >
+ RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL))
{
- kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
- KW_UMUL.vrUx = KW_UMUL.vrUh;
+ rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
+ RLC_UMUL.vrUx = RLC_UMUL.vrUh;
}
}
*/
#ifdef ANSI
-PUBLIC Void kwUmmFreeUlRbCb
+Void rlcUmmFreeUlRbCb
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmFreeUlRbCb(gCb,rbCb)
+Void rlcUmmFreeUlRbCb(gCb,rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwSn curSn = 0; /* sequence number of PDU */
- KwSn windSz; /* PDU window size */
- KwUmRecBuf **umRecBuf; /* UM module receive buffer */
+ RlcSn curSn = 0; /* sequence number of PDU */
+ RlcSn windSz; /* PDU window size */
+ RlcUmRecBuf **umRecBuf; /* UM module receive buffer */
- TRC2(kwUmmFreeUlRbCb)
+ TRC2(rlcUmmFreeUlRbCb)
windSz = rbCb->m.umUl.umWinSz << 1;
umRecBuf = rbCb->m.umUl.recBuf;
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
}
while (curSn < windSz)
{
RLC_FREE_BUF_WC(umRecBuf[curSn]->pdu);
umRecBuf[curSn]->pdu = NULLP;
- RLC_FREE_WC(gCb, umRecBuf[curSn], sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, umRecBuf[curSn], sizeof(RlcUmRecBuf));
umRecBuf[curSn] = NULLP;
}
curSn++;
}
- RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(KwUmRecBuf*));
+ RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(RlcUmRecBuf*));
rbCb->m.umUl.recBuf = NULLP;
RETVOID;
}
Desc: Source code for RLC Utility Module
This file contains following functions
- --kwUtlSndToLi
- --kwUtlRcvFrmLi
- --kwUtlEmptySduQ
- --kwUtlSndDStaRsp
- --kwUtlSndDatInd
+ --rlcUtlSndToLi
+ --rlcUtlRcvFrmLi
+ --rlcUtlEmptySduQ
+ --rlcUtlSndDStaRsp
+ --rlcUtlSndDatInd
--kwUtlShutDown
File: kw_utl_dl.c
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
extern U32 isDatReqProcessed;
#endif
-#define KW_MODULE (KW_DBGMASK_DUT | KW_DBGMASK_DL) /* for debugging purpose */
+#define RLC_MODULE (RLC_DBGMASK_DUT | RLC_DBGMASK_DL) /* for debugging purpose */
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)) || defined (SS_RBUF)
-EXTERN void kwUtlDlBatchProcHqStaInd ARGS ((Void));
+EXTERN void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
#endif
Void ResetRLCStats(Void)
{
RlcCb* dlInst = rlcCb[1];
RlcCb* ulInst = rlcCb[0];
cmMemset((U8*)&gRlcStats, 0, sizeof(RLCStats));
- cmMemset((U8*)&dlInst->genSts,0,sizeof(KwGenSts));
- cmMemset((U8*)&ulInst->genSts,0,sizeof(KwGenSts));
+ cmMemset((U8*)&dlInst->genSts,0,sizeof(RlcGenSts));
+ cmMemset((U8*)&ulInst->genSts,0,sizeof(RlcGenSts));
}
#ifndef ALIGN_64BIT
* This function stores DL PDU info for all logical channels
* of per UE grant per TTI and sends to MAC
*
- * Function : KwLiRguDDatReq
+ * Function : RlcLiRguDDatReq
*
* @params[in]
* @return ROK - success
*
* ****************************************************************/
#ifdef ANSI
-PUBLIC S16 KwLiRguDDatReq
+S16 RlcLiRguDDatReq
(
Pst *post,
SpId spId,
RguDDatReqInfo *datReqInfo
)
#else
-PUBLIC S16 KwLiRguDDatReq(post, spId, datReqInfo)
+S16 RlcLiRguDDatReq(post, spId, datReqInfo)
Pst *post;
SpId spId;
RguDDatReqInfo *datReqInfo;
RguLchDatReq datPerLch; /* DL data info per Lch */
RlcMacData *dlData; /* DL data to be sent to MAC */
- TRC3(KwLiRguDDatReq)
+ TRC3(RlcLiRguDDatReq)
dlData = NULLP;
RLC_ALLOC_SHRABL_BUF(post->region, post->pool,
datReqInfo, sizeof(RguDDatReqInfo));
return ROK;
-}/* End of KwLiRguDDatReq */
+}/* End of RlcLiRguDDatReq */
/**
*
*
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndToLi
+S16 rlcUtlSndToLi
(
RlcCb *gCb,
SuId suId,
KwDStaIndInfo *staIndInfo
)
#else
-PUBLIC S16 kwUtlSndToLi(gCb, suId, staIndInfo)
+S16 rlcUtlSndToLi(gCb, suId, staIndInfo)
RlcCb *gCb;
SuId suId;
KwDStaIndInfo *staIndInfo;
U32 count; /* Loop Counter */
U32 numTb; /* Number of Tbs */
RlcDlRbCb *rbCb; /* RB Control Block */
- KwDatReq datReq; /* PDUs Information */
+ RlcDatReq datReq; /* PDUs Information */
RguDDatReqInfo *datReqInfo; /* Data Request Information */
- KwRguSapCb *rguSap; /* MAC SAP CB */
+ RlcRguSapCb *rguSap; /* MAC SAP CB */
U32 totNumPdu; /* Total number of PDUS */
RguStaIndTb *staIndTb = NULLP;
RguDatReqTb *datReqTb = NULLP;
//Debug
U32 staIndSz=0,datIndSz = 0;
- TRC2(kwUtlSndToLi)
+ TRC2(rlcUtlSndToLi)
datReqInfo = NULLP;
{
staInd = &staIndInfo->staInd[idx];
/* Fetch Ue control block */
- if(ROK != kwDbmFetchDlUeCb(gCb,staInd->rnti,staIndInfo->cellId,&ueCb))
+ if(ROK != rlcDbmFetchDlUeCb(gCb,staInd->rnti,staIndInfo->cellId,&ueCb))
{
/* Fetch UeCb failed */
RLOG_ARG1(L_ERROR, DBG_CELLID,staIndInfo->cellId,
/* If ueCb is not found for current rnti then continue to look for next rnti*/
continue;
}
- /* kw002.201 Removed the allocation of KwDatReq */
+ /* kw002.201 Removed the allocation of RlcDatReq */
/* kw004.201 Used SSI function to initialize the variable */
- cmMemset( (U8 *)&datReq, 0, sizeof(KwDatReq) );
+ cmMemset( (U8 *)&datReq, 0, sizeof(RlcDatReq) );
totNumPdu = 0;
for (numTb = 0; numTb < staInd->nmbOfTbs; numTb++)
{
staIndTb = &(staInd->staIndTb[numTb]);
datReqTb = &(datReqInfo->datReq[idx].datReqTb[numTb]);
#ifdef LTE_L2_MEAS
- ueCb->tbIdx = (ueCb->tbIdx+1) % KW_MAX_TB_PER_UE;
+ ueCb->tbIdx = (ueCb->tbIdx+1) % RLC_MAX_TB_PER_UE;
#endif
for (count = 0;count < staIndTb->nmbLch; count++)
{
#ifdef LTE_L2_MEAS
datReq.totMacGrant = grantPerLch[staIndTb->lchStaInd[count].lcId];
#endif
- kwUtlGetCurrTime(&datReq.boRep.oldestSduArrTime);
+ rlcUtlGetCurrTime(&datReq.boRep.oldestSduArrTime);
if ( CM_LTE_MODE_UM == rbCb->mode )
{
- kwUmmProcessSdus(gCb,rbCb,&datReq);
+ rlcUmmProcessSdus(gCb,rbCb,&datReq);
}
else if ( CM_LTE_MODE_AM == rbCb->mode )
{
- kwAmmProcessSdus(gCb,rbCb,&datReq,staInd->fillCtrlPdu);
+ rlcAmmProcessSdus(gCb,rbCb,&datReq,staInd->fillCtrlPdu);
}
#ifdef LTE_L2_MEAS
grantPerLch[staIndTb->lchStaInd[count].lcId] = datReq.totMacGrant;
datIndSz += len;
}
datReqTb->lchData[count].setMaxUlPrio = FALSE;
- if (KW_AM_IS_POLL_BIT_SET(AMDL) &&
+ if (RLC_AM_IS_POLL_BIT_SET(AMDL) &&
(AMDL.sduQ.count > 1))
{
/* Poll bit is set indicate to MAC*/
datReqTb->lchData[count].boReport.oldestSduArrTime =
datReq.boRep.oldestSduArrTime;
/* kw004.201 Used SSI function to initialize the variable */
- cmMemset( (U8 *)&datReq, 0, sizeof(KwDatReq) );
+ cmMemset( (U8 *)&datReq, 0, sizeof(RlcDatReq) );
}
}
#ifdef LTE_L2_MEAS
}
else
{
- datReqTb->tbId = KW_INVALID_TBID;
+ datReqTb->tbId = RLC_INVALID_TBID;
}
#endif
datReqTb->nmbLch = staIndTb->nmbLch;
#ifdef LTE_L2_MEAS_LOSS_DELAY
if(tbSnMap->numSn == 0)
{
- RLC_FREE(tbSnMap,sizeof(KwTbSnMap));
+ RLC_FREE(tbSnMap,sizeof(RlcTbSnMap));
RLC_FREE(datReqTb->rguSnInfo,sizeof(RguSnMapInfo));
datReqTb->rguSnInfo = NULLP;
- rlcCb.kwL2Cb.curTbSnMap = NULLP;
+ rlcCb.rlcL2Cb.curTbSnMap = NULLP;
datReqTb->snMapPres = FALSE;
}
else
{
- cmHashListInsert(&(rlcCb.kwL2Cb.tbHlCp),(PTR)tbSnMap,
+ cmHashListInsert(&(rlcCb.rlcL2Cb.tbHlCp),(PTR)tbSnMap,
(U8 *) &(tbSnMap->tbId), (U16)sizeof(tbSnMap->tbId));
- rlcCb.kwL2Cb.curTbSnMap = NULLP;
+ rlcCb.rlcL2Cb.curTbSnMap = NULLP;
}
#endif /* LTE_L2_MEAS */
}
if(TRUE == gCb->init.trc )
{
/* Populate the trace params */
- kwLmmSendTrc(gCb,EVTRGUDDATREQ, NULLP);
+ rlcLmmSendTrc(gCb,EVTRGUDDATREQ, NULLP);
}
rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
//Debug
- KwLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo);
+ RlcLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo);
return ROK;
}
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndDStaRsp
+S16 rlcUtlSndDStaRsp
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
U32 staPduBo
)
#else
-PUBLIC S16 kwUtlSndDStaRsp(gCb,rbCb,bo,estHdrSz,staPduPrsnt,staPduBo)
+S16 rlcUtlSndDStaRsp(gCb,rbCb,bo,estHdrSz,staPduPrsnt,staPduBo)
RlcCb *gCb;
RlcDlRbCb *rbCb;
S32 bo;
#endif
{
RlcMacBOStatus boStatus; /* Buffer occupancy status information */
- KwRguSapCb *rguSap; /* MAC SAP Information */
- TRC3(kwUtlSndDStaRsp)
+ RlcRguSapCb *rguSap; /* MAC SAP Information */
+ TRC3(rlcUtlSndDStaRsp)
#ifndef TENB_ACC
if ((rbCb->lastRprtdBoToMac > (U32)8000) && (rbCb->boUnRprtdCnt < (U32)5)
&& (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP)))
if(gCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(gCb, EVTRLCBOSTA, NULLP);
+ rlcLmmSendTrc(gCb, EVTRLCBOSTA, NULLP);
}
/* Send Status Response to MAC layer */
RlcMacSendBOStatus(&rguSap->pst,rguSap->spId,&boStatus);
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
#ifdef ANSI
-PUBLIC Void kwUtlEmptySduQ
+Void rlcUtlEmptySduQ
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
CmLListCp *sduQ
)
#else
-PUBLIC Void kwUtlEmptySduQ(gCb,rbCb, sduQ)
+Void rlcUtlEmptySduQ(gCb,rbCb, sduQ)
RlcCb *gCb;
RlcDlRbCb *rbCb;
CmLListCp *sduQ;
#endif
#else
#ifdef ANSI
-PUBLIC Void kwUtlEmptySduQ
+Void rlcUtlEmptySduQ
(
RlcCb *gCb,
CmLListCp *sduQ
)
#else
-PUBLIC Void kwUtlEmptySduQ(gCb,sduQ)
+Void rlcUtlEmptySduQ(gCb,sduQ)
RlcCb *gCb;
CmLListCp *sduQ;
#endif
#ifdef LTE_L2_MEAS_RLC
CmLListCp *sduSnMapQ; /* SDU Sequence number map queue */
CmLList *firstSduSnMap; /* First Node in SDU SnMap Queue */
- KwSduSnMap *sduSnMap; /* SDU Sn Map */
+ RlcSduSnMap *sduSnMap; /* SDU Sn Map */
- TRC2(kwUtlEmptySduQ)
+ TRC2(rlcUtlEmptySduQ)
sduSnMapQ = NULLP;
firstSduSnMap = NULLP;
sduSnMap = NULLP;
while(firstSduSnMap)
{
- sduSnMap = (KwSduSnMap *)firstSduSnMap->node;
+ sduSnMap = (RlcSduSnMap *)firstSduSnMap->node;
if(sduSnMap != NULLP)
{
cmLListDelFrm(&(rbCb->sduSnMapQ), &(sduSnMap->lstEnt));
- RLC_FREE(sduSnMap, sizeof(KwSduSnMap));
+ RLC_FREE(sduSnMap, sizeof(RlcSduSnMap));
CM_LLIST_FIRST_NODE(sduSnMapQ, firstSduSnMap);
}
else
* @return void
*/
#ifdef ANSI
-PUBLIC Void kwUtlCalcLiForSdu
+Void rlcUtlCalcLiForSdu
(
RlcCb *gCb,
U16 numLi,
S16 *pduSz
)
#else
-PUBLIC Void kwUtlCalcLiForSdu(gCb,numLi,msgLen,pduSz)
+Void rlcUtlCalcLiForSdu(gCb,numLi,msgLen,pduSz)
RlcCb *gCb;
U16 numLi;
MsgLen msgLen;
S16 *pduSz;
#endif
{
- TRC2(kwUtlCalcLiForSdu)
+ TRC2(rlcUtlCalcLiForSdu)
- if ( (*pduSz > msgLen) && (msgLen < KW_2K_BYTE))
+ if ( (*pduSz > msgLen) && (msgLen < RLC_2K_BYTE))
{
- if(0 == (numLi & KW_BIT0)) /* check if number of LIs are odd or even */
+ if(0 == (numLi & RLC_BIT0)) /* check if number of LIs are odd or even */
{
/* if number of LI's are even 2 bytes needed */
*pduSz -= 2;
* @return void
*/
#ifdef ANSI
-PUBLIC Void rlcDlUtlSetReestInProgressForRB
+Void rlcDlUtlSetReestInProgressForRB
(
RlcCb *gCb,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
+Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
RlcCb *gCb;
RlcDlRbCb *rbCb;
#endif
{
rbCb->m.amDl.estHdrSz = 0;
- if(kwChkTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR))
+ if(rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
{
- kwStopTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
}
}
else
rbCb->m.umDl.estHdrSz= 0;
}
- kwUtlSndDStaRsp(gCb, rbCb, 0, 0, FALSE,0);
+ rlcUtlSndDStaRsp(gCb, rbCb, 0, 0, FALSE,0);
RETVOID;
}
* FALSE : Re-establishment is not in progress
*/
#ifdef ANSI
-PUBLIC Bool rlcDlUtlIsReestInProgress
+Bool rlcDlUtlIsReestInProgress
(
RlcDlRbCb *rbCb
)
#else
-PUBLIC Bool rlcDlUtlIsReestInProgress(rbCb)
+Bool rlcDlUtlIsReestInProgress(rbCb)
RlcDlRbCb *rbCb;
#endif
{
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rlcDlUtlResetReestInProgress
+Void rlcDlUtlResetReestInProgress
(
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void rlcDlUtlResetReestInProgress(rbCb)
+Void rlcDlUtlResetReestInProgress(rbCb)
RlcDlRbCb *rbCb;
#endif
{
* @return void
*/
#ifdef ANSI
-PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs
+Void rlcDlUtlSetReestInProgressForAllRBs
(
RlcCb *gCb,
RlcDlUeCb *ueCb
)
#else
-PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
+Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
RlcCb *gCb;
RlcDlUeCb *ueCb;
#endif
TRC2(rlcDlUtlSetReestInProgressForAllRBs)
- for(rbIdx = 0;rbIdx < KW_MAX_SRB_PER_UE;rbIdx++)
+ for(rbIdx = 0;rbIdx < RLC_MAX_SRB_PER_UE;rbIdx++)
{
if(ueCb->srbCb[rbIdx] != NULLP)
{
else
{
/* For SRB we just need to stop the poll re-transmit timer */
- if(kwChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], KW_EVT_AMDL_POLL_RETX_TMR))
+ if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR))
{
- kwStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], KW_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR);
}
}
}
}
- for(rbIdx = 0;rbIdx < KW_MAX_DRB_PER_UE;rbIdx++)
+ for(rbIdx = 0;rbIdx < RLC_MAX_DRB_PER_UE;rbIdx++)
{
if(ueCb->drbCb[rbIdx] != NULLP)
{
* in KWU SAP statistics
*
*
- * @param[in] kwuSap KWU SAP in which to increment the counter
+ * @param[in] rlckwuSap KWU SAP in which to increment the counter
*
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlIncrementKwuStsSduTx
+Void rlcUtlIncrementKwuStsSduTx
(
-KwKwuSapCb *kwuSap
+RlcKwuSapCb *rlckwuSap
)
#else
-PUBLIC Void kwUtlIncrementKwuStsSduTx(kwuSap)
-KwKwuSapCb *kwuSap;
+Void rlcUtlIncrementKwuStsSduTx(rlckwuSap)
+RlcKwuSapCb *rlckwuSap;
#endif
{
- kwuSap->sts.sduTx++;
+ rlckwuSap->sts.sduTx++;
RETVOID;
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlIncrementGenStsBytesAndPdusSent
+Void rlcUtlIncrementGenStsBytesAndPdusSent
(
-KwGenSts *genSts,
+RlcGenSts *genSts,
Buffer *pdu
)
#else
-PUBLIC Void kwUtlIncrementGenStsBytesAndPdusSent(genSts, pdu)
-KwGenSts *genSts;
+Void rlcUtlIncrementGenStsBytesAndPdusSent(genSts, pdu)
+RlcGenSts *genSts;
Buffer *pdu;
#endif
{
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlInitToBeFreed
+Void rlcUtlInitToBeFreed
(
RlcCb *gCb,
RlcDlDataToBeFreed *toBeFreed
)
#else
-PUBLIC Void kwUtlInitToBeFreed(gCb, toBeFreed)
+Void rlcUtlInitToBeFreed(gCb, toBeFreed)
RlcCb *gCb;
RlcDlDataToBeFreed *toBeFreed;
#endif
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlInitializeSelfPst
+Void rlcUtlInitializeSelfPst
(
RlcCb *gCb
)
#else
-PUBLIC Void kwUtlInitializeSelfPst(gCb)
+Void rlcUtlInitializeSelfPst(gCb)
RlcCb *gCb;
#endif
{
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlRaiseDlCleanupEvent
+Void rlcUtlRaiseDlCleanupEvent
(
RlcCb *gCb
)
#else
-PUBLIC Void kwUtlRaiseDlCleanupEvent(gCb)
+Void rlcUtlRaiseDlCleanupEvent(gCb)
RlcCb *gCb;
#endif
{
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlAddSduToBeFreedQueue
+Void rlcUtlAddSduToBeFreedQueue
(
RlcCb *gCb,
-KwSdu *sdu
+RlcSdu *sdu
)
#else
-PUBLIC Void kwUtlAddSduToBeFreedQueue(gCb, sdu)
+Void rlcUtlAddSduToBeFreedQueue(gCb, sdu)
RlcCb *gCb;
-KwSdu *sdu;
+RlcSdu *sdu;
#endif
{
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.sduLst), &(sdu->lstEnt));
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlAddReTxPduToBeFreedQueue
+Void rlcUtlAddReTxPduToBeFreedQueue
(
RlcCb *gCb,
-KwRetx *retx
+RlcRetx *retx
)
#else
-PUBLIC Void kwUtlAddReTxPduToBeFreedQueue(gCb, retx)
+Void rlcUtlAddReTxPduToBeFreedQueue(gCb, retx)
RlcCb *gCb;
-KwRetx *retx;
+RlcRetx *retx;
#endif
{
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.reTxLst), &(retx->lstEnt));
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlAddTxPduToBeFreedQueue
+Void rlcUtlAddTxPduToBeFreedQueue
(
RlcCb *gCb,
-KwTx *pdu
+RlcTx *pdu
)
#else
-PUBLIC Void kwUtlAddTxPduToBeFreedQueue(gCb, pdu)
+Void rlcUtlAddTxPduToBeFreedQueue(gCb, pdu)
RlcCb *gCb;
-KwTx *pdu;
+RlcTx *pdu;
#endif
{
pdu->rlsLnk.node = (PTR)pdu;
* - FALSE if all the data has been freed
*/
#ifdef ANSI
-PRIVATE Bool kwUtlFreeDlAmRbMemory
+PRIVATE Bool rlcUtlFreeDlAmRbMemory
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
U32 *toBeFreed
)
#else
-PRIVATE Bool kwUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
+PRIVATE Bool rlcUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
RlcCb *gCb;
RlcDlRbCb *rbCb;
U32 *toBeFreed
#endif
{
- KwRetx *retx; /* retransmission buffer */
- KwSn mTxNext; /* send state variable */
- KwTx *txBuf;
+ RlcRetx *retx; /* retransmission buffer */
+ RlcSn mTxNext; /* send state variable */
+ RlcTx *txBuf;
- TRC2(kwUtlFreeDlAmRbMemory)
+ TRC2(rlcUtlFreeDlAmRbMemory)
MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
/* TODO : to be checked changed from <= to < */
while ((0 < mTxNext) && *toBeFreed)
{
- txBuf = kwUtlGetTxBuf(AMDL.txBufLst, AMDL.txNextAck);
+ txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, AMDL.txNextAck);
if (txBuf && txBuf->pduLst.first)
{
while(txBuf->pduLst.first)
cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
- kwUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
+ rlcUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
if(gCb->u.dlCb->shutdownReceived == 0)
{
(*toBeFreed)--;
}
#ifndef LTE_TDD
- RLC_FREE(gCb,AMDL.txBufLst, (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE(gCb,AMDL.txBufLst, (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
#endif
- KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+ RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
while (retx && (*toBeFreed)) /* Till to be freed becomes 0 */
{
RLC_FREE_BUF(retx->seg);
cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
- RLC_FREE_WC(gCb, retx, sizeof(KwRetx));
+ RLC_FREE_WC(gCb, retx, sizeof(RlcRetx));
- KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+ RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
if(gCb->u.dlCb->shutdownReceived == 0)
{
(*toBeFreed)--;
RLC_FREE_SHRABL_BUF_WC(udxPst->region,
udxPst->pool,
AMDL.pStaPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
AMDL.pStaPdu = NULLP;
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlFreeDlMemory
+Void rlcUtlFreeDlMemory
(
RlcCb *gCb
)
#else
-PUBLIC Void kwUtlFreeDlMemory(gCb)
+Void rlcUtlFreeDlMemory(gCb)
RlcCb *gCb;
#endif
{
}
else
{
- if ((pToBeFreed->txLst.count + pToBeFreed->reTxLst.count + pToBeFreed->sduLst.count) > (3 * KW_MAX_TO_BE_FREED))
+ if ((pToBeFreed->txLst.count + pToBeFreed->reTxLst.count + pToBeFreed->sduLst.count) > (3 * RLC_MAX_TO_BE_FREED))
{
#if !defined(KWSELFPSTDLCLEAN) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)
if (isDatReqProcessed)
{
- toBeFreed = (2 *KW_MAX_TO_BE_FREED);
+ toBeFreed = (2 *RLC_MAX_TO_BE_FREED);
}
else
#endif
{
- toBeFreed = (3 *KW_MAX_TO_BE_FREED)/2;
+ toBeFreed = (3 *RLC_MAX_TO_BE_FREED)/2;
}
}
else
{
- toBeFreed = KW_MAX_TO_BE_FREED;
+ toBeFreed = RLC_MAX_TO_BE_FREED;
}
}
CmLListCp *lst;
while((lst->first) && toBeFreed)
#endif
{
- KwRetx* seg = (KwRetx *)(lst->first->node);
+ RlcRetx* seg = (RlcRetx *)(lst->first->node);
cmLListDelFrm(lst, lst->first);
RLC_FREE_BUF_WC(seg->seg);
- RLC_FREE_WC(gCb,seg, sizeof(KwRetx));
+ RLC_FREE_WC(gCb,seg, sizeof(RlcRetx));
toBeFreed--;
}
while((lst->first) && toBeFreed)
#endif
{
- KwTx* pdu = (KwTx *)(lst->first->node);
+ RlcTx* pdu = (RlcTx *)(lst->first->node);
cmLListDelFrm(lst, lst->first);
while(pdu->pduLst.first)
{
RLC_FREE_BUF_WC(pduInfo->pdu);
RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
- RLC_FREE_WC(gCb,pdu, sizeof(KwTx));
+ RLC_FREE_WC(gCb,pdu, sizeof(RlcTx));
toBeFreed--;
}
while((lst->first) && toBeFreed)
#endif
{
- KwSdu* sdu = (KwSdu *)(lst->first->node);
- KW_RMV_SDU(gCb, lst, sdu);
+ RlcSdu* sdu = (RlcSdu *)(lst->first->node);
+ RLC_RMV_SDU(gCb, lst, sdu);
toBeFreed--;
}
#endif
{
RlcDlRbCb* rbCb = (RlcDlRbCb *)(lst->first->node);
- Bool moreToBeFreed = kwUtlFreeDlAmRbMemory(gCb, rbCb,&toBeFreed);
+ Bool moreToBeFreed = rlcUtlFreeDlAmRbMemory(gCb, rbCb,&toBeFreed);
if(!moreToBeFreed)
{
cmLListDelFrm(lst, lst->first);
if ((toBeFreed == 0) && !(gCb->u.dlCb->shutdownReceived))
{
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlRaiseDlCleanupEvent(gCb);
}
RETVOID;
* @return Void
*
*/
-S16 kwUtlL2MeasDlInit(RlcCb *gCb)
+S16 rlcUtlL2MeasDlInit(RlcCb *gCb)
{
U16 cntr;
- gCb->u.dlCb->kwL2Cb.kwNumMeas=0;
+ gCb->u.dlCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- cmMemset((U8 *)&(gCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]), 0, sizeof(KwL2MeasEvtCb));
+ cmMemset((U8 *)&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
}
- gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_DL_DISC].measCb.measType = LKW_L2MEAS_DL_DISC;
- gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_DL_IP].measCb.measType = LKW_L2MEAS_DL_IP;
- gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_DL_DELAY].measCb.measType= LKW_L2MEAS_DL_DELAY;
- gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_UU_LOSS].measCb.measType= LKW_L2MEAS_UU_LOSS;
- gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_ACT_UE].measCb.measType= LKW_L2MEAS_ACT_UE;
+ 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;
+ gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_DELAY].measCb.measType= LKW_L2MEAS_DL_DELAY;
+ gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_UU_LOSS].measCb.measType= LKW_L2MEAS_UU_LOSS;
+ gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_ACT_UE].measCb.measType= LKW_L2MEAS_ACT_UE;
return ROK;
}
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlUpdateBurstSdus
+Void rlcUtlUpdateBurstSdus
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwContSduLst *contSduLst,
+RlcContSduLst *contSduLst,
S32 dataVol,
U32 schPduSz
)
#else
-PUBLIC Void kwUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
+Void rlcUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwContSduLst *contSduLst;
+RlcContSduLst *contSduLst;
S32 dataVol;
U32 schPduSz;
#endif
{
- KwL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
- KwL2MeasTb *l2MeasTb = NULLP;
+ RlcL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
+ RlcL2MeasTb *l2MeasTb = NULLP;
U8 idx;
U8 currTbIdx;
VOLATILE U32 startTime = 0;
- KwContSduLst *dstContSduLst;
- TRC2(kwUtlUpdateBurstSdus)
+ RlcContSduLst *dstContSduLst;
+ TRC2(rlcUtlUpdateBurstSdus)
/*starting Task*/
l2MeasDlIpThruput = &rbCb->l2MeasIpThruput.dlIpTh;
- if(KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
+ if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
{
if(dataVol > schPduSz)
{
}
if(l2MeasDlIpThruput->isBurstAct == TRUE)
{
- l2MeasTb = kwUtlGetCurMeasTb(gCb,rbCb);
+ l2MeasTb = rlcUtlGetCurMeasTb(gCb,rbCb);
/* Get the lChId from index 0, because index 0 is always for DL */
- if(l2MeasTb->numLcId >= KW_MAX_ACTV_DRB)
+ if(l2MeasTb->numLcId >= RLC_MAX_ACTV_DRB)
{
/* ccpu00143043 */
RETVOID;
dstContSduLst = &l2MeasTb->sduInfo[l2MeasTb->numLcId];
/* ccpu00143043 */
for(idx = 0; ((idx < contSduLst->numSdus)
- && (currTbIdx < KW_L2MEAS_MAX_OUTSTNGSDU)) ; idx++)
+ && (currTbIdx < RLC_L2MEAS_MAX_OUTSTNGSDU)) ; idx++)
{
dstContSduLst->sduIdx[currTbIdx++] = contSduLst->sduIdx[idx];
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlUpdateContainedSduLst
+Void rlcUtlUpdateContainedSduLst
(
U8 sduIdx,
-KwContSduLst *contSduLst
+RlcContSduLst *contSduLst
)
#else
-PUBLIC Void kwUtlUpdateContainedSduLst(sduIdx, contSduLst)
+Void rlcUtlUpdateContainedSduLst(sduIdx, contSduLst)
U8 sduIdx;
-KwContSduLst *contSduLst;
+RlcContSduLst *contSduLst;
#endif
{
- if (contSduLst->numSdus < KW_L2MEAS_MAX_OUTSTNGSDU)
+ if (contSduLst->numSdus < RLC_L2MEAS_MAX_OUTSTNGSDU)
{
contSduLst->sduIdx[contSduLst->numSdus] = sduIdx;
contSduLst->numSdus++;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlUpdateOutStandingSduLst
+Void rlcUtlUpdateOutStandingSduLst
(
-KwL2MeasDlIpTh *dlIpThPut,
+RlcL2MeasDlIpTh *dlIpThPut,
U8 sduIdx,
MsgLen sduLen,
U32 sduId,
Bool newIdx
)
#else
-PUBLIC Void kwUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
-KwL2MeasDlIpTh *dlIpThPut;
+Void rlcUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
+RlcL2MeasDlIpTh *dlIpThPut;
U8 sduIdx;
MsgLen sduLen;
U32 sduId;
Bool newIdx;
#endif
{
- if (sduIdx < KW_L2MEAS_MAX_OUTSTNGSDU)
+ if (sduIdx < RLC_L2MEAS_MAX_OUTSTNGSDU)
{
if(newIdx == TRUE)
{
RETVOID;
}
#ifdef ANSI
-PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb
+RlcL2MeasTb * rlcUtlGetCurMeasTb
(
RlcCb *gCb,
RlcDlRbCb *rbCb
)
#else
-PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb(gCb, rbCb)
+RlcL2MeasTb * rlcUtlGetCurMeasTb(gCb, rbCb)
RlcCb *gCb;
RlcDlRbCb *rbCb;
#endif
{
- KwL2MeasTb *curL2MeasTb;
+ RlcL2MeasTb *curL2MeasTb;
U16 idx;
- TRC3(kwUtlGetCurMeasTb)
+ TRC3(rlcUtlGetCurMeasTb)
if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
{
if (SGetSBuf(gCb->init.region,
gCb->init.pool,
(Data **)&curL2MeasTb,
- (Size)sizeof(KwL2MeasTb)) != ROK)
+ (Size)sizeof(RlcL2MeasTb)) != ROK)
{
return (NULLP);
}
curL2MeasTb->numLcId = 0;
curL2MeasTb->numLchInfo = 0;
curL2MeasTb->txSegSduCnt = 0;
- for (idx = 0; idx < KW_MAX_ACTV_DRB; idx++)
+ for (idx = 0; idx < RLC_MAX_ACTV_DRB; idx++)
{
curL2MeasTb->sduInfo[idx].numSdus = 0;
}
- for (idx = 0; idx < KW_MAX_ACTV_DRB; idx++)
+ for (idx = 0; idx < RLC_MAX_ACTV_DRB; idx++)
{
curL2MeasTb->lchInfo[idx].numSdus = 0;
}
*/
#ifdef ANSI
-PUBLIC S16 kwUtlProcHarqInd
+S16 rlcUtlProcHarqInd
(
RlcCb *gCb,
RguHarqStatusInd *hqStaInd,
U8 tbIdx
)
#else
-PUBLIC S16 kwUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
+S16 rlcUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
RlcCb *gCb;
RguHarqStatusInd *hqStaInd;
RlcDlUeCb *ueCb;
#endif
{
#ifdef LTE_L2_MEAS
- RlcDlRbCb *kwRbCb; /* KW Control Block */
- KwL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
+ RlcDlRbCb *rlcRbCb; /* KW Control Block */
+ RlcL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
U8 lcIdx; /* Logical channel id index */
U8 sduIndx; /* sdu index to out standing sdu list in rbCb */
U32 numSdus; /* number of sdus in the outstanding sdu list */
- KwOutStngSduInfo *outStngSduArr; /* Outstanding sdu list */
+ RlcOutStngSduInfo *outStngSduArr; /* Outstanding sdu list */
Ticks ackTime;
Ticks delay;
U32 totlSduCnt = 0;
VOLATILE U32 startTime = 0;
/*kw005.201 Code added for DL IP thruput measurement*/
- TRC3(kwUtlProcHarqInd)
+ TRC3(rlcUtlProcHarqInd)
/*starting Task*/
SStartTask(&startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
ret = ROK;
- if(hqStaInd->tbId[tbIdx] >= KW_INVALID_TBID)
+ if(hqStaInd->tbId[tbIdx] >= RLC_INVALID_TBID)
{
return ROK;
}
/* For each logical channel in the tbCb, process
* and get the DL IP thruput */
ackTime = SGetTtiCount();
- for(lcIdx = 0; ((lcIdx < l2MeasTb->numLcId) && (lcIdx < KW_MAX_ACTV_DRB)); lcIdx++)
+ for(lcIdx = 0; ((lcIdx < l2MeasTb->numLcId) && (lcIdx < RLC_MAX_ACTV_DRB)); lcIdx++)
{
timeAddedFlag = FALSE;
- if((kwRbCb = ueCb->lCh[l2MeasTb->sduInfo[lcIdx].lcId - 1].dlRbCb)
+ if((rlcRbCb = ueCb->lCh[l2MeasTb->sduInfo[lcIdx].lcId - 1].dlRbCb)
== NULLP)
{
continue;
}
/* fix for DL IP stop*/
- if (!gCb->u.dlCb->kwL2Cb.measOn[kwRbCb->qci]
- || (kwRbCb->rlcId.rbType == CM_LTE_SRB))
+ if (!gCb->u.dlCb->rlcL2Cb.measOn[rlcRbCb->qci]
+ || (rlcRbCb->rlcId.rbType == CM_LTE_SRB))
{
continue;
}
* and check for HARQ ACK/NACK */
numSdus = l2MeasTb->sduInfo[lcIdx].numSdus;
/* ccpu00143043 */
- if ((numSdus >= KW_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
+ if ((numSdus >= RLC_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
{
break;
}
totlSduCnt += numSdus;
- if (KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,kwRbCb))
+ if (RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rlcRbCb))
{
for(sduIndx = 0; sduIndx < numSdus; sduIndx++)
{
- outStngSduArr =&(kwRbCb->l2MeasIpThruput.dlIpTh.outStngSduArr[\
+ outStngSduArr =&(rlcRbCb->l2MeasIpThruput.dlIpTh.outStngSduArr[\
l2MeasTb->sduInfo[lcIdx].sduIdx[sduIndx]]);
if(hqStaInd->status[tbIdx] == TRUE)
{
/* If ACK is for burst End Sdu Id set burstActive
* to FALSE and accumulate time */
- if((kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId ==
+ if((rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId ==
outStngSduArr->sduId) && (outStngSduArr->numTb == 1))
{
- kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
+ rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
/*Update the l2Sts structure for calculating throughput*/
- kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.volSummation
+ rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.volSummation
+= outStngSduArr->sduLen;
- kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.timeSummation
- += glblTtiCnt - kwRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
+ rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.timeSummation
+ += glblTtiCnt - rlcRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
outStngSduArr->sduId = 0;
outStngSduArr->sduLen = 0;
outStngSduArr->numTb = 0;
- kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
+ rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
}
/* If burst is active and this sdu is only transmitted in single TB then
* accumulate volume and clear the outstanding sduList */
- if((kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE) &&
+ if((rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE) &&
(--(outStngSduArr->numTb) == 0))
{
- kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.volSummation
+ rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.volSummation
+= outStngSduArr->sduLen;
if(timeAddedFlag == FALSE)
{
- kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.timeSummation
- += glblTtiCnt - kwRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
- kwRbCb->l2MeasIpThruput.dlIpTh.burstStartTime = glblTtiCnt;
+ rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.timeSummation
+ += glblTtiCnt - rlcRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
+ rlcRbCb->l2MeasIpThruput.dlIpTh.burstStartTime = glblTtiCnt;
timeAddedFlag = TRUE;
}
outStngSduArr->sduId = 0;
}/* End of status == TRUE */
else
{
- if(kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE)
+ if(rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE)
{
- if((kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId ==
+ if((rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId ==
outStngSduArr->sduId))
{
- kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
- kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
+ rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
+ rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
}
/* Clear the outstanding sdu list */
outStngSduArr->sduId = 0;
}
}
- for(lcIdx = 0; ((lcIdx < l2MeasTb->numLchInfo) && (lcIdx < KW_MAX_ACTV_DRB)); lcIdx++)
+ for(lcIdx = 0; ((lcIdx < l2MeasTb->numLchInfo) && (lcIdx < RLC_MAX_ACTV_DRB)); lcIdx++)
{
- if((kwRbCb = ueCb->lCh[l2MeasTb->lchInfo[lcIdx].lcId - 1].dlRbCb)
+ if((rlcRbCb = ueCb->lCh[l2MeasTb->lchInfo[lcIdx].lcId - 1].dlRbCb)
== NULLP)
{
continue;
continue;
}
/* ccpu00143043 */
- if ((numSdus > KW_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
+ if ((numSdus > RLC_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
{
break;
}
{
for(sduIndx = 0; sduIndx < numSdus; sduIndx++)
{
- delay = KW_TIME_DIFF(ackTime,l2MeasTb->lchInfo[lcIdx].sduInfo[sduIndx].arvlTime);
- KW_UPD_PDCP_L2_DLDELAY_STS(gCb,kwRbCb, delay);
+ delay = RLC_TIME_DIFF(ackTime,l2MeasTb->lchInfo[lcIdx].sduInfo[sduIndx].arvlTime);
+ RLC_UPD_PDCP_L2_DLDELAY_STS(gCb,rlcRbCb, delay);
}
/* Case of sduInfo not updated */
if (totlSduCnt == 0)
{
totlSduCnt = numSdus;
}
- KW_UPD_L2_UU_LOSS_POS_PKTS(gCb,kwRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
+ RLC_UPD_L2_UU_LOSS_POS_PKTS(gCb,rlcRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
}
else
{
{
totlSduCnt = numSdus;
}
- KW_UPD_L2_UU_LOSS_PKTS(gCb,kwRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
+ RLC_UPD_L2_UU_LOSS_PKTS(gCb,rlcRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
}
}
/* Free this tb, deallocate the memory */
- RLC_FREE(gCb, l2MeasTb, sizeof(KwL2MeasTb));
+ RLC_FREE(gCb, l2MeasTb, sizeof(RlcL2MeasTb));
ueCb->l2MeasTbCb[hqStaInd->tbId[tbIdx]] = NULLP;
/*stopping Task*/
SStopTask(startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
return (ret);
-}/* end of kwUtlProcHarqInd */
+}/* end of rlcUtlProcHarqInd */
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndDlL2MeasCfm
+S16 rlcUtlSndDlL2MeasCfm
(
RlcCb *gCb,
-KwL2MeasEvtCb *measEvtCb
+RlcL2MeasEvtCb *measEvtCb
)
#else
-PUBLIC S16 kwUtlSndDlL2MeasCfm(gCb, measEvtCb)
+S16 rlcUtlSndDlL2MeasCfm(gCb, measEvtCb)
RlcCb *gCb;
-KwL2MeasEvtCb *measEvtCb;
+RlcL2MeasEvtCb *measEvtCb;
#endif
{
U32 qciIdx;
- KwL2MeasCb *measCb = NULLP;
- KwL2MeasCfmEvt measCfmEvt;
+ RlcL2MeasCb *measCb = NULLP;
+ RlcL2MeasCfmEvt measCfmEvt;
U32 posPkts;
U32 dLoss;
U32 cfmIdx =0;
/* Discard new changes ends */
- TRC3(kwUtlSndL2MeasCfm)
+ TRC3(rlcUtlSndL2MeasCfm)
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
- RLOG1(L_DEBUG,"kwUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
+ RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
#else
- RLOG1(L_DEBUG,"kwUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
+ RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
#endif
/* Clean up the RB data structures */
measCb = &measEvtCb->measCb;
- cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt));
+ cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
measCfmEvt.transId = measEvtCb->transId;
measCfmEvt.measType = measCb->measType;
if(measCb->measType & LKW_L2MEAS_DL_IP)
{
- KwL2MeasCbUeMeasInfo *pUeInfoLstCb = measCb->val.ipThMeas.ueInfoLst;
- KwL2MeasCfmUeInfoLst *pUeInfoLstCfm = measCfmEvt.val.ipThMeas.ueInfoLst;
+ RlcL2MeasCbUeMeasInfo *pUeInfoLstCb = measCb->val.ipThMeas.ueInfoLst;
+ RlcL2MeasCfmUeInfoLst *pUeInfoLstCfm = measCfmEvt.val.ipThMeas.ueInfoLst;
for(cntr = 0;(cntr < measCb->val.ipThMeas.numUes) && (cntr < gCb->genCfg.maxUe);cntr++)
{
dlDataVol = pUeInfoLstCb[cntr].measData[qci].dlIpThruput.volSummation;
dlTime = pUeInfoLstCb[cntr].measData[qci].dlIpThruput.timeSummation;
- if((0 == dlTime) || !(gCb->u.dlCb->kwL2Cb.measOn[qci] & LKW_L2MEAS_DL_IP) )
+ if((0 == dlTime) || !(gCb->u.dlCb->rlcL2Cb.measOn[qci] & LKW_L2MEAS_DL_IP) )
{
pUeInfoLstCfm[cfmIdx].measCfm[pUeInfoLstCfm[cfmIdx].numCfm].val.ipThrput.dlIpThPut = 0;
}
}
else
{
- KwL2Cntr *pMeasData = measCb->val.nonIpThMeas.measData;
- KwL2MeasCfmNonIpThMeas *pMeasCfmNonIp = &measCfmEvt.val.nonIpThMeas;
+ RlcL2Cntr *pMeasData = measCb->val.nonIpThMeas.measData;
+ RlcL2MeasCfmNonIpThMeas *pMeasCfmNonIp = &measCfmEvt.val.nonIpThMeas;
pMeasCfmNonIp->numCfm = 0;
}
}
/* Fix Klock warning */
- KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
+ RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
return ROK;
-} /* kwUtlSndL2MeasCfm */
+} /* rlcUtlSndL2MeasCfm */
/**
*
* @brief Handler for Sending Negative confirm .
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndDlL2MeasNCfm
+S16 rlcUtlSndDlL2MeasNCfm
(
RlcCb *gCb,
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt
)
#else
-PUBLIC S16 kwUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
+S16 rlcUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
RlcCb *gCb;
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
- TRC3(kwUtlSndDlL2MeasNCfm)
+ TRC3(rlcUtlSndDlL2MeasNCfm)
- KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
+ RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
return ROK;
} /* kwUtlSndL2MeasNCfm */
/**
*/
#ifdef ANSI
-PUBLIC Void kwUtlResetDlL2MeasInKwRb
+Void rlcUtlResetDlL2MeasInRlcRb
(
RlcCb *gCb,
-KwL2MeasCb *measCb,
+RlcL2MeasCb *measCb,
U8 measType
)
#else
-PUBLIC Void kwUtlResetDlL2MeasInKwRb(gCb, measCb, measType)
+Void rlcUtlResetDlL2MeasInRlcRb(gCb, measCb, measType)
RlcCb *gCb;
-KwL2MeasCb *measCb;
+RlcL2MeasCb *measCb;
U8 measType;
#endif
{
{
measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[qciIdx].dlIpThruput.volSummation = 0;
measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[qciIdx].dlIpThruput.timeSummation = 0;
- gCb->u.dlCb->kwL2Cb.measOn[qciIdx] &= ~measType;
+ gCb->u.dlCb->rlcL2Cb.measOn[qciIdx] &= ~measType;
}
}
- if(ROK != kwDbmFetchDlUeCb(gCb,measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
+ if(ROK != rlcDbmFetchDlUeCb(gCb,measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId, &ueCb))
{
continue;
}
measCb->val.nonIpThMeas.numQci = 0;
}
-} /* kwUtlResetDlL2MeasInKwRb */
+} /* rlcUtlResetDlL2MeasInRlcRb */
#endif
PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
else if(dlRbCb->mode == CM_LTE_MODE_AM)
{
U32 j, numTxPdus=0;
- for(j = 0; j <= (KW_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
+ for(j = 0; j <= (RLC_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
{
- KwTx *txBuf = kwUtlGetTxBuf(dlRbCb->m.amDl.txBufLst, j);
+ RlcTx *txBuf = rlcUtlGetTxBuf(dlRbCb->m.amDl.txBufLst, j);
if(txBuf != NULLP)
{
numTxPdus++;
(PTR *)&ueCb))
{
U32 i;
- for(i = 0; i< KW_MAX_SRB_PER_UE; i++)
+ for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
{
RlcDlRbCb* dlRbCb = ueCb->srbCb[i];
if( dlRbCb != NULLP)
dumpRLCDlRbInformation(dlRbCb);
}
}
- for(i = 0; i< KW_MAX_DRB_PER_UE; i++)
+ for(i = 0; i< RLC_MAX_DRB_PER_UE; i++)
{
RlcDlRbCb* dlRbCb = ueCb->drbCb[i];
if( dlRbCb != NULLP)
*/
#ifdef ANSI
-void kwUtlFreeDlMem
+void rlcUtlFreeDlMem
(
Void
)
#else
-void kwUtlFreeDlMem()
+void rlcUtlFreeDlMem()
Void;
#endif
{
- kwUtlFreeDlMemory(RLC_GET_RLCCB(KW_DL_INST));
+ rlcUtlFreeDlMemory(RLC_GET_RLCCB(RLC_DL_INST));
}
/**
*/
#ifdef ANSI
-void kwUtlGetCurrTime
+void rlcUtlGetCurrTime
(
U32 *currTime
)
#else
-void kwUtlGetCurrTime(U32 *currTime)
+void rlcUtlGetCurrTime(U32 *currTime)
U32 *currTime;
#endif
{
- TRC2(kwUtlGetCurrTime)
+ TRC2(rlcUtlGetCurrTime)
/* Need t define else part for PAL */
*currTime = SGetTtiCount();
#if defined(MAC_RLC_HARQ_STA_RBUF) || defined (SS_RBUF)
#ifdef LTE_L2_MEAS
#ifdef ANSI
-void kwUtlDlBatchProcHqStaInd
+void rlcUtlDlBatchProcHqStaInd
(
Void
)
#else
-void kwUtlDlBatchProcHqStaInd()
+void rlcUtlDlBatchProcHqStaInd()
Void;
#endif
{
while(NULLP != elmIndx)
{
staInd = (RguHarqStaInd *)elmIndx;
- KwLiRguHqStaInd(&(staInd->pst), 0, &(staInd->hqStatusInd));
+ RlcLiRguHqStaInd(&(staInd->pst), 0, &(staInd->hqStatusInd));
elmIndx = NULLP;
staInd = NULLP;
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlTrigPdbFlowCntrl
+Void rlcUtlTrigPdbFlowCntrl
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
U32 pktAdmitCnt
)
#else
-PUBLIC Void kwUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
+Void rlcUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
RlcCb *gCb;
RlcDlRbCb *rbCb;
U32 pktAdmitCnt;
#endif
{
KwuFlowCntrlIndInfo *flowCntrlInfo;
- KwKwuSapCb* kwuSap;
+ RlcKwuSapCb* rlckwuSap;
- kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
+ rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
- RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
- kwuSap->pst.pool,
+ RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region,
+ rlckwuSap->pst.pool,
flowCntrlInfo,
sizeof(KwuFlowCntrlIndInfo));
flowCntrlInfo->rlcId = rbCb->rlcId;
flowCntrlInfo->pktAdmitCnt = pktAdmitCnt;
- KwUiKwuFlowCntrlInd(&kwuSap->pst, kwuSap->suId, flowCntrlInfo);
+ RlcUiKwuFlowCntrlInd(&rlckwuSap->pst, rlckwuSap->suId, flowCntrlInfo);
}
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlStoreTxBuf
+Void rlcUtlStoreTxBuf
(
CmLListCp *txBufLst,
-KwTx *txBuf,
-KwSn sn
+RlcTx *txBuf,
+RlcSn sn
)
#else
-PUBLIC Void kwUtlStoreTxBuf(txBufLst, txBuf, sn)
+Void rlcUtlStoreTxBuf(txBufLst, txBuf, sn)
CmLListCp *txBufLst;
-KwTx *txBuf;
-KwSn sn;
+RlcTx *txBuf;
+RlcSn sn;
#endif
{
U32 hashKey;
TRC3(kwUtlStoretxBuf)
//printf("S-sn(%d)\n", sn);
- hashKey = (sn % KW_TX_BUF_BIN_SIZE );
+ hashKey = (sn % RLC_TX_BUF_BIN_SIZE );
txBuf->sn = sn;
txBuf->lnk.node = (PTR)txBuf;
cmLListAdd2Tail(&(txBufLst[hashKey]), &txBuf->lnk);
RETVOID;
-} /* kwUtlStoreRecBuf */
+} /* rlcUtlStoreRecBuf */
/**
*
* @return Void
*/
#ifdef ANSI
-PUBLIC KwTx* kwUtlGetTxBuf
+RlcTx* rlcUtlGetTxBuf
(
CmLListCp *txBufLst,
-KwSn sn
+RlcSn sn
)
#else
-PUBLIC KwTx* kwUtlGetTxBuf(txBufLst, sn)
+RlcTx* rlcUtlGetTxBuf(txBufLst, sn)
CmLListCp *txBufLst;
-KwSn sn;
+RlcSn sn;
#endif
{
U32 hashKey;
CmLListCp *txBufLstCp;
- KwTx *txBuf;
+ RlcTx *txBuf;
CmLList *node = NULLP;
- TRC3(kwUtlGetTxBuf)
+ TRC3(rlcUtlGetTxBuf)
//printf("G-sn(%d)\n", sn);
- hashKey = (sn % KW_TX_BUF_BIN_SIZE );
+ hashKey = (sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
CM_LLIST_FIRST_NODE(txBufLstCp, node);
while(node)
{
- txBuf = (KwTx *) node->node;
+ txBuf = (RlcTx *) node->node;
if(txBuf->sn == sn)
{
return (txBuf);
CM_LLIST_NEXT_NODE(txBufLstCp, node);
}
return (NULLP);
-} /* kwUtlStoreTxBuf */
+} /* rlcUtlStoreTxBuf */
/**
*
* @brief Delete the DL buffer from the list
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlDelTxBuf
+Void rlcUtlDelTxBuf
(
CmLListCp *txBufLst,
-KwTx *txBuf,
+RlcTx *txBuf,
RlcCb *gCb
)
#else
-PUBLIC Void kwUtlDelTxBuf(txBufLst, txBuf, gCb)
+Void rlcUtlDelTxBuf(txBufLst, txBuf, gCb)
CmLListCp *txBufLst;
-KwTx *txBuf;
+RlcTx *txBuf;
RlcCb *gCb;
#endif
{
U32 hashKey;
CmLListCp *txBufLstCp;
- TRC3(kwUtlDelTxBuf)
+ TRC3(rlcUtlDelTxBuf)
- hashKey = (txBuf->sn % KW_TX_BUF_BIN_SIZE );
+ hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
- RLC_FREE_WC(gCb, txBuf, sizeof(KwTx));
+ RLC_FREE_WC(gCb, txBuf, sizeof(RlcTx));
RETVOID;
-} /* kwUtlDelTxBuf */
+} /* rlcUtlDelTxBuf */
/**
*
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlRemovTxBuf
+Void rlcUtlRemovTxBuf
(
CmLListCp *txBufLst,
-KwTx *txBuf,
+RlcTx *txBuf,
RlcCb *gCb
)
#else
-PUBLIC Void kwUtlRemovTxBuf(txBufLst, txBuf, gCb)
+Void rlcUtlRemovTxBuf(txBufLst, txBuf, gCb)
CmLListCp *txBufLst;
-KwTx *txBuf;
+RlcTx *txBuf;
RlcCb *gCb;
#endif
{
U32 hashKey;
CmLListCp *txBufLstCp;
- TRC3(kwUtlRemovTxBuf)
+ TRC3(rlcUtlRemovTxBuf)
- hashKey = (txBuf->sn % KW_TX_BUF_BIN_SIZE );
+ hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
RETVOID;
-} /* kwUtlRemovTxBuf */
+} /* rlcUtlRemovTxBuf */
Desc: Source code for RLC Utility Module
This file contains following functions
- --kwUtlSndToLi
- --kwUtlRcvFrmLi
- --kwUtlEmptySduQ
- --kwUtlSndDatInd
+ --rlcUtlSndToLi
+ --rlcUtlRcvFrmLi
+ --rlcUtlEmptySduQ
+ --rlcUtlSndDatInd
--kwUtlShutDown
File: kw_utl_ul.c
#include "ss_rbuf.h"
#include "ss_rbuf.x"
#ifdef SS_RBUF
-PUBLIC S16 SMrkUlPkt(Buffer *mbuf);
+S16 SMrkUlPkt(Buffer *mbuf);
#endif
-PUBLIC KwAmRecBuf* kwUtlGetRecBuf(CmLListCp *recBufLst, KwSn sn);
-#define KW_MODULE (KW_DBGMASK_DUT | KW_DBGMASK_UL) /* for debugging purpose */
+RlcAmRecBuf* rlcUtlGetRecBuf(CmLListCp *recBufLst, RlcSn sn);
+#define RLC_MODULE (RLC_DBGMASK_DUT | RLC_DBGMASK_UL) /* for debugging purpose */
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwUtlRcvFrmLi
+S16 rlcUtlRcvFrmLi
(
RlcCb *gCb,
KwDatIndInfo *datIndInfo
)
#else
-PUBLIC S16 kwUtlRcvFrmLi(gCb,datIndInfo)
+S16 rlcUtlRcvFrmLi(gCb,datIndInfo)
RlcCb *gCb;
KwDatIndInfo *datIndInfo;
#endif
RlcUlUeCb *ueCb; /* UE Control Block */
/* kw005.201 added support for L2 Measurement */
- TRC2(kwUtlRcvFrmLi)
+ TRC2(rlcUtlRcvFrmLi)
ueCb = NULLP;
/* fetch UeCb */
- if( ROK != kwDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
+ if( ROK != rlcDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
{
/* Fetch UeCb failed */
RLOG_ARG1(L_ERROR,DBG_CELLID,datIndInfo->cellId,
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- kwUmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
+ rlcUmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
#else
- kwUmmProcessPdus(gCb,rbCb,pduInfo);
+ rlcUmmProcessPdus(gCb,rbCb,pduInfo);
#endif
}
else if (rbCb->mode == CM_LTE_MODE_AM )
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- kwAmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
+ rlcAmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
#else
- kwAmmProcessPdus(gCb,rbCb,pduInfo);
+ rlcAmmProcessPdus(gCb,rbCb,pduInfo);
#endif
}
}
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndDatInd
+S16 rlcUtlSndDatInd
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *sdu
)
#else
-PUBLIC S16 kwUtlSndDatInd(gCb,rbCb,sdu)
+S16 rlcUtlSndDatInd(gCb,rbCb,sdu)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *sdu;
KwuDatIndInfo datIndInfoTmp;
#endif
- TRC3(kwUtlSndDatInd)
+ TRC3(rlcUtlSndDatInd)
#ifndef KW_PDCP
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- KW_MEM_CPY(&(datIndInfo->rlcId),&(rbCb->rlcId),sizeof(CmLteRlcId));
+ RLC_MEM_CPY(&(datIndInfo->rlcId),&(rbCb->rlcId),sizeof(CmLteRlcId));
/* Set the "isOutofSeq" flag for each packet
* If packets are in-sequence set flag as TRUE else FALSE */
datIndInfo->isOutOfSeq = rbCb->m.amUl.isOutOfSeq;
if(gCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(gCb,KWU_EVT_DAT_IND, sdu);
+ rlcLmmSendTrc(gCb,KWU_EVT_DAT_IND, sdu);
}
#ifndef KW_PDCP
- KwUiKwuDatInd(&gCb->genCfg.lmPst, datIndInfo, sdu);
+ RlcUiKwuDatInd(&gCb->genCfg.lmPst, datIndInfo, sdu);
#endif
- return ROK;
-} /* kwUtlSndDatInd */
+ return (ROK);
+} /* rlcUtlSndDatInd */
PRIVATE Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
U32 i;
U32 pdusInReceptionBuffer = 0;
U32 totalSegs = 0;
- U32 windSz = KW_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
+ U32 windSz = RLC_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
for(i = 0; i< windSz; i++)
{
- KwAmRecBuf *recBuf = kwUtlGetRecBuf(ulRbCb->m.amUl.recBufLst, i);
+ RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(ulRbCb->m.amUl.recBufLst, i);
if(recBuf != NULLP)
{
pdusInReceptionBuffer++;
(PTR *)&ueCb))
{
U32 i;
- for(i = 0; i< KW_MAX_SRB_PER_UE; i++)
+ for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
{
RlcUlRbCb* ulRbCb = ueCb->srbCb[i];
if(ulRbCb != NULLP)
dumpRLCUlRbInformation(ulRbCb);
}
}
- for(i = 0; i< KW_MAX_DRB_PER_UE; i++)
+ for(i = 0; i< RLC_MAX_DRB_PER_UE; i++)
{
RlcUlRbCb* ulRbCb = ueCb->drbCb[i];
if(ulRbCb != NULLP)
/*
* kwUtlFreeUlRbCb() function is split into two functions
- * - kwAmmFreeUlRbCb() ---> gp_amm_ul.c
- * - kwUmmFreeUlRbCb() ---> gp_umm_ul.c
+ * - rlcAmmFreeUlRbCb() ---> gp_amm_ul.c
+ * - rlcUmmFreeUlRbCb() ---> gp_umm_ul.c
* and placed in respective files mentioned above
*/
* @return S16
* -# ROK
*/
-S16 kwUtlL2MeasUlInit(RlcCb *gCb)
+S16 rlcUtlL2MeasUlInit(RlcCb *gCb)
{
U16 cntr;
- gCb->u.ulCb->kwL2Cb.kwNumMeas=0;
+ gCb->u.ulCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- cmMemset((U8 *)&(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]), 0, sizeof(KwL2MeasEvtCb));
+ cmMemset((U8 *)&(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
}
- gCb->u.ulCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
+ gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
return ROK;
}
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlCalUlIpThrPutIncTTI
+ Void rlcUtlCalUlIpThrPutIncTTI
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
U32 ttiCnt
)
#else
-PUBLIC Void kwUtlCalUlIpThrPutIncTTI(gCb, rbCb, ttiCnt)
+Void rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb, ttiCnt)
RlcCb *gCb;
RlcUlRbCb *rbCb;
U32 ttiCnt;
#endif
{
VOLATILE U32 startTime = 0;
- TRC2(kwUtlCalUlIpThrPutIncTTI)
+ TRC2(rlcUtlCalUlIpThrPutIncTTI)
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
#endif
/*Check if UL IP throughput measurement is ON for this RB or not*/
- if(KW_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb,rbCb))
{
if (TRUE == rbCb->ueCb->isUlBurstActive)
{
}
if (rbCb->l2MeasIpThruput.prevTtiCnt != 0)
{
- rbCb->rbL2Cb.l2Sts[KW_L2MEAS_UL_IP]->ulIpThruput.timeSummation +=
+ rbCb->rbL2Cb.l2Sts[RLC_L2MEAS_UL_IP]->ulIpThruput.timeSummation +=
(ttiCnt - rbCb->l2MeasIpThruput.prevTtiCnt);
}
else
/*stopping Task*/
SStopTask(startTime, PID_RLC_IP_TPT_INCTTI);
-} /* kwUtlCalUlIpThrPutIncTTI */
+} /* rlcUtlCalUlIpThrPutIncTTI */
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlCalUlIpThrPut
+ Void rlcUtlCalUlIpThrPut
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
U32 ttiCnt
)
#else
-PUBLIC Void kwUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt)
+Void rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *pdu;
{
MsgLen rlcSduSz = 0; /*Holds length of Rlc Sdu*/
VOLATILE U32 startTime = 0;
- TRC2(kwUtlCalUlIpThrPut)
+ TRC2(rlcUtlCalUlIpThrPut)
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCVOL);
/*Check if UL IP throughput measurement is ON for this RB or not*/
- if(KW_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb, rbCb) &&
+ if(RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb, rbCb) &&
(TRUE == rbCb->ueCb->isUlBurstActive) &&
(rbCb->ueCb->firstPacketTTI) &&
(ttiCnt != rbCb->ueCb->firstPacketTTI))
{
SFndLenMsg(pdu, &rlcSduSz);
- rbCb->rbL2Cb.l2Sts[KW_L2MEAS_UL_IP]->ulIpThruput.volSummation += rlcSduSz;
+ rbCb->rbL2Cb.l2Sts[RLC_L2MEAS_UL_IP]->ulIpThruput.volSummation += rlcSduSz;
}
/*stopping Task*/
SStopTask(startTime, PID_RLC_IP_TPT_INCVOL);
-} /* kwUtlCalUlIpThrPut */
+} /* rlcUtlCalUlIpThrPut */
\f
/**
*/
#ifdef ANSI
-PUBLIC S16 kwUtlHdlL2TmrExp
+S16 rlcUtlHdlL2TmrExp
(
RlcCb *gCb,
-KwL2MeasEvtCb *measEvtCb
+RlcL2MeasEvtCb *measEvtCb
)
#else
-PUBLIC S16 kwUtlHdlL2TmrExp(measEvtCb)
+S16 rlcUtlHdlL2TmrExp(measEvtCb)
RlcCb *gCb;
-KwL2MeasEvtCb *measEvtCb;
+RlcL2MeasEvtCb *measEvtCb;
#endif
{
- TRC3(kwUtlHdlL2TmrExp)
+ TRC3(rlcUtlHdlL2TmrExp)
#ifdef LTE_L2_MEAS_RLC
U16 qciIdx;
- KwL2MeasCb *measCb;
+ RlcL2MeasCb *measCb;
/* Clean up the RB data structures */
if((measEvtCb->measCb.measType & LKW_L2MEAS_ACT_UE) &&
for(qciIdx = 0; qciIdx < measCb->val.nonIpThMeas.numQci;qciIdx++)
{
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.numActvUe +=
- rlcCb.kwL2Cb.numActUe[measCb->val.nonIpThMeas.qci[qciIdx]];
+ rlcCb.rlcL2Cb.numActUe[measCb->val.nonIpThMeas.qci[qciIdx]];
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.sampOc++;
}
measEvtCb->val.nonIpThMeas.measCb.numSamples--;
- kwStartTmr(gCb, (PTR)measEvtCb, KW_EVT_L2_TMR);
- return ROK;
+ rlcStartTmr(gCb, (PTR)measEvtCb, RLC_EVT_L2_TMR);
+ return (ROK);
}
#endif
- kwUtlSndUlL2MeasCfm(gCb, measEvtCb);
+ rlcUtlSndUlL2MeasCfm(gCb, measEvtCb);
- return ROK;
-} /* kwUtlHdlL2TmrExp */
+ return (ROK);
+} /* rlcUtlHdlL2TmrExp */
/**
*
* @brief Handler for Sending L2 Measurement confirm.
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndUlL2MeasCfm
+S16 rlcUtlSndUlL2MeasCfm
(
RlcCb *gCb,
-KwL2MeasEvtCb *measEvtCb
+RlcL2MeasEvtCb *measEvtCb
)
#else
-PUBLIC S16 kwUtlSndUlL2MeasCfm(gCb, measEvtCb)
+S16 rlcUtlSndUlL2MeasCfm(gCb, measEvtCb)
RlcCb *gCb;
-KwL2MeasEvtCb *measEvtCb;
+RlcL2MeasEvtCb *measEvtCb;
#endif
{
U32 qciIdx;
- KwL2MeasCb *measCb;
- KwL2MeasCfmEvt measCfmEvt;
+ RlcL2MeasCb *measCb;
+ RlcL2MeasCfmEvt measCfmEvt;
U64 ulDataVol;
U64 ulTime;
U32 cfmIdx =0;
/* Discard new changes ends */
- TRC3(kwUtlSndUlL2MeasCfm)
+ TRC3(rlcUtlSndUlL2MeasCfm)
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
- RLOG1(L_DEBUG,"kwUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
+ RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
#else
- RLOG1(L_DEBUG,"kwUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
+ RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
#endif
/* Clean up the RB data structures */
measCb = &measEvtCb->measCb;
- cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt));
+ cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
measCfmEvt.transId = measEvtCb->transId;
measCfmEvt.measType = measCb->measType;
if( measCb->measType & LKW_L2MEAS_UL_IP)
{
- KwL2MeasCbUeMeasInfo *pUeInfoLstCb = measCb->val.ipThMeas.ueInfoLst;
- KwL2MeasCfmUeInfoLst *pUeInfoLstCfm = measCfmEvt.val.ipThMeas.ueInfoLst;
+ RlcL2MeasCbUeMeasInfo *pUeInfoLstCb = measCb->val.ipThMeas.ueInfoLst;
+ RlcL2MeasCfmUeInfoLst *pUeInfoLstCfm = measCfmEvt.val.ipThMeas.ueInfoLst;
for(cntr = 0;(cntr < measCb->val.ipThMeas.numUes) && (cntr < gCb->genCfg.maxUe);cntr++)
{
pUeInfoLstCfm[cfmIdx].numCfm = 0;
}
measCfmEvt.val.ipThMeas.numUes = cfmIdx;
}
- KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
- return ROK;
-} /* kwUtlSndUlL2MeasCfm */
+ RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
+ return (ROK);
+} /* rlcUtlSndUlL2MeasCfm */
/**
*
* @brief Handler for Sending Negative confirm .
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndUlL2MeasNCfm
+S16 rlcUtlSndUlL2MeasNCfm
(
RlcCb *gCb,
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt
)
#else
-PUBLIC S16 kwUtlSndUlL2MeasNCfm(gCb, measReqEvt, measCfmEvt)
+S16 rlcUtlSndUlL2MeasNCfm(gCb, measReqEvt, measCfmEvt)
RlcCb *gCb;
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
- TRC3(kwUtlSndUlL2MeasNCfm)
+ TRC3(rlcUtlSndUlL2MeasNCfm)
- KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
+ RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
return ROK;
} /* kwUtlSndL2MeasNCfm */
*
* @details
*
- * Function :kwUtlValidateL2Meas
+ * Function :rlcUtlValidateL2Meas
*
* @param[in] measReqEvt L2 measurement request received from layer manager.
* @param[out] measCfmEvt L2 measurement confirm to be prepared.
**/
#ifdef ANSI
-PUBLIC S16 kwUtlValidateL2Meas
+S16 rlcUtlValidateL2Meas
(
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt,
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt,
CmLteLcId *lChId,
U8 *numLCh
)
#else
-PUBLIC S16 kwUtlValidateL2Meas(measReqEvt, measCfmEvt, lChId, numLCh)
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+S16 rlcUtlValidateL2Meas(measReqEvt, measCfmEvt, lChId, numLCh)
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
CmLteLcId *lChId;
U8 *numLCh;
#endif
{
- U8 measType;
- S16 ret;
- U8 qciIdx;
- U8 qci;
- U8 idx;
- U8 *qciVal;
- U8 numQci;
- KwRbCb *rbCb;
-
- KwUeCb *ueCb;
+ U8 measType;
+ S16 ret;
+ U8 qciIdx;
+ U8 qci;
+ U8 idx;
+ U8 *qciVal;
+ U8 numQci;
+ RlcUlRbCb *rbCb;
+
+ RlcUlUeCb *ueCb;
RbCb **rbCbLst;
U8 rbIdx;
U8 lsbNibble = 0;
U8 numFaild = 0;
- TRC3(kwUtlValidateL2Meas)
+ TRC3(rlcUtlValidateL2Meas)
idx = 0;
rbCb = NULLP;
}
/* Check for total maximum number of Measurement Control Block */
- if(rlcCb.kwL2Cb.kwNumMeas >= LKW_MAX_L2MEAS )
+ if(rlcCb.rlcL2Cb.rlcNumMeas >= LKW_MAX_L2MEAS )
{
measCfmEvt->transId = measReqEvt->transId;
measCfmEvt->measType = measType;
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
qci = qciVal[qciIdx];
- ret = cmHashListFind(&(rlcCb.kwL2Cb.qciHlCp),
+ ret = cmHashListFind(&(rlcCb.rlcL2Cb.qciHlCp),
(U8 *)&qci, (U16)sizeof(qci), 0, (PTR *)&rbCb);
if(ret != ROK)
{
{
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
- if(rlcCb.kwL2Cb.measOn[qci] & measReqEvt->measReq.measType)
+ if(rlcCb.rlcL2Cb.measOn[qci] & measReqEvt->measReq.measType)
{
/* measurement is already ongoing */
measCfmEvt->status.status = LCM_PRIM_NOK;
return RFAILED;
}
- return ROK;
-}/* kwUtlValidateL2Meas */
+ return (ROK);
+}/* rlcUtlValidateL2Meas */
#endif
#ifdef ANSI
-PUBLIC S16 kwUtlValidateIpThL2Meas
+S16 rlcUtlValidateIpThL2Meas
(
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt
)
#else
-PUBLIC S16 kwUtlValidateIpThL2Meas(measReqEvt, measCfmEvt)
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+S16 rlcUtlValidateIpThL2Meas(measReqEvt, measCfmEvt)
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
U8 measType;
U8 lsbNibble = 0;
U8 msbNibble = 0;
- TRC3(kwUtlValidateIpThL2Meas)
+ TRC3(rlcUtlValidateIpThL2Meas)
measType = measReqEvt->measReq.measType;
/* Check for the range of measType */
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
return RFAILED;
}
- return ROK;
-}/* kwUtlValidateL2Meas */
+ return (ROK);
+}/* rlcUtlValidateL2Meas */
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlResetUlL2MeasInKwRb
+Void rlcUtlResetUlL2MeasInRlcRb
(
RlcCb *gCb,
-KwL2MeasCb *measCb,
+RlcL2MeasCb *measCb,
U8 measType
)
#else
-PUBLIC Void kwUtlResetUlL2MeasInKwRb(measCb, measType)
+Void rlcUtlResetUlL2MeasInRlcRb(measCb, measType)
RlcCb *gCb;
-KwL2MeasCb *measCb;
+RlcL2MeasCb *measCb;
U8 measType;
#endif
{
}
}
- if(ROK != kwDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
+ if(ROK != rlcDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId, &ueCb))
{
continue;
}
- for (rbIdx = 0; rbIdx < KW_MAX_DRB_PER_UE; rbIdx++)
+ for (rbIdx = 0; rbIdx < RLC_MAX_DRB_PER_UE; rbIdx++)
{
if (ueCb->drbCb[rbIdx])
{
}
}
}
-} /* kwUtlResetUlL2MeasInKwRb */
+} /* rlcUtlResetUlL2MeasInRlcRb */
/**
*
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void kwUtlPlcMeasDatInL2Sts
+Void rlcUtlPlcMeasDatInL2Sts
(
-KwL2Cntr *measData,
-KwL2MeasRbCb *rbL2Cb,
+RlcL2Cntr *measData,
+RlcL2MeasRbCb *rbL2Cb,
U8 measType
)
#else
-PUBLIC Void kwUtlPlcMeasDatInL2Sts(measData, rbL2Cb, measType)
-KwL2Cntr *measData;
-KwL2MeasRbCb *rbL2Cb;
+Void rlcUtlPlcMeasDatInL2Sts(measData, rbL2Cb, measType)
+RlcL2Cntr *measData;
+RlcL2MeasRbCb *rbL2Cb;
U8 measType;
#endif
{
- TRC3(kwUtlPlcMeasDatInL2Sts)
+ 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
if(measType & LKW_L2MEAS_ACT_UE)
{
- rbL2Cb->l2Sts[KW_L2MEAS_ACT_UE] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_ACT_UE] = measData;
}
if(measType & LKW_L2MEAS_UU_LOSS)
{
- rbL2Cb->l2Sts[KW_L2MEAS_UU_LOSS] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_UU_LOSS] = measData;
}
if(measType & LKW_L2MEAS_DL_IP )
{
- rbL2Cb->l2Sts[KW_L2MEAS_DL_IP] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_DL_IP] = measData;
}
if(measType & LKW_L2MEAS_UL_IP)
{
- rbL2Cb->l2Sts[KW_L2MEAS_UL_IP] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_UL_IP] = measData;
}
if(measType & LKW_L2MEAS_DL_DISC)
{
- rbL2Cb->l2Sts[KW_L2MEAS_DL_DISC] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_DL_DISC] = measData;
}
if(measType & LKW_L2MEAS_DL_DELAY)
{
- rbL2Cb->l2Sts[KW_L2MEAS_DL_DELAY] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_DL_DELAY] = measData;
}
-}/* End of kwUtlPlcMeasDatInL2Sts */
+}/* End of rlcUtlPlcMeasDatInL2Sts */
#endif /* LTE_L2_MEAS */
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlStoreRecBuf
+Void rlcUtlStoreRecBuf
(
CmLListCp *recBufLst,
-KwAmRecBuf *recBuf,
-KwSn sn
+RlcAmRecBuf *recBuf,
+RlcSn sn
)
#else
-PUBLIC Void kwUtlStoreRecBuf(recBufLst, recBuf, sn)
+Void rlcUtlStoreRecBuf(recBufLst, recBuf, sn)
CmLListCp *recBufLst;
-KwAmRecBuf *recBuf;
-KwSn sn;
+RlcAmRecBuf *recBuf;
+RlcSn sn;
#endif
{
U32 hashKey;
- TRC3(kwUtlStoreRecBuf)
+ TRC3(rlcUtlStoreRecBuf)
- hashKey = (sn % KW_RCV_BUF_BIN_SIZE );
+ hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
recBuf->lnk.node = (PTR)recBuf;
cmLListAdd2Tail(&(recBufLst[hashKey]), &recBuf->lnk);
RETVOID;
-} /* kwUtlStoreRecBuf */
+} /* rlcUtlStoreRecBuf */
/**
*
* @return Void
*/
#ifdef ANSI
-PUBLIC KwAmRecBuf* kwUtlGetRecBuf
+RlcAmRecBuf* rlcUtlGetRecBuf
(
CmLListCp *recBufLst,
-KwSn sn
+RlcSn sn
)
#else
-PUBLIC KwAmRecBuf* kwUtlGetRecBuf(recBufLst, sn)
+RlcAmRecBuf* rlcUtlGetRecBuf(recBufLst, sn)
CmLListCp *recBufLst;
-KwSn sn;
+RlcSn sn;
#endif
{
U32 hashKey;
CmLListCp *recBufLstCp;
- KwAmRecBuf *recBuf;
+ RlcAmRecBuf *recBuf;
CmLList *node = NULLP;
- TRC3(kwUtlGetRecBuf)
+ TRC3(rlcUtlGetRecBuf)
- hashKey = (sn % KW_RCV_BUF_BIN_SIZE );
+ hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
recBufLstCp = &recBufLst[hashKey];
CM_LLIST_FIRST_NODE(recBufLstCp, node);
while(node)
{
- recBuf = (KwAmRecBuf *) node->node;
+ recBuf = (RlcAmRecBuf *) node->node;
if(recBuf->amHdr.sn == sn)
{
return (recBuf);
CM_LLIST_NEXT_NODE(recBufLstCp, node);
}
return (NULLP);
-} /* kwUtlStoreRecBuf */
+} /* rlcUtlStoreRecBuf */
/**
*
* @brief Delete the UL buffer from the list
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlDelRecBuf
+Void rlcUtlDelRecBuf
(
CmLListCp *recBufLst,
-KwAmRecBuf *recBuf,
+RlcAmRecBuf *recBuf,
RlcCb *gCb
)
#else
-PUBLIC Void kwUtlDelRecBuf(recBufLst, recBufi, gCb)
+Void rlcUtlDelRecBuf(recBufLst, recBufi, gCb)
CmLListCp *recBufLst;
-KwAmRecBuf *recBuf;
+RlcAmRecBuf *recBuf;
RlcCb *gCb;
#endif
{
U32 hashKey;
CmLListCp *recBufLstCp;
- TRC3(kwUtlDelRecBuf)
+ TRC3(rlcUtlDelRecBuf)
- hashKey = (recBuf->amHdr.sn % KW_RCV_BUF_BIN_SIZE );
+ hashKey = (recBuf->amHdr.sn % RLC_RCV_BUF_BIN_SIZE );
recBufLstCp = &recBufLst[hashKey];
cmLListDelFrm(recBufLstCp, &recBuf->lnk);
- RLC_FREE_WC(gCb, recBuf, sizeof(KwAmRecBuf));
+ RLC_FREE_WC(gCb, recBuf, sizeof(RlcAmRecBuf));
RETVOID;
-} /* kwUtlDelRecBuf */
+} /* rlcUtlDelRecBuf */
uint8_t rlcDatSn = 0;
uint64_t ulDatNum = 0;
-PUBLIC uint8_t macStubBOStatus(Pst *pst, SpId spId, RlcMacBOStatus *boSta)
+uint8_t macStubBOStatus(Pst *pst, SpId spId, RlcMacBOStatus *boSta)
{
Pst rspPst;
RlcMacSchedRepInfo *schRep;
}
-PUBLIC uint8_t macStubSendDlData(Pst *pst, SpId spId, RlcMacData *dlData)
+uint8_t macStubSendDlData(Pst *pst, SpId spId, RlcMacData *dlData)
{
U32 availmem;
#define FILL_PST_RLC_TO_DUAPP(_pst, _procId, _srcInst, _event) \
{ \
_pst.selector = ODU_SELECTOR_LWLC; \
- _pst.srcEnt = ENTKW; \
+ _pst.srcEnt = ENTRLC; \
_pst.dstEnt = ENTDUAPP; \
_pst.dstInst = 0; \
_pst.srcInst = _srcInst; \
#define FILL_PST_RLC_TO_DUAPP(_pst, _procId, _srcInst, _event) \
{ \
_pst.selector = ODU_SELECTOR_LWLC; \
- _pst.srcEnt = ENTKW; \
+ _pst.srcEnt = ENTRLC; \
_pst.dstEnt = ENTDUAPP; \
_pst.dstInst = 0; \
_pst.srcInst = _srcInst; \
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchCntrlReq
+S16 RgMiLrgSchCntrlReq
(
Pst *pst, /* post structure */
RgMngmt *cntrl /* control structure */
)
#else
-PUBLIC S16 RgMiLrgSchCntrlReq(pst, cntrl)
+S16 RgMiLrgSchCntrlReq(pst, cntrl)
Pst *pst; /* post structure */
RgMngmt *cntrl; /* control structure */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasReq
+S16 RgMiLrgSchL2MeasReq
(
Pst *pst, /* post structure */
LrgSchMeasReqInfo *measInfo /* Meas Req Info */
)
#else
-PUBLIC S16 RgMiLrgSchL2MeasReq(pst, measInfo)
+S16 RgMiLrgSchL2MeasReq(pst, measInfo)
Pst *pst; /* post structure */
LrgSchMeasReqInfo *measInfo; /* Meas Req Info */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasStopReq
+S16 RgMiLrgSchL2MeasStopReq
(
Pst *pst, /* post structure */
LrgSchMeasStopReqInfo *measInfo /* Meas Req Info */
)
#else
-PUBLIC S16 RgMiLrgSchL2MeasStopReq(pst, measInfo)
+S16 RgMiLrgSchL2MeasStopReq(pst, measInfo)
Pst *pst; /* post structure */
LrgSchMeasStopReqInfo *measInfo; /* Meas Req Info */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasSendReq
+S16 RgMiLrgSchL2MeasSendReq
(
Pst *pst, /* post structure */
LrgSchMeasSndReqInfo *measInfo /* Meas Req Info */
)
#else
-PUBLIC S16 RgMiLrgSchL2MeasSendReq(pst, measInfo)
+S16 RgMiLrgSchL2MeasSendReq(pst, measInfo)
Pst *pst; /* post structure */
LrgSchMeasSndReqInfo *measInfo; /* Meas Req Info */
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrBndReq
+S16 RgUiRgrBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 RgUiRgrBndReq(pst, suId, spId)
+S16 RgUiRgrBndReq(pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrUbndReq
+S16 RgUiRgrUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 RgUiRgrUbndReq(pst, spId, reason)
+S16 RgUiRgrUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrSiCfgReq
+S16 RgUiRgrSiCfgReq
(
Pst *pst,
SpId spId,
RgrSiCfgReqInfo *cfgReqInfo
)
#else
-PUBLIC S16 RgUiRgrSiCfgReq(pst, spId, transId, cfgReqInfo)
+S16 RgUiRgrSiCfgReq(pst, spId, transId, cfgReqInfo)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrWarningSiCfgReq
+S16 RgUiRgrWarningSiCfgReq
(
Pst *pst,
SpId spId,
RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
)
#else
-PUBLIC S16 RgUiRgrWarningSiCfgReq(pst, spId, transId, warningSiCfgReqInfo)
+S16 RgUiRgrWarningSiCfgReq(pst, spId, transId, warningSiCfgReqInfo)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrWarningSiStopReq
+S16 RgUiRgrWarningSiStopReq
(
Pst *pst,
SpId spId,
U8 siId
)
#else
-PUBLIC S16 RgUiRgrWarningSiStopReq(pst,spId, transId, siId)
+S16 RgUiRgrWarningSiStopReq(pst,spId, transId, siId)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgrLoadInfReq
+S16 RgUiRgrLoadInfReq
(
Pst *pst,
SpId spId,
RgrLoadInfReqInfo *loadInfReq
)
#else
-PUBLIC S16 RgUiRgrLoadInfReq(pst, spId, transId, loadInfReq)
+S16 RgUiRgrLoadInfReq(pst, spId, transId, loadInfReq)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchDedBoUpdtReq
+S16 RgMacSchDedBoUpdtReq
(
Pst* pst,
RgInfDedBoRpt *boRpt
)
#else
-PUBLIC S16 RgMacSchDedBoUpdtReq(pst, boRpt)
+S16 RgMacSchDedBoUpdtReq(pst, boRpt)
Pst* pst;
RgInfDedBoRpt *boRpt;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchCmnBoUpdtReq
+S16 RgMacSchCmnBoUpdtReq
(
Pst* pst,
RgInfCmnBoRpt *boRpt
)
#else
-PUBLIC S16 RgMacSchCmnBoUpdtReq(pst, boRpt)
+S16 RgMacSchCmnBoUpdtReq(pst, boRpt)
Pst* pst;
RgInfCmnBoRpt *boRpt;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchUeDelInd
+S16 RgMacSchUeDelInd
(
Pst* pst,
RgInfUeDelInd *ueDelInd
)
#else
-PUBLIC S16 RgMacSchUeDelInd(pst, ueDelInd)
+S16 RgMacSchUeDelInd(pst, ueDelInd)
Pst* pst;
RgInfUeDelInd *ueDelInd;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchSfRecpInd
+S16 RgMacSchSfRecpInd
(
Pst* pst,
RgInfSfDatInd *subfrmInfo
)
#else
-PUBLIC S16 RgMacSchSfRecpInd(pst, subfrmInfo)
+S16 RgMacSchSfRecpInd(pst, subfrmInfo)
Pst* pst;
RgInfSfDatInd *subfrmInfo;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchSpsRelInd
+S16 RgMacSchSpsRelInd
(
Pst *pst,
RgInfSpsRelInfo *relInfo
)
#else
-PUBLIC S16 RgMacSchSpsRelInd(pst, relInfo)
+S16 RgMacSchSpsRelInd(pst, relInfo)
Pst *pst;
RgInfSpsRelInfo *relInfo;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchL2MeasCfm
+S16 RgMacSchL2MeasCfm
(
Pst *pst,
RgInfL2MeasCfm *measCfm
)
#else
-PUBLIC S16 RgMacSchL2MeasCfm(pst, measCfm)
+S16 RgMacSchL2MeasCfm(pst, measCfm)
Pst *pst;
RgInfL2MeasCfm *measCfm;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchL2MeasStopCfm
+S16 RgMacSchL2MeasStopCfm
(
Pst *pst,
RgInfL2MeasCfm *measCfm
)
#else
-PUBLIC S16 RgMacSchL2MeasStopCfm(pst, measCfm)
+S16 RgMacSchL2MeasStopCfm(pst, measCfm)
Pst *pst;
RgInfL2MeasCfm *measCfm;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuSchBndCfm
+S16 RgLiTfuSchBndCfm
(
Pst *pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 RgLiTfuSchBndCfm(pst, suId, status)
+S16 RgLiTfuSchBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuRaReqInd
+S16 RgLiTfuRaReqInd
(
Pst *pst,
SuId suId,
TfuRaReqIndInfo *raReqInd
)
#else
-PUBLIC S16 RgLiTfuRaReqInd(pst, suId, raReqInd)
+S16 RgLiTfuRaReqInd(pst, suId, raReqInd)
Pst *pst;
SuId suId;
TfuRaReqIndInfo *raReqInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuUlCqiInd
+S16 RgLiTfuUlCqiInd
(
Pst *pst,
SuId suId,
TfuUlCqiIndInfo *ulCqiInd
)
#else
-PUBLIC S16 RgLiTfuUlCqiInd(pst, suId, ulCqiInd)
+S16 RgLiTfuUlCqiInd(pst, suId, ulCqiInd)
Pst *pst;
SuId suId;
TfuUlCqiIndInfo *ulCqiInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuPucchDeltaPwrInd
+S16 RgLiTfuPucchDeltaPwrInd
(
Pst *pst,
SuId suId,
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr
)
#else
-PUBLIC S16 RgLiTfuPucchDeltaPwrInd(pst, suId, pucchDeltaPwr)
+S16 RgLiTfuPucchDeltaPwrInd(pst, suId, pucchDeltaPwr)
Pst *pst;
SuId suId;
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuHqInd
+S16 RgLiTfuHqInd
(
Pst *pst,
SuId suId,
TfuHqIndInfo *harqAckInd
)
#else
-PUBLIC S16 RgLiTfuHqInd(pst, suId, harqAckInd)
+S16 RgLiTfuHqInd(pst, suId, harqAckInd)
Pst *pst;
SuId suId;
TfuHqIndInfo *harqAckInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuSrInd
+S16 RgLiTfuSrInd
(
Pst *pst,
SuId suId,
TfuSrIndInfo *srInd
)
#else
-PUBLIC S16 RgLiTfuSrInd(pst, suId, srInd)
+S16 RgLiTfuSrInd(pst, suId, srInd)
Pst *pst;
SuId suId;
TfuSrIndInfo *srInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuDlCqiInd
+S16 RgLiTfuDlCqiInd
(
Pst *pst,
SuId suId,
TfuDlCqiIndInfo *dlCqiInd
)
#else
-PUBLIC S16 RgLiTfuDlCqiInd(pst, suId, dlCqiInd)
+S16 RgLiTfuDlCqiInd(pst, suId, dlCqiInd)
Pst *pst;
SuId suId;
TfuDlCqiIndInfo *dlCqiInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuRawCqiInd
+S16 RgLiTfuRawCqiInd
(
Pst *pst,
SuId suId,
TfuRawCqiIndInfo *rawCqiInd
)
#else
-PUBLIC S16 RgLiTfuRawCqiInd(pst, suId, rawCqiInd)
+S16 RgLiTfuRawCqiInd(pst, suId, rawCqiInd)
Pst *pst;
SuId suId;
TfuRawCqiIndInfo *rawCqiInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuSrsInd
+S16 RgLiTfuSrsInd
(
Pst *pst,
SuId suId,
TfuSrsIndInfo *srsInd
)
#else
-PUBLIC S16 RgLiTfuSrsInd(pst, suId, srsInd)
+S16 RgLiTfuSrsInd(pst, suId, srsInd)
Pst *pst;
SuId suId;
TfuSrsIndInfo *srsInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuDoaInd
+S16 RgLiTfuDoaInd
(
Pst *pst,
SuId suId,
TfuDoaIndInfo *doaInd
)
#else
-PUBLIC S16 RgLiTfuDoaInd(pst, suId, doaInd)
+S16 RgLiTfuDoaInd(pst, suId, doaInd)
Pst *pst;
SuId suId;
TfuDoaIndInfo *doaInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuCrcInd
+S16 RgLiTfuCrcInd
(
Pst *pst,
SuId suId,
TfuCrcIndInfo *crcInd
)
#else
-PUBLIC S16 RgLiTfuCrcInd (pst, suId, crcInd)
+S16 RgLiTfuCrcInd (pst, suId, crcInd)
Pst *pst;
SuId suId;
TfuCrcIndInfo *crcInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuTimingAdvInd
+S16 RgLiTfuTimingAdvInd
(
Pst *pst,
SuId suId,
TfuTimingAdvIndInfo *timingAdvInd
)
#else
-PUBLIC S16 RgLiTfuTimingAdvInd(pst, suId, timingAdvInd)
+S16 RgLiTfuTimingAdvInd(pst, suId, timingAdvInd)
Pst *pst;
SuId suId;
TfuTimingAdvIndInfo *timingAdvInd;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgmBndReq
+S16 RgUiRgmBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 RgUiRgmBndReq(pst, suId, spId)
+S16 RgUiRgmBndReq(pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgmUbndReq
+S16 RgUiRgmUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 RgUiRgmUbndReq(pst, spId, reason)
+S16 RgUiRgmUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgUiRgmCfgPrbRprt
+S16 RgUiRgmCfgPrbRprt
(
Pst *pst,
SpId spId,
RgmPrbRprtCfg *prbRprtCfg
)
#else
-PUBLIC S16 RgUiRgmCfgPrbRprt(pst, spId, prbRprtCfg)
+S16 RgUiRgmCfgPrbRprt(pst, spId, prbRprtCfg)
Pst *pst;
SpId spId;
RgmPrbRprtCfg *prbRprtCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 RgLiTfuErrInd
+S16 RgLiTfuErrInd
(
Pst *pst,
SuId suId,
TfuErrIndInfo *errInd
)
#else
-PUBLIC S16 RgLiTfuErrInd(pst, suId, errInd)
+S16 RgLiTfuErrInd(pst, suId, errInd)
Pst *pst;
SuId suId;
TfuErrIndInfo *errInd;
RgSchIotResCb pucchHqFdbkCb;
} RgSchIotResMngmtCb;
-PUBLIC S16 rgSCHUtlIotResPrcTti ARGS((
+S16 rgSCHUtlIotResPrcTti ARGS((
RgSchCellCb *cell
));
-PUBLIC Void rgSCHUtlIotInsAlloc2Lst ARGS((
+Void rgSCHUtlIotInsAlloc2Lst ARGS((
CmLListCp *allocList,
RgSchIotRes *alloc,
CmLList *lnk
));
-PUBLIC S16 rgSCHUtlIotResMngmtInit ARGS((
+S16 rgSCHUtlIotResMngmtInit ARGS((
RgSchCellCb *cell,
U32 pdcchPoolSz,
U32 pdcchDelta,
U32 puschMaxFreqSz
));
-PUBLIC Void rgSCHUtlIotResMngmtDeinit ARGS((
+Void rgSCHUtlIotResMngmtDeinit ARGS((
RgSchCellCb *cell
));
-PUBLIC RgSchIotRes *rgSCHUtlIotAllocRes ARGS((
+RgSchIotRes *rgSCHUtlIotAllocRes ARGS((
RgSchIotResCb *resCb,
U32 fStart,
U32 fSize,
Bool isForEnable
));
-PUBLIC RgSchIotRes *rgSCHUtlIotFirstAllocForTx ARGS((
+RgSchIotRes *rgSCHUtlIotFirstAllocForTx ARGS((
RgSchIotResCb *resCb,
CmLteTimingInfo txTime
));
-PUBLIC RgSchIotRes *rgSCHUtlIotNextAllocForTx ARGS((
+RgSchIotRes *rgSCHUtlIotNextAllocForTx ARGS((
RgSchIotResCb *resCb,
RgSchIotRes *prevAlloc,
CmLteTimingInfo txTime
));
-PUBLIC Void rgSCHUtlIotAllocRls ARGS((
+Void rgSCHUtlIotAllocRls ARGS((
RgSchIotResCb *resCb,
RgSchIotRes *alloc
));
-PUBLIC RgSchIotRes *rgSCHUtlEmtcAllocRes ARGS((
+RgSchIotRes *rgSCHUtlEmtcAllocRes ARGS((
RgSchIotResCb *resCb,
U32 *fStart,
U32 *fEnd,
Bool isRetx
));
-PUBLIC S16 rgSCHUtlEmtcResPrcTti ARGS((
+S16 rgSCHUtlEmtcResPrcTti ARGS((
RgSchCellCb *cell
));
-PUBLIC S16 rgSCHUtlEmtcResMngmtInit ARGS((
+S16 rgSCHUtlEmtcResMngmtInit ARGS((
RgSchCellCb *cell,
U32 pdschPoolSz,
U32 pdschDelta,
U32 pucchMaxFreqSz
));
-PUBLIC Void rgSCHUtlEmtcResMngmtDeinit ARGS((
+Void rgSCHUtlEmtcResMngmtDeinit ARGS((
RgSchCellCb *cell
));
RgrEmtcCellCfg *emtcCellCfg));
EXTERN S16 rgSCHCfgVldtRgrEmtcCellCfg ARGS ((RgrCellCfg *cellCfg));
-EXTERN PUBLIC Void rgSchTomTtiEmtcSched ARGS((RgSchCellCb *cell));
+EXTERN Void rgSchTomTtiEmtcSched ARGS((RgSchCellCb *cell));
EXTERN S16 rgSCHCfgVldtEmtcUeCfg ARGS((RgSchCellCb *cell, RgrUeEmtcCfg *emtcUeCfg));
EXTERN S16 rgSCHUtlUpdUeEmtcInfo ARGS((RgSchCellCb *cell, RgrUeCfg *ueCfg, RgSchUeCb *ueCb));
EXTERN S16 rgSCHEmtcCellDel ARGS((RgSchCellCb *cell));
EXTERN S16 rgSCHDhmEmtcHqFdbkInd ARGS((Void *cb, U8 cbType, RgSchCellCb *cellCb,
CmLteTimingInfo timingInfo, RgTfuHqInfo *fdbk, RgInfRlsHqInfo
*rlsHqBufs,RgSchErrInfo *err));
-EXTERN PUBLIC S16 rgSCHUtlAddToResLst
+EXTERN S16 rgSCHUtlAddToResLst
(
CmLListCp *cp,
RgSchIotRes *iotRes
#endif
/* Nprb indication at PHY for common Ch */
/* Corrected allocation for common channels */
-EXTERN PUBLIC S32 rgSCHUtlGetAllwdCchTbSz ARGS((U32 bo, U8 *nPrb, U8 *mcs
+EXTERN S32 rgSCHUtlGetAllwdCchTbSz ARGS((U32 bo, U8 *nPrb, U8 *mcs
));
/* CR timer changes*/
-EXTERN PUBLIC S16 rgSCHUtlUpdtBo ARGS((RgSchCellCb *cell,
+EXTERN S16 rgSCHUtlUpdtBo ARGS((RgSchCellCb *cell,
RgInfCmnBoRpt *staRsp));
-EXTERN PUBLIC S16 rgSCHUtlAddUeToCcchSduLst ARGS(
+EXTERN S16 rgSCHUtlAddUeToCcchSduLst ARGS(
(RgSchCellCb *cell,
RgSchUeCb *ueCb));
#ifdef EMTC_ENABLE
-EXTERN PUBLIC S16 rgSCHUtlAddUeToEmtcCcchSduLst ARGS(
+EXTERN S16 rgSCHUtlAddUeToEmtcCcchSduLst ARGS(
(RgSchCellCb *cell,
RgSchUeCb *ueCb));
#ifdef TFU_UPGRADE
#ifdef LTE_TDD
-EXTERN CONSTANT PUBLIC RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl;
+EXTERN CONSTANT RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl;
#else
-EXTERN CONSTANT PUBLIC RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl;
+EXTERN CONSTANT RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl;
#endif
#endif
/* ccpu00117452 - MOD - Changed macro name from
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
#ifdef RGR_CQI_REPT
-PUBLIC S16 rgSCHUtlRgrStaInd ARGS((
+S16 rgSCHUtlRgrStaInd ARGS((
RgSchCellCb *cell,
RgrStaIndInfo *rgrSta
));
-PUBLIC S16 rgSCHUtlFillSndStaInd ARGS((
+S16 rgSCHUtlFillSndStaInd ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrStaIndInfo *staInfo,
U8 numCqiRept
));
#endif /* End of RGR_CQI_REPT */
-PUBLIC S16 rgSCHUtlRgrUeStaInd ARGS((
+S16 rgSCHUtlRgrUeStaInd ARGS((
RgSchCellCb *cell,
RgrUeStaIndInfo *rgrUeSta
));
-PUBLIC S16 rgSCHUtlFillSndUeStaInd ARGS((
+S16 rgSCHUtlFillSndUeStaInd ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeStaIndInfo *ueStaInfo
/* LTE_ADV_FLAG_REMOVED_START */
-PUBLIC S16 rgSCHUtlRgrLoadInfInd ARGS((
+S16 rgSCHUtlRgrLoadInfInd ARGS((
RgSchCellCb *cell,
RgrLoadInfIndInfo *rgrLoadInf
));
/* LTE_ADV_FLAG_REMOVED_END */
#ifdef LTE_ADV
#ifdef TFU_UPGRADE
-PUBLIC TfuAckNackMode rgSchUtlGetFdbkMode ARGS((
+TfuAckNackMode rgSchUtlGetFdbkMode ARGS((
RgrSchFrmt1b3TypEnum fdbkType
));
#endif /*TFU_UPGRADE */
#endif /* LTE_ADV */
/* FIX */
-PUBLIC Void rgSCHUtlRlsRnti ARGS((
+Void rgSCHUtlRlsRnti ARGS((
RgSchCellCb *cellCb,
RgSchRntiLnk *rntiLnk,
Bool ueIdChngd,
CmLteRnti newRnti
));
-PUBLIC S16 rgSCHUtlRgmBndCfm ARGS((
+S16 rgSCHUtlRgmBndCfm ARGS((
Inst instId,
SuId suId,
U8 status
));
-PUBLIC Void rgSCHDhmDelHqEnt ARGS((
+Void rgSCHDhmDelHqEnt ARGS((
RgSchCellCb *cell,
RgSchDlHqEnt **hqE
));
-PUBLIC Void rgSCHDhmAssgnUeHqEntFrmRaCb ARGS((
+Void rgSCHDhmAssgnUeHqEntFrmRaCb ARGS((
RgSchUeCb *ue,
RgSchRaCb *raCb
));
-PUBLIC Void rgSCHUtlReTxTa ARGS((
+ Void rgSCHUtlReTxTa ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb));
/* LTE_ADV_FLAG_REMOVED_START */
-PUBLIC Void rgSchSFRTotalPoolFree ARGS((
+Void rgSchSFRTotalPoolFree ARGS((
RgSchSFRTotalPoolInfo *sfrTotalPoolInfo,
RgSchCellCb *cell));
-PUBLIC Void rgSchDSFRPwrCheck ARGS((
+Void rgSchDSFRPwrCheck ARGS((
RgSchDlSf *sf,
Bool *isAllUePwrHigh));
/* LTE_ADV_FLAG_REMOVED_END */
-PUBLIC S16 rgSCHUtlUpdAvgPrbUsage ARGS((
+S16 rgSCHUtlUpdAvgPrbUsage ARGS((
RgSchCellCb *cell
));
-PUBLIC U8 rgSchUtlCfg0ReTxIdx ARGS((
+U8 rgSchUtlCfg0ReTxIdx ARGS((
RgSchCellCb *cell,
CmLteTimingInfo phichTime,
U8 hqFdbkIdx
RgSchCellCb *cell,
Bool isDynCfiEnb
));
-PUBLIC Void rgSchUtlCalcTotalPrbReq ARGS((RgSchCellCb *cell,
+Void rgSchUtlCalcTotalPrbReq ARGS((RgSchCellCb *cell,
RgSchUeCb *ue,
U32 bo,
U32 *prbReqrd));
RgSchCellCb *cell
));
-EXTERN PUBLIC U8 rgSCHCmnGetBiIndex ARGS ((
+EXTERN U8 rgSCHCmnGetBiIndex ARGS ((
RgSchCellCb *cell,
U32 ueCount
));
/* LTE-MAC Scheduler instance control block structures */
-PUBLIC RgSchCb rgSchCb[RGSCH_MAX_INST];
+RgSchCb rgSchCb[RGSCH_MAX_INST];
#ifdef PHY_ERROR_LOGING
-PUBLIC RgSchUlAllocCntr rgSchUlAllocCntr;
+RgSchUlAllocCntr rgSchUlAllocCntr;
#endif
#ifdef EMTC_ENABLE
));
#endif
-PUBLIC S16 rgSCHEnbPfsDlCfg ARGS((
+S16 rgSCHEnbPfsDlCfg ARGS((
Inst instIdx,
RgSchErrInfo *err
));
RgSchRaCb *raCb,RgSchUeCb *ue, RgSchErrInfo *errInfo));
PRIVATE S16 rgSCHCfgRgrCmnLcCfg ARGS((RgSchCellCb *cell, RgrCmnLchCfg *lcCfg,
RgSchErrInfo *errInfo));
-PUBLIC Void rgSCHSCellFreeBuf ARGS((Inst inst,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,U8 idx));
+Void rgSCHSCellFreeBuf ARGS((Inst inst,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,U8 idx));
#ifdef RGR_SI_SCH
PRIVATE S16 rgSCHCfgVldtRgrCellSiCfg ARGS(( Inst inst, RgrSiCfg *siCfg));
#endif/*RGR_SI_SCH */
RgrCellCsgParamCfg *csgParam));
#ifdef TFU_UPGRADE
-PUBLIC S16 rgSCHCfgACqiUeCfg ARGS(( RgSchCellCb *cellCb,RgSchUeCb *ue, RgSchUeACqiCb *aCqiCb,
+S16 rgSCHCfgACqiUeCfg ARGS(( RgSchCellCb *cellCb,RgSchUeCb *ue, RgSchUeACqiCb *aCqiCb,
RgrTxMode ueTxMode,RgrUeAprdDlCqiCfg *aCqiCfg, CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHCfgAcqiUeReCfg ARGS(( RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgAcqiUeReCfg ARGS(( RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUeAprdDlCqiCfg *acqiCfg, CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHUtlGetCfgPerOff ARGS(( RgSchPerTbl tbl, U16 cfgIdx,
+S16 rgSCHUtlGetCfgPerOff ARGS(( RgSchPerTbl tbl, U16 cfgIdx,
U16 *peri, U16 *offset ));
-PUBLIC S16 rgSCHCfgRiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgRiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg, CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHCfgPCqiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgPCqiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg,CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHCfgSrsUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
+S16 rgSCHCfgSrsUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg ));
-PUBLIC S16 rgSCHCfgSrUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
+S16 rgSCHCfgSrUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg));
-PUBLIC S16 rgSCHCfgPCqiUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgPCqiUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg,CmLteUeCategory ueCat));
-PUBLIC S16 rgSCHCfgSrsUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgSrsUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg));
-PUBLIC S16 rgSCHCfgSrUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgSrUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg));
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode ARGS((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrTxmodePuschMode ARGS((RgSchCellCb *cellCb,
RgrTxMode txMde, RgrAprdCqiMode puschMode,RgSchErrInfo *errInfo));
-PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg ARGS(( RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUeACqiCfg ARGS(( RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUeAprdDlCqiCfg *acqiCfg, RgrUeTxModeCfg txMode,
RgSchErrInfo *errInfo ));
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode ARGS((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrTxmodePucchMode ARGS((RgSchCellCb *cellCb,
RgrTxMode txMde, RgrPrdCqiMode pucchMode,RgSchErrInfo *errInfo));
#ifdef LTEMAC_HDFDD
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUePrdDlCqiCfg *cqiCfg, Bool hdFdd,
RgrUeTxModeCfg txMode, RgSchErrInfo *errInfo));
#else
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUePrdDlCqiCfg *cqiCfg, RgrUeTxModeCfg txMode,
RgSchErrInfo *errInfo));
#endif
#ifdef LTEMAC_HDFDD
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUeUlSrsCfg *srsCfg, Bool hdFdd,
RgSchErrInfo *errInfo));
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUeUlSrsCfg *srsCfg,
RgSchErrInfo *errInfo));
#endif
#ifdef LTEMAC_HDFDD
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
+S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
RgrUeSrCfg *srCfg, Bool hdFdd, RgSchErrInfo *errInfo));
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
+S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
RgrUeSrCfg *srCfg, RgSchErrInfo *errInfo));
#endif
PRIVATE S16 rgSCHCfgVldtCqiSrSrsUeCfg ARGS (( RgSchCellCb *cellCb,
RgrUeRecfg *ueReCfg,
RgSchErrInfo *errInfo ));
-PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel ARGS ((RgSchCellCb *cellCb,
+S16 rgSCHCfgPCqiSrsSrUeDel ARGS ((RgSchCellCb *cellCb,
RgSchUeCb *ueCb));
PRIVATE Void rgSCHCfgUtlFetchAcqiBitSz ARGS (( RgSchUeACqiCb *acqiCb,U8 numTxAnt,
RgrUeRecfg *ueReCfg,
RgSchErrInfo *errInfo ));
#ifdef LTE_ADV
-PUBLIC S16 rgSCHSCellCfgUeCfg ARGS((
+S16 rgSCHSCellCfgUeCfg ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
RgSchErrInfo *err
));
-PUBLIC S16 rgSCHSCellCfgUePucchReCfg ARGS((
+S16 rgSCHSCellCfgUePucchReCfg ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
RgSchErrInfo *err
));
-PUBLIC S16 rgSCHCfgVldtRgrUeSCellRecfg ARGS((
+S16 rgSCHCfgVldtRgrUeSCellRecfg ARGS((
RgrUeRecfg *ueRecfg,
RgSchCellCb *cell,
RgSchUeCb *ue,
PRIVATE S16 rgSchAddToL2Meas ARGS ((RgSchCellCb *cellCb,RgSchDlLcCb *dlLc));
#endif
#ifdef EMTC_ENABLE
-PUBLIC S16 rgSCHEmtcCfgVldtDrxOnDurCfg
+S16 rgSCHEmtcCfgVldtDrxOnDurCfg
(
U16 onDurTmr
);
-PUBLIC Void rgSCHUtlUpdEmtcY
+Void rgSCHUtlUpdEmtcY
(
RgSchUeCb *ue
);
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrSchedEnbCfg
+S16 rgSCHCfgVldtRgrSchedEnbCfg
(
Inst inst,
RgrSchedEnbCfg *schedEnbCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrSchedEnbCfg(inst, schedEnbCfg, errInfo)
+S16 rgSCHCfgVldtRgrSchedEnbCfg(inst, schedEnbCfg, errInfo)
Inst inst;
RgrSchedEnbCfg *schedEnbCfg;
RgSchErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellCfg
+S16 rgSCHCfgVldtRgrCellCfg
(
Inst inst,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellCfg(inst, cellCfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrCellCfg(inst, cellCfg, cell, errInfo)
Inst inst;
RgrCellCfg *cellCfg;
RgSchCellCb *cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrSchCfg
+S16 rgSCHCfgVldtRgrSchCfg
(
Inst inst,
RgrSchedEnbCfg *rgSchedCfg
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrSchCfg(inst, rgSchedCfg)
+S16 rgSCHCfgVldtRgrSchCfg(inst, rgSchedCfg)
Inst inst;
RgrSchedCfg *rgSchedCfg;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellSchCfg
+S16 rgSCHCfgVldtRgrCellSchCfg
(
Inst inst,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellSchCfg(inst, cellCfg)
+S16 rgSCHCfgVldtRgrCellSchCfg(inst, cellCfg)
Inst inst;
RgrCellCfg *cellCfg;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellRACfg
+S16 rgSCHCfgVldtRgrCellRACfg
(
Inst inst,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellRACfg(inst, cellCfg)
+S16 rgSCHCfgVldtRgrCellRACfg(inst, cellCfg)
Inst inst;
RgrCellCfg *cellCfg;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeCfg
+S16 rgSCHCfgVldtRgrUeCfg
(
Inst inst,
RgrUeCfg *ueCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeCfg(inst, ueCfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrUeCfg(inst, ueCfg, cell, errInfo)
Inst inst;
RgrUeCfg *ueCfg;
RgSchCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellRecfg
+S16 rgSCHCfgVldtRgrCellRecfg
(
Inst inst,
RgrCellRecfg *cellRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellRecfg(inst, cellRecfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrCellRecfg(inst, cellRecfg, cell, errInfo)
Inst inst;
RgrCellRecfg *cellRecfg;
RgSchCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellCfgUeCfg
+S16 rgSCHSCellCfgUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSCellCfgUeCfg(cell, ue, ueRecfg, err)
+S16 rgSCHSCellCfgUeCfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellCfgUePucchReCfg
+S16 rgSCHSCellCfgUePucchReCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSCellCfgUePucchReCfg(cell, ue, ueRecfg, err)
+S16 rgSCHSCellCfgUePucchReCfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeSCellRecfg
+S16 rgSCHCfgVldtRgrUeSCellRecfg
(
RgrUeRecfg *ueRecfg,
RgSchCellCb *cell,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSCellRecfg(inst, ueRecfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrUeSCellRecfg(inst, ueRecfg, cell, ue, errInfo)
RgrUeRecfg *ueRecfg;
RgSchCellCb *cell;
RgSchUeCb *ue;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeRecfg
+S16 rgSCHCfgVldtRgrUeRecfg
(
Inst inst,
RgrUeRecfg *ueRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeRecfg(inst, ueRecfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrUeRecfg(inst, ueRecfg, cell, ue, errInfo)
Inst inst;
RgrUeRecfg *ueRecfg;
RgSchCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLchRecfg
+S16 rgSCHCfgVldtRgrLchRecfg
(
Inst inst,
RgrLchRecfg *lcRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLchRecfg(inst, lcRecfg, cell, ue, dlLc, errInfo)
+S16 rgSCHCfgVldtRgrLchRecfg(inst, lcRecfg, cell, ue, dlLc, errInfo)
Inst inst;
RgrLchRecfg *lcRecfg;
RgSchCellCb **cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeReset
+S16 rgSCHCfgVldtRgrUeReset
(
Inst inst,
RgrRst *reset,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeReset(inst, reset, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrUeReset(inst, reset, cell, ue, errInfo)
Inst inst;
RgrRst *reset;
RgSchCellCb *cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLcgRecfg
+S16 rgSCHCfgVldtRgrLcgRecfg
(
Inst inst,
RgrLcgRecfg *lcgRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLcgRecfg(inst, lcgRecfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrLcgRecfg(inst, lcgRecfg, cell, ue, errInfo)
Inst inst;
RgrLcgRecfg *lcgRecfg;
RgSchCellCb *cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrSchedEnbCfg
+S16 rgSCHCfgRgrSchedEnbCfg
(
Inst inst,
SpId spId,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrSchedEnbCfg(inst, spId, schedEnbCfg, errInfo)
+S16 rgSCHCfgRgrSchedEnbCfg(inst, spId, schedEnbCfg, errInfo)
Inst inst,
SpId spId;
RgrSchedEnbCfg *schedEnbCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCH5gtfCellCfg
+S16 rgSCH5gtfCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCH5gtfCellCfg(cell, cellCfg)
+S16 rgSCH5gtfCellCfg(cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrCellCfg
+S16 rgSCHCfgRgrCellCfg
(
RgSchCb *instCb,
SpId spId,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrCellCfg(instCb, spId, cellCfg, errInfo)
+S16 rgSCHCfgRgrCellCfg(instCb, spId, cellCfg, errInfo)
RgSchCb *instCb;
SpId spId;
RgrCellCfg *cellCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeCfg
+S16 rgSCHCfgRgrUeCfg
(
RgSchCellCb *cell,
RgrUeCfg *ueCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeCfg(cell, ueCfg, errInfo)
+S16 rgSCHCfgRgrUeCfg(cell, ueCfg, errInfo)
RgSchCellCb *cell;
RgrUeCfg *ueCfg;
RgSchErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDynCfiReCfg
+Void rgSCHDynCfiReCfg
(
RgSchCellCb *cell,
Bool isDynCfiEnb
)
#else
-PUBLIC Void rgSCHDynCfiReCfg(cell, isDynCfiEnb)
+Void rgSCHDynCfiReCfg(cell, isDynCfiEnb)
RgSchCellCb *cell;
Bool isDynCfiEnb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrCellRecfg
+S16 rgSCHCfgRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *cellRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrCellRecfg(cell, cellRecfg, errInfo)
+S16 rgSCHCfgRgrCellRecfg(cell, cellRecfg, errInfo)
RgSchCellCb *cell;
RgrCellRecfg *cellRecfg;
RgSchErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeRecfg
+S16 rgSCHCfgRgrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeRecfg(cell, ue, ueRecfg, errInfo)
+S16 rgSCHCfgRgrUeRecfg(cell, ue, ueRecfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLchRecfg
+S16 rgSCHCfgRgrLchRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLchRecfg(cell, ue, dlLc, lcRecfg, errInfo)
+S16 rgSCHCfgRgrLchRecfg(cell, ue, dlLc, lcRecfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcgRecfg
+S16 rgSCHCfgRgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcgRecfg(cell, ue, lcgRecfg, errInfo)
+S16 rgSCHCfgRgrLcgRecfg(cell, ue, lcgRecfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgRecfg *lcgRecfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeReset
+S16 rgSCHCfgRgrUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeReset(cell, ue, reset, errInfo)
+S16 rgSCHCfgRgrUeReset(cell, ue, reset, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrRst *reset;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrCellDel
+S16 rgSCHCfgRgrCellDel
(
RgSchCellCb *cell,
RgrDel *cellDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrCellDel(cell, cellDelInfo, errInfo)
+S16 rgSCHCfgRgrCellDel(cell, cellDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *cellDelInfo;
RgSchErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeDel
+S16 rgSCHCfgRgrUeDel
(
RgSchCellCb *cell,
RgrDel *ueDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeDel(cell, ueDelInfo, errInfo)
+S16 rgSCHCfgRgrUeDel(cell, ueDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *ueDelInfo;
RgSchErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcDel
+S16 rgSCHCfgRgrLcDel
(
RgSchCellCb *cell,
RgrDel *lcDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcDel(cell, lcDelInfo, errInfo)
+S16 rgSCHCfgRgrLcDel(cell, lcDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *lcDelInfo;
RgSchErrInfo *errInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcgDel
+S16 rgSCHCfgRgrLcgDel
(
RgSchCellCb *cell,
RgrDel *lcDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcgDel(cell, lcDelInfo, errInfo)
+S16 rgSCHCfgRgrLcgDel(cell, lcDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *lcDelInfo;
RgSchErrInfo *errInfo;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLcCfg
+S16 rgSCHCfgVldtRgrLcCfg
(
Inst inst,
RgrLchCfg *lcCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLcCfg(inst, lcCfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrLcCfg(inst, lcCfg, cell, ue, errInfo)
Inst inst;
RgrLchCfg *lcCfg;
RgSchCellCb **cell;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLcgCfg
+S16 rgSCHCfgVldtRgrLcgCfg
(
Inst inst,
RgrLcgCfg *lcgCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLcgCfg(inst, lcgCfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrLcgCfg(inst, lcgCfg, cell, ue, errInfo)
Inst inst;
RgrLcgCfg *lcgCfg;
RgSchCellCb **cell;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLchCfg
+S16 rgSCHCfgRgrLchCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLchCfg(cell, ue, lcCfg, errInfo)
+S16 rgSCHCfgRgrLchCfg(cell, ue, lcCfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLchCfg *lcCfg;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcgCfg
+S16 rgSCHCfgRgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcgCfg(cell, ue, lcgCfg, errInfo)
+S16 rgSCHCfgRgrLcgCfg(cell, ue, lcgCfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgCfg *lcgCfg;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCfgFreeCellCb
+Void rgSCHCfgFreeCellCb
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCfgFreeCellCb(cell)
+Void rgSCHCfgFreeCellCb(cell)
RgSchCellCb *cell;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrSiCfg
+S16 rgSCHCfgVldtRgrSiCfg
(
Inst inst,
RgrSiCfgReqInfo *siCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrSiCfg(inst, siCfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrSiCfg(inst, siCfg, cell, errInfo)
Inst inst;
RgrSiCfgReqInfo *siCfg;
RgSchCellCb *cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLoadInf
+S16 rgSCHCfgVldtRgrLoadInf
(
Inst inst,
RgrLoadInfReqInfo *loadInfReq,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, errInfo)
+S16 rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, errInfo)
Inst inst;
RgrLoadInfReqInfo *loadInfReq;
RgSchCellCb *cell;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode
+S16 rgSCHCfgVldtRgrTxmodePuschMode
(
RgSchCellCb *cellCb,
RgrTxMode txMde,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde, puschMode,errInfo)
+S16 rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde, puschMode,errInfo)
RgSchCellCb *cellCb;
RgrTxMode txMde;
RgrAprdCqiMode puschMode;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg
+S16 rgSCHCfgVldtRgrUeACqiCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg(cellCb, crnti, acqiCfg,txMode, errInfo)
+S16 rgSCHCfgVldtRgrUeACqiCfg(cellCb, crnti, acqiCfg,txMode, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeAprdDlCqiCfg *acqiCfg;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode
+S16 rgSCHCfgVldtRgrTxmodePucchMode
(
RgSchCellCb *cellCb,
RgrTxMode txMde,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde, pucchMode,errInfo)
+S16 rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde, pucchMode,errInfo)
RgSchCellCb *cellCb;
RgrTxMode txMde;
RgrPrdCqiMode pucchMode;
*/
#ifdef LTEMAC_HDFDD
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg
+S16 rgSCHCfgVldtRgrUePCqiCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, hdFdd,
+S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, hdFdd,
txMode, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg
+S16 rgSCHCfgVldtRgrUePCqiCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, txMode, errInfo)
+S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, txMode, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUePrdDlCqiCfg *cqiCfg;
*/
#ifdef LTEMAC_HDFDD
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg
+S16 rgSCHCfgVldtRgrUeUlSrsCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, hdFdd, errInfo)
+S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, hdFdd, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeUlSrsCfg *srsCfg;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg
+S16 rgSCHCfgVldtRgrUeUlSrsCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, errInfo)
+S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeUlSrsCfg *srsCfg;
*/
#ifdef LTEMAC_HDFDD
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg
+S16 rgSCHCfgVldtRgrUeSrCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, hdFdd, errInfo)
+S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, hdFdd, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeSrCfg *srCfg;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg
+S16 rgSCHCfgVldtRgrUeSrCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, errInfo)
+S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeSrCfg *srCfg;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgACqiUeCfg
+S16 rgSCHCfgACqiUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ue,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgACqiUeCfg(cellCb,ue,acqiCb ueTxMode, aCqiCfg, ueCat)
+S16 rgSCHCfgACqiUeCfg(cellCb,ue,acqiCb ueTxMode, aCqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ue;
RgSchUeACqiCb *acqiCb;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgPCqiUeCfg
+S16 rgSCHCfgPCqiUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
+S16 rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUePrdDlCqiCfg *cqiCfg;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRiUeCfg
+S16 rgSCHCfgRiUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
+S16 rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUePrdDlCqiCfg *cqiCfg;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrsUeCfg
+S16 rgSCHCfgSrsUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg
)
#else
-PUBLIC S16 rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg)
+S16 rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeUlSrsCfg *srsCfg;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrUeCfg
+S16 rgSCHCfgSrUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg
)
#else
-PUBLIC S16 rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg)
+S16 rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeSrCfg *srCfg;
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgPCqiUeReCfg
+S16 rgSCHCfgPCqiUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgPCqiUeReCfg(cellCb, ueCb, cqiCfg, ueCat)
+S16 rgSCHCfgPCqiUeReCfg(cellCb, ueCb, cqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUePrdDlCqiCfg *cqiCfg;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrsUeReCfg
+S16 rgSCHCfgSrsUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg
)
#else
-PUBLIC S16 rgSCHCfgSrsUeReCfg(cellCb, ueCb, srsCfg)
+S16 rgSCHCfgSrsUeReCfg(cellCb, ueCb, srsCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeUlSrsCfg *srsCfg;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrUeReCfg
+S16 rgSCHCfgSrUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg
)
#else
-PUBLIC S16 rgSCHCfgSrUeReCfg(cellCb, ueCb, srCfg)
+S16 rgSCHCfgSrUeReCfg(cellCb, ueCb, srCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeSrCfg *srCfg;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgAcqiUeReCfg
+S16 rgSCHCfgAcqiUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgAcqiUeReCfg(cellCb, ueCb, acqiCfg, ueCat)
+S16 rgSCHCfgAcqiUeReCfg(cellCb, ueCb, acqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeAprdDlCqiCfg *acqiCfg;
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel
+S16 rgSCHCfgPCqiSrsSrUeDel
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel(cellCb, ueCb)
+S16 rgSCHCfgPCqiSrsSrUeDel(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetCfgPerOff
+S16 rgSCHUtlGetCfgPerOff
(
RgSchPerTbl tbl,
U16 cfgIdx,
U16 *offset
)
#else
-PUBLIC S16 rgSCHUtlGetCfgPerOff ( tbl, cfgIdx, peri, offset)
+S16 rgSCHUtlGetCfgPerOff ( tbl, cfgIdx, peri, offset)
RgSchPerTbl tbl;
U16 cfgIdx;
U16 *peri;
* @return VOID
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellFreeBuf
+Void rgSCHSCellFreeBuf
(
Inst inst,
RgSchUeCb *ue,
U8 idx
)
#else
-PUBLIC Void rgSCHSCellFreeBuf(inst ,ue, ueRecfg, idx)
+Void rgSCHSCellFreeBuf(inst ,ue, ueRecfg, idx)
Inst inst;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
U8 sbSize,
Bool isEcp
));
-PUBLIC Void rgSCHEmtcCmnUeCcchSduDel
+Void rgSCHEmtcCmnUeCcchSduDel
(
RgSchCellCb *cell,
RgSchUeCb *ueCb
#endif
-PUBLIC Void rgSCHCmnDlSpsSch
+Void rgSCHCmnDlSpsSch
(
RgSchCellCb *cell
);
RgSchCellCb *cell,
RgSchUeCb *ue));
#ifdef DL_LA
-PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa ARGS
+Void rgSCHCmnDlSetUeAllocLmtLa ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue
/* local defines */
-PUBLIC RgSchdApis rgSchCmnApis;
+ RgSchdApis rgSchCmnApis;
PRIVATE RgUlSchdApis rgSchUlSchdTbl[RGSCH_NUM_SCHEDULERS];
PRIVATE RgDlSchdApis rgSchDlSchdTbl[RGSCH_NUM_SCHEDULERS];
#ifdef EMTC_ENABLE
RgSchUeCb *ue,
U16 servCellId
));
-PUBLIC Bool rgSchCmnChkDataOnlyOnPcell
+Bool rgSchCmnChkDataOnlyOnPcell
(
RgSchUeCb *ue,
RgSchDlSf *dlSf
);
#endif /*LTE_ADV */
-PUBLIC U8 rgSCHCmnCalcPcqiBitSz
+U8 rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
U8 numTxAnt
));
#endif
-PUBLIC Bool rgSCHCmnRetxAllocAvoid ARGS((
+Bool rgSCHCmnRetxAllocAvoid ARGS((
RgSchDlSf *subFrm,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
));
-PUBLIC U16 rgSCHCmnGetSiSetId ARGS((
+U16 rgSCHCmnGetSiSetId ARGS((
U16 sfn,
U8 sf,
U16 minPeriodicity
/* CQI Offset Index to Beta CQI Offset value mapping,
* stored as parts per 1000. Reserved is set to 0.
* Refer 36.213 sec 8.6.3 Tbl 8.6.3-3 */
-PUBLIC U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
+U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
1250, 1375, 1625, 1750, 2000, 2250, 2500, 2875,
3125, 3500, 4000, 5000, 6250};
-PUBLIC U32 rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
+U32 rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
4000, 5000, 6250, 8000,10000, 12625, 15875, 20000,
31000, 50000,80000,126000,0};
-PUBLIC U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
+U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
2500, 3125, 4000, 5000, 6250, 8000, 10000,12625,
15875,20000,0,0,0};
-PUBLIC S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
+S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
/* Include CRS REs while calculating Efficiency */
CONSTANT PRIVATE U8 rgSchCmnAntIdx[5] = {0,0,1,0,2};
#ifdef TFU_UPGRADE
-PUBLIC S8 rgSchCmnApUeSelDiffCqi[4] = {1, 2, 3, 4};
-PUBLIC S8 rgSchCmnApEnbConfDiffCqi[4] = {0, 1, 2, -1};
+S8 rgSchCmnApUeSelDiffCqi[4] = {1, 2, 3, 4};
+S8 rgSchCmnApEnbConfDiffCqi[4] = {0, 1, 2, -1};
#endif
typedef struct rgSchCmnDlUeDciFrmtOptns
/* BI table from 36.321 Table 7.2.1 */
CONSTANT PRIVATE S16 rgSchCmnBiTbl[RG_SCH_CMN_NUM_BI_VAL] = {
0, 10, 20, 30,40,60,80,120,160,240,320,480,960};
-PUBLIC RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
+RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
{ 0, 0 },
{RGSCH_CMN_QM_CQI_1,RGSCH_CMN_UL_EFF_CQI_1 },
{RGSCH_CMN_QM_CQI_2,RGSCH_CMN_UL_EFF_CQI_2 },
#ifdef LTE_TDD
-PUBLIC RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl = {
+RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl = {
{RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME},
{RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME},
{RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME},
/* SPS_INTG_FIX */
#ifdef LTEMAC_SPS
-PUBLIC U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
+U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
/* 0 */ 6,
/* 1 */ 7,
/* 2 */ 8,
/* Special Subframes in OFDM symbols */
/* ccpu00134197-MOD-Correct the number of symbols */
-PUBLIC RgSchTddSplSubfrmInfoTbl rgSchTddSplSubfrmInfoTbl = {
+RgSchTddSplSubfrmInfoTbl rgSchTddSplSubfrmInfoTbl = {
{3, 1, 1, 3, 1, 1},
{9, 1, 1, 8, 1, 1},
{10, 1, 1, 9, 1, 1},
};
/* PHICH 'm' value Table */
-PUBLIC RgSchTddPhichMValTbl rgSchTddPhichMValTbl = {
+RgSchTddPhichMValTbl rgSchTddPhichMValTbl = {
{2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
{0, 1, 0, 0, 1, 0, 1, 0, 0, 1},
{0, 0, 0, 1, 0, 0, 0, 0, 1, 0},
};
/* PHICH 'K' value Table */
-PUBLIC RgSchTddKPhichTbl rgSchTddKPhichTbl = {
+RgSchTddKPhichTbl rgSchTddKPhichTbl = {
{0, 0, 4, 7, 6, 0, 0, 4, 7, 6},
{0, 0, 4, 6, 0, 0, 0, 4, 6, 0},
{0, 0, 6, 0, 0, 0, 0, 6, 0, 0},
};
/* Uplink association index 'K' value Table */
-PUBLIC RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl = {
+RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl = {
{0, 0, 6, 4, 0, 0, 0, 6, 4, 0},
{0, 0, 4, 0, 0, 0, 0, 4, 0, 0},
{0, 0, 4, 4, 4, 0, 0, 0, 0, 0},
/* PUSCH 'K' value Table */
-PUBLIC RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl = {
+RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{0, 6, 0, 0, 4, 0, 6, 0, 0, 4},
{0, 0, 0, 4, 0, 0, 0, 0, 4, 0},
/* PDSCH to PUCCH Table for DL Harq Feed back. Based on the
Downlink association set index 'K' table */
-PUBLIC U8 rgSchTddPucchTxTbl[7][10] = {
+U8 rgSchTddPucchTxTbl[7][10] = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{7, 6, 0, 0, 4, 7, 6, 0, 0, 4},
{7, 6, 0, 4, 8, 7, 6, 0, 4, 8},
So at sf4 the new CFI can be applied. To arrive at sf4 from
sf0, the sfIdx has to be increased by 3 */
-PUBLIC U8 rgSchTddPdcchSfIncTbl[7][10] = {
+U8 rgSchTddPdcchSfIncTbl[7][10] = {
/* A/N Bundl: 0,1,5,6*/ {2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
/* A/N Bundl: 0,4,5,9*/ {2, 2, 0, 0, 3, 2, 2, 0, 0, 3},
/* A/N Bundl: 4,9*/ {3, 6, 0, 5, 4, 3, 6, 0, 5, 4},
#ifdef LTEMAC_SPS
/* subframe offset values to be used when twoIntervalsConfig is enabled in UL
* SPS for a UE */
-PUBLIC RgSchTddSfOffTbl rgSchTddSfOffTbl = {
+RgSchTddSfOffTbl rgSchTddSfOffTbl = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 1, -1, 0, 0, 0, 1, -1, 0},
{0, 0, 5, 0, 0, 0, 0, -5, 0, 0},
* as that of Msg3SubfrmTbl, indicates competition with msg3.
* As of now, this is same as Msg3SubfrmTbl (leaving out uldlcfg 2),
* except that all 255s are now zeros. */
-PUBLIC RgSchTddSpsUlRsrvTbl rgSchTddSpsUlRsrvTbl = {
+RgSchTddSpsUlRsrvTbl rgSchTddSpsUlRsrvTbl = {
{0, 0, 0, 6, 8, 0, 0, 0, 6, 8},
{0, 0, 6, 9, 0, 0, 0, 6, 9, 0},
{0, 0, 10, 0, 0, 0, 0, 10, 0, 0},
};
/* Inverse DL Assoc Set index Table */
-PUBLIC RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl = {
+RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{7, 6, 0, 0, 4, 7, 6, 0, 0, 4},
{7, 6, 0, 4, 8, 7, 6, 0, 4, 8},
PRIVATE U8 rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
/* Downlink HARQ processes Table */
-PUBLIC RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
+RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
/* Uplink HARQ processes Table */
-PUBLIC RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl = { 4, 7, 10, 9, 12, 15, 6};
+RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl = { 4, 7, 10, 9, 12, 15, 6};
/* Downlink association index set 'K' value Table */
-PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlAscSetIdxKTbl = {
+RgSchTddDlAscSetIdxKTbl rgSchTddDlAscSetIdxKTbl = {
{ {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
{ {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
/* ccpu132282-ADD-the table rgSchTddDlAscSetIdxKTbl is rearranged in
* decreasing order of Km, this is used to calculate the NCE used for
* calculating N1Pucch Resource for Harq*/
-PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl = {
+RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl = {
{ {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
{ {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
/* Minimum number of Ack/Nack feeback information to be
stored for each UL-DL configuration */
-PUBLIC RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl = {4, 4, 2, 3, 2, 1, 5};
+RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl = {4, 4, 2, 3, 2, 1, 5};
/* Uplink switch points and number of UL subframes Table */
-PUBLIC RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl = {
+RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl = {
{2,3,3}, {2,2,2}, {2,1,1}, {1,3,0}, {1,2,0}, {1,1,0}, {2,3,2}
};
/* Uplink switch points and number of DL subframes Table */
-PUBLIC RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl = {
+RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl = {
{2,2,2}, {2,3,3}, {2,4,4}, {1,7,0}, {1,8,0}, {1,9,0}, {2,2,3}
};
/* Number of UL subframes present before a particular subframe */
-PUBLIC RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl = {
+RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl = {
{0, 0, 1, 2, 3, 3, 3, 4, 5, 6},
{0, 0, 1, 2, 2, 2, 2, 3, 4, 4},
{0, 0, 1, 1, 1, 1, 1, 2, 2, 2},
};
/* Number of DL subframes present till a particular subframe */
-PUBLIC RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl = {
+RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl = {
{1, 2, 2, 2, 2, 3, 4, 4, 4, 4},
{1, 2, 2, 2, 3, 4, 5, 5, 5, 6},
{1, 2, 2, 3, 4, 5, 6, 6, 7, 8},
/* Nearest possible UL subframe Index from UL subframe
* DL Index < UL Index */
-PUBLIC RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl = {
+RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl = {
{0, 1, 1, 1, 1, 5, 6, 6, 6, 6},
{0, 1, 1, 1, 4, 5, 6, 6, 6, 9},
{0, 1, 1, 3, 4, 5, 6, 6, 8, 9},
/* Nearest possible DL subframe Index from UL subframe
* DL Index > UL Index
* 10 represents Next SFN low DL Idx */
-PUBLIC RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl = {
+RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl = {
{0, 1, 5, 5, 5, 5, 6, 10, 10, 10},
{0, 1, 4, 4, 4, 5, 6, 9, 9, 9},
{0, 1, 3, 3, 4, 5, 6, 8, 8, 9},
};
/* RACH Message3 related information */
-PUBLIC RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl = {
+RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl = {
{7, 6, 255, 255, 255, 7, 6, 255, 255, 255},
{7, 6, 255, 255, 8, 7, 6, 255, 255, 8},
{7, 6, 255, 9, 8, 7, 6, 255, 9, 8},
867737, 1067031, 1312097, 1613447, 1984009, 2439678, 3000000, 3100000
};
-PUBLIC U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
+U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
-PUBLIC RgSchTbSzTbl rgTbSzTbl = {
+RgSchTbSzTbl rgTbSzTbl = {
{
{16, 32, 56, 88, 120, 152, 176, 208, 224, 256, 288, 328, 344, 376, 392, 424, 456, 488, 504, 536, 568, 600, 616, 648, 680, 712, 744, 776, 776, 808, 840, 872, 904, 936, 968, 1000, 1032, 1032, 1064, 1096, 1128, 1160, 1192, 1224, 1256, 1256, 1288, 1320, 1352, 1384, 1416, 1416, 1480, 1480, 1544, 1544, 1608, 1608, 1608, 1672, 1672, 1736, 1736, 1800, 1800, 1800, 1864, 1864, 1928, 1928, 1992, 1992, 2024, 2088, 2088, 2088, 2152, 2152, 2216, 2216, 2280, 2280, 2280, 2344, 2344, 2408, 2408, 2472, 2472, 2536, 2536, 2536, 2600, 2600, 2664, 2664, 2728, 2728, 2728, 2792, 2792, 2856, 2856, 2856, 2984, 2984, 2984, 2984, 2984, 3112},
{24, 56, 88, 144, 176, 208, 224, 256, 328, 344, 376, 424, 456, 488, 520, 568, 600, 632, 680, 712, 744, 776, 808, 872, 904, 936, 968, 1000, 1032, 1064, 1128, 1160, 1192, 1224, 1256, 1288, 1352, 1384, 1416, 1416, 1480, 1544, 1544, 1608, 1608, 1672, 1736, 1736, 1800, 1800, 1864, 1864, 1928, 1992, 1992, 2024, 2088, 2088, 2152, 2152, 2216, 2280, 2280, 2344, 2344, 2408, 2472, 2472, 2536, 2536, 2600, 2600, 2664, 2728, 2728, 2792, 2792, 2856, 2856, 2856, 2984, 2984, 2984, 3112, 3112, 3112, 3240, 3240, 3240, 3240, 3368, 3368, 3368, 3496, 3496, 3496, 3496, 3624, 3624, 3624, 3752, 3752, 3752, 3752, 3880, 3880, 3880, 4008, 4008, 4008},
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PUBLIC RgSchUeCb* rgSCHCmnGetHoUe ARGS((
+RgSchUeCb* rgSCHCmnGetHoUe ARGS((
RgSchCellCb *cell,
U16 rapId
));
RgSchCellCb *cell,
U8 preambleId
));
-PUBLIC RgSchUeCb* rgSCHCmnGetPoUe ARGS((
+RgSchUeCb* rgSCHCmnGetPoUe ARGS((
RgSchCellCb *cell,
U16 rapId,
CmLteTimingInfo timingInfo
RgSchCellCb *cell
));
-/*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now PUBLIC */
+/*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now */
PRIVATE Void rgSCHCmnUlRbAllocForLst ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchCmnDlRbAllocInfo *allocInfo,
RgInfSfAlloc *subfrmAlloc
));
-PUBLIC Bool rgSCHCmnChkInWin ARGS((
+Bool rgSCHCmnChkInWin ARGS((
CmLteTimingInfo frm,
CmLteTimingInfo start,
CmLteTimingInfo end
));
-PUBLIC Bool rgSCHCmnChkPastWin ARGS((
+Bool rgSCHCmnChkPastWin ARGS((
CmLteTimingInfo frm,
CmLteTimingInfo end
));
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnInit
+Void rgSCHCmnInit
(
)
#else
-PUBLIC Void rgSCHCmnInit()
+Void rgSCHCmnInit()
#endif
{
U8 idx;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlRlsSubFrm
+Void rgSCHCmnDlRlsSubFrm
(
RgSchCellCb *cell,
CmLteTimingInfo frm
)
#else
-PUBLIC Void rgSCHCmnDlRlsSubFrm(cell, frm)
+Void rgSCHCmnDlRlsSubFrm(cell, frm)
RgSchCellCb *cell;
CmLteTimingInfo frm;
#endif
*
*/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnChkInWin
+Bool rgSCHCmnChkInWin
(
CmLteTimingInfo frm,
CmLteTimingInfo start,
CmLteTimingInfo end
)
#else
-PUBLIC Bool rgSCHCmnChkInWin(frm, start, end)
+Bool rgSCHCmnChkInWin(frm, start, end)
CmLteTimingInfo frm;
CmLteTimingInfo start;
CmLteTimingInfo end;
*
*/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnChkPastWin
+Bool rgSCHCmnChkPastWin
(
CmLteTimingInfo frm,
CmLteTimingInfo end
)
#else
-PUBLIC Bool rgSCHCmnChkPastWin(frm, end)
+Bool rgSCHCmnChkPastWin(frm, end)
CmLteTimingInfo frm;
CmLteTimingInfo end;
#endif
*
**/
#ifdef ANSI
-PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc
+RgSchPdcch *rgSCHCmnCmnPdcchAlloc
(
RgSchCellCb *cell,
RgSchDlSf *subFrm
)
#else
-PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
+RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
#endif
**/
#ifdef LTEMAC_SPS
#ifdef ANSI
-PUBLIC Void rgSCHCmnClcRbAlloc
+Void rgSCHCmnClcRbAlloc
(
RgSchCellCb *cell,
U32 bo,
RgSchDlSf *sf
)
#else
-PUBLIC Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
+Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
RgSchCellCb *cell;
U32 bo;
U8 cqi;
*
**/
#ifdef ANSI
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc
+RgSchPdcch *rgSCHCmnPdcchAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isDtx
)
#else
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
+RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *subFrm;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocFillRbInfo
+Void rgSCHCmnUlAllocFillRbInfo
(
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
+Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa
+Void rgSCHCmnDlSetUeAllocLmtLa
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
+Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlHqPResetTemp
+Void rgSCHCmnDlHqPResetTemp
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlHqPResetTemp(hqP)
+Void rgSCHCmnDlHqPResetTemp(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlUeResetTemp
+Void rgSCHCmnDlUeResetTemp
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlUeResetTemp(ue, hqP)
+Void rgSCHCmnDlUeResetTemp(ue, hqP)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlUeResetTemp
+Void rgSCHCmnUlUeResetTemp
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlUeResetTemp(cell, ue)
+Void rgSCHCmnUlUeResetTemp(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnFillPdcch
+Void rgSCHCmnFillPdcch
(
RgSchCellCb *cell,
RgSchPdcch *pdcch,
RgSchDlRbAlloc *rbAllocInfo
)
#else
-PUBLIC Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
+Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
RgSchCellCb *cell;
RgSchPdcch *pdcch;
RgSchDlRbAlloc *rbAllocInfo;
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUpdDai
+U8 rgSCHCmnUpdDai
(
RgSchUeCb *ue,
CmLteTimingInfo *fdbkTime,
U8 *ulDai
)
#else
-PUBLIC U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
+U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
RgSchUeCb *ue;
CmLteTimingInfo *fdbkTime;
U8 m;
}
#endif /* ifdef LTE_TDD */
-PUBLIC U32 rgHqRvRetxCnt[4][2];
-PUBLIC U32 rgUlrate_grant;
+U32 rgHqRvRetxCnt[4][2];
+U32 rgUlrate_grant;
/**
* @brief This function fills the HqP TB with rbAllocInfo.
**/
#ifdef LTEMAC_SPS
#ifdef ANSI
-PUBLIC Void rgSCHCmnFillHqPTb
+Void rgSCHCmnFillHqPTb
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchPdcch *pdcch
)
#else
-PUBLIC Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
+Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
U8 tbAllocIdx;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnFillHqPPdcch
+Void rgSCHCmnFillHqPPdcch
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
+Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUpdVars
+Void rgSCHCmnUpdVars
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnUpdVars(cell)
+Void rgSCHCmnUpdVars(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetPhichUlSfIdx
+U8 rgSCHCmnGetPhichUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-PUBLIC U8 rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
+U8 rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetUlSfIdx
+U8 rgSCHCmnGetUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-PUBLIC U8 rgSCHCmnGetUlSfIdx(timeInfo, cell)
+U8 rgSCHCmnGetUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetUlHqProcIdx
+U8 rgSCHCmnGetUlHqProcIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-PUBLIC U8 rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
+U8 rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlFreeAlloc
+Void rgSCHCmnUlFreeAlloc
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlFreeAlloc(cell, alloc)
+Void rgSCHCmnUlFreeAlloc(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlFreeAllocation
+Void rgSCHCmnUlFreeAllocation
(
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
+Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
* -# NULLP when unsuccessful
**/
#ifdef ANSI
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
+RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
+RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocFillNdmrs
+Void rgSCHCmnUlAllocFillNdmrs
(
RgSchCmnUlCell *cellUl,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
+Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
RgSchCmnUlCell *cellUl;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocLnkHqProc
+Void rgSCHCmnUlAllocLnkHqProc
(
RgSchUeCb *ue,
RgSchUlAlloc *alloc,
Bool isRetx
)
#else
-PUBLIC Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
+Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
RgSchUeCb *ue;
RgSchUlAlloc *alloc;
RgSchUlHqProcCb *proc;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnPdcchRlsCrntSf
+Void rgSCHCmnPdcchRlsCrntSf
(
RgSchCellCb *cell,
RgSchPdcch *pdcch
)
#else
-PUBLIC Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
+Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
RgSchCellCb *cell;
RgSchPdcch *pdcch;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc
+Void rgSCHCmnUlFillPdcchWithAlloc
(
RgSchPdcch *pdcch,
RgSchUlAlloc *alloc,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
+Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
RgSchPdcch *pdcch;
RgSchUlAlloc *alloc;
RgSchUeCb *ue;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocFillTpc
+Void rgSCHCmnUlAllocFillTpc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
+Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchUlAlloc *alloc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUeReset
+Void rgSCHCmnUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUeReset(cell, ue)
+Void rgSCHCmnUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnActvtUlUe
+Void rgSCHCmnActvtUlUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnActvtUlUe(cell, ue)
+Void rgSCHCmnActvtUlUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnActvtDlUe
+Void rgSCHCmnActvtDlUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnActvtDlUe(cell, ue)
+Void rgSCHCmnActvtDlUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdlUlTransInd
+Void rgSCHCmnHdlUlTransInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
+Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
**/
/*KWORK_FIX:Changed function return type to void */
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlDeInitHqEnt
+Void rgSCHCmnDlDeInitHqEnt
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqE
)
#else
-PUBLIC Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
+Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
RgSchCellCb *cell;
RgSchDlHqEnt *hqE;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnDlInitHqEnt
+S16 rgSCHCmnDlInitHqEnt
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqEnt
)
#else
-PUBLIC S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
+S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
RgSchCellCb *cell;
RgSchDlHqEnt *hqEnt;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrSCellUeCfg
+S16 rgSCHCmnRgrSCellUeCfg
(
RgSchCellCb *sCell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
+S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
RgSchCellCb *sCell;
RgSchUeCb *ue;
RgrUeSecCellCfg *sCellInfoCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrSCellUeDel
+S16 rgSCHCmnRgrSCellUeDel
(
RgSchUeCellInfo *sCellInfo,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
+S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
RgSchUeCellInfo *sCellInfo;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmn5gtfUeCfg
+S16 rgSCHCmn5gtfUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCfg *cfg
)
#else
-PUBLIC S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
+S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *cfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrUeCfg
+S16 rgSCHCmnRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
+S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrUeRecfg
+S16 rgSCHCmnRgrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUeDel
+Void rgSCHCmnUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUeDel(cell, ue)
+Void rgSCHCmnUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlCalcReqRbCeil
+U8 rgSCHCmnUlCalcReqRbCeil
(
U32 bytes,
U8 cqi,
RgSchCmnUlCell *cellUl
)
#else
-PUBLIC U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
+U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
U32 bytes;
U8 cqi;
RgSchCmnUlCell *cellUl;
return ROK;
}
-PUBLIC U32 gPrntPucchDet=0;
+U32 gPrntPucchDet=0;
#ifdef LTE_TDD
/***********************************************************
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrCellCfg
+S16 rgSCHCmnRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
+S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrCellRecfg
+S16 rgSCHCmnRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
+S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
RgSchErrInfo *err;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnCellDel
+Void rgSCHCmnCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnCellDel(cell)
+Void rgSCHCmnCellDel(cell)
RgSchCellCb *cell;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLchCfg
+S16 rgSCHCmnRgrLchCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
+S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLchRecfg
+S16 rgSCHCmnRgrLchRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
+S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLcgCfg
+S16 rgSCHCmnRgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
+S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLcgRecfg
+S16 rgSCHCmnRgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
+S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
* File :
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLchDel
+S16 rgSCHCmnRgrLchDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
+S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnLcgDel
+Void rgSCHCmnLcgDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg
)
#else
-PUBLIC Void rgSCHCmnLcgDel(cell, ue, lcg)
+Void rgSCHCmnLcgDel(cell, ue, lcg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnFreeDlLc
+Void rgSCHCmnFreeDlLc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHCmnFreeDlLc(cell, ue, svc)
+Void rgSCHCmnFreeDlLc(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetBiIndex
+U8 rgSCHCmnGetBiIndex
(
RgSchCellCb *cell,
U32 ueCount
)
#else
-PUBLIC U8 rgSCHCmnGetBiIndex(cell, ueCount)
+U8 rgSCHCmnGetBiIndex(cell, ueCount)
RgSchCellCb *cell;
U32 ueCount;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAdd2CntResLst
+Void rgSCHCmnUlAdd2CntResLst
(
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
+Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
RgSchCmnUlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAdd2UeLst
+Void rgSCHCmnUlAdd2UeLst
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
+Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnAllocUlRb
+Void rgSCHCmnAllocUlRb
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHCmnAllocUlRb(cell, allocInfo)
+Void rgSCHCmnAllocUlRb(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst
+Void rgSCHCmnUlRbAllocAddUeToLst
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLListCp *lst
)
#else
-PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
+Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLListCp *lst;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlAllocFnlz
+Void rgSCHCmnDlAllocFnlz
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDlAllocFnlz(cell)
+Void rgSCHCmnDlAllocFnlz(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnSndCnsldtInfo
+Void rgSCHCmnSndCnsldtInfo
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnSndCnsldtInfo(cell)
+Void rgSCHCmnSndCnsldtInfo(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnCnsldtSfAlloc
+Void rgSCHCmnCnsldtSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnCnsldtSfAlloc(cell)
+Void rgSCHCmnCnsldtSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnInitUlRbAllocInfo
+Void rgSCHCmnInitUlRbAllocInfo
(
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
+Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSchCmnUpdCfiDb
+Void rgSchCmnUpdCfiDb
(
RgSchCellCb *cell,
U8 delta
)
#else
-PUBLIC Void rgSchCmnUpdCfiDb(cell, delta)
+Void rgSchCmnUpdCfiDb(cell, delta)
RgSchCellCb *cell;
U8 delta;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlCommonChSch
+Void rgSCHCmnDlCommonChSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDlCommonChSch(cell)
+Void rgSCHCmnDlCommonChSch(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlSch
+Void rgSCHCmnUlSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnUlSch(cell)
+Void rgSCHCmnUlSch(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlDedBoUpd
+Void rgSCHCmnDlDedBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
+Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnRmvFrmTaLst
+Void rgSCHCmnRmvFrmTaLst
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnRmvFrmTaLst(cell, ue)
+Void rgSCHCmnRmvFrmTaLst(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx
+Void rgSCHCmnDlMsg4ProcRmvFrmRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
+Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlProcAddToRetx
+Void rgSCHCmnDlProcAddToRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlProcAddToRetx(cell, hqP)
+Void rgSCHCmnDlProcAddToRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlCqiInd
+Void rgSCHCmnDlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
+Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isPucchInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnSrsInd
+Void rgSCHCmnSrsInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
+Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuSrsRpt *srsRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlTARpt
+Void rgSCHCmnDlTARpt
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnDlTARpt(cell, ue)
+Void rgSCHCmnDlTARpt(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlCqiInd
+Void rgSCHCmnUlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo
)
#else
-PUBLIC Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
+Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuUlCqiRpt *ulCqiInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlHqProcForUe
+Void rgSCHCmnUlHqProcForUe
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
RgSchUlHqProcCb **procRef
)
#else
-PUBLIC Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
+Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
RgSchCellCb *cell;
CmLteTimingInfo frm;
RgSchUeCb *ue;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdUlHqProc
+S16 rgSCHCmnUpdUlHqProc
(
RgSchCellCb *cell,
RgSchUlHqProcCb *curProc,
RgSchUlHqProcCb *oldProc
)
#else
-PUBLIC S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
+S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
RgSchCellCb *cell;
RgSchUlHqProcCb *curProc;
RgSchUlHqProcCb *oldProc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnBsrTmrExpry
+S16 rgSCHCmnBsrTmrExpry
(
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHCmnBsrTmrExpry(ueCb)
+S16 rgSCHCmnBsrTmrExpry(ueCb)
RgSchUeCb *ueCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdBsrShort
+S16 rgSCHCmnUpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
+S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdBsrTrunc
+S16 rgSCHCmnUpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
+S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdBsrLong
+S16 rgSCHCmnUpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
+S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 *bsArr;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdExtPhr
+S16 rgSCHCmnUpdExtPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
+S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfExtPhrCEInfo *extPhr;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdPhr
+S16 rgSCHCmnUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
+S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 phr;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnContResUlGrant
+S16 rgSCHCmnContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnContResUlGrant(cell, ue, err)
+S16 rgSCHCmnContResUlGrant(cell, ue, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnSrRcvd
+S16 rgSCHCmnSrRcvd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
+S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq
+RgSchUlAlloc *rgSCHCmnFirstRcptnReq
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
+RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
RgSchCellCb *cell;
#endif
{
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq
+RgSchUlAlloc *rgSCHCmnNextRcptnReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
+RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl
+Void rgSCHCmnDrxStrtInActvTmrInUl
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
+Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
RgSchCellCb *cell;
#endif
{
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
+RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
(
RgSchCellCb *cell,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
+RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
U8 idx;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
+RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
+RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
U8 idx;
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs
+U8 rgSCHCmnUlGetITbsFrmIMcs
(
U8 iMcs
)
#else
-PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
+U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
U8 iMcs;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs
+U8 rgSCHCmnUlGetIMcsFrmITbs
(
U8 iTbs,
CmLteUeCategory ueCtg
)
#else
-PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
+U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
U8 iTbs;
CmLteUeCategory ueCtg;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs
+U32 rgSCHCmnUlMinTbBitsForITbs
(
RgSchCmnUlCell *cellUl,
U8 iTbs
)
#else
-PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
+U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
RgSchCmnUlCell *cellUl;
U8 iTbs;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc
+RgSchUlAlloc *rgSCHCmnUlSbAlloc
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
+RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlUeFillAllocInfo
+Void rgSCHCmnUlUeFillAllocInfo
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
+Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlRecordUeAlloc
+Void rgSCHCmnUlRecordUeAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlRecordUeAlloc(cell, ue)
+Void rgSCHCmnUlRecordUeAlloc(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlRecMsg3Alloc
+Void rgSCHCmnUlRecMsg3Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchRaCb *raCb
)
#else
-PUBLIC Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
+Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchRaCb *raCb;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlUpdOutStndAlloc
+Void rgSCHCmnUlUpdOutStndAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 alloc
)
#else
-PUBLIC Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
+Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 alloc;
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetITbs
+U8 rgSCHCmnUlGetITbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
+U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isEcp;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUpdVars
+Void rgSCHCmnUpdVars
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnUpdVars(cell)
+Void rgSCHCmnUpdVars(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetPValFrmCCE
+U8 rgSCHCmnGetPValFrmCCE
(
RgSchCellCb *cell,
U8 cce
)
#else
-PUBLIC U8 rgSCHCmnGetPValFrmCCE(cell, cce)
+U8 rgSCHCmnGetPValFrmCCE(cell, cce)
RgSchCellCb *cell;
U8 cce;
#endif
*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHCmnGetHoUe
+RgSchUeCb* rgSCHCmnGetHoUe
(
RgSchCellCb *cell,
U16 rapId
)
#else
-PUBLIC RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
+RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
RgSchCellCb *cell;
U16 rapId
#endif
*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHCmnGetPoUe
+RgSchUeCb* rgSCHCmnGetPoUe
(
RgSchCellCb *cell,
U16 rapId,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
+RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
RgSchCellCb *cell;
U16 rapId;
CmLteTimingInfo timingInfo;
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetCqi
+U8 rgSCHCmnUlGetCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteUeCategory ueCtgy
)
#else
-PUBLIC U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
+U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteUeCategory ueCtgy;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnRlsUlSf
+Void rgSCHCmnRlsUlSf
(
RgSchCellCb *cell,
U8 idx
)
#else
-PUBLIC Void rgSCHCmnRlsUlSf(cell, idx)
+Void rgSCHCmnRlsUlSf(cell, idx)
RgSchCellCb *cell;
U8 idx;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlGetRbgInfo
+Void rgSCHCmnDlGetRbgInfo
(
U8 dlTotalBw,
U8 dlSubsetBw,
RgSchBwRbgInfo *rbgInfo
)
#else
-PUBLIC Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
+Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
rbgSize, rbgInfo)
U8 dlTotalBw;
U8 dlSubsetBw;
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnDlRaType0Alloc
+U8 rgSCHCmnDlRaType0Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
U8 rbsReq,
Bool isPartialAlloc
)
#else
-PUBLIC U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
+U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
numAllocRbs, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
U8 rbsReq;
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnDlRaType1Alloc
+U8 rgSCHCmnDlRaType1Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
U8 rbsReq,
Bool isPartialAlloc
)
#else
-PUBLIC U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
+U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
allocRbgSubset, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
U8 rbsReq;
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnDlRaType2Alloc
+U8 rgSCHCmnDlRaType2Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
U8 rbsReq,
Bool isPartialAlloc
)
#else
-PUBLIC U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
+U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
U8 rbsReq;
* RFAILED failed
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnAllocUeInSpsBw
+Bool rgSCHCmnAllocUeInSpsBw
(
RgSchDlSf *dlSf,
RgSchCellCb *cell,
Bool isPartialAlloc
)
#else
-PUBLIC Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
+Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
RgSchDlSf *dlSf;
RgSchCellCb *cell;
RgSchUeCb *ue;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
+Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
U8 numRb
)
#else
-PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
+Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
U8 rbStrt;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc
+Void rgSCHCmnNonDlfsDedRbAlloc
(
RgSchCellCb *cell,
RgSchCmnUeRbAlloc *allocInfo,
CmLListCp *nonSchdHqPLst
)
#else
-PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
+Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
schdHqPLst, nonSchdHqPLst)
RgSchCellCb *cell;
RgSchCmnUeRbAlloc *allocInfo;
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnNonDlfsRbAlloc
+Void rgSCHCmnNonDlfsRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
+Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
**********************************************************/
#ifdef LTEMAC_SPS
#ifdef ANSI
-PUBLIC U32 rgSCHCmnCalcRiv
+U32 rgSCHCmnCalcRiv
(
U8 bw,
U8 rbStart,
U8 numRb
)
#else
-PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
+U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
U8 bw;
U8 rbStart;
U8 numRb;
#endif
#else
#ifdef ANSI
-PUBLIC U32 rgSCHCmnCalcRiv
+U32 rgSCHCmnCalcRiv
(
U8 bw,
U8 rbStart,
U8 numRb
)
#else
-PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
+U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
U8 bw;
U8 rbStart;
U8 numRb;
*
**/
#ifdef ANSI
-PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt
+TfuDciFormat rgSCHCmnSlctPdcchFrmt
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 *raType
)
#else
-PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
+TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 *raType;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnDlAllocTxRb
+S16 rgSCHCmnDlAllocTxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PUBLIC S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
*
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnRetxAvoidTdd
+Bool rgSCHCmnRetxAvoidTdd
(
RgSchDlSf *curSf,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
)
#else
-PUBLIC Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
+Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
RgSchDlSf *curSf;
RgSchCellCb *cell;
RgSchDlHqProcCb *proc;
*
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnRetxAllocAvoid
+Bool rgSCHCmnRetxAllocAvoid
(
RgSchDlSf *subFrm,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
)
#else
-PUBLIC Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
+Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
RgSchDlSf *subFrm;
RgSchCellCb *cell;
RgSchDlHqProcCb *proc;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnDlAllocRetxRb
+S16 rgSCHCmnDlAllocRetxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PUBLIC S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnRdcImcsTxTb
+Void rgSCHCmnRdcImcsTxTb
(
RgSchDlRbAlloc *allocInfo,
U8 tbInfoIdx,
U32 cnsmdBytes
)
#else
-PUBLIC Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
+Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
RgSchDlRbAlloc *allocInfo;
U8 tbInfoIdx;
U32 cnsmdBytes;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlRelPdcchFbk
+Void rgSCHCmnDlRelPdcchFbk
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isAck
)
#else
-PUBLIC Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
+Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isAck;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlProcAck
+Void rgSCHCmnDlProcAck
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlProcAck(cell, hqP)
+Void rgSCHCmnDlProcAck(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdlCrntiCE
+Void rgSCHCmnHdlCrntiCE
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnHdlCrntiCE(cell, ue)
+Void rgSCHCmnHdlCrntiCE(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlSpsRelInd
+Void rgSCHCmnUlSpsRelInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isExplRel
)
#else
-PUBLIC Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
+Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isExplRel;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlSpsActInd
+Void rgSCHCmnUlSpsActInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U16 spsSduSize
)
#else
-PUBLIC Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
+Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
RgSchCellCb *cell;
RgSchUeCb *ue;
U16 spsSduSize;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlCrcInd
+Void rgSCHCmnUlCrcInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo crcTime
)
#else
-PUBLIC Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
+Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo crcTime;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlCrcFailInd
+Void rgSCHCmnUlCrcFailInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo crcTime
)
#else
-PUBLIC Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
+Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo crcTime;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnChkRetxAllowDtx
+Void rgSCHCmnChkRetxAllowDtx
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
Bool *reTxAllwd
)
#else
-PUBLIC Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
+Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
RgSchDlHqProcCb *proc;
* @return U16 siSetId
**/
#ifdef ANSI
-PUBLIC U16 rgSCHCmnGetSiSetId
+U16 rgSCHCmnGetSiSetId
(
U16 sfn,
U8 sf,
U16 minPeriodicity
)
#else
-PUBLIC U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
+U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
U16 sfn;
U8 sf
U16 minPeriodicity;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUpdUeDataIndLcg
+Void rgSCHCmnUpdUeDataIndLcg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgInfUeDatInd *datInd
)
#else
-PUBLIC Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
+Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfUeDatInd *datInd;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchCheckAndTriggerModeChange
+Void rgSchCheckAndTriggerModeChange
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 maxiTbs
)
#else
-PUBLIC Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
+Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 reportediTbs;
* @return Void
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnIsDlCsgPrio
+Bool rgSCHCmnIsDlCsgPrio
(
RgSchCellCb *cell
)
#else
-PUBLIC Bool rgSCHCmnIsDlCsgPrio(cell)
+Bool rgSCHCmnIsDlCsgPrio(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnIsUlCsgPrio
+Bool rgSCHCmnIsUlCsgPrio
(
RgSchCellCb *cell
)
#else
-PUBLIC Bool rgSCHCmnIsUlCsgPrio(cell)
+Bool rgSCHCmnIsUlCsgPrio(cell)
RgSchCellCb *cell;
#endif
{
*
*/
#ifdef ANSI
- PUBLIC Void rgSchCmnPreDlSch
+ Void rgSchCmnPreDlSch
(
RgSchCellCb **cell,
U8 nCell,
RgSchCellCb **cellLst
)
#else
-PUBLIC Void rgSchCmnPreDlSch(cell, nCell, cellLst)
+Void rgSchCmnPreDlSch(cell, nCell, cellLst)
RgSchCellCb **cell;
U8 nCell;
RgSchCellCb **cellLst;
*
*/
#ifdef ANSI
-PUBLIC Void rgSchCmnPstDlSch
+Void rgSchCmnPstDlSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSchCmnPstDlSch(cell)
+Void rgSchCmnPstDlSch(cell)
RgSchCellCb *cell
#endif
{
}
#ifdef ANSI
-PUBLIC U8 rgSCHCmnCalcPcqiBitSz
+U8 rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
U8 numTxAnt
)
#else
-PUBLIC U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
+U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
RgSchUeCb *ueCb;
U8 numTxAnt;
#endif
*
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlSch
+Void rgSCHCmnDlSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDlSch (cell)
+Void rgSCHCmnDlSch (cell)
RgSchCellCb *cell;
#endif
{
/* Added periodic BSR timer */
-/*ccpu00117180 - ADD - Added Prototype in .x since the function access is now PUBLIC */
-PUBLIC Void rgSCHCmnUpdVars ARGS((
+/*ccpu00117180 - ADD - Added Prototype in .x since the function access is now */
+Void rgSCHCmnUpdVars ARGS((
RgSchCellCb *cell
));
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-EXTERN PUBLIC Bool rgSCHCmnIsDlCsgPrio ARGS((
+EXTERN Bool rgSCHCmnIsDlCsgPrio ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC Bool rgSCHCmnIsUlCsgPrio ARGS((
+EXTERN Bool rgSCHCmnIsUlCsgPrio ARGS((
RgSchCellCb *cell
));
EXTERN S16 rgSCHCmnDlAllocRetxRb ARGS((
Bool isSpsBo,
RgSchDlSf *sf
));
-PUBLIC U32 rgSCHCmnCalcRiv ARGS((
+U32 rgSCHCmnCalcRiv ARGS((
U8 bw,
U8 rbStart,
U8 numRb
RgSchDlHqEnt *hqEnt
));
-EXTERN PUBLIC Void rgSchCmnDlSfHqDel
+EXTERN Void rgSchCmnDlSfHqDel
ARGS((
RgSchUeCb *ue,
RgSchCellCb *cell
));
-EXTERN PUBLIC Void rgSCHCmnDlDeInitHqEnt
+EXTERN Void rgSCHCmnDlDeInitHqEnt
ARGS((
RgSchCellCb *cell,
RgSchDlHqEnt *hqE
));
-EXTERN PUBLIC U8 rgSCHCmnUlGetCqi
+EXTERN U8 rgSCHCmnUlGetCqi
ARGS ((
RgSchCellCb *cell,
RgSchUeCb *ue,
PRIVATE Void rgSCHDbmInitPndngRgrCfgLst ARGS(( RgSchCellCb *cellCb));
#ifdef EMTC_ENABLE
-PUBLIC S16 rgSCHDbmPutEmtcRnti ARGS((RgSchCellCb *cellCb,RgSchRntiLnk *rntiLnk));
+ S16 rgSCHDbmPutEmtcRnti ARGS((RgSchCellCb *cellCb,RgSchRntiLnk *rntiLnk));
#endif
/* local typedefs */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInitCell
+S16 rgSCHDbmInitCell
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmInitCell(cellCb)
+S16 rgSCHDbmInitCell(cellCb)
RgSchCellCb *cellCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDeInitUeCbLst
+S16 rgSCHDbmDeInitUeCbLst
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmDeInitUeCbLst(cellCb)
+S16 rgSCHDbmDeInitUeCbLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDeInitSpsUeCbLst
+S16 rgSCHDbmDeInitSpsUeCbLst
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmDeInitSpsUeCbLst(cellCb)
+S16 rgSCHDbmDeInitSpsUeCbLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInsUeCb
+S16 rgSCHDbmInsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmInsUeCb(cellCb, ueCb)
+S16 rgSCHDbmInsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInsSpsUeCb
+S16 rgSCHDbmInsSpsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmInsSpsUeCb(cellCb, ueCb)
+S16 rgSCHDbmInsSpsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetUeCb
+RgSchUeCb* rgSCHDbmGetUeCb
(
RgSchCellCb *cellCb,
CmLteRnti ueId
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetUeCb(cellCb, ueId)
+RgSchUeCb* rgSCHDbmGetUeCb(cellCb, ueId)
RgSchCellCb *cellCb;
CmLteRnti ueId;
#endif
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetSpsUeCb
+RgSchUeCb* rgSCHDbmGetSpsUeCb
(
RgSchCellCb *cellCb,
CmLteRnti spsRnti
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetSpsUeCb(cellCb, spsRnti)
+RgSchUeCb* rgSCHDbmGetSpsUeCb(cellCb, spsRnti)
RgSchCellCb *cellCb;
CmLteRnti spsRnti;
#endif
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetNextUeCb
+RgSchUeCb* rgSCHDbmGetNextUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetNextUeCb(cellCb, ueCb)
+RgSchUeCb* rgSCHDbmGetNextUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetNextSpsUeCb
+RgSchUeCb* rgSCHDbmGetNextSpsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetNextSpsUeCb(cellCb, ueCb)
+RgSchUeCb* rgSCHDbmGetNextSpsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDelL2MUe
+S16 rgSCHDbmDelL2MUe
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmDelL2MUe(cellCb, ueCb)
+S16 rgSCHDbmDelL2MUe(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDelUeCb
+S16 rgSCHDbmDelUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmDelUeCb(cellCb, ueCb)
+S16 rgSCHDbmDelUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDelSpsUeCb
+S16 rgSCHDbmDelSpsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmDelSpsUeCb(cellCb, ueCb)
+S16 rgSCHDbmDelSpsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInitUe
+S16 rgSCHDbmInitUe
(
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmInitUe(ueCb)
+S16 rgSCHDbmInitUe(ueCb)
RgSchUeCb *ueCb;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsDlDedLcCb
+Void rgSCHDbmInsDlDedLcCb
(
RgSchUeCb *ueCb,
RgSchDlLcCb *dlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsDlDedLcCb(ueCb, dlLcCb)
+Void rgSCHDbmInsDlDedLcCb(ueCb, dlLcCb)
RgSchUeCb *ueCb;
RgSchDlLcCb *dlLcCb;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmDelDlDedLcCb
+Void rgSCHDbmDelDlDedLcCb
(
RgSchUeCb *ueCb,
RgSchDlLcCb *dlLcCb
)
#else
-PUBLIC Void rgSCHDbmDelDlDedLcCb(ueCb, dlLcCb)
+Void rgSCHDbmDelDlDedLcCb(ueCb, dlLcCb)
RgSchUeCb *ueCb;
RgSchDlLcCb *dlLcCb;
#endif
* @return RgSchDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchDlLcCb* rgSCHDbmGetDlDedLcCb
+RgSchDlLcCb* rgSCHDbmGetDlDedLcCb
(
RgSchUeCb *ueCb,
CmLteLcId idx
)
#else
-PUBLIC RgSchDlLcCb* rgSCHDbmGetDlDedLcCb(ueCb, idx)
+RgSchDlLcCb* rgSCHDbmGetDlDedLcCb(ueCb, idx)
RgSchUeCb *ueCb;
CmLteLcId idx;
#endif
* @return RgSchDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb
+RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb
(
RgSchUeCb *ueCb
)
#else
-PUBLIC RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb(ueCb)
+RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb(ueCb)
RgSchUeCb *ueCb;
#endif
{
* @return RgSchDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb
+RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb
(
RgSchUeCb *ueCb,
RgSchDlLcCb *lcCb
)
#else
-PUBLIC RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb(ueCb, lcCb)
+RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb(ueCb, lcCb)
RgSchUeCb *ueCb;
RgSchDlLcCb *lcCb;
#endif
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb
+RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb
(
RgSchCellCb *cellCb,
CmLteLcId lcId
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb(cellCb, lcId)
+RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb(cellCb, lcId)
RgSchCellCb *cellCb;
CmLteLcId lcId;
#endif
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch
+RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch(cellCb)
RgSchCellCb *cellCb;
#endif
{
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch
+RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch(cellCb)
RgSchCellCb *cellCb;
#endif
{
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch
+RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch(cellCb)
RgSchCellCb *cellCb;
#endif
{
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetPcch
+RgSchClcDlLcCb* rgSCHDbmGetPcch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetPcch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetPcch(cellCb)
RgSchCellCb *cellCb;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsBcchOnBch
+Void rgSCHDbmInsBcchOnBch
(
RgSchCellCb *cellCb,
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsBcchOnBch(cellCb, cmnDlLcCb)
+Void rgSCHDbmInsBcchOnBch(cellCb, cmnDlLcCb)
RgSchCellCb *cellCb;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsBcchOnDlsch
+Void rgSCHDbmInsBcchOnDlsch
(
RgSchCellCb *cellCb,
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsBcchOnDlsch(cellCb, cmnDlLcCb)
+Void rgSCHDbmInsBcchOnDlsch(cellCb, cmnDlLcCb)
RgSchCellCb *cellCb;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsPcch
+Void rgSCHDbmInsPcch
(
RgSchCellCb *cellCb,
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsPcch(cellCb, cmnDlLcCb)
+Void rgSCHDbmInsPcch(cellCb, cmnDlLcCb)
RgSchCellCb *cellCb;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInitCmnLcBoLst
+Void rgSCHDbmInitCmnLcBoLst
(
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInitCmnLcBoLst(cmnDlLcCb)
+Void rgSCHDbmInitCmnLcBoLst(cmnDlLcCb)
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsCmnLcBoRpt
+Void rgSCHDbmInsCmnLcBoRpt
(
RgSchClcDlLcCb *cmnDlLcCb,
RgSchClcBoRpt *cmnBoRpt
)
#else
-PUBLIC Void rgSCHDbmInsCmnLcBoRpt(cmnDlLcCb, cmnBoRpt)
+Void rgSCHDbmInsCmnLcBoRpt(cmnDlLcCb, cmnBoRpt)
RgSchClcDlLcCb *cmnDlLcCb;
RgSchClcBoRpt *cmnBoRpt;
#endif
* @return RgSchRaCb*
**/
#ifdef ANSI
-PUBLIC RgSchRaCb* rgSCHDbmGetRaCb
+RgSchRaCb* rgSCHDbmGetRaCb
(
RgSchCellCb *cellCb,
CmLteRnti key
)
#else
-PUBLIC RgSchRaCb* rgSCHDbmGetRaCb(cellCb, key)
+RgSchRaCb* rgSCHDbmGetRaCb(cellCb, key)
RgSchCellCb *cellCb;
CmLteRnti key;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsCrntRgrCfgElem
+Void rgSCHDbmInsCrntRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC Void rgSCHDbmInsCrntRgrCfgElem(cellCb, cfgElem)
+Void rgSCHDbmInsCrntRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsPndngRgrCfgElem
+Void rgSCHDbmInsPndngRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC Void rgSCHDbmInsPndngRgrCfgElem(cellCb, cfgElem)
+Void rgSCHDbmInsPndngRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem
+RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem
+RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey
+RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey
(
RgSchCellCb *cellCb,
CmLteTimingInfo key
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey(cellCb, key)
+RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey(cellCb, key)
RgSchCellCb *cellCb;
CmLteTimingInfo key;
#endif
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem
+RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem
+RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmRntiDbInit
+S16 rgSCHDbmRntiDbInit
(
RgSchCellCb *cellCb,
U16 rntiStart,
U16 maxRntis
)
#else
-PUBLIC S16 rgSCHDbmRntiDbInit(cellCb, rntiStart, maxRntis)
+S16 rgSCHDbmRntiDbInit(cellCb, rntiStart, maxRntis)
RgSchCellCb *cellCb;
U16 rntiStart;
U16 maxRntis;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmRntiDbDeInit
+Void rgSCHDbmRntiDbDeInit
(
RgSchCellCb *cellCb
)
#else
-PUBLIC Void rgSCHDbmRntiDbDeInit(cellCb)
+Void rgSCHDbmRntiDbDeInit(cellCb)
RgSchCellCb *cellCb;
#endif
{
* @return RgSchRntiLnk*
**/
#ifdef ANSI
-PUBLIC RgSchRntiLnk* rgSCHDbmGetRnti
+RgSchRntiLnk* rgSCHDbmGetRnti
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchRntiLnk* rgSCHDbmGetRnti(cellCb)
+RgSchRntiLnk* rgSCHDbmGetRnti(cellCb)
RgSchCellCb *cellCb;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmRlsRnti
+Void rgSCHDbmRlsRnti
(
RgSchCellCb *cellCb,
RgSchRntiLnk *rntiLnk
)
#else
-PUBLIC Void rgSCHDbmRlsRnti(cellCb, rntiLnk)
+Void rgSCHDbmRlsRnti(cellCb, rntiLnk)
RgSchCellCb *cellCb;
RgSchRntiLnk *rntiLnk;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDeInitUeTfuPendLst
+S16 rgSCHDbmDeInitUeTfuPendLst
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmDeInitUeTfuPendLst(cellCb)
+S16 rgSCHDbmDeInitUeTfuPendLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
extern U32 rgNumSPSSchedDropMaxRetx;
extern U32 rgNumActDtx;
#endif
-PUBLIC U32 nackSf[10];
+U32 nackSf[10];
#ifdef MAC_SCH_STATS
-PUBLIC RgSchNackAckStats hqFailStats;
-PUBLIC RgSchHqRetxStats hqRetxStats;
+RgSchNackAckStats hqFailStats;
+RgSchHqRetxStats hqRetxStats;
#endif /* MAC_SCH_STATS */
//Chandan Stats Collection
#ifdef DLHQ_STATS
PRIVATE Void rgSCHDhmFdbkIndHndlTa ARGS((RgSchDlHqProcCb *hqP, U8 tbIdx, U8 fdbk,
Bool maxHqRetxReached));
-PUBLIC void rgEmtcsetNullSubFrm ARGS((RgSchDlHqProcCb *hqP));
+void rgEmtcsetNullSubFrm ARGS((RgSchDlHqProcCb *hqP));
#ifndef LTE_TDD
PRIVATE S16 rgSCHDhmProcHqFdbkAckNackRep ARGS((
RgSchDlHqProcCb *hqP,
/* Freeing up the HARQ proc blocked for
* indefinite time in case of Retx */
-PUBLIC S16 rgSCHDhmDlRetxAllocFail ARGS((
+S16 rgSCHDhmDlRetxAllocFail ARGS((
RgSchUeCb *ue,
RgSchDlHqProcCb *proc
));
**/
/*MS_WORKAROUND for ccpu00122893*/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqEntReset
+Void rgSCHDhmHqEntReset
(
RgSchDlHqEnt *hqE
)
#else
-PUBLIC Void rgSCHDhmHqEntReset(hqE)
+Void rgSCHDhmHqEntReset(hqE)
RgSchDlHqEnt *hqE;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmAssgnUeHqEntFrmRaCb
+Void rgSCHDhmAssgnUeHqEntFrmRaCb
(
RgSchUeCb *ue,
RgSchRaCb *raCb
)
#else
-PUBLIC Void rgSCHDhmAssgnUeHqEntFrmRaCb(ue, raCb)
+Void rgSCHDhmAssgnUeHqEntFrmRaCb(ue, raCb)
RgSchUeCb *ue;
RgSchRaCb *raCb;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmDelHqEnt
+Void rgSCHDhmDelHqEnt
(
RgSchCellCb *cell,
RgSchDlHqEnt **hqE
)
#else
-PUBLIC Void rgSCHDhmDelHqEnt(cell, hqE)
+Void rgSCHDhmDelHqEnt(cell, hqE)
RgSchCellCb *cell;
RgSchDlHqEnt **hqE;
#endif
}
#ifdef ANSI
-PUBLIC RgSchDlHqEnt *rgSCHDhmHqEntInit
+RgSchDlHqEnt *rgSCHDhmHqEntInit
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchDlHqEnt *rgSCHDhmHqEntInit(cell)
+RgSchDlHqEnt *rgSCHDhmHqEntInit(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetAvlHqProc
+S16 rgSCHDhmGetAvlHqProc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHDhmGetAvlHqProc (cell, ue, timingInfo, hqP)
+S16 rgSCHDhmGetAvlHqProc (cell, ue, timingInfo, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqTbRetx
+Void rgSCHDhmHqTbRetx
(
RgSchDlHqEnt *hqE,
CmLteTimingInfo timingInfo,
U8 tbIdx
)
#else
-PUBLIC Void rgSCHDhmHqTbRetx(hqE, timingInfo, hqP, tbIdx)
+Void rgSCHDhmHqTbRetx(hqE, timingInfo, hqP, tbIdx)
RgSchDlHqEnt *hqE;
CmLteTimingInfo timingInfo;
RgSchDlHqProcCb *hqP;
*
**/
#ifdef ANSI
-PUBLIC RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc
+RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc
(
RgSchDlHqEnt *hqE
)
#else
-PUBLIC RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc(hqE)
+RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc(hqE)
RgSchDlHqEnt *hqE;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetCcchSduHqProc
+S16 rgSCHDhmGetCcchSduHqProc
(
RgSchUeCb *ueCb,
CmLteTimingInfo timingInfo,
RgSchDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHDhmGetCcchSduHqProc (ueCb, timingInfo, hqP)
+S16 rgSCHDhmGetCcchSduHqProc (ueCb, timingInfo, hqP)
RgSchUeCb *ueCb;
CmLteTimingInfo timingInfo;
RgSchDlHqProcCb **hqP;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetMsg4HqProc
+S16 rgSCHDhmGetMsg4HqProc
(
RgSchRaCb *raCb,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC S16 rgSCHDhmGetMsg4HqProc (raCb, timingInfo)
+S16 rgSCHDhmGetMsg4HqProc (raCb, timingInfo)
RgSchRaCb *raCb;
CmLteTimingInfo timingInfo;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRlsHqpTb
+Void rgSCHDhmRlsHqpTb
(
RgSchDlHqProcCb *hqP,
U8 tbIdx,
Bool togNdi
)
#else
-PUBLIC Void rgSCHDhmRlsHqpTb(hqP, tbIdx, togNdi)
+Void rgSCHDhmRlsHqpTb(hqP, tbIdx, togNdi)
RgSchDlHqProcCb *hqP;
U8 tbIdx;
Bool togNdi;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRlsHqProc
+Void rgSCHDhmRlsHqProc
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmRlsHqProc(hqP)
+Void rgSCHDhmRlsHqProc(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetHqProcFrmId
+S16 rgSCHDhmGetHqProcFrmId
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHDhmGetHqProcFrmId(cell, ue, idx, hqP)
+S16 rgSCHDhmGetHqProcFrmId(cell, ue, idx, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 idx;
*
**/
#ifdef ANSI
-PUBLIC RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc
+RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc(cell, ue, timingInfo)
+RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc(cell, ue, timingInfo)
RgSchCellCb *cell,
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
* -# None.
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmSchdTa
+Void rgSCHDhmSchdTa
(
RgSchUeCb *ueCb,
RgSchDlHqTbCb *tbInfo
)
#else
-PUBLIC Void rgSCHDhmSchdTa(ueCb, tbInfo)
+Void rgSCHDhmSchdTa(ueCb, tbInfo)
RgSchUeCb *ueCb;
RgSchDlHqTbCb *tbInfo;
#endif
* -# NULLP
**/
#ifdef ANSI
-PUBLIC RgSchDlHqProcCb *rgSCHDhmHqProcByTime
+RgSchDlHqProcCb *rgSCHDhmHqProcByTime
(
RgSchDlHqEnt *hqE,
CmLteTimingInfo timeInfo,
RgSchDlSf *sf
)
#else
-PUBLIC RgSchDlHqProcCb *rgSCHDhmHqProcByTime(hqE, timeInfo,
+RgSchDlHqProcCb *rgSCHDhmHqProcByTime(hqE, timeInfo,
isMsg4,sf)
RgSchDlHqEnt *hqE;
CmLteTimingInfo timeInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqTbTrnsFail
+Void rgSCHDhmHqTbTrnsFail
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
Bool *isMaxRetx
)
#else
-PUBLIC Void rgSCHDhmHqTbTrnsFail(cell, hqP, tbCnt, isMaxRetx)
+Void rgSCHDhmHqTbTrnsFail(cell, hqP, tbCnt, isMaxRetx)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
U8 tbCnt;
RETVOID;
} /* rgSCHDhmHqTbTrnsFail */
-PUBLIC U32 rgHqRvStats[2][4][2] = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
+U32 rgHqRvStats[2][4][2] = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
{{0, 0}, {0, 0}, {0, 0}, {0, 0}}};
#ifdef LTE_TDD
#ifdef LTE_ADV
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmHqFdbkInd
+S16 rgSCHDhmHqFdbkInd
(
Void *cb,
U8 cbType,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhmHqFdbkInd(cb, cbType, cellCb, timeInfo, fdbk, rlsHqBufs, err)
+S16 rgSCHDhmHqFdbkInd(cb, cbType, cellCb, timeInfo, fdbk, rlsHqBufs, err)
Void *cb;
U8 cbType;
RgSchCellCb *cellCb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmPrcFdbkForTb
+S16 rgSCHDhmPrcFdbkForTb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhmPrcFdbkForTb(cell, ue, hqP, sf, isMsg4, rnti, tbCnt, timingInfo, isAck, rlsHqBufs, err)
+S16 rgSCHDhmPrcFdbkForTb(cell, ue, hqP, sf, isMsg4, rnti, tbCnt, timingInfo, isAck, rlsHqBufs, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
* @return RETVOID
**/
#ifdef ANSI
-PUBLIC Void rgSchGetHqFdbkPos
+Void rgSchGetHqFdbkPos
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgTfuHqInfo *fdbk
)
#else
-PUBLIC Void rgSchGetHqFdbkPos(cell,ue,hqP,uciFrmtTyp,isAck,fdbk)
+Void rgSchGetHqFdbkPos(cell,ue,hqP,uciFrmtTyp,isAck,fdbk)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
}/* End of rgSchGetHqFdbkPos */
#ifdef LTE_ADV
#ifdef ANSI
-PUBLIC Void rgSchGetHqFdbkPosFormat3
+Void rgSchGetHqFdbkPosFormat3
(
RgSchDlHqProcCb *hqP,
U8 *isAck,
TfuHqFdbk *fdbk
)
#else
-PUBLIC Void rgSchGetHqFdbkPosFormat3(hqP,isAck,fdbk)
+Void rgSchGetHqFdbkPosFormat3(hqP,isAck,fdbk)
RgSchDlHqProcCb *hqP;
U8 *isAck;
TfuHqFdbk *fdbk;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhm5gtfHqFdbkInd
+S16 rgSCHDhm5gtfHqFdbkInd
(
RgSchUeCb *ue,
RgSchCellCb *cell,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhm5gtfHqFdbkInd(ue, cell, timingInfo, fdbk, err)
+S16 rgSCHDhm5gtfHqFdbkInd(ue, cell, timingInfo, fdbk, err)
RgSchUeCb *ue;
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmHqFdbkInd
+S16 rgSCHDhmHqFdbkInd
(
Void *cb,
U8 cbType,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhmHqFdbkInd(cb, cbType, cell, timingInfo, fdbk, rlsHqBufs, err)
+S16 rgSCHDhmHqFdbkInd(cb, cbType, cell, timingInfo, fdbk, rlsHqBufs, err)
Void *cb;
U8 cbType;
RgSchCellCb *cell;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRgrUeCfg
+Void rgSCHDhmRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHDhmRgrUeCfg(cell, ueCb, ueCfg, err)
+Void rgSCHDhmRgrUeCfg(cell, ueCb, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
RgrUeCfg *ueCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRgrCellCfg
+Void rgSCHDhmRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHDhmRgrCellCfg(cell, cellCfg, err)
+Void rgSCHDhmRgrCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRgrCellRecfg
+Void rgSCHDhmRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *cellRecfg,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHDhmRgrCellRecfg(cell, cellRecfg, err)
+Void rgSCHDhmRgrCellRecfg(cell, cellRecfg, err)
RgSchCellCb *cell;
RgrCellRecfg *cellRecfg;
RgSchErrInfo *err;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmFreeUe
+Void rgSCHDhmFreeUe
(
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDhmFreeUe(ueCb)
+Void rgSCHDhmFreeUe(ueCb)
RgSchUeCb *ueCb;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmUpdTa
+Void rgSCHDhmUpdTa
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
U8 ta
)
#else
-PUBLIC Void rgSCHDhmUpdTa(cell, ueCb, ta)
+Void rgSCHDhmUpdTa(cell, ueCb, ta)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
U8 ta;
* -#None.
*/
#ifdef ANSI
-PUBLIC Void rgSCHDhmProcTAExp
+Void rgSCHDhmProcTAExp
(
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDhmProcTAExp (ueCb)
+Void rgSCHDhmProcTAExp (ueCb)
RgSchUeCb *ueCb;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmAddLcData
+S16 rgSCHDhmAddLcData
(
Inst inst,
RgSchLchAllocInfo *lchData,
RgSchDlHqTbCb *tbInfo
)
#else
-PUBLIC S16 rgSCHDhmAddLcData(inst, lchData, tbInfo)
+S16 rgSCHDhmAddLcData(inst, lchData, tbInfo)
Inst inst;
RgSchLchAllocInfo *lchData;
RgSchDlHqTbCb *tbInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmTddRlsSubFrm
+S16 rgSCHDhmTddRlsSubFrm
(
RgSchCellCb *cellCb,
CmLteTimingInfo uciTimingInfo
)
#else
-PUBLIC S16 rgSCHDhmTddRlsSubFrm(cellCb, uciTimingInfo)
+S16 rgSCHDhmTddRlsSubFrm(cellCb, uciTimingInfo)
RgSchCellCb *cellCb;
CmLteTimingInfo uciTimingInfo;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc
+S16 rgSCHDhmRlsDlsfHqProc
(
RgSchCellCb *cellCb,
CmLteTimingInfo uciTimingInfo
)
#else
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc(cellCb, uciTimingInfo)
+S16 rgSCHDhmRlsDlsfHqProc(cellCb, uciTimingInfo)
RgSchCellCb *cellCb;
CmLteTimingInfo uciTimingInfo;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc
+S16 rgSCHDhmRlsDlsfHqProc
(
RgSchCellCb *cell,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc(cell, timingInfo)
+S16 rgSCHDhmRlsDlsfHqProc(cell, timingInfo)
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmMarkSpsHqProc
+S16 rgSCHDhmMarkSpsHqProc
(
RgSchUeCb *ue,
U8 idx
)
#else
-PUBLIC S16 rgSCHDhmMarkSpsHqProc(ue, idx)
+S16 rgSCHDhmMarkSpsHqProc(ue, idx)
RgSchUeCb *ue;
U8 idx;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmDlRetxAllocFail
+S16 rgSCHDhmDlRetxAllocFail
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC S16 rgSCHDhmDlRetxAllocFail(ue, hqP)
+S16 rgSCHDhmDlRetxAllocFail(ue, hqP)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
#endif
}
#ifdef ANSI
-PUBLIC S16 rgSCHDhmUpdBlerBasediTbsEff
+S16 rgSCHDhmUpdBlerBasediTbsEff
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
U8 tbCnt
)
#else
-PUBLIC S16 rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt)
+S16 rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt)
(
RgSchCellCb *cell;
RgSchUeCb *ueCb;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPAdd2FreeLst
+Void rgSCHDhmHqPAdd2FreeLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPAdd2FreeLst(hqP)
+Void rgSCHDhmHqPAdd2FreeLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPAdd2InUseLst
+Void rgSCHDhmHqPAdd2InUseLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPAdd2InUseLst(hqP)
+Void rgSCHDhmHqPAdd2InUseLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPDelFrmFreeLst
+Void rgSCHDhmHqPDelFrmFreeLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPDelFrmFreeLst(hqP)
+Void rgSCHDhmHqPDelFrmFreeLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPDelFrmInUseLst
+Void rgSCHDhmHqPDelFrmInUseLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPDelFrmInUseLst(hqP)
+Void rgSCHDhmHqPDelFrmInUseLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
* @return
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxTtiInd
+Void rgSCHDrxTtiInd
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHDrxTtiInd (cell)
+Void rgSCHDrxTtiInd (cell)
RgSchCellCb *cell;
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxTtiHdlInActv
+S16 rgSCHDrxTtiHdlInActv
(
RgSchCellCb *cell,
U16 dlIndex,
U16 ulIndex
)
#else
-PUBLIC S16 rgSCHDrxTtiHdlInActv(cell, dlIndex, ulIndex)
+S16 rgSCHDrxTtiHdlInActv(cell, dlIndex, ulIndex)
RgSchCellCb *cell;
U16 dlIndex;
U16 ulIndex;
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxTtiHdlShortCycle
+S16 rgSCHDrxTtiHdlShortCycle
(
RgSchCellCb *cell,
U16 dlIndex,
U16 ulIndex
)
#else
-PUBLIC S16 rgSCHDrxTtiHdlShortCycle (cell, dlIndex, ulIndex)
+S16 rgSCHDrxTtiHdlShortCycle (cell, dlIndex, ulIndex)
RgSchCellCb *cell;
U16 dlIndex;
U16 ulIndex;
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxStrtInActvTmr
+Void rgSCHDrxStrtInActvTmr
(
RgSchCellCb *cell,
CmLListCp *ueLst,
U8 direction
)
#else
-PUBLIC Void rgSCHDrxStrtInActvTmr(cell, ueLst, direction)
+Void rgSCHDrxStrtInActvTmr(cell, ueLst, direction)
RgSchCellCb *cell;
CmLListCp *ueLst;
U8 direction;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxStartHarqRTTTmr
+Void rgSCHDrxStartHarqRTTTmr
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
U8 tbCnt
)
#else
-PUBLIC Void rgSCHDrxStartHarqRTTTmr(cell, hqP, tbCnt)
+Void rgSCHDrxStartHarqRTTTmr(cell, hqP, tbCnt)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
U8 tbCnt;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxUeCfg
+S16 rgSCHDrxUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCfg *ueCfg
)
#else
-PUBLIC S16 rgSCHDrxUeCfg (cell, ue, ueCfg)
+S16 rgSCHDrxUeCfg (cell, ue, ueCfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxUeReCfg
+S16 rgSCHDrxUeReCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueReCfg
)
#else
-PUBLIC S16 rgSCHDrxUeReCfg (cell, ue, ueReCfg)
+S16 rgSCHDrxUeReCfg (cell, ue, ueReCfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueReCfg;
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxUeHqReset
+Void rgSCHDrxUeHqReset
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 cellIdx
)
#else
-PUBLIC Void rgSCHDrxUeHqReset(cell, ue, hqE, cellIdx)
+Void rgSCHDrxUeHqReset(cell, ue, hqE, cellIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqEnt *hqE;
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxUeDel
+S16 rgSCHDrxUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHDrxUeDel (cell, ue)
+S16 rgSCHDrxUeDel (cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxCellCfg
+S16 rgSCHDrxCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCHDrxCellCfg (cell, cellCfg)
+S16 rgSCHDrxCellCfg (cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxCellDel
+Void rgSCHDrxCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHDrxCellDel (cell)
+Void rgSCHDrxCellDel (cell)
RgSchCellCb *cell;
#endif
{
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxSrInd
+S16 rgSCHDrxSrInd
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHDrxSrInd (cell, ue)
+S16 rgSCHDrxSrInd (cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxDedRa
+Void rgSCHDrxDedRa
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDrxDedRa (cellCb, ueCb)
+Void rgSCHDrxDedRa (cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtTddDrxCycCfg
+S16 rgSCHCfgVldtTddDrxCycCfg
(
RgSchCellCb *cell,
U16 drxCycle,
U16 offSet
)
#else
-PUBLIC S16 rgSCHCfgVldtTddDrxCycCfg(cell, drxCycle, onDurTmr, offSet)
+S16 rgSCHCfgVldtTddDrxCycCfg(cell, drxCycle, onDurTmr, offSet)
RgSchCellCb *cell;
U16 drxCycle;
U8 onDurTmr;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnSpsInit
+Void rgSCHCmnSpsInit
(
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnSpsInit ()
+Void rgSCHCmnSpsInit ()
#endif /* ANSI */
{
TRC2(rgSCHCmnSpsInit);
* @return Void
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnSpsUeCfg
+S16 rgSCHCmnSpsUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else /* ANSI */
-PUBLIC S16 rgSCHCmnSpsUeCfg (cell, ue, ueCfg, err)
+S16 rgSCHCmnSpsUeCfg (cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnSpsUeRecfg
+S16 rgSCHCmnSpsUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else /* ANSI */
-PUBLIC S16 rgSCHCmnSpsUeRecfg (cell, ue, ueCfg, err)
+S16 rgSCHCmnSpsUeRecfg (cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnSpsUeDel
+Void rgSCHCmnSpsUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnSpsUeDel (cell, ue)
+Void rgSCHCmnSpsUeDel (cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif /* ANSI */
* @return Void
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnSpsCellCfg
+S16 rgSCHCmnSpsCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else /* ANSI */
-PUBLIC S16 rgSCHCmnSpsCellCfg(cell, cellCfg, err)
+S16 rgSCHCmnSpsCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnSpsCellDel
+Void rgSCHCmnSpsCellDel
(
RgSchCellCb *cell
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnSpsCellDel (cell)
+Void rgSCHCmnSpsCellDel (cell)
RgSchCellCb *cell;
#endif /* ANSI */
{
* @return Void
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnSpsDlLcCfg
+S16 rgSCHCmnSpsDlLcCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else /* ANSI */
-PUBLIC S16 rgSCHCmnSpsDlLcCfg(cell, ue, dlLc, lcCfg, err)
+S16 rgSCHCmnSpsDlLcCfg(cell, ue, dlLc, lcCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 schActvTsk
+S16 schActvTsk
(
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 schActvTsk(pst, mBuf)
+S16 schActvTsk(pst, mBuf)
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
break;
}
break;
- case ENTTF:
+ case ENTLWRMAC:
switch(pst->event)
{
/*#ifdef LCRGLITFU L2Split */
break;
}
break;
- case ENTRG: /* When MAC sends a msg to Scheduler instance */
+ case ENTMAC: /* When MAC sends a msg to Scheduler instance */
switch(pst->event)
{
#ifdef LCSCH
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHGomHndlCfg
+S16 rgSCHGomHndlCfg
(
Pst *pst,
RgSchCb *instCb,
RgrCfgReqInfo *cfgReqInfo
)
#else
-PUBLIC S16 rgSCHGomHndlCfg(pst, instCb, transId, cfgReqInfo)
+S16 rgSCHGomHndlCfg(pst, instCb, transId, cfgReqInfo)
Pst *pst;
RgSchCb *instCb;
RgrCfgTransId transId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHGomTtiHndlr
+S16 rgSCHGomTtiHndlr
(
RgSchCellCb *cell,
SpId spId
)
#else
-PUBLIC S16 rgSCHGomTtiHndlr(cell, spId)
+S16 rgSCHGomTtiHndlr(cell, spId)
RgSchCellCb *cell;
SpId spId;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHGomHndlSiCfg
+S16 rgSCHGomHndlSiCfg
(
Region reg,
Pool pool,
RgrSiCfgReqInfo *cfgReqInfo
)
#else
-PUBLIC S16 rgSCHGomHndlSiCfg(reg, pool, instCb, spId, transId, cfgReqInfo)
+S16 rgSCHGomHndlSiCfg(reg, pool, instCb, spId, transId, cfgReqInfo)
Region reg;
Pool pool;
RgSchCb *instCb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHGomHndlWarningSiCfg
+S16 rgSCHGomHndlWarningSiCfg
(
Region reg,
Pool pool,
RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
)
#else
-PUBLIC S16 rgSCHGomHndlWarningSiCfg(reg, pool, instCb, spId, transId,
+S16 rgSCHGomHndlWarningSiCfg(reg, pool, instCb, spId, transId,
warningSiCfgReqInfo)
Region reg;
Pool pool;
* @return void
**/
#ifdef ANSI
-PUBLIC Void rgSCHGomHndlWarningSiStopReq
+Void rgSCHGomHndlWarningSiStopReq
(
Region reg,
Pool pool,
SpId spId
)
#else
-PUBLIC Void rgSCHGomHndlWarningSiStopReq(reg, pool, instCb, siId, transId, spId)
+Void rgSCHGomHndlWarningSiStopReq(reg, pool, instCb, siId, transId, spId)
Region reg;
Pool pool;
RgSchCb *instCb;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchUpdtRNTPInfo
+S16 rgSchUpdtRNTPInfo
(
RgSchCellCb *cell,
RgSchDlSf *sf,
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHGomHndlLoadInf
+S16 rgSCHGomHndlLoadInf
(
Region reg,
Pool pool,
RgrLoadInfReqInfo *loadInfReq
)
#else
-PUBLIC S16 rgSCHGomHndlLoadInf(reg, pool, instCb, spId, transId, loadInfReq)
+S16 rgSCHGomHndlLoadInf(reg, pool, instCb, spId, transId, loadInfReq)
Region reg;
Pool pool;
RgSchCb *instCb;
*/
#ifdef ANSI
-PUBLIC S16 rgSCHHdFddUeCfg
+S16 rgSCHHdFddUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
Bool hdFddEnbl
)
#else /* ANSI */
-PUBLIC S16 rgSCHHdFddUeCfg (cellCb, ueCb, hdFddEnbl)
+S16 rgSCHHdFddUeCfg (cellCb, ueCb, hdFddEnbl)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
Bool hdFddEnbl;
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHHdFddUeDel
+S16 rgSCHHdFddUeDel
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else /* ANSI */
-PUBLIC S16 rgSCHHdFddUeDel(cellCb, ueCb)
+S16 rgSCHHdFddUeDel(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif /* ANSI */
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdFddPtUlMrk
+Void rgSCHCmnHdFddPtUlMrk
(
RgSchCellCb *cellCb
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnHdFddPtUlMrk (cellCb)
+Void rgSCHCmnHdFddPtUlMrk (cellCb)
RgSchCellCb *cellCb;
#endif /* ANSI */
{
*
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdFddChkUlAllow
+Void rgSCHCmnHdFddChkUlAllow
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
U8 *allow
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnHdFddChkUlAllow ( cellCb, ueCb, allow)
+Void rgSCHCmnHdFddChkUlAllow ( cellCb, ueCb, allow)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
U8 *allow;
*
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdFddChkDlAllow
+Void rgSCHCmnHdFddChkDlAllow
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
Bool *allow /* Valdity of this pointer is not done in this function */
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnHdFddChkDlAllow ( cellCb, ueCb, allow)
+Void rgSCHCmnHdFddChkDlAllow ( cellCb, ueCb, allow)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
Bool *allow; /* Valdity of this pointer is not done in this function */
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdFddChkNackAllow
+Void rgSCHCmnHdFddChkNackAllow
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
Bool *sndNACK
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnHdFddChkNackAllow(cellCb, ueCb, timeInfo, sndNACK)
+Void rgSCHCmnHdFddChkNackAllow(cellCb, ueCb, timeInfo, sndNACK)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
CmLteTimingInfo timeInfo;
* @return None
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdFddUpdULMark
+Void rgSCHCmnHdFddUpdULMark
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnHdFddUpdULMark ( cellCb, ueCb)
+Void rgSCHCmnHdFddUpdULMark ( cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif /* ANSI */
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdFddUpdDLMark
+Void rgSCHCmnHdFddUpdDLMark
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else /* ANSI */
-PUBLIC Void rgSCHCmnHdFddUpdDLMark (cellCb, ueCb)
+Void rgSCHCmnHdFddUpdDLMark (cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif /* ANSI */
*/
#ifdef ANSI
-PUBLIC Void rgSCHHdFddGetSfn
+Void rgSCHHdFddGetSfn
(
U16 *sfn,
CmLteTimingInfo timeInfo,
S16 offset
)
#else /* ANSI */
-PUBLIC Void rgSCHHdFddGetSfn (sfn, timeInfo, offset)
+Void rgSCHHdFddGetSfn (sfn, timeInfo, offset)
U16 *sfn;
CmLteTimingInfo timeInfo;
S16 offset;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchUeDelInd
+S16 cmPkMacSchUeDelInd
(
Pst* pst,
RgInfUeDelInd* ueDelInd
)
#else
-PUBLIC S16 cmPkMacSchUeDelInd(pst, ueDelInd)
+S16 cmPkMacSchUeDelInd(pst, ueDelInd)
Pst* pst;
RgInfUeDelInd* ueDelInd;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchUeDelInd
+S16 cmUnpkMacSchUeDelInd
(
UeDelInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchUeDelInd(func, pst, mBuf)
+S16 cmUnpkMacSchUeDelInd(func, pst, mBuf)
UeDelInd func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchDedBoUpdtReq
+S16 cmPkMacSchDedBoUpdtReq
(
Pst* pst,
RgInfDedBoRpt* boRpt
)
#else
-PUBLIC S16 cmPkMacSchDedBoUpdtReq(pst, boRpt)
+S16 cmPkMacSchDedBoUpdtReq(pst, boRpt)
Pst* pst;
RgInfDedBoRpt* boRpt;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchDedBoUpdtReq
+S16 cmUnpkMacSchDedBoUpdtReq
(
DedBoUpdtReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchDedBoUpdtReq(func, pst, mBuf)
+S16 cmUnpkMacSchDedBoUpdtReq(func, pst, mBuf)
DedBoUpdtReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchCmnBoUpdtReq
+S16 cmPkMacSchCmnBoUpdtReq
(
Pst* pst,
RgInfCmnBoRpt* boRpt
)
#else
-PUBLIC S16 cmPkMacSchCmnBoUpdtReq(pst, boRpt)
+S16 cmPkMacSchCmnBoUpdtReq(pst, boRpt)
Pst* pst;
RgInfCmnBoRpt* boRpt;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchCmnBoUpdtReq
+S16 cmUnpkMacSchCmnBoUpdtReq
(
CmnBoUpdtReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchCmnBoUpdtReq(func, pst, mBuf)
+S16 cmUnpkMacSchCmnBoUpdtReq(func, pst, mBuf)
CmnBoUpdtReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchSfRecpInd
+S16 cmPkMacSchSfRecpInd
(
Pst* pst,
RgInfSfDatInd* datInd
)
#else
-PUBLIC S16 cmPkMacSchSfRecpInd(pst, datInd)
+S16 cmPkMacSchSfRecpInd(pst, datInd)
Pst* pst;
RgInfSfDatInd* datInd;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchSfRecpInd
+S16 cmUnpkMacSchSfRecpInd
(
SfRecpInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchSfRecpInd(func, pst, mBuf)
+S16 cmUnpkMacSchSfRecpInd(func, pst, mBuf)
SfRecpInd func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchSpsRelInd
+S16 cmPkMacSchSpsRelInd
(
Pst* pst,
RgInfSpsRelInfo* relInfo
)
#else
-PUBLIC S16 cmPkMacSchSpsRelInd(pst, relInfo)
+S16 cmPkMacSchSpsRelInd(pst, relInfo)
Pst* pst;
RgInfSpsRelInfo* relInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchSpsRelInd
+S16 cmUnpkMacSchSpsRelInd
(
SpsRelInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchSpsRelInd(func, pst, mBuf)
+S16 cmUnpkMacSchSpsRelInd(func, pst, mBuf)
SpsRelInd func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacSfAllocReq
+S16 cmPkSchMacSfAllocReq
(
Pst* pst,
RgInfSfAlloc* resAllocReq
)
#else
-PUBLIC S16 cmPkSchMacSfAllocReq(pst, resAllocReq)
+S16 cmPkSchMacSfAllocReq(pst, resAllocReq)
Pst* pst;
RgInfSfAlloc* resAllocReq;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacSfAllocReq
+S16 cmUnpkSchMacSfAllocReq
(
SfAllocReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacSfAllocReq(func, pst, mBuf)
+S16 cmUnpkSchMacSfAllocReq(func, pst, mBuf)
SfAllocReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacRstHqEntReq
+S16 cmPkSchMacRstHqEntReq
(
Pst* pst,
RgInfResetHqEnt* hqEntInfo
)
#else
-PUBLIC S16 cmPkSchMacRstHqEntReq(pst, sfHqInfo)
+S16 cmPkSchMacRstHqEntReq(pst, sfHqInfo)
Pst* pst,
RgInfResetHqEnt* hqEntInfo
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacRstHqEntReq
+S16 cmUnpkSchMacRstHqEntReq
(
RstHqEntReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacRstHqEntReq(func, pst, mBuf)
+S16 cmUnpkSchMacRstHqEntReq(func, pst, mBuf)
RstHqEntReq func,
Pst *pst,
Buffer *mBuf
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacRlsHqReq
+S16 cmPkSchMacRlsHqReq
(
Pst* pst,
RgInfRlsHqInfo* sfHqInfo
)
#else
-PUBLIC S16 cmPkSchMacRlsHqReq(pst, sfHqInfo)
+S16 cmPkSchMacRlsHqReq(pst, sfHqInfo)
Pst* pst;
RgInfRlsHqInfo* sfHqInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacRlsHqReq
+S16 cmUnpkSchMacRlsHqReq
(
RlsHqReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacRlsHqReq(func, pst, mBuf)
+S16 cmUnpkSchMacRlsHqReq(func, pst, mBuf)
RlsHqReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacRlsRntiReq
+S16 cmPkSchMacRlsRntiReq
(
Pst* pst,
RgInfRlsRnti* rlsRnti
)
#else
-PUBLIC S16 cmPkSchMacRlsRntiReq(pst, rlsRnti)
+S16 cmPkSchMacRlsRntiReq(pst, rlsRnti)
Pst* pst;
RgInfRlsRnti* rlsRnti;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacRlsRntiReq
+S16 cmUnpkSchMacRlsRntiReq
(
RlsRntiReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacRlsRntiReq(func, pst, mBuf)
+S16 cmUnpkSchMacRlsRntiReq(func, pst, mBuf)
RlsRntiReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacCellRegReq
+S16 cmPkSchMacCellRegReq
(
Pst* pst,
RgInfCellReg* regReq
)
#else
-PUBLIC S16 cmPkSchMacCellRegReq(pst, regReq)
+S16 cmPkSchMacCellRegReq(pst, regReq)
Pst* pst;
RgInfCellReg* regReq;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacCellRegReq
+S16 cmUnpkSchMacCellRegReq
(
CellRegReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacCellRegReq(func, pst, mBuf)
+S16 cmUnpkSchMacCellRegReq(func, pst, mBuf)
CellRegReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacLcgRegReq
+S16 cmPkSchMacLcgRegReq
(
Pst* pst,
RgInfLcgRegReq *lcgRegReq
)
#else
-PUBLIC S16 cmPkSchMacLcgRegReq(pst, lcgRegReq)
+S16 cmPkSchMacLcgRegReq(pst, lcgRegReq)
Pst* pst;
RgInfLcgRegReq *lcgRegReq;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacLcgRegReq
+S16 cmUnpkSchMacLcgRegReq
(
LcgReg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacLcgRegReq(func, pst, mBuf)
+S16 cmUnpkSchMacLcgRegReq(func, pst, mBuf)
LcgReg func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacSpsLcRegReq
+S16 cmPkSchMacSpsLcRegReq
(
Pst* pst,
RgInfSpsLcInfo *lcInfo
)
#else
-PUBLIC S16 cmPkSchMacSpsLcRegReq(pst, lcInfo)
+S16 cmPkSchMacSpsLcRegReq(pst, lcInfo)
Pst* pst;
RgInfSpsLcInfo *lcInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacUlSpsResetReq
+S16 cmPkSchMacUlSpsResetReq
(
Pst* pst,
RgInfUlSpsReset *ulSpsResetInfo
)
#else
-PUBLIC S16 cmPkSchMacUlSpsResetReq(pst, ulSpsResetInfo)
+S16 cmPkSchMacUlSpsResetReq(pst, ulSpsResetInfo)
Pst* pst;
RgInfUlSpsReset *ulSpsResetInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacSpsLcRegReq
+S16 cmUnpkSchMacSpsLcRegReq
(
SpsLcReg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacSpsLcRegReq(func, pst, mBuf)
+S16 cmUnpkSchMacSpsLcRegReq(func, pst, mBuf)
SpsLcReg func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacUlSpsResetReq
+S16 cmUnpkSchMacUlSpsResetReq
(
UlSpsReset func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacUlSpsResetReq(func, pst, mBuf)
+S16 cmUnpkSchMacUlSpsResetReq(func, pst, mBuf)
UlSpsReset func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacSpsLcDeregReq
+S16 cmPkSchMacSpsLcDeregReq
(
Pst* pst,
CmLteCellId cellId,
CmLteRnti crnti
)
#else
-PUBLIC S16 cmPkSchMacSpsLcDeregReq(pst, cellId, crnti)
+S16 cmPkSchMacSpsLcDeregReq(pst, cellId, crnti)
Pst* pst;
CmLteCellId cellId;
CmLteRnti crnti;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacSpsLcDeregReq
+S16 cmUnpkSchMacSpsLcDeregReq
(
SpsLcDereg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacSpsLcDeregReq(func, pst, mBuf)
+S16 cmUnpkSchMacSpsLcDeregReq(func, pst, mBuf)
SpsLcDereg func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacL2MeasReq
+S16 cmPkSchMacL2MeasReq
(
Pst* pst,
RgInfL2MeasReq *measInfo
)
#else
-PUBLIC S16 cmPkSchMacL2MeasReq(pst, measInfo)
+S16 cmPkSchMacL2MeasReq(pst, measInfo)
Pst* pst;
RgInfL2MeasReq *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacL2MeasStopReq
+S16 cmPkSchMacL2MeasStopReq
(
Pst* pst,
RgInfL2MeasStopReq *measInfo
)
#else
-PUBLIC S16 cmPkSchMacL2MeasStopReq(pst, measInfo)
+S16 cmPkSchMacL2MeasStopReq(pst, measInfo)
Pst* pst;
RgInfL2MeasStopReq *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkSchMacL2MeasSendReq
+S16 cmPkSchMacL2MeasSendReq
(
Pst* pst,
RgInfL2MeasSndReq *measInfo
)
#else
-PUBLIC S16 cmPkSchMacL2MeasSendReq(pst, measInfo)
+S16 cmPkSchMacL2MeasSendReq(pst, measInfo)
Pst* pst;
RgInfL2MeasSndReq *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacL2MeasReq
+S16 cmUnpkSchMacL2MeasReq
(
L2MeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacL2MeasReq(func, pst, mBuf)
+S16 cmUnpkSchMacL2MeasReq(func, pst, mBuf)
L2MeasReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacL2MeasStopReq
+S16 cmUnpkSchMacL2MeasStopReq
(
L2MeasStopReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacL2MeasStopReq(func, pst, mBuf)
+S16 cmUnpkSchMacL2MeasStopReq(func, pst, mBuf)
L2MeasStopReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkSchMacL2MeasSendReq
+S16 cmUnpkSchMacL2MeasSendReq
(
L2MeasSendReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkSchMacL2MeasSendReq(func, pst, mBuf)
+S16 cmUnpkSchMacL2MeasSendReq(func, pst, mBuf)
L2MeasSendReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchL2MeasCfm
+S16 cmPkMacSchL2MeasCfm
(
Pst* pst,
RgInfL2MeasCfm *measCfm
)
#else
-PUBLIC S16 cmPkMacSchL2MeasCfm(pst, measCfm)
+S16 cmPkMacSchL2MeasCfm(pst, measCfm)
Pst* pst;
RgInfL2MeasCfm *measCfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchL2MeasStopCfm
+S16 cmPkMacSchL2MeasStopCfm
(
Pst* pst,
RgInfL2MeasCfm *measCfm
)
#else
-PUBLIC S16 cmPkMacSchL2MeasStopCfm(pst, measCfm)
+S16 cmPkMacSchL2MeasStopCfm(pst, measCfm)
Pst* pst;
RgInfL2MeasCfm *measCfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchL2MeasCfm
+S16 cmUnpkMacSchL2MeasCfm
(
L2MeasCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchL2MeasCfm(func, pst, mBuf)
+S16 cmUnpkMacSchL2MeasCfm(func, pst, mBuf)
L2MeasCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchL2MeasStopCfm
+S16 cmUnpkMacSchL2MeasStopCfm
(
L2MeasCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchL2MeasStopCfm(func, pst, mBuf)
+S16 cmUnpkMacSchL2MeasStopCfm(func, pst, mBuf)
L2MeasCfm func;
Pst *pst;
Buffer *mBuf;
* @return Void
*/
#ifdef ANSI
-PUBLIC S16 rgSchFillL2MeasCfm
+S16 rgSchFillL2MeasCfm
(
RgSchCellCb *cell,
RgSchL2MeasCb *measCb,
U32 measTime
)
#else
-PUBLIC S16 rgSchFillL2MeasCfm(cell, measCb, cfm, measTime)
+S16 rgSchFillL2MeasCfm(cell, measCb, cfm, measTime)
RgSchCellCb *cell;
RgSchL2MeasCb *measCb;
LrgSchMeasCfmInfo *cfm;
* @return Void
*/
#ifdef ANSI
-PUBLIC S16 rgSchL2mSndCfm
+S16 rgSchL2mSndCfm
(
Pst *pst,
RgSchL2MeasCb *measCb,
Bool isErr
)
#else
-PUBLIC S16 rgSchL2mSndCfm(pst, measCb, measInfo, isErr)
+S16 rgSchL2mSndCfm(pst, measCb, measInfo, isErr)
Pst *pst;
RgSchL2MeasCb *measCb;
LrgSchMeasReqInfo *measInfo;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSchL2mFillCfmPst
+Void rgSchL2mFillCfmPst
(
Pst *pst,
Pst *cfmPst,
LrgSchMeasReqInfo *measInfo
)
#else
-PUBLIC Void rgSchL2mFillCfmPst(pst, cfmPst, measInfo)
+Void rgSchL2mFillCfmPst(pst, cfmPst, measInfo)
Pst *pst;
Pst *cfmPst;
LrgSchMeasReqInfo *measInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSchL2mMeasReq
+S16 rgSchL2mMeasReq
(
RgSchCellCb *cell,
LrgSchMeasReqInfo *measInfo,
RgSchErrInfo err
)
#else
-PUBLIC S16 rgSchL2mMeasReq(cell, measInfo, err)
+S16 rgSchL2mMeasReq(cell, measInfo, err)
RgSchCellCb *cell;
LrgSchMeasReqInfo *measInfo;
RgSchErrInfo err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHL2Meas
+S16 rgSCHL2Meas
(
RgSchCellCb *cell,
U8 isCalrCrcInd
)
#else
-PUBLIC S16 rgschL2Meas(cell,isCalrCrcInd)
+S16 rgschL2Meas(cell,isCalrCrcInd)
RgSchCellCb *cell;
U8 isCalrCrcInd
#endif
#include "rg_sch_cmn.x" /* typedefs for Scheduler */
#endif
#ifndef LTE_L2_MEAS
-PUBLIC Void rgSCHCmnInit ARGS((Void));
+Void rgSCHCmnInit ARGS((Void));
#endif
/* forward references */
extern int schActvInit(Ent entity, Inst instId, Region region, Reason reason);
));
-PUBLIC void printSchCellInfo(void)
+void printSchCellInfo(void)
{
U8 idx=0;
U8 inst=0;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHLmmGenCntrl
+Void rgSCHLmmGenCntrl
(
RgMngmt *cntrl,
RgMngmt *cfm,
Pst *cfmPst
)
#else
-PUBLIC Void rgSCHLmmGenCntrl(cntrl, cfm, cfmPst)
+Void rgSCHLmmGenCntrl(cntrl, cfm, cfmPst)
RgMngmt *cntrl;
RgMngmt *cfm;
Pst *cfmPst;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHLmmSapCntrl
+Void rgSCHLmmSapCntrl
(
RgMngmt *cntrl,
RgMngmt *cfm,
Pst *cfmPst
)
#else
-PUBLIC Void rgSCHLmmSapCntrl(cntrl, cfm, cfmPst)
+Void rgSCHLmmSapCntrl(cntrl, cfm, cfmPst)
RgMngmt *cntrl;
RgMngmt *cfm;
Pst *cfmPst;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void SchFillCfmPst
+Void SchFillCfmPst
(
Pst *reqPst,
Pst *cfmPst,
RgMngmt *cfm
)
#else
-PUBLIC Void SchFillCfmPst(reqPst, cfmPst, cfm)
+Void SchFillCfmPst(reqPst, cfmPst, cfm)
Pst *reqPst;
Pst *cfmPst;
RgMngmt *cfm;
inst = (reqPst->dstInst - SCH_INST_START);
- cfmPst->srcEnt = ENTRG;
+ cfmPst->srcEnt = ENTMAC;
cfmPst->srcInst = (Inst) 1;
cfmPst->srcProcId = rgSchCb[inst].rgSchInit.procId;
- cfmPst->dstEnt = ENTRG;
+ cfmPst->dstEnt = ENTMAC;
cfmPst->dstInst = (Inst) 0;
cfmPst->dstProcId = reqPst->srcProcId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmStartTmr
+S16 rgSCHLmmStartTmr
(
Inst inst,
S16 tmrEvnt, /* Timer Event */
PTR cb /* Entry for which Timer Expired */
)
#else
-PUBLIC S16 rgSCHLmmStartTmr(inst, tmrEvnt, tmrVal, cb)
+S16 rgSCHLmmStartTmr(inst, tmrEvnt, tmrVal, cb)
Inst inst; /* scheduler instance ID */
S16 tmrEvnt; /* Timer Event */
U32 tmrVal; /* Wait Time */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmStopTmr
+S16 rgSCHLmmStopTmr
(
Inst inst, /* Scheduler instance */
S16 tmrEvnt, /* Timer Event */
PTR cb /* Entry for which Timer Expired */
)
#else
-PUBLIC S16 rgSCHLmmStopTmr(inst, tmrEvnt, cb)
+S16 rgSCHLmmStopTmr(inst, tmrEvnt, cb)
Inst inst; /* Scheduler instance */
S16 tmrEvnt; /* Timer Event */
PTR cb; /* Entry for which Timer Expired */
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmTmrExpiry
+S16 rgSCHLmmTmrExpiry
(
PTR cb, /* Pointer to timer control block */
S16 tmrEvnt /* Timer Event */
)
#else
-PUBLIC S16 rgSCHLmmTmrExpiry(cb,tmrEvnt)
+S16 rgSCHLmmTmrExpiry(cb,tmrEvnt)
PTR cb; /* Pointer to timer control block */
S16 tmrEvnt; /* Timer Event */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmBndCfm
+S16 rgSCHLmmBndCfm
(
Pst *pst, /* Post Structure */
SuId suId, /* Service user ID */
U8 status /* Status */
)
#else
-PUBLIC S16 rgSCHLmmBndCfm(pst,suId,status)
+S16 rgSCHLmmBndCfm(pst,suId,status)
Pst *pst; /* Post Structure */
SuId suId; /* Service user Id */
U8 status; /* Status */
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHLmmStaInd
+S16 rgSCHLmmStaInd
(
Inst inst,
U16 category,
RgUstaDgn *dgn
)
#else
-PUBLIC S16 rgSCHLmmStaInd(inst, category, event, cause, dgn)
+S16 rgSCHLmmStaInd(inst, category, event, cause, dgn)
Inst inst;
U16 category;
U16 event;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 schActvTmr
+S16 schActvTmr
(
Ent ent,
Inst inst
)
#else
-PUBLIC S16 schActvTmr(ent, inst)
+S16 schActvTmr(ent, inst)
Ent ent;
Inst inst;
#endif
**/
#ifdef ANSI
-PUBLIC S16 rgSCHMeasGapANRepUeCfg
+S16 rgSCHMeasGapANRepUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCfg *ueCfg
)
#else
-PUBLIC S16 rgSCHMeasGapANRepUeCfg(cell, ue, ueCfg)
+S16 rgSCHMeasGapANRepUeCfg(cell, ue, ueCfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
**/
#ifdef ANSI
-PUBLIC S16 rgSCHMeasGapANRepUeRecfg
+S16 rgSCHMeasGapANRepUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg
)
#else
-PUBLIC S16 rgSCHMeasGapANRepUeRecfg(cell, ue, ueRecfg)
+S16 rgSCHMeasGapANRepUeRecfg(cell, ue, ueRecfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
**/
#ifdef ANSI
-PUBLIC Void rgSCHMeasGapANRepUeDel
+Void rgSCHMeasGapANRepUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isUeDel
)
#else
-PUBLIC Void rgSCHMeasGapANRepUeDel(cell, ue, isUeDel)
+Void rgSCHMeasGapANRepUeDel(cell, ue, isUeDel)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isUeDel;
**/
#ifdef ANSI
-PUBLIC S16 rgSCHMeasGapANRepTtiHndl
+S16 rgSCHMeasGapANRepTtiHndl
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHMeasGapANRepTtiHndl(cell)
+S16 rgSCHMeasGapANRepTtiHndl(cell)
RgSchCellCb *cell;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHMeasGapANRepGetDlInactvUe
+S16 rgSCHMeasGapANRepGetDlInactvUe
(
RgSchCellCb *cell,
CmLListCp *dlInactvUeLst
)
#else
-PUBLIC S16 rgSCHMeasGapANRepGetDlInactvUe(cell, dlInactvUeLst)
+S16 rgSCHMeasGapANRepGetDlInactvUe(cell, dlInactvUeLst)
RgSchCellCb *cell;
CmLListCp *dlInactvUeLst;
#endif
**/
#ifdef ANSI
-PUBLIC S16 rgSCHMeasGapANRepGetUlInactvUe
+S16 rgSCHMeasGapANRepGetUlInactvUe
(
RgSchCellCb *cell,
CmLListCp *ulInactvUeLst
)
#else
-PUBLIC S16 rgSCHMeasGapANRepGetUlInactvUe(cell, ulInactvUeLst)
+S16 rgSCHMeasGapANRepGetUlInactvUe(cell, ulInactvUeLst)
RgSchCellCb *cell;
CmLListCp *ulInactvUeLst;
#endif
**/
#ifdef ANSI
-PUBLIC Void rgSCHMeasGapANRepDlInactvTmrExpry
+Void rgSCHMeasGapANRepDlInactvTmrExpry
(
RgSchUeCb *ue,
U8 tmrEvnt
)
#else
-PUBLIC Void rgSCHMeasGapANRepDlInactvTmrExpry(ue, tmrEvnt)
+Void rgSCHMeasGapANRepDlInactvTmrExpry(ue, tmrEvnt)
RgSchUeCb *ue;
U8 tmrEvnt;
#endif
**/
#ifdef ANSI
-PUBLIC Void rgSCHMeasGapANRepUlInactvTmrExpry
+Void rgSCHMeasGapANRepUlInactvTmrExpry
(
RgSchUeCb *ue,
U8 tmrEvnt
)
#else
-PUBLIC Void rgSCHMeasGapANRepUlInactvTmrExpry(ue, tmrEvnt)
+Void rgSCHMeasGapANRepUlInactvTmrExpry(ue, tmrEvnt)
RgSchUeCb *ue;
U8 tmrEvnt;
#endif
**/
#ifdef ANSI
-PUBLIC Void rgSCHMeasGapANRepTmrExpry
+Void rgSCHMeasGapANRepTmrExpry
(
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHMeasGapANRepTmrExpry(ue)
+Void rgSCHMeasGapANRepTmrExpry(ue)
RgSchUeCb *ue;
#endif
{
**/
#ifdef ANSI
-PUBLIC Void rgSCHAckNakRepTmrExpry
+Void rgSCHAckNakRepTmrExpry
(
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHAckNakRepTmrExpry(ue)
+Void rgSCHAckNakRepTmrExpry(ue)
RgSchUeCb *ue;
#endif
{
**/
#ifdef ANSI
-PUBLIC Void rgSCHAckNakRepAddToQ
+Void rgSCHAckNakRepAddToQ
(
RgSchCellCb *cell,
RgSchDlSf *crntDlSf
)
#else
-PUBLIC Void rgSCHAckNakRepAddToQ(cell, crntDlSf)
+Void rgSCHAckNakRepAddToQ(cell, crntDlSf)
RgSchCellCb *cell;
RgSchDlSf *crntDlSf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacCellReg
+S16 RgSchMacCellReg
(
Pst* pst,
RgInfCellReg* regReq
)
#else
-PUBLIC S16 RgSchMacCellReg(pst, regReq)
+S16 RgSchMacCellReg(pst, regReq)
Pst* pst;
RgInfCellReg* regReq;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchDedBoUpdt
+S16 RgMacSchDedBoUpdt
(
Pst* pst,
RgInfDedBoRpt* boRpt
)
#else
-PUBLIC S16 RgMacSchDedBoUpdt(pst, boRpt)
+S16 RgMacSchDedBoUpdt(pst, boRpt)
Pst* pst;
RgInfDedBoRpt* boRpt;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchCmnBoUpdt
+S16 RgMacSchCmnBoUpdt
(
Pst* pst,
RgInfCmnBoRpt* boRpt
)
#else
-PUBLIC S16 RgMacSchCmnBoUpdt(pst, boRpt)
+S16 RgMacSchCmnBoUpdt(pst, boRpt)
Pst* pst;
RgInfCmnBoRpt* boRpt;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchUeDel
+S16 RgMacSchUeDel
(
Pst* pst,
RgInfUeDelInd* ueDelInd
)
#else
-PUBLIC S16 RgMacSchUeDel(pst, datInd)
+S16 RgMacSchUeDel(pst, datInd)
Pst* pst;
RgInfUeDelInd* ueDelInd;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchSfRecp
+S16 RgMacSchSfRecp
(
Pst* pst,
RgInfSfDatInd* datInd
)
#else
-PUBLIC S16 RgMacSchSfRecp(pst, datInd)
+S16 RgMacSchSfRecp(pst, datInd)
Pst* pst;
RgInfSfDatInd* datInd;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacSfAlloc
+S16 RgSchMacSfAlloc
(
Pst* pst,
RgInfSfAlloc* resAllocReq
)
#else
-PUBLIC S16 RgSchMacSfAlloc(pst, resAllocReq)
+S16 RgSchMacSfAlloc(pst, resAllocReq)
Pst* pst;
RgInfSfAlloc* resAllocReq;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRstHqEnt
+S16 RgSchMacRstHqEnt
(
Pst* pst,
RgInfResetHqEnt* hqEntInfo
)
#else
-PUBLIC S16 RgSchMacRstHqEnt(pst, hqEntInfo)
+S16 RgSchMacRstHqEnt(pst, hqEntInfo)
Pst* pst;
RgInfResetHqEnt* hqEntInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRlsHq
+S16 RgSchMacRlsHq
(
Pst* pst,
RgInfRlsHqInfo* sfHqInfo
)
#else
-PUBLIC S16 RgSchMacRlsHq(pst, sfHqInfo)
+S16 RgSchMacRlsHq(pst, sfHqInfo)
Pst* pst;
RgInfRlsHqInfo* sfHqInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRlsRnti
+S16 RgSchMacRlsRnti
(
Pst* pst,
RgInfRlsRnti* rlsRnti
)
#else
-PUBLIC S16 RgSchMacRlsRnti(pst, rlsRnti)
+S16 RgSchMacRlsRnti(pst, rlsRnti)
Pst* pst;
RgInfRlsRnti* rlsRnti;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacLcgReg
+S16 RgSchMacLcgReg
(
Pst* pst,
RgInfLcgRegReq *lcgRegReq
)
#else
-PUBLIC S16 RgSchMacLcgReg(pst, lcgRegReq)
+S16 RgSchMacLcgReg(pst, lcgRegReq)
Pst* pst;
RgInfLcgRegReq *lcgRegReq;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchSpsRel
+S16 RgMacSchSpsRel
(
Pst* pst,
RgInfSpsRelInfo* relInfo
)
#else
-PUBLIC S16 RgMacSchSpsRel(pst, relInfo)
+S16 RgMacSchSpsRel(pst, relInfo)
Pst* pst;
RgInfSpsRelInfo* relInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacSpsLcReg
+S16 RgSchMacSpsLcReg
(
Pst* pst,
RgInfSpsLcInfo *lcInfo
)
#else
-PUBLIC S16 RgSchMacSpsLcReg(pst, lcInfo)
+S16 RgSchMacSpsLcReg(pst, lcInfo)
Pst* pst;
RgInfSpsLcInfo *lcInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacUlSpsReset
+S16 RgSchMacUlSpsReset
(
Pst* pst,
RgInfUlSpsReset *ulSpsResetInfo
)
#else
-PUBLIC S16 RgSchMacUlSpsReset(pst, ulSpsResetInfo)
+S16 RgSchMacUlSpsReset(pst, ulSpsResetInfo)
Pst* pst;
RgInfUlSpsReset *ulSpsResetInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacSpsLcDereg
+S16 RgSchMacSpsLcDereg
(
Pst* pst,
CmLteCellId cellId,
CmLteRnti crnti
)
#else
-PUBLIC S16 RgSchMacSpsLcDereg(pst, cellId, crnti)
+S16 RgSchMacSpsLcDereg(pst, cellId, crnti)
Pst* pst;
CmLteCellId cellId;
CmLteRnti crnti;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacL2Meas
+S16 RgSchMacL2Meas
(
Pst* pst,
RgInfL2MeasReq *measInfo
)
#else
-PUBLIC S16 RgSchMacL2Meas(pst, measInfo)
+S16 RgSchMacL2Meas(pst, measInfo)
Pst* pst;
RgInfL2MeasReq *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacL2MeasStop
+S16 RgSchMacL2MeasStop
(
Pst* pst,
RgInfL2MeasStopReq *measInfo
)
#else
-PUBLIC S16 RgSchMacL2MeasStop(pst, measInfo)
+S16 RgSchMacL2MeasStop(pst, measInfo)
Pst* pst;
RgInfL2MeasStopReq *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacL2MeasSend
+S16 RgSchMacL2MeasSend
(
Pst* pst,
RgInfL2MeasSndReq *measInfo
)
#else
-PUBLIC S16 RgSchMacL2MeasSend(pst, measInfo)
+S16 RgSchMacL2MeasSend(pst, measInfo)
Pst* pst;
RgInfL2MeasSndReq *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchL2Meas
+S16 RgMacSchL2Meas
(
Pst* pst,
RgInfL2MeasCfm *measInfo
)
#else
-PUBLIC S16 RgMacSchL2Meas(pst, measInfo)
+S16 RgMacSchL2Meas(pst, measInfo)
Pst* pst;
RgInfL2MeasCfm *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgMacSchL2MeasStop
+S16 RgMacSchL2MeasStop
(
Pst* pst,
RgInfL2MeasCfm *measInfo
)
#else
-PUBLIC S16 RgMacSchL2MeasStop(pst, measInfo)
+S16 RgMacSchL2MeasStop(pst, measInfo)
Pst* pst;
RgInfL2MeasCfm *measInfo;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrInit
+Void rgSCHPwrInit
(
Void
)
#else
-PUBLIC Void rgSCHPwrInit()
+Void rgSCHPwrInit()
#endif
{
U8 idx;
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHPwrPuschTpcForUe
+U8 rgSCHPwrPuschTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSCHPwrPuschTpcForUe(cell, ue)
+U8 rgSCHPwrPuschTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC U8 rgSCHPwrGetMaxUlRb
+U8 rgSCHPwrGetMaxUlRb
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSCHPwrGetMaxUlRb(cell, ue)
+U8 rgSCHPwrGetMaxUlRb(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHPwrPucchTpcForUe
+U8 rgSCHPwrPucchTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSCHPwrPucchTpcForUe(cell, ue)
+U8 rgSCHPwrPucchTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrGrpCntrlPucch
+Void rgSCHPwrGrpCntrlPucch
(
RgSchCellCb *cell,
RgSchDlSf *dlSf
)
#else
-PUBLIC Void rgSCHPwrGrpCntrlPucch(cell, dlSf)
+Void rgSCHPwrGrpCntrlPucch(cell, dlSf)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrGrpCntrlPusch
+Void rgSCHPwrGrpCntrlPusch
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchUlSf *ulSf
)
#else
-PUBLIC Void rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf)
+Void rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchUlSf *ulSf;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrPucchDeltaInd
+Void rgSCHPwrPucchDeltaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
S8 pwrDelta
)
#else
-PUBLIC Void rgSCHPwrPucchDeltaInd(cell, ue, pwrDelta)
+Void rgSCHPwrPucchDeltaInd(cell, ue, pwrDelta)
RgSchCellCb *cell;
RgSchUeCb *ue;
S8 pwrDelta;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUpdExtPhr
+Void rgSCHPwrUpdExtPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchCmnAllocRecord *allocInfo
)
#else
-PUBLIC Void rgSCHPwrUpdExtPhr(cell, ue, extPhr, allocInfo)
+Void rgSCHPwrUpdExtPhr(cell, ue, extPhr, allocInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfExtPhrCEInfo *extPhr;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUpdPhr
+Void rgSCHPwrUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
S8 maxUePwr
)
#else
-PUBLIC Void rgSCHPwrUpdPhr(cell, ue, phr, allocInfo, maxUePwr)
+Void rgSCHPwrUpdPhr(cell, ue, phr, allocInfo, maxUePwr)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 phr;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUlCqiInd
+Void rgSCHPwrUlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHPwrUlCqiInd(cell, ue)
+Void rgSCHPwrUlCqiInd(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrRecordRbAlloc
+Void rgSCHPwrRecordRbAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 numRb
)
#else
-PUBLIC Void rgSCHPwrRecordRbAlloc(cell, ue, numRb)
+Void rgSCHPwrRecordRbAlloc(cell, ue, numRb)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 numRb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrCellCfg
+S16 rgSCHPwrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cfg
)
#else
-PUBLIC S16 rgSCHPwrCellCfg(cell, cfg)
+S16 rgSCHPwrCellCfg(cell, cfg)
RgSchCellCb *cell;
RgrCellCfg *cfg;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrCellRecfg
+S16 rgSCHPwrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg
)
#else
-PUBLIC S16 rgSCHPwrCellRecfg(cell, recfg)
+S16 rgSCHPwrCellRecfg(cell, recfg)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrCellDel
+Void rgSCHPwrCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHPwrCellDel(cell)
+Void rgSCHPwrCellDel(cell)
RgSchCellCb *cell;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrUeSCellCfg
+S16 rgSCHPwrUeSCellCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeSecCellCfg *sCellInfoCfg
)
#else
-PUBLIC S16 rgSCHPwrUeSCellCfg(cell, ue, sCellInfoCfg)
+S16 rgSCHPwrUeSCellCfg(cell, ue, sCellInfoCfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeSecCellCfg *sCellInfoCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrUeCfg
+S16 rgSCHPwrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCfg *cfg
)
#else
-PUBLIC S16 rgSCHPwrUeCfg(cell, ue, cfg)
+S16 rgSCHPwrUeCfg(cell, ue, cfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *cfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrUeRecfg
+S16 rgSCHPwrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *recfg
)
#else
-PUBLIC S16 rgSCHPwrUeRecfg(cell, ue, recfg)
+S16 rgSCHPwrUeRecfg(cell, ue, recfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *recfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUeDel
+Void rgSCHPwrUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHPwrUeDel(cell, ue)
+Void rgSCHPwrUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUeReset
+Void rgSCHPwrUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHPwrUeReset(cell, ue)
+Void rgSCHPwrUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamVldtUeCfg
+S16 rgSCHRamVldtUeCfg
(
RgSchCellCb *cell,
RgrUeCfg *ueCfg
)
#else
-PUBLIC S16 rgSCHRamVldtUeCfg(cell, ueCfg)
+S16 rgSCHRamVldtUeCfg(cell, ueCfg)
RgSchCellCb *cell;
RgrUeCfg *ueCfg;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamProcRaReq
+S16 rgSCHRamProcRaReq
(
U8 raReqCnt,
RgSchCellCb *cell,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHRamProcRaReq(raReqCnt, cell, raRnti, raReqInd, timingInfo, ue, err)
+S16 rgSCHRamProcRaReq(raReqCnt, cell, raRnti, raReqInd, timingInfo, ue, err)
U8 raReqCnt;
RgSchCellCb *cell;
CmLteRnti raRnti;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamCreateRaCb
+S16 rgSCHRamCreateRaCb
(
RgSchCellCb *cell,
RgSchRaCb **raCb,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHRamCreateRaCb(cell, raCb, err)
+S16 rgSCHRamCreateRaCb(cell, raCb, err)
RgSchCellCb *cell;
RgSchRaCb **raCb;
RgSchErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamRgrUeCfg
+S16 rgSCHRamRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHRamRgrUeCfg(cell, ue, raCb, err)
+S16 rgSCHRamRgrUeCfg(cell, ue, raCb, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchRaCb *raCb;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamProcMsg3
+S16 rgSCHRamProcMsg3
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHRamProcMsg3(cell, ue, raCb, pdu, err)
+S16 rgSCHRamProcMsg3(cell, ue, raCb, pdu, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchRaCb *raCb;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamUpdtBo
+S16 rgSCHRamUpdtBo
(
RgSchCellCb *cell,
RgSchRaCb *raCb,
RgInfCmnBoRpt *staRsp
)
#else
-PUBLIC S16 rgSCHRamUpdtBo(cell, raCb, staRsp)
+S16 rgSCHRamUpdtBo(cell, raCb, staRsp)
RgSchCellCb *cell;
RgSchRaCb *raCb;
RgInfCmnBoRpt *staRsp;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg3DatInd
+S16 rgSCHRamMsg3DatInd
(
RgSchRaCb *raCb
)
#else
-PUBLIC S16 rgSCHRamMsg3DatInd(raCb)
+S16 rgSCHRamMsg3DatInd(raCb)
RgSchRaCb *raCb;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg3FailureInd
+S16 rgSCHRamMsg3FailureInd
(
RgSchRaCb *raCb
)
#else
-PUBLIC S16 rgSCHRamMsg3FailureInd(raCb)
+S16 rgSCHRamMsg3FailureInd(raCb)
RgSchRaCb *raCb;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg4FdbkInd
+S16 rgSCHRamMsg4FdbkInd
(
RgSchRaCb *raCb
)
#else
-PUBLIC S16 rgSCHRamMsg4FdbkInd(raCb)
+S16 rgSCHRamMsg4FdbkInd(raCb)
RgSchRaCb *raCb;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg4Done
+S16 rgSCHRamMsg4Done
(
RgSchCellCb *cell,
RgSchRaCb *raCb
)
#else
-PUBLIC S16 rgSCHRamMsg4Done(cell, raCb)
+S16 rgSCHRamMsg4Done(cell, raCb)
RgSchCellCb *cell;
RgSchRaCb *raCb;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamDelRaCb
+S16 rgSCHRamDelRaCb
(
RgSchCellCb *cell,
RgSchRaCb *raCb,
Bool rlsRnti
)
#else
-PUBLIC S16 rgSCHRamDelRaCb(cell, raCb, rlsRnti)
+S16 rgSCHRamDelRaCb(cell, raCb, rlsRnti)
RgSchCellCb *cell;
RgSchRaCb *raCb;
Bool rlsRnti;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamTtiHndlr
+S16 rgSCHRamTtiHndlr
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHRamTtiHndlr(cell)
+S16 rgSCHRamTtiHndlr(cell)
RgSchCellCb *cell;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamFreeCell
+S16 rgSCHRamFreeCell
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHRamFreeCell(cell)
+S16 rgSCHRamFreeCell(cell)
RgSchCellCb *cell;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHRamDelRaReq
+S16 rgSCHRamDelRaReq
(
RgSchCellCb *cell,
CmLteTimingInfo timingInfo,
U8 raIdx
)
#else
-PUBLIC S16 rgSCHRamDelRaReq(cell, timingInfo, raIdx)
+S16 rgSCHRamDelRaReq(cell, timingInfo, raIdx)
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
U8 raIdx;
/*MSG4 Fix Start */
#ifdef ANSI
-PUBLIC S16 rgSCHRamAddToRaInfoSchdLst
+S16 rgSCHRamAddToRaInfoSchdLst
(
RgSchCellCb *cell,
RgSchRaCb *raCb
)
#else
-PUBLIC S16 rgSCHRamAddToRaInfoSchdLst(cell, raCb)
+S16 rgSCHRamAddToRaInfoSchdLst(cell, raCb)
RgSchCellCb *cell;
RgSchRaCb *raCb;
#endif
#ifdef ANSI
-PUBLIC S16 rgSCHRamRmvFrmRaInfoSchdLst
+S16 rgSCHRamRmvFrmRaInfoSchdLst
(
RgSchCellCb *cell,
RgSchRaCb *raCb
)
#else
-PUBLIC S16 rgSCHRamRmvFrmRaInfoSchdLst(cell, raCb)
+S16 rgSCHRamRmvFrmRaInfoSchdLst(cell, raCb)
RgSchCellCb *cell;
RgSchRaCb *raCb;
#endif
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
));
-PUBLIC Void rgSCHSc1DlScanUpdPdbPrio ARGS((
+Void rgSCHSc1DlScanUpdPdbPrio ARGS((
RgSchCellCb *cell
));
-PUBLIC S16 rgSCHSc1DlFillFlowCntrlInfo ARGS((
+S16 rgSCHSc1DlFillFlowCntrlInfo ARGS((
RgSchCellCb *cell,
RgInfSfAlloc *sfAlloc
));
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlUeReset
+Void rgSCHSc1DlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlUeReset(cell, ue)
+Void rgSCHSc1DlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlActvtUe
+Void rgSCHSc1DlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlActvtUe(cell, ue)
+Void rgSCHSc1DlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlUeRefresh
+Void rgSCHSc1DlUeRefresh
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlUeRefresh(cell, ue)
+Void rgSCHSc1DlUeRefresh(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlProcAddToCellRetx
+Void rgSCHSc1DlProcAddToCellRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHSc1DlProcAddToCellRetx(cell, hqP)
+Void rgSCHSc1DlProcAddToCellRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1DlPreSchd(cell)
+Void rgSCHSc1DlPreSchd(cell)
RgSchCellCb *cell;
#endif
{
Inst schInst
)
#else
-PUBLIC Void rgSCHSc1DlPstSchd(schInst)
+Void rgSCHSc1DlPstSchd(schInst)
Inst schInst
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlLcRmv
+Void rgSCHSc1DlLcRmv
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHSc1DlLcRmv(cell, ue, svc)
+Void rgSCHSc1DlLcRmv(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlLcBoUpd
+Void rgSCHSc1DlLcBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHSc1DlLcBoUpd(cell, ue, svc)
+Void rgSCHSc1DlLcBoUpd(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrDlCellCfg
+S16 rgSCHSc1RgrDlCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrDlCellCfg(cell, cellCfg, err)
+S16 rgSCHSc1RgrDlCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlCellDel
+Void rgSCHSc1DlCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1DlCellDel(cell)
+Void rgSCHSc1DlCellDel(cell)
RgSchCellCb *cell;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrDlUeCfg
+S16 rgSCHSc1RgrDlUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrDlUeCfg(cell, ue, ueCfg, err)
+S16 rgSCHSc1RgrDlUeCfg(cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1DlUeHqEntInit
+S16 rgSCHSc1DlUeHqEntInit
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqEnt
)
#else
-PUBLIC S16 rgSCHSc1DlUeHqEntInit(cell, hqEnt)
+S16 rgSCHSc1DlUeHqEntInit(cell, hqEnt)
RgSchCellCb *cell;
RgSchDlHqEnt *hqEnt
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1DlUeHqEntDeInit
+S16 rgSCHSc1DlUeHqEntDeInit
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqE
)
#else
-PUBLIC S16 rgSCHSc1DlUeHqEntDeInit(cell, hqE)
+S16 rgSCHSc1DlUeHqEntDeInit(cell, hqE)
RgSchCellCb *cell;
RgSchDlHqEnt *hqE;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrDlUeRecfg
+S16 rgSCHSc1RgrDlUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrDlUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHSc1RgrDlUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlScanUpdPdbPrio
+Void rgSCHSc1DlScanUpdPdbPrio
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1DlScanUpdPdbPrio (cell)
+Void rgSCHSc1DlScanUpdPdbPrio (cell)
RgSchCellCb *cell;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1DlFillFlowCntrlInfo
+S16 rgSCHSc1DlFillFlowCntrlInfo
(
RgSchCellCb *cell,
RgInfSfAlloc *sfAlloc
)
#else
-PUBLIC S16 rgSCHSc1DlFillFlowCntrlInfo(cell,sfAlloc)
+S16 rgSCHSc1DlFillFlowCntrlInfo(cell,sfAlloc)
RgSchCellCb *cell;
RgInfSfAlloc *sfAlloc;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlUeDel
+Void rgSCHSc1DlUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlUeDel(cell, ue)
+Void rgSCHSc1DlUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcCfg
+S16 rgSCHSc1RgrLcCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcCfg(cell, ue, dlLc, lcCfg, err)
+S16 rgSCHSc1RgrLcCfg(cell, ue, dlLc, lcCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcRecfg
+S16 rgSCHSc1RgrLcRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcRecfg(cell, ue, dlLc, lcRecfg, err)
+S16 rgSCHSc1RgrLcRecfg(cell, ue, dlLc, lcRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlHndlInActUes
+Void rgSCHSc1DlHndlInActUes
(
RgSchCellCb *cell,
CmLListCp *inactvLst
)
#else
-PUBLIC Void rgSCHSc1DlHndlInActUes(cell, inactvLst)
+Void rgSCHSc1DlHndlInActUes(cell, inactvLst)
RgSchCellCb *cell;
CmLListCp *inactvLst;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlInit
+Void rgSCHSc1DlInit
(
RgDlSchdApis *rgSchDlApis
)
#else
-PUBLIC Void rgSCHSc1DlInit(rgSchDlApis)
+Void rgSCHSc1DlInit(rgSchDlApis)
RgDlSchdApis *rgSchDlApis;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlAllocFnlz
+Void rgSCHSc1DlAllocFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHSc1DlAllocFnlz(cell, allocInfo)
+Void rgSCHSc1DlAllocFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlCqiInd
+Void rgSCHSc1DlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Void *dlCqi
)
#else
-PUBLIC Void rgSCHSc1DlCqiInd(cell, ue, isPucchInfo, dlCqi)
+Void rgSCHSc1DlCqiInd(cell, ue, isPucchInfo, dlCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isPucchInfo;
* @return S16
* -# ROK
**/
-PUBLIC S16 rgSCHSc1UlLchCfg
+S16 rgSCHSc1UlLchCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
* @return S16
* -# ROK
**/
-PUBLIC S16 rgSCHSc1UlLchRecfg
+S16 rgSCHSc1UlLchRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1UlLchDel
+S16 rgSCHSc1UlLchDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC S16 rgSCHRrUlLchDel(cell, ue, lcId, lcgId)
+S16 rgSCHRrUlLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlInit
+Void rgSCHSc1UlInit
(
RgUlSchdApis *rgSchUlApis
)
#else
-PUBLIC Void rgSCHSc1UlInit(rgSchUlApis)
+Void rgSCHSc1UlInit(rgSchUlApis)
RgUlSchdApis *rgSchUlApis;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlUeCfg
+S16 rgSCHSc1RgrUlUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlUeCfg(cell, ue, ueCfg, err)
+S16 rgSCHSc1RgrUlUeCfg(cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlUeRecfg
+S16 rgSCHSc1RgrUlUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHSc1RgrUlUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlUeDel
+Void rgSCHSc1UlUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlUeDel(cell, ue)
+Void rgSCHSc1UlUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlUeReset
+Void rgSCHSc1UlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlUeReset(cell, ue)
+Void rgSCHSc1UlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlCellCfg
+S16 rgSCHSc1RgrUlCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlCellCfg(cell, cellCfg, err)
+S16 rgSCHSc1RgrUlCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlCellRecfg
+S16 rgSCHSc1RgrUlCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlCellRecfg(cell, recfg, err)
+S16 rgSCHSc1RgrUlCellRecfg(cell, recfg, err)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
RgSchErrInfo *err;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlCellDel
+Void rgSCHSc1UlCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1UlCellDel(cell)
+Void rgSCHSc1UlCellDel(cell)
RgSchCellCb *cell;
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcgCfg
+S16 rgSCHSc1RgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcgCfg(cell, ue, lcg, lcgCfg, err)
+S16 rgSCHSc1RgrLcgCfg(cell, ue, lcg, lcgCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcgRecfg
+S16 rgSCHSc1RgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcgRecfg(cell, ue, lcg, reCfg, err)
+S16 rgSCHSc1RgrLcgRecfg(cell, ue, lcg, reCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1LcgDel
+Void rgSCHSc1LcgDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg
)
#else
-PUBLIC Void rgSCHSc1LcgDel(cell, ue, lcg)
+Void rgSCHSc1LcgDel(cell, ue, lcg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlSched
+Void rgSCHSc1UlSched
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHSc1UlSched(cell, allocInfo)
+Void rgSCHSc1UlSched(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UpdBsrShort
+Void rgSCHSc1UpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 bsr
)
#else
-PUBLIC Void rgSCHSc1UpdBsrShort(cell, ue, lcg, bsr)
+Void rgSCHSc1UpdBsrShort(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UpdBsrTrunc
+Void rgSCHSc1UpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 bsr
)
#else
-PUBLIC Void rgSCHSc1UpdBsrTrunc(cell, ue, lcg, bsr)
+Void rgSCHSc1UpdBsrTrunc(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UpdBsrLong
+Void rgSCHSc1UpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 *bsArr
)
#else
-PUBLIC Void rgSCHSc1UpdBsrLong(cell, ue, bsArr)
+Void rgSCHSc1UpdBsrLong(cell, ue, bsArr)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 *bsArr;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1ContResUlGrant
+Void rgSCHSc1ContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1ContResUlGrant(cell, ue)
+Void rgSCHSc1ContResUlGrant(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1SrRcvd
+Void rgSCHSc1SrRcvd
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1SrRcvd(cell, ue)
+Void rgSCHSc1SrRcvd(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlCqiInd
+Void rgSCHSc1UlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo
)
#else
-PUBLIC Void rgSCHSc1UlCqiInd(cell, ue, ulCqiInfo)
+Void rgSCHSc1UlCqiInd(cell, ue, ulCqiInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuUlCqiRpt *ulCqiInfo;
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1UlLcgUpd
+S16 rgSCHSc1UlLcgUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgInfUeDatInd *datInd
)
#else
-PUBLIC S16 rgSCHSc1UlLcgUpd(cell, ue)
+S16 rgSCHSc1UlLcgUpd(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfUeDatInd *datInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlUeRefresh
+Void rgSCHSc1UlUeRefresh
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlUeRefresh(cell, ue)
+Void rgSCHSc1UlUeRefresh(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlAllocFnlz
+Void rgSCHSc1UlAllocFnlz
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHSc1UlAllocFnlz(cell, allocInfo)
+Void rgSCHSc1UlAllocFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlActvtUe
+Void rgSCHSc1UlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlActvtUe(cell, ue)
+Void rgSCHSc1UlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlHndlInActUes
+Void rgSCHSc1UlHndlInActUes
(
RgSchCellCb *cell,
CmLListCp *inactvLst
)
#else
-PUBLIC Void rgSCHSc1UlHndlInActUes(cell, inactvLst)
+Void rgSCHSc1UlHndlInActUes(cell, inactvLst)
RgSchCellCb *cell;
CmLListCp *inactvLst;
#endif
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlProcRmvFrmRetx(
+Void rgSCHSc1DlProcRmvFrmRetx(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHSc1DlProcRmvFrmRetx(cell, ue, hqP)
+Void rgSCHSc1DlProcRmvFrmRetx(cell, ue, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
#ifdef LTE_ADV
-PUBLIC Void rgSCHSCellActivation ARGS((
+Void rgSCHSCellActivation ARGS((
RgSchUeCellInfo *sCell
));
-PUBLIC Void rgSCHSCellSchdActDeactCe ARGS((
+Void rgSCHSCellSchdActDeactCe ARGS((
RgSchUeCb *ueCb,
RgSchDlHqTbCb *tbInfo
));
-PUBLIC Void rgSCHSCellAddToActDeactLst ARGS((
+Void rgSCHSCellAddToActDeactLst ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PUBLIC Void rgSCHSCellRmvFrmActLst ARGS((
+Void rgSCHSCellRmvFrmActLst ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PUBLIC S16 rgSCHSCellIsActive ARGS((
+S16 rgSCHSCellIsActive ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PUBLIC Void rgSCHSCellHndlFdbkInd ARGS((
+Void rgSCHSCellHndlFdbkInd ARGS((
RgSchDlHqProcCb *hqP,
U8 tbIdx,
U8 fdbk,
));
#ifdef LTE_ADV
-PUBLIC Void rgSCHSCellDeactTmrExpry ARGS((
+Void rgSCHSCellDeactTmrExpry ARGS((
RgSchUeCellInfo *sCell
));
#endif
-PUBLIC Void rgSCHSCellDelUeSCell ARGS((
+Void rgSCHSCellDelUeSCell ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
U8 sCellIdx
));
-PUBLIC S16 rgSCHSCellDelUe ARGS((
+S16 rgSCHSCellDelUe ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
));
#ifdef TFU_UPGRADE
-PUBLIC S16 rgSCHSCellPCqiCfg ARGS((
+S16 rgSCHSCellPCqiCfg ARGS((
RgSchCellCb *priCellCb,
RgSchCellCb *secCellCb,
RgSchUeCb *ueCb,
* -# None.
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellSchdActDeactCe
+Void rgSCHSCellSchdActDeactCe
(
RgSchUeCb *ueCb,
RgSchDlHqTbCb *tbInfo
)
#else
-PUBLIC Void rgSCHSCellSchdActDeactCe(ueCb, tbInfo)
+Void rgSCHSCellSchdActDeactCe(ueCb, tbInfo)
RgSchUeCb *ueCb;
RgSchDlHqTbCb *tbInfo;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellAddToActDeactLst
+Void rgSCHSCellAddToActDeactLst
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSCellAddToActDeactLst(cell, ue)
+Void rgSCHSCellAddToActDeactLst(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellRmvFrmActLst
+Void rgSCHSCellRmvFrmActLst
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSCellRmvFrmActLst(cell, ue)
+Void rgSCHSCellRmvFrmActLst(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellActivation
+Void rgSCHSCellActivation
(
RgSchUeCellInfo *sCellInfo
)
#else
-PUBLIC Void rgSCHSCellActivation(sCellInfo)
+Void rgSCHSCellActivation(sCellInfo)
RgSchUeCellInfo *sCellInfo
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellHndlFdbkInd
+Void rgSCHSCellHndlFdbkInd
(
RgSchDlHqProcCb *hqP,
U8 tbIdx,
Bool maxHqRetxReached
)
#else
-PUBLIC Void rgSCHSCellHndlFdbkInd(hqP, tbIdx, fdbk,maxHqRetxReached)
+Void rgSCHSCellHndlFdbkInd(hqP, tbIdx, fdbk,maxHqRetxReached)
RgSchDlHqProcCb *hqP;
U8 tbIdx;
U8 fdbk;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellDeactTmrExpry
+Void rgSCHSCellDeactTmrExpry
(
RgSchUeCellInfo *sCellInfo
)
#else
-PUBLIC Void rgSCHSCellDeactTmrExpry(sCellInfo)
+Void rgSCHSCellDeactTmrExpry(sCellInfo)
RgSchUeCellInfo *sCellInfo;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellTrigActDeact
+S16 rgSCHSCellTrigActDeact
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
U8 action
)
#else
-PUBLIC S16 rgSCHSCellTrigActDeact(cell,ueCb,sCellIdx,action)
+S16 rgSCHSCellTrigActDeact(cell,ueCb,sCellIdx,action)
RgSchCellCb *cell,
RgSchUeCb *ueCb;
U8 sCellIdx;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellSelectAndActDeAct
+Void rgSCHSCellSelectAndActDeAct
(
RgSchCellCb *pCell,
RgSchUeCb *ueCb,
U8 action
)
#else
-PUBLIC Void rgSCHSCellSelectAndActDeAct(pCell, ueCb, action)
+Void rgSCHSCellSelectAndActDeAct(pCell, ueCb, action)
RgSchCellCb *pCell;
RgSchUeCb *ueCb;
U8 action;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellDelUeSCell
+Void rgSCHSCellDelUeSCell
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
U8 sCellIdx
)
#else
-PUBLIC Void rgSCHSCellDelUeSCell(cellCb,ueCb,sCellIdx)
+Void rgSCHSCellDelUeSCell(cellCb,ueCb,sCellIdx)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
U8 sCellIdx;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellDelUe
+S16 rgSCHSCellDelUe
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHSCellDelUe(cellCb,ueCb)
+S16 rgSCHSCellDelUe(cellCb,ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellPCqiCfg
+S16 rgSCHSCellPCqiCfg
(
RgSchCellCb *priCellCb,
RgSchCellCb *secCellCb,
U8 sCellIdx
)
#else
-PUBLIC S16 rgSCHSCellPCqiCfg(priCellCb,secCellCb,ueCb,cqiCfg,ueCat,sCellIdx)
+S16 rgSCHSCellPCqiCfg(priCellCb,secCellCb,ueCb,cqiCfg,ueCat,sCellIdx)
RgSchCellCb *priCellCb;
RgSchCellCb *secCellCb;
RgSchUeCb *ueCb;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellDlUeReset
+Void rgSCHSCellDlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSCellDlUeReset(cell, ue)
+Void rgSCHSCellDlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellDlLcCfg
+Void rgSCHSCellDlLcCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHSCellDlLcCfg(cell, ue, svc)
+Void rgSCHSCellDlLcCfg(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellDlLcDel
+Void rgSCHSCellDlLcDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHSCellDlLcDel(cell, ue, svc)
+Void rgSCHSCellDlLcDel(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellDlDedBoUpd
+Void rgSCHSCellDlDedBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHSCellDlDedBoUpd(cell, ue, svc)
+Void rgSCHSCellDlDedBoUpd(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSCellHndlCqiCollsn
+S16 rgSCHUtlSCellHndlCqiCollsn
(
RgSchUePCqiCb *cqiCb
)
#else
-PUBLIC S16 rgSCHUtlSCellHndlCqiCollsn(cqiCb)
+S16 rgSCHUtlSCellHndlCqiCollsn(cqiCb)
RgSchUePCqiCb *cqiCb;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSCellHndlRiCollsn
+S16 rgSCHUtlSCellHndlRiCollsn
(
RgSchUePCqiCb *cqiCb
)
#else
-PUBLIC S16 rgSCHUtlSCellHndlRiCollsn(cqiCb)
+S16 rgSCHUtlSCellHndlRiCollsn(cqiCb)
RgSchUePCqiCb *cqiCb;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellIsActive
+S16 rgSCHSCellIsActive
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHSCellIsActive(cell, ue)
+S16 rgSCHSCellIsActive(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# TRUE
**/
#ifdef ANSI
-PUBLIC Bool rgSCHIsActvReqd
+Bool rgSCHIsActvReqd
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Bool rgSCHIsActvReqd(cell, ue)
+Bool rgSCHIsActvReqd(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue
#endif
#include "rg_sch.x" /* typedefs for MAC */
#ifdef LTE_ADV
-EXTERN PUBLIC Void rgSCHSCellActivation ARGS((
+EXTERN Void rgSCHSCellActivation ARGS((
RgSchUeCellInfo *sCell
));
#endif
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHTmrStartTmr
+Void rgSCHTmrStartTmr
(
RgSchCellCb *cell,
Ptr cb,
U32 tmrVal
)
#else
-PUBLIC Void rgSCHTmrStartTmr (cell, cb, tmrEvnt, tmrVal)
+Void rgSCHTmrStartTmr (cell, cb, tmrEvnt, tmrVal)
RgSchCellCb *cell;
Ptr cb;
S16 tmrEvnt;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHTmrStopTmr
+Void rgSCHTmrStopTmr
(
RgSchCellCb *cell,
S16 tmrEvnt,
Ptr cb
)
#else
-PUBLIC Void rgSCHTmrStopTmr (cell, tmrEvnt, cb)
+Void rgSCHTmrStopTmr (cell, tmrEvnt, cb)
RgSchCellCb *cell;
S16 tmrEvnt;
Ptr cb;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHTmrProcTmr
+Void rgSCHTmrProcTmr
(
Ptr cb,
S16 tmrEvnt
)
#else
-PUBLIC Void rgSCHTmrProcTmr (cb, tmrEvnt)
+Void rgSCHTmrProcTmr (cb, tmrEvnt)
Ptr cb;
S16 tmrEvnt;
#endif
#include "rg_sch_emtc_ext.x"
#endif
U8 rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb,U8 numTxAnt);
-PUBLIC S16 rgSCHDhm5gtfHqFdbkInd(RgSchUeCb *ue,RgSchCellCb *cell,CmLteTimingInfo timingInfo,TfuHqFdbk fdbk,RgSchErrInfo *err);
+S16 rgSCHDhm5gtfHqFdbkInd(RgSchUeCb *ue,RgSchCellCb *cell,CmLteTimingInfo timingInfo,TfuHqFdbk fdbk,RgSchErrInfo *err);
/* local defines */
#ifdef EMTC_ENABLE
EXTERN Bool rgSCHEmtcChkEmtcUe ARGS(
U16 rapId,
CmLteTimingInfo timingInfo
);
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
+S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
(
RgSchCellCb *cell,
U8 cqiReq,
U16 validIdx
));
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
+S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
));
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
+S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
));
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
+S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
Bool hqPres
));
-PUBLIC void schFillCrntTime(
+void schFillCrntTime(
SlotIndInfo slotInd,
Inst schInst);
#endif
/* local typedefs */
-PUBLIC U32 rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
-PUBLIC U32 rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
+U32 rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
+U32 rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
/* local externs */
/* rg006.201: [ccpu000111706, ccpu00112394]: Separated UL and DL TTI
#endif
#ifdef TFU_UPGRADE
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq ARGS
+S16 rgSCHTomFillOnlySrsRecpReq ARGS
((
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
Bool isDatPresOnSecCell
));
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
+S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
((
RgSchUeCb *ueCb
));
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz ARGS
+U8 rgSCHTomUtlFetchPcqiBitSz ARGS
((
RgSchUeCb *ueCb,
U8 numTxAnt,
U8 *ri
));
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
+U8 rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
((
RgSchUeCb *ueCb,
TfuCqiPucchMode21 *mode21Info,
U8 *ri
));
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion ARGS
+S16 rgSCHTomUtlMoveNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
));
#endif
#ifdef LTEMAC_SPS
-EXTERN PUBLIC Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
+EXTERN Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
#ifndef LTE_TDD
#ifdef UNUSED_FUNC
#ifdef TFU_UPGRADE
#endif/*LTE_ADV*/
#endif/*LTE_TDD*/
-PUBLIC U32 rgDlCqiRptCnt[16], rgTotDlCqiRpt;
+U32 rgDlCqiRptCnt[16], rgTotDlCqiRpt;
#ifdef RG_5GTF
U32 rgSch5gtfCqi2Mcs[15] =
/*Tables Derived from 3GPP TS 36.211 Section 5.5.3.3 */
/* Table 5.5.3.3-1 */
#ifndef LTE_TDD
-CONSTANT PUBLIC RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
+CONSTANT RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
{TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE},
{TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE},
};
#else
/* Table 5.5.3.3-2 */
-CONSTANT PUBLIC RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
+CONSTANT RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
{FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE},
{FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE},
{FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE}
};
#endif
-PUBLIC S8 rgSchCmnAper20n22DiffCqi[4] = {1, 2, 3, 4};
-PUBLIC S8 rgSchCmnAper30n31DiffCqi[4] = {0, 1, 2, -1};
+S8 rgSchCmnAper20n22DiffCqi[4] = {1, 2, 3, 4};
+S8 rgSchCmnAper30n31DiffCqi[4] = {0, 1, 2, -1};
#endif
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHGetDedPrmUe
+S16 rgSCHGetDedPrmUe
(
RgSchCellCb *cell,
U16 rapId,
RgSchUeCb **ue
)
#else
-PUBLIC S16 rgSCHGetDedPrmUe(cell, rapId, timingInfo, ue)
+S16 rgSCHGetDedPrmUe(cell, rapId, timingInfo, ue)
RgSchCellCb *cell;
U16 rapId;
CmLteTimingInfo timingInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomRaReqInd
+S16 rgSCHTomRaReqInd
(
RgSchCellCb *cell,
TfuRaReqIndInfo *raReqInd
)
#else
-PUBLIC S16 rgSCHTomRaReqInd(cell, raReqInd)
+S16 rgSCHTomRaReqInd(cell, raReqInd)
RgSchCellCb *cell;
TfuRaReqIndInfo *raReqInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUlCqiInd
+S16 rgSCHTomUlCqiInd
(
RgSchCellCb *cell,
TfuUlCqiIndInfo *ulCqiInd
)
#else
-PUBLIC S16 rgSCHTomUlCqiInd(cell, ulCqiInd)
+S16 rgSCHTomUlCqiInd(cell, ulCqiInd)
RgSchCellCb *cell;
TfuUlCqiIndInfo *ulCqiInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomPucchDeltaPwrInd
+S16 rgSCHTomPucchDeltaPwrInd
(
RgSchCellCb *cell,
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr
)
#else
-PUBLIC S16 rgSCHTomPucchDeltaPwrInd(cell, pucchDeltaPwr)
+S16 rgSCHTomPucchDeltaPwrInd(cell, pucchDeltaPwr)
RgSchCellCb *cell;
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomHarqAckInd
+S16 rgSCHTomHarqAckInd
(
RgSchCellCb *cell,
TfuHqIndInfo *harqAckInd
)
#else
-PUBLIC S16 rgSCHTomHarqAckInd(cell, harqAckInd)
+S16 rgSCHTomHarqAckInd(cell, harqAckInd)
RgSchCellCb *cell;
TfuHqIndInfo *harqAckInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomSrInd
+S16 rgSCHTomSrInd
(
RgSchCellCb *cell,
TfuSrIndInfo *srInd
)
#else
-PUBLIC S16 rgSCHTomSrInd(cell, srInd)
+S16 rgSCHTomSrInd(cell, srInd)
RgSchCellCb *cell;
TfuSrIndInfo *srInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomDoaInd
+S16 rgSCHTomDoaInd
(
RgSchCellCb *cell,
TfuDoaIndInfo *doaInd
)
#else
-PUBLIC S16 rgSCHTomDoaInd(cell, doaInd )
+S16 rgSCHTomDoaInd(cell, doaInd )
RgSchCellCb *cell;
TfuDoaIndInfo *doaInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomDlCqiInd
+S16 rgSCHTomDlCqiInd
(
RgSchCellCb *cell,
TfuDlCqiIndInfo *dlCqiInd
)
#else
-PUBLIC S16 rgSCHTomDlCqiInd(cell, dlCqiInd)
+S16 rgSCHTomDlCqiInd(cell, dlCqiInd)
RgSchCellCb *cell;
TfuDlCqiIndInfo *dlCqiInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomRawCqiInd
+S16 rgSCHTomRawCqiInd
(
RgSchCellCb *cell,
TfuRawCqiIndInfo *rawCqiInd
)
#else
-PUBLIC S16 rgSCHTomRawCqiInd(cell, rawCqiInd)
+S16 rgSCHTomRawCqiInd(cell, rawCqiInd)
RgSchCellCb *cell;
TfuRawCqiIndInfo *rawCqiInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomSrsInd
+S16 rgSCHTomSrsInd
(
RgSchCellCb *cell,
TfuSrsIndInfo *srsInd
)
#else
-PUBLIC S16 rgSCHTomSrsInd(cell, srsInd)
+S16 rgSCHTomSrsInd(cell, srsInd)
RgSchCellCb *cell;
TfuSrsIndInfo *srsInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomCrcInd
+S16 rgSCHTomCrcInd
(
RgSchCellCb *cell,
TfuCrcIndInfo *crcInd
)
#else
-PUBLIC S16 rgSCHTomCrcInd(cell, crcInd)
+S16 rgSCHTomCrcInd(cell, crcInd)
RgSchCellCb *cell;
TfuCrcIndInfo *crcInd;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomTimingAdvInd
+S16 rgSCHTomTimingAdvInd
(
RgSchCellCb *cell,
TfuTimingAdvIndInfo *timingAdvInd
)
#else
-PUBLIC S16 rgSCHTomTimingAdvInd(cell, timingAdvInd)
+S16 rgSCHTomTimingAdvInd(cell, timingAdvInd)
RgSchCellCb *cell;
TfuTimingAdvIndInfo *timingAdvInd;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHTomTtiInd
+Void rgSCHTomTtiInd
(
SlotIndInfo *slotInd,
Inst schInst
)
#else
-PUBLIC Void rgSCHTomTtiInd(slotInd, schInst)
+Void rgSCHTomTtiInd(slotInd, schInst)
SlotIndInfo *slotInd;
Inst schInst;
#endif
*/
#ifdef TFU_UPGRADE
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo
+S16 rgSCHTomUtlFillHqFdbkInfo
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, validIdx, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
+S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, validIdx, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
U16 validIdx;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo
+S16 rgSCHTomUtlFillHqFdbkInfo
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
+S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
RgSchDlHqProcCb *hqCb;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo
+S16 rgSCHTomUtlFillRiBitWidthInfo
(
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo(ueCb)
+S16 rgSCHTomUtlFillRiBitWidthInfo(ueCb)
RgSchUeCb *ueCb;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz
+U8 rgSCHTomUtlFetchPcqiBitSz
(
RgSchUeCb *ueCb,
U8 numTxAnt,
U8 *ri
)
#else
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
+U8 rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
RgSchUeCb *ueCb;
U8 numTxAnt;
U8 *ri;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlPcqiSbCalcBpIdx
+S16 rgSCHTomUtlPcqiSbCalcBpIdx
(
CmLteTimingInfo crntTimInfo,
RgSchUeCb *ueCb,
RgSchUePCqiCb *cqiCb
)
#else
-PUBLIC S16 rgSCHTomUtlPcqiSbCalcBpIdx(crntTimInfo, ueCb, cqiCb)
+S16 rgSCHTomUtlPcqiSbCalcBpIdx(crntTimInfo, ueCb, cqiCb)
CmLteTimingInfo crntTimInfo;
RgSchUeCb *ueCb;
RgSchUePCqiCb *cqiCb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion
+S16 rgSCHTomUtlMoveNxtOccasion
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion(cell, ue, validIdx)
+S16 rgSCHTomUtlMoveNxtOccasion(cell, ue, validIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
U16 validIdx;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHTomPrepareAcqiRecp
+Void rgSCHTomPrepareAcqiRecp
(
RgSchUeCb *ueCb,
RgSchCellCb *cell,
U8 ccIdx
)
#else
-PUBLIC Void rgSCHTomPrepareAcqiRecp(ueCb, cell, cqiRecpReqInfo, ccIdx)
+ Void rgSCHTomPrepareAcqiRecp(ueCb, cell, cqiRecpReqInfo, ccIdx)
RgSchUeCb *ueCb;
RgSchCellCb *cell;
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq
+S16 rgSCHTomUtlFillDatAperRecpReq
(
RgSchCellCb *cell,
U8 cqiReq,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq(cell, cqiReq, alloc, datRecpInfo, timeInfo, hqPres, validIdx)
+S16 rgSCHTomUtlFillDatAperRecpReq(cell, cqiReq, alloc, datRecpInfo, timeInfo, hqPres, validIdx)
RgSchCellCb *cell;
U8 cqiReq;
RgSchUlAlloc *alloc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq
+S16 rgSCHTomUtlFillDatPriRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq(cell, alloc, datRecpInfo, timeInfo,
+S16 rgSCHTomUtlFillDatPriRecpReq(cell, alloc, datRecpInfo, timeInfo,
hqPres, validIdx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq
+S16 rgSCHTomUtlFillDatPCqiRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq(cell, alloc, datRecpInfo,
+S16 rgSCHTomUtlFillDatPCqiRecpReq(cell, alloc, datRecpInfo,
timeInfo, hqPres, validIdx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq
+S16 rgSCHTomUtlFillDatSrsRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
Bool hqPres
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq(cell, alloc, datRecpInfo, timeInfo,
+S16 rgSCHTomUtlFillDatSrsRecpReq(cell, alloc, datRecpInfo, timeInfo,
hqPres)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq
+S16 rgSCHTomFillOnlySrsRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
TfuUeRecpReqInfo *datRecpInfo
)
#else
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq(cell, alloc, datRecpInfo)
+S16 rgSCHTomFillOnlySrsRecpReq(cell, alloc, datRecpInfo)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
EXTERN U32 gUlCrcPassCounter;
EXTERN U32 gUlCrcFailCounter;*/
#endif
-PUBLIC U8 rgRvIdxTable[] = {0, 3, 1, 2}; /* This gives rvIdx for a given rv */
-PUBLIC U8 rgRvTable[] = {0, 2, 3 ,1}; /* This gives rv for a given rvIdx */
+U8 rgRvIdxTable[] = {0, 3, 1, 2}; /* This gives rvIdx for a given rv */
+U8 rgRvTable[] = {0, 2, 3 ,1}; /* This gives rv for a given rvIdx */
#ifdef EMTC_ENABLE
-PUBLIC Void rgSCHCmnEmtcHdlHarqProcFail
+Void rgSCHCmnEmtcHdlHarqProcFail
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchUlHqProcCb *hqProc,
CmLteTimingInfo frm
);
-PUBLIC Void rgSCHEmtcInitUlUeHqEnt
+Void rgSCHEmtcInitUlUeHqEnt
(
RgSchCellCb *cell,
RgrUeCfg *ueCfg,
**/
#ifndef MAC_SCH_STATS
#ifdef ANSI
-PUBLIC Void rgSCHUhmProcDatInd
+Void rgSCHUhmProcDatInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo frm
)
#else
-PUBLIC Void rgSCHUhmProcDatInd(cell, ue, frm)
+Void rgSCHUhmProcDatInd(cell, ue, frm)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
#endif
#else /* MAC_SCH_STATS */
#ifdef ANSI
-PUBLIC Void rgSCHUhmProcDatInd
+Void rgSCHUhmProcDatInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 cqi
)
#else
-PUBLIC Void rgSCHUhmProcDatInd(cell, ue, frm, cqi)
+Void rgSCHUhmProcDatInd(cell, ue, frm, cqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmProcMsg3DatInd
+Void rgSCHUhmProcMsg3DatInd
(
RgSchUlHqProcCb *hqProc
)
#else
-PUBLIC Void rgSCHUhmProcMsg3DatInd(hqProc)
+Void rgSCHUhmProcMsg3DatInd(hqProc)
RgSchUlHqProcCb *hqProc;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmProcMsg3Failure
+Void rgSCHUhmProcMsg3Failure
(
RgSchUlHqProcCb *hqProc
)
#else
-PUBLIC Void rgSCHUhmProcMsg3Failure(hqProc)
+Void rgSCHUhmProcMsg3Failure(hqProc)
RgSchUlHqProcCb *hqProc;
#endif
{
**/
#ifndef MAC_SCH_STATS
#ifdef ANSI
-PUBLIC Void rgSCHUhmProcHqFailure
+Void rgSCHUhmProcHqFailure
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TknU8 rv
)
#else
-PUBLIC Void rgSCHUhmProcHqFailure(cell, ue, frm, rv)
+Void rgSCHUhmProcHqFailure(cell, ue, frm, rv)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
#endif
#else /* MAC_SCH_STATS */
#ifdef ANSI
-PUBLIC Void rgSCHUhmProcHqFailure
+Void rgSCHUhmProcHqFailure
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 cqi
)
#else
-PUBLIC Void rgSCHUhmProcHqFailure(cell, ue, frm, rv, cqi)
+Void rgSCHUhmProcHqFailure(cell, ue, frm, rv, cqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
* -# NULL
**/
#ifdef ANSI
-PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlHqProc
+RgSchUlHqProcCb* rgSCHUhmGetUlHqProc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 idx
)
#else
-PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlHqProc(cell, ue, idx)
+RgSchUlHqProcCb* rgSCHUhmGetUlHqProc(cell, ue, idx)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 idx;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmNewTx
+Void rgSCHUhmNewTx
(
RgSchUlHqProcCb *hqProc,
U8 maxHqRetx,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUhmNewTx(hqProc, maxHqRetx, alloc)
+Void rgSCHUhmNewTx(hqProc, maxHqRetx, alloc)
RgSchUlHqProcCb *hqProc;
U8 maxHqRetx;
RgSchUlAlloc *alloc;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmFreeProc
+Void rgSCHUhmFreeProc
(
RgSchUlHqProcCb *hqProc,
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUhmFreeProc(hqProc, cell)
+Void rgSCHUhmFreeProc(hqProc, cell)
RgSchUlHqProcCb *hqProc;
RgSchCellCb *cell;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmRetx
+Void rgSCHUhmRetx
(
RgSchUlHqProcCb *hqProc,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUhmRetx(hqProc, alloc)
+Void rgSCHUhmRetx(hqProc, alloc)
RgSchUlHqProcCb *hqProc;
RgSchUlAlloc *alloc;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmRgrUeCfg
+Void rgSCHUhmRgrUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeCfg *ueCfg
)
#else
-PUBLIC Void rgSCHUhmRgrUeCfg(cellCb, ueCb, ueCfg)
+Void rgSCHUhmRgrUeCfg(cellCb, ueCb, ueCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeCfg *ueCfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmRgrUeRecfg
+Void rgSCHUhmRgrUeRecfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeRecfg *ueRecfg
)
#else
-PUBLIC Void rgSCHUhmRgrUeRecfg(cellCb, ueCb, ueRecfg)
+Void rgSCHUhmRgrUeRecfg(cellCb, ueCb, ueRecfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeRecfg *ueRecfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUhmFreeUe
+Void rgSCHUhmFreeUe
(
RgSchCellCb *cellCb,
RgUeUlHqCb *hqEnt
)
#else
-PUBLIC Void rgSCHUhmFreeUe(cellCb, hqEnt)
+Void rgSCHUhmFreeUe(cellCb, hqEnt)
RgSchCellCb *cellCb;
RgUeUlHqCb *hqEnt;
#endif
* @return Void
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUhmAppendPhich
+S16 rgSCHUhmAppendPhich
(
RgSchCellCb *cellCb,
CmLteTimingInfo frm,
U8 idx
)
#else
-PUBLIC S16 rgSCHUhmAppendPhich (cellCb, frm, idx)
+S16 rgSCHUhmAppendPhich (cellCb, frm, idx)
RgSchCellCb *cellCb;
CmLteTimingInfo frm;
U8 idx;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUhmHqEntInit
+S16 rgSCHUhmHqEntInit
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHUhmHqEntInit(cellCb, ueCb)
+S16 rgSCHUhmHqEntInit(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUhmGetAvlHqProc
+S16 rgSCHUhmGetAvlHqProc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchUlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHUhmGetAvlHqProc (cell, ue, hqP)
+S16 rgSCHUhmGetAvlHqProc (cell, ue, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchUlHqProcCb **hqP;
* -# NULL
**/
#ifdef ANSI
-PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime
+RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo frm
)
#else
-PUBLIC RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime(cell, ue, frm)
+RgSchUlHqProcCb* rgSCHUhmGetUlProcByTime(cell, ue, frm)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
EXTERN U32 rgSchCmnBetaCqiOffstTbl[16];
EXTERN U32 rgSchCmnBetaRiOffstTbl[16];
EXTERN RgSchdApis rgSchCmnApis;
-EXTERN PUBLIC S16 RgUiRgmSendPrbRprtInd ARGS((
+EXTERN S16 RgUiRgmSendPrbRprtInd ARGS((
Pst* pst,
SuId suId,
RgmPrbRprtInd *prbRprtInd
));
-EXTERN PUBLIC S16 RgUiRgmSendTmModeChangeInd ARGS((
+EXTERN S16 RgUiRgmSendTmModeChangeInd ARGS((
Pst* pst,
SuId suId,
RgmTransModeInd *txModeChngInd
));
#ifdef EMTC_ENABLE
-EXTERN PUBLIC S16 rgSCHEmtcUtlGetSfAlloc ARGS((
+EXTERN S16 rgSCHEmtcUtlGetSfAlloc ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC S16 rgSCHEmtcUtlPutSfAlloc ARGS((
+EXTERN S16 rgSCHEmtcUtlPutSfAlloc ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC Void rgSCHEmtcUtlUpdUeDciSize ARGS((
+EXTERN Void rgSCHEmtcUtlUpdUeDciSize ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb
));
-EXTERN PUBLIC Void rgSCHEmtcGetDciFrmt61ASize ARGS((
+EXTERN Void rgSCHEmtcGetDciFrmt61ASize ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC Void rgSCHEmtcGetDciFrmt60ASize ARGS((
+EXTERN Void rgSCHEmtcGetDciFrmt60ASize ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC S16 rgSCHEmtcUtlFillPdschDciInfo ARGS((
+EXTERN S16 rgSCHEmtcUtlFillPdschDciInfo ARGS((
TfuPdschDciInfo *pdsch,
TfuDciInfo *pdcchDci
));
-EXTERN PUBLIC Void rgSCHEmtcUtlRlsRnti ARGS((
+EXTERN Void rgSCHEmtcUtlRlsRnti ARGS((
RgSchCellCb *cell,
RgSchRntiLnk *rntiLnk,
U8 *isLegacy
));
-EXTERN PUBLIC S16 rgSCHEmtcPdcchAlloc ARGS((
+EXTERN S16 rgSCHEmtcPdcchAlloc ARGS((
RgSchCellCb *cell,
RgSchPdcch *pdcch
));
-EXTERN PUBLIC Void rgSCHEmtcPdcchFree ARGS((
+EXTERN Void rgSCHEmtcPdcchFree ARGS((
RgSchCellCb *cell,
RgSchPdcch *pdcch
));
#endif
/* Functions specific to TM1/TM2/TM6/TM7 for PRB calculation*/
-PUBLIC Void rgSchUtlDlCalc1CwPrb ARGS(( RgSchCellCb *cell,
+Void rgSchUtlDlCalc1CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
U32 bo,
U32 *prbReqrd));
/* Functions specific to TM3/TM4 for PRB calculation*/
-PUBLIC Void rgSchUtlDlCalc2CwPrb ARGS(( RgSchCellCb *cell,
+Void rgSchUtlDlCalc2CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
U32 bo,
U32 *prbReqrd));
#ifdef LTE_ADV
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb ARGS(( Inst inst,
+RgSchCellCb* rgSchUtlGetCellCb ARGS(( Inst inst,
U16 cellId
));
#endif
*
*/
#ifdef ANSI
-PUBLIC F64 rgSCHUtlPower
+F64 rgSCHUtlPower
(
F64 x,
F64 n
)
#else
-PUBLIC F64 rgSCHUtlPower(x, n)
+F64 rgSCHUtlPower(x, n)
F64 x;
F64 n;
#endif
*
*/
#ifdef ANSI
-PUBLIC U32 rgSCHUtlParse
+U32 rgSCHUtlParse
(
U8 *buff,
U8 startPos,
U8 buffSize
)
#else
-PUBLIC U32 rgSCHUtlParse(buff, startPos, endPos, buffSize)
+U32 rgSCHUtlParse(buff, startPos, endPos, buffSize)
U8 *buff;
U8 startPos;
U8 endPos;
*
*/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlFindDist
+U8 rgSCHUtlFindDist
(
U16 crntTime,
U16 tempIdx
)
#else
-PUBLIC U8 rgSCHUtlFindDist(crntTime, tempIdx)
+U8 rgSCHUtlFindDist(crntTime, tempIdx)
U16 crntTime;
U16 tempIdx;
#endif
*
**/
#ifdef ANSI
-PUBLIC Bool rgSCHUtlPdcchAvail
+Bool rgSCHUtlPdcchAvail
(
RgSchCellCb *cell,
RgSchPdcchInfo *pdcchInfo,
RgSchPdcch **pdcch
)
#else
-PUBLIC Bool rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, pdcch)
+Bool rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, pdcch)
RgSchCellCb *cell;
RgSchPdcchInfo *pdcchInfo;
CmLteAggrLvl aggrLvl;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPdcchPut
+Void rgSCHUtlPdcchPut
(
RgSchCellCb *cell,
RgSchPdcchInfo *pdcchInfo,
RgSchPdcch *pdcch
)
#else
-PUBLIC Void rgSCHUtlPdcchPut(cell, pdcchInfo, pdcch)
+Void rgSCHUtlPdcchPut(cell, pdcchInfo, pdcch)
RgSchCellCb *cell;
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPdcchInit
+Void rgSCHUtlPdcchInit
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
U16 nCce
)
#else
-PUBLIC Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
+Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
U16 nCce;
*
**/
#ifdef ANSI
-PUBLIC Void rgSchSFRTotalPoolFree
+Void rgSchSFRTotalPoolFree
(
RgSchSFRTotalPoolInfo *sfrTotalPoolInfo,
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
+Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
RgSchSFRTotalPoolInfo *sfrTotalPoolInfo;
RgSchCellCb *cell;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchSFRTotalPoolInit
+S16 rgSchSFRTotalPoolInit
(
RgSchCellCb *cell,
RgSchDlSf *sf
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchDSFRRntpInfoInit
+S16 rgSchDSFRRntpInfoInit
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchDSFRRntpInfoFree
+S16 rgSchDSFRRntpInfoFree
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
**/
#ifdef LTE_TDD
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddPhich
+S16 rgSCHUtlAddPhich
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
U8 iPhich
)
#else
-PUBLIC S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
+S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
RgSchCellCb *cell;
CmLteTimingInfo frm;
U8 hqFeedBack;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddPhich
+S16 rgSCHUtlAddPhich
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
Bool isForMsg3
)
#else
-PUBLIC S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
+S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
RgSchCellCb *cell;
CmLteTimingInfo frm;
U8 hqFeedBack;
*
**/
#ifdef ANSI
-PUBLIC RgSchDlSf* rgSCHUtlSubFrmGet
+RgSchDlSf* rgSCHUtlSubFrmGet
(
RgSchCellCb *cell,
CmLteTimingInfo frm
)
#else
-PUBLIC RgSchDlSf* rgSCHUtlSubFrmGet(cell, frm)
+RgSchDlSf* rgSCHUtlSubFrmGet(cell, frm)
RgSchCellCb *cell;
CmLteTimingInfo frm;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSubFrmPut
+Void rgSCHUtlSubFrmPut
(
RgSchCellCb *cell,
RgSchDlSf *sf
)
#else
-PUBLIC Void rgSCHUtlSubFrmPut(cell, sf)
+Void rgSCHUtlSubFrmPut(cell, sf)
RgSchCellCb *cell;
RgSchDlSf *sf;
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlLog32bitNbase2
+U8 rgSCHUtlLog32bitNbase2
(
U32 n
)
#else
-PUBLIC U8 rgSCHUtlLog32bitNbase2(n)
+U8 rgSCHUtlLog32bitNbase2(n)
U32 n;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlRelPdcchFbk
+Void rgSCHUtlDlRelPdcchFbk
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 isAck
)
#else
-PUBLIC Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
+Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 isAck;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlProcAck
+Void rgSCHUtlDlProcAck
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHUtlDlProcAck(cell, hqP)
+Void rgSCHUtlDlProcAck(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrntiCE
+Void rgSCHUtlHdlCrntiCE
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlHdlCrntiCE(cell, ue)
+Void rgSCHUtlHdlCrntiCE(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlCalcNCce
+U8 rgSCHUtlCalcNCce
(
U8 bw,
RgrPhichNg ng,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
+U8 rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
U8 bw;
RgrPhichNg ng;
U8 cfi;
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlCalcNCce
+U8 rgSCHUtlCalcNCce
(
U8 bw,
RgrPhichNg ng,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
+U8 rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
U8 bw;
RgrPhichNg ng;
U8 cfi;
**/
#ifdef LTE_TDD
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetPhichInfo
+S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
U8 *rbStartRef,
U8 *iPhich
)
#else
-PUBLIC S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
+S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
RgSchUlHqProcCb *hqProc;
U8 *rbStartRef;
U8 *nDmrsRef;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetPhichInfo
+S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
U8 *rbStartRef,
U8 *nDmrsRef
)
#else
-PUBLIC S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
+S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
RgSchUlHqProcCb *hqProc;
U8 *rbStartRef;
U8 *nDmrsRef;
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocRcptInfo
+S16 rgSCHUtlAllocRcptInfo
(
RgSchUlAlloc *alloc,
CmLteRnti *rnti,
U8 *hqPId
)
#else
-PUBLIC S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
+S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
rvRef, size, modType, isRtx, nDmrs, ndi,
hqPId)
RgSchUlAlloc *alloc;
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocRcptInfo
+S16 rgSCHUtlAllocRcptInfo
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
TfuUeUlSchRecpInfo *recpReq
)
#else
-PUBLIC S16 rgSCHUtlAllocRcptInfo(cell, alloc, timeInfo, recpReq)
+S16 rgSCHUtlAllocRcptInfo(cell, alloc, timeInfo, recpReq)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
CmLteTimingInfo *timeInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPrachCfgInit
+Void rgSCHUtlPrachCfgInit
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PUBLIC Void rgSCHUtlPrachCfgInit(cell, cellCfg)
+Void rgSCHUtlPrachCfgInit(cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellCfg
+S16 rgSCHUtlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
+S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *errInfo;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellCfg
+S16 rgSCHUtlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
+S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *errInfo;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellRecfg
+S16 rgSCHUtlRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrCellRecfg(cell, recfg, err)
+S16 rgSCHUtlRgrCellRecfg(cell, recfg, err)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
RgSchErrInfo *err;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFreeCell
+S16 rgSCHUtlFreeCell
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlFreeCell(cell)
+S16 rgSCHUtlFreeCell(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeCfg
+S16 rgSCHUtlRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrUeCfg(cell, ue, cfg, err)
+S16 rgSCHUtlRgrUeCfg(cell, ue, cfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *cfg;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcCfg
+S16 rgSCHUtlRgrLcCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrLcCfg(cell, ue, dlLc, cfg, errInfo)
+S16 rgSCHUtlRgrLcCfg(cell, ue, dlLc, cfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcRecfg
+S16 rgSCHUtlRgrLcRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrLcRecfg(cell, ue, dlLc, recfg, err)
+S16 rgSCHUtlRgrLcRecfg(cell, ue, dlLc, recfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcDel
+S16 rgSCHUtlRgrLcDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
+S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcgCfg
+S16 rgSCHUtlRgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrLcgCfg(cell, ue, cfg, errInfo)
+S16 rgSCHUtlRgrLcgCfg(cell, ue, cfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgCfg *cfg;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcgRecfg
+S16 rgSCHUtlRgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrLcgRecfg(cell, ue, recfg, err)
+S16 rgSCHUtlRgrLcgRecfg(cell, ue, recfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgRecfg *recfg;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRgrLcgDel
+Void rgSCHUtlRgrLcgDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
+Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDoaInd
+Void rgSCHUtlDoaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDoaRpt *doaRpt
)
#else
-PUBLIC Void rgSCHUtlDoaInd(cell, ue, doaRpt)
+Void rgSCHUtlDoaInd(cell, ue, doaRpt)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDoaRpt *doaRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlCqiInd
+Void rgSCHUtlDlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlDlCqiInd(cell, ue, dlCqiRpt, timingInfo)
+Void rgSCHUtlDlCqiInd(cell, ue, dlCqiRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiRpt *dlCqiRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSrsInd
+Void rgSCHUtlSrsInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlSrsInd(cell, ue, srsRpt, timingInfo)
+Void rgSCHUtlSrsInd(cell, ue, srsRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuSrsRpt *srsRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlTARpt
+Void rgSCHUtlDlTARpt
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlDlTARpt(cell, ue)
+Void rgSCHUtlDlTARpt(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlRlsSubFrm
+Void rgSCHUtlDlRlsSubFrm
(
RgSchCellCb *cell,
CmLteTimingInfo subFrm
)
#else
-PUBLIC Void rgSCHUtlDlRlsSubFrm(cell, subFrm)
+Void rgSCHUtlDlRlsSubFrm(cell, subFrm)
RgSchCellCb *cell;
CmLteTimingInfo subFrm;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdACqiTrigWt
+Void rgSCHUtlUpdACqiTrigWt
(
RgSchUeCb *ue,
RgSchUeCellInfo *cellInfo,
U8 isAck
)
#else
-PUBLIC Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
+Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
RgSchUeCb *ue;
RgSchUeCellInfo *cellInfo;
U8 isAck;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlUlTransInd
+Void rgSCHUtlHdlUlTransInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlUlTransInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlUlTransInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrcInd
+Void rgSCHUtlHdlCrcInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlCrcInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlCrcInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrcFailInd
+Void rgSCHUtlHdlCrcFailInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlCrcFailInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlCrcFailInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlProcAddToRetx
+Void rgSCHUtlDlProcAddToRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHUtlDlProcAddToRetx(cell, hqP)
+Void rgSCHUtlDlProcAddToRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlHqPTbAddToTx
+Void rgSCHUtlDlHqPTbAddToTx
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
U8 tbIdx
)
#else
-PUBLIC Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
+Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
U8 tbIdx;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlHqPTbRmvFrmTx
+Void rgSCHUtlDlHqPTbRmvFrmTx
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
Bool isRepeting
)
#else
-PUBLIC Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
+Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
U8 tbIdx;
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb
+RgSchCellCb* rgSchUtlGetCellCb
(
Inst inst,
U16 cellId
)
#else
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
+RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
Inst inst;
U16 cellId;
#endif
* @return U8 servCellIdx
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlGetServCellIdx
+U8 rgSchUtlGetServCellIdx
(
Inst inst,
U16 cellId,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSchUtlGetServCellIdx(inst,cellId,ue)
+U8 rgSchUtlGetServCellIdx(inst,cellId,ue)
Inst inst;
U16 cellId;
RgSchUeCb *ue;
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC S16 rgSchUtlVldtCellId
+S16 rgSchUtlVldtCellId
(
Inst inst,
U16 cellId
)
#else
-PUBLIC S16 rgSchUtlVldtCellId(inst, cellId)
+S16 rgSchUtlVldtCellId(inst, cellId)
Inst inst;
U16 cellId;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeRecfg
+S16 rgSCHUtlRgrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeDlLc
+Void rgSCHUtlFreeDlLc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHUtlFreeDlLc(cell, ue, svc)
+Void rgSCHUtlFreeDlLc(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeUe
+Void rgSCHUtlFreeUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlFreeUe(cell, ue)
+Void rgSCHUtlFreeUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlDedBoUpd
+Void rgSCHUtlDlDedBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *lc
)
#else
-PUBLIC Void rgSCHUtlDlDedBoUpd(cell, ue, lc)
+Void rgSCHUtlDlDedBoUpd(cell, ue, lc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *lc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRecMsg3Alloc
+Void rgSCHUtlRecMsg3Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchRaCb *raCb
)
#else
-PUBLIC Void rgSCHUtlRecMsg3Alloc(cell, ue, raCb)
+Void rgSCHUtlRecMsg3Alloc(cell, ue, raCb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchRaCb *raCb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdUlHqProc
+S16 rgSCHUtlUpdUlHqProc
(
RgSchCellCb *cell,
RgSchUlHqProcCb *curProc,
RgSchUlHqProcCb *oldProc
)
#else
-PUBLIC S16 rgSCHUtlUpdUlHqProc(cell, curProc, oldProc)
+S16 rgSCHUtlUpdUlHqProc(cell, curProc, oldProc)
RgSchCellCb *cell;
RgSchUlHqProcCb *curProc;
RgSchUlHqProcCb *oldProc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlContResUlGrant
+S16 rgSCHUtlContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlContResUlGrant(cell, ue, err)
+S16 rgSCHUtlContResUlGrant(cell, ue, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSrRcvd
+S16 rgSCHUtlSrRcvd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlSrRcvd(cell, ue, frm, err)
+S16 rgSCHUtlSrRcvd(cell, ue, frm, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrShort
+Void rgSCHUtlUpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
+Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrTrunc
+Void rgSCHUtlUpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
+Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrLong
+Void rgSCHUtlUpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
+Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 bsr0;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdExtPhr
+S16 rgSCHUtlUpdExtPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdExtPhr(cell, ue, extPhr, err)
+S16 rgSCHUtlUpdExtPhr(cell, ue, extPhr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfExtPhrCEInfo * extPhr;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdPhr
+S16 rgSCHUtlUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
+S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 phr;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlCqiInd
+Void rgSCHUtlUlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo
)
#else
-PUBLIC Void rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo)
+Void rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuUlCqiRpt *ulCqiInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPucchDeltaPwrInd
+Void rgSCHUtlPucchDeltaPwrInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
S8 delta
)
#else
-PUBLIC Void rgSCHUtlPucchDeltaPwrInd(cell, ue, delta)
+Void rgSCHUtlPucchDeltaPwrInd(cell, ue, delta)
RgSchCellCb *cell;
RgSchUeCb *ue;
S8 delta;
* @return S16
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUeReset
+Void rgSCHUtlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlUeReset(cell, ue)
+Void rgSCHUtlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHqProcForUe
+Void rgSCHUtlUlHqProcForUe
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
RgSchUlHqProcCb **procRef
)
#else
-PUBLIC Void rgSCHUtlUlHqProcForUe(cell, frm, ue, procRef)
+Void rgSCHUtlUlHqProcForUe(cell, frm, ue, procRef)
RgSchCellCb *cell;
CmLteTimingInfo frm;
RgSchUeCb *ue;
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstRcptnReq
+RgSchUlAlloc *rgSCHUtlFirstRcptnReq
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstRcptnReq(cell)
+RgSchUlAlloc *rgSCHUtlFirstRcptnReq(cell)
RgSchCellCb *cell;
#endif
{
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlNextRcptnReq
+RgSchUlAlloc *rgSCHUtlNextRcptnReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlNextRcptnReq(cell, alloc)
+RgSchUlAlloc *rgSCHUtlNextRcptnReq(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
+RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
(
RgSchCellCb *cell,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
+RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
U8 idx;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc
+RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
+RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
U8 idx;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuBndReq
+S16 rgSCHUtlTfuBndReq
(
Inst instId,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 rgSCHUtlTfuBndReq(instId, suId, spId)
+S16 rgSCHUtlTfuBndReq(instId, suId, spId)
Inst instId;
SuId suId;
SpId spId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuUBndReq
+S16 rgSCHUtlTfuUBndReq
(
Inst inst,
RgSchLowSapCfgInfo sapCfg,
Reason reason
)
#else
-PUBLIC S16 rgSCHUtlTfuUBndReq(inst, sapCfg, reason)
+S16 rgSCHUtlTfuUBndReq(inst, sapCfg, reason)
Inst inst;
RgSchLowSapCfgInfo sapCfg;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlResetSfAlloc
+S16 rgSCHUtlResetSfAlloc
(
RgInfSfAlloc *sfAlloc,
Bool resetCmnLcInfo,
Bool restAlloc
)
#else
-PUBLIC S16 rgSCHUtlResetSfAlloc(sfAlloc,resetCmnLcInfo,restAlloc)
+S16 rgSCHUtlResetSfAlloc(sfAlloc,resetCmnLcInfo,restAlloc)
RgInfSfAlloc *sfAlloc;
Bool resetCmnLcInfo;
Bool restAlloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetRlsHqAlloc
+S16 rgSCHUtlGetRlsHqAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlGetRlsHqAlloc(cell)
+S16 rgSCHUtlGetRlsHqAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlPutRlsHqAlloc
+S16 rgSCHUtlPutRlsHqAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlPutRlsHqAlloc(cell)
+S16 rgSCHUtlPutRlsHqAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetSfAlloc
+S16 rgSCHUtlGetSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlGetSfAlloc(cell)
+S16 rgSCHUtlGetSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlPutSfAlloc
+S16 rgSCHUtlPutSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlPutSfAlloc(cell)
+S16 rgSCHUtlPutSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocSBuf
+S16 rgSCHUtlAllocSBuf
(
Inst inst, /* Instance of the invoking scheduler */
Data **pData, /* Pointer of the data to be returned */
Size size /* size */
)
#else
-PUBLIC S16 rgSCHUtlAllocSBuf(inst, pData, size)
+S16 rgSCHUtlAllocSBuf(inst, pData, size)
Inst inst; /* Instance of the invoking scheduler */
Data **pData; /* Pointer of the data to be returned */
Size size; /* size */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeSBuf
+Void rgSCHUtlFreeSBuf
(
Inst inst, /* Instance of the invoking scheduler */
Data **data, /* pointer to data */
Size size /* size */
)
#else
-PUBLIC Void rgSCHUtlFreeSBuf(inst, data, size)
+Void rgSCHUtlFreeSBuf(inst, data, size)
Inst inst; /* Instance of the invoking scheduler */
Data **data; /* pointer to data */
Size size; /* size */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeWarningSiSeg
+Void rgSCHUtlFreeWarningSiSeg
(
Region reg,
Pool pool,
CmLListCp *siPduLst
)
#else
-PUBLIC Void rgSCHUtlFreeWarningSiSeg(reg, pool, siPduLst)
+Void rgSCHUtlFreeWarningSiSeg(reg, pool, siPduLst)
Region reg;
Pool pool;
CmLListCp *siPduLst;
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeWarningSiPdu
+Void rgSCHUtlFreeWarningSiPdu
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlFreeWarningSiPdu(cell)
+Void rgSCHUtlFreeWarningSiPdu(cell)
RgSchCellCb *cell;
#endif
{
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Buffer *rgSCHUtlGetWarningSiPdu
+Buffer *rgSCHUtlGetWarningSiPdu
(
RgSchCellCb *cell
)
#else
-PUBLIC Buffer *rgSCHUtlGetWarningSiPdu(cell)
+Buffer *rgSCHUtlGetWarningSiPdu(cell)
RgSchCellCb *cell;
#endif
{
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetMcsAndNPrb
+S16 rgSCHUtlGetMcsAndNPrb
(
RgSchCellCb *cell,
U8 *nPrb,
MsgLen *msgLen
)
#else
-PUBLIC S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
+S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
U8 *nPrb;
U8 *mcs;
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlCalMcsAndNPrb
+S16 rgSCHUtlCalMcsAndNPrb
(
RgSchCellCb *cell,
U8 cfgType,
U8 siId
)
#else
-PUBLIC S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
+S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
U8 cfgType;
MsgLen msgLen;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFillDgnParams
+Void rgSCHUtlFillDgnParams
(
Inst inst,
RgUstaDgn *dgn,
U8 dgnType
)
#else
-PUBLIC Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
+Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
Inst inst;
RgUstaDgn *dgn;
U8 dgnType;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetPstToLyr
+Void rgSCHUtlGetPstToLyr
(
Pst *pst,
RgSchCb *schCb,
Inst macInst
)
#else
-PUBLIC Void rgSCHUtlGetPstToLyr (pst, schCb, macInst)
+Void rgSCHUtlGetPstToLyr (pst, schCb, macInst)
Pst *pst;
RgSchCb *schCb;
Inst macInst;
pst->dstProcId = schCb->rgSchInit.procId;
pst->dstInst = macInst;
- pst->dstEnt = ENTRG;
- pst->srcEnt = ENTRG;
+ pst->dstEnt = ENTMAC;
+ pst->srcEnt = ENTMAC;
pst->selector = 0;
pst->prior = PRIOR0;
pst->intfVer = 0;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillRgInfCmnLcInfo
+S16 rgSCHUtlFillRgInfCmnLcInfo
(
RgSchDlSf *sf,
RgInfSfAlloc *sfAlloc,
Bool sendInd
)
#else
-PUBLIC S16 rgSCHUtlFillRgInfCmnLcInfo(sf, sfAlloc, lcId, sendInd)
+S16 rgSCHUtlFillRgInfCmnLcInfo(sf, sfAlloc, lcId, sendInd)
RgSchDlSf *sf;
RgInfSfAlloc *sfAlloc;
CmLteLcId lcId;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillRgInfRarInfo
+S16 rgSCHUtlFillRgInfRarInfo
(
RgSchDlSf *sf,
RgInfSfAlloc *sfAlloc,
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlFillRgInfRarInfo(sf, sfAlloc, cell)
+S16 rgSCHUtlFillRgInfRarInfo(sf, sfAlloc, cell)
RgSchDlSf *sf;
RgInfSfAlloc *sfAlloc;
RgSchCellCb *cell;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillPdschDciInfo
+S16 rgSCHUtlFillPdschDciInfo
(
TfuPdschDciInfo *pdsch,
TfuDciInfo *pdcchDci
)
#else
-PUBLIC S16 rgSCHUtlFillPdschDciInfo(pdsch, pdcchDci)
+S16 rgSCHUtlFillPdschDciInfo(pdsch, pdcchDci)
TfuPdschDciInfo *pdsch;
TfuDciInfo *pdcchDci;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSchDSFRPwrCheck
+Void rgSchDSFRPwrCheck
(
RgSchDlSf *sf,
Bool *isAllUePwrHigh
**********************************************************/
/* CA dev Start */
#ifdef ANSI
-PUBLIC Void rgSCHUtlFillRgInfUeInfo
+Void rgSCHUtlFillRgInfUeInfo
(
RgSchDlSf *sf,
RgSchCellCb *cell,
CmLListCp *ulInActvLst
)
#else
-PUBLIC Void rgSCHUtlFillRgInfUeInfo (sf,cell, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
+Void rgSCHUtlFillRgInfUeInfo (sf,cell, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
{
RgSchDlSf *sf;
RgSchCellCb *cell;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdSch
+S16 rgSCHUtlUpdSch
(
RgInfSfDatInd *subfrmInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err)
+S16 rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err)
RgInfSfDatInd *subfrmInfo;
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddUeToCcchSduLst
+S16 rgSCHUtlAddUeToCcchSduLst
(
RgSchCellCb *cell,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHUtlAddUeToCcchSduLst(cell, ueCb)
+S16 rgSCHUtlAddUeToCcchSduLst(cell, ueCb)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdtBo
+S16 rgSCHUtlUpdtBo
(
RgSchCellCb *cell,
RgInfCmnBoRpt *staRsp
)
#else
-PUBLIC S16 rgSCHUtlUpdtBo(cell, staRsp)
+S16 rgSCHUtlUpdtBo(cell, staRsp)
RgSchCellCb *cell;
RgInfCmnBoRpt *staRsp;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlHndlCcchBoUpdt
+S16 rgSCHUtlHndlCcchBoUpdt
(
RgSchCellCb *cell,
RgInfCmnBoRpt *boRpt
)
#else
-PUBLIC S16 rgSCHUtlHndlCcchBoUpdt(cell, boRpt)
+S16 rgSCHUtlHndlCcchBoUpdt(cell, boRpt)
RgSchCellCb *cell;
RgInfCmnBoRpt *boRpt;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S32 rgSCHUtlGetAllwdCchTbSz
+S32 rgSCHUtlGetAllwdCchTbSz
(
U32 bo,
U8 *nPrb,
U8 *mcs
)
#else
-PUBLIC S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
+S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
U32 bo;
U8 *nPrb;
U8 *mcs;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlHndlBcchPcchBoUpdt
+S16 rgSCHUtlHndlBcchPcchBoUpdt
(
RgSchCellCb *cell,
RgInfCmnBoRpt *boUpdt
)
#else
-PUBLIC S16 rgSCHUtlHndlBcchPcchBoUpdt(cell, boUpdt)
+S16 rgSCHUtlHndlBcchPcchBoUpdt(cell, boUpdt)
RgSchCellCb *cell;
RgInfCmnBoRpt *boUpdt;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrBndCfm
+S16 rgSCHUtlRgrBndCfm
(
Inst instId,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrBndCfm(instId, suId, status)
+S16 rgSCHUtlRgrBndCfm(instId, suId, status)
Inst instId;
SuId suId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgmBndCfm
+S16 rgSCHUtlRgmBndCfm
(
Inst instId,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgmBndCfm(instId, suId, status)
+S16 rgSCHUtlRgmBndCfm(instId, suId, status)
Inst instId;
SuId suId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 schSendCfgCfm
+S16 schSendCfgCfm
(
Region reg,
Pool pool,
U8 status
)
#else
-PUBLIC S16 schSendCfgCfm(reg, pool, transId, status)
+S16 schSendCfgCfm(reg, pool, transId, status)
Region reg;
Pool pool;
RgrCfgTransId transId;
cfmPst.srcEnt = (Ent)ENTDUAPP;
cfmPst.srcInst = (Inst) 0;
cfmPst.srcProcId = SFndProcId();
- cfmPst.dstEnt = (Ent)ENTRG;
+ cfmPst.dstEnt = (Ent)ENTMAC;
cfmPst.dstInst = (Inst) 0;
cfmPst.dstProcId = SFndProcId();
cfmPst.selector = ODU_SELECTOR_LC;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrTtiInd
+S16 rgSCHUtlRgrTtiInd
(
RgSchCellCb *cell,
RgrTtiIndInfo *rgrTti
)
#else
-PUBLIC S16 rgSCHUtlRgrTtiInd(cell, rgrTti)
+S16 rgSCHUtlRgrTtiInd(cell, rgrTti)
RgSchCellCb *cell;
RgrTtiIndInfo *rgrTti;
#endif
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlProcMsg3
+S16 rgSCHUtlProcMsg3
(
RgInfSfDatInd *subfrmInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlProcMsg3 (subfrmInfo, cellCb, ueCb, rnti, pdu, err)
+S16 rgSCHUtlProcMsg3 (subfrmInfo, cellCb, ueCb, rnti, pdu, err)
RgInfSfDatInd *subfrmInfo;
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSpsRelInd
+S16 rgSCHUtlSpsRelInd
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
Bool isExplRel
)
#else
-PUBLIC S16 rgSCHUtlSpsRelInd (cellCb, ueCb, isExplRel)
+S16 rgSCHUtlSpsRelInd (cellCb, ueCb, isExplRel)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
Bool isExplRel;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSpsActInd
+S16 rgSCHUtlSpsActInd
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
U16 spsSduSize
)
#else
-PUBLIC S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
+S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
U16 spsSduSize;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuGrpPwrCntrlReq
+S16 rgSCHUtlTfuGrpPwrCntrlReq
(
Inst inst,
S16 sapId,
TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq
)
#else
-PUBLIC S16 rgSCHUtlTfuGrpPwrCntrlReq(inst, sapId, grpPwrCntrlReq)
+S16 rgSCHUtlTfuGrpPwrCntrlReq(inst, sapId, grpPwrCntrlReq)
Inst inst;
S16 sapId;
TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuCntrlReq
+S16 rgSCHUtlTfuCntrlReq
(
Inst inst,
S16 sapId,
TfuCntrlReqInfo *cntrlReq
)
#else
-PUBLIC S16 rgSCHUtlTfuCntrlReq(inst, sapId, cntrlReq)
+S16 rgSCHUtlTfuCntrlReq(inst, sapId, cntrlReq)
Inst inst;
S16 sapId;
TfuCntrlReqInfo *cntrlReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlDlActvtUe
+S16 rgSCHUtlDlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHUtlDlActvtUe(cell, ue)
+S16 rgSCHUtlDlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlActvtUe
+S16 rgSCHUtlUlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHUtlUlActvtUe(cell, ue)
+S16 rgSCHUtlUlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuRecpReq
+S16 rgSCHUtlTfuRecpReq
(
Inst inst,
S16 sapId,
TfuRecpReqInfo *recpReq
)
#else
-PUBLIC S16 rgSCHUtlTfuRecpReq(inst, sapId, recpReq)
+S16 rgSCHUtlTfuRecpReq(inst, sapId, recpReq)
Inst inst;
S16 sapId;
TfuRecpReqInfo *recpReq;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlValidateTfuSap
+S16 rgSCHUtlValidateTfuSap
(
Inst inst,
SuId suId
)
#else
-PUBLIC S16 rgSCHUtlValidateTfuSap(inst, suId)
+S16 rgSCHUtlValidateTfuSap(inst, suId)
Inst inst;
SuId suId;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocEventMem
+S16 rgSCHUtlAllocEventMem
(
Inst inst,
Ptr *memPtr,
Size memSize
)
#else
-PUBLIC S16 rgSCHUtlAllocEventMem(inst, memPtr, memSize)
+S16 rgSCHUtlAllocEventMem(inst, memPtr, memSize)
Inst inst;
Ptr *memPtr;
Size memSize;
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetEventMem
+S16 rgSCHUtlGetEventMem
(
Ptr *ptr,
Size len,
Ptr memCp
)
#else
-PUBLIC S16 rgSCHUtlGetEventMem(ptr, len, memCp)
+S16 rgSCHUtlGetEventMem(ptr, len, memCp)
Ptr *ptr;
Size len;
Ptr memCp;
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocUeANFdbkInfo
+S16 rgSCHUtlAllocUeANFdbkInfo
(
RgSchUeCb *ue,
U8 servCellIdx
)
#else
-PUBLIC S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
+S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
U8 servCellIdx;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDelUeANFdbkInfo
+Void rgSCHUtlDelUeANFdbkInfo
(
RgSchUeCb *ue,
U8 servCellIdx
)
#else
-PUBLIC Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
+Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
U8 servCellIdx;
#endif
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlInitUeANFdbkInfo
+S16 rgSCHUtlInitUeANFdbkInfo
(
RgSchTddANInfo *anFdInfo
)
#else
-PUBLIC S16 rgSCHUtlInitUeANFdbkInfo(anFdInfo)
+S16 rgSCHUtlInitUeANFdbkInfo(anFdInfo)
RgSchTddANInfo *anFdInfo;
#endif
{
* @return RgSchTddANInfo*
**/
#ifdef ANSI
-PUBLIC RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo
+RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo
(
RgSchUeCb *ueCb,
CmLteTimingInfo *timeInfo,
U8 servCellIdx
)
#else
-PUBLIC RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
+RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
RgSchUeCb *ueCb;
CmLteTimingInfo *timeInfo;
U8 servCellIdx;
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlGetDlSfIdx
+U8 rgSCHUtlGetDlSfIdx
(
RgSchCellCb *cell,
CmLteTimingInfo *timeInfo
)
#else
-PUBLIC U8 rgSCHUtlGetDlSfIdx(cell, timeInfo)
+U8 rgSCHUtlGetDlSfIdx(cell, timeInfo)
RgSchCellCb *cell;
CmLteTimingInfo *timeInfo;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetNxtDlSfInfo
+Void rgSCHUtlGetNxtDlSfInfo
(
CmLteTimingInfo curDlTime,
RgSchCellCb *cell,
CmLteTimingInfo *nxtDlTime
)
#else
-PUBLIC Void rgSCHUtlGetNxtDlSfInfo(curDlTime, cell, dlSf, nxtDlsf, nxtDlTime)
+Void rgSCHUtlGetNxtDlSfInfo(curDlTime, cell, dlSf, nxtDlsf, nxtDlTime)
CmLteTimingInfo curDlTime;
RgSchCellCb *cell;
RgSchDlSf *dlSf;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetPrevDlSfInfo
+Void rgSCHUtlGetPrevDlSfInfo
(
RgSchCellCb *cell,
CmLteTimingInfo curDlTime,
U8 *numSubfrm
)
#else
-PUBLIC Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
+Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
RgSchCellCb *cell;
CmLteTimingInfo curDlTime;
CmLteTimingInfo *prevDlTime;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlSfInit
+S16 rgSCHUtlUlSfInit
(
RgSchCellCb *cell,
RgSchUlSf *sf,
U8 maxUePerSf
)
#else
-PUBLIC S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
+S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
RgSchCellCb *cell;
RgSchUlSf *sf;
U8 idx;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlSfDeinit
+Void rgSCHUtlUlSfDeinit
(
RgSchCellCb *cell,
RgSchUlSf *sf
)
#else
-PUBLIC Void rgSCHUtlUlSfDeinit(cell, sf)
+Void rgSCHUtlUlSfDeinit(cell, sf)
RgSchCellCb *cell;
RgSchUlSf *sf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetHole
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole
(
RgSchUlSf *sf,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(sf, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(sf, hole)
RgSchUlSf *sf;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocFirst
+RgSchUlAlloc *rgSCHUtlUlAllocFirst
(
RgSchUlSf *sf
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocFirst(sf)
+RgSchUlAlloc *rgSCHUtlUlAllocFirst(sf)
RgSchUlSf *sf;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocNxt
+RgSchUlAlloc *rgSCHUtlUlAllocNxt
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocNxt(sf, alloc)
+RgSchUlAlloc *rgSCHUtlUlAllocNxt(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt
+RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt
(
RgSchUlAllocDb *db,
RgSchUlAlloc *prv
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(db, prv)
+RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(db, prv)
RgSchUlAllocDb *db;
RgSchUlAlloc *prv;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetFirst
+RgSchUlAlloc *rgSCHUtlUlAllocGetFirst
(
RgSchUlAllocDb *db
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(db)
+RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(db)
RgSchUlAllocDb *db;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleAddAllocation
+Void rgSCHUtlUlHoleAddAllocation
(
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleAddAllocation(alloc)
+Void rgSCHUtlUlHoleAddAllocation(alloc)
RgSchUlAlloc *alloc;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocRelease
+Void rgSCHUtlUlAllocRelease
(
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocRelease(alloc)
+Void rgSCHUtlUlAllocRelease(alloc)
RgSchUlAlloc *alloc;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocRls
+Void rgSCHUtlUlAllocRls
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocRls(sf, alloc)
+Void rgSCHUtlUlAllocRls(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleFirst
+RgSchUlHole *rgSCHUtlUlHoleFirst
(
RgSchUlSf *sf
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleFirst(sf)
+RgSchUlHole *rgSCHUtlUlHoleFirst(sf)
RgSchUlSf *sf;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleNxt
+RgSchUlHole *rgSCHUtlUlHoleNxt
(
RgSchUlSf *sf,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleNxt(sf, hole)
+RgSchUlHole *rgSCHUtlUlHoleNxt(sf, hole)
RgSchUlSf *sf;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleAddAlloc
+Void rgSCHUtlUlHoleAddAlloc
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleAddAlloc(sf, alloc)
+Void rgSCHUtlUlHoleAddAlloc(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleJoin
+Void rgSCHUtlUlHoleJoin
(
RgSchUlHoleDb *db,
RgSchUlHole *prv,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleJoin(db, prv, nxt, alloc)
+Void rgSCHUtlUlHoleJoin(db, prv, nxt, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *prv;
RgSchUlHole *nxt;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleExtndRight
+Void rgSCHUtlUlHoleExtndRight
(
RgSchUlHoleDb *db,
RgSchUlHole *prv,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleExtndRight(db, prv, alloc)
+Void rgSCHUtlUlHoleExtndRight(db, prv, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *prv;
RgSchUlAlloc *alloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleExtndLeft
+Void rgSCHUtlUlHoleExtndLeft
(
RgSchUlHoleDb *db,
RgSchUlHole *nxt,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleExtndLeft(db, nxt, alloc)
+Void rgSCHUtlUlHoleExtndLeft(db, nxt, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *nxt;
RgSchUlAlloc *alloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleNew
+Void rgSCHUtlUlHoleNew
(
RgSchUlHoleDb *db,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleNew(db, alloc)
+Void rgSCHUtlUlHoleNew(db, alloc)
RgSchUlHoleDb *db;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleUpdAllocLnks
+Void rgSCHUtlUlHoleUpdAllocLnks
(
RgSchUlHole *hole,
RgSchUlAlloc *prvAlloc,
RgSchUlAlloc *nxtAlloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleUpdAllocLnks(hole, prvAlloc, nxtAlloc)
+Void rgSCHUtlUlHoleUpdAllocLnks(hole, prvAlloc, nxtAlloc)
RgSchUlHole *hole;
RgSchUlAlloc *prvAlloc;
RgSchUlAlloc *nxtAlloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleIns
+Void rgSCHUtlUlHoleIns
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleIns(db, hole)
+Void rgSCHUtlUlHoleIns(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleIncr
+Void rgSCHUtlUlHoleIncr
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleIncr(db, hole)
+Void rgSCHUtlUlHoleIncr(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleDecr
+Void rgSCHUtlUlHoleDecr
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleDecr(db, hole)
+Void rgSCHUtlUlHoleDecr(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleRls
+Void rgSCHUtlUlHoleRls
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleRls(db, hole)
+Void rgSCHUtlUlHoleRls(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlAllocMemInit
+S16 rgSCHUtlUlAllocMemInit
(
RgSchCellCb *cell,
RgSchUlAllocMem *mem,
U8 maxAllocs
)
#else
-PUBLIC S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
+S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
RgSchCellCb *cell;
RgSchUlAllocMem *mem;
U8 maxAllocs;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocMemDeinit
+Void rgSCHUtlUlAllocMemDeinit
(
RgSchCellCb *cell,
RgSchUlAllocMem *mem
)
#else
-PUBLIC Void rgSCHUtlUlAllocMemDeinit(cell, mem)
+Void rgSCHUtlUlAllocMemDeinit(cell, mem)
RgSchCellCb *cell;
RgSchUlAllocMem *mem;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlHoleMemInit
+S16 rgSCHUtlUlHoleMemInit
(
RgSchCellCb *cell,
RgSchUlHoleMem *mem,
RgSchUlHole **holeRef
)
#else
-PUBLIC S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
+S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
RgSchCellCb *cell;
RgSchUlHoleMem *mem;
U8 maxHoles;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleMemDeinit
+Void rgSCHUtlUlHoleMemDeinit
(
RgSchCellCb *cell,
RgSchUlHoleMem *mem
)
#else
-PUBLIC Void rgSCHUtlUlHoleMemDeinit(cell, mem)
+Void rgSCHUtlUlHoleMemDeinit(cell, mem)
RgSchCellCb *cell;
RgSchUlHoleMem *mem;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocMemGet
+RgSchUlAlloc *rgSCHUtlUlAllocMemGet
(
RgSchUlAllocMem *mem
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocMemGet(mem)
+RgSchUlAlloc *rgSCHUtlUlAllocMemGet(mem)
RgSchUlAllocMem *mem;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocMemRls
+Void rgSCHUtlUlAllocMemRls
(
RgSchUlAllocMem *mem,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocMemRls(mem, alloc)
+Void rgSCHUtlUlAllocMemRls(mem, alloc)
RgSchUlAllocMem *mem;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleMemGet
+RgSchUlHole *rgSCHUtlUlHoleMemGet
(
RgSchUlHoleMem *mem
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleMemGet(mem)
+RgSchUlHole *rgSCHUtlUlHoleMemGet(mem)
RgSchUlHoleMem *mem;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleMemRls
+Void rgSCHUtlUlHoleMemRls
(
RgSchUlHoleMem *mem,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleMemRls(mem, hole)
+Void rgSCHUtlUlHoleMemRls(mem, hole)
RgSchUlHoleMem *mem;
RgSchUlHole *hole;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
+RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
(
RgSchUlSf *sf,
U8 startSb,
U8 numSb
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
+RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
RgSchUlSf *sf;
U8 startSb;
U8 numSb;
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlValidateMeasReq
+S16 rgSCHUtlValidateMeasReq
(
RgSchCellCb *cellCb,
LrgSchMeasReqInfo *schL2MeasInfo,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlValidateMeasReq(cellCb, schL2MeasInfo, err)
+S16 rgSCHUtlValidateMeasReq(cellCb, schL2MeasInfo, err)
RgSchCellCb *cellCb;
LrgSchMeasReqInfo *schL2MeasInfo;
RgSchErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrSiCfgCfm
+S16 rgSCHUtlRgrSiCfgCfm
(
Inst instId,
SpId spId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
+S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
Inst instId;
SpId spId;
RgrCfgTransId transId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrWarningSiCfgCfm
+S16 rgSCHUtlRgrWarningSiCfgCfm
(
Inst instId,
SpId spId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
+S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
Inst instId;
SpId spId;
U8 siId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPutSiInfo
+Void rgSCHUtlPutSiInfo
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlPutSiInfo(cell)
+Void rgSCHUtlPutSiInfo(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetDrxSchdUesInDl
+S16 rgSCHUtlGetDrxSchdUesInDl
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLListCp *ulInActvLst
)
#else
-PUBLIC S16 rgSCHUtlGetDrxSchdUesInDl(cellCb, ueCb, dlHq, allocInfo, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
+S16 rgSCHUtlGetDrxSchdUesInDl(cellCb, ueCb, dlHq, allocInfo, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgSchDlHqProcCb *dlHq;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillSndStaInd
+S16 rgSCHUtlFillSndStaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 numCqiRept
)
#else
-PUBLIC S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
+S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrStaIndInfo *staInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrStaInd
+S16 rgSCHUtlRgrStaInd
(
RgSchCellCb *cell,
RgrStaIndInfo *rgrSta
)
#else
-PUBLIC S16 rgSCHUtlRgrStaInd(cell, rgrSta)
+S16 rgSCHUtlRgrStaInd(cell, rgrSta)
RgSchCellCb *cell;
RgrStaIndInfo *rgrSta;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlIndRntiRls2Mac
+Void rgSCHUtlIndRntiRls2Mac
(
RgSchCellCb *cell,
CmLteRnti rnti,
CmLteRnti newRnti
)
#else
-PUBLIC Void rgSCHUtlIndRntiRls2Mac(cell, rnti, ueIdChng, newRnti)
+Void rgSCHUtlIndRntiRls2Mac(cell, rnti, ueIdChng, newRnti)
RgSchCellCb *cell;
CmLteRnti rnti;
Bool ueIdChng;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLoadInfInd
+S16 rgSCHUtlRgrLoadInfInd
(
RgSchCellCb *cell,
RgrLoadInfIndInfo *rgrLoadInf
)
#else
-PUBLIC S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
+S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
RgSchCellCb *cell;
RgrLoadInfIndInfo *rgrLoadInf;
#endif
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRlsRnti
+Void rgSCHUtlRlsRnti
(
RgSchCellCb *cell,
RgSchRntiLnk *rntiLnk,
CmLteRnti newRnti
)
#else
-PUBLIC Void rgSCHUtlRlsRnti(cell, rntiLnk, ueIdChngd, newRnti)
+Void rgSCHUtlRlsRnti(cell, rntiLnk, ueIdChngd, newRnti)
RgSchCellCb *cell;
RgSchRntiLnk *rntiLnk;
Bool ueIdChngd;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillSndUeStaInd
+S16 rgSCHUtlFillSndUeStaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeStaIndInfo *ueStaInfo
)
#else
-PUBLIC S16 rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInfo)
+S16 rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeStaIndInfo *ueStaInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeStaInd
+S16 rgSCHUtlRgrUeStaInd
(
RgSchCellCb *cell,
RgrUeStaIndInfo *rgrUeSta
)
#else
-PUBLIC S16 rgSCHUtlRgrUeStaInd(cell, rgrUeSta)
+S16 rgSCHUtlRgrUeStaInd(cell, rgrUeSta)
RgSchCellCb *cell;
RgrUeStaIndInfo *rgrUeSta;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdAvgPrbUsage
+S16 rgSCHUtlUpdAvgPrbUsage
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlUpdAvgPrbUsage(cell)
+S16 rgSCHUtlUpdAvgPrbUsage(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlReTxTa
+Void rgSCHUtlReTxTa
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHUtlReTxTa(cellCb, ueCb)
+Void rgSCHUtlReTxTa(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlCfg0ReTxIdx
+U8 rgSchUtlCfg0ReTxIdx
(
RgSchCellCb *cell,
CmLteTimingInfo phichTime,
U8 hqFdbkIdx
)
#else
-PUBLIC U8 rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
+U8 rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
RgSchCellCb *cell;
CmLteTimingInfo phichTime;
U8 hqFdbkIdx;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlDlCalc1CwPrb
+Void rgSchUtlDlCalc1CwPrb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
+Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlDlCalc2CwPrb
+Void rgSchUtlDlCalc2CwPrb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
+Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlCalcTotalPrbReq
+Void rgSchUtlCalcTotalPrbReq
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
+Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlGetNumSbs
+U8 rgSchUtlGetNumSbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *numSbs
)
#else
-PUBLIC U8 rgSchUtlGetNumSbs (cell, ue, numSbs)
+U8 rgSchUtlGetNumSbs (cell, ue, numSbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 *numSbs;
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlSortInsUeLst
+U8 rgSchUtlSortInsUeLst
(
RgSchCellCb *cell,
CmLListCp *ueLst,
U8 vrbgRequired
)
#else
-PUBLIC U8 rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
+U8 rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
RgSchCellCb *cell;
CmLListCp *ueLst;
CmLList *node;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlBuildNSendLcgReg
+S16 rgSCHUtlBuildNSendLcgReg
(
RgSchCellCb *cell,
CmLteRnti crnti,
Bool isGbr
)
#else
-PUBLIC S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
+S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
RgSchCellCb *cell;
CmLteRnti crnti;
U8 lcgId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC TfuAckNackMode rgSchUtlGetFdbkMode
+TfuAckNackMode rgSchUtlGetFdbkMode
(
RgrSchFrmt1b3TypEnum fdbkType
)
#else
-PUBLIC TfuAckNackMode rgSchUtlGetFdbkMode(fdbkType)
+TfuAckNackMode rgSchUtlGetFdbkMode(fdbkType)
RgrSchFrmt1b3TypEnum fdbkType;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSndUeSCellDel2Mac
+Void rgSCHUtlSndUeSCellDel2Mac
(
RgSchCellCb *cell,
CmLteRnti rnti
)
#else
-PUBLIC Void rgSCHUtlSndUeSCellDel2Mac(cell, rnti)
+Void rgSCHUtlSndUeSCellDel2Mac(cell, rnti)
RgSchCellCb *cell;
CmLteRnti rnti;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlGetMaxTbSupp
+U8 rgSCHUtlGetMaxTbSupp
(
RgrTxMode txMode
)
#else
-PUBLIC U8 rgSCHUtlGetMaxTbSupp(txMode)
+U8 rgSCHUtlGetMaxTbSupp(txMode)
RgrTxMode txMode
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHTomUtlGetTrigSet
+Void rgSCHTomUtlGetTrigSet
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdUeDciSize
+Void rgSCHUtlUpdUeDciSize
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
Bool isCsi2Bit
)
#else
-PUBLIC Void rgSCHUtlUpdUeDciSize(cell, ueCb, isCsi2Bit)
+Void rgSCHUtlUpdUeDciSize(cell, ueCb, isCsi2Bit)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
Bool isCsi2Bit;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlCalcDciSizes
+Void rgSCHUtlCalcDciSizes
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlCalcDciSizes(cell)
+Void rgSCHUtlCalcDciSizes(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlCpuOvrLdAdjItbsCap
+Void rgSCHUtlCpuOvrLdAdjItbsCap
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
+Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
RgSchCellCb *cell
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlResetCpuOvrLdState
+S16 rgSCHUtlResetCpuOvrLdState
(
RgSchCellCb *cell,
U8 crntCpuOvrLdIns
)
#else
-PUBLIC S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
+S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
RgSchCellCb *cell;
U8 crntCpuOvrLdIns;
#endif
return ROK;
}
#ifdef EMTC_ENABLE
-PUBLIC S16 rgSCHUtlAddToResLst
+S16 rgSCHUtlAddToResLst
(
CmLListCp *cp,
RgSchIotRes *iotRes
iotRes->resLnk.node = (PTR)iotRes;
return ROK;
}
-PUBLIC S16 rgSCHUtlDelFrmResLst
+S16 rgSCHUtlDelFrmResLst
(
RgSchUeCb *ue,
RgSchIotRes *iotRes
*
*/
#ifdef ANSI
-PUBLIC Void rgSCHRrCListInit
+Void rgSCHRrCListInit
(
RgSchRrCListCp *lCp /* list control point */
)
#else
-PUBLIC Void rgSCHRrCListInit(lCp)
+Void rgSCHRrCListInit(lCp)
RgSchRrCListCp *lCp; /* list control point */
#endif
{
* File: rr_clist.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHRrCListAdd2Crnt
+Void rgSCHRrCListAdd2Crnt
(
RgSchRrCListCp *lCp, /* list control point */
RgSchRrCList *node /* node to be added */
)
#else
-PUBLIC Void rgSCHRrCListAdd2Crnt(lCp, node)
+Void rgSCHRrCListAdd2Crnt(lCp, node)
RgSchRrCListCp *lCp; /* list control point */
RgSchRrCList *node; /* node to be added */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void rgSCHRrCListAdd2Tail
+Void rgSCHRrCListAdd2Tail
(
RgSchRrCListCp *lCp, /* list control point */
RgSchRrCList *node /* node to be added */
)
#else
-PUBLIC Void rgSCHRrCListAdd2Tail(lCp, node)
+Void rgSCHRrCListAdd2Tail(lCp, node)
RgSchRrCListCp *lCp; /* list control point */
RgSchRrCList *node; /* node to be added */
#endif
*
*/
#ifdef ANSI
-PUBLIC RgSchRrCList *rgSCHRrCListDelFrm
+RgSchRrCList *rgSCHRrCListDelFrm
(
RgSchRrCListCp *lCp, /* list control pointer */
RgSchRrCList *node /* node to be removed */
)
#else
-PUBLIC RgSchRrCList *rgSCHRrCListDelFrm(lCp, node)
+RgSchRrCList *rgSCHRrCListDelFrm(lCp, node)
RgSchRrCListCp *lCp; /* list control pointer */
RgSchRrCList *node; /* node to be removed */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void rgSCHRrCListInsrtAtCrnt
+Void rgSCHRrCListInsrtAtCrnt
(
RgSchRrCListCp *lCp, /* list control pointer */
RgSchRrCList *node /* node to be removed */
)
#else
-PUBLIC Void rgSCHRrCListInsrtAtCrnt(lCp, node)
+Void rgSCHRrCListInsrtAtCrnt(lCp, node)
RgSchRrCListCp *lCp; /* list control pointer */
RgSchRrCList *node; /* node to be inserted */
#endif
* -# LCM_REASON_INVALID_MSGTYPE
* -# LCM_REASON_MEM_NOAVAIL
**/
-PUBLIC uint8_t SchInstCfg(RgCfg *cfg, Inst dInst)
+uint8_t SchInstCfg(RgCfg *cfg, Inst dInst)
{
uint16_t ret = LCM_REASON_NOT_APPL;
Inst inst = (dInst - SCH_INST_START);
{ \
_pst.srcProcId = SFndProcId(); \
_pst.dstProcId = SFndProcId(); \
- _pst.srcEnt = ENTRG; \
- _pst.dstEnt = ENTRG; \
+ _pst.srcEnt = ENTMAC; \
+ _pst.dstEnt = ENTMAC; \
_pst.srcInst = 1; \
_pst.dstInst = 0; \
_pst.selector = ODU_SELECTOR_TC; \
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwBndReq
+S16 cmPkCkwBndReq
(
Pst *pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkCkwBndReq(pst, suId, spId)
+S16 cmPkCkwBndReq(pst, suId, spId)
Pst *pst;
SuId suId;
SpId spId;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwUbndReq
+S16 cmPkCkwUbndReq
(
Pst *pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkCkwUbndReq(pst, spId, reason)
+S16 cmPkCkwUbndReq(pst, spId, reason)
Pst *pst;
SpId spId;
Reason reason;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwBndCfm
+S16 cmPkCkwBndCfm
(
Pst *pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkCkwBndCfm(pst, suId, status)
+S16 cmPkCkwBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
U8 status;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcTmInfo
+S16 cmPkRlcTmInfo
(
RlcTmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRlcTmInfo(param, mBuf)
+S16 cmPkRlcTmInfo(param, mBuf)
RlcTmInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcUmInfo
+S16 cmPkRlcUmInfo
(
RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRlcUmInfo(param, mBuf)
+S16 cmPkRlcUmInfo(param, mBuf)
RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcAmInfo
+S16 cmPkRlcAmInfo
(
RlcAmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRlcAmInfo(param, mBuf)
+S16 cmPkRlcAmInfo(param, mBuf)
RlcAmInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwLChInfo
+S16 cmPkCkwLChInfo
(
CkwLChInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwLChInfo(param, mBuf)
+S16 cmPkCkwLChInfo(param, mBuf)
CkwLChInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcEntCfgInfo
+S16 cmPkRlcEntCfgInfo
(
RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRlcEntCfgInfo(param, mBuf)
+S16 cmPkRlcEntCfgInfo(param, mBuf)
RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcCfgInfo
+S16 cmPkRlcCfgInfo
(
RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRlcCfgInfo(param, pst, mBuf)
+S16 cmPkRlcCfgInfo(param, pst, mBuf)
RlcCfgInfo *param;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcEntCfgCfmInfo
+S16 cmPkRlcEntCfgCfmInfo
(
RlcEntCfgCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRlcEntCfgCfmInfo(param, mBuf)
+S16 cmPkRlcEntCfgCfmInfo(param, mBuf)
RlcEntCfgCfmInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcCfgCfmInfo
+S16 cmPkRlcCfgCfmInfo
(
RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRlcCfgCfmInfo(param, pst, mBuf)
+S16 cmPkRlcCfgCfmInfo(param, pst, mBuf)
RlcCfgCfmInfo *param;
Pst *pst;
Buffer *mBuf;
*
* Fun: cmPkRlcCfgCfm
*
-* Desc: pack the primitive KwUiRlcCfgCfm
+* Desc: pack the primitive RlcUiRlcCfgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkRlcCfgCfm
+S16 cmPkRlcCfgCfm
(
Pst *pst,
SuId suId,
RlcCfgCfmInfo *cfgCfmInfo
)
#else
-PUBLIC S16 cmPkRlcCfgCfm(pst, suId, cfgCfmInfo)
+S16 cmPkRlcCfgCfm(pst, suId, cfgCfmInfo)
Pst *pst;
SuId suId;
RlcCfgCfmInfo *cfgCfmInfo;
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwUeInfo
+S16 cmPkCkwUeInfo
(
CkwUeInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwUeInfo(param, mBuf)
+S16 cmPkCkwUeInfo(param, mBuf)
CkwUeInfo *param;
Buffer *mBuf;
#endif
*
* Fun: cmPkCkwUeIdChgReq
*
-* Desc: pack the primitive KwUiCkwUeIdChgReq
+* Desc: pack the primitive RlcUiCkwUeIdChgReq
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwUeIdChgReq
+S16 cmPkCkwUeIdChgReq
(
Pst *pst,
SpId spId,
CkwUeInfo *newUeInfo
)
#else
-PUBLIC S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
+S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst *pst;
SpId spId;
U32 transId;
*
* Fun: cmPkCkwUeIdChgCfm
*
-* Desc: pack the primitive KwUiCkwUeIdChgCfm
+* Desc: pack the primitive RlcUiCkwUeIdChgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwUeIdChgCfm
+S16 cmPkCkwUeIdChgCfm
(
Pst *pst,
SuId suId,
CmStatus status
)
#else
-PUBLIC S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
+S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
Pst *pst;
SuId suId;
U32 transId;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwBndReq
+S16 cmUnpkCkwBndReq
(
CkwBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwBndReq(func, pst, mBuf)
+S16 cmUnpkCkwBndReq(func, pst, mBuf)
CkwBndReq func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwUbndReq
+S16 cmUnpkCkwUbndReq
(
CkwUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwUbndReq(func, pst, mBuf)
+S16 cmUnpkCkwUbndReq(func, pst, mBuf)
CkwUbndReq func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwBndCfm
+S16 cmUnpkCkwBndCfm
(
CkwBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwBndCfm(func, pst, mBuf)
+S16 cmUnpkCkwBndCfm(func, pst, mBuf)
CkwBndCfm func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcTmInfo
+S16 cmUnpkRlcTmInfo
(
RlcTmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcTmInfo(param, mBuf)
+S16 cmUnpkRlcTmInfo(param, mBuf)
RlcTmInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcUmInfo
+S16 cmUnpkRlcUmInfo
(
RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcUmInfo(param, mBuf)
+S16 cmUnpkRlcUmInfo(param, mBuf)
RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcAmInfo
+S16 cmUnpkRlcAmInfo
(
RlcAmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcAmInfo(param, mBuf)
+S16 cmUnpkRlcAmInfo(param, mBuf)
RlcAmInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwLChInfo
+S16 cmUnpkCkwLChInfo
(
CkwLChInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwLChInfo(param, mBuf)
+S16 cmUnpkCkwLChInfo(param, mBuf)
CkwLChInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcEntCfgCfmInfo
+S16 cmUnpkRlcEntCfgCfmInfo
(
RlcEntCfgCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcEntCfgCfmInfo(param, mBuf)
+S16 cmUnpkRlcEntCfgCfmInfo(param, mBuf)
RlcEntCfgCfmInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcCfgCfmInfo
+S16 cmUnpkRlcCfgCfmInfo
(
RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcCfgCfmInfo(param, pst, mBuf)
+S16 cmUnpkRlcCfgCfmInfo(param, pst, mBuf)
RlcCfgCfmInfo *param;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcEntCfgInfo
+S16 cmUnpkRlcEntCfgInfo
(
RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcEntCfgInfo(param, mBuf)
+S16 cmUnpkRlcEntCfgInfo(param, mBuf)
RlcEntCfgInfo *param;
Buffer *mBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcCfgInfo
+S16 cmUnpkRlcCfgInfo
(
RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcCfgInfo(param, pst, mBuf)
+S16 cmUnpkRlcCfgInfo(param, pst, mBuf)
RlcCfgInfo *param;
Pst *pst;
Buffer *mBuf;
*
* Fun: cmUnpkRlcCfgCfm
*
-* Desc: unpack the primitive KwUiRlcCfgCfm
+* Desc: unpack the primitive RlcUiRlcCfgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRlcCfgCfm
+S16 cmUnpkRlcCfgCfm
(
RlcCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRlcCfgCfm(func, pst, mBuf)
+S16 cmUnpkRlcCfgCfm(func, pst, mBuf)
RlcCfgCfm func;
Pst *pst;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwUeInfo
+S16 cmUnpkCkwUeInfo
(
CkwUeInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwUeInfo(param, mBuf)
+S16 cmUnpkCkwUeInfo(param, mBuf)
CkwUeInfo *param;
Buffer *mBuf;
#endif
*
* Fun: cmUnpkCkwUeIdChgReq
*
-* Desc: unpack the primitive KwUiCkwUeIdChgReq
+* Desc: unpack the primitive RlcUiCkwUeIdChgReq
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwUeIdChgReq
+S16 cmUnpkCkwUeIdChgReq
(
CkwUeIdChgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
+S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
CkwUeIdChgReq func;
Pst *pst;
Buffer *mBuf;
*
* Fun: cmUnpkCkwUeIdChgCfm
*
-* Desc: unpack the primitive KwUiCkwUeIdChgCfm
+* Desc: unpack the primitive RlcUiCkwUeIdChgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwUeIdChgCfm
+S16 cmUnpkCkwUeIdChgCfm
(
CkwUeIdChgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
+S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
CkwUeIdChgCfm func;
Pst *pst;
Buffer *mBuf;
* @details The primitive binds the RLC service user entity to the RLC product.
* The RLC service user must bind each CKW SAP individually before sending any
* other request. RLC acknowledges the receipt of the bind request by sending
- * a KwUiCkwBndCfm primitive.
+ * a RlcUiCkwBndCfm primitive.
* @param[in] pst - For the bind request, the event field in the Pst
* structure is set to EVTCKWBNDREQ
* Allowable values: 0 to 32767.
* @return ROK
*/
-EXTERN S16 KwUiCkwBndReq ARGS((Pst *pst, SuId suId, SpId spId));
+EXTERN S16 RlcUiCkwBndReq ARGS((Pst *pst, SuId suId, SpId spId));
/**
* @details RLC invokes the bind confirm primitive to acknowledge the receipt
- * of the KwUiCkwBndReq primitive from the service user. The status field
+ * of the RlcUiCkwBndReq primitive from the service user. The status field
* indicates whether the bind request succeeded or failed. The bind request
* may fail due to invalid parameters in the bind request from the
* service user (for example, an invalid spId).
CM_BND_NOK: Error encountered during the processing of the bind request.
* @return ROK
*/
-EXTERN S16 KwUiCkwBndCfm ARGS((Pst *pst, SuId suId, U8 status));
+EXTERN S16 RlcUiCkwBndCfm ARGS((Pst *pst, SuId suId, U8 status));
/**
* @details The RLC service user initiates this primitive for performing
* Allowable value: CKW_UBND_REQ.
* @return ROK
*/
-EXTERN S16 KwUiCkwUbndReq ARGS((Pst *pst, SpId spId, Reason reason));
+EXTERN S16 RlcUiCkwUbndReq ARGS((Pst *pst, SpId spId, Reason reason));
/* Layer interface Control Primitives */
/**
* information.
* @return ROK
*/
-EXTERN S16 KwUiRlcCfgCfm ARGS((Pst *pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
+EXTERN S16 RlcUiRlcCfgCfm ARGS((Pst *pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
/**
*@details This primitive is used by RRC to change the UeId for the existing UE
* @param[in] newUeInfo - New UE Id Info for existing UE context.
* @return ROK
*/
-EXTERN S16 KwUiCkwUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
+EXTERN S16 RlcUiCkwUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
/**
* information.
* @return ROK
*/
-EXTERN S16 KwUiCkwUeIdChgCfm ARGS((Pst *pst, SuId suId, U32 transId,
+EXTERN S16 RlcUiCkwUeIdChgCfm ARGS((Pst *pst, SuId suId, U32 transId,
CkwUeInfo *ueInfo, CmStatus status));
/* RRC Extern declarations */
#ifdef SS_FAP
#ifdef ANSI
-PUBLIC Void cmPrcTmr
+Void cmPrcTmr
(
CmTqCp *tqCp, /* timing que control point */
CmTqType *tq, /* timing queue */
PFV func /* function */
)
#else
-PUBLIC Void cmPrcTmr(tqCp, tq, func)
+Void cmPrcTmr(tqCp, tq, func)
CmTqCp *tqCp; /* connection control block */
CmTqType *tq; /* message buffer */
PFV func; /* function */
#else /* not defined SS_FAP */
#ifdef ANSI
-PUBLIC Void cmPrcTmr
+Void cmPrcTmr
(
CmTqCp *tqCp, /* timing que control point */
CmTqType *tq, /* timing queue */
PFV func /* function */
)
#else
-PUBLIC Void cmPrcTmr(tqCp, tq, func)
+Void cmPrcTmr(tqCp, tq, func)
CmTqCp *tqCp; /* connection control block */
CmTqType *tq; /* message buffer */
PFV func; /* function */
*
*/
#ifdef ANSI
-PUBLIC Void cmInitTimers
+Void cmInitTimers
(
CmTimer *timers, /* timer list */
U8 max /* maximum tmrs */
)
#else
-PUBLIC Void cmInitTimers(timers, max)
+Void cmInitTimers(timers, max)
CmTimer *timers; /* timer list */
U8 max; /* maximum tmrs */
#endif
*/
#ifdef ANSI
-PUBLIC Void cmPlcCbTq
+Void cmPlcCbTq
(
CmTmrArg *arg
)
#else
-PUBLIC Void cmPlcCbTq(arg)
+Void cmPlcCbTq(arg)
CmTmrArg *arg;
#endif
{
*/
#ifdef ANSI
-PUBLIC Void cmRstCbTq
+Void cmRstCbTq
(
CmTmrArg *arg
)
#else
-PUBLIC Void cmRstCbTq(arg)
+Void cmRstCbTq(arg)
CmTmrArg *arg;
#endif
{
*/
#ifdef ANSI
-PUBLIC Void cmRmvCbTq
+Void cmRmvCbTq
(
CmTmrArg *arg
)
#else
-PUBLIC Void cmRmvCbTq(arg)
+Void cmRmvCbTq(arg)
CmTmrArg *arg;
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 cmPkDateTime
+S16 cmPkDateTime
(
DateTime *dateTime, /* date and time */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkDateTime(dateTime, mBuf)
+S16 cmPkDateTime(dateTime, mBuf)
DateTime *dateTime; /* date and time */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkDuration
+S16 cmPkDuration
(
Duration *duration, /* duration */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkDuration(duration, mBuf)
+S16 cmPkDuration(duration, mBuf)
Duration *duration; /* duration */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduPackPointer
+S16 oduPackPointer
(
PTR ptr, /* pointer */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduPackPointer(ptr, mBuf)
+S16 oduPackPointer(ptr, mBuf)
PTR ptr; /* pointer */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkEntityId
+S16 cmPkEntityId
(
EntityId *entityId, /* entity id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkEntityId(entityId, mBuf)
+S16 cmPkEntityId(entityId, mBuf)
EntityId *entityId; /* entity id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkElmntId
+S16 cmPkElmntId
(
ElmntId *elmntId, /* element id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkElmntId(elmntId, mBuf)
+S16 cmPkElmntId(elmntId, mBuf)
ElmntId *elmntId; /* element id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkMemoryId
+S16 cmPkMemoryId
(
MemoryId *memoryId, /* memoryId */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkMemoryId(memoryId, mBuf)
+S16 cmPkMemoryId(memoryId, mBuf)
MemoryId *memoryId; /* memoryId */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkSystemId
+S16 cmPkSystemId
(
SystemId *systemId, /* system id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkSystemId(systemId, mBuf)
+S16 cmPkSystemId(systemId, mBuf)
SystemId *systemId; /* system id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkProtAddr
+S16 cmPkProtAddr
(
ProtAddr *pAddr, /* protocol address */
Buffer *mBuf /* buffer */
)
#else
-PUBLIC S16 cmPkProtAddr(pAddr, mBuf)
+S16 cmPkProtAddr(pAddr, mBuf)
ProtAddr *pAddr; /* protocol address */
Buffer *mBuf; /* buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkProtAddrTbl
+S16 cmPkProtAddrTbl
(
ProtAddrTbl *protAddr, /* protocol address table */
Buffer *mBuf /* buffer */
)
#else
-PUBLIC S16 cmPkProtAddrTbl(protAddr, mBuf)
+S16 cmPkProtAddrTbl(protAddr, mBuf)
ProtAddrTbl *protAddr; /* protocol address table */
Buffer *mBuf; /* buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkAddrs
+S16 cmPkAddrs
(
Addrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkAddrs(addrs, mBuf)
+S16 cmPkAddrs(addrs, mBuf)
Addrs *addrs; /* address */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkShrtAddrs
+S16 cmPkShrtAddrs
(
ShrtAddrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkShrtAddrs(addrs, mBuf)
+S16 cmPkShrtAddrs(addrs, mBuf)
ShrtAddrs *addrs; /* address */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkAddrMask
+S16 cmPkAddrMask
(
U8 *mask, /* pointer to address mask array */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkAddrMask(mask, mBuf)
+S16 cmPkAddrMask(mask, mBuf)
U8 *mask; /* pointer to address mask array */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkBndCfg
+S16 cmPkBndCfg
(
BndCfg *bndCfg, /* bndCfg */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkBndCfg(bndCfg, mBuf)
+S16 cmPkBndCfg(bndCfg, mBuf)
BndCfg *bndCfg; /* bndCfg */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkPst
+S16 cmPkPst
(
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkPst(pst, mBuf)
+S16 cmPkPst(pst, mBuf)
Pst *pst;
Buffer *mBuf;
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkElmtHdr
+S16 cmPkElmtHdr
(
ElmtHdr *m, /* element header */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkElmtHdr(m, mBuf)
+S16 cmPkElmtHdr(m, mBuf)
ElmtHdr *m; /* element header */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknU8
+S16 cmPkTknU8
(
TknU8 *tknU8, /* token U8 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknU8(tknU8, mBuf)
+S16 cmPkTknU8(tknU8, mBuf)
TknU8 *tknU8; /* token U8 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknS8
+S16 cmPkTknS8
(
TknS8 *tknS8, /* token S8 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknS8(tknS8, mBuf)
+S16 cmPkTknS8(tknS8, mBuf)
TknS8 *tknS8; /* token S8 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknU16
+S16 cmPkTknU16
(
TknU16 *tknU16, /* token U16 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknU16(tknU16, mBuf)
+S16 cmPkTknU16(tknU16, mBuf)
TknU16 *tknU16; /* token U16 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknU32
+S16 cmPkTknU32
(
TknU32 *tknU32, /* token U32 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknU32(tknU32, mBuf)
+S16 cmPkTknU32(tknU32, mBuf)
TknU32 *tknU32; /* token U32 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr
+S16 cmPkTknStr
(
TknStr *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr(tknStr, mBuf)
+S16 cmPkTknStr(tknStr, mBuf)
TknStr *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrM
+S16 cmPkTknStrM
(
TknStrM *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrM(tknStr, mBuf)
+S16 cmPkTknStrM(tknStr, mBuf)
TknStrM *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrS
+S16 cmPkTknStrS
(
TknStrS *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrS(tknStr, mBuf)
+S16 cmPkTknStrS(tknStr, mBuf)
TknStrS *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrE
+S16 cmPkTknStrE
(
TknStrE *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrE(tknStr, mBuf)
+S16 cmPkTknStrE(tknStr, mBuf)
TknStrE *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkPnNodeId
+S16 cmPkPnNodeId
(
PnNodeId *src, /* source PNNI Node Id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkPnNodeId (src, mBuf)
+S16 cmPkPnNodeId (src, mBuf)
PnNodeId *src; /* source PNNI Node Id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr4
+S16 cmPkTknStr4
(
TknStr4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr4(tknStr, mBuf)
+S16 cmPkTknStr4(tknStr, mBuf)
TknStr4 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr12
+S16 cmPkTknStr12
(
TknStr12 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr12(tknStr, mBuf)
+S16 cmPkTknStr12(tknStr, mBuf)
TknStr12 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr32
+S16 cmPkTknStr32
(
TknStr32 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr32(tknStr, mBuf)
+S16 cmPkTknStr32(tknStr, mBuf)
TknStr32 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr64
+S16 cmPkTknStr64
(
TknStr64 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr64(tknStr, mBuf)
+S16 cmPkTknStr64(tknStr, mBuf)
TknStr64 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr132
+S16 cmPkTknStr132
(
TknStr132 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr132(tknStr, mBuf)
+S16 cmPkTknStr132(tknStr, mBuf)
TknStr132 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr256
+S16 cmPkTknStr256
(
TknStr256 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr256(tknStr, mBuf)
+S16 cmPkTknStr256(tknStr, mBuf)
TknStr256 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknOid
+S16 cmPkTknOid
(
TknOid *tknOid, /* Object Identifier token */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknOid(tknOid, mBuf)
+S16 cmPkTknOid(tknOid, mBuf)
TknOid *tknOid; /* Object Identifier token */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknS32
+S16 cmPkTknS32
(
TknS32 *tknS32, /* token S32 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknS32(tknS32, mBuf)
+S16 cmPkTknS32(tknS32, mBuf)
TknS32 *tknS32; /* token S32 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkHeader
+S16 cmPkHeader
(
Header *header, /* header */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkHeader(header, mBuf)
+S16 cmPkHeader(header, mBuf)
Header *header; /* header */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmStatus
+S16 cmPkCmStatus
(
CmStatus *sta, /* status structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmStatus(sta, mBuf)
+S16 cmPkCmStatus(sta, mBuf)
CmStatus *sta; /* status structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmAlarm
+S16 cmPkCmAlarm
(
CmAlarm *alarm, /* alarm structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmAlarm(alarm, mBuf)
+S16 cmPkCmAlarm(alarm, mBuf)
CmAlarm *alarm; /* alarm structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkSmCfg
+S16 cmPkSmCfg
(
SmCfg *smCfg, /* stack manager */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkSmCfg(smCfg, mBuf)
+S16 cmPkSmCfg(smCfg, mBuf)
SmCfg *smCfg; /* stack manager */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTmrCfg
+S16 cmPkTmrCfg
(
TmrCfg *tmrCfg, /* timer configuration */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTmrCfg(tmrCfg, mBuf)
+S16 cmPkTmrCfg(tmrCfg, mBuf)
TmrCfg *tmrCfg; /* timer configuration */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknBuf
+S16 cmPkTknBuf
(
TknBuf *tknBuf, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknBuf(tknBuf, mBuf)
+S16 cmPkTknBuf(tknBuf, mBuf)
TknBuf *tknBuf; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkIntf
+S16 cmPkIntf
(
CmIntf *intf, /* interface info */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkIntf(intf, mBuf)
+S16 cmPkIntf(intf, mBuf)
CmIntf *intf; /* interface info */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkDateTime
+S16 cmUnpkDateTime
(
DateTime *dateTime, /* date/time structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkDateTime(dateTime, mBuf)
+S16 cmUnpkDateTime(dateTime, mBuf)
DateTime *dateTime; /* date/time structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkDuration
+S16 cmUnpkDuration
(
Duration *duration, /* duration structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkDuration(duration, mBuf)
+S16 cmUnpkDuration(duration, mBuf)
Duration *duration; /* duration structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduUnpackPointer
+S16 oduUnpackPointer
(
PTR *ptr, /* duration structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduUnpackPointer(ptr, mBuf)
+S16 oduUnpackPointer(ptr, mBuf)
PTR *ptr; /* duration structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkEntityId
+S16 cmUnpkEntityId
(
EntityId *entityId, /* entity id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkEntityId(entityId, mBuf)
+S16 cmUnpkEntityId(entityId, mBuf)
EntityId *entityId; /* entity id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkElmntId
+S16 cmUnpkElmntId
(
ElmntId *elmntId, /* element id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkElmntId(elmntId, mBuf)
+S16 cmUnpkElmntId(elmntId, mBuf)
ElmntId *elmntId; /* element id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkMemoryId
+S16 cmUnpkMemoryId
(
MemoryId *memoryId, /* memoryId */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkMemoryId(memoryId, mBuf)
+S16 cmUnpkMemoryId(memoryId, mBuf)
MemoryId *memoryId; /* memoryId */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkSystemId
+S16 cmUnpkSystemId
(
SystemId *systemId, /* system id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkSystemId(systemId, mBuf)
+S16 cmUnpkSystemId(systemId, mBuf)
SystemId *systemId; /* system id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkProtAddr
+S16 cmUnpkProtAddr
(
ProtAddr *pAddr, /* protocol address */
Buffer *mBuf /* buffer */
)
#else
-PUBLIC S16 cmUnpkProtAddr(pAddr, mBuf)
+S16 cmUnpkProtAddr(pAddr, mBuf)
ProtAddr *pAddr; /* protocol address table */
Buffer *mBuf; /* buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkProtAddrTbl
+S16 cmUnpkProtAddrTbl
(
ProtAddrTbl *protAddr, /* protocol address table */
Buffer *mBuf /* buffer */
)
#else
-PUBLIC S16 cmUnpkProtAddrTbl(protAddr, mBuf)
+S16 cmUnpkProtAddrTbl(protAddr, mBuf)
ProtAddrTbl *protAddr; /* protocol address table */
Buffer *mBuf; /* buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkAddrs
+S16 cmUnpkAddrs
(
Addrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkAddrs(addrs, mBuf)
+S16 cmUnpkAddrs(addrs, mBuf)
Addrs *addrs; /* address */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkShrtAddrs
+S16 cmUnpkShrtAddrs
(
ShrtAddrs *addrs, /* address */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkShrtAddrs(addrs, mBuf)
+S16 cmUnpkShrtAddrs(addrs, mBuf)
ShrtAddrs *addrs; /* address */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkAddrMask
+S16 cmUnpkAddrMask
(
U8 *mask, /* pointer to address mask */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkAddrMask(mask, mBuf)
+S16 cmUnpkAddrMask(mask, mBuf)
U8 *mask; /* pointer to address mask */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkBndCfg
+S16 cmUnpkBndCfg
(
BndCfg *bndCfg, /* bndCfg */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkBndCfg(bndCfg, mBuf)
+S16 cmUnpkBndCfg(bndCfg, mBuf)
BndCfg *bndCfg; /* bndCfg */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkPst
+S16 cmUnpkPst
(
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPst(pst, mBuf)
+S16 cmUnpkPst(pst, mBuf)
Pst *pst;
Buffer *mBuf;
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkElmtHdr
+S16 cmUnpkElmtHdr
(
ElmtHdr *m, /* element header */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkElmtHdr(m, mBuf)
+S16 cmUnpkElmtHdr(m, mBuf)
ElmtHdr *m; /* element header */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknU8
+S16 cmUnpkTknU8
(
TknU8 *tknU8, /* token U8 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknU8(tknU8, mBuf)
+S16 cmUnpkTknU8(tknU8, mBuf)
TknU8 *tknU8; /* token U8 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknS8
+S16 cmUnpkTknS8
(
TknS8 *tknS8, /* token S8 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknS8(tknS8, mBuf)
+S16 cmUnpkTknS8(tknS8, mBuf)
TknS8 *tknS8; /* token S8 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknU16
+S16 cmUnpkTknU16
(
TknU16 *tknU16, /* token U16 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknU16(tknU16, mBuf)
+S16 cmUnpkTknU16(tknU16, mBuf)
TknU16 *tknU16; /* token U16 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknU32
+S16 cmUnpkTknU32
(
TknU32 *tknU32, /* token U32 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknU32(tknU32, mBuf)
+S16 cmUnpkTknU32(tknU32, mBuf)
TknU32 *tknU32; /* token U32 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr
+S16 cmUnpkTknStr
(
TknStr *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr(tknStr, mBuf)
+S16 cmUnpkTknStr(tknStr, mBuf)
TknStr *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrM
+S16 cmUnpkTknStrM
(
TknStrM *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStrM(tknStr, mBuf)
+S16 cmUnpkTknStrM(tknStr, mBuf)
TknStrM *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrS
+S16 cmUnpkTknStrS
(
TknStrS *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStrS(tknStr, mBuf)
+S16 cmUnpkTknStrS(tknStr, mBuf)
TknStrS *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrE
+S16 cmUnpkTknStrE
(
TknStrE *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStrE(tknStr, mBuf)
+S16 cmUnpkTknStrE(tknStr, mBuf)
TknStrE *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkPnNodeId
+S16 cmUnpkPnNodeId
(
PnNodeId *dst, /* source PNNI Node Id */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkPnNodeId (dst, mBuf)
+S16 cmUnpkPnNodeId (dst, mBuf)
PnNodeId *dst; /* source PNNI Node Id */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr4
+S16 cmUnpkTknStr4
(
TknStr4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr4(tknStr, mBuf)
+S16 cmUnpkTknStr4(tknStr, mBuf)
TknStr4 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr12
+S16 cmUnpkTknStr12
(
TknStr12 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr12(tknStr, mBuf)
+S16 cmUnpkTknStr12(tknStr, mBuf)
TknStr12 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr32
+S16 cmUnpkTknStr32
(
TknStr32 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr32(tknStr, mBuf)
+S16 cmUnpkTknStr32(tknStr, mBuf)
TknStr32 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr64
+S16 cmUnpkTknStr64
(
TknStr64 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr64(tknStr, mBuf)
+S16 cmUnpkTknStr64(tknStr, mBuf)
TknStr64 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr132
+S16 cmUnpkTknStr132
(
TknStr132 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr132(tknStr, mBuf)
+S16 cmUnpkTknStr132(tknStr, mBuf)
TknStr132 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr256
+S16 cmUnpkTknStr256
(
TknStr256 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr256(tknStr, mBuf)
+S16 cmUnpkTknStr256(tknStr, mBuf)
TknStr256 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknOid
+S16 cmUnpkTknOid
(
TknOid *tknOid, /* Object Identifier token */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknOid(tknOid, mBuf)
+S16 cmUnpkTknOid(tknOid, mBuf)
TknOid *tknOid; /* Object Identifier token */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknS32
+S16 cmUnpkTknS32
(
TknS32 *tknS32, /* token S32 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknS32(tknS32, mBuf)
+S16 cmUnpkTknS32(tknS32, mBuf)
TknS32 *tknS32; /* token S32 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkHeader
+S16 cmUnpkHeader
(
Header *header, /* header structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkHeader(header, mBuf)
+S16 cmUnpkHeader(header, mBuf)
Header *header; /* header structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmStatus
+S16 cmUnpkCmStatus
(
CmStatus *sta, /* status structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmStatus(sta, mBuf)
+S16 cmUnpkCmStatus(sta, mBuf)
CmStatus *sta; /* status structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmAlarm
+S16 cmUnpkCmAlarm
(
CmAlarm *alarm, /* alarm structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmAlarm(alarm, mBuf)
+S16 cmUnpkCmAlarm(alarm, mBuf)
CmAlarm *alarm; /* alarm structure */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkSmCfg
+S16 cmUnpkSmCfg
(
SmCfg *smCfg, /* stack manager */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkSmCfg(smCfg, mBuf)
+S16 cmUnpkSmCfg(smCfg, mBuf)
SmCfg *smCfg; /* stack manager */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTmrCfg
+S16 cmUnpkTmrCfg
(
TmrCfg *tmrCfg, /* timer configuration */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTmrCfg(tmrCfg, mBuf)
+S16 cmUnpkTmrCfg(tmrCfg, mBuf)
TmrCfg *tmrCfg; /* timer configuration */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknBuf
+S16 cmUnpkTknBuf
(
TknBuf *tknBuf, /* token string */
Buffer **tBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknBuf(tknBuf, tBuf)
+S16 cmUnpkTknBuf(tknBuf, tBuf)
TknBuf *tknBuf; /* token string */
Buffer **tBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkIntf
+S16 cmUnpkIntf
(
CmIntf *intf, /* interface info */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkIntf(intf, mBuf)
+S16 cmUnpkIntf(intf, mBuf)
CmIntf *intf; /* interface info */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmHashListInit
+S16 cmHashListInit
(
CmHashListCp *hashListCp, /* hash list to initialize */
U16 nmbBins, /* number of hash list bins */
Pool pool /* memory pool to allocate bins */
)
#else
-PUBLIC S16 cmHashListInit(hashListCp, nmbBins, offset, dupFlg, keyType, region, pool)
+S16 cmHashListInit(hashListCp, nmbBins, offset, dupFlg, keyType, region, pool)
CmHashListCp *hashListCp; /* hash list to initialize */
U16 nmbBins; /* number of hash list bins */
U16 offset; /* offset of CmHashListEnt in entries */
*
*/
#ifdef ANSI
-PUBLIC S16 cmHashListDeinit
+S16 cmHashListDeinit
(
CmHashListCp *hashListCp /* hash list to deinitialize */
)
#else
-PUBLIC S16 cmHashListDeinit(hashListCp)
+S16 cmHashListDeinit(hashListCp)
CmHashListCp *hashListCp; /* hash list to deinitialize */
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 cmHashListInsert
+S16 cmHashListInsert
(
CmHashListCp *hashListCp, /* hash list to add to */
PTR entry, /* entry to add */
U16 keyLen /* length of key */
)
#else
-PUBLIC S16 cmHashListInsert(hashListCp, entry, key, keyLen)
+S16 cmHashListInsert(hashListCp, entry, key, keyLen)
CmHashListCp *hashListCp; /* hash list to add to */
PTR entry; /* entry to add */
U8 *key; /* pointer to key */
*/
#ifdef ANSI
-PUBLIC S16 cmHashListDelete
+S16 cmHashListDelete
(
CmHashListCp *hashListCp, /* hash list to delete from */
PTR entry /* entry to delete */
)
#else
-PUBLIC S16 cmHashListDelete(hashListCp, entry)
+S16 cmHashListDelete(hashListCp, entry)
CmHashListCp *hashListCp; /* hash list to delete from */
PTR entry; /* entry to delete */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmHashListFind
+S16 cmHashListFind
(
CmHashListCp *hashListCp, /* hash list to search */
U8 *key, /* pointer to key */
PTR *entry /* entry to be returned */
)
#else
-PUBLIC S16 cmHashListFind(hashListCp, key, keyLen, seqNmb, entry)
+S16 cmHashListFind(hashListCp, key, keyLen, seqNmb, entry)
CmHashListCp *hashListCp; /* hash list to search */
U8 *key; /* pointer to key */
U16 keyLen; /* length of key */
*
*/
#ifdef ANSI
-PUBLIC S16 cmHashListGetNext
+S16 cmHashListGetNext
(
CmHashListCp *hashListCp, /* hash list to get from */
PTR prevEnt, /* previous entry */
PTR *entry /* entry to be returned */
)
#else
-PUBLIC S16 cmHashListGetNext(hashListCp, prevEnt, entry)
+S16 cmHashListGetNext(hashListCp, prevEnt, entry)
CmHashListCp *hashListCp; /* hash list to get from */
PTR prevEnt; /* previous entry */
PTR *entry; /* entry to be returned */
*
*/
#ifdef ANSI
-PUBLIC S16 cmHashListBinGetNextEntry
+S16 cmHashListBinGetNextEntry
(
CmHashListCp *hashListCp, /* hash list to get from */
U16 binIdx, /* Bin Index to retreive the entry */
PTR *entry /* entry to be returned */
)
#else
-PUBLIC S16 cmHashListBinGetNextEntry(hashListCp, binIdx, prevEnt, entry)
+S16 cmHashListBinGetNextEntry(hashListCp, binIdx, prevEnt, entry)
CmHashListCp *hashListCp; /* hash list to get from */
U16 binIdx; /* Bin Index to retreive the entry */
PTR prevEnt; /* previous entry */
*
*/
#ifdef ANSI
-PUBLIC S16 cmHashListQuery
+S16 cmHashListQuery
(
CmHashListCp *hashListCp, /* hash list to query */
U8 queryType, /* type of query */
U16 *result /* result of query */
)
#else
-PUBLIC S16 cmHashListQuery(hashListCp, queryType, result)
+S16 cmHashListQuery(hashListCp, queryType, result)
CmHashListCp *hashListCp; /* hash list to query */
U8 queryType; /* type of query */
U16 *result; /* result of query */
*/
#ifdef ANSI
-PUBLIC S16 cmHashListOAInsert
+S16 cmHashListOAInsert
(
CmHashListCp *hashListCp, /* hash table to add to */
PTR entry, /* entry to add */
U16 keyLen /* length of key */
)
#else
-PUBLIC S16 cmHashListOAInsert(hashListCp, entry, key, keyLen)
+S16 cmHashListOAInsert(hashListCp, entry, key, keyLen)
CmHashListCp *hashListCp; /* hash table to add to */
PTR entry; /* entry to add */
U8 *key; /* pointer to key */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPoll
+S16 cmInetPoll
(
CmInetPollFd *pollFdArr, /* poll FD Array */
U32 numFds, /* Number of Fds to be monitored */
U32 timeout /* timeout value for Poll */
)
#else
-PUBLIC S16 cmInetPoll(pollFdArr,numFds,numRdyFds,timeout)
+S16 cmInetPoll(pollFdArr,numFds,numRdyFds,timeout)
CmInetPollFd *pollFdArr; /* poll FD Array */
U32 numFds; /* Number of Fds to be monitored */
S16 *numRdyFds; /* number of ready descriptors */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPollSetFd
+S16 cmInetPollSetFd
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetPollFd *pollFdArr, /* poll FD Array */
U16 eventMask /* Event Mask to be set */
)
#else
-PUBLIC S16 cmInetPollSetFd(sockFd,pollFdArr,idx,eventMask)
+S16 cmInetPollSetFd(sockFd,pollFdArr,idx,eventMask)
CmInetFd *sockFd; /* socket file descriptor */
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPollFdIsSet
+S16 cmInetPollFdIsSet
(
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 idx, /* poll Fd Array Index */
U16 eventMask /* Event Mask to be set */
)
#else
-PUBLIC S16 cmInetPollFdIsSet(pollFdArr,idx,eventMask)
+S16 cmInetPollFdIsSet(pollFdArr,idx,eventMask)
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
U16 eventMask; /* Event Mask to be set */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPollClearFdREvent
+S16 cmInetPollClearFdREvent
(
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 idx, /* poll Fd Array Index */
U16 eventMask /* Event Mask to be set */
)
#else
-PUBLIC S16 cmInetPollClearFdREvent(sockFd,pollFdArr,eventMask)
+S16 cmInetPollClearFdREvent(sockFd,pollFdArr,eventMask)
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
U16 eventMask; /* Event Mask to be set */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPollClearFdEvent
+S16 cmInetPollClearFdEvent
(
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 idx, /* poll Fd Array Index */
U16 eventMask /* Event Mask to be set */
)
#else
-PUBLIC S16 cmInetPollClearFdEvent(sockFd,pollFdArr,eventMask)
+S16 cmInetPollClearFdEvent(sockFd,pollFdArr,eventMask)
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
U16 eventMask; /* Event Mask to be set */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPollDelFd
+S16 cmInetPollDelFd
(
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 delIdx, /* poll Fd Array Index for which fd has to be deleted*/
S16 lastIdx /* Last index of poll Fd Array */
)
#else
-PUBLIC S16 cmInetPollDelFd(pollFdArr, delIdx, lastIdx)
+S16 cmInetPollDelFd(pollFdArr, delIdx, lastIdx)
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 delIdx; /* poll Fd Array Index for which fd has to be deleted*/
S16 lastIdx; /* Last index of poll Fd Array */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPollInitFdArr
+S16 cmInetPollInitFdArr
(
CmInetPollFd *pollFdArr /* poll FD Array */
)
#else
-PUBLIC S16 cmInetPollInitFdArr(pollFdArr)
+S16 cmInetPollInitFdArr(pollFdArr)
CmInetPollFd *pollFdArr; /* poll FD Array */
#endif
{
#ifdef ANSI
#ifdef CM_INET2
#ifdef IPV6_SUPPORTED
-PUBLIC S16 cmInetSocket
+S16 cmInetSocket
(
U8 type, /* socket type */
CmInetFd *sockFd, /* socket file descriptor */
U8 domain /* domain */
)
#else
-PUBLIC S16 cmInetSocket
+S16 cmInetSocket
(
U8 type, /* socket type */
CmInetFd *sockFd, /* socket file descriptor */
)
#endif /* IPV6_SUPPORTED */
#else /* CM_INET2 */
-PUBLIC S16 cmInetSocket
+S16 cmInetSocket
(
U8 type, /* socket type */
CmInetFd *sockFd /* socket file descriptor */
#else
#ifdef CM_INET2
#ifdef IPV6_SUPPORTED
-PUBLIC S16 cmInetSocket(type, sockFd, protocol, domain)
+S16 cmInetSocket(type, sockFd, protocol, domain)
U8 type; /* socket type */
CmInetFd *sockFd; /* socket file descriptor */
U8 protocol; /* protocol value */
U8 domain; /* domain */
#else
-PUBLIC S16 cmInetSocket(type, sockFd, protocol)
+S16 cmInetSocket(type, sockFd, protocol)
U8 type; /* socket type */
CmInetFd *sockFd; /* socket file descriptor */
U8 protocol; /* protocol value */
#endif /* IPV6_SUPPORTED */
#else /* CM_INET2 */
-PUBLIC S16 cmInetSocket(type, sockFd)
+S16 cmInetSocket(type, sockFd)
U8 type; /* socket type */
CmInetFd *sockFd; /* socket file descriptor */
#endif /* CM_INET2 */
*/
#ifdef ANSI
-PUBLIC S16 cmInetBind
+S16 cmInetBind
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *myAddr /* locale Internet address/port */
)
#else
-PUBLIC S16 cmInetBind(sockFd, myAddr)
+S16 cmInetBind(sockFd, myAddr)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *myAddr; /* locale Internet address/port */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetSctpBindx
+S16 cmInetSctpBindx
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddrLst *addrLst, /* local Internet address list */
U16 port /* port number */
)
#else
-PUBLIC S16 cmInetSctpBindx(sockFd, addrLst, port)
+S16 cmInetSctpBindx(sockFd, addrLst, port)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddrLst *addrLst; /* locale Internet address list */
U16 port; /* port number */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetSctpConnectx
+S16 cmInetSctpConnectx
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddr *primAddr, /* primary destination Internet address */
U16 port /* port number */
)
#else
-PUBLIC S16 cmInetSctpConnectx(sockFd, primAddr, addrLst, port)
+S16 cmInetSctpConnectx(sockFd, primAddr, addrLst, port)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddr *primAddr; /* primary destination Internet address */
CmInetNetAddrLst *addrLst; /* destination Internet address list */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetSctpPeelOff
+S16 cmInetSctpPeelOff
(
CmInetFd *sockFd, /* socket file descriptor */
U32 assocId, /* association id */
CmInetFdType *assocFd /* association fd */
)
#else
-PUBLIC S16 cmInetSctpPeelOff(sockFd, assocId, assocFd)
+S16 cmInetSctpPeelOff(sockFd, assocId, assocFd)
CmInetFd *sockFd; /* socket file descriptor */
U32 assocId; /* association id */
CmInetFdType *assocFd; /* association fd */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetSctpSendMsg
+S16 cmInetSctpSendMsg
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddr *dstAddr, /* destination Internet address/port */
U32 context /* value to be passed back, if error occurs */
)
#else
-PUBLIC S16 cmInetSctpSendMsg(sockFd, dstAddr, port, info, mBuf, len, strmId,
+S16 cmInetSctpSendMsg(sockFd, dstAddr, port, info, mBuf, len, strmId,
unorderFlg, ttl, ppId, context)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddr *dstAddr; /* destination Internet address/port */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetSctpRecvMsg
+S16 cmInetSctpRecvMsg
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddr *srcAddr, /* source Internet address/port */
CmInetSctpNotification *ntfy /* notification parameters */
)
#else
-PUBLIC S16 cmInetSctpRecvMsg(sockFd, srcAddr, port, meminfo, mBuf, len,
+S16 cmInetSctpRecvMsg(sockFd, srcAddr, port, meminfo, mBuf, len,
sinfo, flag, ntfy)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddr *srcAddr; /* source Internet address/port */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetSctpGetPAddrs
+S16 cmInetSctpGetPAddrs
(
CmInetFd *sockFd, /* socket file descriptor */
U32 assocId, /* association id */
CmInetNetAddrLst *addrlst /* peer address list */
)
#else
-PUBLIC S16 cmInetSctpGetPAddrs(sockFd, assocId, addrlst)
+S16 cmInetSctpGetPAddrs(sockFd, assocId, addrlst)
CmInetFd *sockFd; /* socket file descriptor */
U32 assocId; /* association id */
CmInetNetAddrLst *addrlst; /* peer address list */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetGetOpt
+S16 cmInetGetOpt
(
CmInetFd *sockFd, /* socket file descriptor */
U32 level, /* option level */
Ptr value /* option value */
)
#else
-PUBLIC S16 cmInetGetOpt(sockFd, level, type, value)
+S16 cmInetGetOpt(sockFd, level, type, value)
CmInetFd *sockFd; /* socket file descriptor */
U32 level; /* option level */
U32 type; /* option type */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetShutDownSctp
+S16 cmInetShutDownSctp
(
CmInetFd *sockFd /* socket file descriptor */
)
#else
-PUBLIC S16 cmInetShutDownSctp(sockFd)
+S16 cmInetShutDownSctp(sockFd)
CmInetFd *sockFd; /* socket file descriptor */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetAbortSctpAssoc
+S16 cmInetAbortSctpAssoc
(
CmInetFd *sockFd, /* socket file descriptor */
UConnId assocId /* Association ID */
)
#else
-PUBLIC S16 cmInetAbortSctpAssoc(sockFd, assocId)
+S16 cmInetAbortSctpAssoc(sockFd, assocId)
CmInetFd *sockFd; /* socket file descriptor */
UConnId assocId; /* Association ID */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetConnect
+S16 cmInetConnect
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *servAddr /* foreign Internet address/port */
)
#else
-PUBLIC S16 cmInetConnect(sockFd, servAddr)
+S16 cmInetConnect(sockFd, servAddr)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *servAddr; /* foreign Internet address/port */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetListen
+S16 cmInetListen
(
CmInetFd *sockFd, /* socket file descriptor */
S16 backLog /* max. number of outstandig connections 0..5 */
)
#else
-PUBLIC S16 cmInetListen(sockFd, backLog)
+S16 cmInetListen(sockFd, backLog)
CmInetFd *sockFd; /* socket file descriptor */
S16 backLog; /* max. number of outstandig connections 0..5 */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetAccept
+S16 cmInetAccept
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *fromAddr, /* calling Internet address/port */
CmInetFd *newSockFd /* socket file descriptor for new connection*/
)
#else
-PUBLIC S16 cmInetAccept(sockFd, fromAddr, newSockFd)
+S16 cmInetAccept(sockFd, fromAddr, newSockFd)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *fromAddr; /* calling Internet address/port */
CmInetFd *newSockFd; /* socket file descriptor for new connection*/
*/
#ifdef ANSI
-PUBLIC S16 cmInetSendDscpMsg
+S16 cmInetSendDscpMsg
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *dstAddr, /* destination Internet address/port */
)
#else
/* added for IPv6 ext hdr */
-PUBLIC S16 cmInetSendDscpMsg(sockFd, dstAddr, info, mBuf, len, ipHdrParams, flags)
+S16 cmInetSendDscpMsg(sockFd, dstAddr, info, mBuf, len, ipHdrParams, flags)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *dstAddr; /* destination Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
*/
#ifdef ANSI
-PUBLIC S16 cmInetSendMsg
+S16 cmInetSendMsg
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *dstAddr, /* destination Internet address/port */
#else
/* added for IPv6 ext hdr */
#ifdef IPV6_OPTS_SUPPORTED
-PUBLIC S16 cmInetSendMsg(sockFd, dstAddr, info, mBuf, len, ipHdrParams, flags)
+S16 cmInetSendMsg(sockFd, dstAddr, info, mBuf, len, ipHdrParams, flags)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *dstAddr; /* destination Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
CmInetIpHdrParm *ipHdrParams; /* IPv6 extensions headers */
S16 flags; /* additional control flags, unused */
#else
-PUBLIC S16 cmInetSendMsg(sockFd, dstAddr, info, mBuf, len, flags)
+S16 cmInetSendMsg(sockFd, dstAddr, info, mBuf, len, flags)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *dstAddr; /* destination Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetRecvMsg
+S16 cmInetRecvMsg
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *fromAddr, /* sender Internet address/port */
/* added for IPv6 */
#ifdef IPV6_OPTS_SUPPORTED
#ifdef LOCAL_INTF
-PUBLIC S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len,
+S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len,
ipHdrParams, localIf, flags)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *fromAddr; /* sender Internet address/port */
CmInetLocalInf *localIf; /* local interface on which pkt was recvd */
S32 flags; /* additional control flags */
#else
-PUBLIC S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len, ipHdrParams, flags)
+S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len, ipHdrParams, flags)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *fromAddr; /* sender Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
#endif /* LOCAL_INTF */
#else
#ifdef LOCAL_INTF
-PUBLIC S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len, localIf, flags)
+S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len, localIf, flags)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *fromAddr; /* sender Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
CmInetLocalInf *localIf; /* local interface on which pkt was recvd */
S32 flags; /* additional control flags */
#else
-PUBLIC S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len, flags)
+S16 cmInetRecvMsg(sockFd, fromAddr, info, mPtr, len, flags)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *fromAddr; /* sender Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPeekNew
+S16 cmInetPeekNew
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *fromAddr, /* sender Internet address/port */
Data *data /* read data */
)
#else
-PUBLIC S16 cmInetPeekNew(sockFd, fromAddr, info, dataPos, dataLen, data)
+S16 cmInetPeekNew(sockFd, fromAddr, info, dataPos, dataLen, data)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *fromAddr; /* sender Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPeek
+S16 cmInetPeek
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *fromAddr, /* sender Internet address/port */
Data *data /* read data */
)
#else
-PUBLIC S16 cmInetPeek(sockFd, fromAddr, info, dataPos, dataLen, data)
+S16 cmInetPeek(sockFd, fromAddr, info, dataPos, dataLen, data)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *fromAddr; /* sender Internet address/port */
CmInetMemInfo *info; /* buffer allocation info */
*/
#ifdef ANSI
-PUBLIC S16 cmInetClose
+S16 cmInetClose
(
CmInetFd *sockFd /* socket file descriptor */
)
#else
-PUBLIC S16 cmInetClose(sockFd)
+S16 cmInetClose(sockFd)
CmInetFd *sockFd; /* socket file descriptor */
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 cmInetShutdown
+S16 cmInetShutdown
(
CmInetFd *sockFd, /* socket file descriptor */
S32 howTo /* operation flag */
)
#else
-PUBLIC S16 cmInetShutdown(sockFd, howTo)
+S16 cmInetShutdown(sockFd, howTo)
CmInetFd *sockFd; /* socket file descriptor */
S32 howTo; /* operation flag */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetSelect
+S16 cmInetSelect
(
CmInetFdSet *readFdS, /* read socket descriptor file set */
CmInetFdSet *writeFdS, /* write socket descriptor file set */
S16 *numFdS /* number of ready descriptors */
)
#else
-PUBLIC S16 cmInetSelect(readFdS, writeFdS, mSecTimeout, numFdS)
+S16 cmInetSelect(readFdS, writeFdS, mSecTimeout, numFdS)
CmInetFdSet *readFdS; /* read socket descriptor file set */
CmInetFdSet *writeFdS; /* write socket descriptor file set */
U32 *mSecTimeout; /* timeout in msecs */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetSetOpt
+S16 cmInetSetOpt
(
CmInetFd *sockFd, /* socket file descriptor */
U32 level, /* option level */
Ptr value /* option value */
)
#else
-PUBLIC S16 cmInetSetOpt(sockFd, level, type, value)
+S16 cmInetSetOpt(sockFd, level, type, value)
CmInetFd *sockFd; /* socket file descriptor */
U32 level; /* option level */
U32 type; /* option type */
*/
#ifdef ANSI
-PUBLIC S16 cmInetGetNumRead
+S16 cmInetGetNumRead
(
CmInetFd *sockFd, /* socket file descriptor */
U32 *dataLen /* number of pending octets */
/* removed 3rd argument memInfo */
)
#else
-PUBLIC S16 cmInetGetNumRead(sockFd, dataLen)
+S16 cmInetGetNumRead(sockFd, dataLen)
CmInetFd *sockFd; /* socket file descriptor */
U32 *dataLen; /* number of pending octets */
/* removed 3rd argument memInfo */
*/
#ifdef ANSI
-PUBLIC S16 cmInetGetHostByName
+S16 cmInetGetHostByName
(
S8 *hostName, /* host name */
CmInetIpAddrTbl *addrTbl /* Address Table of IPV4 Addresses */
)
#else
-PUBLIC S16 cmInetGetHostByName (hostName, addrTbl)
+S16 cmInetGetHostByName (hostName, addrTbl)
S8 *hostName; /* host name */
CmInetIpAddrTbl *addrTbl; /* Address Table of IPV4 Addresses */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetGetIpNodeByName
+S16 cmInetGetIpNodeByName
(
S8 *hostName, /* host name */
CmInetIpAddrArr *addrArr /* Array of addressed filled in */
)
#else
-PUBLIC S16 cmInetGetIpNodeByName(hostName, addrArr)
+S16 cmInetGetIpNodeByName(hostName, addrArr)
S8 *hostName; /* host name */
CmInetIpAddrArr *addrArr; /* Array of addressed filled in */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetAddr(
+S16 cmInetAddr(
S8 *asciiAddr, /* ascii address representation */
CmInetIpAddr *address /* 4 byte interent address */
)
#else
-PUBLIC S16 cmInetAddr(asciiAddr, address)
+S16 cmInetAddr(asciiAddr, address)
S8 *asciiAddr; /* ascii address representation */
CmInetIpAddr *address; /* 4 byte interent address */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetNtoa(
+S16 cmInetNtoa(
CmInetIpAddr address, /* 4 byte interent address */
S8 **asciiAddr /* ascii address representation */
)
#else
-PUBLIC S16 cmInetNtoa(address, asciiAddr)
+S16 cmInetNtoa(address, asciiAddr)
CmInetIpAddr address; /* 4 byte interent address */
S8 **asciiAddr; /* ascii address representation */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetNtop(
+S16 cmInetNtop(
U8 type, /* ip address type */
Void *address, /* 4/16 byte interent address */
S8 *asciiAddr, /* ascii adress representation */
U32 len
)
#else
-PUBLIC S16 cmInetNtop(type,address, asciiAddr,len)
+S16 cmInetNtop(type,address, asciiAddr,len)
U8 type; /* ip address type */
Void *address; /* 4/16 byte interent address */
S8 *asciiAddr; /* ascii adress representation */
*/
#ifdef ANSI
-PUBLIC S16 cmInetPton(
+S16 cmInetPton(
CmInetIpAddr *address, /* 4 byte interent address */
S8 *asciiAddr /* ascii address representation */
)
#else
-PUBLIC S16 cmInetPton(address, asciiAddr)
+S16 cmInetPton(address, asciiAddr)
CmInetIpAddr *address; /* 4 byte interent address */
S8 *asciiAddr; /* ascii address representation */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetPton6(
+S16 cmInetPton6(
CmInetIpAddr6 *address6, /* 16 byte interent address */
S8 *asciiAddr /* ascii address representation */
)
#else
-PUBLIC S16 cmInetPton6(address6, asciiAddr)
+S16 cmInetPton6(address6, asciiAddr)
CmInetIpAddr6 *address6; /* 16 byte interent address */
S8 *asciiAddr; /* ascii address representation */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmInetGetMemSize(
+S16 cmInetGetMemSize(
S32 *size /* max used memory size */
)
#else
-PUBLIC S16 cmInetGetMemSize(size)
+S16 cmInetGetMemSize(size)
S32 *size; /* max used memory size */
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 cmInetInit(
+S16 cmInetInit(
Void
)
#else
-PUBLIC S16 cmInetInit(Void)
+S16 cmInetInit(Void)
#endif
{
#ifdef WIN32
*/
#ifdef ANSI
-PUBLIC S16 cmInetDeInit(
+S16 cmInetDeInit(
Void
)
#else
-PUBLIC S16 cmInetDeInit(Void)
+S16 cmInetDeInit(Void)
#endif
{
#ifdef WIN32
*/
\f
#ifdef ANSI
-PUBLIC S16 cmInetGetSockName
+S16 cmInetGetSockName
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetAddr *locAddr
)
#else
-PUBLIC S16 cmInetGetSockName(sockFd, locAddr)
+S16 cmInetGetSockName(sockFd, locAddr)
CmInetFd *sockFd; /* socket file descriptor */
CmInetAddr *locAddr;
#endif
*/
\f
#ifdef ANSI
-PUBLIC S16 cmInetFdSetInfoInit
+S16 cmInetFdSetInfoInit
(
CmInetFdSetInfo *fdSetInfo
)
#else
-PUBLIC S16 cmInetFdSetInfoInit(fdSetInfo)
+S16 cmInetFdSetInfoInit(fdSetInfo)
CmInetFdSetInfo *fdSetInfo;
#endif
{
*/
\f
#ifdef ANSI
-PUBLIC S16 cmInetGetFd
+S16 cmInetGetFd
(
CmInetFdSetInfo *fdSetInfo,
CmInetFdSet *fdSet,
CmInetFdType *sockFd
)
#else
-PUBLIC S16 cmInetGetFd(fdSetInfo, fdSet, sockFd)
+S16 cmInetGetFd(fdSetInfo, fdSet, sockFd)
CmInetFdSetInfo *fdSetInfo;
CmInetFdSet *fdSet;
CmInetFdType *sockFd;
*/
#ifdef ANSI
-PUBLIC S16 cmInetConvertStrToIpAddr
+S16 cmInetConvertStrToIpAddr
(
U16 len, /* Length of IP address */
U8 *val, /* Domain Name String */
CmInetNetAddr *address /* IP Address */
)
#else
-PUBLIC S16 cmInetConvertStrToIpAddr(len, val, address)
+S16 cmInetConvertStrToIpAddr(len, val, address)
U16 len; /* Length of IP address */
U8 *val; /* Domain Name String */
CmInetNetAddr *address; /* IP Address */
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetAsciiToIpv4
+S16 cmInetAsciiToIpv4
(
U8 numBytes, /* number of Byte to convert */
U8 *ipv4Addr, /* IPV4 Address */
U8 *val /* Domain Name String */
)
#else
-PUBLIC S16 cmInetAsciiToIpv4(numBytes, ipv4Addr, len, val)
+S16 cmInetAsciiToIpv4(numBytes, ipv4Addr, len, val)
U8 numBytes; /* number of Byte to convert */
U8 *ipv4Addr; /* IPV4 Address */
U16 len; /* Length of IP address */
*/
#ifdef ANSI
-PUBLIC S32 cmInetGetAddrInfo
+S32 cmInetGetAddrInfo
(
CONSTANT S8 *node, /* Network addr which has to be resolved */
CONSTANT S8 *service, /* Sets the port number in network addr */
CmInetAddrInfo **res /* Link list of addrInfo structure */
)
#else
-PUBLIC S32 cmInetGetAddrInfo(node,service,hints,res)
+S32 cmInetGetAddrInfo(node,service,hints,res)
CONSTANT S8 *node; /* Network addr which has to be resolved */
CONSTANT S8 *service; /* Sets the port number in network addr */
CONSTANT CmInetAddrInfo *hints; /* Specifies preferred socket type or protocol */
*/
#ifdef ANSI
-PUBLIC Void cmInetFreeAddrInfo
+Void cmInetFreeAddrInfo
(
CmInetAddrInfo *res /* Link list of addrInfo structure */
)
#else
-PUBLIC Void cmInetFreeAddrInfo(res)
+Void cmInetFreeAddrInfo(res)
CmInetAddrInfo *res; /* Link list of addrInfo structure */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 cmInetFlushRecvBuf
+S16 cmInetFlushRecvBuf
(
CmInetFd *sockFd, /* socket file descriptor */
MsgLen *len, /* number of octects to be flushed */
S32 flags /* additional control flags */
)
#else
-PUBLIC S16 cmInetFlushRecvBuf(sockFd, len, flags)
+S16 cmInetFlushRecvBuf(sockFd, len, flags)
CmInetFd *sockFd; /* socket file descriptor */
MsgLen *len; /* number of octects to be flushed */
S32 flags; /* additional control flags */
*
*/
#ifdef ANSI
-PUBLIC U8 *cmMemcpy
+U8 *cmMemcpy
(
U8 *tgt,
CONSTANT U8 *src,
PTR len
)
#else
-PUBLIC U8 *cmMemcpy(tgt, src, len)
+U8 *cmMemcpy(tgt, src, len)
U8 *tgt;
CONSTANT U8 *src;
PTR len;
*
*/
#ifdef ANSI
-PUBLIC S16 cmMemcmp
+S16 cmMemcmp
(
CONSTANT U8 *s1,
CONSTANT U8 *s2,
PTR len
)
#else
-PUBLIC S16 cmMemcmp (s1, s2, len)
+S16 cmMemcmp (s1, s2, len)
CONSTANT U8 *s1;
CONSTANT U8 *s2;
PTR len;
*
*/
#ifdef ANSI
-PUBLIC U8 *cmMemset
+U8 *cmMemset
(
U8 *str,
U8 val,
PTR len
)
#else
-PUBLIC U8 *cmMemset(str, val, len)
+U8 *cmMemset(str, val, len)
U8 *str;
U8 val;
PTR len;
*
*/
#ifdef ANSI
-PUBLIC S16 cmStrcmp
+S16 cmStrcmp
(
CONSTANT U8 *s1,
CONSTANT U8 *s2
)
#else
-PUBLIC S16 cmStrcmp (s1, s2)
+S16 cmStrcmp (s1, s2)
CONSTANT U8 *s1;
CONSTANT U8 *s2;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmStrncmp
+S16 cmStrncmp
(
CONSTANT U8 *s1,
CONSTANT U8 *s2,
MsgLen len /* cm_lib_c_001.main_12: Changing from S16 to MsgLen.*/
)
#else
-PUBLIC S16 cmStrncmp (s1, s2, len)
+S16 cmStrncmp (s1, s2, len)
CONSTANT U8 *s1;
CONSTANT U8 *s2;
MsgLen len;
*
*/
#ifdef ANSI
-PUBLIC MsgLen cmStrlen
+MsgLen cmStrlen
(
CONSTANT U8 *s
)
#else
/* cm_lib_c_001.main_12: Changing from S16 to MsgLen.*/
-PUBLIC MsgLen cmStrlen (s)
+MsgLen cmStrlen (s)
CONSTANT U8 *s;
#endif
{
extern "C" {
#endif
-PUBLIC U8 *cmMemcpy ARGS((U8 *tgt, CONSTANT U8 *src, PTR len));
-PUBLIC S16 cmMemcmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2, PTR len));
-PUBLIC U8 *cmMemset ARGS((U8 *src, U8 val, PTR len));
+U8 *cmMemcpy ARGS((U8 *tgt, CONSTANT U8 *src, PTR len));
+S16 cmMemcmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2, PTR len));
+U8 *cmMemset ARGS((U8 *src, U8 val, PTR len));
-PUBLIC S16 cmStrcmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2));
+S16 cmStrcmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2));
/* cm_lib_x_001.main_8:Changing from S16 to MsgLen.*/
-PUBLIC S16 cmStrncmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2, MsgLen len));
-PUBLIC MsgLen cmStrlen ARGS((CONSTANT U8 *s));
+S16 cmStrncmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2, MsgLen len));
+MsgLen cmStrlen ARGS((CONSTANT U8 *s));
#ifdef __cplusplus
}
*
*/
#ifdef ANSI
-PUBLIC Void cmLListInit
+Void cmLListInit
(
CmLListCp *lCp /* list control point */
)
#else
-PUBLIC Void cmLListInit(lCp)
+Void cmLListInit(lCp)
CmLListCp *lCp; /* list control point */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void cmLListAdd2Head
+Void cmLListAdd2Head
(
CmLListCp *lCp, /* list control point */
CmLList *node /* node to be added */
)
#else
-PUBLIC Void cmLListAdd2Head(lCp, node)
+Void cmLListAdd2Head(lCp, node)
CmLListCp *lCp; /* list control point */
CmLList *node; /* node to be added */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void cmLListAdd2Tail
+Void cmLListAdd2Tail
(
CmLListCp *lCp, /* list control point */
CmLList *node /* node to be added */
)
#else
-PUBLIC Void cmLListAdd2Tail(lCp, node)
+Void cmLListAdd2Tail(lCp, node)
CmLListCp *lCp; /* list control point */
CmLList *node; /* node to be added */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void cmLListInsCrnt
+Void cmLListInsCrnt
(
CmLListCp *lCp, /* list control point */
CmLList *node /* node to be added */
)
#else
-PUBLIC Void cmLListInsCrnt(lCp, node)
+Void cmLListInsCrnt(lCp, node)
CmLListCp *lCp; /* list control point */
CmLList *node; /* node to be added */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void cmLListInsAfterCrnt
+Void cmLListInsAfterCrnt
(
CmLListCp *lCp, /* list control point */
CmLList *node /* node to be added */
)
#else
-PUBLIC Void cmLListInsAfterCrnt(lCp, node)
+Void cmLListInsAfterCrnt(lCp, node)
CmLListCp *lCp; /* list control point */
CmLList *node; /* node to be added */
#endif
*
*/
#ifdef ANSI
-PUBLIC CmLList *cmLListDelFrm
+CmLList *cmLListDelFrm
(
CmLListCp *lCp, /* list control pointer */
CmLList *node /* node to be removed */
)
#else
-PUBLIC CmLList *cmLListDelFrm(lCp, node)
+CmLList *cmLListDelFrm(lCp, node)
CmLListCp *lCp; /* list control pointer */
CmLList *node; /* node to be removed */
#endif
*
--*/
#ifdef ANSI
-PUBLIC Void cmLListCatLList
+Void cmLListCatLList
(
CmLListCp *list1, /*-- list control point --*/
CmLListCp *list2 /*-- node to be added --*/
)
#else
-PUBLIC Void cmLListCatLList(list1, list2)
+Void cmLListCatLList(list1, list2)
CmLListCp *list1; /*-- list control point --*/
CmLListCp *list2; /*-- node to be added --*/
#endif
/* public variable declarations */
-PUBLIC U32 cmLteTime;
+U32 cmLteTime;
\f
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkLteRlcId
+S16 cmPkLteRlcId
(
CmLteRlcId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkLteRlcId(param, mBuf)
+S16 cmPkLteRlcId(param, mBuf)
CmLteRlcId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkLteRlcId
+S16 cmUnpkLteRlcId
(
CmLteRlcId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLteRlcId(param, mBuf)
+S16 cmUnpkLteRlcId(param, mBuf)
CmLteRlcId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkLteTimingInfo
+S16 cmPkLteTimingInfo
(
CmLteTimingInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkLteTimingInfo(param, mBuf)
+S16 cmPkLteTimingInfo(param, mBuf)
CmLteTimingInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkLteTimingInfo
+S16 cmUnpkLteTimingInfo
(
CmLteTimingInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLteTimingInfo(param, mBuf)
+S16 cmUnpkLteTimingInfo(param, mBuf)
CmLteTimingInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkLtePdcpId
+S16 cmPkLtePdcpId
(
CmLtePdcpId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkLtePdcpId(param, mBuf)
+S16 cmPkLtePdcpId(param, mBuf)
CmLtePdcpId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkLtePdcpId
+S16 cmUnpkLtePdcpId
(
CmLtePdcpId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLtePdcpId(param, mBuf)
+S16 cmUnpkLtePdcpId(param, mBuf)
CmLtePdcpId *param;
Buffer *mBuf;
#endif
}
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC S16 cmUpdateSsiMemInfo
+S16 cmUpdateSsiMemInfo
(
CmLteMemInfo *mInfo
)
#else
-PUBLIC S16 cmUpdateSsiMemInfo(mInfo)
+S16 cmUpdateSsiMemInfo(mInfo)
CmLteMemInfo *mInfo;
#endif
{
}
#ifdef ANSI
-PUBLIC S16 cmFillMemUtilizationMeas
+S16 cmFillMemUtilizationMeas
(
CmLteMemInfo *memoryInfo,
CmLteMemInfo *memInfo
)
#else
-PUBLIC S16 cmFillMemUtilizationMeas(memoryInfo,memInfo)
+S16 cmFillMemUtilizationMeas(memoryInfo,memInfo)
CmLteMemInfo *memoryInfo;
CmLteMemInfo *memInfo;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmClearMemUtilizationCounter
+S16 cmClearMemUtilizationCounter
(
CmLteMemInfo *memInfo
)
#else
-PUBLIC S16 cmClearMemUtilizationCounter(memInfo)
+S16 cmClearMemUtilizationCounter(memInfo)
CmLteMemInfo *memInfo;
#endif
{
}
#ifdef ANSI
-PUBLIC S16 cmClearCpuUtilizationCounter
+S16 cmClearCpuUtilizationCounter
(
CmCpuStatsInfo *cpuInfo
)
#else
-PUBLIC S16 cmClearCpuUtilizationCounter(cpuInfo)
+S16 cmClearCpuUtilizationCounter(cpuInfo)
CmCpuStatsInfo *cpuInfo
#endif
{
}
#ifdef ANSI
-PUBLIC S16 cmFillCpuUtilizationMeas
+S16 cmFillCpuUtilizationMeas
(
CmLteCpuInfo *cpuMeasInfo,
CmCpuStatsInfo *cpuInfo
)
#else
-PUBLIC S16 cmFillCpuUtilizationMeas(cpuMeasInfo,cpuInfo)
+S16 cmFillCpuUtilizationMeas(cpuMeasInfo,cpuInfo)
CmLteCpuInfo *cpuMeasInfo;
CmCpuStatsInfo *cpuInfo;
#endif
CmTtiProc ttiProc;
#define TTI_1MS 950
-PUBLIC Void cmUpdateTtiCounters(U32 ttiProcessingTime)
+Void cmUpdateTtiCounters(U32 ttiProcessingTime)
{
ttiProc.numOfTti++;
ttiProc.totTtiProcessingTime += ttiProcessingTime;
RETVOID;
}
-PUBLIC Void cmResetTtiCounters(Void)
+Void cmResetTtiCounters(Void)
{
ttiProc.totTtiProcessingTime = 0;
ttiProc.numOfTti = 0;
* PACK/UNPACK Functions
***************************************************************************/
-EXTERN PUBLIC S16 cmUpdateSsiMemInfo(CmLteMemInfo *mInfo);
+EXTERN S16 cmUpdateSsiMemInfo(CmLteMemInfo *mInfo);
-EXTERN PUBLIC S16 cmFillMemUtilizationMeas(CmLteMemInfo *memoryInfo,CmLteMemInfo *memInfo);
+EXTERN S16 cmFillMemUtilizationMeas(CmLteMemInfo *memoryInfo,CmLteMemInfo *memInfo);
-EXTERN PUBLIC S16 cmClearMemUtilizationCounter(CmLteMemInfo *memInfo);
-EXTERN PUBLIC S16 UpdateSocMemInfo(U8 area , CmLteMemInfo *mInfo);
+EXTERN S16 cmClearMemUtilizationCounter(CmLteMemInfo *memInfo);
+EXTERN S16 UpdateSocMemInfo(U8 area , CmLteMemInfo *mInfo);
EXTERN S16 cmFillCpuUtilizationMeas(CmLteCpuInfo *cpuMeasInfo,CmCpuStatsInfo *cpuInfo);
EXTERN S16 cmClearCpuUtilizationCounter(CmCpuStatsInfo *cpuInfo);
-EXTERN PUBLIC Void UpdateSocCpuInfo(CmCpuStatsInfo *cpuInfo,U8 Idx);
+EXTERN Void UpdateSocCpuInfo(CmCpuStatsInfo *cpuInfo,U8 Idx);
-EXTERN PUBLIC S16 SGetRegPoolInfo(U8* numRegion, U8* numPool);
+EXTERN S16 SGetRegPoolInfo(U8* numRegion, U8* numPool);
/* Packing Functions */
EXTERN S16 cmPkLteRlcId ARGS ((
*
*/
#ifdef ANSI
-PUBLIC U32 cmAbs
+U32 cmAbs
(
F64 val
)
#else
-PUBLIC U32 cmAbs(val)
+U32 cmAbs(val)
F64 val;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC F64 cmPow
+F64 cmPow
(
F64 x,
F64 y
)
#else
-PUBLIC F64 cmPow(x, y)
+F64 cmPow(x, y)
F64 x;
F64 y;
#endif
*
*/
#ifdef ANSI
-PUBLIC F64 cmFloor
+F64 cmFloor
(
F64 x
)
#else
-PUBLIC F64 cmFloor(x)
+F64 cmFloor(x)
F64 x;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC F64 cmLog
+F64 cmLog
(
F64 x
)
#else
-PUBLIC F64 cmLog(x)
+F64 cmLog(x)
F64 x;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC F64 cmLog10
+F64 cmLog10
(
F64 x
)
#else
-PUBLIC F64 cmLog10(x)
+F64 cmLog10(x)
F64 x;
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 cmAllocEvnt
+S16 cmAllocEvnt
(
Size evntSize, /* Size of the Event structure */
Size maxBlkSize, /* Chunk Memory size */
Ptr *ptr /* Location to place allocated event ptr */
)
#else
-PUBLIC S16 cmAllocEvnt (evntSize,maxBlkSize,sMem,ptr)
+S16 cmAllocEvnt (evntSize,maxBlkSize,sMem,ptr)
Size evntSize; /* Size of the Event structure */
Size maxBlkSize; /* Memory size requested */
Mem *sMem; /* Static Memory region and pool */
*/
#ifdef ANSI
-PUBLIC Void cmInitMemCp
+Void cmInitMemCp
(
CmMemListCp *memCp, /* Memory control pointer */
Size maxBlkSize, /* Chunk Memory size */
Mem *sMem /* Static memory region and pool */
)
#else
-PUBLIC Void cmInitMemCp (memCp,maxBlkSize,sMem)
+Void cmInitMemCp (memCp,maxBlkSize,sMem)
CmMemListCp *memCp; /* Memory control pointer */
Size maxBlkSize; /* Memory size requested */
Mem *sMem; /* Static Memory region and pool */
*/
#ifdef ANSI
-PUBLIC S16 cmGetMem
+S16 cmGetMem
(
Ptr memPtr, /* Pointer to memCp */
Size size, /* Memory size requested */
Ptr *allocPtr /* location to place pointer */
)
#else
-PUBLIC S16 cmGetMem (memPtr,size,allocPtr)
+S16 cmGetMem (memPtr,size,allocPtr)
Ptr memPtr; /* Pointer to memCp */
Size size; /* Memory size requested */
Ptr *allocPtr; /* location to place pointer */
*/
#ifdef ANSI
-PUBLIC S16 cmAllocEvntNoInit
+S16 cmAllocEvntNoInit
(
Size evntSize, /* Size of the Event structure */
Size maxBlkSize, /* Chunk Memory size */
Ptr *ptr /* Location to place allocated event ptr */
)
#else
-PUBLIC S16 cmAllocEvntNoInit (evntSize,maxBlkSize,sMem,ptr)
+S16 cmAllocEvntNoInit (evntSize,maxBlkSize,sMem,ptr)
Size evntSize; /* Size of the Event structure */
Size maxBlkSize; /* Memory size requested */
Mem *sMem; /* Static Memory region and pool */
*/
#ifdef ANSI
-PUBLIC S16 cmGetMemNoInit
+S16 cmGetMemNoInit
(
Ptr memPtr, /* Pointer to memCp */
Size size, /* Memory size requested */
Ptr *allocPtr /* location to place pointer */
)
#else
-PUBLIC S16 cmGetMemNoInit (memPtr,size,allocPtr)
+S16 cmGetMemNoInit (memPtr,size,allocPtr)
Ptr memPtr; /* Pointer to memCp */
Size size; /* Memory size requested */
Ptr *allocPtr; /* location to place pointer */
*/
#ifdef ANSI
-PUBLIC Void cmFreeMem
+Void cmFreeMem
(
Ptr memPtr /* Link List CP */
)
#else
-PUBLIC Void cmFreeMem (memPtr)
+Void cmFreeMem (memPtr)
Ptr memPtr; /* Link List CP */
#endif
{
*/
#ifdef ANSI
-PUBLIC Void cmGetMemStatus
+Void cmGetMemStatus
(
Ptr memPtr, /* Memory control pointer */
CmMemStatus *status /* memory region,pool and status */
)
#else
-PUBLIC Void cmGetMemStatus (memPtr,status)
+Void cmGetMemStatus (memPtr,status)
Ptr memPtr; /* Memory control pointer */
CmMemStatus *status; /* memory region,pool and status */
#endif
#endif
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
-PUBLIC U32 memFreeCount=0;
-PUBLIC U32 cmFreeCaller[4]={0};
-PUBLIC U32 cmAllocCaller[4]={0};
-PUBLIC Data *startPtr256=NULLP;
-PUBLIC Data *startPtr128=NULLP;
-PUBLIC U32 cmMemInfo128[100000][2]={0, 0};
-PUBLIC U32 cmMemInfo256[100000][2]={0, 0};
-PUBLIC Data *startPtr512=NULLP;
-PUBLIC Data *startPtr768=NULLP;
-PUBLIC Data *startPtr1664=NULLP;
-PUBLIC Data *startPtr4800=NULLP;
-PUBLIC Data *startPtr9920=NULLP;
-PUBLIC Size regMemSize=0;
+U32 memFreeCount=0;
+U32 cmFreeCaller[4]={0};
+U32 cmAllocCaller[4]={0};
+Data *startPtr256=NULLP;
+Data *startPtr128=NULLP;
+U32 cmMemInfo128[100000][2]={0, 0};
+U32 cmMemInfo256[100000][2]={0, 0};
+Data *startPtr512=NULLP;
+Data *startPtr768=NULLP;
+Data *startPtr1664=NULLP;
+Data *startPtr4800=NULLP;
+Data *startPtr9920=NULLP;
+Size regMemSize=0;
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
//extern CmMmRegCb *mtCMMRegCb[SS_MAX_REGS];
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmRegInit
+S16 cmMmRegInit
(
Region region,
CmMmRegCb *regCb,
CmMmRegCfg *cfg
)
#else
-PUBLIC S16 cmMmRegInit(region, regCb, cfg)
+S16 cmMmRegInit(region, regCb, cfg)
Region region;
CmMmRegCb *regCb;
CmMmRegCfg *cfg;
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmRegDeInit
+S16 cmMmRegDeInit
(
CmMmRegCb *regCb
)
#else
-PUBLIC S16 cmMmRegDeInit(regCb)
+S16 cmMmRegDeInit(regCb)
CmMmRegCb *regCb;
#endif
{
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
Bool hstReg
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType,
+S16 cmAllocNL(regionCb, size, flags, ptr, memType,
line, fileName, entId, hstReg)
Void *regionCb;
Size *size;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
Bool hstReg
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, line,
+S16 cmAllocNL(regionCb, size, flags, ptr, line,
fileName, entId, hstReg)
Void *regionCb;
Size *size;
#else
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
U8 *funcName
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName)
+S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName)
Void *regionCb;
Size *size;
U32 flags;
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
U32 memType
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType)
+S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
U32 flags;
#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
U32 memType
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType)
+S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
U32 flags;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
Data **ptr
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr)
+S16 cmAllocNL(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
U32 flags;
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
U8 *funcName
)
#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName)
+S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName)
Void *regionCb;
Data *ptr;
Size size;
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
Bool hstReg
)
#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size, line, fileName, entId, hstReg)
+S16 cmFreeNL(regionCb, ptr, size, line, fileName, entId, hstReg)
Void *regionCb;
Data *ptr;
Size size;
#else
#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
Size size
)
#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size)
+S16 cmFreeNL(regionCb, ptr, size)
Void *regionCb;
Data *ptr;
Size size;
#endif/*USE_PURE*/
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-PUBLIC U32 cmGetFreeIndx
+U32 cmGetFreeIndx
(
Void
)
#else
-PUBLIC U32 cmGetFreeIndx(Void)
+U32 cmGetFreeIndx(Void)
#endif
{
}
#ifdef ANSI
-PUBLIC U32 cmPutFreeIndx
+U32 cmPutFreeIndx
(
U32 allocQIndx
)
#else
-PUBLIC U32 cmPutFreeIndx(allocQIndx)
+U32 cmPutFreeIndx(allocQIndx)
U32 allocQIndx;
#endif
*
*/
#ifdef ANSI
-PUBLIC Void cmInitMemLeak
+Void cmInitMemLeak
(
Void
)
#else
-PUBLIC Void cmInitMemLeak (Void)
+Void cmInitMemLeak (Void)
#endif
{
U32 indx;
*
**/
#ifdef ANSI
-PUBLIC Void cmDeinitMemLeak
+Void cmDeinitMemLeak
(
Void
)
#else
-PUBLIC Void cmDeinitMemLeak (Void)
+Void cmDeinitMemLeak (Void)
#endif
{
U32 indx;
*
*/
#ifdef ANSI
-PUBLIC U32 cmStorAllocBlk
+U32 cmStorAllocBlk
(
Void *addr
)
#else
-PUBLIC U32 cmStorAllocBlk (addr)
+U32 cmStorAllocBlk (addr)
Void *addr;
#endif /* ANSI */
*
*/
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
U32 allocQIndx
)
#else
-PUBLIC Void cmRlsAllocBlk(allocQIndx)
+Void cmRlsAllocBlk(allocQIndx)
U32 allocQIndx;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void cmStartStopLeakLog
+Void cmStartStopLeakLog
(
Void
)
#else
-PUBLIC Void cmStartStopLeakLog(Void)
+Void cmStartStopLeakLog(Void)
#endif
{
if (FALSE == gmemLkCb.isStarted)
*
*/
#ifdef ANSI
-PUBLIC Void cmPrintLeakLog
+Void cmPrintLeakLog
(
Void
)
#else
-PUBLIC Void cmPrintLeakLog(Void)
+Void cmPrintLeakLog(Void)
#endif
{
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
CmMmBlkHdr *ptrHdr,
CmMmRegCb *regCb
)
#else
-PUBLIC Void cmRlsAllocBlk(ptrHdr, regCb)
+Void cmRlsAllocBlk(ptrHdr, regCb)
CmMmBlkHdr *ptrHdr;
CmMmRegCb *regCb;
#endif
#else
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
#ifdef BIT_64
U64 addr
#endif
)
#else
-PUBLIC Void cmRlsAllocBlk(addr)
+Void cmRlsAllocBlk(addr)
#ifdef BIT_64
U64 addr;
#else
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef ANSI
-PUBLIC Void cmStorAllocBlk
+Void cmStorAllocBlk
(
CmMmBlkHdr *ptrHdr,
Size reqSz,
CmMmRegCb *regCb
)
#else
-PUBLIC Void cmStorAllocBlk (ptrHdr, reqSz, allocSz, bktIdx, regCb)
+Void cmStorAllocBlk (ptrHdr, reqSz, allocSz, bktIdx, regCb)
CmMmBlkHdr *ptrHdr;
Size reqSz;
Size allocSz;
#endif
#else
#ifdef ANSI
-PUBLIC Void cmStorAllocBlk
+Void cmStorAllocBlk
(
#ifdef BIT_64
U64 addr,
U16 bktIdx
)
#else
-PUBLIC Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
+Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
#ifdef BIT_64
U64 addr;
#else
*
*/
#ifdef ANSI
-PUBLIC Void SLogLkInfo
+Void SLogLkInfo
(
Void
)
#else
-PUBLIC Void SLogLkInfo (Void)
+Void SLogLkInfo (Void)
#endif
{
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
*
*/
#ifdef ANSI
-PUBLIC Void cmInitMemLeakMdl
+Void cmInitMemLeakMdl
(
Void
)
#else
-PUBLIC Void cmInitMemLeakMdl (Void)
+Void cmInitMemLeakMdl (Void)
#endif
{
U8 memMdl;
*
**/
#ifdef ANSI
-PUBLIC Void cmDeinitMemLeakMdl
+Void cmDeinitMemLeakMdl
(
Void
)
#else
-PUBLIC Void cmDeinitMemLeakMdl (Void)
+Void cmDeinitMemLeakMdl (Void)
#endif
{
U8 memMdl;
*
*/
#ifdef ANSI
-PUBLIC Void cmMemOpenMemLkFile
+Void cmMemOpenMemLkFile
(
S8 *arg
)
#else
-PUBLIC Void cmMemOpenMemLkFile (arg)
+Void cmMemOpenMemLkFile (arg)
S8 *msOptArg;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void SFlushLkInfo
+Void SFlushLkInfo
(
Void
)
#else
-PUBLIC Void SFlushLkInfo (Void)
+Void SFlushLkInfo (Void)
#endif
{
MemAllocInfo *newMemInfo;
*
*/
#ifdef ANSI
-PUBLIC U8 cmMemGetModuleId
+U8 cmMemGetModuleId
(
S8 **funNm,
S32 traceSize
)
#else
-PUBLIC U8 cmMemGetModuleId (funNm, traceSize)
+U8 cmMemGetModuleId (funNm, traceSize)
S8 **funNm;
S32 traceSize;
#endif /* ANSI */
*
*/
#ifdef ANSI
-PUBLIC S16 cmMemGetStrMtchIdx
+S16 cmMemGetStrMtchIdx
(
U8 strtIdx,
U8 endIdx,
S8 **strLst
)
#else
-PUBLIC S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
+S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
U8 strtIdx;
U8 endIdx;
S8 *str;
*
*/
#ifdef ANSI
-PUBLIC S32 cmAddrToSymStr
+S32 cmAddrToSymStr
(
Void *pc,
S8 *buffer,
S32 size
)
#else
-PUBLIC S32 cmAddrToSymStr(pc, buffer, size)
+S32 cmAddrToSymStr(pc, buffer, size)
Void *pc;
S8 *buffer;
S32 size;
*
*/
#ifdef ANSI
-PUBLIC S32 cmLeakCallBack
+S32 cmLeakCallBack
(
uintptr_t pc,
S32 sigNo,
Void *arg
)
#else
-PUBLIC S32 cmLeakCallBack(pc, sigNo, arg)
+S32 cmLeakCallBack(pc, sigNo, arg)
uintptr_t pc;
S32 sigNo;
Void *arg;
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
+S16 cmMmRegIsBlkSane
(
CmMmBlkHdr *blkPtr,
Size size
)
#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr, size)
+S16 cmMmRegIsBlkSane(blkPtr, size)
CmMmBlkHdr *blkPtr;
Size size;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
+S16 cmMmRegIsBlkSane
(
CmMmBlkHdr *blkPtr
)
#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr)
+S16 cmMmRegIsBlkSane(blkPtr)
CmMmBlkHdr *blkPtr;
#endif
#endif
}CmMemDoubleFree;
PTR prvAllocPtr[8];
-PUBLIC U8 stopBtInfo = FALSE;
-PUBLIC Buffer *palBuffer;
+U8 stopBtInfo = FALSE;
+Buffer *palBuffer;
EXTERN Buffer *mtTskBuffer1;
EXTERN Buffer *mtTskBuffer2;
PRIVATE S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char*, U32));
PRIVATE S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
-PUBLIC void InsertToT2kMemLeakInfo ARGS((U32 address, U32 size, U32 lineNo, char* fileName));
+void InsertToT2kMemLeakInfo ARGS((U32 address, U32 size, U32 lineNo, char* fileName));
void RemoveFromT2kMemLeakInfo ARGS((U32 address, char *file, U32 line));
PRIVATE U32 getT2kMemLeakIndex ARGS((U32 address));
#else
U32 num_times = 0;
EXTERN pthread_t tmpRegTidMap[20];
extern Bool g_usettitmr;
-PUBLIC void DumpLayersDebugInformation()
+void DumpLayersDebugInformation()
{
DumpSSIDemandQDebugInformation();
/* dump layers information only after we start receiving the TTIs */
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmStatRegInit
+S16 cmMmStatRegInit
(
Region region,
CmMmRegCb *regCb,
CmMmRegCfg *cfg
)
#else
-PUBLIC S16 cmMmStatRegInit(region, regCb, cfg)
+S16 cmMmStatRegInit(region, regCb, cfg)
Region region;
CmMmRegCb *regCb;
CmMmRegCfg *cfg;
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmGlobRegInit
+S16 cmMmGlobRegInit
(
CmMmGlobRegCb *regCb
)
#else
-PUBLIC S16 cmMmGlobRegInit(regCb)
+S16 cmMmGlobRegInit(regCb)
CmMmGlobRegCb *regCb;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmDynRegInit
+S16 cmMmDynRegInit
(
CmMmDynRegCb *regCb
)
#else
-PUBLIC S16 cmMmDynRegInit(regCb)
+S16 cmMmDynRegInit(regCb)
CmMmDynRegCb *regCb;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmDynRegInit
+S16 cmMmDynRegInit
(
CmMmDynRegCb *regCb
)
#else
-PUBLIC S16 cmMmDynRegInit(regCb)
+S16 cmMmDynRegInit(regCb)
CmMmDynRegCb *regCb;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmRegDeInit
+S16 cmMmRegDeInit
(
CmMmRegCb *regCb
)
#else
-PUBLIC S16 cmMmRegDeInit(regCb)
+S16 cmMmRegDeInit(regCb)
CmMmRegCb *regCb;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 cmInitDoubleFreeList
+S16 cmInitDoubleFreeList
(
Void
)
#else
-PUBLIC S16 cmInitDoubleFreeList()
+S16 cmInitDoubleFreeList()
#endif
{
U16 offset;
*
*/
#ifdef ANSI
-PUBLIC Void cmAnalyseBtInfo
+Void cmAnalyseBtInfo
(
PTR ptr, /* Memory block needs to be freed */
U32 idx
)
#else
-PUBLIC Void cmAnalyseBtInfo (ptr,idx)
+Void cmAnalyseBtInfo (ptr,idx)
PTR ptr; /* Memory block needs to be freed */
U32 idx;
#endif
*
*/
#ifdef ANSI
-PUBLIC Void cmInitMemLeakMdl
+Void cmInitMemLeakMdl
(
Void
)
#else
-PUBLIC Void cmInitMemLeakMdl (Void)
+Void cmInitMemLeakMdl (Void)
#endif
{
U8 memMdl;
*
**/
#ifdef ANSI
-PUBLIC Void cmDeinitMemLeakMdl
+Void cmDeinitMemLeakMdl
(
Void
)
#else
-PUBLIC Void cmDeinitMemLeakMdl (Void)
+Void cmDeinitMemLeakMdl (Void)
#endif
{
U8 memMdl;
*
*/
#ifdef ANSI
-PUBLIC Void cmMemOpenMemLkFile
+Void cmMemOpenMemLkFile
(
S8 *arg
)
#else
-PUBLIC Void cmMemOpenMemLkFile (arg)
+Void cmMemOpenMemLkFile (arg)
S8 *msOptArg;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void SLogLkInfo
+Void SLogLkInfo
(
Void
)
#else
-PUBLIC Void SLogLkInfo (Void)
+Void SLogLkInfo (Void)
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void SFlushLkInfo
+Void SFlushLkInfo
(
Void
)
#else
-PUBLIC Void SFlushLkInfo (Void)
+Void SFlushLkInfo (Void)
#endif
{
MemAllocInfo *newMemInfo;
*
*/
#ifdef ANSI
-PUBLIC Void cmStorAllocBlk
+Void cmStorAllocBlk
(
U32 addr,
Size reqSz,
U16 bktIdx
)
#else
-PUBLIC Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
+Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
U32 addr;
Size reqSz;
Size allocSz;
*
*/
#ifdef ANSI
-PUBLIC U8 cmMemGetModuleId
+U8 cmMemGetModuleId
(
S8 **funNm,
S32 traceSize
)
#else
-PUBLIC U8 cmMemGetModuleId (funNm, traceSize)
+U8 cmMemGetModuleId (funNm, traceSize)
S8 **funNm;
S32 traceSize;
#endif /* ANSI */
*
*/
#ifdef ANSI
-PUBLIC S16 cmMemGetStrMtchIdx
+S16 cmMemGetStrMtchIdx
(
U8 strtIdx,
U8 endIdx,
S8 **strLst
)
#else
-PUBLIC S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
+S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
U8 strtIdx;
U8 endIdx;
S8 *str;
*
*/
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
U32 addr
)
#else
-PUBLIC Void cmRlsAllocBlk(addr)
+Void cmRlsAllocBlk(addr)
U32 addr;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S32 cmAddrToSymStr
+S32 cmAddrToSymStr
(
Void *pc,
S8 *buffer,
S32 size
)
#else
-PUBLIC S32 cmAddrToSymStr(pc, buffer, size)
+S32 cmAddrToSymStr(pc, buffer, size)
Void *pc;
S8 *buffer;
S32 size;
*
*/
#ifdef ANSI
-PUBLIC S32 cmLeakCallBack
+S32 cmLeakCallBack
(
uintptr_t pc,
S32 sigNo,
Void *arg
)
#else
-PUBLIC S32 cmLeakCallBack(pc, sigNo, arg)
+S32 cmLeakCallBack(pc, sigNo, arg)
uintptr_t pc;
S32 sigNo;
Void *arg;
*
*/
#ifdef ANSI
-PUBLIC S32 backtrace
+S32 backtrace
(
Void **buffer,
S32 count
)
#else
-PUBLIC S32 backtrace(buffer, count)
+S32 backtrace(buffer, count)
Void **buffer;
S32 count;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
+S16 cmMmRegIsBlkSane
(
CmMmBlkHdr *blkPtr
)
#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr)
+S16 cmMmRegIsBlkSane(blkPtr)
CmMmBlkHdr *blkPtr;
#endif
{
}
}
-PUBLIC void DumpT2kMemLeakInfoToFile()
+void DumpT2kMemLeakInfoToFile()
{
int i;
/* For Updating SOC Specific Memory Information */
#ifdef ANSI
-PUBLIC S16 UpdateSocMemInfo
+S16 UpdateSocMemInfo
(
U8 areaIndex,
CmLteMemInfo *mInfo
)
#else
-PUBLIC S16 UpdateSocMemInfo(areaIndex,mInfo)
+S16 UpdateSocMemInfo(areaIndex,mInfo)
U8 areaIndex;
CmLteMemInfo *mInfo;
#endif
*
*/
#ifdef ANSI
-PUBLIC U32 isL2MemUsageBelowLowerThreshold(
+U32 isL2MemUsageBelowLowerThreshold(
Region region
)
#else
-PUBLIC U32 isL2MemUsageBelowLowerThreshold(region)
+U32 isL2MemUsageBelowLowerThreshold(region)
Region region;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC U32 isMemUsageBelowLowerThreshold(
+U32 isMemUsageBelowLowerThreshold(
Region region
)
#else
-PUBLIC U32 isMemUsageBelowLowerThreshold(region)
+U32 isMemUsageBelowLowerThreshold(region)
Region region;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC U32 isMemThreshReached(
+U32 isMemThreshReached(
Region reg
)
#else
-PUBLIC U32 isMemThreshReached(reg)
+U32 isMemThreshReached(reg)
Region reg;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void TSInfTrigStats
+Void TSInfTrigStats
(
Region region,
Pool pool
)
#else
-PUBLIC Void TSInfTrigStats(region, pool)
+Void TSInfTrigStats(region, pool)
Region region;
Pool pool;
#endif
}
#ifdef ANSI
-PUBLIC Void TSInfPkSndL2UeStats
+Void TSInfPkSndL2UeStats
(
Pst *pst,
SuId suId,
TSInfL2UeStats *stats
)
#else
-PUBLIC Void TSInfPkSndL2UeStats(pst, suId, stats)
+Void TSInfPkSndL2UeStats(pst, suId, stats)
Pst *pst;
SuId suId;
TSInfL2UeStats *stats;
}
#ifdef ANSI
-PUBLIC Void TSInfUnpkL2UeStats
+Void TSInfUnpkL2UeStats
(
TSInfL2UeStatsInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC Void TSInfUnpkL2UeStats(func, pst, mBuf)
+Void TSInfUnpkL2UeStats(func, pst, mBuf)
TSInfL2UeStatsInd func;
Pst *pst;
Buffer *mBuf;
}
#ifdef ANSI
-PUBLIC Void TSInfPkSndL2CellStats
+Void TSInfPkSndL2CellStats
(
Pst *pst,
SuId suId,
TSInfL2CellStats *stats
)
#else
-PUBLIC Void TSInfPkSndL2CellStats(pst, suId, stats)
+Void TSInfPkSndL2CellStats(pst, suId, stats)
Pst *pst;
SuId suId;
TSInfL2Cellstats *stats;
}
#ifdef ANSI
-PUBLIC Void TSInfUnpkL2CellStats
+Void TSInfUnpkL2CellStats
(
TSInfL2CellStatsInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC Void TSInfUnpkL2CellStats(func, pst, mBuf)
+Void TSInfUnpkL2CellStats(func, pst, mBuf)
TSInfL2CellStatsInd func;
Pst *pst;
Buffer *mBuf;
#ifdef L2_L3_SPLIT
#define STATS_SRCPROCID 1
#define STATS_DSTPROCID 1
-#define STATS_DSTENT ENTKW
+#define STATS_DSTENT ENTRLC
#else
#define STATS_SRCPROCID 100
#define STATS_DSTPROCID 100
-#define STATS_DSTENT ENTKW
+#define STATS_DSTENT ENTRLC
#endif /* L2_L3_SPLIT */
#define STATS_DSTINST 0 /* PDCP UL */
#endif /* MSPD */
#endif
-#define STATS_SRCENT ENTTF
+#define STATS_SRCENT ENTLWRMAC
#define EVTTENBL2CELLSTATS 0xF1
#define EVTTENBL2UESTATS 0xF2
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknS16
+S16 cmPkTknS16
(
TknS16 *tknS16, /* token S16 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknS16(tknS16, mBuf)
+S16 cmPkTknS16(tknS16, mBuf)
TknS16 *tknS16; /* token S16 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknBStr32
+S16 cmPkTknBStr32
(
TknBStr32 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknBStr32(tknStr, mBuf)
+S16 cmPkTknBStr32(tknStr, mBuf)
TknBStr32 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr8
+S16 cmPkTknStr8
(
TknStr8 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr8(tknStr, mBuf)
+S16 cmPkTknStr8(tknStr, mBuf)
TknStr8 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStr16
+S16 cmPkTknStr16
(
TknStr16 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStr16(tknStr, mBuf)
+S16 cmPkTknStr16(tknStr, mBuf)
TknStr16 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrOSXL
+S16 cmPkTknStrOSXL
(
TknStrOSXL *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrOSXL(tknStr, mBuf)
+S16 cmPkTknStrOSXL(tknStr, mBuf)
TknStrOSXL *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrBSXL
+S16 cmPkTknStrBSXL
(
TknStrBSXL *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrBSXL(tknStr, mBuf)
+S16 cmPkTknStrBSXL(tknStr, mBuf)
TknStrBSXL *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrBMP4
+S16 cmPkTknStrBMP4
(
TknStrBMP4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrBMP4(tknStr, mBuf)
+S16 cmPkTknStrBMP4(tknStr, mBuf)
TknStrBMP4 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrBMPXL
+S16 cmPkTknStrBMPXL
(
TknStrBMPXL *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrBMPXL(tknStr, mBuf)
+S16 cmPkTknStrBMPXL(tknStr, mBuf)
TknStrBMPXL *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrUNI4
+S16 cmPkTknStrUNI4
(
TknStrUNI4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrUNI4(tknStr, mBuf)
+S16 cmPkTknStrUNI4(tknStr, mBuf)
TknStrUNI4 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmPkTknStrUNIXL
+S16 cmPkTknStrUNIXL
(
TknStrUNIXL *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkTknStrUNIXL(tknStr, mBuf)
+S16 cmPkTknStrUNIXL(tknStr, mBuf)
TknStrUNIXL *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknS16
+S16 cmUnpkTknS16
(
TknS16 *tknS16, /* token S16 */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknS16(tknS16, mBuf)
+S16 cmUnpkTknS16(tknS16, mBuf)
TknS16 *tknS16; /* token S16 */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknBStr32
+S16 cmUnpkTknBStr32
(
TknBStr32 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknBStr32(tknStr, mBuf)
+S16 cmUnpkTknBStr32(tknStr, mBuf)
TknBStr32 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr8
+S16 cmUnpkTknStr8
(
TknStr8 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr8(tknStr, mBuf)
+S16 cmUnpkTknStr8(tknStr, mBuf)
TknStr8 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStr16
+S16 cmUnpkTknStr16
(
TknStr16 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStr16(tknStr, mBuf)
+S16 cmUnpkTknStr16(tknStr, mBuf)
TknStr16 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrOSXL
+S16 cmUnpkTknStrOSXL
(
TknStrOSXL *tknStr, /* token string */
Buffer *mBuf, /* message buffer */
Ptr ptr /* pointer to memory control block */
)
#else
-PUBLIC S16 cmUnpkTknStrOSXL(tknStr, mBuf, ptr)
+S16 cmUnpkTknStrOSXL(tknStr, mBuf, ptr)
TknStrOSXL *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
Ptr ptr; /* pointer to control memory block */
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrBSXL
+S16 cmUnpkTknStrBSXL
(
TknStrBSXL *tknStr, /* token string */
Ptr ptr, /* pointer to memory control block */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStrBSXL(tknStr, ptr, mBuf)
+S16 cmUnpkTknStrBSXL(tknStr, ptr, mBuf)
TknStrBSXL *tknStr; /* token string */
Ptr ptr; /* pointer to control memory block */
Buffer *mBuf; /* message buffer */
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrBMP4
+S16 cmUnpkTknStrBMP4
(
TknStrBMP4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStrBMP4(tknStr, mBuf)
+S16 cmUnpkTknStrBMP4(tknStr, mBuf)
TknStrBMP4 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrBMPXL
+S16 cmUnpkTknStrBMPXL
(
TknStrBMPXL *tknStr, /* token string */
Buffer *mBuf, /* message buffer */
Ptr ptr /* pointer to memory control block */
)
#else
-PUBLIC S16 cmUnpkTknStrBMPXL(tknStr, mBuf, ptr)
+S16 cmUnpkTknStrBMPXL(tknStr, mBuf, ptr)
TknStrBMPXL *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
Ptr ptr; /* pointer to control memory block */
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrUNI4
+S16 cmUnpkTknStrUNI4
(
TknStrUNI4 *tknStr, /* token string */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkTknStrUNI4(tknStr, mBuf)
+S16 cmUnpkTknStrUNI4(tknStr, mBuf)
TknStrUNI4 *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkTknStrUNIXL
+S16 cmUnpkTknStrUNIXL
(
TknStrUNIXL *tknStr, /* token string */
Buffer *mBuf, /* message buffer */
Ptr ptr /* pointer to memory control block */
)
#else
-PUBLIC S16 cmUnpkTknStrUNIXL(tknStr, mBuf, ptr)
+S16 cmUnpkTknStrUNIXL(tknStr, mBuf, ptr)
TknStrUNIXL *tknStr; /* token string */
Buffer *mBuf; /* message buffer */
Ptr ptr; /* pointer to control memory block */
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpv4TptAddr
+S16 cmPkCmIpv4TptAddr
(
CmIpv4TptAddr *pkParam, /* IPv4 Address structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpv4TptAddr (pkParam, mBuf)
+S16 cmPkCmIpv4TptAddr (pkParam, mBuf)
CmIpv4TptAddr *pkParam; /* IPv4 Address structure */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmNetAddrTbl
+S16 cmPkCmNetAddrTbl
(
CmNetAddrTbl *pkParam, /* Network Address Table */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmNetAddrTbl (pkParam, mBuf)
+S16 cmPkCmNetAddrTbl (pkParam, mBuf)
CmNetAddrTbl *pkParam; /* Network Address Table */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmNetAddr
+S16 cmPkCmNetAddr
(
CmNetAddr *pkParam,
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmNetAddr (pkParam, mBuf)
+S16 cmPkCmNetAddr (pkParam, mBuf)
CmNetAddr *pkParam;
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmTptAddr
+S16 cmPkCmTptAddr
(
CmTptAddr *pkParam,
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmTptAddr (pkParam, mBuf)
+S16 cmPkCmTptAddr (pkParam, mBuf)
CmTptAddr *pkParam;
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmTptLocalInf
+S16 cmPkCmTptLocalInf
(
CmTptLocalInf *pkParam, /* local interface info */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmTptLocalInf (pkParam, mBuf)
+S16 cmPkCmTptLocalInf (pkParam, mBuf)
CmTptLocalInf *pkParam; /* local interface info */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmNetMCastInf6
+S16 cmPkCmNetMCastInf6
(
CmNetMCastInf6 *pkParam, /* IPv6 multicast information */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmNetMCastInf6(pkParam, mBuf)
+S16 cmPkCmNetMCastInf6(pkParam, mBuf)
CmNetMCastInf6 *pkParam; /* IPv6 multicast information */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmTptParam
+S16 cmPkCmTptParam
(
CmTptParam *pkParam,
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmTptParam (pkParam, mBuf)
+S16 cmPkCmTptParam (pkParam, mBuf)
CmTptParam *pkParam;
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv4TptAddr
+S16 cmUnpkCmIpv4TptAddr
(
CmIpv4TptAddr *unpkParam, /* IPv4 Address */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmIpv4TptAddr (unpkParam, mBuf)
+S16 cmUnpkCmIpv4TptAddr (unpkParam, mBuf)
CmIpv4TptAddr *unpkParam; /* IPv4 Address */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmNetAddrTbl
+S16 cmUnpkCmNetAddrTbl
(
CmNetAddrTbl *unpkParam, /* Network Address Table */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmNetAddrTbl (unpkParam, mBuf )
+S16 cmUnpkCmNetAddrTbl (unpkParam, mBuf )
CmNetAddrTbl *unpkParam; /* Network Address Table */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmNetAddr
+S16 cmUnpkCmNetAddr
(
CmNetAddr *unpkParam,
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmNetAddr (unpkParam, mBuf )
+S16 cmUnpkCmNetAddr (unpkParam, mBuf )
CmNetAddr *unpkParam;
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmTptAddr
+S16 cmUnpkCmTptAddr
(
CmTptAddr *unpkParam,
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmTptAddr (unpkParam, mBuf)
+S16 cmUnpkCmTptAddr (unpkParam, mBuf)
CmTptAddr *unpkParam;
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmNetMCastInf6
+S16 cmUnpkCmNetMCastInf6
(
CmNetMCastInf6 *unpkParam, /* IPv6 multicast information */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmNetMCastInf6(unpkParam, mBuf)
+S16 cmUnpkCmNetMCastInf6(unpkParam, mBuf)
CmNetMCastInf6 *unpkParam; /* IPv6 multicast information */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmTptParam
+S16 cmUnpkCmTptParam
(
CmTptParam *unpkParam, /* transport parameters */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmTptParam (unpkParam, mBuf)
+S16 cmUnpkCmTptParam (unpkParam, mBuf)
CmTptParam *unpkParam; /* transport parameters */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpHdrParm
+S16 cmPkCmIpHdrParm
(
CmIpHdrParm *pkParam, /* IP hdr parameters */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpHdrParm (pkParam, mBuf)
+S16 cmPkCmIpHdrParm (pkParam, mBuf)
CmIpHdrParm *pkParam; /* IP hdr parameters */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmTptLocalInf
+S16 cmUnpkCmTptLocalInf
(
CmTptLocalInf *unpkParam, /* local interface info */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmTptLocalInf (unpkParam, mBuf)
+S16 cmUnpkCmTptLocalInf (unpkParam, mBuf)
CmTptLocalInf *unpkParam; /* local interface info */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpv6ExtHdr
+S16 cmPkCmIpv6ExtHdr
(
CmIpv6ExtHdr *pkParam, /* IPV6 extension hdrs */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpv6ExtHdr (pkParam, mBuf)
+S16 cmPkCmIpv6ExtHdr (pkParam, mBuf)
CmIpv6ExtHdr *pkParam; /*IPV6 extension hdrs */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpv6RtHdr
+S16 cmPkCmIpv6RtHdr
(
CmIpv6RtHdr *pkParam, /* IPV6 Route hdr */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpv6RtHdr (pkParam, mBuf)
+S16 cmPkCmIpv6RtHdr (pkParam, mBuf)
CmIpv6RtHdr *pkParam; /* IPV6 Route hdr */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6RtHdr
+S16 cmUnpkCmIpv6RtHdr
(
CmIpv6RtHdr *unpkParam, /* IPV6 Route hdr */
Buffer *mBuf, /* message buffer */
Mem *memInfo /* meminfo to allocate for Route hdr */
)
#else
-PUBLIC S16 cmUnpkCmIpv6RtHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6RtHdr (unpkParam, mBuf, memInfo)
CmIpv6RtHdr *unpkParam; /* IPV6 Route hdr */
Buffer *mBuf; /* message buffer */
Mem *memInfo; /* meminfo to allocate for Route hdr */
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6ExtHdr
+S16 cmUnpkCmIpv6ExtHdr
(
CmIpv6ExtHdr *unpkParam, /* IPV6 extension hdrs */
Buffer *mBuf, /* message buffer */
Mem *memInfo /* meminfo to allocate for IPV6 ext hdr */
)
#else
-PUBLIC S16 cmUnpkCmIpv6ExtHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6ExtHdr (unpkParam, mBuf, memInfo)
CmIpv6ExtHdr *unpkParam; /* IPV6 extension hdrs */
Buffer *mBuf; /* message buffer */
Mem *memInfo; /* meminfo to allocate for IPV6 ext hdr */
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpv6DestOptsArr
+S16 cmPkCmIpv6DestOptsArr
(
CmIpv6DestOptsArr *pkParam, /* IPV6 Dest hdr array */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpv6DestOptsArr (pkParam, mBuf)
+S16 cmPkCmIpv6DestOptsArr (pkParam, mBuf)
CmIpv6DestOptsArr *pkParam; /* IPV6 Dest hdr array */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpv6DestOptsHdr
+S16 cmPkCmIpv6DestOptsHdr
(
CmIpv6DestOptsHdr *pkParam, /* IPV6 Dest opt */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpv6DestOptsHdr (pkParam, mBuf)
+S16 cmPkCmIpv6DestOptsHdr (pkParam, mBuf)
CmIpv6DestOptsHdr *pkParam; /* IPV6 Dest opt */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6DestOptsHdr
+S16 cmUnpkCmIpv6DestOptsHdr
(
CmIpv6DestOptsHdr *unpkParam,/* IPV6 Dest Option */
Buffer *mBuf, /* message buffer */
Mem *memInfo /* meminfo to allocate mem for dest opt */
)
#else
-PUBLIC S16 cmUnpkCmIpv6DestOptsHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6DestOptsHdr (unpkParam, mBuf, memInfo)
CmIpv6DestOptsHdr *unpkParam;/* IPV6 Dest Option */
Buffer *mBuf; /* message buffer */
Mem *memInfo; /* meminfo to allocate mem for dest opt */
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6DestOptsArr
+S16 cmUnpkCmIpv6DestOptsArr
(
CmIpv6DestOptsArr *unpkParam, /* all IPV6 Destination Options */
Buffer *mBuf, /* message buffer */
Mem *memInfo /* meminfo to allocate mem for dest opts */
)
#else
-PUBLIC S16 cmUnpkCmIpv6DestOptsArr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6DestOptsArr (unpkParam, mBuf, memInfo)
CmIpv6DestOptsArr *unpkParam; /* all IPV6 Destination Options */
Buffer *mBuf; /* message buffer */
Mem *memInfo; /* meminfo to allocate mem for dest opts */
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpv6HBHHdrArr
+S16 cmPkCmIpv6HBHHdrArr
(
CmIpv6HBHHdrArr *pkParam, /* all IPV6 HopByHop options */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpv6HBHHdrArr (pkParam, mBuf)
+S16 cmPkCmIpv6HBHHdrArr (pkParam, mBuf)
CmIpv6HBHHdrArr *pkParam; /* IPV6 HopByHop options */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIpv6HBHHdr
+S16 cmPkCmIpv6HBHHdr
(
CmIpv6HBHHdr *pkParam, /* individual IPV6 HBH options */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIpv6HBHHdr (pkParam, mBuf)
+S16 cmPkCmIpv6HBHHdr (pkParam, mBuf)
CmIpv6HBHHdr *pkParam; /* individual IPV6 HBH options */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6HBHHdr
+S16 cmUnpkCmIpv6HBHHdr
(
CmIpv6HBHHdr *unpkParam,/* individual IPV6 HBH Option */
Buffer *mBuf, /* message buffer */
Mem *memInfo /* meminfo to allocate mem for HBH opt */
)
#else
-PUBLIC S16 cmUnpkCmIpv6HBHHdr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6HBHHdr (unpkParam, mBuf, memInfo)
CmIpv6HBHHdr *unpkParam;/* individual IPV6 HBH Option */
Buffer *mBuf; /* message buffer */
Mem *memInfo; /* meminfo to allocate mem for HBH opt */
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIpv6HBHHdrArr
+S16 cmUnpkCmIpv6HBHHdrArr
(
CmIpv6HBHHdrArr *unpkParam, /* all HBH options */
Buffer *mBuf, /* message buffer */
Mem *memInfo /* meminfo to allocate space for HBH opt */
)
#else
-PUBLIC S16 cmUnpkCmIpv6HBHHdrArr (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpv6HBHHdrArr (unpkParam, mBuf, memInfo)
CmIpv6HBHHdrArr *unpkParam; /* all HBH options */
Buffer *mBuf; /* message buffer */
Mem *memInfo; /* meminfo to allocate space for HBH opt */
#ifdef ANSI
/* added */
#ifdef IPV6_OPTS_SUPPORTED
-PUBLIC S16 cmUnpkCmIpHdrParm
+S16 cmUnpkCmIpHdrParm
(
CmIpHdrParm *unpkParam,/* ip hdr parameters */
Buffer *mBuf, /* message buffer */
Mem *memInfo /* meminfo to allocate mem for ipHdrParam */
)
#else
-PUBLIC S16 cmUnpkCmIpHdrParm
+S16 cmUnpkCmIpHdrParm
(
CmIpHdrParm *unpkParam,/* ip hdr parameters */
Buffer *mBuf /* message buffer */
#else
/* added */
#ifdef IPV6_OPTS_SUPPORTED
-PUBLIC S16 cmUnpkCmIpHdrParm (unpkParam, mBuf, memInfo)
+S16 cmUnpkCmIpHdrParm (unpkParam, mBuf, memInfo)
CmIpHdrParm *unpkParam;/* ip hdr parameters */
Buffer *mBuf; /* message buffer */
Mem *memInfo; /* meminfo to allocate mem for ipHdrParam */
#else
-PUBLIC S16 cmUnpkCmIpHdrParm (unpkParam, mBuf)
+S16 cmUnpkCmIpHdrParm (unpkParam, mBuf)
CmIpHdrParm *unpkParam;/* ip hdr parameters */
Buffer *mBuf; /* message buffer */
#endif /* IPV6_OPTS_SUPPORTED */
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCmIcmpFilter
+S16 cmPkCmIcmpFilter
(
CmIcmpFilter *pkParam,
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkCmIcmpFilter (pkParam, mBuf)
+S16 cmPkCmIcmpFilter (pkParam, mBuf)
CmIcmpFilter *pkParam;
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCmIcmpFilter
+S16 cmUnpkCmIcmpFilter
(
CmIcmpFilter *unpkParam,
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkCmIcmpFilter (unpkParam, mBuf)
+S16 cmUnpkCmIcmpFilter (unpkParam, mBuf)
CmIcmpFilter *unpkParam;
Buffer *mBuf; /* message buffer */
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCrgBndReq
+S16 cmPkCrgBndReq
(
Pst* pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkCrgBndReq(pst, suId, spId)
+S16 cmPkCrgBndReq(pst, suId, spId)
Pst* pst;
SuId suId;
SpId spId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgBndReq
+S16 cmUnpkCrgBndReq
(
CrgBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgBndReq(func, pst, mBuf)
+S16 cmUnpkCrgBndReq(func, pst, mBuf)
CrgBndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCrgBndCfm
+S16 cmPkCrgBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkCrgBndCfm(pst, suId, status)
+S16 cmPkCrgBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgBndCfm
+S16 cmUnpkCrgBndCfm
(
CrgBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgBndCfm(func, pst, mBuf)
+S16 cmUnpkCrgBndCfm(func, pst, mBuf)
CrgBndCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCrgUbndReq
+S16 cmPkCrgUbndReq
(
Pst* pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkCrgUbndReq(pst, spId, reason)
+S16 cmPkCrgUbndReq(pst, spId, reason)
Pst* pst;
SpId spId;
Reason reason;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgUbndReq
+S16 cmUnpkCrgUbndReq
(
CrgUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgUbndReq(func, pst, mBuf)
+S16 cmUnpkCrgUbndReq(func, pst, mBuf)
CrgUbndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCrgCfgReq
+S16 cmPkCrgCfgReq
(
Pst* pst,
SpId spId,
CrgCfgReqInfo * cfgReqInfo
)
#else
-PUBLIC S16 cmPkCrgCfgReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCrgCfgReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
CrgCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgReq
+S16 cmUnpkCrgCfgReq
(
CrgCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgCfgReq(func, pst, mBuf)
+S16 cmUnpkCrgCfgReq(func, pst, mBuf)
CrgCfgReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCrgCfgCfm
+S16 cmPkCrgCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkCrgCfgCfm(pst, suId, transId, status)
+S16 cmPkCrgCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CrgCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgCfm
+S16 cmUnpkCrgCfgCfm
(
CrgCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgCfgCfm(func, pst, mBuf)
+S16 cmUnpkCrgCfgCfm(func, pst, mBuf)
CrgCfgCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgCfgTransId
+S16 cmPkCrgCfgTransId
(
CrgCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgCfgTransId(param, mBuf)
+S16 cmPkCrgCfgTransId(param, mBuf)
CrgCfgTransId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgTransId
+S16 cmUnpkCrgCfgTransId
(
CrgCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgCfgTransId(param, mBuf)
+S16 cmUnpkCrgCfgTransId(param, mBuf)
CrgCfgTransId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgBwCfg
+S16 cmPkCrgBwCfg
(
CrgBwCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgBwCfg(param, mBuf)
+S16 cmPkCrgBwCfg(param, mBuf)
CrgBwCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgBwCfg
+S16 cmUnpkCrgBwCfg
(
CrgBwCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgBwCfg(param, mBuf)
+S16 cmUnpkCrgBwCfg(param, mBuf)
CrgBwCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgRachCfg
+S16 cmPkCrgRachCfg
(
CrgRachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgRachCfg(param, mBuf)
+S16 cmPkCrgRachCfg(param, mBuf)
CrgRachCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgRachCfg
+S16 cmUnpkCrgRachCfg
(
CrgRachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgRachCfg(param, mBuf)
+S16 cmUnpkCrgRachCfg(param, mBuf)
CrgRachCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgCellCfg
+S16 cmPkCrgCellCfg
(
CrgCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgCellCfg(param, mBuf)
+S16 cmPkCrgCellCfg(param, mBuf)
CrgCellCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgCellCfg
+S16 cmUnpkCrgCellCfg
(
CrgCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgCellCfg(param, mBuf)
+S16 cmUnpkCrgCellCfg(param, mBuf)
CrgCellCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgUeUlHqCfg
+S16 cmPkCrgUeUlHqCfg
(
CrgUeUlHqCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgUeUlHqCfg(param, mBuf)
+S16 cmPkCrgUeUlHqCfg(param, mBuf)
CrgUeUlHqCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgUeSecCellInfo
+S16 cmPkCrgUeSecCellInfo
(
CrgUeSecCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgUeSecCellInfo(param, mBuf)
+S16 cmPkCrgUeSecCellInfo(param, mBuf)
CrgUeSecCellInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeSecCellInfo
+S16 cmUnpkCrgUeSecCellInfo
(
CrgUeSecCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgUeSecCellInfo(param, mBuf)
+S16 cmUnpkCrgUeSecCellInfo(param, mBuf)
CrgUeSecCellInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeUlHqCfg
+S16 cmUnpkCrgUeUlHqCfg
(
CrgUeUlHqCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgUeUlHqCfg(param, mBuf)
+S16 cmUnpkCrgUeUlHqCfg(param, mBuf)
CrgUeUlHqCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgUeCfg
+S16 cmPkCrgUeCfg
(
CrgUeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgUeCfg(param, mBuf)
+S16 cmPkCrgUeCfg(param, mBuf)
CrgUeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeCfg
+S16 cmUnpkCrgUeCfg
(
CrgUeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgUeCfg(param, mBuf)
+S16 cmUnpkCrgUeCfg(param, mBuf)
CrgUeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgDlLchCfg
+S16 cmPkCrgDlLchCfg
(
CrgDlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgDlLchCfg(param, mBuf)
+S16 cmPkCrgDlLchCfg(param, mBuf)
CrgDlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgDlLchCfg
+S16 cmUnpkCrgDlLchCfg
(
CrgDlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgDlLchCfg(param, mBuf)
+S16 cmUnpkCrgDlLchCfg(param, mBuf)
CrgDlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgUlLchCfg
+S16 cmPkCrgUlLchCfg
(
CrgUlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgUlLchCfg(param, mBuf)
+S16 cmPkCrgUlLchCfg(param, mBuf)
CrgUlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgUlLchCfg
+S16 cmUnpkCrgUlLchCfg
(
CrgUlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgUlLchCfg(param, mBuf)
+S16 cmUnpkCrgUlLchCfg(param, mBuf)
CrgUlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgLchCfg
+S16 cmPkCrgLchCfg
(
CrgLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgLchCfg(param, mBuf)
+S16 cmPkCrgLchCfg(param, mBuf)
CrgLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgLchCfg
+S16 cmUnpkCrgLchCfg
(
CrgLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgLchCfg(param, mBuf)
+S16 cmUnpkCrgLchCfg(param, mBuf)
CrgLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgCfg
+S16 cmPkCrgCfg
(
CrgCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgCfg(param, mBuf)
+S16 cmPkCrgCfg(param, mBuf)
CrgCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfg
+S16 cmUnpkCrgCfg
(
CrgCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgCfg(param, mBuf)
+S16 cmUnpkCrgCfg(param, mBuf)
CrgCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgCellRecfg
+S16 cmPkCrgCellRecfg
(
CrgCellRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgCellRecfg(param, mBuf)
+S16 cmPkCrgCellRecfg(param, mBuf)
CrgCellRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgCellRecfg
+S16 cmUnpkCrgCellRecfg
(
CrgCellRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgCellRecfg(param, mBuf)
+S16 cmUnpkCrgCellRecfg(param, mBuf)
CrgCellRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgUeRecfg
+S16 cmPkCrgUeRecfg
(
CrgUeRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgUeRecfg(param, mBuf)
+S16 cmPkCrgUeRecfg(param, mBuf)
CrgUeRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgUeRecfg
+S16 cmUnpkCrgUeRecfg
(
CrgUeRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgUeRecfg(param, mBuf)
+S16 cmUnpkCrgUeRecfg(param, mBuf)
CrgUeRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgLchRecfg
+S16 cmPkCrgLchRecfg
(
CrgLchRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgLchRecfg(param, mBuf)
+S16 cmPkCrgLchRecfg(param, mBuf)
CrgLchRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgLchRecfg
+S16 cmUnpkCrgLchRecfg
(
CrgLchRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgLchRecfg(param, mBuf)
+S16 cmUnpkCrgLchRecfg(param, mBuf)
CrgLchRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgRecfg
+S16 cmPkCrgRecfg
(
CrgRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgRecfg(param, mBuf)
+S16 cmPkCrgRecfg(param, mBuf)
CrgRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgRecfg
+S16 cmUnpkCrgRecfg
(
CrgRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgRecfg(param, mBuf)
+S16 cmUnpkCrgRecfg(param, mBuf)
CrgRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgDel
+S16 cmPkCrgDel
(
CrgDel *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgDel(param, mBuf)
+S16 cmPkCrgDel(param, mBuf)
CrgDel *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgDel
+S16 cmUnpkCrgDel
(
CrgDel *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgDel(param, mBuf)
+S16 cmUnpkCrgDel(param, mBuf)
CrgDel *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgRst
+S16 cmPkCrgRst
(
CrgRst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgRst(param, mBuf)
+S16 cmPkCrgRst(param, mBuf)
CrgRst *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgRst
+S16 cmUnpkCrgRst
(
CrgRst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgRst(param, mBuf)
+S16 cmUnpkCrgRst(param, mBuf)
CrgRst *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCrgCfgReqInfo
+S16 cmPkCrgCfgReqInfo
(
CrgCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCrgCfgReqInfo(param, mBuf)
+S16 cmPkCrgCfgReqInfo(param, mBuf)
CrgCfgReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCrgCfgReqInfo
+S16 cmUnpkCrgCfgReqInfo
(
CrgCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCrgCfgReqInfo(param, mBuf)
+S16 cmUnpkCrgCfgReqInfo(param, mBuf)
CrgCfgReqInfo *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfBndReq
+S16 cmPkCtfBndReq
(
Pst* pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkCtfBndReq(pst, suId, spId)
+S16 cmPkCtfBndReq(pst, suId, spId)
Pst* pst;
SuId suId;
SpId spId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfBndReq
+S16 cmUnpkCtfBndReq
(
CtfBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfBndReq(func, pst, mBuf)
+S16 cmUnpkCtfBndReq(func, pst, mBuf)
CtfBndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfBndCfm
+S16 cmPkCtfBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkCtfBndCfm(pst, suId, status)
+S16 cmPkCtfBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfBndCfm
+S16 cmUnpkCtfBndCfm
(
CtfBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfBndCfm(func, pst, mBuf)
+S16 cmUnpkCtfBndCfm(func, pst, mBuf)
CtfBndCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUbndReq
+S16 cmPkCtfUbndReq
(
Pst* pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkCtfUbndReq(pst, spId, reason)
+S16 cmPkCtfUbndReq(pst, spId, reason)
Pst* pst;
SpId spId;
Reason reason;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUbndReq
+S16 cmUnpkCtfUbndReq
(
CtfUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUbndReq(func, pst, mBuf)
+S16 cmUnpkCtfUbndReq(func, pst, mBuf)
CtfUbndReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfNhKeyInfo
+S16 cmPkCtfNhKeyInfo
(
CtfNhKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfNhKeyInfo(param, mBuf)
+S16 cmPkCtfNhKeyInfo(param, mBuf)
CtfNhKeyInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKenbStarInfo
+S16 cmPkCtfKenbStarInfo
(
CtfKenbStarInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKenbStarInfo(param, mBuf)
+S16 cmPkCtfKenbStarInfo(param, mBuf)
CtfKenbStarInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfAskeyInfo
+S16 cmPkCtfAskeyInfo
(
CtfAsKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfAskeyInfo(param, mBuf)
+S16 cmPkCtfAskeyInfo(param, mBuf)
CtfAsKeyInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfReqInfo
+S16 cmPkCtfKdfReqInfo
(
CtfKdfReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKdfReqInfo(param, mBuf)
+S16 cmPkCtfKdfReqInfo(param, mBuf)
CtfKdfReqInfo *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfReq
+S16 cmPkCtfKdfReq
(
Pst* pst,
SpId spId,
CtfKdfReqInfo* kdfReqInfo
)
#else
-PUBLIC S16 cmPkCtfKdfReq(pst, spId, transId, kdfReqInfo)
+S16 cmPkCtfKdfReq(pst, spId, transId, kdfReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId transId;
/*START OF CNM PACK & UNPACK FUNCTIONS*/
/********************************************************************************************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmVendorSpecificInfo
+S16 cmPkCtfCnmVendorSpecificInfo
(
CtfCnmVendorSpecificInfo *param,
Buffer *mBuf
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfCtfCnmCellSyncReq
+S16 cmPkCtfCtfCnmCellSyncReq
(
CtfCnmCellSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCtfCnmCellSyncReq(param, mBuf)
+S16 cmPkCtfCtfCnmCellSyncReq(param, mBuf)
CtfCnmCellSyncReq *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfcfgReqInfo
+S16 cmPkCtfcfgReqInfo
(
CtfCnmInitSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfcfgReqInfo(param, mBuf)
+S16 cmPkCtfcfgReqInfo(param, mBuf)
CtfCnmInitSyncReq *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmVendorSpecificInfo
+S16 cmUnpkCtfCnmVendorSpecificInfo
(
CtfCnmVendorSpecificInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmVendorSpecificInfo(param, mBuf)
+S16 cmUnpkCtfCnmVendorSpecificInfo(param, mBuf)
CtfCnmVendorSpecificInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCtfCnmCellSyncReq
+S16 cmUnpkCtfCtfCnmCellSyncReq
(
CtfCnmCellSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCtfCnmCellSyncReq(param, mBuf)
+S16 cmUnpkCtfCtfCnmCellSyncReq(param, mBuf)
CtfCnmCellSyncReq *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfsyncReqInfo
+S16 cmUnpkCtfsyncReqInfo
(
CtfCnmInitSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfsyncReqInfo(param, mBuf)
+S16 cmUnpkCtfsyncReqInfo(param, mBuf)
CtfCnmInitSyncReq *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmCellSyncReq
+S16 cmPkCtfCnmCellSyncReq
(
Pst* pst,
SpId spId,
CtfCnmCellSyncReq * cfgReqInfo
)
#else
-PUBLIC S16 cmPkCtfCnmCellSyncReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCtfCnmCellSyncReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmCellSyncReq
+S16 cmUnpkCtfCnmCellSyncReq
(
CtfCnmCellSyncReqMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmCellSyncReq(func, pst, mBuf)
+S16 cmUnpkCtfCnmCellSyncReq(func, pst, mBuf)
CtfCnmCellSyncReqMsg func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmInitSyncReq
+S16 cmPkCtfCnmInitSyncReq
(
Pst* pst,
SpId spId,
CtfCnmInitSyncReq * cfgReqInfo
)
#else
-PUBLIC S16 cmPkCtfCnmInitSyncReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCtfCnmInitSyncReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmInitSyncReq
+S16 cmUnpkCtfCnmInitSyncReq
(
CtfCnmInitSyncReqMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmInitSyncReq(func, pst, mBuf)
+S16 cmUnpkCtfCnmInitSyncReq(func, pst, mBuf)
CtfCnmInitSyncReqMsg func;
Pst *pst;
Buffer *mBuf;
/*-----------------------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmPkCtfctfCnmMibInfo
+S16 cmPkCtfctfCnmMibInfo
(
CtfCnmMibInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfctfCnmMibInfo(param, mBuf)
+S16 cmPkCtfctfCnmMibInfo(param, mBuf)
CtfCnmMibInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfctfCnmInitSyncInfo
+S16 cmPkCtfctfCnmInitSyncInfo
(
CtfCnmInitSyncInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfctfCnmInitSyncInfo(param, mBuf)
+S16 cmPkCtfctfCnmInitSyncInfo(param, mBuf)
CtfCnmInitSyncInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfcfgRspInfo
+S16 cmPkCtfcfgRspInfo
(
CtfCnmInitSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfcfgRspInfo(param, mBuf)
+S16 cmPkCtfcfgRspInfo(param, mBuf)
CtfCnmInitSyncRsp *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmInitSyncRsp
+S16 cmPkCtfCnmInitSyncRsp
(
Pst* pst,
SpId spId,
CtfCnmInitSyncRsp * cfgRspInfo
)
#else
-PUBLIC S16 cmPkCtfCnmInitSyncRsp(pst, spId, transId, cfgRspInfo)
+S16 cmPkCtfCnmInitSyncRsp(pst, spId, transId, cfgRspInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
/*-----------------------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfctfCnmMibInfo
+S16 cmUnpkCtfctfCnmMibInfo
(
CtfCnmMibInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfctfCnmMibInfo(param, mBuf)
+S16 cmUnpkCtfctfCnmMibInfo(param, mBuf)
CtfCnmMibInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkctfCnmInitSyncInfo
+S16 cmUnpkctfCnmInitSyncInfo
(
CtfCnmInitSyncInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkctfCnmInitSyncInfo(param, mBuf)
+S16 cmUnpkctfCnmInitSyncInfo(param, mBuf)
CtfCnmInitSyncInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmInitSyncRspMsg
+S16 cmUnpkCtfCnmInitSyncRspMsg
(
CtfCnmInitSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmInitSyncRspMsg(param, mBuf)
+S16 cmUnpkCtfCnmInitSyncRspMsg(param, mBuf)
CtfCnmInitSyncRsp *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmInitSyncRsp
+S16 cmUnpkCtfCnmInitSyncRsp
(
CtfCnmInitSyncRspMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmInitSyncRsp(func, pst, mBuf)
+S16 cmUnpkCtfCnmInitSyncRsp(func, pst, mBuf)
CtfCnmInitSyncRspMsg func;
Pst *pst;
Buffer *mBuf;
/*-----------------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellSyncRsp
+S16 cmPkCtfCellSyncRsp
(
CtfCnmCellSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellSyncRsp(param, mBuf)
+S16 cmPkCtfCellSyncRsp(param, mBuf)
CtfCnmCellSyncRsp *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmCellSyncRsp
+S16 cmPkCtfCnmCellSyncRsp
(
Pst* pst,
SpId spId,
CtfCnmCellSyncRsp * cfgRspInfo
)
#else
-PUBLIC S16 cmPkCtfCnmCellSyncRsp(pst, spId, transId, cfgRspInfo)
+S16 cmPkCtfCnmCellSyncRsp(pst, spId, transId, cfgRspInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
/*------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmSyncRspMsg
+S16 cmUnpkCtfCnmSyncRspMsg
(
CtfCnmCellSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmSyncRspMsg(param, mBuf)
+S16 cmUnpkCtfCnmSyncRspMsg(param, mBuf)
CtfCnmCellSyncRsp *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmCellSyncRsp
+S16 cmUnpkCtfCnmCellSyncRsp
(
CtfCnmCellSyncRspMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmCellSyncRsp(func, pst, mBuf)
+S16 cmUnpkCtfCnmCellSyncRsp(func, pst, mBuf)
CtfCnmCellSyncRspMsg func;
Pst *pst;
Buffer *mBuf;
/*---------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmPkCtfcfgIndInfo
+S16 cmPkCtfcfgIndInfo
(
CtfCnmCellSyncInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfcfgIndInfo(param, mBuf)
+S16 cmPkCtfcfgIndInfo(param, mBuf)
CtfCnmCellSyncInd *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmCellSyncInd
+S16 cmPkCtfCnmCellSyncInd
(
Pst* pst,
SpId spId,
CtfCnmCellSyncInd * cfgIndInfo
)
#else
-PUBLIC S16 cmPkCtfCnmCellSyncInd(pst, spId, transId, cfgIndInfo)
+S16 cmPkCtfCnmCellSyncInd(pst, spId, transId, cfgIndInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
/*---------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmSyncIndMsg
+S16 cmUnpkCtfCnmSyncIndMsg
(
CtfCnmCellSyncInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmSyncIndMsg(param, mBuf)
+S16 cmUnpkCtfCnmSyncIndMsg(param, mBuf)
CtfCnmCellSyncInd *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmCellSyncInd
+S16 cmUnpkCtfCnmCellSyncInd
(
CtfCnmCellSyncIndMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmCellSyncInd(func, pst, mBuf)
+S16 cmUnpkCtfCnmCellSyncInd(func, pst, mBuf)
CtfCnmCellSyncIndMsg func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgReq
+S16 cmPkCtfCfgReq
(
Pst* pst,
SpId spId,
CtfCfgReqInfo* cfgReqInfo
)
#else
-PUBLIC S16 cmPkCtfCfgReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCtfCfgReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId transId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfNhKeyInfo
+S16 cmUnpkCtfNhKeyInfo
(
CtfNhKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfNhKeyInfo(param, mBuf)
+S16 cmUnpkCtfNhKeyInfo(param, mBuf)
CtfNhKeyInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKenbStarInfo
+S16 cmUnpkCtfKenbStarInfo
(
CtfKenbStarInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKenbStarInfo(param, mBuf)
+S16 cmUnpkCtfKenbStarInfo(param, mBuf)
CtfKenbStarInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfAskeyInfo
+S16 cmUnpkCtfAskeyInfo
(
CtfAsKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfAskeyInfo(param, mBuf)
+S16 cmUnpkCtfAskeyInfo(param, mBuf)
CtfAskeyInfo *param;
Buffer *mBuf;
#endif
*
* **********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfReqInfo
+S16 cmUnpkCtfKdfReqInfo
(
CtfKdfReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKdfReqInfo(param, mBuf)
+S16 cmUnpkCtfKdfReqInfo(param, mBuf)
CtfKdfReqInfo *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfReq
+S16 cmUnpkCtfKdfReq
(
CtfKdfReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKdfReq(func, pst, mBuf)
+S16 cmUnpkCtfKdfReq(func, pst, mBuf)
CtfKdfReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgReq
+S16 cmUnpkCtfCfgReq
(
CtfCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgReq(func, pst, mBuf)
+S16 cmUnpkCtfCfgReq(func, pst, mBuf)
CtfCfgReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfNhKeyCfmInfo
+S16 cmPkCtfNhKeyCfmInfo
(
CtfNhKeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfNhKeyCfmInfo(param, mBuf)
+S16 cmPkCtfNhKeyCfmInfo(param, mBuf)
CtfNhKeyCfmInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKenbStarCfmInfo
+S16 cmPkCtfKenbStarCfmInfo
(
CtfKenbStarCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKenbStarCfmInfo(param, mBuf)
+S16 cmPkCtfKenbStarCfmInfo(param, mBuf)
CtfKenbStarCfmInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfAskeyCfmInfo
+S16 cmPkCtfAskeyCfmInfo
(
CtfAskeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfAskeyCfmInfo(param, mBuf)
+S16 cmPkCtfAskeyCfmInfo(param, mBuf)
CtfAskeyCfmInfo *param;
Buffer *mBuf;
#endif
*
* **********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfCfmInfo
+S16 cmPkCtfKdfCfmInfo
(
CtfKdfCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKdfCfmInfo(param, mBuf)
+S16 cmPkCtfKdfCfmInfo(param, mBuf)
CtfKdfCfmInfo *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfCfm
+S16 cmPkCtfKdfCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkCtfKdfCfm(pst, suId, transId, status)
+S16 cmPkCtfKdfCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgCfm
+S16 cmPkCtfCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkCtfCfgCfm(pst, suId, transId, status)
+S16 cmPkCtfCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfEnbStopInd
+S16 cmPkCtfEnbStopInd
(
Pst* pst,
SuId suId,
CtfCfgTransId transId
)
#else
-PUBLIC S16 cmPkCtfEnbStopInd(pst, suId, transId)
+S16 cmPkCtfEnbStopInd(pst, suId, transId)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfNhKeyCfmInfo
+S16 cmUnpkCtfNhKeyCfmInfo
(
CtfNhKeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfNhKeyCfmInfo(param, mBuf)
+S16 cmUnpkCtfNhKeyCfmInfo(param, mBuf)
CtfNhKeyCfmInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKenbStarCfmInfo
+S16 cmUnpkCtfKenbStarCfmInfo
(
CtfKenbStarCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKenbStarCfmInfo(param, mBuf)
+S16 cmUnpkCtfKenbStarCfmInfo(param, mBuf)
CtfKenbStarCfmInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfAskeyCfmInfo
+S16 cmUnpkCtfAskeyCfmInfo
(
CtfAskeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfAskeyCfmInfo(param, mBuf)
+S16 cmUnpkCtfAskeyCfmInfo(param, mBuf)
CtfAskeyCfmInfo *param;
Buffer *mBuf;
#endif
*
* **********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfCfmInfo
+S16 cmUnpkCtfKdfCfmInfo
(
CtfKdfCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKdfCfmInfo(param, mBuf)
+S16 cmUnpkCtfKdfCfmInfo(param, mBuf)
CtfKdfCfmInfo *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfCfm
+S16 cmUnpkCtfKdfCfm
(
CtfKdfCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
+S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
CtfKdfCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgCfm
+S16 cmUnpkCtfCfgCfm
(
CtfCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
+S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
CtfCfgCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfEnbStopInd
+S16 cmUnpkCtfEnbStopInd
(
CtfEnbStopInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfEnbStopInd(func, pst, mBuf)
+S16 cmUnpkCtfEnbStopInd(func, pst, mBuf)
CtfEnbStopInd func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeIdChgReq
+S16 cmPkCtfUeIdChgReq
(
Pst* pst,
SpId spId,
CtfUeInfo * newUeInfo
)
#else
-PUBLIC S16 cmPkCtfUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
+S16 cmPkCtfUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst* pst;
SpId spId;
CtfCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeIdChgReq
+S16 cmUnpkCtfUeIdChgReq
(
CtfUeIdChgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeIdChgReq(func, pst, mBuf)
+S16 cmUnpkCtfUeIdChgReq(func, pst, mBuf)
CtfUeIdChgReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeIdChgCfm
+S16 cmPkCtfUeIdChgCfm
(
Pst* pst,
SuId suId,
CmStatus status
)
#else
-PUBLIC S16 cmPkCtfUeIdChgCfm(pst, suId, transId, ueInfo, status)
+S16 cmPkCtfUeIdChgCfm(pst, suId, transId, ueInfo, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeIdChgCfm
+S16 cmUnpkCtfUeIdChgCfm
(
CtfUeIdChgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeIdChgCfm(func, pst, mBuf)
+S16 cmUnpkCtfUeIdChgCfm(func, pst, mBuf)
CtfUeIdChgCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgTransId
+S16 cmPkCtfCfgTransId
(
CtfCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCfgTransId(param, mBuf)
+S16 cmPkCtfCfgTransId(param, mBuf)
CtfCfgTransId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgTransId
+S16 cmUnpkCtfCfgTransId
(
CtfCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgTransId(param, mBuf)
+S16 cmUnpkCtfCfgTransId(param, mBuf)
CtfCfgTransId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeInfo
+S16 cmPkCtfUeInfo
(
CtfUeInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfUeInfo(param, mBuf)
+S16 cmPkCtfUeInfo(param, mBuf)
CtfUeInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeInfo
+S16 cmUnpkCtfUeInfo
(
CtfUeInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeInfo(param, mBuf)
+S16 cmUnpkCtfUeInfo(param, mBuf)
CtfUeInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfBwCfgInfo
+S16 cmPkCtfBwCfgInfo
(
CtfBwCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfBwCfgInfo(param, mBuf)
+S16 cmPkCtfBwCfgInfo(param, mBuf)
CtfBwCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfBwCfgInfo
+S16 cmUnpkCtfBwCfgInfo
(
CtfBwCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfBwCfgInfo(param, mBuf)
+S16 cmUnpkCtfBwCfgInfo(param, mBuf)
CtfBwCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfTxSchemeCfg
+S16 cmPkCtfTxSchemeCfg
(
CtfTxSchemeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfTxSchemeCfg(param, mBuf)
+S16 cmPkCtfTxSchemeCfg(param, mBuf)
CtfTxSchemeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfTxSchemeCfg
+S16 cmUnpkCtfTxSchemeCfg
(
CtfTxSchemeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfTxSchemeCfg(param, mBuf)
+S16 cmUnpkCtfTxSchemeCfg(param, mBuf)
CtfTxSchemeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfAntennaCfgInfo
+S16 cmPkCtfAntennaCfgInfo
(
CtfAntennaCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfAntennaCfgInfo(param, mBuf)
+S16 cmPkCtfAntennaCfgInfo(param, mBuf)
CtfAntennaCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfAntennaCfgInfo
+S16 cmUnpkCtfAntennaCfgInfo
(
CtfAntennaCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfAntennaCfgInfo(param, mBuf)
+S16 cmUnpkCtfAntennaCfgInfo(param, mBuf)
CtfAntennaCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPrachCfgInfo
+S16 cmPkCtfPrachCfgInfo
(
CtfPrachCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPrachCfgInfo(param, mBuf)
+S16 cmPkCtfPrachCfgInfo(param, mBuf)
CtfPrachCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPrachCfgInfo
+S16 cmUnpkCtfPrachCfgInfo
(
CtfPrachCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPrachCfgInfo(param, mBuf)
+S16 cmUnpkCtfPrachCfgInfo(param, mBuf)
CtfPrachCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPdschCfgInfo
+S16 cmPkCtfPdschCfgInfo
(
CtfPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPdschCfgInfo(param, mBuf)
+S16 cmPkCtfPdschCfgInfo(param, mBuf)
CtfPdschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPdschCfgInfo
+S16 cmUnpkCtfPdschCfgInfo
(
CtfPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPdschCfgInfo(param, mBuf)
+S16 cmUnpkCtfPdschCfgInfo(param, mBuf)
CtfPdschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPuschCfgBasic
+S16 cmPkCtfPuschCfgBasic
(
CtfPuschCfgBasic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPuschCfgBasic(param, mBuf)
+S16 cmPkCtfPuschCfgBasic(param, mBuf)
CtfPuschCfgBasic *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPuschCfgBasic
+S16 cmUnpkCtfPuschCfgBasic
(
CtfPuschCfgBasic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPuschCfgBasic(param, mBuf)
+S16 cmUnpkCtfPuschCfgBasic(param, mBuf)
CtfPuschCfgBasic *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPuschUlRS
+S16 cmPkCtfPuschUlRS
(
CtfPuschUlRS *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPuschUlRS(param, mBuf)
+S16 cmPkCtfPuschUlRS(param, mBuf)
CtfPuschUlRS *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPuschUlRS
+S16 cmUnpkCtfPuschUlRS
(
CtfPuschUlRS *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPuschUlRS(param, mBuf)
+S16 cmUnpkCtfPuschUlRS(param, mBuf)
CtfPuschUlRS *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPuschCfgInfo
+S16 cmPkCtfPuschCfgInfo
(
CtfPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPuschCfgInfo(param, mBuf)
+S16 cmPkCtfPuschCfgInfo(param, mBuf)
CtfPuschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPuschCfgInfo
+S16 cmUnpkCtfPuschCfgInfo
(
CtfPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPuschCfgInfo(param, mBuf)
+S16 cmUnpkCtfPuschCfgInfo(param, mBuf)
CtfPuschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPhichCfgInfo
+S16 cmPkCtfPhichCfgInfo
(
CtfPhichCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPhichCfgInfo(param, mBuf)
+S16 cmPkCtfPhichCfgInfo(param, mBuf)
CtfPhichCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPhichCfgInfo
+S16 cmUnpkCtfPhichCfgInfo
(
CtfPhichCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPhichCfgInfo(param, mBuf)
+S16 cmUnpkCtfPhichCfgInfo(param, mBuf)
CtfPhichCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPucchCfgInfo
+S16 cmPkCtfPucchCfgInfo
(
CtfPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPucchCfgInfo(param, mBuf)
+S16 cmPkCtfPucchCfgInfo(param, mBuf)
CtfPucchCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPucchCfgInfo
+S16 cmUnpkCtfPucchCfgInfo
(
CtfPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPucchCfgInfo(param, mBuf)
+S16 cmUnpkCtfPucchCfgInfo(param, mBuf)
CtfPucchCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfSrsUlCfgInfo
+S16 cmPkCtfSrsUlCfgInfo
(
CtfSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfSrsUlCfgInfo(param, mBuf)
+S16 cmPkCtfSrsUlCfgInfo(param, mBuf)
CtfSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfSrsUlCfgInfo
+S16 cmUnpkCtfSrsUlCfgInfo
(
CtfSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfSrsUlCfgInfo(param, mBuf)
+S16 cmUnpkCtfSrsUlCfgInfo(param, mBuf)
CtfSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfTddSfCfgInfo
+S16 cmPkCtfTddSfCfgInfo
(
CtfTddSfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfTddSfCfgInfo(param, mBuf)
+S16 cmPkCtfTddSfCfgInfo(param, mBuf)
CtfTddSfCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfVendorSpecParams
+S16 cmPkCtfVendorSpecParams
(
CtfVendorSpecific *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfVendorSpecParams(param, mBuf)
+S16 cmPkCtfVendorSpecParams(param, mBuf)
CtfVendorSpecific *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfVendorSpecParams
+S16 cmUnpkCtfVendorSpecParams
(
Pst *pst,
CtfVendorSpecific *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfVendorSpecParams(pst, param, mBuf)
+S16 cmUnpkCtfVendorSpecParams(pst, param, mBuf)
Pst *pst;
CtfVendorSpecific *param;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfTddSfCfgInfo
+S16 cmUnpkCtfTddSfCfgInfo
(
CtfTddSfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfTddSfCfgInfo(param, mBuf)
+S16 cmUnpkCtfTddSfCfgInfo(param, mBuf)
CtfTddSfCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellCfgInfo
+S16 cmPkCtfCellCfgInfo
(
CtfCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellCfgInfo(param, mBuf)
+S16 cmPkCtfCellCfgInfo(param, mBuf)
CtfCellCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellCfgInfo
+S16 cmUnpkCtfCellCfgInfo
(
CtfCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellCfgInfo(param, mBuf)
+S16 cmUnpkCtfCellCfgInfo(param, mBuf)
CtfCellCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellRecfgInfo
+S16 cmPkCtfCellRecfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellRecfgInfo(param, mBuf)
+S16 cmPkCtfCellRecfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellRecfgInfo
+S16 cmUnpkCtfCellRecfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellRecfgInfo(param, mBuf)
+S16 cmUnpkCtfCellRecfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedPdschCfgInfo
+S16 cmPkCtfDedPdschCfgInfo
(
CtfDedPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedPdschCfgInfo(param, mBuf)
+S16 cmPkCtfDedPdschCfgInfo(param, mBuf)
CtfDedPdschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedPdschCfgInfo
+S16 cmUnpkCtfDedPdschCfgInfo
(
CtfDedPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedPdschCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedPdschCfgInfo(param, mBuf)
CtfDedPdschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedPucchCfgInfo
+S16 cmPkCtfDedPucchCfgInfo
(
CtfDedPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedPucchCfgInfo(param, mBuf)
+S16 cmPkCtfDedPucchCfgInfo(param, mBuf)
CtfDedPucchCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedPucchCfgInfo
+S16 cmUnpkCtfDedPucchCfgInfo
(
CtfDedPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedPucchCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedPucchCfgInfo(param, mBuf)
CtfDedPucchCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedPuschCfgInfo
+S16 cmPkCtfDedPuschCfgInfo
(
CtfDedPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedPuschCfgInfo(param, mBuf)
+S16 cmPkCtfDedPuschCfgInfo(param, mBuf)
CtfDedPuschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedPuschCfgInfo
+S16 cmUnpkCtfDedPuschCfgInfo
(
CtfDedPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedPuschCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedPuschCfgInfo(param, mBuf)
CtfDedPuschCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCqiRptModePeriodic
+S16 cmPkCtfCqiRptModePeriodic
(
CtfCqiRptModePeriodic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCqiRptModePeriodic(param, mBuf)
+S16 cmPkCtfCqiRptModePeriodic(param, mBuf)
CtfCqiRptModePeriodic *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCqiRptModePeriodic
+S16 cmUnpkCtfCqiRptModePeriodic
(
CtfCqiRptModePeriodic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCqiRptModePeriodic(param, mBuf)
+S16 cmUnpkCtfCqiRptModePeriodic(param, mBuf)
CtfCqiRptModePeriodic *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCqiReportCfgInfo
+S16 cmPkCtfCqiReportCfgInfo
(
CtfCqiReportCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCqiReportCfgInfo(param, mBuf)
+S16 cmPkCtfCqiReportCfgInfo(param, mBuf)
CtfCqiReportCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCqiReportCfgInfo
+S16 cmUnpkCtfCqiReportCfgInfo
(
CtfCqiReportCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCqiReportCfgInfo(param, mBuf)
+S16 cmUnpkCtfCqiReportCfgInfo(param, mBuf)
CtfCqiReportCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedSrsUlCfgInfo
+S16 cmPkCtfDedSrsUlCfgInfo
(
CtfDedSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedSrsUlCfgInfo(param, mBuf)
+S16 cmPkCtfDedSrsUlCfgInfo(param, mBuf)
CtfDedSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedSrsUlCfgInfo
+S16 cmUnpkCtfDedSrsUlCfgInfo
(
CtfDedSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedSrsUlCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedSrsUlCfgInfo(param, mBuf)
CtfDedSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedSRCfgInfo
+S16 cmPkCtfDedSRCfgInfo
(
CtfDedSRCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedSRCfgInfo(param, mBuf)
+S16 cmPkCtfDedSRCfgInfo(param, mBuf)
CtfDedSRCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedSRCfgInfo
+S16 cmUnpkCtfDedSRCfgInfo
(
CtfDedSRCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedSRCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedSRCfgInfo(param, mBuf)
CtfDedSRCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedAntCfgInfo
+S16 cmPkCtfDedAntCfgInfo
(
CtfDedAntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedAntCfgInfo(param, mBuf)
+S16 cmPkCtfDedAntCfgInfo(param, mBuf)
CtfDedAntCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedAntCfgInfo
+S16 cmUnpkCtfDedAntCfgInfo
(
CtfDedAntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedAntCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedAntCfgInfo(param, mBuf)
CtfDedAntCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeSecCellCfgInfo
+S16 cmPkCtfUeSecCellCfgInfo
(
CtfUeSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfUeSecCellCfgInfo(*param, mBuf)
+S16 cmPkCtfUeSecCellCfgInfo(*param, mBuf)
CtfUeSecCellCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfSecCellCfgInfo
+S16 cmPkCtfSecCellCfgInfo
(
CtfSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfSecCellCfgInfo(*param, mBuf)
+S16 cmPkCtfSecCellCfgInfo(*param, mBuf)
CtfSecCellCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeSecCellCfgInfo
+S16 cmUnpkCtfUeSecCellCfgInfo
(
CtfUeSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeSecCellCfgInfo(*param, mBuf)
+S16 cmUnpkCtfUeSecCellCfgInfo(*param, mBuf)
CtfUeSecCellCfgInfo *param;
Buffer *mBuf;
#endif
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfSecCellCfgInfo
+S16 cmUnpkCtfSecCellCfgInfo
(
CtfSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfSecCellCfgInfo(*param, mBuf)
+S16 cmUnpkCtfSecCellCfgInfo(*param, mBuf)
CtfSecCellCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeCatCfgInfo
+S16 cmPkCtfUeCatCfgInfo
(
CtfUeCatCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfUeCatCfgInfo(param, mBuf)
+S16 cmPkCtfUeCatCfgInfo(param, mBuf)
CtfUeCatCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeCatCfgInfo
+S16 cmUnpkCtfUeCatCfgInfo
(
CtfUeCatCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeCatCfgInfo(param, mBuf)
+S16 cmUnpkCtfUeCatCfgInfo(param, mBuf)
CtfUeCatCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedCfgInfo
+S16 cmPkCtfDedCfgInfo
(
CtfDedCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedCfgInfo(param, mBuf)
+S16 cmPkCtfDedCfgInfo(param, mBuf)
CtfDedCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedCfgInfo
+S16 cmUnpkCtfDedCfgInfo
(
CtfDedCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedCfgInfo(param, mBuf)
CtfDedCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedRecfgInfo
+S16 cmPkCtfDedRecfgInfo
(
CtfDedRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedRecfgInfo(param, mBuf)
+S16 cmPkCtfDedRecfgInfo(param, mBuf)
CtfDedRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedRecfgInfo
+S16 cmUnpkCtfDedRecfgInfo
(
CtfDedRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedRecfgInfo(param, mBuf)
+S16 cmUnpkCtfDedRecfgInfo(param, mBuf)
CtfDedRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellReleaseInfo
+S16 cmPkCtfCellReleaseInfo
(
CtfCellReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellReleaseInfo(param, mBuf)
+S16 cmPkCtfCellReleaseInfo(param, mBuf)
CtfCellReleaseInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellReleaseInfo
+S16 cmUnpkCtfCellReleaseInfo
(
CtfCellReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellReleaseInfo(param, mBuf)
+S16 cmUnpkCtfCellReleaseInfo(param, mBuf)
CtfCellReleaseInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedReleaseInfo
+S16 cmPkCtfDedReleaseInfo
(
CtfDedReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedReleaseInfo(param, mBuf)
+S16 cmPkCtfDedReleaseInfo(param, mBuf)
CtfDedReleaseInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedReleaseInfo
+S16 cmUnpkCtfDedReleaseInfo
(
CtfDedReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedReleaseInfo(param, mBuf)
+S16 cmUnpkCtfDedReleaseInfo(param, mBuf)
CtfDedReleaseInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgInfo
+S16 cmPkCtfCfgInfo
(
CtfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCfgInfo(param, mBuf)
+S16 cmPkCtfCfgInfo(param, mBuf)
CtfCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgInfo
+S16 cmUnpkCtfCfgInfo
(
CtfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgInfo(param, mBuf)
+S16 cmUnpkCtfCfgInfo(param, mBuf)
CtfCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfReCfgInfo
+S16 cmPkCtfReCfgInfo
(
CtfReCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfReCfgInfo(param, mBuf)
+S16 cmPkCtfReCfgInfo(param, mBuf)
CtfReCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfReCfgInfo
+S16 cmUnpkCtfReCfgInfo
(
CtfReCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfReCfgInfo(param, mBuf)
+S16 cmUnpkCtfReCfgInfo(param, mBuf)
CtfReCfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfReleaseInfo
+S16 cmPkCtfReleaseInfo
(
CtfReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfReleaseInfo(param, mBuf)
+S16 cmPkCtfReleaseInfo(param, mBuf)
CtfReleaseInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfReleaseInfo
+S16 cmUnpkCtfReleaseInfo
(
CtfReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfReleaseInfo(param, mBuf)
+S16 cmUnpkCtfReleaseInfo(param, mBuf)
CtfReleaseInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgReqInfo
+S16 cmPkCtfCfgReqInfo
(
CtfCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCfgReqInfo(param, mBuf)
+S16 cmPkCtfCfgReqInfo(param, mBuf)
CtfCfgReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgReqInfo
+S16 cmUnpkCtfCfgReqInfo
(
Pst *pst,
CtfCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgReqInfo(param, mBuf)
+S16 cmUnpkCtfCfgReqInfo(param, mBuf)
Pst *pst;
CtfCfgReqInfo *param;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellPwrcfgInfo
+S16 cmPkCtfCellPwrcfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellPwrcfgInfo(param, mBuf)
+S16 cmPkCtfCellPwrcfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellPwrcfgInfo
+S16 cmUnpkCtfCellPwrcfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellPwrcfgInfo(param, mBuf)
+S16 cmUnpkCtfCellPwrcfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellStop
+S16 cmPkCtfCellStop
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellStop(param, mBuf)
+S16 cmPkCtfCellStop(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellStop
+S16 cmUnpkCtfCellStop
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellStop(param, mBuf)
+S16 cmUnpkCtfCellStop(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkPerRemScanCellInfo
+S16 cmPkPerRemScanCellInfo
(
CtfPeriodicRemCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkPerRemScanCellInfo(param, mBuf)
+S16 cmPkPerRemScanCellInfo(param, mBuf)
CtfPeriodicRemCellInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPeriodicCellSearchRsp
+S16 cmPkCtfPeriodicCellSearchRsp
(
CtfPeriodicRemCellSearchRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPeriodicCellSearchRsp(param, mBuf)
+S16 cmPkCtfPeriodicCellSearchRsp(param, mBuf)
CtfPeriodicRemCellSearchRsp *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPeriodicRemCellSearchRsp
+S16 cmPkCtfPeriodicRemCellSearchRsp
(
Pst* pst,
SpId spId,
CtfPeriodicRemCellSearchRsp *CellCfgRsp
)
#else
-PUBLIC S16 cmPkCtfPeriodicRemCellSearchRsp(pst, spId, transId, CellCfgRsp)
+S16 cmPkCtfPeriodicRemCellSearchRsp(pst, spId, transId, CellCfgRsp)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPerRemScanCellInfo
+S16 cmUnpkCtfPerRemScanCellInfo
(
CtfPeriodicRemCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPerRemScanCellInfo(param, mBuf)
+S16 cmUnpkCtfPerRemScanCellInfo(param, mBuf)
CtfPeriodicRemCellInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPerRemCellSrch
+S16 cmUnpkCtfPerRemCellSrch
(
CtfPeriodicRemCellSearchRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPerRemCellSrch(param, mBuf)
+S16 cmUnpkCtfPerRemCellSrch(param, mBuf)
CtfPeriodicRemCellSearchRsp *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPerRemCellSrchRsp
+S16 cmUnpkPerRemCellSrchRsp
(
CtfPerRemCellSrchRsp func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPerRemCellSrchRsp(func, pst, mBuf)
+S16 cmUnpkPerRemCellSrchRsp(func, pst, mBuf)
CtfPerRemCellSrchRsp func;
Pst *pst;
Buffer *mBuf;
EXTERN S16 cmPkTknStr132 ARGS((TknStr132 *tknStr, Buffer *mBuf));
EXTERN S16 cmPkTknStr256 ARGS((TknStr256 *tknStr, Buffer *mBuf));
-PUBLIC S16 cmPkTknS32 ARGS((TknS32 *tknS32, Buffer *mBuf));
-PUBLIC S16 cmPkTknOid ARGS((TknOid *tknOid, Buffer *mBuf));
-PUBLIC S16 cmPkTknBuf ARGS((TknBuf *tknBuf, Buffer *mBuf));
+ S16 cmPkTknS32 ARGS((TknS32 *tknS32, Buffer *mBuf));
+ S16 cmPkTknOid ARGS((TknOid *tknOid, Buffer *mBuf));
+ S16 cmPkTknBuf ARGS((TknBuf *tknBuf, Buffer *mBuf));
#ifdef TDS_ROLL_UPGRADE_SUPPORT
-PUBLIC S16 cmPkIntf ARGS((CmIntf *intf, Buffer *mBuf));
+ S16 cmPkIntf ARGS((CmIntf *intf, Buffer *mBuf));
#endif
/* layer management structures */
EXTERN S16 cmUnpkTknStr132 ARGS((TknStr132 *tknStr, Buffer *mBuf));
EXTERN S16 cmUnpkTknStr256 ARGS((TknStr256 *tknStr, Buffer *mBuf));
-PUBLIC S16 cmUnpkTknS32 ARGS((TknS32 *tknS32, Buffer *mBuf));
-PUBLIC S16 cmUnpkTknOid ARGS((TknOid *tknOid, Buffer *mBuf));
-PUBLIC S16 cmUnpkTknBuf ARGS((TknBuf *tknBuf, Buffer **mBuf));
+ S16 cmUnpkTknS32 ARGS((TknS32 *tknS32, Buffer *mBuf));
+ S16 cmUnpkTknOid ARGS((TknOid *tknOid, Buffer *mBuf));
+ S16 cmUnpkTknBuf ARGS((TknBuf *tknBuf, Buffer **mBuf));
#ifdef TDS_ROLL_UPGRADE_SUPPORT
-PUBLIC S16 cmUnpkIntf ARGS((CmIntf *intf, Buffer *mBuf));
+ S16 cmUnpkIntf ARGS((CmIntf *intf, Buffer *mBuf));
#endif
/* layer management structures */
* Packing Functions
***************************************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkKwuBndReq
+S16 cmPkKwuBndReq
(
Pst * pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkKwuBndReq(pst, suId, spId)
+S16 cmPkKwuBndReq(pst, suId, spId)
Pst * pst;
SuId suId;
SpId spId;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuBndCfm
+S16 cmPkKwuBndCfm
(
Pst * pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkKwuBndCfm(pst, suId, status)
+S16 cmPkKwuBndCfm(pst, suId, status)
Pst * pst;
SuId suId;
U8 status;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuUbndReq
+S16 cmPkKwuUbndReq
(
Pst * pst,
SuId suId,
Reason reason
)
#else
-PUBLIC S16 cmPkKwuUbndReq(pst, suId, reason)
+S16 cmPkKwuUbndReq(pst, suId, reason)
Pst * pst;
SuId suId;
Reason reason;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatCfmInfo
+S16 cmPkKwuDatCfmInfo
(
KwuDatCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuDatCfmInfo(param, mBuf)
+S16 cmPkKwuDatCfmInfo(param, mBuf)
KwuDatCfmInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatCfm
+S16 cmPkKwuDatCfm
(
Pst * pst,
SuId suId,
KwuDatCfmInfo* datCfm
)
#else
-PUBLIC S16 cmPkKwuDatCfm(pst, suId, datCfm)
+S16 cmPkKwuDatCfm(pst, suId, datCfm)
Pst * pst;
SuId suId;
KwuDatCfmInfo* datCfm;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDiscSduReq
+S16 cmPkKwuDiscSduReq
(
Pst * pst,
SpId spId,
KwuDiscSduInfo* discSdu
)
#else
-PUBLIC S16 cmPkKwuDiscSduReq(pst, spId, discSdu)
+S16 cmPkKwuDiscSduReq(pst, spId, discSdu)
Pst * pst;
SpId spId;
KwuDiscSduInfo* discSdu;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuStaIndInfo
+S16 cmPkKwuStaIndInfo
(
KwuStaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuStaIndInfo(param, mBuf)
+S16 cmPkKwuStaIndInfo(param, mBuf)
KwuStaIndInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkKwuFlowCntrlIndInfo
+S16 cmPkKwuFlowCntrlIndInfo
(
KwuFlowCntrlIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuFlowCntrlIndInfo(param, mBuf)
+S16 cmPkKwuFlowCntrlIndInfo(param, mBuf)
KwuFlowCntrlIndInfo *param;
Buffer *mBuf;
#endif
} /* cmPkKwuFlowCntrlIndInfo */
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo
+S16 cmUnpkKwuFlowCntrlIndInfo
(
KwuFlowCntrlIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf)
+S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf)
KwuFlowCntrlIndInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuStaInd
+S16 cmPkKwuStaInd
(
Pst * pst,
SuId suId,
KwuStaIndInfo* staInd
)
#else
-PUBLIC S16 cmPkKwuStaInd(pst, suId, staInd)
+S16 cmPkKwuStaInd(pst, suId, staInd)
Pst * pst;
SuId suId;
KwuStaIndInfo* staInd;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuReEstCmpInd
+S16 cmPkKwuReEstCmpInd
(
Pst * pst,
SuId suId,
CmLteRlcId rlcId
)
#else
-PUBLIC S16 cmPkKwuReEstCmpInd(pst, suId, rlcId)
+S16 cmPkKwuReEstCmpInd(pst, suId, rlcId)
Pst * pst;
SuId suId;
CmLteRlcId rlcId;
/* kwu_c_001.main_3 added support for L2 Measurement */
#ifdef ANSI
-PUBLIC S16 cmPkKwuDiscSduCfm
+S16 cmPkKwuDiscSduCfm
(
Pst *pst,
SpId spId,
KwuDiscSduInfo *discCfmSdu
)
#else
-PUBLIC S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu)
+S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu)
Pst *pst;
SpId spId;
KwuDiscSduInfo *discCfmSdu;
} /* cmPkKwuDiscSduCfm */
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuFlowCntrlInd
+S16 cmPkKwuFlowCntrlInd
(
Pst *pst,
SuId suId,
KwuFlowCntrlIndInfo *flowCntrlIndInfo
)
#else
-PUBLIC S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
+S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
Pst *pst;
SuId suId;
KwuFlowCntrlIndInfo *flowCntrlIndInfo;
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatAckInfo
+S16 cmPkKwuDatAckInfo
(
KwuDatAckInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuDatAckInfo(param, mBuf)
+S16 cmPkKwuDatAckInfo(param, mBuf)
KwuDatAckInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatAckInd
+S16 cmPkKwuDatAckInd
(
Pst * pst,
SuId suId,
KwuDatAckInfo* datInd
)
#else
-PUBLIC S16 cmPkKwuDatAckInd(pst, suId, datInd)
+S16 cmPkKwuDatAckInd(pst, suId, datInd)
Pst * pst;
SuId suId;
KwuDatAckInfo* datInd;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuBndReq
+S16 cmUnpkKwuBndReq
(
KwuBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuBndReq(func, pst, mBuf)
+S16 cmUnpkKwuBndReq(func, pst, mBuf)
KwuBndReq func;
Pst *pst;
Buffer *mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuBndCfm
+S16 cmUnpkKwuBndCfm
(
KwuBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuBndCfm(func, pst, mBuf)
+S16 cmUnpkKwuBndCfm(func, pst, mBuf)
KwuBndCfm func;
Pst *pst;
Buffer *mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuUbndReq
+S16 cmUnpkKwuUbndReq
(
KwuUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuUbndReq(func, pst, mBuf)
+S16 cmUnpkKwuUbndReq(func, pst, mBuf)
KwuUbndReq func;
Pst *pst;
Buffer *mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatReqInfo
+S16 cmUnpkKwuDatReqInfo
(
KwuDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatReqInfo(param, mBuf)
+S16 cmUnpkKwuDatReqInfo(param, mBuf)
KwuDatReqInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatReq
+S16 cmUnpkKwuDatReq
(
KwuDatReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatReq(func, pst, mBuf)
+S16 cmUnpkKwuDatReq(func, pst, mBuf)
KwuDatReq func;
Pst *pst;
Buffer *mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatCfmInfo
+S16 cmUnpkKwuDatCfmInfo
(
KwuDatCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatCfmInfo(param, mBuf)
+S16 cmUnpkKwuDatCfmInfo(param, mBuf)
KwuDatCfmInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatCfm
+S16 cmUnpkKwuDatCfm
(
KwuDatCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatCfm(func, pst, mBuf)
+S16 cmUnpkKwuDatCfm(func, pst, mBuf)
KwuDatCfm func;
Pst *pst;
Buffer *mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDiscSduReq
+S16 cmUnpkKwuDiscSduReq
(
KwuDiscSduReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDiscSduReq(func, pst, mBuf)
+S16 cmUnpkKwuDiscSduReq(func, pst, mBuf)
KwuDiscSduReq func;
Pst *pst;
Buffer *mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuStaIndInfo
+S16 cmUnpkKwuStaIndInfo
(
KwuStaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuStaIndInfo(param, mBuf)
+S16 cmUnpkKwuStaIndInfo(param, mBuf)
KwuStaIndInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuStaInd
+S16 cmUnpkKwuStaInd
(
KwuStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuStaInd(func, pst, mBuf)
+S16 cmUnpkKwuStaInd(func, pst, mBuf)
KwuStaInd func;
Pst *pst;
Buffer *mBuf;
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuReEstCmpInd
+S16 cmUnpkKwuReEstCmpInd
(
KwuReEstCmpInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf)
+S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf)
KwuReEstCmpInd func;
Pst *pst;
Buffer *mBuf;
/* kwu_c_001.main_3 added support for L2 Measurement */
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDiscSduCfm
+S16 cmUnpkKwuDiscSduCfm
(
KwuDiscSduCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf)
+S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf)
KwuDiscSduCfm func;
Pst *pst;
Buffer *mBuf;
return ((*func)(pst, spId, discSdu));
} /* cmUnpkKwuDiscSduCfm */
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuFlowCntrlInd
+S16 cmUnpkKwuFlowCntrlInd
(
KwuFlowCntrlInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf)
+S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf)
KwuFlowCntrlInd func;
Pst *pst;
Buffer *mBuf;
#ifdef LTE_L2_MEAS
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatAckInfo
+S16 cmUnpkKwuDatAckInfo
(
KwuDatAckInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatAckInfo(param, mBuf)
+S16 cmUnpkKwuDatAckInfo(param, mBuf)
KwuDatAckInfo *param;
Buffer *mBuf;
#endif
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatAckInd
+S16 cmUnpkKwuDatAckInd
(
KwuDatAckInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatAckInd(func, pst, mBuf)
+S16 cmUnpkKwuDatAckInd(func, pst, mBuf)
KwuDatAckInd func;
Pst *pst;
Buffer *mBuf;
* @details This primitive binds the RLC service user entity to the RLC product.
* The RLC service user must bind each KWU SAP individually before sending any
* other request. RLC acknowledges the receipt of the bind request by sending
- * a KwUiKwuBndCfm primitive.
+ * a RlcUiKwuBndCfm primitive.
* @param[in] pst - For the bind request, the event field in the Pst structure is set to
EVTKWUBNDREQ
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuBndReq ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuBndReq ARGS((Pst *pst,
SuId suId,
SpId spId));
/**
* @details RLC invokes the bind confirm primitive to acknowledge the receipt
- * of the KwUiKwuBndReq primitive from the service user. The status field
+ * of the RlcUiKwuBndReq primitive from the service user. The status field
* indicates whether the bind request succeeded or failed. The bind request
* may fail due to invalid parameters in the bind request from the
* service user (for example, an invalid spId).
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuBndCfm ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuBndCfm ARGS((Pst *pst,
SuId suId,
U8 status));
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuUbndReq ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuUbndReq ARGS((Pst *pst,
SpId spId,
Reason reason));
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuDatReq ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuDatReq ARGS((Pst *pst,
KwuDatReqInfo* datReq,
Buffer *buf));
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuDatInd ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuDatInd ARGS((Pst *pst,
KwuDatIndInfo* datInd,
Buffer *mBuf));
/**
- *@details This primitive is used by RLC as the confirmation for the KwUiKwuDatReq
+ *@details This primitive is used by RLC as the confirmation for the RlcUiKwuDatReq
to the service user (RLC/PDCP). It is used only in AM mode data transfers for
RLC.
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuDatCfm ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuDatCfm ARGS((Pst *pst,
SuId suId,
KwuDatCfmInfo* datCfm));
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuDiscSduReq ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuDiscSduReq ARGS((Pst *pst,
SpId spId,
KwuDiscSduInfo* discSdu));
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuStaInd ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuStaInd ARGS((Pst *pst,
SuId suId,
KwuStaIndInfo* staInd));
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuDiscSduCfm ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuDiscSduCfm ARGS((Pst *pst,
SpId spId,
KwuDiscSduInfo* discCfmSdu));
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuFlowCntrlInd ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuFlowCntrlInd ARGS((Pst *pst,
SuId suId,
KwuFlowCntrlIndInfo* flowCntrlIndInfo));
#ifdef LTE_L2_MEAS
* -# ROK
* -# RFAILED
*/
-EXTERN S16 KwUiKwuDatAckInd ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuDatAckInd ARGS((Pst *pst,
SuId suId,
KwuDatAckInfo* ackInd));
#endif /* LTE_L2_MEAS */
-EXTERN S16 KwUiKwuReEstCmpInd ARGS((Pst *pst,
+EXTERN S16 RlcUiKwuReEstCmpInd ARGS((Pst *pst,
SuId suId,
CmLteRlcId rlcId
));
#endif /* PJ */
#ifdef MAC_RLC_UL_RBUF
-EXTERN S16 kwUlBatchProc ARGS((Void));
+EXTERN S16 rlcUlBatchProc ARGS((Void));
#endif
/*****************************************************************************
* PACK/UNPACK FUNCTIONS
\f
/* forward references */
-PRIVATE S16 cmPkKwMngmt ARGS ((KwMngmt *param ,Event eventType,
+PRIVATE S16 cmPkRlcMngmt ARGS ((RlcMngmt *param ,Event eventType,
Buffer *mBuf));
-PRIVATE S16 cmPkRlcCfg ARGS ((KwMngmt *param ,Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmPkKwCntrl ARGS ((KwMngmt *cntrl, Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmPkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmPkKwSsta ARGS ((KwMngmt *ssta, Elmnt etmnt, Event eventType,
+PRIVATE S16 cmPkRlcCfg ARGS ((RlcMngmt *param ,Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmPkRlcCntrl ARGS ((RlcMngmt *cntrl, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmPkRlcUsta ARGS ((RlcMngmt *usta, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmPkRlcSsta ARGS ((RlcMngmt *ssta, Elmnt etmnt, Event eventType,
Buffer *mBuf));
-PRIVATE S16 cmPkKwSts ARGS ((KwMngmt *sts, Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmPkGenSts ARGS ((KwGenSts *gen, Buffer *mBuf));
-PRIVATE S16 cmPkCkwSapSts ARGS ((KwCkwCntSts *rcSap, Buffer *mBuf));
-PRIVATE S16 cmPkKwuSapSts ARGS ((KwKwuSapSts *ruSap, Buffer *mBuf));
+PRIVATE S16 cmPkRlcSts ARGS ((RlcMngmt *sts, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmPkGenSts ARGS ((RlcGenSts *gen, Buffer *mBuf));
+PRIVATE S16 cmPkCkwSapSts ARGS ((RlcCkwCntSts *rcSap, Buffer *mBuf));
+PRIVATE S16 cmPkKwuSapSts ARGS ((RlcKwuSapSts *ruSap, Buffer *mBuf));
/* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
* in general statstics.
* */
-PRIVATE S16 cmPkKwTrc ARGS ((KwMngmt *trc, Buffer *mBuf));
+PRIVATE S16 cmPkRlcTrc ARGS ((RlcMngmt *trc, Buffer *mBuf));
-PRIVATE S16 cmUnpkKwMngmt ARGS ((KwMngmt *param, Event eventType,
+PRIVATE S16 cmUnpkRlcMngmt ARGS ((RlcMngmt *param, Event eventType,
Buffer * mBuf));
-PRIVATE S16 cmUnpkRlcCfg ARGS ((KwMngmt *cfg, Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmUnpkKwCntrl ARGS ((KwMngmt *param, Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmUnpkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmUnpkKwSsta ARGS ((KwMngmt *ssta, Elmnt elmnt, Event eventType,
+PRIVATE S16 cmUnpkRlcCfg ARGS ((RlcMngmt *cfg, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmUnpkRlcCntrl ARGS ((RlcMngmt *param, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmUnpkRlcUsta ARGS ((RlcMngmt *usta, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmUnpkRlcSsta ARGS ((RlcMngmt *ssta, Elmnt elmnt, Event eventType,
Buffer *mBuf));
-PRIVATE S16 cmUnpkKwSts ARGS ((KwMngmt *sts, Elmnt elmnt, Buffer *mBuf));
-PRIVATE S16 cmUnpkGenSts ARGS ((KwGenSts *gen, Buffer *mBuf));
-PRIVATE S16 cmUnpkCkwSapSts ARGS ((KwCkwCntSts *rcSap, Buffer *mBuf));
-PRIVATE S16 cmUnpkKwuSapSts ARGS ((KwKwuSapSts *ruSap, Buffer *mBuf));
+PRIVATE S16 cmUnpkRlcSts ARGS ((RlcMngmt *sts, Elmnt elmnt, Buffer *mBuf));
+PRIVATE S16 cmUnpkGenSts ARGS ((RlcGenSts *gen, Buffer *mBuf));
+PRIVATE S16 cmUnpkCkwSapSts ARGS ((RlcCkwCntSts *rcSap, Buffer *mBuf));
+PRIVATE S16 cmUnpkKwuSapSts ARGS ((RlcKwuSapSts *ruSap, Buffer *mBuf));
/* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
* in general statstics.
* */
-PRIVATE S16 cmUnpkKwTrc ARGS ((KwMngmt *trc, Buffer *mBuf));
+PRIVATE S16 cmUnpkRlcTrc ARGS ((RlcMngmt *trc, Buffer *mBuf));
-PRIVATE S16 cmPkCkwSapSta ARGS ((KwCkwCntSapSta *rcSap, Buffer *mBuf));
-PRIVATE S16 cmUnpkCkwSapSta ARGS ((KwCkwCntSapSta *rcSap, Buffer *mBuf));
+PRIVATE S16 cmPkCkwSapSta ARGS ((RlcCkwCntSapSta *rcSap, Buffer *mBuf));
+PRIVATE S16 cmUnpkCkwSapSta ARGS ((RlcCkwCntSapSta *rcSap, Buffer *mBuf));
-PRIVATE S16 cmPkKwuSapSta ARGS ((KwKwuSapSta *rlSap, Buffer *mBuf));
-PRIVATE S16 cmUnpkKwuSapSta ARGS ((KwKwuSapSta *rlSap, Buffer *mBuf));
+PRIVATE S16 cmPkKwuSapSta ARGS ((RlcKwuSapSta *rlSap, Buffer *mBuf));
+PRIVATE S16 cmUnpkKwuSapSta ARGS ((RlcKwuSapSta *rlSap, Buffer *mBuf));
-PRIVATE S16 cmPkRguSapSta ARGS ((KwRguSapSta *mkSap, Buffer *mBuf));
-PRIVATE S16 cmUnpkRguSapSta ARGS ((KwRguSapSta *mkSap, Buffer *mBuf));
+PRIVATE S16 cmPkRguSapSta ARGS ((RlcRguSapSta *mkSap, Buffer *mBuf));
+PRIVATE S16 cmUnpkRguSapSta ARGS ((RlcRguSapSta *mkSap, Buffer *mBuf));
/**
* @brief
*/
#ifdef ANSI
-PUBLIC S16 packRlcConfigReq
+S16 packRlcConfigReq
(
Pst *pst, /* post structure */
-KwMngmt *cfg /* RLC LM structure */
+RlcMngmt *cfg /* RLC LM structure */
)
#else
-PUBLIC S16 packRlcConfigReq(pst, cfg)
+S16 packRlcConfigReq(pst, cfg)
Pst *pst; /* post structure */
-KwMngmt *cfg; /* RLC LM structure */
+RlcMngmt *cfg; /* RLC LM structure */
#endif
{
Buffer *mBuf; /* message buffer */
return (ret1);
}
- ret1 = cmPkKwMngmt(cfg, LKW_EVT_CFG_REQ, mBuf);
+ ret1 = cmPkRlcMngmt(cfg, LKW_EVT_CFG_REQ, mBuf);
if(ret1 != ROK)
{
if(ret1 != ROK)
{
LKWLOGERROR(pst, ERRCLS_ADD_RES, ELKW002, (ErrVal) ret1,
- "cmPkKwMngmt failure ......!");
+ "cmPkRlcMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return RFAILED;
*/
#ifdef ANSI
-PUBLIC S16 unpackRlcConfigReq
+S16 unpackRlcConfigReq
(
RlcConfigReq func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 unpackRlcConfigReq(func, pst, mBuf)
+S16 unpackRlcConfigReq(func, pst, mBuf)
RlcConfigReq func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
S16 ret1; /* Return value */
- KwMngmt cfg; /* RLC LM structure */
+ RlcMngmt cfg; /* RLC LM structure */
TRC3(unpackRlcConfigReq)
- cmMemset((U8 *) &cfg, (U8) 0, (S16) sizeof(KwMngmt));
- ret1 = cmUnpkKwMngmt(&cfg, LKW_EVT_CFG_REQ, mBuf);
+ cmMemset((U8 *) &cfg, (U8) 0, (S16) sizeof(RlcMngmt));
+ ret1 = cmUnpkRlcMngmt(&cfg, LKW_EVT_CFG_REQ, mBuf);
if(ret1 != ROK)
{
#if (ERRCLASS & ERRCLS_DEBUG)
/*MBUF_FIXX*/
LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW003, (ErrVal) ret1,
- "cmUnpkKwMngmt failure ......!");
+ "cmUnpkRlcMngmt failure ......!");
#endif /* ERRCLASS & ERRCLS_DEBUG */
return RFAILED;
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwCntrlReq
+S16 cmPkLkwCntrlReq
(
Pst *pst, /* post structure */
-KwMngmt *cntrl /* RLC LM structure */
+RlcMngmt *cntrl /* RLC LM structure */
)
#else
-PUBLIC S16 cmPkLkwCntrlReq(pst,cntrl)
+S16 cmPkLkwCntrlReq(pst,cntrl)
Pst *pst; /* post structure */
-KwMngmt *cntrl; /* RLC LM structure */
+RlcMngmt *cntrl; /* RLC LM structure */
#endif
{
Buffer *mBuf; /* message buffer */
return (ret1);
}
- ret1 = cmPkKwMngmt(cntrl, LKW_EVT_CNTRL_REQ, mBuf);
+ ret1 = cmPkRlcMngmt(cntrl, LKW_EVT_CNTRL_REQ, mBuf);
if(ret1 != ROK)
{
if(ret1 != ROK)
{
LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW005, (ErrVal) ret1,
- "cmPkKwMngmt failure ......!");
+ "cmPkRlcMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwCntrlReq
+S16 cmUnpkLkwCntrlReq
(
LkwCntrlReq func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwCntrlReq(func, pst, mBuf)
+S16 cmUnpkLkwCntrlReq(func, pst, mBuf)
LkwCntrlReq func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
S16 ret1; /* return value */
- KwMngmt cfm; /* Confirmation */
+ RlcMngmt cfm; /* Confirmation */
TRC3(cmUnpkLkwCntrlReq)
- ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CNTRL_REQ, mBuf);
+ ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_CNTRL_REQ, mBuf);
if(ret1 != ROK)
{
#if (ERRCLASS & ERRCLS_DEBUG)
/*MBUF_FIXX*/
LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW006, (ErrVal) ret1,
- "cmUnpkKwMngmt failure ......!");
+ "cmUnpkRlcMngmt failure ......!");
#endif /* ERRCLASS & ERRCLS_DEBUG */
return RFAILED;
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwCntrlCfm
+S16 cmPkLkwCntrlCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* RLC LM structure */
+RlcMngmt *cfm /* RLC LM structure */
)
#else
-PUBLIC S16 cmPkLkwCntrlCfm(pst, cfm)
+S16 cmPkLkwCntrlCfm(pst, cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* RLC LM structure */
+RlcMngmt *cfm; /* RLC LM structure */
#endif
{
Buffer *mBuf; /* message buffer */
return (ret1);
}
- ret1 = cmPkKwMngmt(cfm, LKW_EVT_CNTRL_CFM, mBuf);
+ ret1 = cmPkRlcMngmt(cfm, LKW_EVT_CNTRL_CFM, mBuf);
if(ret1 != ROK)
{
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwCntrlCfm
+S16 cmUnpkLkwCntrlCfm
(
LkwCntrlCfm func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwCntrlCfm(func, pst, mBuf)
+S16 cmUnpkLkwCntrlCfm(func, pst, mBuf)
LkwCntrlCfm func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
- KwMngmt cfm; /* RLC LM structure */
+ RlcMngmt cfm; /* RLC LM structure */
S16 ret1; /* return value */
TRC3(cmUnpkLkwCntrlCfm)
- ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CNTRL_CFM, mBuf);
+ ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_CNTRL_CFM, mBuf);
if(ret1 != ROK)
{
if(ret1 != ROK)
{
LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW009, (ErrVal) ret1,
- "cmUnpkKwMngmt failure ......!");
+ "cmUnpkRlcMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
return RFAILED;
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwStsCfm
+S16 cmUnpkLkwStsCfm
(
LkwStsCfm func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwStsCfm(func, pst, mBuf)
+S16 cmUnpkLkwStsCfm(func, pst, mBuf)
LkwStsCfm func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
- KwMngmt cfm; /* RLC LM structure */
+ RlcMngmt cfm; /* RLC LM structure */
S16 ret1; /* return value */
TRC3(cmUnpkLkwStsCfm)
- ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_STS_CFM, mBuf);
+ ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_STS_CFM, mBuf);
if(ret1 != ROK)
{
#ifdef ANSI
-PUBLIC S16 packRlcConfigCfm
+S16 packRlcConfigCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* RLC LM structure */
+RlcMngmt *cfm /* RLC LM structure */
)
#else
-PUBLIC S16 packRlcConfigCfm(pst,cfm)
+S16 packRlcConfigCfm(pst,cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* RLC LM structure */
+RlcMngmt *cfm; /* RLC LM structure */
#endif
{
Buffer *mBuf; /* message buffer */
return (ret1);
}
- ret1 = cmPkKwMngmt(cfm, LKW_EVT_CFG_CFM, mBuf);
+ ret1 = cmPkRlcMngmt(cfm, LKW_EVT_CFG_CFM, mBuf);
if(ret1 != ROK)
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 unpackRlcConfigCfm
+S16 unpackRlcConfigCfm
(
RlcConfigCfm func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 unpackRlcConfigCfm(func, pst, mBuf)
+S16 unpackRlcConfigCfm(func, pst, mBuf)
RlcConfigCfm func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
S16 ret1; /* return value */
- KwMngmt cfm; /* RLC LM structure */
+ RlcMngmt cfm; /* RLC LM structure */
TRC3(unpackRlcConfigCfm)
- ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CFG_CFM, mBuf);
+ ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_CFG_CFM, mBuf);
if(ret1 != ROK)
{
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwStaInd
+S16 cmPkLkwStaInd
(
Pst *pst, /* post structure */
-KwMngmt *usta /* RLC LM structure */
+RlcMngmt *usta /* RLC LM structure */
)
#else
-PUBLIC S16 cmPkLkwStaInd(pst,usta)
+S16 cmPkLkwStaInd(pst,usta)
Pst *pst; /* post structure */
-KwMngmt *usta; /* RLC LM structure */
+RlcMngmt *usta; /* RLC LM structure */
#endif
{
Buffer *mBuf; /* message buffer */
return (ret1);
}
- ret1 = cmPkKwMngmt(usta, LKW_EVT_STA_IND, mBuf);
+ ret1 = cmPkRlcMngmt(usta, LKW_EVT_STA_IND, mBuf);
if(ret1 != ROK)
{
if(ret1 != ROK)
{
LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW015, (ErrVal) ret1,
- "cmPkKwMngmt failure ......!");
+ "cmPkRlcMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwStaInd
+S16 cmUnpkLkwStaInd
(
LkwStaInd func, /* primitive pointer */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwStaInd(func, pst, mBuf)
+S16 cmUnpkLkwStaInd(func, pst, mBuf)
LkwStaInd func; /* primitive pointer */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
- KwMngmt usta; /* RLC LM structure */
+ RlcMngmt usta; /* RLC LM structure */
S16 ret1; /* return value */
TRC3(cmUnpkLkwStaInd)
- ret1 = cmUnpkKwMngmt(&usta, LKW_EVT_STA_IND, mBuf);
+ ret1 = cmUnpkRlcMngmt(&usta, LKW_EVT_STA_IND, mBuf);
if(ret1 != ROK)
{
if(ret1 != ROK)
{
LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW016, (ErrVal) ret1,
- "cmUnpkKwMngmt failure ......!");
+ "cmUnpkRlcMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
return RFAILED;
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwStaReq
+S16 cmPkLkwStaReq
(
Pst *pst, /* post structure */
-KwMngmt *sta /* status */
+RlcMngmt *sta /* status */
)
#else
-PUBLIC S16 cmPkLkwStaReq(pst,sta)
+S16 cmPkLkwStaReq(pst,sta)
Pst *pst; /* post structure */
-KwMngmt *sta; /* status */
+RlcMngmt *sta; /* status */
#endif
{
Buffer *mBuf; /* message buffer */
return RFAILED;
}
- ret1 = cmPkKwMngmt(sta, LKW_EVT_STA_REQ, mBuf);
+ ret1 = cmPkRlcMngmt(sta, LKW_EVT_STA_REQ, mBuf);
if(ret1 != ROK)
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwStaCfm
+S16 cmUnpkLkwStaCfm
(
LkwStaReq func, /* primitive pointer */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwStaCfm(func, pst, mBuf)
+S16 cmUnpkLkwStaCfm(func, pst, mBuf)
LkwStaReq func; /* primitive pointer */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
- KwMngmt cfm; /* RLC LM structure */
+ RlcMngmt cfm; /* RLC LM structure */
S16 ret1; /* return value */
TRC3(cmUnpkLkwStaReq)
- ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_STA_CFM, mBuf);
+ ret1 = cmUnpkRlcMngmt(&cfm, LKW_EVT_STA_CFM, mBuf);
if(ret1 != ROK)
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwStsReq
+S16 cmUnpkLkwStsReq
(
LkwStsReq func, /* primitive pointer */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwStsReq(func, pst, mBuf)
+S16 cmUnpkLkwStsReq(func, pst, mBuf)
LkwStsReq func; /* primitive pointer */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
- KwMngmt sts; /* RLC LM structure */
+ RlcMngmt sts; /* RLC LM structure */
S16 ret1; /* return value */
Action action; /* Action */
CMCHKUNPK(SUnpkS16, &action, mBuf);
- ret1 = cmUnpkKwMngmt(&sts, LKW_EVT_STS_REQ, mBuf);
+ ret1 = cmUnpkRlcMngmt(&sts, LKW_EVT_STS_REQ, mBuf);
if(ret1 != ROK)
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwStaReq
+S16 cmUnpkLkwStaReq
(
LkwStaReq func, /* primitive pointer */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwStaReq(func, pst, mBuf)
+S16 cmUnpkLkwStaReq(func, pst, mBuf)
LkwStaReq func; /* primitive pointer */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
- KwMngmt sta; /* RLC LM structure */
+ RlcMngmt sta; /* RLC LM structure */
S16 ret1; /* return value */
TRC3(cmUnpkLkwStaReq)
- ret1 = cmUnpkKwMngmt(&sta, LKW_EVT_STA_REQ, mBuf);
+ ret1 = cmUnpkRlcMngmt(&sta, LKW_EVT_STA_REQ, mBuf);
if(ret1 != ROK)
{
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwTrcInd
+S16 cmUnpkLkwTrcInd
(
LkwTrcInd func, /* primitive to call */
Pst *pst, /* post structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkLkwTrcInd(func, pst, mBuf)
+S16 cmUnpkLkwTrcInd(func, pst, mBuf)
LkwTrcInd func; /* primitive to call */
Pst *pst; /* post structure */
Buffer *mBuf; /* message buffer */
#endif
{
S16 ret1; /* return value */
- KwMngmt trc; /* RLC LM structure */
+ RlcMngmt trc; /* RLC LM structure */
TRC3(cmUnpkLkwTrcInd)
- ret1 = cmUnpkKwMngmt(&trc, LKW_EVT_TRC_IND, mBuf);
+ ret1 = cmUnpkRlcMngmt(&trc, LKW_EVT_TRC_IND, mBuf);
if(ret1 != ROK)
{
#ifdef ANSI
PRIVATE S16 cmPkCkwSapSta
(
-KwCkwCntSapSta *rcSap, /* SAP statistics */
+RlcCkwCntSapSta *rcSap, /* SAP statistics */
Buffer *mBuf /* Message buffer */
)
#else
PRIVATE S16 cmPkCkwSapSta(rcSap, mBuf)
-KwCkwCntSapSta *rcSap; /* SAP statistics */
+RlcCkwCntSapSta *rcSap; /* SAP statistics */
Buffer *mBuf; /* Message buffer */
#endif
{
#ifdef ANSI
PRIVATE S16 cmUnpkCkwSapSta
(
-KwCkwCntSapSta *rcSap, /* SAP statistics */
+RlcCkwCntSapSta *rcSap, /* SAP statistics */
Buffer *mBuf /* Message buffer */
)
#else
PRIVATE S16 cmUnpkCkwSapSta(rcSap, mBuf)
-KwCkwCntSapSta *rcSap; /* SAP statistics */
+RlcCkwCntSapSta *rcSap; /* SAP statistics */
Buffer *mBuf; /* Message buffer */
#endif
{
#ifdef ANSI
PRIVATE S16 cmPkKwuSapSta
(
-KwKwuSapSta *rlSap, /* SAP statistics */
+RlcKwuSapSta *rlSap, /* SAP statistics */
Buffer *mBuf /* Message buffer */
)
#else
PRIVATE S16 cmPkKwuSapSta(rlSap, mBuf)
-KwKwuSapSta *rlSap; /* SAP statistics */
+RlcKwuSapSta *rlSap; /* SAP statistics */
Buffer *mBuf; /* Message buffer */
#endif
{
#ifdef ANSI
PRIVATE S16 cmUnpkKwuSapSta
(
-KwKwuSapSta *rlSap, /* SAP statistics */
+RlcKwuSapSta *rlSap, /* SAP statistics */
Buffer *mBuf /* Message buffer */
)
#else
PRIVATE S16 cmUnpkKwuSapSta(rlSap, mBuf)
-KwKwuSapSta *rlSap; /* SAP statistics */
+RlcKwuSapSta *rlSap; /* SAP statistics */
Buffer *mBuf; /* Message buffer */
#endif
{
#ifdef ANSI
PRIVATE S16 cmPkRguSapSta
(
-KwRguSapSta *mkSap, /* SAP statistics */
+RlcRguSapSta *mkSap, /* SAP statistics */
Buffer *mBuf /* Message buffer */
)
#else
PRIVATE S16 cmPkRguSapSta(mkSap, mBuf)
-KwRguSapSta *mkSap; /* SAP statistics */
+RlcRguSapSta *mkSap; /* SAP statistics */
Buffer *mBuf; /* Message buffer */
#endif
{
* @brief
Unpack Rgu Sap Sta
*
- * @param[out] mkSap: KwRguSapSta structure
+ * @param[out] mkSap: RlcRguSapSta structure
* @param[in] mBuf : message buffer
* @return S16
* -# Success : ROK
#ifdef ANSI
PRIVATE S16 cmUnpkRguSapSta
(
-KwRguSapSta *mkSap, /* SAP statistics */
+RlcRguSapSta *mkSap, /* SAP statistics */
Buffer *mBuf /* Message buffer */
)
#else
PRIVATE S16 cmUnpkRguSapSta(mkSap, mBuf)
-KwRguSapSta *mkSap; /* SAP statistics */
+RlcRguSapSta *mkSap; /* SAP statistics */
Buffer *mBuf; /* Message buffer */
#endif
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwStaCfm
+S16 cmPkLkwStaCfm
(
Pst *pst, /* post structure */
-KwMngmt *cfm /* solicited status confirm */
+RlcMngmt *cfm /* solicited status confirm */
)
#else
-PUBLIC S16 cmPkLkwStaCfm(pst, cfm)
+S16 cmPkLkwStaCfm(pst, cfm)
Pst *pst; /* post structure */
-KwMngmt *cfm; /* solicited status confirm */
+RlcMngmt *cfm; /* solicited status confirm */
#endif
{
Buffer *mBuf; /* message buffer */
return RFAILED;
}
- ret1 = cmPkKwMngmt(cfm, LKW_EVT_STA_CFM, mBuf);
+ ret1 = cmPkRlcMngmt(cfm, LKW_EVT_STA_CFM, mBuf);
if(ret1 != ROK)
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwTrcInd
+S16 cmPkLkwTrcInd
(
Pst *pst, /* post structure */
-KwMngmt *trc, /* trace */
+RlcMngmt *trc, /* trace */
Buffer *trcBuf /* trace buffer */
)
#else
-PUBLIC S16 cmPkLkwTrcInd(pst, trc, trcBuf)
+S16 cmPkLkwTrcInd(pst, trc, trcBuf)
Pst *pst; /* post structure */
-KwMngmt *trc; /* trace */
+RlcMngmt *trc; /* trace */
Buffer *trcBuf; /* trace buffer */
#endif
{
SPutMsg(trcBuf);
}
- ret1 = cmPkKwMngmt(trc, LKW_EVT_TRC_IND, mBuf);
+ ret1 = cmPkRlcMngmt(trc, LKW_EVT_TRC_IND, mBuf);
if(ret1 != ROK)
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwStsReq
+S16 cmPkLkwStsReq
(
Pst *pst, /* post structure */
Action action, /* action */
-KwMngmt *sts /* statistics request */
+RlcMngmt *sts /* statistics request */
)
#else
-PUBLIC S16 cmPkLkwStsReq(pst, action, sts)
+S16 cmPkLkwStsReq(pst, action, sts)
Pst *pst; /* post structure */
Action action; /* action */
-KwMngmt *sts; /* statistics request */
+RlcMngmt *sts; /* statistics request */
#endif
{
return RFAILED;
}
- ret1 = cmPkKwMngmt(sts, LKW_EVT_STS_REQ, mBuf);
+ ret1 = cmPkRlcMngmt(sts, LKW_EVT_STS_REQ, mBuf);
if(ret1 != ROK)
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PUBLIC S16 cmPkLkwStsCfm
+S16 cmPkLkwStsCfm
(
Pst *pst, /* post structure */
Action action, /* action */
-KwMngmt *cfm /* statistics confirmation */
+RlcMngmt *cfm /* statistics confirmation */
)
#else
-PUBLIC S16 cmPkLkwStsCfm(pst, action, cfm)
+S16 cmPkLkwStsCfm(pst, action, cfm)
Pst *pst; /* post structure */
Action action; /* action */
-KwMngmt *cfm; /* statistics confirmation */
+RlcMngmt *cfm; /* statistics confirmation */
#endif
{
Buffer *mBuf; /* message buffer */
return RFAILED;
}
- ret1 = cmPkKwMngmt(cfm, LKW_EVT_STS_CFM, mBuf);
+ ret1 = cmPkRlcMngmt(cfm, LKW_EVT_STS_CFM, mBuf);
if(ret1 != ROK)
{
*/
#ifdef ANSI
-PRIVATE S16 cmPkKwMngmt
+PRIVATE S16 cmPkRlcMngmt
(
-KwMngmt *param, /* Managment */
+RlcMngmt *param, /* Managment */
Event eventType, /* Event type */
Buffer *mBuf /* Message Buffer */
)
#else
-PRIVATE S16 cmPkKwMngmt(param ,eventType, mBuf)
-KwMngmt *param; /* Managment */
+PRIVATE S16 cmPkRlcMngmt(param ,eventType, mBuf)
+RlcMngmt *param; /* Managment */
Event eventType; /* Event type */
Buffer *mBuf; /* Message Buffer */
#endif
{
S16 ret1; /* return value */
- TRC3(cmPkKwMngmt)
+ TRC3(cmPkRlcMngmt)
switch( eventType )
{
break;
case LKW_EVT_CNTRL_REQ:
- ret1 = cmPkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmPkRlcCntrl(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
return RFAILED;
break;
case LKW_EVT_STA_IND:
- ret1 = cmPkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmPkRlcUsta(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
return RFAILED;
case LKW_EVT_STA_REQ:
case LKW_EVT_STA_CFM:
- ret1 = cmPkKwSsta(param, param->hdr.elmId.elmnt , eventType, mBuf);
+ ret1 = cmPkRlcSsta(param, param->hdr.elmId.elmnt , eventType, mBuf);
if (ret1 != ROK)
{
return RFAILED;
case LKW_EVT_STS_REQ:
case LKW_EVT_STS_CFM:
- ret1 = cmPkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmPkRlcSts(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
return RFAILED;
}
break;
case LKW_EVT_TRC_IND:
- ret1 = cmPkKwTrc(param, mBuf);
+ ret1 = cmPkRlcTrc(param, mBuf);
if (ret1 != ROK)
{
return RFAILED;
CMCHKPK(cmPkHeader, ¶m->hdr, mBuf);
return ROK;
-} /* end of function cmPkKwMngmt */
+} /* end of function cmPkRlcMngmt */
/**
#ifdef ANSI
PRIVATE S16 cmPkRlcCfg
(
-KwMngmt *cfg,
+RlcMngmt *cfg,
Elmnt elmnt,
Buffer *mBuf
)
#else
PRIVATE S16 cmPkRlcCfg(cfg, elmnt, mBuf)
-KwMngmt *cfg;
+RlcMngmt *cfg;
Elmnt elmnt;
Buffer *mBuf;
#endif
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmPkKwCntrl
+PRIVATE S16 cmPkRlcCntrl
(
-KwMngmt *cntrl,
+RlcMngmt *cntrl,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmPkKwCntrl(cntrl, elmnt, mBuf)
-KwMngmt *cntrl;
+PRIVATE S16 cmPkRlcCntrl(cntrl, elmnt, mBuf)
+RlcMngmt *cntrl;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
U8 subAction; /* sub action */
- TRC3(cmPkKwCntrl)
+ TRC3(cmPkRlcCntrl)
switch( elmnt )
{
CMCHKPK(cmPkDateTime, &cntrl->t.cntrl.dt, mBuf);
return ROK;
-} /*end of function cmPkKwCntrl */
+} /*end of function cmPkRlcCntrl */
/**
* @brief
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmPkKwUsta
+PRIVATE S16 cmPkRlcUsta
(
-KwMngmt *usta,
+RlcMngmt *usta,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmPkKwUsta(usta, elmnt, mBuf)
-KwMngmt *usta;
+PRIVATE S16 cmPkRlcUsta(usta, elmnt, mBuf)
+RlcMngmt *usta;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmPkKwUsta)
+ TRC3(cmPkRlcUsta)
/* lkw_c_001.main_2 removed warning */
UNUSED(elmnt);
return ROK;
-} /* end of cmPkKwUsta */
+} /* end of cmPkRlcUsta */
/**
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmPkKwSsta
+PRIVATE S16 cmPkRlcSsta
(
-KwMngmt *ssta,
+RlcMngmt *ssta,
Elmnt elmnt,
Event eventType,
Buffer *mBuf
)
#else
-PRIVATE S16 cmPkKwSsta(ssta, elmnt, eventType, mBuf)
-KwMngmt *ssta;
+PRIVATE S16 cmPkRlcSsta(ssta, elmnt, eventType, mBuf)
+RlcMngmt *ssta;
Elmnt elmnt;
Event eventType;
Buffer *mBuf;
#endif
{
S16 ret1;
- TRC3(cmPkKwSsta)
+ TRC3(cmPkRlcSsta)
ret1 = RFAILED;
switch(elmnt)
ret1 = cmPkCkwSapSta(&ssta->t.ssta.s.ckwSap, mBuf);
break;
case STKWUSAP:
- ret1 = cmPkKwuSapSta(&ssta->t.ssta.s.kwuSap, mBuf);
+ ret1 = cmPkKwuSapSta(&ssta->t.ssta.s.rlckwuSap, mBuf);
break;
case STRGUSAP:
case STUDXSAP:
return ROK;
-} /* end of cmPkKwSsta */
+} /* end of cmPkRlcSsta */
/**
* @brief
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmPkKwTrc
+PRIVATE S16 cmPkRlcTrc
(
-KwMngmt *trc, /* trace */
+RlcMngmt *trc, /* trace */
Buffer *mBuf /* data buffer */
)
#else
-PRIVATE S16 cmPkKwTrc(trc, mBuf)
-KwMngmt *trc; /* trace */
+PRIVATE S16 cmPkRlcTrc(trc, mBuf)
+RlcMngmt *trc; /* trace */
Buffer *mBuf; /* data buffer */
#endif
{
- TRC3(cmPkKwTrc)
+ TRC3(cmPkRlcTrc)
CMCHKPK(oduUnpackUInt16, trc->t.trc.event, mBuf);
CMCHKPK(cmPkDateTime, &trc->t.trc.dt, mBuf);
return ROK;
-} /* end of cmPkKwTrc */
+} /* end of cmPkRlcTrc */
/**
*/
#ifdef ANSI
-PRIVATE S16 cmPkKwSts
+PRIVATE S16 cmPkRlcSts
(
-KwMngmt *sts,
+RlcMngmt *sts,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmPkKwSts(sts, elmnt, mBuf)
-KwMngmt *sts;
+PRIVATE S16 cmPkRlcSts(sts, elmnt, mBuf)
+RlcMngmt *sts;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
S16 ret1;
- TRC3(cmPkKwSts)
+ TRC3(cmPkRlcSts)
ret1 = RFAILED;
switch(elmnt)
ret1 = cmPkCkwSapSts(&sts->t.sts.s.ckwSap, mBuf);
break;
case STKWUSAP:
- ret1 = cmPkKwuSapSts(&sts->t.sts.s.kwuSap, mBuf);
+ ret1 = cmPkKwuSapSts(&sts->t.sts.s.rlckwuSap, mBuf);
break;
/* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
* in general statstics.
CMCHKPK(cmPkDateTime, &sts->t.sts.dt, mBuf);
return ROK;
-} /* end of cmPkKwSts */
+} /* end of cmPkRlcSts */
* @brief
Pack general statistics
*
- * @param[in] gen : KwGenSts structure
+ * @param[in] gen : RlcGenSts structure
* @param[in] mBuf : Buffer
* @return S16
* -# Success : ROK
#ifdef ANSI
PRIVATE S16 cmPkGenSts
(
-KwGenSts *gen,
+RlcGenSts *gen,
Buffer *mBuf
)
#else
PRIVATE S16 cmPkGenSts(gen, mBuf)
-KwGenSts *gen;
+RlcGenSts *gen;
Buffer *mBuf;
#endif
{
#ifdef ANSI
PRIVATE S16 cmPkCkwSapSts
(
-KwCkwCntSts *rcSap,
+RlcCkwCntSts *rcSap,
Buffer *mBuf
)
#else
PRIVATE S16 cmPkCkwSapSts(rcSap, mBuf)
-KwCkwCntSts *rcSap;
+RlcCkwCntSts *rcSap;
Buffer *mBuf;
#endif
{
#ifdef ANSI
PRIVATE S16 cmPkKwuSapSts
(
-KwKwuSapSts *ruSap,
+RlcKwuSapSts *ruSap,
Buffer *mBuf
)
#else
PRIVATE S16 cmPkKwuSapSts(ruSap, mBuf)
-KwKwuSapSts *ruSap;
+RlcKwuSapSts *ruSap;
Buffer *mBuf;
#endif
{
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmUnpkKwMngmt
+PRIVATE S16 cmUnpkRlcMngmt
(
-KwMngmt *param,
+RlcMngmt *param,
Event eventType,
Buffer *mBuf
)
#else
-PRIVATE S16 cmUnpkKwMngmt(param ,eventType, mBuf)
-KwMngmt *param;
+PRIVATE S16 cmUnpkRlcMngmt(param ,eventType, mBuf)
+RlcMngmt *param;
Event eventType;
Buffer *mBuf;
#endif
{
S16 ret1;
- TRC3(cmUnpkKwMngmt)
+ TRC3(cmUnpkRlcMngmt)
- cmMemset((U8 *) param, (U8) 0, (S16) sizeof(KwMngmt));
+ cmMemset((U8 *) param, (U8) 0, (S16) sizeof(RlcMngmt));
CMCHKUNPK(cmUnpkHeader, ¶m->hdr, mBuf);
CMCHKUNPK(cmUnpkCmStatus, ¶m->cfm, mBuf);
}
break;
case LKW_EVT_CNTRL_REQ:
- ret1 = cmUnpkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmUnpkRlcCntrl(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
return RFAILED;
break;
case LKW_EVT_STA_IND:
- ret1 = cmUnpkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmUnpkRlcUsta(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
return RFAILED;
case LKW_EVT_STA_REQ:
case LKW_EVT_STA_CFM:
- ret1 = cmUnpkKwSsta(param, param->hdr.elmId.elmnt, eventType,mBuf);
+ ret1 = cmUnpkRlcSsta(param, param->hdr.elmId.elmnt, eventType,mBuf);
if (ret1 != ROK)
{
return RFAILED;
case LKW_EVT_STS_REQ:
case LKW_EVT_STS_CFM:
- ret1 = cmUnpkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
+ ret1 = cmUnpkRlcSts(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
return RFAILED;
}
break;
case LKW_EVT_TRC_IND:
- ret1 = cmUnpkKwTrc(param, mBuf);
+ ret1 = cmUnpkRlcTrc(param, mBuf);
if (ret1 != ROK)
{
return RFAILED;
break;
}
return ROK;
-} /*end of function cmUnpkKwMngmt*/
+} /*end of function cmUnpkRlcMngmt*/
/**
* @brief
#ifdef ANSI
PRIVATE S16 cmUnpkRlcCfg
(
-KwMngmt *cfg,
+RlcMngmt *cfg,
Elmnt elmnt,
Buffer *mBuf
)
#else
PRIVATE S16 cmUnpkRlcCfg(cfg ,elmnt, mBuf)
-KwMngmt *cfg;
+RlcMngmt *cfg;
Elmnt elmnt;
Buffer *mBuf;
#endif
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmUnpkKwCntrl
+PRIVATE S16 cmUnpkRlcCntrl
(
-KwMngmt *cfm,
+RlcMngmt *cfm,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmUnpkKwCntrl(cfm, elmnt, mBuf)
-KwMngmt *cfm;
+PRIVATE S16 cmUnpkRlcCntrl(cfm, elmnt, mBuf)
+RlcMngmt *cfm;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
U8 subAction;
- KwDbgCntrl *dbgCntrl;
- KwTrcCntrl *trcCntrl;
+ RlcDbgCntrl *dbgCntrl;
+ RlcTrcCntrl *trcCntrl;
- TRC3(cmUnpkKwCntrl);
+ TRC3(cmUnpkRlcCntrl);
/* lkw_c_001.main_2 removed warning */
UNUSED(elmnt);
return ROK;
-} /* end of cmUnpkKwCntrl */
+} /* end of cmUnpkRlcCntrl */
/**
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmUnpkKwUsta
+PRIVATE S16 cmUnpkRlcUsta
(
-KwMngmt *usta,
+RlcMngmt *usta,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmUnpkKwUsta(usta ,elmnt, mBuf)
-KwMngmt *usta;
+PRIVATE S16 cmUnpkRlcUsta(usta ,elmnt, mBuf)
+RlcMngmt *usta;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwUsta);
+ TRC3(cmUnpkRlcUsta);
/* lkw_c_001.main_2 removed warning */
UNUSED(elmnt);
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmUnpkKwSsta
+PRIVATE S16 cmUnpkRlcSsta
(
-KwMngmt *ssta,
+RlcMngmt *ssta,
Elmnt elmnt,
Event eventType,
Buffer *mBuf
)
#else
-PRIVATE S16 cmUnpkKwSsta(ssta ,elmnt, eventType, mBuf)
-KwMngmt *ssta;
+PRIVATE S16 cmUnpkRlcSsta(ssta ,elmnt, eventType, mBuf)
+RlcMngmt *ssta;
Elmnt elmnt;
Event eventType;
Buffer *mBuf;
#endif
{
S16 ret1; /* return value */
- TRC3(cmUnpkKwSsta);
+ TRC3(cmUnpkRlcSsta);
CMCHKUNPK(cmUnpkDateTime, &ssta->t.ssta.dt, mBuf);
switch(elmnt)
ret1 = cmUnpkCkwSapSta(&ssta->t.ssta.s.ckwSap, mBuf);
break;
case STKWUSAP:
- ret1 = cmUnpkKwuSapSta(&ssta->t.ssta.s.kwuSap, mBuf);
+ ret1 = cmUnpkKwuSapSta(&ssta->t.ssta.s.rlckwuSap, mBuf);
break;
case STRGUSAP:
case STUDXSAP:
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmUnpkKwTrc
+PRIVATE S16 cmUnpkRlcTrc
(
-KwMngmt *trc,
+RlcMngmt *trc,
Buffer *mBuf
)
#else
-PRIVATE S16 cmUnpkKwTrc(trc, mBuf)
-KwMngmt *trc;
+PRIVATE S16 cmUnpkRlcTrc(trc, mBuf)
+RlcMngmt *trc;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwTrc);
+ TRC3(cmUnpkRlcTrc);
CMCHKUNPK(cmUnpkDateTime, &trc->t.trc.dt, mBuf);
CMCHKUNPK(oduPackUInt16, &trc->t.trc.event, mBuf);
return ROK;
-} /* end of cmUnpkKwTrc */
+} /* end of cmUnpkRlcTrc */
/**
* -# Failure : RFAILED
*/
#ifdef ANSI
-PRIVATE S16 cmUnpkKwSts
+PRIVATE S16 cmUnpkRlcSts
(
-KwMngmt *sts,
+RlcMngmt *sts,
Elmnt elmnt,
Buffer *mBuf
)
#else
-PRIVATE S16 cmUnpkKwSts(sts ,elmnt, mBuf)
-KwMngmt *sts;
+PRIVATE S16 cmUnpkRlcSts(sts ,elmnt, mBuf)
+RlcMngmt *sts;
Elmnt elmnt;
Buffer *mBuf;
#endif
{
S16 ret1; /* return value */
- TRC3(cmUnpkKwSts);
+ TRC3(cmUnpkRlcSts);
CMCHKUNPK(cmUnpkDateTime, &sts->t.sts.dt, mBuf);
ret1 = cmUnpkCkwSapSts(&sts->t.sts.s.ckwSap, mBuf);
break;
case STKWUSAP:
- ret1 = cmUnpkKwuSapSts(&sts->t.sts.s.kwuSap, mBuf);
+ ret1 = cmUnpkKwuSapSts(&sts->t.sts.s.rlckwuSap, mBuf);
break;
/* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
* in general statstics.
}
return ROK;
-} /* end of cmUnpkKwSts */
+} /* end of cmUnpkRlcSts */
/**
* @brief
Unpack General statistics
*
- * @param[out] gen : KwGenSts structure
+ * @param[out] gen : RlcGenSts structure
* @param[in] mBuf : message buffer
* @return S16
* -# Success : ROK
#ifdef ANSI
PRIVATE S16 cmUnpkGenSts
(
-KwGenSts *gen,
+RlcGenSts *gen,
Buffer *mBuf
)
#else
PRIVATE S16 cmUnpkGenSts(gen, mBuf)
-KwGenSts *gen;
+RlcGenSts *gen;
Buffer *mBuf;
#endif
{
* @brief
Unpack Ckw Sap Statistics
*
- * @param[out] rcSap : KwCkwCntSts structure
+ * @param[out] rcSap : RlcCkwCntSts structure
* @param[in] mBuf : message buffer
* @return S16
* -# Success : ROK
#ifdef ANSI
PRIVATE S16 cmUnpkCkwSapSts
(
-KwCkwCntSts *rcSap,
+RlcCkwCntSts *rcSap,
Buffer *mBuf
)
#else
PRIVATE S16 cmUnpkCkwSapSts(rcSap ,mBuf)
-KwCkwCntSts *rcSap;
+RlcCkwCntSts *rcSap;
Buffer *mBuf;
#endif
{
* @brief
Unpack Kwu Sap statistics
*
- * @param[out] : KwKwuSapSts structure
+ * @param[out] : RlcKwuSapSts structure
* @param[in] mBuf : message buffer
* @return S16
* -# Success : ROK
#ifdef ANSI
PRIVATE S16 cmUnpkKwuSapSts
(
-KwKwuSapSts *ruSap,
+RlcKwuSapSts *ruSap,
Buffer *mBuf
)
#else
PRIVATE S16 cmUnpkKwuSapSts(ruSap, mBuf)
-KwKwuSapSts *ruSap;
+RlcKwuSapSts *ruSap;
Buffer *mBuf;
#endif
{
/* lkw_c_001.main_2 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC S16 cmPkLkwL2MeasReq
+S16 cmPkLkwL2MeasReq
(
Pst * pst,
-KwL2MeasReqEvt *measReqEvt
+RlcL2MeasReqEvt *measReqEvt
)
#else
-PUBLIC S16 cmPkLkwL2MeasReq(pst, measReqEvt)
+S16 cmPkLkwL2MeasReq(pst, measReqEvt)
Pst * pst;
-KwL2MeasReqEvt *measReqEvt;
+RlcL2MeasReqEvt *measReqEvt;
#endif
{
Buffer *mBuf = NULLP;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
+ SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
return RFAILED;
}
- if (cmPkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK) {
+ if (cmPkRlcL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
+ SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
+ SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
+ SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
return RFAILED;
}
}
#ifdef ANSI
-PUBLIC S16 cmPkKwL2MeasReqInfo
+S16 cmPkRlcL2MeasReqInfo
(
-KwL2MeasReqInfo *param,
+RlcL2MeasReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwL2MeasReqInfo(param, mBuf)
-KwL2MeasReqInfo *param;
+S16 cmPkRlcL2MeasReqInfo(param, mBuf)
+RlcL2MeasReqInfo *param;
Buffer *mBuf;
#endif
{
U8 idx;
U16 idx1;
- TRC3(cmPkKwL2MeasReqInfo)
+ TRC3(cmPkRlcL2MeasReqInfo)
if((param->measType & LKW_L2MEAS_DL_IP) ||
(param->measType & LKW_L2MEAS_UL_IP))
}
#ifdef ANSI
-PUBLIC S16 cmPkLkwL2MeasStopReq
+S16 cmPkLkwL2MeasStopReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 cmPkLkwL2MeasStopReq(pst, measType)
+S16 cmPkLkwL2MeasStopReq(pst, measType)
Pst *pst;
U8 measType;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkLkwL2MeasSendReq
+S16 cmPkLkwL2MeasSendReq
(
Pst *pst,
U8 measType
)
#else
-PUBLIC S16 cmPkLkwL2MeasSendReq(pst, measType)
+S16 cmPkLkwL2MeasSendReq(pst, measType)
Pst *pst;
U8 measType;
#endif
}
#ifdef TENB_SPLIT_ARCH
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwL2MeasReq
+S16 cmUnpkLkwL2MeasReq
(
LkwL2MeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
+S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
LkwL2MeasReq func;
Pst *pst;
Buffer *mBuf;
#endif
{
- KwL2MeasReqEvt measReqEvt;
+ RlcL2MeasReqEvt measReqEvt;
TRC3(cmUnpkLkwL2MeasReq)
#endif
return RFAILED;
}
- if (cmUnpkKwL2MeasReqInfo(&measReqEvt.measReq, mBuf) != ROK)
+ if (cmUnpkRlcL2MeasReqInfo(&measReqEvt.measReq, mBuf) != ROK)
{
- /*SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));*/
+ /*SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));*/
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
#else
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwL2MeasReq
+S16 cmUnpkLkwL2MeasReq
(
LkwL2MeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
+S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
LkwL2MeasReq func;
Pst *pst;
Buffer *mBuf;
#endif
{
S16 ret;
- KwL2MeasReqEvt *measReqEvt;
+ RlcL2MeasReqEvt *measReqEvt;
TRC3(cmUnpkLkwL2MeasReq)
if((ret = SGetSBuf(pst->region, pst->pool, (Data **)&measReqEvt,\
- sizeof(KwL2MeasReqEvt))) != ROK)
+ sizeof(RlcL2MeasReqEvt))) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
return RFAILED;
}
- if (cmUnpkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK)
+ if (cmUnpkRlcL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK)
{
- SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
+ SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(RlcL2MeasReqEvt));
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkKwL2MeasReqInfo
+S16 cmUnpkRlcL2MeasReqInfo
(
-KwL2MeasReqInfo *param,
+RlcL2MeasReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwL2MeasReqInfo(param, mBuf)
-KwL2MeasReqInfo *param;
+S16 cmUnpkRlcL2MeasReqInfo(param, mBuf)
+RlcL2MeasReqInfo *param;
Buffer *mBuf;
#endif
{
U8 idx;
U16 idx1;
- TRC3(cmUnpkKwL2MeasReqInfo)
+ TRC3(cmUnpkRlcL2MeasReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->measType, mBuf);
}
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwL2MeasStopReq
+S16 cmUnpkLkwL2MeasStopReq
(
LkwL2MeasStopReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLkwL2MeasStopReq(func, pst, mBuf)
+S16 cmUnpkLkwL2MeasStopReq(func, pst, mBuf)
LkwL2MeasStopReq func;
Pst *pst;
Buffer *mBuf;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwL2MeasSendReq
+S16 cmUnpkLkwL2MeasSendReq
(
LkwL2MeasSendReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLkwL2MeasSendReq(func, pst, mBuf)
+S16 cmUnpkLkwL2MeasSendReq(func, pst, mBuf)
LkwL2MeasSendReq func;
Pst *pst;
Buffer *mBuf;
}
#ifdef ANSI
-PUBLIC S16 cmPkLkwL2MeasCfm
+S16 cmPkLkwL2MeasCfm
(
Pst * pst,
-KwL2MeasCfmEvt *measCfmEvt
+RlcL2MeasCfmEvt *measCfmEvt
)
#else
-PUBLIC S16 cmPkLkwL2MeasCfm(pst, measCfmEvt)
+S16 cmPkLkwL2MeasCfm(pst, measCfmEvt)
Pst * pst;
-KwL2MeasCfmEvt *measCfmEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
Buffer *mBuf = NULLP;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)measCfmEvt, sizeof(KwL2MeasCfmEvt));
+ SPutSBuf(pst->region, pst->pool, (Data *)measCfmEvt, sizeof(RlcL2MeasCfmEvt));
return RFAILED;
}
{
for(idx = 0; idx < measCfmEvt->val.nonIpThMeas.numCfm; idx++)
{
- if (cmPkKwL2MeasCfmInfo(&measCfmEvt->val.nonIpThMeas.measCfm[idx], \
+ if (cmPkRlcL2MeasCfmInfo(&measCfmEvt->val.nonIpThMeas.measCfm[idx], \
mBuf, measCfmEvt->measType) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
for(idx = 0; idx < measCfmEvt->val.ipThMeas.ueInfoLst[idx1].numCfm; idx++)
{
- if (cmPkKwL2MeasCfmInfo(&measCfmEvt->val.ipThMeas.ueInfoLst[idx1].\
+ if (cmPkRlcL2MeasCfmInfo(&measCfmEvt->val.ipThMeas.ueInfoLst[idx1].\
measCfm[idx], mBuf, measCfmEvt->measType) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
}
#ifdef ANSI
-PUBLIC S16 cmPkKwL2MeasCfmInfo
+S16 cmPkRlcL2MeasCfmInfo
(
-KwL2MeasCfmInfo *param,
+RlcL2MeasCfmInfo *param,
Buffer *mBuf,
U8 measType
)
#else
-PUBLIC S16 cmPkKwL2MeasCfmInfo(param, mBuf, measType)
-KwL2MeasCfmInfo *param;
+S16 cmPkRlcL2MeasCfmInfo(param, mBuf, measType)
+RlcL2MeasCfmInfo *param;
Buffer *mBuf;
U8 measType;
#endif
{
- TRC3(cmPkKwL2MeasCfmInfo)
+ TRC3(cmPkRlcL2MeasCfmInfo)
if((measType & LKW_L2MEAS_DL_IP) ||
(measType & LKW_L2MEAS_UL_IP))
}
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwL2MeasCfm
+S16 cmUnpkLkwL2MeasCfm
(
LkwL2MeasCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLkwL2MeasCfm(func, pst, mBuf)
+S16 cmUnpkLkwL2MeasCfm(func, pst, mBuf)
LkwL2MeasCfm func;
Pst *pst;
Buffer *mBuf;
{
U8 idx;
U16 idx1;
- KwL2MeasCfmEvt measCfmEvt;
+ RlcL2MeasCfmEvt measCfmEvt;
TRC3(cmUnpkLkwL2MeasCfm)
- cmMemset((U8 *)&measCfmEvt, 0 , sizeof(KwL2MeasCfmEvt));
+ cmMemset((U8 *)&measCfmEvt, 0 , sizeof(RlcL2MeasCfmEvt));
if (oduPackUInt32(&measCfmEvt.transId, mBuf) != ROK) {
SPutMsg(mBuf);
}
for(idx = measCfmEvt.val.ipThMeas.ueInfoLst[idx1].numCfm; idx > 0; idx--)
{
- if (cmUnpkKwL2MeasCfmInfo(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
+ if (cmUnpkRlcL2MeasCfmInfo(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
measCfm[idx - 1], mBuf, measCfmEvt.measType) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
}
for(idx = measCfmEvt.val.nonIpThMeas.numCfm; idx > 0; idx--)
{
- if (cmUnpkKwL2MeasCfmInfo(&measCfmEvt.val.nonIpThMeas.measCfm[idx - 1], \
+ if (cmUnpkRlcL2MeasCfmInfo(&measCfmEvt.val.nonIpThMeas.measCfm[idx - 1], \
mBuf, measCfmEvt.measType) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
}
#ifdef ANSI
-PUBLIC S16 cmUnpkKwL2MeasCfmInfo
+S16 cmUnpkRlcL2MeasCfmInfo
(
-KwL2MeasCfmInfo *param,
+RlcL2MeasCfmInfo *param,
Buffer *mBuf,
U8 measType
)
#else
-PUBLIC S16 cmUnpkKwL2MeasCfmInfo(param, mBuf, measType)
-KwL2MeasCfmInfo *param;
+S16 cmUnpkRlcL2MeasCfmInfo(param, mBuf, measType)
+RlcL2MeasCfmInfo *param;
Buffer *mBuf;
U8 measType;
#endif
{
- TRC3(cmUnpkKwL2MeasCfmInfo)
+ TRC3(cmUnpkRlcL2MeasCfmInfo)
if((measType & LKW_L2MEAS_DL_IP) ||
(measType & LKW_L2MEAS_UL_IP))
#ifdef ANSI
-PUBLIC S16 cmPkLkwL2MeasStopCfm
+S16 cmPkLkwL2MeasStopCfm
(
Pst * pst,
U8 measType,
U8 status
)
#else
-PUBLIC S16 cmPkLkwL2MeasStopCfm(pst, measType,status)
+S16 cmPkLkwL2MeasStopCfm(pst, measType,status)
Pst * pst;
U8 measType;
U8 status
}
#ifdef ANSI
-PUBLIC S16 cmUnpkLkwL2MeasStopCfm
+S16 cmUnpkLkwL2MeasStopCfm
(
LkwL2MeasStopCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLkwL2MeasStopCfm(func, pst, mBuf)
+S16 cmUnpkLkwL2MeasStopCfm(func, pst, mBuf)
LkwL2MeasStopCfm func;
Pst *pst;
Buffer *mBuf;
/** @brief
General Configuration Structure. */
-typedef struct kwGenCfg
+typedef struct rlcGenCfg
{
Pst lmPst; /*!< Post structure for communicating
with LM. */
U8 rlcMode; /*!< RLC_DL or RLC_UL */
/* Supported by SPLIT Architecture ends */
U16 maxRguSaps; /*!< Maximum RGU SAPs. */
-}KwGenCfg;
+}RlcGenCfg;
/** @brief
SAP Configuration Structure */
-typedef struct kwSapCfg
+typedef struct rlcSapCfg
{
Selector selector; /*!< Selector for LC/TC. */
MemoryId mem; /*!< Region and pool. */
U16 bndTmrIntvl; /*!< Bind timer interval. */
Priority priority; /*!< Priority. */
Route route; /*!< Route. */
-}KwSapCfg;
+}RlcSapCfg;
/** @brief
* Configuration Structure
{
union
{
- KwGenCfg gen; /*!< General configuraton. */
- KwSapCfg sap; /*!< SAP configuration. */
+ RlcGenCfg gen; /*!< General configuraton. */
+ RlcSapCfg sap; /*!< SAP configuration. */
}s;
}RlcCfg;
/** @brief
General Statistics Structure */
-typedef struct kwGenSts
+typedef struct rlcGenSts
{
CntrSts numUe; /*!< Total number of UEs. */
CntrSts pdusRecv; /*!< Number of PDUs received. */
to retransmission. */
CntrSts numOfRb; /*!< Total number of RBs in RLC. */
CntrSts numSduDisc; /*!< Number of SDUs discarded. */
-}KwGenSts;
+}RlcGenSts;
/** @brief
RLC Upper SAP statistics */
-typedef struct kwKwuSapSts
+typedef struct rlcKwuSapSts
{
/* lkw_x_001.main_2, changed from suId to spId */
SpId spId; /*!< Service Provider ID. */
CntrSts sduRx; /*!< Number of SDUs received. */
CntrSts sduTx; /*!< Number of tranxmitted SDUs. */
-}KwKwuSapSts;
+}RlcKwuSapSts;
/** @brief
RRC Control SAP Statistics */
-typedef struct kwCkwCntSts
+typedef struct rlcCkwCntSts
{
CntrSts statMsgs; /*!< Number of Status Messages send. */
-}KwCkwCntSts;
+}RlcCkwCntSts;
/** @brief
Statistics Structure */
-typedef struct kwSts
+typedef struct rlcSts
{
DateTime dt; /*!< Date and Time structure. */
union
{
- KwGenSts gen; /*!< General Statistics. */
- KwKwuSapSts kwuSap; /*!< RLC upper SAP statistics. */
- KwCkwCntSts ckwSap; /*!< RRC control SAP. */
+ RlcGenSts gen; /*!< General Statistics. */
+ RlcKwuSapSts rlckwuSap; /*!< RLC upper SAP statistics. */
+ RlcCkwCntSts ckwSap; /*!< RRC control SAP. */
}s;
-}KwSts;
+}RlcSts;
/** @brief
MAC Upper SAP Status Structure */
-typedef struct kwRguSapSta
+typedef struct rlcRguSapSta
{
SuId suId; /*!< Service user ID. */
State state; /*!< State of the SAP. */
-}KwRguSapSta;
+}RlcRguSapSta;
/** @brief
RLC Upper SAP Status Structure */
-typedef struct kwKwuSapSta
+typedef struct rlcKwuSapSta
{
SpId spId; /*!< Service provider ID. */
State state; /*!< State of the SAP. */
-}KwKwuSapSta;
+}RlcKwuSapSta;
/** @brief
RRC Control SAP Status Structure */
-typedef struct kwCkwCntSapSta
+typedef struct rlcCkwCntSapSta
{
SpId spId; /*!< Service provider ID. */
State state; /*!< State of the SAP. */
-}KwCkwCntSapSta;
+}RlcCkwCntSapSta;
/** @brief
Status Structure */
-typedef struct kwSSta
+typedef struct rlcSSta
{
DateTime dt; /*!< Date and Time structure. */
union
{
SystemId sysId; /*!< System ID. */
- KwRguSapSta rguSap; /*!< RLC lower SAP (MAC) status. */
- KwKwuSapSta kwuSap; /*!< RLC Upper SAP status. */
- KwCkwCntSapSta ckwSap; /*!< RRC Control SAP Status. */
+ RlcRguSapSta rguSap; /*!< RLC lower SAP (MAC) status. */
+ RlcKwuSapSta rlckwuSap; /*!< RLC Upper SAP status. */
+ RlcCkwCntSapSta ckwSap; /*!< RRC Control SAP Status. */
}s;
-}KwSSta;
+}RlcSSta;
/** @brief
Trace Control Structure */
-typedef struct kwTrcCntrl
+typedef struct rlcTrcCntrl
{
U8 trcMask; /*!< Trace mask. */
S16 trcLen; /*!< Trace length. */
-}KwTrcCntrl;
+}RlcTrcCntrl;
/** @brief
Debug Control Structure */
-typedef struct kwDbgCntrl
+typedef struct rlcDbgCntrl
{
U32 dbgMask; /*!< Debug mask. Assign non zero value to enable
and zero to disable debug */
-}KwDbgCntrl;
+}RlcDbgCntrl;
/** @brief
SAP Control Structure */
-typedef struct kwSapCntrl
+typedef struct rlcSapCntrl
{
SuId suId; /*!< Service user ID. */
SpId spId; /*!< Service provider ID. */
-}KwSapCntrl;
+}RlcSapCntrl;
/** @brief
Control Structure */
-typedef struct kwCntrl
+typedef struct rlcCntrl
{
DateTime dt; /*!< Date and Time structure. */
U8 action; /*!< Action. */
U8 subAction; /*!< Sub action. */
union
{
- KwTrcCntrl trcCntrl; /*!< Trace Control Structure. */
- KwDbgCntrl dbgCntrl; /*!< Debug Control Structure. */
- KwSapCntrl sapCntrl; /*!< SAP Control Structure. */
+ RlcTrcCntrl trcCntrl; /*!< Trace Control Structure. */
+ RlcDbgCntrl dbgCntrl; /*!< Debug Control Structure. */
+ RlcSapCntrl sapCntrl; /*!< SAP Control Structure. */
#ifdef SS_DIAG
U32 logMask; /*!< Logging Control Structure. */
#endif
}s;
-}KwCntrl;
+}RlcCntrl;
/** @brief
Unsolicited Status Structure */
-typedef struct kwUSta
+typedef struct rlcUSta
{
DateTime dt; /*!< Date and Time structure. */
CmAlarm alarm; /*!< Alarm. */
#ifdef LTE_L2_MEAS
U8 qci; /*!< Qci value */
#endif
-}KwUSta;
+}RlcUSta;
/** @brief
Trace Structure */
-typedef struct kwTrc
+typedef struct rlcTrc
{
DateTime dt; /*!< Date and Time structure. */
U16 event; /*!< Event. Events defined in the differenct RLC
interfaces are pssible values here.*/
-}KwTrc;
+}RlcTrc;
/** @brief
Layer Management Structure */
-typedef struct _kwMngmt
+typedef struct rlcMngmt
{
Header hdr; /*!< Common header. */
CmStatus cfm; /*!< Status of confirmation. */
union
{
RlcCfg cfg; /*!< General Configuration. */
- KwCntrl cntrl; /*!< Control Structure. */
- KwSts sts; /*!< Statistics. */
- KwSSta ssta; /*!< Status. */
- KwUSta usta; /*!< Unsolicited Status. */
- KwTrc trc; /*!< Trace Structre. */
+ RlcCntrl cntrl; /*!< Control Structure. */
+ RlcSts sts; /*!< Statistics. */
+ RlcSSta ssta; /*!< Status. */
+ RlcUSta usta; /*!< Unsolicited Status. */
+ RlcTrc trc; /*!< Trace Structre. */
}t;
-}KwMngmt;
+}RlcMngmt;
/* lkw_x_001.main_2, added support for L2 measurement */
#ifdef LTE_L2_MEAS
/** @brief Measurement Request Params Structure. */
-typedef struct kwL2MeasReqInfo
+typedef struct rlcL2MeasReqInfo
{
U8 measType; /*!< Measurement type, bit 1 to 4 (LSB nibble)
will be used for non IP Throughput and
}ipThMeas;
}val;
-}KwL2MeasReqInfo;
+}RlcL2MeasReqInfo;
/** @brief Measurement Request Exvent Structure. */
-typedef struct kwL2MeasReqEvt
+typedef struct rlcL2MeasReqEvt
{
U32 transId; /*!< Transaction Identifier */
U16 measPeriod; /*!< Measurement Period */
- KwL2MeasReqInfo measReq; /*!< Measurement request structure */
-}KwL2MeasReqEvt;
+ RlcL2MeasReqInfo measReq; /*!< Measurement request structure */
+}RlcL2MeasReqEvt;
/** @brief Measurement Confirm Params Structure. */
-typedef struct kwL2MeasCfmInfo
+typedef struct rlcL2MeasCfmInfo
{
U8 qci; /*!< QCI value */
union
}ipThrput;
}val;
-}KwL2MeasCfmInfo;
+}RlcL2MeasCfmInfo;
-typedef struct kwL2MeasCfmUeInfoLst
+typedef struct rlcL2MeasCfmUeInfoLst
{
CmLteRnti ueId; /*!< UE Id used for DL/UL Ipthroughput*/
CmLteCellId cellId; /*!< Cell Id used for DL/UL Ipthroughput*/
- KwL2MeasCfmInfo measCfm[LKW_MAX_QCI]; /*!< Measurement confirm structure*/
+ RlcL2MeasCfmInfo measCfm[LKW_MAX_QCI]; /*!< Measurement confirm structure*/
U16 numCfm; /*!< Number of Measurement confirm*/
-}KwL2MeasCfmUeInfoLst;
+}RlcL2MeasCfmUeInfoLst;
-typedef struct kwL2MeasCfmIpThMeas
+typedef struct rlcL2MeasCfmIpThMeas
{
U16 numUes; /*!< Number of Ue Info*/
- KwL2MeasCfmUeInfoLst ueInfoLst[LKW_MAX_UE]; /*!< UE info list*/
-}KwL2MeasCfmIpThMeas;
+ RlcL2MeasCfmUeInfoLst ueInfoLst[LKW_MAX_UE]; /*!< UE info list*/
+}RlcL2MeasCfmIpThMeas;
-typedef struct kwL2MeasCfmNonIpThMeas
+typedef struct rlcL2MeasCfmNonIpThMeas
{
U16 numCfm; /*!< Number of confirm */
- KwL2MeasCfmInfo measCfm[LKW_MAX_QCI]; /*!< Confirmation info */
-}KwL2MeasCfmNonIpThMeas;
+ RlcL2MeasCfmInfo measCfm[LKW_MAX_QCI]; /*!< Confirmation info */
+}RlcL2MeasCfmNonIpThMeas;
typedef union kwL2MeasCfmIpNonIp
{
- KwL2MeasCfmIpThMeas ipThMeas; /*!< Ip thrupt measurements*/
- KwL2MeasCfmNonIpThMeas nonIpThMeas; /*!< Non-Ip thrupt measurements*/
-}KwL2MeasCfmIpNonIp;
+ RlcL2MeasCfmIpThMeas ipThMeas; /*!< Ip thrupt measurements*/
+ RlcL2MeasCfmNonIpThMeas nonIpThMeas; /*!< Non-Ip thrupt measurements*/
+}RlcL2MeasCfmIpNonIp;
/** @brief Measurement Confirm Event Structure. */
-typedef struct kwL2MeasCfmEvt
+typedef struct rlcL2MeasCfmEvt
{
U32 transId; /*!< Transaction id */
CmStatus status; /*!< Status is for all QCIs */
bit 5 and 6 will be used for DL and UL
Ipthroughput respectively. It is same for
all qci in this Cfm event. */
- KwL2MeasCfmIpNonIp val;
-}KwL2MeasCfmEvt;
+ RlcL2MeasCfmIpNonIp val;
+}RlcL2MeasCfmEvt;
#endif /* LTE_L2_MEAS */
/* Control primitives towards LTE RLC */
/* Pointer functions to pack/unpack primitives */
-typedef S16 (*RlcConfigReq) ARGS((Pst *pst, KwMngmt *cfg));
-typedef S16 (*RlcConfigCfm) ARGS((Pst *pst, KwMngmt *cfgCfm));
+typedef S16 (*RlcConfigReq) ARGS((Pst *pst, RlcMngmt *cfg));
+typedef S16 (*RlcConfigCfm) ARGS((Pst *pst, RlcMngmt *cfgCfm));
-typedef S16 (*LkwCntrlReq) ARGS((Pst *pst, KwMngmt *cntl));
-typedef S16 (*LkwCntrlCfm) ARGS((Pst *pst, KwMngmt *cntlCfm));
+typedef S16 (*LkwCntrlReq) ARGS((Pst *pst, RlcMngmt *cntl));
+typedef S16 (*LkwCntrlCfm) ARGS((Pst *pst, RlcMngmt *cntlCfm));
-typedef S16 (*LkwStaInd) ARGS((Pst *pst, KwMngmt *staInd));
-typedef S16 (*LkwStaReq) ARGS((Pst *pst, KwMngmt *staReq));
-typedef S16 (*LkwStaCfm) ARGS((Pst *pst, KwMngmt *staCfm));
+typedef S16 (*LkwStaInd) ARGS((Pst *pst, RlcMngmt *staInd));
+typedef S16 (*LkwStaReq) ARGS((Pst *pst, RlcMngmt *staReq));
+typedef S16 (*LkwStaCfm) ARGS((Pst *pst, RlcMngmt *staCfm));
-typedef S16 (*LkwStsReq) ARGS((Pst *pst, Action, KwMngmt *sts));
-typedef S16 (*LkwStsCfm) ARGS((Pst *pst, Action, KwMngmt *stsCfm));
+typedef S16 (*LkwStsReq) ARGS((Pst *pst, Action, RlcMngmt *sts));
+typedef S16 (*LkwStsCfm) ARGS((Pst *pst, Action, RlcMngmt *stsCfm));
-typedef S16 (*LkwTrcInd) ARGS((Pst *pst, KwMngmt *trc, Buffer *mBuf));
+typedef S16 (*LkwTrcInd) ARGS((Pst *pst, RlcMngmt *trc, Buffer *mBuf));
/* lkw_x_001.main_2, added support for L2 measurement */
#ifdef LTE_L2_MEAS
-typedef S16 (*LkwL2MeasReq) ARGS((Pst *pst, KwL2MeasReqEvt *measEvt));
-typedef S16 (*LkwL2MeasCfm) ARGS((Pst *pst, KwL2MeasCfmEvt *measEvt));
+typedef S16 (*LkwL2MeasReq) ARGS((Pst *pst, RlcL2MeasReqEvt *measEvt));
+typedef S16 (*LkwL2MeasCfm) ARGS((Pst *pst, RlcL2MeasCfmEvt *measEvt));
typedef S16 (*LkwL2MeasSendReq) ARGS((Pst *pst, U8 measType));
typedef S16 (*LkwL2MeasStopReq) ARGS((Pst *pst, U8 measType));
typedef S16 (*LkwL2MeasStopCfm) ARGS((Pst *pst, U8 measType,U8 status));
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiRlcConfigReq ARGS((Pst *pst, KwMngmt *cfg));
+EXTERN S16 RlcMiRlcConfigReq ARGS((Pst *pst, RlcMngmt *cfg));
/**
-@details This function is called by the KwMiRlcConfigReq function for responding to configuration requests.The cfm field in the KwMngmt structure contains the response value.
+@details This function is called by the RlcMiRlcConfigReq function for responding to configuration requests.The cfm field in the RlcMngmt structure contains the response value.
@param[in] pst - Pointer to post structure
@param[in] cfm - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiRlcConfigCfm ARGS((Pst *pst, KwMngmt *cfgCfm));
+EXTERN S16 RlcMiRlcConfigCfm ARGS((Pst *pst, RlcMngmt *cfgCfm));
/**
@details
The layer manager initiates and uses the management-control procedure to control
-RLC elements.The RLC control request primitive (KwMiLkwCntrlReq) is called
+RLC elements.The RLC control request primitive (RlcMiLkwCntrlReq) is called
more than once and at any time after the management-configuration procedure.The
-control request primitive is confirmed by a KwMiLkwCntrlCfm primitive.
+control request primitive is confirmed by a RlcMiLkwCntrlCfm primitive.
@param[in] pst - Pointer to post structure
@param[in] cntl - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwCntrlReq ARGS((Pst *pst, KwMngmt *cntl));
+EXTERN S16 RlcMiLkwCntrlReq ARGS((Pst *pst, RlcMngmt *cntl));
/**
@details
-This function is called by the KwMiLkwCntrlReq function to send a control confirm to the layer management module.
+This function is called by the RlcMiLkwCntrlReq function to send a control confirm to the layer management module.
@param[in] pst - Pointer to post structure
@param[in] cfm - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwCntrlCfm ARGS((Pst *pst, KwMngmt *cntlCfm));
+EXTERN S16 RlcMiLkwCntrlCfm ARGS((Pst *pst, RlcMngmt *cntlCfm));
/**
@details
@param[in] cfg - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwStaReq ARGS((Pst *pst, KwMngmt *staInd));
+EXTERN S16 RlcMiLkwStaReq ARGS((Pst *pst, RlcMngmt *staInd));
/**
@details
-This function is called by the KwMiLkwStaReq function to send the requested stat
+This function is called by the RlcMiLkwStaReq function to send the requested stat
us information to the layer manager.
@param[in] pst - Pointer to post structure
@param[in] stacfm - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwStaCfm ARGS((Pst *pst, KwMngmt *staCfm));
+EXTERN S16 RlcMiLkwStaCfm ARGS((Pst *pst, RlcMngmt *staCfm));
/**
@details
@param[in] sts - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwStsReq ARGS((Pst *pst, Action, KwMngmt *sts));
+EXTERN S16 RlcMiLkwStsReq ARGS((Pst *pst, Action, RlcMngmt *sts));
/**
@details
-This function is called by the KwMiLkwStsReq function for responding to statisti
+This function is called by the RlcMiLkwStsReq function for responding to statisti
cs requests.
@param[in] pst - Pointer to post structure
@param[in] cfg - Configuration management structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwStsCfm ARGS((Pst *pst, Action action, KwMngmt *stsCfm));
+EXTERN S16 RlcMiLkwStsCfm ARGS((Pst *pst, Action action, RlcMngmt *stsCfm));
/**
@details
This function is used by RLC module to send unsolicited trace indications to
@param[in] buf - buffer
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwTrcInd ARGS ((Pst *pst, KwMngmt *trc, Buffer *mBuf));
+EXTERN S16 RlcMiLkwTrcInd ARGS ((Pst *pst, RlcMngmt *trc, Buffer *mBuf));
/**
@details This function is used by RLC to send unsolicited status information to the layer manager, when the unsolicited status flag is enabled by the layer manager through a previous control request.
@param[in] measEvt - Measurement Request structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwL2MeasReq ARGS((Pst *pst, KwL2MeasReqEvt *measEvt));
-EXTERN S16 KwMiLkwL2MeasStopReq ARGS((Pst *pst,U8 measType));
-EXTERN S16 KwMiLkwL2MeasSendReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 RlcMiLkwL2MeasReq ARGS((Pst *pst, RlcL2MeasReqEvt *measEvt));
+EXTERN S16 RlcMiLkwL2MeasStopReq ARGS((Pst *pst,U8 measType));
+EXTERN S16 RlcMiLkwL2MeasSendReq ARGS((Pst *pst,U8 measType));
/**
@details This function can be used by PDCP to send the measurement values
after doing L2 measurement that was requested by the layer manager.
@param[in] measEvt - Measurement confirmation structure
@return ROK if success , RFAILED if failure
*/
-EXTERN S16 KwMiLkwL2MeasCfm ARGS((Pst *pst, KwL2MeasCfmEvt *measCfm));
-EXTERN S16 KwMiLkwL2MeasStopCfm ARGS((Pst *pst, U8 measType, U8 status));
+EXTERN S16 RlcMiLkwL2MeasCfm ARGS((Pst *pst, RlcL2MeasCfmEvt *measCfm));
+EXTERN S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, U8 measType, U8 status));
#endif /* LTE_L2_MEAS */
-EXTERN S16 KwMiLkwStaInd ARGS((Pst *pst, KwMngmt *staReq));
+EXTERN S16 RlcMiLkwStaInd ARGS((Pst *pst, RlcMngmt *staReq));
-EXTERN Void kwSendLmAlarm ARGS ((
+EXTERN Void rlcSendLmAlarm ARGS ((
U16 category,
U16 event,
U16 cause,
#ifdef SM
EXTERN S16 SmMiRlcConfigCfm ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiLkwCntrlCfm ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiLkwStaInd ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiLkwStaCfm ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiLkwStsCfm ARGS((
Pst *,
Action,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiLkwTrcInd ARGS((
Pst *,
- KwMngmt *,
+ RlcMngmt *,
Buffer *
));
EXTERN S16 SmMiLkwStsReq ARGS((
Pst *,
Action,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiLkwStaReq ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiLkwCntrlReq ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 SmMiRlcConfigReq ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
/* lkw_x_001.main_2, added support for L2 measurement */
#ifdef LTE_L2_MEAS
EXTERN S16 SmMiLkwL2MeasReq ARGS((
Pst *,
- KwL2MeasReqEvt *
+ RlcL2MeasReqEvt *
));
EXTERN S16 SmMiLkwL2MeasStopReq ARGS((
Pst *pst,
));
EXTERN S16 SmMiLkwL2MeasCfm ARGS((
Pst *,
- KwL2MeasCfmEvt *
+ RlcL2MeasCfmEvt *
));
EXTERN S16 SmMiLkwL2MeasStopCfm ARGS((
Pst *pst,
#ifdef LCLKW
EXTERN S16 packRlcConfigReq ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 packRlcConfigCfm ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwCntrlReq ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwCntrlCfm ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwStaInd ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwStaReq ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwStaCfm ARGS((
Pst *,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwStsReq ARGS((
Pst *,
Action,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwStsCfm ARGS((
Pst *,
Action,
- KwMngmt *
+ RlcMngmt *
));
EXTERN S16 cmPkLkwTrcInd ARGS((
Pst *,
- KwMngmt *,
+ RlcMngmt *,
Buffer *
));
#ifdef LTE_L2_MEAS
EXTERN S16 cmPkLkwL2MeasReq ARGS((
Pst * pst,
- KwL2MeasReqEvt * measReqEvt
+ RlcL2MeasReqEvt * measReqEvt
));
EXTERN S16 cmUnpkLkwL2MeasReq ARGS((
LkwL2MeasReq func,
));
EXTERN S16 cmPkLkwL2MeasCfm ARGS((
Pst * pst,
- KwL2MeasCfmEvt *measCfmEvt
+ RlcL2MeasCfmEvt *measCfmEvt
));
EXTERN S16 cmUnpkLkwL2MeasCfm ARGS((
LkwL2MeasCfm func,
Pst *pst,
Buffer *mBuf
));
-EXTERN S16 cmPkKwL2MeasReqInfo ARGS((
- KwL2MeasReqInfo * measReqInfo,
+EXTERN S16 cmPkRlcL2MeasReqInfo ARGS((
+ RlcL2MeasReqInfo * measReqInfo,
Buffer *mBuf
));
-EXTERN S16 cmUnpkKwL2MeasReqInfo ARGS((
- KwL2MeasReqInfo * measReqInfo,
+EXTERN S16 cmUnpkRlcL2MeasReqInfo ARGS((
+ RlcL2MeasReqInfo * measReqInfo,
Buffer *mBuf
));
-EXTERN S16 cmPkKwL2MeasCfmInfo ARGS((
- KwL2MeasCfmInfo * measCfmInfo,
+EXTERN S16 cmPkRlcL2MeasCfmInfo ARGS((
+ RlcL2MeasCfmInfo * measCfmInfo,
Buffer *mBuf,
U8 measType
));
-EXTERN S16 cmUnpkKwL2MeasCfmInfo ARGS((
- KwL2MeasCfmInfo * measCfmInfo,
+EXTERN S16 cmUnpkRlcL2MeasCfmInfo ARGS((
+ RlcL2MeasCfmInfo * measCfmInfo,
Buffer *mBuf,
U8 measType
));
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCfgReq
+S16 cmPkLrgCfgReq
(
Pst * pst,
RgMngmt * cfg
)
#else
-PUBLIC S16 cmPkLrgCfgReq(pst, cfg)
+S16 cmPkLrgCfgReq(pst, cfg)
Pst * pst;
RgMngmt * cfg;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCfgReq
+S16 cmUnpkLrgCfgReq
(
LrgCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCfgReq(func, pst, mBuf)
+S16 cmUnpkLrgCfgReq(func, pst, mBuf)
LrgCfgReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCfgReq
+S16 cmPkLrgSchCfgReq
(
Pst * pst,
RgMngmt * cfg
)
#else
-PUBLIC S16 cmPkLrgSchCfgReq(pst, cfg)
+S16 cmPkLrgSchCfgReq(pst, cfg)
Pst * pst;
RgMngmt * cfg;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCfgReq
+S16 cmUnpkLrgSchCfgReq
(
LrgSchCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCfgReq(func, pst, mBuf)
+S16 cmUnpkLrgSchCfgReq(func, pst, mBuf)
LrgSchCfgReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCfgCfm
+S16 cmPkLrgCfgCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgCfgCfm(pst, cfm)
+S16 cmPkLrgCfgCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCfgCfm
+S16 cmUnpkLrgCfgCfm
(
LrgCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCfgCfm(func, pst, mBuf)
+S16 cmUnpkLrgCfgCfm(func, pst, mBuf)
LrgCfgCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCfgCfm
+S16 cmPkLrgSchCfgCfm
(
Pst * pst,
RgMngmt * cfg
)
#else
-PUBLIC S16 cmPkLrgSchCfgCfm(pst, cfg)
+S16 cmPkLrgSchCfgCfm(pst, cfg)
Pst * pst;
RgMngmt * cfg;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCfgCfm
+S16 cmUnpkLrgSchCfgCfm
(
LrgSchCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCfgCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchCfgCfm(func, pst, mBuf)
LrgSchCfgCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStsReq
+S16 cmPkLrgStsReq
(
Pst * pst,
RgMngmt * sts
)
#else
-PUBLIC S16 cmPkLrgStsReq(pst, sts)
+S16 cmPkLrgStsReq(pst, sts)
Pst * pst;
RgMngmt * sts;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStsReq
+S16 cmUnpkLrgStsReq
(
LrgStsReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStsReq(func, pst, mBuf)
+S16 cmUnpkLrgStsReq(func, pst, mBuf)
LrgStsReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStsCfm
+S16 cmPkLrgStsCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgStsCfm(pst, cfm)
+S16 cmPkLrgStsCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStsCfm
+S16 cmUnpkLrgStsCfm
(
LrgStsCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStsCfm(func, pst, mBuf)
+S16 cmUnpkLrgStsCfm(func, pst, mBuf)
LrgStsCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStaReq
+S16 cmPkLrgStaReq
(
Pst * pst,
RgMngmt * sta
)
#else
-PUBLIC S16 cmPkLrgStaReq(pst, sta)
+S16 cmPkLrgStaReq(pst, sta)
Pst * pst;
RgMngmt * sta;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaReq
+S16 cmUnpkLrgStaReq
(
LrgStaReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStaReq(func, pst, mBuf)
+S16 cmUnpkLrgStaReq(func, pst, mBuf)
LrgStaReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStaCfm
+S16 cmPkLrgStaCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgStaCfm(pst, cfm)
+S16 cmPkLrgStaCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaCfm
+S16 cmUnpkLrgStaCfm
(
LrgStaCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStaCfm(func, pst, mBuf)
+S16 cmUnpkLrgStaCfm(func, pst, mBuf)
LrgStaCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStaInd
+S16 cmPkLrgStaInd
(
Pst * pst,
RgMngmt * usta
)
#else
-PUBLIC S16 cmPkLrgStaInd(pst, usta)
+S16 cmPkLrgStaInd(pst, usta)
Pst * pst;
RgMngmt * usta;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaInd
+S16 cmUnpkLrgStaInd
(
LrgStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStaInd(func, pst, mBuf)
+S16 cmUnpkLrgStaInd(func, pst, mBuf)
LrgStaInd func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchStaInd
+S16 cmPkLrgSchStaInd
(
Pst * pst,
RgMngmt * sta
)
#else
-PUBLIC S16 cmPkLrgSchStaInd(pst, sta)
+S16 cmPkLrgSchStaInd(pst, sta)
Pst * pst;
RgMngmt * sta;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchStaInd
+S16 cmUnpkLrgSchStaInd
(
LrgSchStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchStaInd(func, pst, mBuf)
+S16 cmUnpkLrgSchStaInd(func, pst, mBuf)
LrgSchStaInd func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCntrlReq
+S16 cmPkLrgCntrlReq
(
Pst * pst,
RgMngmt * cntrl
)
#else
-PUBLIC S16 cmPkLrgCntrlReq(pst, cntrl)
+S16 cmPkLrgCntrlReq(pst, cntrl)
Pst * pst;
RgMngmt * cntrl;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCntrlReq
+S16 cmUnpkLrgCntrlReq
(
LrgCntrlReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCntrlReq(func, pst, mBuf)
+S16 cmUnpkLrgCntrlReq(func, pst, mBuf)
LrgCntrlReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCntrlReq
+S16 cmPkLrgSchCntrlReq
(
Pst * pst,
RgMngmt * cntrl
)
#else
-PUBLIC S16 cmPkLrgSchCntrlReq(pst, cntrl)
+S16 cmPkLrgSchCntrlReq(pst, cntrl)
Pst * pst;
RgMngmt * cntrl;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCntrlReq
+S16 cmUnpkLrgSchCntrlReq
(
LrgSchCntrlReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCntrlReq(func, pst, mBuf)
+S16 cmUnpkLrgSchCntrlReq(func, pst, mBuf)
LrgSchCntrlReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCntrlCfm
+S16 cmPkLrgCntrlCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgCntrlCfm(pst, cfm)
+S16 cmPkLrgCntrlCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCntrlCfm
+S16 cmUnpkLrgCntrlCfm
(
LrgCntrlCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCntrlCfm(func, pst, mBuf)
+S16 cmUnpkLrgCntrlCfm(func, pst, mBuf)
LrgCntrlCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCntrlCfm
+S16 cmPkLrgSchCntrlCfm
(
Pst * pst,
RgMngmt * cntrl
)
#else
-PUBLIC S16 cmPkLrgSchCntrlCfm(pst, cntrl)
+S16 cmPkLrgSchCntrlCfm(pst, cntrl)
Pst * pst;
RgMngmt * cntrl;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCntrlCfm
+S16 cmUnpkLrgSchCntrlCfm
(
LrgSchCntrlCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCntrlCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchCntrlCfm(func, pst, mBuf)
LrgSchCntrlCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgTrcInd
+S16 cmPkLrgTrcInd
(
Pst * pst,
RgMngmt * trc,
Buffer * trcBuf
)
#else
-PUBLIC S16 cmPkLrgTrcInd(pst, trc, trcBuf)
+S16 cmPkLrgTrcInd(pst, trc, trcBuf)
Pst * pst;
RgMngmt * trc;
Buffer * trcBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgTrcInd
+S16 cmUnpkLrgTrcInd
(
LrgTrcInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgTrcInd(func, pst, mBuf)
+S16 cmUnpkLrgTrcInd(func, pst, mBuf)
LrgTrcInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgGenCfg
+S16 cmPkRgGenCfg
(
RgGenCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgGenCfg(param, mBuf)
+S16 cmPkRgGenCfg(param, mBuf)
RgGenCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgGenCfg
+S16 cmUnpkRgGenCfg
(
RgGenCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgGenCfg(param, mBuf)
+S16 cmUnpkRgGenCfg(param, mBuf)
RgGenCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgUpSapCfg
+S16 cmPkRgUpSapCfg
(
RgUpSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgUpSapCfg(param, mBuf)
+S16 cmPkRgUpSapCfg(param, mBuf)
RgUpSapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgUpSapCfg
+S16 cmUnpkRgUpSapCfg
(
RgUpSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgUpSapCfg(param, mBuf)
+S16 cmUnpkRgUpSapCfg(param, mBuf)
RgUpSapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgLowSapCfg
+S16 cmPkRgLowSapCfg
(
RgLowSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgLowSapCfg(param, mBuf)
+S16 cmPkRgLowSapCfg(param, mBuf)
RgLowSapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgLowSapCfg
+S16 cmUnpkRgLowSapCfg
(
RgLowSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgLowSapCfg(param, mBuf)
+S16 cmUnpkRgLowSapCfg(param, mBuf)
RgLowSapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgAckNack
+S16 cmPkRgAckNack
(
RgAckNack *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgAckNack (param, mBuf)
+S16 cmPkRgAckNack (param, mBuf)
RgAckNack *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchNackAckStats
+S16 cmPkRgSchNackAckStats
(
RgSchNackAckStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchNackAckStats (param, mBuf)
+S16 cmPkRgSchNackAckStats (param, mBuf)
RgSchNackAckStats *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgHqNumRetx
+S16 cmPkRgHqNumRetx
(
RgSchHqNumRetx *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgHqNumRetx (param, mBuf)
+S16 cmPkRgHqNumRetx (param, mBuf)
RgSchHqNumRetx *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchHqRetxStats
+S16 cmPkRgSchHqRetxStats
(
RgSchHqRetxStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchHqRetxStats (param, mBuf)
+S16 cmPkRgSchHqRetxStats (param, mBuf)
RgSchHqRetxStats *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgAckNack
+S16 cmUnpkRgAckNack
(
RgAckNack *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgAckNack (param, mBuf)
+S16 cmUnpkRgAckNack (param, mBuf)
RgAckNack *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchNackAckStats
+S16 cmUnpkRgSchNackAckStats
(
RgSchNackAckStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchNackAckStats (param, mBuf)
+S16 cmUnpkRgSchNackAckStats (param, mBuf)
RgSchNackAckStats *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgHqNumRetx
+S16 cmUnpkRgHqNumRetx
(
RgSchHqNumRetx *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgHqNumRetx (param, mBuf)
+S16 cmUnpkRgHqNumRetx (param, mBuf)
RgSchHqNumRetx *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchHqRetxStats
+S16 cmUnpkRgSchHqRetxStats
(
RgSchHqRetxStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchHqRetxStats (param, mBuf)
+S16 cmUnpkRgSchHqRetxStats (param, mBuf)
RgSchHqRetxStats *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgGenSts
+S16 cmPkRgGenSts
(
RgGenSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgGenSts(param, mBuf)
+S16 cmPkRgGenSts(param, mBuf)
RgGenSts *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgGenSts
+S16 cmUnpkRgGenSts
(
RgGenSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgGenSts(param, mBuf)
+S16 cmUnpkRgGenSts(param, mBuf)
RgGenSts *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSapSts
+S16 cmPkRgSapSts
(
RgSapSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSapSts(param, mBuf)
+S16 cmPkRgSapSts(param, mBuf)
RgSapSts *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSapSts
+S16 cmUnpkRgSapSts
(
RgSapSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSapSts(param, mBuf)
+S16 cmUnpkRgSapSts(param, mBuf)
RgSapSts *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchInstCfg
+S16 cmPkRgSchInstCfg
(
RgSchInstCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchInstCfg(param, mBuf)
+S16 cmPkRgSchInstCfg(param, mBuf)
RgSchInstCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchInstCfg
+S16 cmUnpkRgSchInstCfg
(
RgSchInstCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchInstCfg(param, mBuf)
+S16 cmUnpkRgSchInstCfg(param, mBuf)
RgSchInstCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgCfg
+S16 cmPkRgCfg
(
RgCfg *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgCfg(param, elmnt, mBuf)
+S16 cmPkRgCfg(param, elmnt, mBuf)
RgCfg *param;
S16 elmnt;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgCfg
+S16 cmUnpkRgCfg
(
RgCfg *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgCfg(param, elmnt, mBuf)
+S16 cmUnpkRgCfg(param, elmnt, mBuf)
RgCfg *param;
S16 elmnt;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSapSta
+S16 cmPkRgSapSta
(
RgSapSta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSapSta(param, mBuf)
+S16 cmPkRgSapSta(param, mBuf)
RgSapSta *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSapSta
+S16 cmUnpkRgSapSta
(
RgSapSta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSapSta(param, mBuf)
+S16 cmUnpkRgSapSta(param, mBuf)
RgSapSta *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSts
+S16 cmPkRgSts
(
RgSts *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSts(param, elmnt, mBuf)
+S16 cmPkRgSts(param, elmnt, mBuf)
RgSts *param;
S16 elmnt;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSts
+S16 cmUnpkRgSts
(
RgSts *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSts(param, elmnt, mBuf)
+S16 cmUnpkRgSts(param, elmnt, mBuf)
RgSts *param;
S16 elmnt;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSsta
+S16 cmPkRgSsta
(
Pst *pst,
RgSsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
+S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
Pst *pst;
RgSsta *param;
S16 elmnt;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSsta
+S16 cmUnpkRgSsta
(
Pst *pst,
RgSsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
+S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
Pst *pst;
RgSsta *param;
S16 elmnt;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgUstaDgn
+S16 cmPkRgUstaDgn
(
RgUstaDgn *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgUstaDgn(param, mBuf)
+S16 cmPkRgUstaDgn(param, mBuf)
RgUstaDgn *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgUstaDgn
+S16 cmUnpkRgUstaDgn
(
RgUstaDgn *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgUstaDgn(param, mBuf)
+S16 cmUnpkRgUstaDgn(param, mBuf)
RgUstaDgn *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgUsta
+S16 cmPkRgUsta
(
RgUsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgUsta(param, mBuf)
+S16 cmPkRgUsta(param, mBuf)
RgUsta *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgUsta
+S16 cmUnpkRgUsta
(
RgUsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgUsta(param, mBuf)
+S16 cmUnpkRgUsta(param, mBuf)
RgUsta *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgTrc
+S16 cmPkRgTrc
(
RgTrc *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgTrc(param, mBuf)
+S16 cmPkRgTrc(param, mBuf)
RgTrc *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgTrc
+S16 cmUnpkRgTrc
(
RgTrc *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgTrc(param, mBuf)
+S16 cmUnpkRgTrc(param, mBuf)
RgTrc *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgDbgCntrl
+S16 cmPkRgDbgCntrl
(
RgDbgCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgDbgCntrl(param, mBuf)
+S16 cmPkRgDbgCntrl(param, mBuf)
RgDbgCntrl *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchUlAllocCntrl
+S16 cmPkRgSchUlAllocCntrl
(
RgSchUlAllocCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchUlAllocCntrl(param, mBuf)
+S16 cmPkRgSchUlAllocCntrl(param, mBuf)
RgSchUlAllocCntrl *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchUlAllocCntrl
+S16 cmUnpkRgSchUlAllocCntrl
(
RgSchUlAllocCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchUlAllocCntrl(param, mBuf)
+S16 cmUnpkRgSchUlAllocCntrl(param, mBuf)
RgSchUlAllocCntrl *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgDbgCntrl
+S16 cmUnpkRgDbgCntrl
(
RgDbgCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgDbgCntrl(param, mBuf)
+S16 cmUnpkRgDbgCntrl(param, mBuf)
RgDbgCntrl *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSapCntrl
+S16 cmPkRgSapCntrl
(
RgSapCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSapCntrl(param, mBuf)
+S16 cmPkRgSapCntrl(param, mBuf)
RgSapCntrl *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSapCntrl
+S16 cmUnpkRgSapCntrl
(
RgSapCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSapCntrl(param, mBuf)
+S16 cmUnpkRgSapCntrl(param, mBuf)
RgSapCntrl *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgCntrl
+S16 cmPkRgCntrl
(
RgCntrl *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgCntrl(param, elmnt, mBuf)
+S16 cmPkRgCntrl(param, elmnt, mBuf)
RgCntrl *param;
S16 elmnt;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgCntrl
+S16 cmUnpkRgCntrl
(
RgCntrl *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgCntrl(param, elmnt, mBuf)
+S16 cmUnpkRgCntrl(param, elmnt, mBuf)
RgCntrl *param;
S16 elmnt;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgMngmt
+S16 cmPkRgMngmt
(
Pst *pst,
RgMngmt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgMngmt(pst, param, eventType, mBuf)
+S16 cmPkRgMngmt(pst, param, eventType, mBuf)
Pst *pst;
RgMngmt *param;
U8 eventType;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgMngmt
+S16 cmUnpkRgMngmt
(
Pst *pst,
RgMngmt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
+S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
Pst *pst;
RgMngmt *param;
U8 eventType;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasReq
+S16 cmPkLrgSchL2MeasReq
(
Pst * pst,
LrgSchMeasReqInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasReq(pst, measInfo)
Pst * pst;
LrgSchMeasReqInfo *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasStopReq
+S16 cmPkLrgSchL2MeasStopReq
(
Pst * pst,
LrgSchMeasStopReqInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasStopReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasStopReq(pst, measInfo)
Pst * pst;
LrgSchMeasStopReqInfo *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasSendReq
+S16 cmPkLrgSchL2MeasSendReq
(
Pst * pst,
LrgSchMeasSndReqInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasSendReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasSendReq(pst, measInfo)
Pst * pst;
LrgSchMeasSndReqInfo *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasReq
+S16 cmUnpkLrgSchL2MeasReq
(
LrgSchL2MeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasReq(func, pst, mBuf)
LrgSchL2MeasReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasStopReq
+S16 cmUnpkLrgSchL2MeasStopReq
(
LrgSchL2MeasStopReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasStopReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasStopReq(func, pst, mBuf)
LrgSchL2MeasStopReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasSendReq
+S16 cmUnpkLrgSchL2MeasSendReq
(
LrgSchL2MeasSendReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasSendReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasSendReq(func, pst, mBuf)
LrgSchL2MeasSendReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasStopCfm
+S16 cmPkLrgSchL2MeasStopCfm
(
Pst * pst,
LrgSchMeasCfmInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasStopCfm(pst, measInfo)
+S16 cmPkLrgSchL2MeasStopCfm(pst, measInfo)
Pst * pst;
LrgSchMeasCfmInfo *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasStopCfm
+S16 cmUnpkLrgSchL2MeasStopCfm
(
LrgSchL2MeasStopCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasStopCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasStopCfm(func, pst, mBuf)
LrgSchL2MeasStopCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasCfm
+S16 cmPkLrgSchL2MeasCfm
(
Pst * pst,
LrgSchMeasCfmInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasCfm(pst, measInfo)
+S16 cmPkLrgSchL2MeasCfm(pst, measInfo)
Pst * pst;
LrgSchMeasCfmInfo *measInfo;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasCfm
+S16 cmUnpkLrgSchL2MeasCfm
(
LrgSchL2MeasCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasCfm(func, pst, mBuf)
LrgSchL2MeasCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLwLcRgmBndReq
+S16 cmPkLwLcRgmBndReq
(
Pst* pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkLwLcRgmBndReq(pst, suId, spId)
+S16 cmPkLwLcRgmBndReq(pst, suId, spId)
Pst* pst;
SuId suId;
SpId spId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLwLcRgmBndReq
+S16 cmUnpkLwLcRgmBndReq
(
RgmBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLwLcRgmBndReq(func, pst, mBuf)
+S16 cmUnpkLwLcRgmBndReq(func, pst, mBuf)
RgmBndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLwLcRgmUbndReq
+S16 cmPkLwLcRgmUbndReq
(
Pst* pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkLwLcRgmUbndReq(pst, spId, reason)
+S16 cmPkLwLcRgmUbndReq(pst, spId, reason)
Pst* pst;
SpId spId;
Reason reason;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLwLcRgmBndCfm
+S16 cmPkLwLcRgmBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkLwLcRgmBndCfm(pst, suId, status)
+S16 cmPkLwLcRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLwLcRgmBndCfm
+S16 cmUnpkLwLcRgmBndCfm
(
RgmBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLwLcRgmBndCfm(func, pst, mBuf)
+S16 cmUnpkLwLcRgmBndCfm(func, pst, mBuf)
RgmBndCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLwLcRgmCfgPrbRprt
+S16 cmPkLwLcRgmCfgPrbRprt
(
Pst* pst,
SpId spId,
RgmPrbRprtCfg * prbRprtCfg
)
#else
-PUBLIC S16 cmPkLwLcRgmCfgPrbRprt(pst, spId, prbRprtCfg)
+S16 cmPkLwLcRgmCfgPrbRprt(pst, spId, prbRprtCfg)
Pst* pst;
SpId spId;
RgmPrbRprtCfg * prbRprtCfg;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLwLcRgmCfgPrbRprt
+S16 cmUnpkLwLcRgmCfgPrbRprt
(
RgmCfgPrbRprtFptr func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLwLcRgmCfgPrbRprt(func, pst, mBuf)
+S16 cmUnpkLwLcRgmCfgPrbRprt(func, pst, mBuf)
RgmCfgPrbRprtFptr func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLwLcRgmPrbRprtInd
+S16 cmPkLwLcRgmPrbRprtInd
(
Pst* pst,
SuId suId,
RgmPrbRprtInd * prbRprtInd
)
#else
-PUBLIC S16 cmPkLwLcRgmPrbRprtInd(pst, suId, prbRprtInd)
+S16 cmPkLwLcRgmPrbRprtInd(pst, suId, prbRprtInd)
Pst* pst;
SuId suId;
RgmPrbRprtInd * prbRprtInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLwLcRgmPrbRprtInd
+S16 cmUnpkLwLcRgmPrbRprtInd
(
RgmPrbRprtIndFptr func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLwLcRgmPrbRprtInd(func, pst, mBuf)
+S16 cmUnpkLwLcRgmPrbRprtInd(func, pst, mBuf)
RgmPrbRprtIndFptr func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRgmBndReq
+S16 cmPkRgmBndReq
(
Pst* pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkRgmBndReq(pst, suId, spId)
+S16 cmPkRgmBndReq(pst, suId, spId)
Pst* pst;
SuId suId;
SpId spId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgmBndReq
+S16 cmUnpkRgmBndReq
(
RgmBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgmBndReq(func, pst, mBuf)
+S16 cmUnpkRgmBndReq(func, pst, mBuf)
RgmBndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRgmUbndReq
+S16 cmPkRgmUbndReq
(
Pst* pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkRgmUbndReq(pst, spId, reason)
+S16 cmPkRgmUbndReq(pst, spId, reason)
Pst* pst;
SpId spId;
Reason reason;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgmUbndReq
+S16 cmUnpkRgmUbndReq
(
RgmUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgmUbndReq(func, pst, mBuf)
+S16 cmUnpkRgmUbndReq(func, pst, mBuf)
RgmUbndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRgmBndCfm
+S16 cmPkRgmBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkRgmBndCfm(pst, suId, status)
+S16 cmPkRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgmBndCfm
+S16 cmUnpkRgmBndCfm
(
RgmBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgmBndCfm(func, pst, mBuf)
+S16 cmUnpkRgmBndCfm(func, pst, mBuf)
RgmBndCfm func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCfgPrbRprt
+S16 cmPkCfgPrbRprt
(
RgmPrbRprtCfg * prbRprtCfg,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCfgPrbRprt(prbRprtCfg, mBuf)
+S16 cmPkCfgPrbRprt(prbRprtCfg, mBuf)
RgmPrbRprtCfg * prbRprtCfg;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnPkCfgPrbRprt
+S16 cmUnPkCfgPrbRprt
(
RgmPrbRprtCfg * prbRprtCfg,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnPkCfgPrbRprt(prbRprtCfg, mBuf)
+S16 cmUnPkCfgPrbRprt(prbRprtCfg, mBuf)
RgmPrbRprtCfg * prbRprtCfg;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRgmCfgPrbRprt
+S16 cmPkRgmCfgPrbRprt
(
Pst* pst,
SpId spId,
RgmPrbRprtCfg * prbRprtCfg
)
#else
-PUBLIC S16 cmPkRgmCfgPrbRprt(pst, spId, prbRprtCfg)
+S16 cmPkRgmCfgPrbRprt(pst, spId, prbRprtCfg)
Pst* pst;
SpId spId;
RgmPrbRprtCfg * prbRprtCfg;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgmCfgPrbRprt
+S16 cmUnpkRgmCfgPrbRprt
(
RgmCfgPrbRprtFptr func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgmCfgPrbRprt(func, pst, mBuf)
+S16 cmUnpkRgmCfgPrbRprt(func, pst, mBuf)
RgmCfgPrbRprtFptr func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRgmPrbQciRpt
+S16 cmPkRgmPrbQciRpt
(
RgmPrbRptPerQci *qciPrbRprt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgmPrbQciRpt(qciPrbRprt, mBuf)
+S16 cmPkRgmPrbQciRpt(qciPrbRprt, mBuf)
RgmPrbRptPerQci *qciPrbRprt;
Buffer *mBuf = NULLP;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgmPrbQciRpt
+S16 cmUnpkRgmPrbQciRpt
(
RgmPrbRptPerQci *qciPrbRprt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgmPrbQciRpt(qciPrbRprt, mBuf)
+S16 cmUnpkRgmPrbQciRpt(qciPrbRprt, mBuf)
RgmPrbRptPerQci *qciPrbRprt;
Buffer *mBuf = NULLP;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkPrbRprtInd
+S16 cmPkPrbRprtInd
(
RgmPrbRprtInd * prbRprtInd,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkPrbRprtInd(prbRprtInd, mBuf)
+S16 cmPkPrbRprtInd(prbRprtInd, mBuf)
RgmPrbRprtInd * prbRprtInd;
Buffer *mBuf = NULLP;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPrbRprtInd
+S16 cmUnpkPrbRprtInd
(
RgmPrbRprtInd * prbRprtInd,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPrbRprtInd(prbRprtInd, mBuf)
+S16 cmUnpkPrbRprtInd(prbRprtInd, mBuf)
RgmPrbRprtInd * prbRprtInd;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRgmPrbRprtInd
+S16 cmPkRgmPrbRprtInd
(
Pst* pst,
SuId suId,
RgmPrbRprtInd * prbRprtInd
)
#else
-PUBLIC S16 cmPkRgmPrbRprtInd(pst, suId, prbRprtInd)
+S16 cmPkRgmPrbRprtInd(pst, suId, prbRprtInd)
Pst* pst;
SuId suId;
RgmPrbRprtInd * prbRprtInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgmPrbRprtInd
+S16 cmUnpkRgmPrbRprtInd
(
RgmPrbRprtIndFptr func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgmPrbRprtInd(func, pst, mBuf)
+S16 cmUnpkRgmPrbRprtInd(func, pst, mBuf)
RgmPrbRprtIndFptr func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkTransModeInd
+S16 cmPkTransModeInd
(
RgmTransModeInd *transModeInd,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTransModeInd(transModeInd, mBuf)
+S16 cmPkTransModeInd(transModeInd, mBuf)
RgmTransModeInd *transModeInd;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkTransModeInd
+S16 cmUnpkTransModeInd
(
RgmTransModeInd *transModeInd,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTransModeInd(transModeInd, mBuf)
+S16 cmUnpkTransModeInd(transModeInd, mBuf)
RgmTransModeInd *transModeInd;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRgmTransModeInd
+S16 cmPkRgmTransModeInd
(
Pst* pst,
SuId suId,
RgmTransModeInd *transModeInd
)
#else
-PUBLIC S16 cmPkRgmTransModeInd(pst, suId, transModeInd)
+S16 cmPkRgmTransModeInd(pst, suId, transModeInd)
Pst* pst;
SuId suId;
RgmTransModeInd *transModeInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgmTransModeInd
+S16 cmUnpkRgmTransModeInd
(
RgmTransModeIndFptr func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgmTransModeInd(func, pst, mBuf)
+S16 cmUnpkRgmTransModeInd(func, pst, mBuf)
RgmTransModeIndFptr func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrBndReq
+S16 cmPkRgrBndReq
(
Pst* pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkRgrBndReq(pst, suId, spId)
+S16 cmPkRgrBndReq(pst, suId, spId)
Pst* pst;
SuId suId;
SpId spId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrBndReq
+S16 cmUnpkRgrBndReq
(
RgrBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrBndReq(func, pst, mBuf)
+S16 cmUnpkRgrBndReq(func, pst, mBuf)
RgrBndReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrBndCfm
+S16 cmPkRgrBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkRgrBndCfm(pst, suId, status)
+S16 cmPkRgrBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrBndCfm
+S16 cmUnpkRgrBndCfm
(
RgrBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrBndCfm(func, pst, mBuf)
+S16 cmUnpkRgrBndCfm(func, pst, mBuf)
RgrBndCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUbndReq
+S16 cmPkRgrUbndReq
(
Pst* pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkRgrUbndReq(pst, spId, reason)
+S16 cmPkRgrUbndReq(pst, spId, reason)
Pst* pst;
SpId spId;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUbndReq
+S16 cmUnpkRgrUbndReq
(
RgrUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUbndReq(func, pst, mBuf)
+S16 cmUnpkRgrUbndReq(func, pst, mBuf)
RgrUbndReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgReq
+S16 cmUnpkRgrCfgReq
(
RgrCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCfgReq(func, pst, mBuf)
+S16 cmUnpkRgrCfgReq(func, pst, mBuf)
RgrCfgReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrTtiIndInfo
+S16 cmPkRgrTtiIndInfo
(
RgrTtiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrTtiIndInfo(param, mBuf)
+S16 cmPkRgrTtiIndInfo(param, mBuf)
RgrTtiIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTtiIndInfo
+S16 cmUnpkRgrTtiIndInfo
(
RgrTtiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrTtiIndInfo(param, mBuf)
+S16 cmUnpkRgrTtiIndInfo(param, mBuf)
RgrTtiIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrTtiInd
+S16 cmPkRgrTtiInd
(
Pst* pst,
SuId suId,
RgrTtiIndInfo *ttiInd
)
#else
-PUBLIC S16 cmPkRgrTtiInd(pst, suId, ttiInd)
+S16 cmPkRgrTtiInd(pst, suId, ttiInd)
Pst* pst;
SuId suId;
RgrTtiIndInfo *ttiInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTtiInd
+S16 cmUnpkRgrTtiInd
(
RgrTtiInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrTtiInd(func, pst, mBuf)
+S16 cmUnpkRgrTtiInd(func, pst, mBuf)
RgrTtiInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCfgCfm
+S16 cmPkRgrCfgCfm
(
Pst* pst,
RgrCfgTransId transId,
U8 status
)
#else
-PUBLIC S16 cmPkRgrCfgCfm(pst, transId, status)
+S16 cmPkRgrCfgCfm(pst, transId, status)
Pst* pst;
RgrCfgTransId transId;
U8 status;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgCfm
+S16 cmUnpkRgrCfgCfm
(
RgrCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCfgCfm(func, pst, mBuf)
+S16 cmUnpkRgrCfgCfm(func, pst, mBuf)
RgrCfgCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfgCfm
+S16 cmPkRgrSiCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkRgrSiCfgCfm(pst, suId, transId, status)
+S16 cmPkRgrSiCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfgCfm
+S16 cmUnpkRgrSiCfgCfm
(
RgrSiCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSiCfgCfm(func, pst, mBuf)
+S16 cmUnpkRgrSiCfgCfm(func, pst, mBuf)
RgrSiCfgCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCfgTransId
+S16 cmPkRgrCfgTransId
(
RgrCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCfgTransId(param, mBuf)
+S16 cmPkRgrCfgTransId(param, mBuf)
RgrCfgTransId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgTransId
+S16 cmUnpkRgrCfgTransId
(
RgrCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCfgTransId(param, mBuf)
+S16 cmUnpkRgrCfgTransId(param, mBuf)
RgrCfgTransId *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDlHqCfg
+S16 cmPkRgrDlHqCfg
(
RgrDlHqCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDlHqCfg(param, mBuf)
+S16 cmPkRgrDlHqCfg(param, mBuf)
RgrDlHqCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlHqCfg
+S16 cmUnpkRgrDlHqCfg
(
RgrDlHqCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDlHqCfg(param, mBuf)
+S16 cmUnpkRgrDlHqCfg(param, mBuf)
RgrDlHqCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrRntiCfg
+S16 cmPkRgrRntiCfg
(
RgrRntiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrRntiCfg(param, mBuf)
+S16 cmPkRgrRntiCfg(param, mBuf)
RgrRntiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRntiCfg
+S16 cmUnpkRgrRntiCfg
(
RgrRntiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrRntiCfg(param, mBuf)
+S16 cmUnpkRgrRntiCfg(param, mBuf)
RgrRntiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcRntiCfg
+S16 cmPkRgrEmtcRntiCfg
(
RgrEmtcRntiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcRntiCfg(param, mBuf)
+S16 cmPkRgrEmtcRntiCfg(param, mBuf)
RgrEmtcRntiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcRntiCfg
+S16 cmUnpkRgrEmtcRntiCfg
(
RgrEmtcRntiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcRntiCfg(param, mBuf)
+S16 cmUnpkRgrEmtcRntiCfg(param, mBuf)
RgrEmtcRntiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDlCmnCodeRateCfg
+S16 cmPkRgrDlCmnCodeRateCfg
(
RgrDlCmnCodeRateCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDlCmnCodeRateCfg(param, mBuf)
+S16 cmPkRgrDlCmnCodeRateCfg(param, mBuf)
RgrDlCmnCodeRateCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlCmnCodeRateCfg
+S16 cmUnpkRgrDlCmnCodeRateCfg
(
RgrDlCmnCodeRateCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDlCmnCodeRateCfg(param, mBuf)
+S16 cmUnpkRgrDlCmnCodeRateCfg(param, mBuf)
RgrDlCmnCodeRateCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCfiCfg
+S16 cmPkRgrCfiCfg
(
RgrCfiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCfiCfg(param, mBuf)
+S16 cmPkRgrCfiCfg(param, mBuf)
RgrCfiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfiCfg
+S16 cmUnpkRgrCfiCfg
(
RgrCfiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCfiCfg(param, mBuf)
+S16 cmUnpkRgrCfiCfg(param, mBuf)
RgrCfiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrPuschSubBandCfg
+S16 cmPkRgrPuschSubBandCfg
(
RgrPuschSubBandCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrPuschSubBandCfg(param, mBuf)
+S16 cmPkRgrPuschSubBandCfg(param, mBuf)
RgrPuschSubBandCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPuschSubBandCfg
+S16 cmUnpkRgrPuschSubBandCfg
(
RgrPuschSubBandCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrPuschSubBandCfg(param, mBuf)
+S16 cmUnpkRgrPuschSubBandCfg(param, mBuf)
RgrPuschSubBandCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUlCmnCodeRateCfg
+S16 cmPkRgrUlCmnCodeRateCfg
(
RgrUlCmnCodeRateCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUlCmnCodeRateCfg(param, mBuf)
+S16 cmPkRgrUlCmnCodeRateCfg(param, mBuf)
RgrUlCmnCodeRateCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlCmnCodeRateCfg
+S16 cmUnpkRgrUlCmnCodeRateCfg
(
RgrUlCmnCodeRateCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUlCmnCodeRateCfg(param, mBuf)
+S16 cmUnpkRgrUlCmnCodeRateCfg(param, mBuf)
RgrUlCmnCodeRateCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUlTrgCqiCfg
+S16 cmPkRgrUlTrgCqiCfg
(
RgrUlTrgCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUlTrgCqiCfg(param, mBuf)
+S16 cmPkRgrUlTrgCqiCfg(param, mBuf)
RgrUlTrgCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlTrgCqiCfg
+S16 cmUnpkRgrUlTrgCqiCfg
(
RgrUlTrgCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUlTrgCqiCfg(param, mBuf)
+S16 cmUnpkRgrUlTrgCqiCfg(param, mBuf)
RgrUlTrgCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrBwCfg
+S16 cmPkRgrBwCfg
(
RgrBwCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrBwCfg(param, mBuf)
+S16 cmPkRgrBwCfg(param, mBuf)
RgrBwCfg *param;
Buffer *mBuf;
#endif
/* EMTC related pack changes start*/
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcSiCfg
+S16 cmPkRgrEmtcSiCfg
(
RgrEmtcSiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcSiCfg(param, mBuf)
+S16 cmPkRgrEmtcSiCfg(param, mBuf)
RgrEmtcSiCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcRachCfg
+S16 cmPkRgrEmtcRachCfg
(
RgrEmtcRachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcRachCfg(param, mBuf)
+S16 cmPkRgrEmtcRachCfg(param, mBuf)
RgrEmtcRachCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPdschCfg
+S16 cmPkRgrEmtcPdschCfg
(
RgrEmtcPdschCfg*param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcPdschCfg(param, mBuf)
+S16 cmPkRgrEmtcPdschCfg(param, mBuf)
RgrEmtcPdschCfg *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPuschCfg
+S16 cmPkRgrEmtcPuschCfg
(
RgrEmtcPuschCfg*param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcPuschCfg(param, mBuf)
+S16 cmPkRgrEmtcPuschCfg(param, mBuf)
RgrEmtcPuschCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPucchCfg
+S16 cmPkRgrEmtcPucchCfg
(
RgrEmtcPucchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcPucchCfg(param, mBuf)
+S16 cmPkRgrEmtcPucchCfg(param, mBuf)
RgrEmtcPucchCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPrachCeParamCfg
+S16 cmPkRgrEmtcPrachCeParamCfg
(
RgrEmtcPrachCEParamLst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcPrachCeParamCfg(param, mBuf)
+S16 cmPkRgrEmtcPrachCeParamCfg(param, mBuf)
RgrEmtcPrachCEParamLst *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcPrachCfg
+S16 cmPkRgrEmtcPrachCfg
(
RgrEmtcPrachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcPrachCfg(param, mBuf)
+S16 cmPkRgrEmtcPrachCfg(param, mBuf)
RgrEmtcPrachCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrEmtcCfg
+S16 cmPkRgrEmtcCfg
(
RgrEmtcCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEmtcCfg(param, mBuf)
+S16 cmPkRgrEmtcCfg(param, mBuf)
RgrEmtcCellCfg *param;
Buffer *mBuf;
#endif
/* EMTC related unpack changes start*/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcSiCfg
+S16 cmUnpkRgrEmtcSiCfg
(
RgrEmtcSiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcSiCfg(param, mBuf)
+S16 cmUnpkRgrEmtcSiCfg(param, mBuf)
RgrEmtcSiCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcRachCfg
+S16 cmUnpkRgrEmtcRachCfg
(
RgrEmtcRachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcRachCfg(param, mBuf)
+S16 cmUnpkRgrEmtcRachCfg(param, mBuf)
RgrEmtcRachCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPdschCfg
+S16 cmUnpkRgrEmtcPdschCfg
(
RgrEmtcPdschCfg*param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcPdschCfg(param, mBuf)
+S16 cmUnpkRgrEmtcPdschCfg(param, mBuf)
RgrEmtcPdschCfg *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPuschCfg
+S16 cmUnpkRgrEmtcPuschCfg
(
RgrEmtcPuschCfg*param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcPuschCfg(param, mBuf)
+S16 cmUnpkRgrEmtcPuschCfg(param, mBuf)
RgrEmtcPuschCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPucchCfg
+S16 cmUnpkRgrEmtcPucchCfg
(
RgrEmtcPucchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcPucchCfg(param, mBuf)
+S16 cmUnpkRgrEmtcPucchCfg(param, mBuf)
RgrEmtcPucchCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPrachCeParamCfg
+S16 cmUnpkRgrEmtcPrachCeParamCfg
(
RgrEmtcPrachCEParamLst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcPrachCeParamCfg(param, mBuf)
+S16 cmUnpkRgrEmtcPrachCeParamCfg(param, mBuf)
RgrEmtcPrachCEParamLst *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcPrachCfg
+S16 cmUnpkRgrEmtcPrachCfg
(
RgrEmtcPrachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcPrachCfg(param, mBuf)
+S16 cmUnpkRgrEmtcPrachCfg(param, mBuf)
RgrEmtcPrachCfg *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcCfg
+S16 cmUnpkRgrEmtcCfg
(
RgrEmtcCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcCfg(param, mBuf)
+S16 cmUnpkRgrEmtcCfg(param, mBuf)
RgrEmtcCellCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrBwCfg
+S16 cmUnpkRgrBwCfg
(
RgrBwCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrBwCfg(param, mBuf)
+S16 cmUnpkRgrBwCfg(param, mBuf)
RgrBwCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrPhichCfg
+S16 cmPkRgrPhichCfg
(
RgrPhichCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrPhichCfg(param, mBuf)
+S16 cmPkRgrPhichCfg(param, mBuf)
RgrPhichCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPhichCfg
+S16 cmUnpkRgrPhichCfg
(
RgrPhichCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrPhichCfg(param, mBuf)
+S16 cmUnpkRgrPhichCfg(param, mBuf)
RgrPhichCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrPucchCfg
+S16 cmPkRgrPucchCfg
(
RgrPucchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrPucchCfg(param, mBuf)
+S16 cmPkRgrPucchCfg(param, mBuf)
RgrPucchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPucchCfg
+S16 cmUnpkRgrPucchCfg
(
RgrPucchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrPucchCfg(param, mBuf)
+S16 cmUnpkRgrPucchCfg(param, mBuf)
RgrPucchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSrsCfg
+S16 cmPkRgrSrsCfg
(
RgrSrsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSrsCfg(param, mBuf)
+S16 cmPkRgrSrsCfg(param, mBuf)
RgrSrsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSrsCfg
+S16 cmUnpkRgrSrsCfg
(
RgrSrsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSrsCfg(param, mBuf)
+S16 cmUnpkRgrSrsCfg(param, mBuf)
RgrSrsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrRachCfg
+S16 cmPkRgrRachCfg
(
RgrRachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrRachCfg(param, mBuf)
+S16 cmPkRgrRachCfg(param, mBuf)
RgrRachCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRachCfg
+S16 cmUnpkRgrRachCfg
(
RgrRachCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrRachCfg(param, mBuf)
+S16 cmUnpkRgrRachCfg(param, mBuf)
RgrRachCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfg
+S16 cmPkRgrSiCfg
(
RgrSiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSiCfg(param, mBuf)
+S16 cmPkRgrSiCfg(param, mBuf)
RgrSiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfg
+S16 cmUnpkRgrSiCfg
(
RgrSiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSiCfg(param, mBuf)
+S16 cmUnpkRgrSiCfg(param, mBuf)
RgrSiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrTpcRntiCfg
+S16 cmPkRgrTpcRntiCfg
(
RgrTpcRntiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrTpcRntiCfg(param, mBuf)
+S16 cmPkRgrTpcRntiCfg(param, mBuf)
RgrTpcRntiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTpcRntiCfg
+S16 cmUnpkRgrTpcRntiCfg
(
RgrTpcRntiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrTpcRntiCfg(param, mBuf)
+S16 cmUnpkRgrTpcRntiCfg(param, mBuf)
RgrTpcRntiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUlPwrCfg
+S16 cmPkRgrUlPwrCfg
(
RgrUlPwrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUlPwrCfg(param, mBuf)
+S16 cmPkRgrUlPwrCfg(param, mBuf)
RgrUlPwrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlPwrCfg
+S16 cmUnpkRgrUlPwrCfg
(
RgrUlPwrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUlPwrCfg(param, mBuf)
+S16 cmUnpkRgrUlPwrCfg(param, mBuf)
RgrUlPwrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrPuschCfg
+S16 cmPkRgrPuschCfg
(
RgrPuschCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrPuschCfg(param, mBuf)
+S16 cmPkRgrPuschCfg(param, mBuf)
RgrPuschCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPuschCfg
+S16 cmUnpkRgrPuschCfg
(
RgrPuschCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrPuschCfg(param, mBuf)
+S16 cmUnpkRgrPuschCfg(param, mBuf)
RgrPuschCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCodeBookRstCfg
+S16 cmPkRgrCodeBookRstCfg
(
RgrCodeBookRstCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCodeBookRstCfg(param, mBuf)
+S16 cmPkRgrCodeBookRstCfg(param, mBuf)
RgrCodeBookRstCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCodeBookRstCfg
+S16 cmUnpkRgrCodeBookRstCfg
(
RgrCodeBookRstCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCodeBookRstCfg(param, mBuf)
+S16 cmUnpkRgrCodeBookRstCfg(param, mBuf)
RgrCodeBookRstCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrPreambleSetCfg
+S16 cmPkRgrPreambleSetCfg
(
RgrPreambleSetCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrPreambleSetCfg(param, mBuf)
+S16 cmPkRgrPreambleSetCfg(param, mBuf)
RgrPreambleSetCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrPreambleSetCfg
+S16 cmUnpkRgrPreambleSetCfg
(
RgrPreambleSetCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrPreambleSetCfg(param, mBuf)
+S16 cmUnpkRgrPreambleSetCfg(param, mBuf)
RgrPreambleSetCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCmnLchCfg
+S16 cmPkRgrCmnLchCfg
(
RgrCmnLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCmnLchCfg(param, mBuf)
+S16 cmPkRgrCmnLchCfg(param, mBuf)
RgrCmnLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCmnLchCfg
+S16 cmUnpkRgrCmnLchCfg
(
RgrCmnLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCmnLchCfg(param, mBuf)
+S16 cmUnpkRgrCmnLchCfg(param, mBuf)
RgrCmnLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDlfsCfg
+S16 cmPkRgrDlfsCfg
(
RgrDlfsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDlfsCfg(param, mBuf)
+S16 cmPkRgrDlfsCfg(param, mBuf)
RgrDlfsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlfsCfg
+S16 cmUnpkRgrDlfsCfg
(
RgrDlfsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDlfsCfg(param, mBuf)
+S16 cmUnpkRgrDlfsCfg(param, mBuf)
RgrDlfsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrTddPrachInfo
+S16 cmPkRgrTddPrachInfo
(
RgrTddPrachInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrTddPrachInfo(param, mBuf)
+S16 cmPkRgrTddPrachInfo(param, mBuf)
RgrTddPrachInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTddPrachInfo
+S16 cmUnpkRgrTddPrachInfo
(
RgrTddPrachInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrTddPrachInfo(param, mBuf)
+S16 cmUnpkRgrTddPrachInfo(param, mBuf)
RgrTddPrachInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrTddPrachRscInfo
+S16 cmPkRgrTddPrachRscInfo
(
RgrTddPrachRscInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrTddPrachRscInfo(param, mBuf)
+S16 cmPkRgrTddPrachRscInfo(param, mBuf)
RgrTddPrachRscInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrTddPrachRscInfo
+S16 cmUnpkRgrTddPrachRscInfo
(
RgrTddPrachRscInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrTddPrachRscInfo(param, mBuf)
+S16 cmUnpkRgrTddPrachRscInfo(param, mBuf)
RgrTddPrachRscInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrEnbPfs
+S16 cmPkRgrEnbPfs
(
RgrEnbPfs *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrEnbPfs(param, mBuf)
+S16 cmPkRgrEnbPfs(param, mBuf)
RgrEnbPfs *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEnbPfs
+S16 cmUnpkRgrEnbPfs
(
RgrEnbPfs *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEnbPfs(param, mBuf)
+S16 cmUnpkRgrEnbPfs(param, mBuf)
RgrEnbPfs *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSpsCellCfg
+S16 cmPkRgrSpsCellCfg
(
RgrSpsCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSpsCellCfg(param, mBuf)
+S16 cmPkRgrSpsCellCfg(param, mBuf)
RgrSpsCellCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSpsDlCellCfg
+S16 cmUnpkRgrSpsDlCellCfg
(
RgrSpsCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSpsDlCellCfg(param, mBuf)
+S16 cmUnpkRgrSpsDlCellCfg(param, mBuf)
RgrSpsCellCfg *param;
Buffer *mBuf;
#endif
}
#ifdef RG_5GTF
-PUBLIC S16 cmPkRgr5gtfCellCfg
+S16 cmPkRgr5gtfCellCfg
(
Rgr5gtfCellCfg *param,
Buffer *mBuf
return ROK;
}
-PUBLIC S16 cmUnPkRgr5gtfCellCfg
+S16 cmUnPkRgr5gtfCellCfg
(
Rgr5gtfCellCfg *param,
Buffer *mBuf
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLteAdvancedUeConfig
+S16 cmPkRgrLteAdvancedUeConfig
(
RgrLteAdvancedUeConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLteAdvancedUeConfig(param, mBuf)
+S16 cmPkRgrLteAdvancedUeConfig(param, mBuf)
RgrLteAdvancedUeConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLteAdvancedUeConfig
+S16 cmUnpkRgrLteAdvancedUeConfig
(
RgrLteAdvancedUeConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLteAdvancedUeConfig(param, mBuf)
+S16 cmUnpkRgrLteAdvancedUeConfig(param, mBuf)
RgrLteAdvancedUeConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrAbsConfig
+S16 cmPkRgrAbsConfig
(
RgrAbsConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrAbsConfig(param, mBuf)
+S16 cmPkRgrAbsConfig(param, mBuf)
RgrAbsConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSfrConfig
+S16 cmPkRgrSfrConfig
(
RgrSfrConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSfrConfig(param, mBuf)
+S16 cmPkRgrSfrConfig(param, mBuf)
RgrSfrConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDsfrConfig
+S16 cmPkRgrDsfrConfig
(
RgrDsfrConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDsfrConfig(param, mBuf)
+S16 cmPkRgrDsfrConfig(param, mBuf)
RgrDsfrConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDsfrConfig
+S16 cmUnpkRgrDsfrConfig
(
RgrDsfrConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDsfrConfig(param, mBuf)
+S16 cmUnpkRgrDsfrConfig(param, mBuf)
RgrDsfrConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCellLteAdvancedFeatureCfg
+S16 cmPkRgrCellLteAdvancedFeatureCfg
(
RgrLteAdvancedCellConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCellLteAdvancedFeatureCfg(param, mBuf)
+S16 cmPkRgrCellLteAdvancedFeatureCfg(param, mBuf)
RgrLteAdvancedCellConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrAbsConfig
+S16 cmUnpkRgrAbsConfig
(
RgrAbsConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrAbsConfig(param, mBuf)
+S16 cmUnpkRgrAbsConfig(param, mBuf)
RgrAbsConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSfrConfig
+S16 cmUnpkRgrSfrConfig
(
RgrSfrConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSfrConfig(param, mBuf)
+S16 cmUnpkRgrSfrConfig(param, mBuf)
RgrSfrConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellLteAdvancedFeatureCfg
+S16 cmUnpkRgrCellLteAdvancedFeatureCfg
(
RgrLteAdvancedCellConfig *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCellLteAdvancedFeatureCfg(param, mBuf)
+S16 cmUnpkRgrCellLteAdvancedFeatureCfg(param, mBuf)
RgrLteAdvancedCellConfig *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkMacSchedGnbCfg
+S16 cmPkMacSchedGnbCfg
(
MacSchedGnbCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkMacSchedGnbCfg(param, mBuf)
+S16 cmPkMacSchedGnbCfg(param, mBuf)
RgrSchedEnbCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkMacSchedGnbCfg
+S16 cmUnpkMacSchedGnbCfg
(
MacSchedGnbCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkMacSchedGnbCfg(param, mBuf)
+S16 cmUnpkMacSchedGnbCfg(param, mBuf)
MacSchedGnbCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCellCfg
+S16 cmPkRgrCellCfg
(
RgrCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCellCfg(param, mBuf)
+S16 cmPkRgrCellCfg(param, mBuf)
RgrCellCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellCfg
+S16 cmUnpkRgrCellCfg
(
RgrCellCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCellCfg(param, mBuf)
+S16 cmUnpkRgrCellCfg(param, mBuf)
RgrCellCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeAprdDlCqiCfg
+S16 cmPkRgrUeAprdDlCqiCfg
(
RgrUeAprdDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeAprdDlCqiCfg(param, mBuf)
+S16 cmPkRgrUeAprdDlCqiCfg(param, mBuf)
RgrUeAprdDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeAprdDlCqiCfg
+S16 cmUnpkRgrUeAprdDlCqiCfg
(
RgrUeAprdDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeAprdDlCqiCfg(param, mBuf)
+S16 cmUnpkRgrUeAprdDlCqiCfg(param, mBuf)
RgrUeAprdDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg
+S16 cmPkRgrUePrdDlCqiCfg
(
RgrUePrdDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
+S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
RgrUePrdDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg
+S16 cmUnpkRgrUePrdDlCqiCfg
(
RgrUePrdDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
+S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
RgrUePrdDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDlPCqiSetup
+S16 cmPkRgrUeDlPCqiSetup
(
RgrUeDlPCqiSetup *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeDlPCqiSetup(param, mBuf)
+S16 cmPkRgrUeDlPCqiSetup(param, mBuf)
RgrUeDlPCqiSetup *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDlPCqiSetup
+S16 cmUnpkRgrUeDlPCqiSetup
(
RgrUeDlPCqiSetup *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeDlPCqiSetup(param, mBuf)
+S16 cmUnpkRgrUeDlPCqiSetup(param, mBuf)
RgrUeDlPCqiSetup *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg
+S16 cmPkRgrUePrdDlCqiCfg
(
RgrUePrdDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
+S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
RgrUePrdDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg
+S16 cmUnpkRgrUePrdDlCqiCfg
(
RgrUePrdDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
+S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
RgrUePrdDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlSrsSetupCfg
+S16 cmPkRgrUeUlSrsSetupCfg
(
RgrUeUlSrsSetupCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeUlSrsSetupCfg(param, mBuf)
+S16 cmPkRgrUeUlSrsSetupCfg(param, mBuf)
RgrUeUlSrsSetupCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlSrsSetupCfg
+S16 cmUnpkRgrUeUlSrsSetupCfg
(
RgrUeUlSrsSetupCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeUlSrsSetupCfg(param, mBuf)
+S16 cmUnpkRgrUeUlSrsSetupCfg(param, mBuf)
RgrUeUlSrsSetupCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSrSetupCfg
+S16 cmPkRgrUeSrSetupCfg
(
RgrUeSrSetupCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSrSetupCfg(param, mBuf)
+S16 cmPkRgrUeSrSetupCfg(param, mBuf)
RgrUeSrSetupCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSrSetupCfg
+S16 cmUnpkRgrUeSrSetupCfg
(
RgrUeSrSetupCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSrSetupCfg(param, mBuf)
+S16 cmUnpkRgrUeSrSetupCfg(param, mBuf)
RgrUeSrSetupCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSrCfg
+S16 cmPkRgrUeSrCfg
(
RgrUeSrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSrCfg(param, mBuf)
+S16 cmPkRgrUeSrCfg(param, mBuf)
RgrUeSrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSrCfg
+S16 cmUnpkRgrUeSrCfg
(
RgrUeSrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSrCfg(param, mBuf)
+S16 cmUnpkRgrUeSrCfg(param, mBuf)
RgrUeSrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlSrsCfg
+S16 cmPkRgrUeUlSrsCfg
(
RgrUeUlSrsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeUlSrsCfg(param, mBuf)
+S16 cmPkRgrUeUlSrsCfg(param, mBuf)
RgrUeUlSrsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlSrsCfg
+S16 cmUnpkRgrUeUlSrsCfg
(
RgrUeUlSrsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeUlSrsCfg(param, mBuf)
+S16 cmUnpkRgrUeUlSrsCfg(param, mBuf)
RgrUeUlSrsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDlCqiCfg
+S16 cmPkRgrUeDlCqiCfg
(
RgrUeDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeDlCqiCfg(param, mBuf)
+S16 cmPkRgrUeDlCqiCfg(param, mBuf)
RgrUeDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDlCqiCfg
+S16 cmUnpkRgrUeDlCqiCfg
(
RgrUeDlCqiCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeDlCqiCfg(param, mBuf)
+S16 cmUnpkRgrUeDlCqiCfg(param, mBuf)
RgrUeDlCqiCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeMeasGapCfg
+S16 cmPkRgrUeMeasGapCfg
(
RgrUeMeasGapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeMeasGapCfg(param, mBuf)
+S16 cmPkRgrUeMeasGapCfg(param, mBuf)
RgrUeMeasGapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeMeasGapCfg
+S16 cmUnpkRgrUeMeasGapCfg
(
RgrUeMeasGapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeMeasGapCfg(param, mBuf)
+S16 cmUnpkRgrUeMeasGapCfg(param, mBuf)
RgrUeMeasGapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDrxLongCycleOffst
+S16 cmPkRgrDrxLongCycleOffst
(
RgrDrxLongCycleOffst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDrxLongCycleOffst(param, mBuf)
+S16 cmPkRgrDrxLongCycleOffst(param, mBuf)
RgrDrxLongCycleOffst *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDrxLongCycleOffst
+S16 cmUnpkRgrDrxLongCycleOffst
(
RgrDrxLongCycleOffst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDrxLongCycleOffst(param, mBuf)
+S16 cmUnpkRgrDrxLongCycleOffst(param, mBuf)
RgrDrxLongCycleOffst *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDrxShortDrx
+S16 cmPkRgrDrxShortDrx
(
RgrDrxShortDrx *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDrxShortDrx(param, mBuf)
+S16 cmPkRgrDrxShortDrx(param, mBuf)
RgrDrxShortDrx *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDrxShortDrx
+S16 cmUnpkRgrDrxShortDrx
(
RgrDrxShortDrx *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDrxShortDrx(param, mBuf)
+S16 cmUnpkRgrDrxShortDrx(param, mBuf)
RgrDrxShortDrx *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDrxCfg
+S16 cmPkRgrUeDrxCfg
(
RgrUeDrxCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeDrxCfg(param, mBuf)
+S16 cmPkRgrUeDrxCfg(param, mBuf)
RgrUeDrxCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDrxCfg
+S16 cmUnpkRgrUeDrxCfg
(
RgrUeDrxCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeDrxCfg(param, mBuf)
+S16 cmUnpkRgrUeDrxCfg(param, mBuf)
RgrUeDrxCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCapCfg
+S16 cmPkRgrUeCapCfg
(
RgrUeCapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeCapCfg(param, mBuf)
+S16 cmPkRgrUeCapCfg(param, mBuf)
RgrUeCapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCapCfg
+S16 cmUnpkRgrUeCapCfg
(
RgrUeCapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeCapCfg(param, mBuf)
+S16 cmUnpkRgrUeCapCfg(param, mBuf)
RgrUeCapCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeAckNackRepCfg
+S16 cmPkRgrUeAckNackRepCfg
(
RgrUeAckNackRepCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeAckNackRepCfg(param, mBuf)
+S16 cmPkRgrUeAckNackRepCfg(param, mBuf)
RgrUeAckNackRepCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeAckNackRepCfg
+S16 cmUnpkRgrUeAckNackRepCfg
(
RgrUeAckNackRepCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeAckNackRepCfg(param, mBuf)
+S16 cmUnpkRgrUeAckNackRepCfg(param, mBuf)
RgrUeAckNackRepCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeTxModeCfg
+S16 cmPkRgrUeTxModeCfg
(
RgrUeTxModeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeTxModeCfg(param, mBuf)
+S16 cmPkRgrUeTxModeCfg(param, mBuf)
RgrUeTxModeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeTxModeCfg
+S16 cmUnpkRgrUeTxModeCfg
(
RgrUeTxModeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeTxModeCfg(param, mBuf)
+S16 cmUnpkRgrUeTxModeCfg(param, mBuf)
RgrUeTxModeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlHqCfg
+S16 cmPkRgrUeUlHqCfg
(
RgrUeUlHqCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeUlHqCfg(param, mBuf)
+S16 cmPkRgrUeUlHqCfg(param, mBuf)
RgrUeUlHqCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlHqCfg
+S16 cmUnpkRgrUeUlHqCfg
(
RgrUeUlHqCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeUlHqCfg(param, mBuf)
+S16 cmUnpkRgrUeUlHqCfg(param, mBuf)
RgrUeUlHqCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeGrpPwrCfg
+S16 cmPkRgrUeGrpPwrCfg
(
RgrUeGrpPwrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeGrpPwrCfg(param, mBuf)
+S16 cmPkRgrUeGrpPwrCfg(param, mBuf)
RgrUeGrpPwrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeGrpPwrCfg
+S16 cmUnpkRgrUeGrpPwrCfg
(
RgrUeGrpPwrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeGrpPwrCfg(param, mBuf)
+S16 cmUnpkRgrUeGrpPwrCfg(param, mBuf)
RgrUeGrpPwrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSpsDlCfg
+S16 cmPkRgrUeSpsDlCfg
(
RgrUeSpsDlCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSpsDlCfg(param, mBuf)
+S16 cmPkRgrUeSpsDlCfg(param, mBuf)
RgrUeSpsDlCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSpsDlCfg
+S16 cmUnpkRgrUeSpsDlCfg
(
RgrUeSpsDlCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSpsDlCfg(param, mBuf)
+S16 cmUnpkRgrUeSpsDlCfg(param, mBuf)
RgrUeSpsDlCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSpsUlCfg
+S16 cmPkRgrUeSpsUlCfg
(
RgrUeSpsUlCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSpsUlCfg(param, mBuf)
+S16 cmPkRgrUeSpsUlCfg(param, mBuf)
RgrUeSpsUlCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSpsUlCfg
+S16 cmUnpkRgrUeSpsUlCfg
(
RgrUeSpsUlCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSpsUlCfg(param, mBuf)
+S16 cmUnpkRgrUeSpsUlCfg(param, mBuf)
RgrUeSpsUlCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSpsCfg
+S16 cmPkRgrUeSpsCfg
(
RgrUeSpsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSpsCfg(param, mBuf)
+S16 cmPkRgrUeSpsCfg(param, mBuf)
RgrUeSpsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSpsCfg
+S16 cmUnpkRgrUeSpsCfg
(
RgrUeSpsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSpsCfg(param, mBuf)
+S16 cmUnpkRgrUeSpsCfg(param, mBuf)
RgrUeSpsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeUlPwrCfg
+S16 cmPkRgrUeUlPwrCfg
(
RgrUeUlPwrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeUlPwrCfg(param, mBuf)
+S16 cmPkRgrUeUlPwrCfg(param, mBuf)
RgrUeUlPwrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeUlPwrCfg
+S16 cmUnpkRgrUeUlPwrCfg
(
RgrUeUlPwrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeUlPwrCfg(param, mBuf)
+S16 cmUnpkRgrUeUlPwrCfg(param, mBuf)
RgrUeUlPwrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeQosCfg
+S16 cmPkRgrUeQosCfg
(
RgrUeQosCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeQosCfg(param, mBuf)
+S16 cmPkRgrUeQosCfg(param, mBuf)
RgrUeQosCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeQosCfg
+S16 cmUnpkRgrUeQosCfg
(
RgrUeQosCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeQosCfg(param, mBuf)
+S16 cmUnpkRgrUeQosCfg(param, mBuf)
RgrUeQosCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUePuschDedCfg
+S16 cmPkRgrUePuschDedCfg
(
RgrUePuschDedCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUePuschDedCfg(param, mBuf)
+S16 cmPkRgrUePuschDedCfg(param, mBuf)
RgrUePuschDedCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePuschDedCfg
+S16 cmUnpkRgrUePuschDedCfg
(
RgrUePuschDedCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUePuschDedCfg(param, mBuf)
+S16 cmUnpkRgrUePuschDedCfg(param, mBuf)
RgrUePuschDedCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeTxAntSelCfg
+S16 cmPkRgrUeTxAntSelCfg
(
RgrUeTxAntSelCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeTxAntSelCfg(param, mBuf)
+S16 cmPkRgrUeTxAntSelCfg(param, mBuf)
RgrUeTxAntSelCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeTxAntSelCfg
+S16 cmUnpkRgrUeTxAntSelCfg
(
RgrUeTxAntSelCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeTxAntSelCfg(param, mBuf)
+S16 cmUnpkRgrUeTxAntSelCfg(param, mBuf)
RgrUeTxAntSelCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeTaTmrCfg
+S16 cmPkRgrUeTaTmrCfg
(
RgrUeTaTmrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeTaTmrCfg(param, mBuf)
+S16 cmPkRgrUeTaTmrCfg(param, mBuf)
RgrUeTaTmrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeTaTmrCfg
+S16 cmUnpkRgrUeTaTmrCfg
(
RgrUeTaTmrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeTaTmrCfg(param, mBuf)
+S16 cmUnpkRgrUeTaTmrCfg(param, mBuf)
RgrUeTaTmrCfg *param;
Buffer *mBuf;
#endif
#ifdef EMTC_ENABLE
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrEmtcUeCfg
+S16 cmUnpkRgrEmtcUeCfg
(
RgrUeEmtcCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrEmtcUeCfg(param, mBuf)
+S16 cmUnpkRgrEmtcUeCfg(param, mBuf)
RgrUeEmtcCfg *param;
Buffer *mBuf;
#endif
-PUBLIC S16 cmPkRgrEmtcUeCfg
+S16 cmPkRgrEmtcUeCfg
(
RgrUeEmtcCfg *param,
Buffer *mBuf
#endif
#ifdef RG_5GTF
-PUBLIC S16 cmUnpkRgr5gtfUeCfg
+S16 cmUnpkRgr5gtfUeCfg
(
RgrUe5gtfCfg *param,
Buffer *mBuf
return ROK;
}
-PUBLIC S16 cmPkRgr5gtfUeCfg
+S16 cmPkRgr5gtfUeCfg
(
RgrUe5gtfCfg *param,
Buffer *mBuf
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCfg
+S16 cmPkRgrUeCfg
(
RgrUeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeCfg(param, mBuf)
+S16 cmPkRgrUeCfg(param, mBuf)
RgrUeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCfg
+S16 cmUnpkRgrUeCfg
(
RgrUeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeCfg(param, mBuf)
+S16 cmUnpkRgrUeCfg(param, mBuf)
RgrUeCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLchQosCfg
+S16 cmPkRgrLchQosCfg
(
RgrLchQosCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLchQosCfg(param, mBuf)
+S16 cmPkRgrLchQosCfg(param, mBuf)
RgrLchQosCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchQosCfg
+S16 cmUnpkRgrLchQosCfg
(
RgrLchQosCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLchQosCfg(param, mBuf)
+S16 cmUnpkRgrLchQosCfg(param, mBuf)
RgrLchQosCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLchSpsCfg
+S16 cmPkRgrLchSpsCfg
(
RgrLchSpsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLchSpsCfg(param, mBuf)
+S16 cmPkRgrLchSpsCfg(param, mBuf)
RgrLchSpsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchSpsCfg
+S16 cmUnpkRgrLchSpsCfg
(
RgrLchSpsCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLchSpsCfg(param, mBuf)
+S16 cmUnpkRgrLchSpsCfg(param, mBuf)
RgrLchSpsCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDlLchCfg
+S16 cmPkRgrDlLchCfg
(
RgrDlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDlLchCfg(param, mBuf)
+S16 cmPkRgrDlLchCfg(param, mBuf)
RgrDlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDlLchCfg
+S16 cmUnpkRgrDlLchCfg
(
RgrDlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDlLchCfg(param, mBuf)
+S16 cmUnpkRgrDlLchCfg(param, mBuf)
RgrDlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUlLchCfg
+S16 cmPkRgrUlLchCfg
(
RgrUlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUlLchCfg(param, mBuf)
+S16 cmPkRgrUlLchCfg(param, mBuf)
RgrUlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlLchCfg
+S16 cmUnpkRgrUlLchCfg
(
RgrUlLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUlLchCfg(param, mBuf)
+S16 cmUnpkRgrUlLchCfg(param, mBuf)
RgrUlLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUlLcgCfg
+S16 cmPkRgrUlLcgCfg
(
RgrUlLcgCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUlLcgCfg(param, mBuf)
+S16 cmPkRgrUlLcgCfg(param, mBuf)
RgrUlLcgCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlLcgCfg
+S16 cmUnpkRgrUlLcgCfg
(
RgrUlLcgCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUlLcgCfg(param, mBuf)
+S16 cmUnpkRgrUlLcgCfg(param, mBuf)
RgrUlLcgCfg *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkRgrUlLchQciCfg
+S16 cmPkRgrUlLchQciCfg
(
RgrUlLchQciCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUlLchQciCfg (param, mBuf)
+S16 cmPkRgrUlLchQciCfg (param, mBuf)
RgrUlLchQciCfg *param;
Buffer *mBuf;
#endif
return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUlLchQciCfg
+S16 cmUnpkRgrUlLchQciCfg
(
RgrUlLchQciCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUlLchQciCfg (param, mBuf)
+S16 cmUnpkRgrUlLchQciCfg (param, mBuf)
RgrUlLchQciCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLchCfg
+S16 cmPkRgrLchCfg
(
RgrLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLchCfg(param, mBuf)
+S16 cmPkRgrLchCfg(param, mBuf)
RgrLchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchCfg
+S16 cmUnpkRgrLchCfg
(
RgrLchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLchCfg(param, mBuf)
+S16 cmUnpkRgrLchCfg(param, mBuf)
RgrLchCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrLcgCfg
+S16 cmPkRgrLcgCfg
(
RgrLcgCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLcgCfg(param, mBuf)
+S16 cmPkRgrLcgCfg(param, mBuf)
RgrLcgCfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLcgCfg
+S16 cmUnpkRgrLcgCfg
(
RgrLcgCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLcgCfg(param, mBuf)
+S16 cmUnpkRgrLcgCfg(param, mBuf)
RgrLcgCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCfg
+S16 cmPkRgrCfg
(
RgrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCfg(param, mBuf)
+S16 cmPkRgrCfg(param, mBuf)
RgrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfg
+S16 cmUnpkRgrCfg
(
RgrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCfg(param, mBuf)
+S16 cmUnpkRgrCfg(param, mBuf)
RgrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrActvTime
+S16 cmPkRgrActvTime
(
RgrActvTime *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrActvTime(param, mBuf)
+S16 cmPkRgrActvTime(param, mBuf)
RgrActvTime *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrActvTime
+S16 cmUnpkRgrActvTime
(
RgrActvTime *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrActvTime(param, mBuf)
+S16 cmUnpkRgrActvTime(param, mBuf)
RgrActvTime *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCellRecfg
+S16 cmPkRgrCellRecfg
(
RgrCellRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCellRecfg(param, mBuf)
+S16 cmPkRgrCellRecfg(param, mBuf)
RgrCellRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellRecfg
+S16 cmUnpkRgrCellRecfg
(
RgrCellRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCellRecfg(param, mBuf)
+S16 cmUnpkRgrCellRecfg(param, mBuf)
RgrCellRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeRecfg
+S16 cmPkRgrUeRecfg
(
RgrUeRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeRecfg(param, mBuf)
+S16 cmPkRgrUeRecfg(param, mBuf)
RgrUeRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeRecfg
+S16 cmUnpkRgrUeRecfg
(
RgrUeRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeRecfg(param, mBuf)
+S16 cmUnpkRgrUeRecfg(param, mBuf)
RgrUeRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLchRecfg
+S16 cmPkRgrLchRecfg
(
RgrLchRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLchRecfg(param, mBuf)
+S16 cmPkRgrLchRecfg(param, mBuf)
RgrLchRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLchRecfg
+S16 cmUnpkRgrLchRecfg
(
RgrLchRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLchRecfg(param, mBuf)
+S16 cmUnpkRgrLchRecfg(param, mBuf)
RgrLchRecfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkRgrLcgRecfg
+S16 cmPkRgrLcgRecfg
(
RgrLcgRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLcgRecfg(param, mBuf)
+S16 cmPkRgrLcgRecfg(param, mBuf)
RgrLcgRecfg *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLcgRecfg
+S16 cmUnpkRgrLcgRecfg
(
RgrLcgRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLcgRecfg(param, mBuf)
+S16 cmUnpkRgrLcgRecfg(param, mBuf)
RgrLcgRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrRecfg
+S16 cmPkRgrRecfg
(
RgrRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrRecfg(param, mBuf)
+S16 cmPkRgrRecfg(param, mBuf)
RgrRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRecfg
+S16 cmUnpkRgrRecfg
(
RgrRecfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrRecfg(param, mBuf)
+S16 cmUnpkRgrRecfg(param, mBuf)
RgrRecfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeDlSecCellRelInfo
+S16 cmPkRgrUeDlSecCellRelInfo
(
RgrUeDlSecCellRelInfo *param,
Buffer *mBuf
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSecCellRelInfo
+S16 cmPkRgrUeSecCellRelInfo
(
RgrUeSecCellRelInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSecCellRelInfo(param, mBuf)
+S16 cmPkRgrUeSecCellRelInfo(param, mBuf)
RgrUeSecCellRelInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrDel
+S16 cmPkRgrDel
(
RgrDel *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrDel(param, mBuf)
+S16 cmPkRgrDel(param, mBuf)
RgrDel *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeDlSecCellRelInfo
+S16 cmUnpkRgrUeDlSecCellRelInfo
(
RgrUeDlSecCellRelInfo *param,
Buffer *mBuf
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSecCellRelInfo
+S16 cmUnpkRgrUeSecCellRelInfo
(
RgrUeSecCellRelInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSecCellRelInfo(param, mBuf)
+S16 cmUnpkRgrUeSecCellRelInfo(param, mBuf)
RgrUeSecCellRelInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrDel
+S16 cmUnpkRgrDel
(
RgrDel *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrDel(param, mBuf)
+S16 cmUnpkRgrDel(param, mBuf)
RgrDel *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSonPrbCfg
+S16 cmPkRgrSonPrbCfg
(
RgrPrbCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSonPrbCfg(param, mBuf)
+S16 cmPkRgrSonPrbCfg(param, mBuf)
RgrPrbCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSonPrbCfg
+S16 cmUnpkRgrSonPrbCfg
(
RgrPrbCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSonPrbCfg(param, mBuf)
+S16 cmUnpkRgrSonPrbCfg(param, mBuf)
RgrPrbCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSonCfg
+S16 cmPkRgrSonCfg
(
RgrSonCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSonCfg(param, mBuf)
+S16 cmPkRgrSonCfg(param, mBuf)
RgrSonCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSonCfg
+S16 cmUnpkRgrSonCfg
(
RgrSonCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSonCfg(param, mBuf)
+S16 cmUnpkRgrSonCfg(param, mBuf)
RgrSonCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrRst
+S16 cmPkRgrRst
(
RgrRst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrRst(param, mBuf)
+S16 cmPkRgrRst(param, mBuf)
RgrRst *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrRst
+S16 cmUnpkRgrRst
(
RgrRst *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrRst(param, mBuf)
+S16 cmUnpkRgrRst(param, mBuf)
RgrRst *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnPkRgrSCellActDeactEvnt
+S16 cmUnPkRgrSCellActDeactEvnt
(
RgrSCellActDeactEvnt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnPkRgrSCellActDeactEvnt(param, mBuf)
+S16 cmUnPkRgrSCellActDeactEvnt(param, mBuf)
RgrSCellActDeactEvnt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSCellActDeactEvnt
+S16 cmPkRgrSCellActDeactEvnt
(
RgrSCellActDeactEvnt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSCellActDeactEvnt(param, mBuf)
+S16 cmPkRgrSCellActDeactEvnt(param, mBuf)
RgrSCellActDeactEvnt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCfgReqInfo
+S16 cmPkRgrCfgReqInfo
(
RgrCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCfgReqInfo(param, mBuf)
+S16 cmPkRgrCfgReqInfo(param, mBuf)
RgrCfgReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCfgReqInfo
+S16 cmUnpkRgrCfgReqInfo
(
RgrCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCfgReqInfo(param, mBuf)
+S16 cmUnpkRgrCfgReqInfo(param, mBuf)
RgrCfgReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeBsrTmrCfg
+S16 cmPkRgrUeBsrTmrCfg
(
RgrUeBsrTmrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeBsrTmrCfg(param, mBuf)
+S16 cmPkRgrUeBsrTmrCfg(param, mBuf)
RgrUeBsrTmrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeBsrTmrCfg
+S16 cmUnpkRgrUeBsrTmrCfg
(
RgrUeBsrTmrCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeBsrTmrCfg(param, mBuf)
+S16 cmUnpkRgrUeBsrTmrCfg(param, mBuf)
RgrUeBsrTmrCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfgReq
+S16 cmPkRgrSiCfgReq
(
Pst* pst,
SpId spId,
RgrSiCfgReqInfo * cfgReqInfo
)
#else
-PUBLIC S16 cmPkRgrSiCfgReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkRgrSiCfgReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
RgrCfgTransId transId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfgReq
+S16 cmUnpkRgrSiCfgReq
(
RgrSiCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSiCfgReq(func, pst, mBuf)
+S16 cmUnpkRgrSiCfgReq(func, pst, mBuf)
RgrSiCfgReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfgReqInfo
+S16 cmPkRgrSiCfgReqInfo
(
RgrSiCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSiCfgReqInfo(param, mBuf)
+S16 cmPkRgrSiCfgReqInfo(param, mBuf)
RgrSiCfgReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSiCfgReqInfo
+S16 cmUnpkRgrSiCfgReqInfo
(
RgrSiCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSiCfgReqInfo(param, mBuf)
+S16 cmUnpkRgrSiCfgReqInfo(param, mBuf)
RgrSiCfgReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiCfgReq
+S16 cmPkRgrWarningSiCfgReq
(
Pst* pst,
SpId spId,
RgrWarningSiCfgReqInfo * warningSiCfgReqInfo
)
#else
-PUBLIC S16 cmPkRgrWarningSiCfgReq(pst, spId, transId, warningSiCfgReqInfo)
+S16 cmPkRgrWarningSiCfgReq(pst, spId, transId, warningSiCfgReqInfo)
Pst* pst;
SpId spId;
RgrCfgTransId transId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiCfgReq
+S16 cmUnpkRgrWarningSiCfgReq
(
RgrWarningSiCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrWarningSiCfgReq(func, pst, mBuf)
+S16 cmUnpkRgrWarningSiCfgReq(func, pst, mBuf)
RgrWarningSiCfgReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiCfgReqInfo
+S16 cmPkRgrWarningSiCfgReqInfo
(
Pst *pst,
RgrWarningSiCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrWarningSiCfgReqInfo(pst, param, mBuf)
+S16 cmPkRgrWarningSiCfgReqInfo(pst, param, mBuf)
Pst *pst;
RgrWarningSiCfgReqInfo *param;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiCfgReqInfo
+S16 cmUnpkRgrWarningSiCfgReqInfo
(
Pst *pst,
RgrWarningSiCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrWarningSiCfgReqInfo(pst, param, mBuf)
+S16 cmUnpkRgrWarningSiCfgReqInfo(pst, param, mBuf)
Pst *pst;
RgrWarningSiCfgReqInfo *param;
Buffer *mBuf;
* File :
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiStopReq
+S16 cmPkRgrWarningSiStopReq
(
Pst *pst,
SpId spId,
U8 siId
)
#else
-PUBLIC S16 cmPkRgrWarningSiStopReq(pst,spId, transId, siId)
+S16 cmPkRgrWarningSiStopReq(pst,spId, transId, siId)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
* File :
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiStopReq
+S16 cmUnpkRgrWarningSiStopReq
(
RgrWarningSiStopReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrWarningSiStopReq(param, mBuf)
+S16 cmUnpkRgrWarningSiStopReq(param, mBuf)
RgrWarningSiStopReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiCfgCfm
+S16 cmPkRgrWarningSiCfgCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
+S16 cmPkRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrWarningSiCfgCfm
+S16 cmUnpkRgrWarningSiCfgCfm
(
RgrWarningSiCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrWarningSiCfgCfm(func, pst, mBuf)
+S16 cmUnpkRgrWarningSiCfgCfm(func, pst, mBuf)
RgrWarningSiCfgCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfReq
+S16 cmPkRgrLoadInfReq
(
Pst* pst,
SpId spId,
RgrLoadInfReqInfo * loadInfReq
)
#else
-PUBLIC S16 cmPkRgrLoadInfReq(pst, spId, transId, loadInfReq)
+S16 cmPkRgrLoadInfReq(pst, spId, transId, loadInfReq)
Pst* pst;
SpId spId;
RgrCfgTransId transId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfReq
+S16 cmUnpkRgrLoadInfReq
(
RgrLoadInfReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLoadInfReq(func, pst, mBuf)
+S16 cmUnpkRgrLoadInfReq(func, pst, mBuf)
RgrLoadInfReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfReqInfo
+S16 cmPkRgrLoadInfReqInfo
(
RgrLoadInfReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLoadInfReqInfo(param, mBuf)
+S16 cmPkRgrLoadInfReqInfo(param, mBuf)
RgrLoadInfReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfReqInfo
+S16 cmUnpkRgrLoadInfReqInfo
(
RgrLoadInfReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLoadInfReqInfo(param, mBuf)
+S16 cmUnpkRgrLoadInfReqInfo(param, mBuf)
RgrLoadInfReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCqiReptCfg
+S16 cmPkRgrUeCqiReptCfg
(
RgrUeCqiReptCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeCqiReptCfg(param, mBuf)
+S16 cmPkRgrUeCqiReptCfg(param, mBuf)
RgrUeCqiReptCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCqiReptCfg
+S16 cmUnpkRgrUeCqiReptCfg
(
RgrUeCqiReptCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeCqiReptCfg(param, mBuf)
+S16 cmUnpkRgrUeCqiReptCfg(param, mBuf)
RgrUeCqiReptCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrStaInd
+S16 cmPkRgrStaInd
(
Pst* pst,
SuId suId,
RgrStaIndInfo* staInd
)
#else
-PUBLIC S16 cmPkRgrStaInd(pst, suId, staInd)
+S16 cmPkRgrStaInd(pst, suId, staInd)
Pst* pst;
SuId suId;
RgrStaIndInfo* staInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrStaInd
+S16 cmUnpkRgrStaInd
(
RgrStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrStaInd(func, pst, mBuf)
+S16 cmUnpkRgrStaInd(func, pst, mBuf)
RgrStaInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrStaIndInfo
+S16 cmPkRgrStaIndInfo
(
RgrStaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrStaIndInfo(param, mBuf)
+S16 cmPkRgrStaIndInfo(param, mBuf)
RgrStaIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrStaIndInfo
+S16 cmUnpkRgrStaIndInfo
(
RgrStaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrStaIndInfo(param, mBuf)
+S16 cmUnpkRgrStaIndInfo(param, mBuf)
RgrStaIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCqiInfo
+S16 cmPkRgrUeCqiInfo
(
RgrUeCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeCqiInfo(param, mBuf)
+S16 cmPkRgrUeCqiInfo(param, mBuf)
RgrUeCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCqiInfo
+S16 cmUnpkRgrUeCqiInfo
(
RgrUeCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeCqiInfo(param, mBuf)
+S16 cmUnpkRgrUeCqiInfo(param, mBuf)
RgrUeCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSubBandCqiInfo
+S16 cmPkRgrSubBandCqiInfo
(
RgrSubBandCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrSubBandCqiInfo(param, mBuf)
+S16 cmPkRgrSubBandCqiInfo(param, mBuf)
RgrSubBandCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeCqiRept
+S16 cmPkRgrUeCqiRept
(
RgrUeCqiRept *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeCqiRept(param, mBuf)
+S16 cmPkRgrUeCqiRept(param, mBuf)
RgrUeCqiRept *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrSubBandCqiInfo
+S16 cmUnpkRgrSubBandCqiInfo
(
RgrSubBandCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrSubBandCqiInfo(param, mBuf)
+S16 cmUnpkRgrSubBandCqiInfo(param, mBuf)
RgrSubBandCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeCqiRept
+S16 cmUnpkRgrUeCqiRept
(
RgrUeCqiRept *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeCqiRept(param, mBuf)
+S16 cmUnpkRgrUeCqiRept(param, mBuf)
RgrUeCqiRept *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfInd
+S16 cmPkRgrLoadInfInd
(
Pst* pst,
SuId suId,
RgrLoadInfIndInfo* loadInfInd
)
#else
-PUBLIC S16 cmPkRgrLoadInfInd(pst, suId, loadInfInd)
+S16 cmPkRgrLoadInfInd(pst, suId, loadInfInd)
Pst* pst;
SuId suId;
RgrLoadInfIndInfo* loadInfInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfInd
+S16 cmUnpkRgrLoadInfInd
(
RgrLoadInfInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLoadInfInd(func, pst, mBuf)
+S16 cmUnpkRgrLoadInfInd(func, pst, mBuf)
RgrLoadInfInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrLoadInfIndInfo
+S16 cmPkRgrLoadInfIndInfo
(
RgrLoadInfIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrLoadInfIndInfo(param, mBuf)
+S16 cmPkRgrLoadInfIndInfo(param, mBuf)
RgrLoadInfIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrLoadInfIndInfo
+S16 cmUnpkRgrLoadInfIndInfo
(
RgrLoadInfIndInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrLoadInfIndInfo(param, pst, mBuf)
+S16 cmUnpkRgrLoadInfIndInfo(param, pst, mBuf)
RgrLoadInfIndInfo *param;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUepACfg
+S16 cmPkRgrUepACfg
(
RgrUepACfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUepACfg(param, mBuf)
+S16 cmPkRgrUepACfg(param, mBuf)
RgrUepACfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUepACfg
+S16 cmUnpkRgrUepACfg
(
RgrUepACfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUepACfg(param, mBuf)
+S16 cmUnpkRgrUepACfg(param, mBuf)
RgrUepACfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUePdschDedCfg
+S16 cmPkRgrUePdschDedCfg
(
RgrUePdschDedCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUePdschDedCfg(param, mBuf)
+S16 cmPkRgrUePdschDedCfg(param, mBuf)
RgrUePdschDedCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUePdschDedCfg
+S16 cmUnpkRgrUePdschDedCfg
(
RgrUePdschDedCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUePdschDedCfg(param, mBuf)
+S16 cmUnpkRgrUePdschDedCfg(param, mBuf)
RgrUePdschDedCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSecCellInfo
+S16 cmPkRgrUeSecCellInfo
(
RgrUeSecCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSecCellInfo(param, mBuf)
+S16 cmPkRgrUeSecCellInfo(param, mBuf)
RgrUeSecCellInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSecCellInfo
+S16 cmUnpkRgrUeSecCellInfo
(
RgrUeSecCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSecCellInfo(param, mBuf)
+S16 cmUnpkRgrUeSecCellInfo(param, mBuf)
RgrUeSecCellInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeSCellAckPucchCfg
+S16 cmPkRgrUeSCellAckPucchCfg
(
RgrUeSCellAckPucchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeSCellAckPucchCfg(param, mBuf)
+S16 cmPkRgrUeSCellAckPucchCfg(param, mBuf)
RgrUeSCellAckPucchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeSCellAckPucchCfg
+S16 cmUnpkRgrUeSCellAckPucchCfg
(
RgrUeSCellAckPucchCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeSCellAckPucchCfg(param, mBuf)
+S16 cmUnpkRgrUeSCellAckPucchCfg(param, mBuf)
RgrUeSCellAckPucchCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeStaInd
+S16 cmPkRgrUeStaInd
(
Pst* pst,
SuId suId,
RgrUeStaIndInfo* ueStaInd
)
#else
-PUBLIC S16 cmPkRgrUeStaInd(pst, suId, ueStaInd)
+S16 cmPkRgrUeStaInd(pst, suId, ueStaInd)
Pst* pst;
SuId suId;
RgrUeStaIndInfo* ueStaInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeStaInd
+S16 cmUnpkRgrUeStaInd
(
RgrUeStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeStaInd(func, pst, mBuf)
+S16 cmUnpkRgrUeStaInd(func, pst, mBuf)
RgrUeStaInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrUeStaIndInfo
+S16 cmPkRgrUeStaIndInfo
(
RgrUeStaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrUeStaIndInfo(param, mBuf)
+S16 cmPkRgrUeStaIndInfo(param, mBuf)
RgrUeStaIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrUeStaIndInfo
+S16 cmUnpkRgrUeStaIndInfo
(
RgrUeStaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrUeStaIndInfo(param, mBuf)
+S16 cmUnpkRgrUeStaIndInfo(param, mBuf)
RgrUeStaIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCellCsgParamCfg
+S16 cmPkRgrCellCsgParamCfg
(
RgrCellCsgParamCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCellCsgParamCfg(param, mBuf)
+S16 cmPkRgrCellCsgParamCfg(param, mBuf)
RgrCellCsgParamCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellCsgParamCfg
+S16 cmUnpkRgrCellCsgParamCfg
(
RgrCellCsgParamCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCellCsgParamCfg(param, mBuf)
+S16 cmUnpkRgrCellCsgParamCfg(param, mBuf)
RgrCellCsgParamCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCellCntrlCmdCfg
+S16 cmPkRgrCellCntrlCmdCfg
(
RgrCellCntrlCmdCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgrCellCntrlCmdCfg(param, mBuf)
+S16 cmPkRgrCellCntrlCmdCfg(param, mBuf)
RgrCellCntrlCmdCfg *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgrCellCntrlCmdCfg
+S16 cmUnpkRgrCellCntrlCmdCfg
(
RgrCellCntrlCmdCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgrCellCntrlCmdCfg(param, mBuf)
+S16 cmUnpkRgrCellCntrlCmdCfg(param, mBuf)
RgrCellCntrlCmdCfg *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRguBndReq
+S16 cmPkRguBndReq
(
Pst* pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkRguBndReq(pst, suId, spId)
+S16 cmPkRguBndReq(pst, suId, spId)
Pst* pst;
SuId suId;
SpId spId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguBndReq
+S16 cmUnpkRguBndReq
(
RguBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguBndReq(func, pst, mBuf)
+S16 cmUnpkRguBndReq(func, pst, mBuf)
RguBndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRguUbndReq
+S16 cmPkRguUbndReq
(
Pst* pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkRguUbndReq(pst, spId, reason)
+S16 cmPkRguUbndReq(pst, spId, reason)
Pst* pst;
SpId spId;
Reason reason;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguUbndReq
+S16 cmUnpkRguUbndReq
(
RguUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguUbndReq(func, pst, mBuf)
+S16 cmUnpkRguUbndReq(func, pst, mBuf)
RguUbndReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRguBndCfm
+S16 cmPkRguBndCfm
(
Pst* pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkRguBndCfm(pst, suId, status)
+S16 cmPkRguBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
U8 status;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguBndCfm
+S16 cmUnpkRguBndCfm
(
RguBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguBndCfm(func, pst, mBuf)
+S16 cmUnpkRguBndCfm(func, pst, mBuf)
RguBndCfm func;
Pst *pst;
Buffer *mBuf;
* @return S16
* -# ROK
**/
-PUBLIC uint16_t packDlData
+uint16_t packDlData
(
Pst* pst,
SpId spId,
* @return S16
* -# ROK
**/
-PUBLIC S16 unpackDlData
+S16 unpackDlData
(
RlcMacDlData func,
Pst *pst,
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguL2MUlThrpMeasReqInfo
+S16 cmPkRguL2MUlThrpMeasReqInfo
(
RguL2MUlThrpMeasReqInfo* param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguL2MUlThrpMeasReqInfo(param, mBuf)
+S16 cmPkRguL2MUlThrpMeasReqInfo(param, mBuf)
RguL2MUlThrpMeasReqInfo* param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguL2MUlThrpMeasReqInfo
+S16 cmUnpkRguL2MUlThrpMeasReqInfo
(
RguL2MUlThrpMeasReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguL2MUlThrpMeasReqInfo(param, mBuf)
+S16 cmUnpkRguL2MUlThrpMeasReqInfo(param, mBuf)
RguL2MUlThrpMeasReqInfo *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRguL2MUlThrpMeasReq
+S16 cmPkRguL2MUlThrpMeasReq
(
Pst* pst,
SpId spId,
RguL2MUlThrpMeasReqInfo* measReq
)
#else
-PUBLIC S16 cmPkRguL2MUlThrpMeasReq(pst, spId, measReq)
+S16 cmPkRguL2MUlThrpMeasReq(pst, spId, measReq)
Pst* pst;
SpId spId;
RguL2MUlThrpMeasReqInfo* measReq;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguL2MUlThrpMeasReq
+S16 cmUnpkRguL2MUlThrpMeasReq
(
RguL2MUlThrpMeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguL2MUlThrpMeasReq(func, pst, mBuf)
+S16 cmUnpkRguL2MUlThrpMeasReq(func, pst, mBuf)
RguL2MUlThrpMeasReq func;
Pst *pst;
Buffer *mBuf;
* @return S16
* -# ROK
**/
-PUBLIC uint16_t packBOStatus
+uint16_t packBOStatus
(
Pst* pst,
SpId spId,
* @return S16
* -# ROK
**/
-PUBLIC uint16_t unpackBOStatus
+uint16_t unpackBOStatus
(
RlcMacBoStatus func,
Pst *pst,
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRguHqStaInd
+S16 cmPkRguHqStaInd
(
Pst* pst,
SuId suId,
RguHarqStatusInd *harqStatusInd
)
#else
-PUBLIC S16 cmPkRguHqStaInd(pst, suId, harqStatusInd)
+S16 cmPkRguHqStaInd(pst, suId, harqStatusInd)
Pst* pst;
SuId suId;
RguHarqStatusInd *harqStatusInd;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguHqStaInd
+S16 cmUnpkRguHqStaInd
(
RguHqStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguHqStaInd(func, pst, mBuf)
+S16 cmUnpkRguHqStaInd(func, pst, mBuf)
RguHqStaInd func;
Pst *pst;
Buffer *mBuf;
* @return S16
* -# ROK
**/
-PUBLIC S16 packSchedRep
+S16 packSchedRep
(
Pst* pst,
SuId suId,
* @return S16
* -# ROK
**/
-PUBLIC S16 unpackSchedRep
+S16 unpackSchedRep
(
RlcMacSchedRep func,
Pst *pst,
}
#ifdef ANSI
-PUBLIC S16 cmPkRguLcFlowCntrlInfo
+S16 cmPkRguLcFlowCntrlInfo
(
RguLcFlowCntrlInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguLcFlowCntrlInfo (param,mBuf)
+S16 cmPkRguLcFlowCntrlInfo (param,mBuf)
RguLcFlowCntrlInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkRguUeFlowCntrlInfo
+S16 cmPkRguUeFlowCntrlInfo
(
RguUeFlowCntrlInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguUeFlowCntrlInfo (param,mBuf)
+S16 cmPkRguUeFlowCntrlInfo (param,mBuf)
RguUeFlowCntrlInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmPkRguFlowCntrlInfo
+S16 cmPkRguFlowCntrlInfo
(
RguFlowCntrlInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguFlowCntrlInfo(flowCntrlInd, mBuf)
+S16 cmPkRguFlowCntrlInfo(flowCntrlInd, mBuf)
RguFlowCntrlInd *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkRguFlowCntrlInd
+S16 cmPkRguFlowCntrlInd
(
Pst* pst,
SuId suId,
RguFlowCntrlInd *flowCntrlInd
)
#else
-PUBLIC S16 cmPkRguFlowCntrlInd(pst, suId, flowCntrlInd)
+S16 cmPkRguFlowCntrlInd(pst, suId, flowCntrlInd)
Pst* pst;
SuId suId;
RguFlowCntrlInd *flowCntrlInd;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkRguLcFlowCntrlInfo
+S16 cmUnpkRguLcFlowCntrlInfo
(
RguLcFlowCntrlInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguLcFlowCntrlInfo (param,mBuf)
+S16 cmUnpkRguLcFlowCntrlInfo (param,mBuf)
RguLcFlowCntrlInfo *param;
Buffer *mBuf;
#endif
return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkRguUeFlowCntrlInfo
+S16 cmUnpkRguUeFlowCntrlInfo
(
RguUeFlowCntrlInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguUeFlowCntrlInfo (param,mBuf)
+S16 cmUnpkRguUeFlowCntrlInfo (param,mBuf)
RguUeFlowCntrlInfo *param;
Buffer *mBuf;
#endif
}
#ifdef ANSI
-PUBLIC S16 cmUnpkRguFlowCntrlInfo
+S16 cmUnpkRguFlowCntrlInfo
(
RguFlowCntrlInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguFlowCntrlInfo(flowCntrlInfo, mBuf)
+S16 cmUnpkRguFlowCntrlInfo(flowCntrlInfo, mBuf)
RguFlowCntrlInd *param;
Buffer *mBuf;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguFlowCntrlInd
+S16 cmUnpkRguFlowCntrlInd
(
RguFlowCntrlIndInfo func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguFlowCntrlInd(func, pst, mBuf)
+S16 cmUnpkRguFlowCntrlInd(func, pst, mBuf)
RguFlowCntrlIndInfo func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguPduInfo
+S16 cmPkRguPduInfo
(
RguPduInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguPduInfo(param, mBuf)
+S16 cmPkRguPduInfo(param, mBuf)
RguPduInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguPduInfo
+S16 cmUnpkRguPduInfo
(
RguPduInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguPduInfo(param, mBuf)
+S16 cmUnpkRguPduInfo(param, mBuf)
RguPduInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguDBoReport
+S16 cmPkRguDBoReport
(
RguDBoReport *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguDBoReport(param, mBuf)
+S16 cmPkRguDBoReport(param, mBuf)
RguDBoReport *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguDBoReport
+S16 cmUnpkRguDBoReport
(
RguDBoReport *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguDBoReport(param, mBuf)
+S16 cmUnpkRguDBoReport(param, mBuf)
RguDBoReport *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguCDatReqInfo
+S16 cmPkRguCDatReqInfo
(
RguCDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguCDatReqInfo(param, mBuf)
+S16 cmPkRguCDatReqInfo(param, mBuf)
RguCDatReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguCDatReqInfo
+S16 cmUnpkRguCDatReqInfo
(
RguCDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguCDatReqInfo(param, mBuf)
+S16 cmUnpkRguCDatReqInfo(param, mBuf)
RguCDatReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguLchDatReq
+S16 cmPkRguLchDatReq
(
RguLchDatReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguLchDatReq(param, mBuf)
+S16 cmPkRguLchDatReq(param, mBuf)
RguLchDatReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguLchDatReq
+S16 cmUnpkRguLchDatReq
(
RguLchDatReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguLchDatReq(param, mBuf)
+S16 cmUnpkRguLchDatReq(param, mBuf)
RguLchDatReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguDatReqTb
+S16 cmPkRguDatReqTb
(
RguDatReqTb *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguDatReqTb(param, mBuf)
+S16 cmPkRguDatReqTb(param, mBuf)
RguDatReqTb *param;
Buffer *mBuf;
#endif
**********************************************************/
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC S16 cmUnpkRguDatReqTb
+S16 cmUnpkRguDatReqTb
(
Pst *pst,
RguDatReqTb *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguDatReqTb(pst, param, mBuf)
+S16 cmUnpkRguDatReqTb(pst, param, mBuf)
Pst *pst;
RguDatReqTb *param;
Buffer *mBuf;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmUnpkRguDatReqTb
+S16 cmUnpkRguDatReqTb
(
RguDatReqTb *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguDatReqTb(param, mBuf)
+S16 cmUnpkRguDatReqTb(param, mBuf)
RguDatReqTb *param;
Buffer *mBuf;
#endif
/*rgu_c_001.main_5 - ADD - L2M Support */
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC S16 cmPkRguDDatReqInfo
+S16 cmPkRguDDatReqInfo
(
Pst *pst,
RguDDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguDDatReqInfo(pst, param, mBuf)
+S16 cmPkRguDDatReqInfo(pst, param, mBuf)
Pst *pst;
RguDDatReqInfo *param;
Buffer *mBuf;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmPkRguDDatReqInfo
+S16 cmPkRguDDatReqInfo
(
RguDDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguDDatReqInfo(param, mBuf)
+S16 cmPkRguDDatReqInfo(param, mBuf)
RguDDatReqInfo *param;
Buffer *mBuf;
#endif
**********************************************************/
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC S16 cmUnpkRguDDatReqInfo
+S16 cmUnpkRguDDatReqInfo
(
Pst *pst,
RguDDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguDDatReqInfo(pst, param, mBuf)
+S16 cmUnpkRguDDatReqInfo(pst, param, mBuf)
Pst *pst;
RguDDatReqInfo *param;
Buffer *mBuf;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmUnpkRguDDatReqInfo
+S16 cmUnpkRguDDatReqInfo
(
RguDDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguDDatReqInfo(param, mBuf)
+S16 cmUnpkRguDDatReqInfo(param, mBuf)
RguDDatReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguCDatIndInfo
+S16 cmPkRguCDatIndInfo
(
RguCDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguCDatIndInfo(param, mBuf)
+S16 cmPkRguCDatIndInfo(param, mBuf)
RguCDatIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguCDatIndInfo
+S16 cmUnpkRguCDatIndInfo
(
RguCDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguCDatIndInfo(param, mBuf)
+S16 cmUnpkRguCDatIndInfo(param, mBuf)
RguCDatIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguLchDatInd
+S16 cmPkRguLchDatInd
(
RguLchDatInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguLchDatInd(param, mBuf)
+S16 cmPkRguLchDatInd(param, mBuf)
RguLchDatInd *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguLchDatInd
+S16 cmUnpkRguLchDatInd
(
RguLchDatInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguLchDatInd(param, mBuf)
+S16 cmUnpkRguLchDatInd(param, mBuf)
RguLchDatInd *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 packRlcMacDataInfo
+S16 packRlcMacDataInfo
(
RlcMacData *param,
Buffer *mBuf
)
#else
-PUBLIC S16 packRlcMacDataInfo(param, mBuf)
+S16 packRlcMacDataInfo(param, mBuf)
RlcMacData *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 unpackRlcMacDataInfo
+S16 unpackRlcMacDataInfo
(
RlcMacData *param,
Buffer *mBuf
)
#else
-PUBLIC S16 unpackRlcMacDataInfo(param, mBuf)
+S16 unpackRlcMacDataInfo(param, mBuf)
RlcMacData *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguCStaRspInfo
+S16 cmPkRguCStaRspInfo
(
RguCStaRspInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguCStaRspInfo(param, mBuf)
+S16 cmPkRguCStaRspInfo(param, mBuf)
RguCStaRspInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguCStaRspInfo
+S16 cmUnpkRguCStaRspInfo
(
RguCStaRspInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguCStaRspInfo(param, mBuf)
+S16 cmUnpkRguCStaRspInfo(param, mBuf)
RguCStaRspInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 packBOStatusInfo
+S16 packBOStatusInfo
(
RlcMacBOStatus *param,
Buffer *mBuf
)
#else
-PUBLIC S16 packBOStatusInfo(param, mBuf)
+S16 packBOStatusInfo(param, mBuf)
RlcMacBOStatus *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 unpackBOStatusInfo
+S16 unpackBOStatusInfo
(
RlcMacBOStatus *param,
Buffer *mBuf
)
#else
-PUBLIC S16 unpackBOStatusInfo(param, mBuf)
+S16 unpackBOStatusInfo(param, mBuf)
RlcMacBOStatus *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguLchStaInd
+S16 cmPkRguLchStaInd
(
RguLchStaInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguLchStaInd(param, mBuf)
+S16 cmPkRguLchStaInd(param, mBuf)
RguLchStaInd *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguLchStaInd
+S16 cmUnpkRguLchStaInd
(
RguLchStaInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguLchStaInd(param, mBuf)
+S16 cmUnpkRguLchStaInd(param, mBuf)
RguLchStaInd *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRguStaIndTb
+S16 cmPkRguStaIndTb
(
RguStaIndTb *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRguStaIndTb(param, mBuf)
+S16 cmPkRguStaIndTb(param, mBuf)
RguStaIndTb *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRguStaIndTb
+S16 cmUnpkRguStaIndTb
(
RguStaIndTb *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRguStaIndTb(param, mBuf)
+S16 cmUnpkRguStaIndTb(param, mBuf)
RguStaIndTb *param;
Buffer *mBuf;
#endif
* File :
*
**********************************************************/
-PUBLIC S16 packSchedRepInfo
+S16 packSchedRepInfo
(
RlcMacSchedRepInfo *param,
Buffer *mBuf
* File :
*
**********************************************************/
-PUBLIC S16 unpackSchedRepInfo
+S16 unpackSchedRepInfo
(
RlcMacSchedRepInfo *param,
Buffer *mBuf
#ifdef KW
/** @brief Request from RLC to MAC to bind the interface saps */
-EXTERN S16 KwLiRguBndReq ARGS((
+EXTERN S16 RlcLiRguBndReq ARGS((
Pst* pst,
SuId suId,
SpId spId
));
/** @brief Request from RLC to MAC to Unbind the interface saps */
-EXTERN S16 KwLiRguUbndReq ARGS((
+EXTERN S16 RlcLiRguUbndReq ARGS((
Pst* pst,
SpId spId,
Reason reason
));
/** @brief Confirmation from MAC to RLC for the bind/Unbind
* request for the interface saps */
-EXTERN S16 KwLiRguBndCfm ARGS((
+EXTERN S16 RlcLiRguBndCfm ARGS((
Pst* pst,
SuId suId,
U8 status
));
/** @brief Request from RLC to MAC for forwarding SDUs on common
* channel for transmission */
-EXTERN S16 KwLiRguCDatReq ARGS((
+EXTERN S16 RlcLiRguCDatReq ARGS((
Pst* pst,
SpId spId,
RguCDatReqInfo * datReq
/** @brief Data Indication from MAC to RLC to
* forward the data received for common channels*/
-EXTERN S16 KwLiRguCDatInd ARGS((
+EXTERN S16 RlcLiRguCDatInd ARGS((
Pst* pst,
SuId suId,
RguCDatIndInfo * datInd
));
/** @brief Data Indication from MAC to RLC to
* forward the data received for dedicated channels*/
-EXTERN S16 KwLiRguDDatInd ARGS((
+EXTERN S16 RlcLiRguDDatInd ARGS((
Pst* pst,
SuId suId,
RguDDatIndInfo * datInd
));
/** @brief Primitive invoked from RLC to MAC to
* inform the BO report for common channels*/
-EXTERN S16 KwLiRguCStaRsp ARGS((
+EXTERN S16 RlcLiRguCStaRsp ARGS((
Pst* pst,
SpId spId,
RguCStaRspInfo * staRsp
* as a response to the staRsp primitive from RLC.
* Informs RLC of the totalBufferSize and Timing Info
* for the transmission on common channels. */
-EXTERN S16 KwLiRguCStaInd ARGS((
+EXTERN S16 RlcLiRguCStaInd ARGS((
Pst* pst,
SuId suId,
RguCStaIndInfo * staInd
* as a response to the staRsp primitive from RLC.
* Informs RLC of the totalBufferSize and Timing Info
* for the transmission on dedicated channels. */
-EXTERN S16 KwLiRguDStaInd ARGS((
+EXTERN S16 RlcLiRguDStaInd ARGS((
Pst* pst,
SuId suId,
RguDStaIndInfo * staInd
/** @brief HARQ Status Indication from MAC to RLC
* as a response to the Data Req from RLC.
* Informs HARQ feedback for the PDU with sn. */
-EXTERN S16 KwLiRguHqStaInd ARGS((
+EXTERN S16 RlcLiRguHqStaInd ARGS((
Pst* pst,
SuId suId,
RguHarqStatusInd *harqStatusInd));
/** @brief Request for measuring the timing Info for a LC from RLC to MAC
* When the status is ON then Timing Info for data bursts
* shall be captured and provided to RLC on DDatInd. */
-EXTERN S16 KwLiRguL2MUlThrpMeasReq ARGS((
+EXTERN S16 RlcLiRguL2MUlThrpMeasReq ARGS((
Pst* pst,
SpId spId,
RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq));
#endif /* LTE_L2_MEAS */
/** @brief flowCntrl Indication from MAC to RLC */
-EXTERN S16 KwLiRguFlowCntrlInd ARGS((
+EXTERN S16 RlcLiRguFlowCntrlInd ARGS((
Pst *pst,
SuId suId,
RguFlowCntrlInd *flowCntrlInd
#define ENTEG 0xd3 /* EGTP Layer */
#define ENTEU 0xd4 /* EGTP USER */
/* ssi_h_001.main_135 : addition of LTE related entities */
-#define ENTTF 0xd5 /* LTE-PHY */
-#define ENTRG 0xd6 /* LTE-MAC */
-#define ENTKW 0xd7 /* LTE-RLC */
+#define ENTLWRMAC 0xd5 /* LTE-PHY */
+#define ENTMAC 0xd6 /* LTE-MAC */
+#define ENTRLC 0xd7 /* LTE-RLC */
#define ENTPJ 0xd8 /* LTE-PDCP */
#define ENTNH 0xd9 /* LTE-RRC */
#ifdef T2K_MEM_LEAK_DBG
#define ssGetDBufOfSize(region,size,dBuf) ssGetDBufOfSizeNew(region,size,dBuf,__FILE__,__LINE__)
-PUBLIC S16 ssGetDBufOfSizeNew ARGS((Region region, Size size, Buffer **dBuf,char*,U32));
+S16 ssGetDBufOfSizeNew ARGS((Region region, Size size, Buffer **dBuf,char*,U32));
#else
EXTERN S16 ssGetDBufOfSize(Region region,Size size,Buffer **dBuf);
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuBndReq
+S16 cmPkTfuBndReq
(
Pst * pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkTfuBndReq(pst, suId, spId)
+S16 cmPkTfuBndReq(pst, suId, spId)
Pst * pst;
SuId suId;
SpId spId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuBndReq
+S16 cmUnpkTfuBndReq
(
TfuBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuBndReq(func, pst, mBuf)
+S16 cmUnpkTfuBndReq(func, pst, mBuf)
TfuBndReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuBndCfm
+S16 cmPkTfuBndCfm
(
Pst * pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkTfuBndCfm(pst, suId, status)
+S16 cmPkTfuBndCfm(pst, suId, status)
Pst * pst;
SuId suId;
U8 status;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuBndCfm
+S16 cmUnpkTfuBndCfm
(
TfuBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuBndCfm(func, pst, mBuf)
+S16 cmUnpkTfuBndCfm(func, pst, mBuf)
TfuBndCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUbndReq
+S16 cmPkTfuUbndReq
(
Pst * pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkTfuUbndReq(pst, spId, reason)
+S16 cmPkTfuUbndReq(pst, spId, reason)
Pst * pst;
SpId spId;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUbndReq
+S16 cmUnpkTfuUbndReq
(
TfuUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUbndReq(func, pst, mBuf)
+S16 cmUnpkTfuUbndReq(func, pst, mBuf)
TfuUbndReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSchBndReq
+S16 cmPkTfuSchBndReq
(
Pst * pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkTfuSchBndReq(pst, suId, spId)
+S16 cmPkTfuSchBndReq(pst, suId, spId)
Pst * pst;
SuId suId;
SpId spId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSchBndReq
+S16 cmUnpkTfuSchBndReq
(
TfuSchBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSchBndReq(func, pst, mBuf)
+S16 cmUnpkTfuSchBndReq(func, pst, mBuf)
TfuSchBndReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSchBndCfm
+S16 cmPkTfuSchBndCfm
(
Pst * pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkTfuSchBndCfm(pst, suId, status)
+S16 cmPkTfuSchBndCfm(pst, suId, status)
Pst * pst;
SuId suId;
U8 status;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSchBndCfm
+S16 cmUnpkTfuSchBndCfm
(
TfuSchBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSchBndCfm(func, pst, mBuf)
+S16 cmUnpkTfuSchBndCfm(func, pst, mBuf)
TfuSchBndCfm func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSchUbndReq
+S16 cmPkTfuSchUbndReq
(
Pst * pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkTfuSchUbndReq(pst, spId, reason)
+S16 cmPkTfuSchUbndReq(pst, spId, reason)
Pst * pst;
SpId spId;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSchUbndReq
+S16 cmUnpkTfuSchUbndReq
(
TfuSchUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSchUbndReq(func, pst, mBuf)
+S16 cmUnpkTfuSchUbndReq(func, pst, mBuf)
TfuSchUbndReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqInd
+S16 cmPkTfuRaReqInd
(
Pst * pst,
SuId suId,
TfuRaReqIndInfo * raReqInd
)
#else
-PUBLIC S16 cmPkTfuRaReqInd(pst, suId, raReqInd)
+S16 cmPkTfuRaReqInd(pst, suId, raReqInd)
Pst * pst;
SuId suId;
TfuRaReqIndInfo * raReqInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRaReqInd
+S16 cmUnpkTfuRaReqInd
(
TfuRaReqInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRaReqInd(func, pst, mBuf)
+S16 cmUnpkTfuRaReqInd(func, pst, mBuf)
TfuRaReqInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRecpReq
+S16 cmPkTfuRecpReq
(
Pst * pst,
SpId spId,
TfuRecpReqInfo * recpReq
)
#else
-PUBLIC S16 cmPkTfuRecpReq(pst, spId, recpReq)
+S16 cmPkTfuRecpReq(pst, spId, recpReq)
Pst * pst;
SpId spId;
TfuRecpReqInfo * recpReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRecpReq
+S16 cmUnpkTfuRecpReq
(
TfuRecpReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRecpReq(func, pst, mBuf)
+S16 cmUnpkTfuRecpReq(func, pst, mBuf)
TfuRecpReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiInd
+S16 cmPkTfuUlCqiInd
(
Pst * pst,
SuId suId,
TfuUlCqiIndInfo * ulCqiInd
)
#else
-PUBLIC S16 cmPkTfuUlCqiInd(pst, suId, ulCqiInd)
+S16 cmPkTfuUlCqiInd(pst, suId, ulCqiInd)
Pst * pst;
SuId suId;
TfuUlCqiIndInfo * ulCqiInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiInd
+S16 cmUnpkTfuUlCqiInd
(
TfuUlCqiInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUlCqiInd(func, pst, mBuf)
+S16 cmUnpkTfuUlCqiInd(func, pst, mBuf)
TfuUlCqiInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuHqInd
+S16 cmPkTfuHqInd
(
Pst * pst,
SpId spId,
TfuHqIndInfo * hqInd
)
#else
-PUBLIC S16 cmPkTfuHqInd(pst, spId, hqInd)
+S16 cmPkTfuHqInd(pst, spId, hqInd)
Pst * pst;
SpId spId;
TfuHqIndInfo * hqInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuHqInd
+S16 cmUnpkTfuHqInd
(
TfuHqInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuHqInd(func, pst, mBuf)
+S16 cmUnpkTfuHqInd(func, pst, mBuf)
TfuHqInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrInd
+S16 cmPkTfuSrInd
(
Pst * pst,
SpId spId,
TfuSrIndInfo * srInd
)
#else
-PUBLIC S16 cmPkTfuSrInd(pst, spId, srInd)
+S16 cmPkTfuSrInd(pst, spId, srInd)
Pst * pst;
SpId spId;
TfuSrIndInfo * srInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrInd
+S16 cmUnpkTfuSrInd
(
TfuSrInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSrInd(func, pst, mBuf)
+S16 cmUnpkTfuSrInd(func, pst, mBuf)
TfuSrInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiInd
+S16 cmPkTfuDlCqiInd
(
Pst * pst,
SuId suId,
TfuDlCqiIndInfo * dlCqiInd
)
#else
-PUBLIC S16 cmPkTfuDlCqiInd(pst, suId, dlCqiInd)
+S16 cmPkTfuDlCqiInd(pst, suId, dlCqiInd)
Pst * pst;
SuId suId;
TfuDlCqiIndInfo * dlCqiInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiInd
+S16 cmUnpkTfuDlCqiInd
(
TfuDlCqiInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiInd(func, pst, mBuf)
+S16 cmUnpkTfuDlCqiInd(func, pst, mBuf)
TfuDlCqiInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiInd
+S16 cmPkTfuRawCqiInd
(
Pst * pst,
SuId suId,
TfuRawCqiIndInfo * rawCqiInd
)
#else
-PUBLIC S16 cmPkTfuRawCqiInd(pst, suId, rawCqiInd)
+S16 cmPkTfuRawCqiInd(pst, suId, rawCqiInd)
Pst * pst;
SuId suId;
TfuRawCqiIndInfo * rawCqiInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRawCqiInd
+S16 cmUnpkTfuRawCqiInd
(
TfuRawCqiInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRawCqiInd(func, pst, mBuf)
+S16 cmUnpkTfuRawCqiInd(func, pst, mBuf)
TfuRawCqiInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrsInd
+S16 cmPkTfuSrsInd
(
Pst * pst,
SuId suId,
TfuSrsIndInfo * srsInd
)
#else
-PUBLIC S16 cmPkTfuSrsInd(pst, suId, srsInd)
+S16 cmPkTfuSrsInd(pst, suId, srsInd)
Pst * pst;
SuId suId;
TfuSrsIndInfo * srsInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrsInd
+S16 cmUnpkTfuSrsInd
(
TfuSrsInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSrsInd(func, pst, mBuf)
+S16 cmUnpkTfuSrsInd(func, pst, mBuf)
TfuSrsInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatInd
+S16 cmPkTfuDatInd
(
Pst * pst,
SpId spId,
TfuDatIndInfo * datInd
)
#else
-PUBLIC S16 cmPkTfuDatInd(pst, spId, datInd)
+S16 cmPkTfuDatInd(pst, spId, datInd)
Pst * pst;
SpId spId;
TfuDatIndInfo * datInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatInd
+S16 cmUnpkTfuDatInd
(
TfuDatInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDatInd(func, pst, mBuf)
+S16 cmUnpkTfuDatInd(func, pst, mBuf)
TfuDatInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCrcInd
+S16 cmPkTfuCrcInd
(
Pst * pst,
SuId suId,
TfuCrcIndInfo * crcIndInfo
)
#else
-PUBLIC S16 cmPkTfuCrcInd(pst, suId, crcIndInfo)
+S16 cmPkTfuCrcInd(pst, suId, crcIndInfo)
Pst * pst;
SuId suId;
TfuCrcIndInfo * crcIndInfo;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCrcInd
+S16 cmUnpkTfuCrcInd
(
TfuCrcInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCrcInd(func, pst, mBuf)
+S16 cmUnpkTfuCrcInd(func, pst, mBuf)
TfuCrcInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvInd
+S16 cmPkTfuTimingAdvInd
(
Pst * pst,
SuId suId,
TfuTimingAdvIndInfo * timingAdvInd
)
#else
-PUBLIC S16 cmPkTfuTimingAdvInd(pst, suId, timingAdvInd)
+S16 cmPkTfuTimingAdvInd(pst, suId, timingAdvInd)
Pst * pst;
SuId suId;
TfuTimingAdvIndInfo * timingAdvInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuTimingAdvInd
+S16 cmUnpkTfuTimingAdvInd
(
TfuTimingAdvInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuTimingAdvInd(func, pst, mBuf)
+S16 cmUnpkTfuTimingAdvInd(func, pst, mBuf)
TfuTimingAdvInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatReq
+S16 cmPkTfuDatReq
(
Pst * pst,
SpId spId,
TfuDatReqInfo * datReq
)
#else
-PUBLIC S16 cmPkTfuDatReq(pst, spId, datReq)
+S16 cmPkTfuDatReq(pst, spId, datReq)
Pst * pst;
SpId spId;
TfuDatReqInfo * datReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatReq
+S16 cmUnpkTfuDatReq
(
TfuDatReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDatReq(func, pst, mBuf)
+S16 cmUnpkTfuDatReq(func, pst, mBuf)
TfuDatReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCntrlReq
+S16 cmPkTfuCntrlReq
(
Pst * pst,
SpId spId,
TfuCntrlReqInfo * cntrlReq
)
#else
-PUBLIC S16 cmPkTfuCntrlReq(pst, spId, cntrlReq)
+S16 cmPkTfuCntrlReq(pst, spId, cntrlReq)
Pst * pst;
SpId spId;
TfuCntrlReqInfo * cntrlReq;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCntrlReq
+S16 cmUnpkTfuCntrlReq
(
TfuCntrlReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCntrlReq(func, pst, mBuf)
+S16 cmUnpkTfuCntrlReq(func, pst, mBuf)
TfuCntrlReq func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTtiInd
+S16 cmPkTfuTtiInd
(
Pst * pst,
SuId suId,
TfuTtiIndInfo * ttiInd
)
#else
-PUBLIC S16 cmPkTfuTtiInd(pst, suId, ttiInd)
+S16 cmPkTfuTtiInd(pst, suId, ttiInd)
Pst * pst;
SuId suId;
TfuTtiIndInfo * ttiInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuNonRtInd
+S16 cmPkTfuNonRtInd
(
Pst * pst,
SuId suId
)
#else
-PUBLIC S16 cmPkTfuNonRtInd(pst, suId)
+S16 cmPkTfuNonRtInd(pst, suId)
Pst * pst;
SuId suId;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuNonRtInd
+S16 cmUnpkTfuNonRtInd
(
TfuNonRtInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuNonRtInd(func, pst, mBuf)
+S16 cmUnpkTfuNonRtInd(func, pst, mBuf)
TfuNonRtInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPucchDeltaPwr
+S16 cmPkTfuPucchDeltaPwr
(
Pst * pst,
SuId suId,
TfuPucchDeltaPwrIndInfo * pucchDeltaPwr
)
#else
-PUBLIC S16 cmPkTfuPucchDeltaPwr(pst, suId, pucchDeltaPwr)
+S16 cmPkTfuPucchDeltaPwr(pst, suId, pucchDeltaPwr)
Pst * pst;
SuId suId;
TfuPucchDeltaPwrIndInfo * pucchDeltaPwr;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPucchDeltaPwr
+S16 cmUnpkTfuPucchDeltaPwr
(
TfuPucchDeltaPwrInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPucchDeltaPwr(func, pst, mBuf)
+S16 cmUnpkTfuPucchDeltaPwr(func, pst, mBuf)
TfuPucchDeltaPwrInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignA1Val324
+S16 cmPkTfuRbAssignA1Val324
(
TfuRbAssignA1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRbAssignA1Val324(param, mBuf)
+S16 cmPkTfuRbAssignA1Val324(param, mBuf)
TfuRbAssignA1Val324 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignB1Val324
+S16 cmPkTfuRbAssignB1Val324
(
TfuRbAssignB1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRbAssignB1Val324(param, mBuf)
+S16 cmPkTfuRbAssignB1Val324(param, mBuf)
TfuRbAssignB1Val324 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignVal326
+S16 cmPkTfuRbAssignVal326
(
TfuRbAssignVal326 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRbAssignVal326(param, mBuf)
+S16 cmPkTfuRbAssignVal326(param, mBuf)
TfuRbAssignVal326 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignA1Val324
+S16 cmUnpkTfuRbAssignA1Val324
(
TfuRbAssignA1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRbAssignA1Val324(param, mBuf)
+S16 cmUnpkTfuRbAssignA1Val324(param, mBuf)
TfuRbAssignA1Val324 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignB1Val324
+S16 cmUnpkTfuRbAssignB1Val324
(
TfuRbAssignB1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRbAssignB1Val324(param, mBuf)
+S16 cmUnpkTfuRbAssignB1Val324(param, mBuf)
TfuRbAssignB1Val324 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignVal326
+S16 cmUnpkTfuRbAssignVal326
(
TfuRbAssignVal326 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRbAssignVal326(param, mBuf)
+S16 cmUnpkTfuRbAssignVal326(param, mBuf)
TfuRbAssignVal326 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatA1A2Info
+S16 cmPkTfuDciFormatA1A2Info
(
TfuDciFormatA1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormatA1A2Info(param, mBuf)
+S16 cmPkTfuDciFormatA1A2Info(param, mBuf)
TfuDciFormatA1Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatB1B2Info
+S16 cmPkTfuDciFormatB1B2Info
(
TfuDciFormatB1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormatB1B2Info(param, mBuf)
+S16 cmPkTfuDciFormatB1B2Info(param, mBuf)
TfuDciFormatB1Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatA1A2Info
+S16 cmUnpkTfuDciFormatA1A2Info
(
TfuDciFormatA1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormatA1A2Info(param, mBuf)
+S16 cmUnpkTfuDciFormatA1A2Info(param, mBuf)
TfuDciFormatA1Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatB1B2Info
+S16 cmUnpkTfuDciFormatB1B2Info
(
TfuDciFormatB1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormatB1B2Info(param, mBuf)
+S16 cmUnpkTfuDciFormatB1B2Info(param, mBuf)
TfuDciFormatB1Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat0Info
+S16 cmPkTfuDciFormat0Info
(
TfuDciFormat0Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat0Info(param, mBuf)
+S16 cmPkTfuDciFormat0Info(param, mBuf)
TfuDciFormat0Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat0Info
+S16 cmUnpkTfuDciFormat0Info
(
TfuDciFormat0Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat0Info(param, mBuf)
+S16 cmUnpkTfuDciFormat0Info(param, mBuf)
TfuDciFormat0Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuAllocMapOrRiv
+S16 cmPkTfuAllocMapOrRiv
(
TfuAllocMapOrRiv *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuAllocMapOrRiv(param, mBuf)
+S16 cmPkTfuAllocMapOrRiv(param, mBuf)
TfuAllocMapOrRiv *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuAllocMapOrRiv
+S16 cmUnpkTfuAllocMapOrRiv
(
TfuAllocMapOrRiv *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuAllocMapOrRiv(param, mBuf)
+S16 cmUnpkTfuAllocMapOrRiv(param, mBuf)
TfuAllocMapOrRiv *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1AllocInfo
+S16 cmPkTfuDciFormat1AllocInfo
(
TfuDciFormat1AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1AllocInfo(param, mBuf)
TfuDciFormat1AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1AllocInfo
+S16 cmUnpkTfuDciFormat1AllocInfo
(
TfuDciFormat1AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1AllocInfo(param, mBuf)
TfuDciFormat1AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1Info
+S16 cmPkTfuDciFormat1Info
(
TfuDciFormat1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1Info(param, mBuf)
+S16 cmPkTfuDciFormat1Info(param, mBuf)
TfuDciFormat1Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1Info
+S16 cmUnpkTfuDciFormat1Info
(
TfuDciFormat1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1Info(param, mBuf)
+S16 cmUnpkTfuDciFormat1Info(param, mBuf)
TfuDciFormat1Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AAllocInfo
+S16 cmPkTfuDciFormat2AAllocInfo
(
TfuDciFormat2AAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat2AAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AAllocInfo(param, mBuf)
TfuDciFormat2AAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2AAllocInfo
+S16 cmUnpkTfuDciFormat2AAllocInfo
(
TfuDciFormat2AAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat2AAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat2AAllocInfo(param, mBuf)
TfuDciFormat2AAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat6AAllocInfo
+S16 cmPkTfuDciFormat6AAllocInfo
(
TfuDciFormat61AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat6AAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat6AAllocInfo(param, mBuf)
TfuDciFormat61AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat6AAllocInfo
+S16 cmUnpkTfuDciFormat6AAllocInfo
(
TfuDciFormat61AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat6AAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat6AAllocInfo(param, mBuf)
TfuDciFormat61AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AInfo
+S16 cmPkTfuDciFormat2AInfo
(
TfuDciFormat2AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat2AInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AInfo(param, mBuf)
TfuDciFormat2AInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2AInfo
+S16 cmUnpkTfuDciFormat2AInfo
(
TfuDciFormat2AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat2AInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat2AInfo(param, mBuf)
TfuDciFormat2AInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AllocInfo
+S16 cmPkTfuDciFormat2AllocInfo
(
TfuDciFormat2AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat2AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AllocInfo(param, mBuf)
TfuDciFormat2AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2AllocInfo
+S16 cmUnpkTfuDciFormat2AllocInfo
(
TfuDciFormat2AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat2AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat2AllocInfo(param, mBuf)
TfuDciFormat2AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2Info
+S16 cmPkTfuDciFormat2Info
(
TfuDciFormat2Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat2Info(param, mBuf)
+S16 cmPkTfuDciFormat2Info(param, mBuf)
TfuDciFormat2Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2Info
+S16 cmUnpkTfuDciFormat2Info
(
TfuDciFormat2Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat2Info(param, mBuf)
+S16 cmUnpkTfuDciFormat2Info(param, mBuf)
TfuDciFormat2Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat3Info
+S16 cmPkTfuDciFormat3Info
(
TfuDciFormat3Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat3Info(param, mBuf)
+S16 cmPkTfuDciFormat3Info(param, mBuf)
TfuDciFormat3Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat3Info
+S16 cmUnpkTfuDciFormat3Info
(
TfuDciFormat3Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat3Info(param, mBuf)
+S16 cmUnpkTfuDciFormat3Info(param, mBuf)
TfuDciFormat3Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat3AInfo
+S16 cmPkTfuDciFormat3AInfo
(
TfuDciFormat3AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat3AInfo(param, mBuf)
+S16 cmPkTfuDciFormat3AInfo(param, mBuf)
TfuDciFormat3AInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat3AInfo
+S16 cmUnpkTfuDciFormat3AInfo
(
TfuDciFormat3AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat3AInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat3AInfo(param, mBuf)
TfuDciFormat3AInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat61aInfo
+S16 cmPkTfuDciFormat61aInfo
(
TfuDciFormat61aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat61aInfo(param, mBuf)
+S16 cmPkTfuDciFormat61aInfo(param, mBuf)
TfuDciFormat61aInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat61aInfo
+S16 cmUnpkTfuDciFormat61aInfo
(
TfuDciFormat61aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat61aInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat61aInfo(param, mBuf)
TfuDciFormat61aInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1dAllocInfo
+S16 cmPkTfuDciFormat1dAllocInfo
(
TfuDciFormat1dAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1dAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1dAllocInfo(param, mBuf)
TfuDciFormat1dAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1dAllocInfo
+S16 cmUnpkTfuDciFormat1dAllocInfo
(
TfuDciFormat1dAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1dAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1dAllocInfo(param, mBuf)
TfuDciFormat1dAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1dInfo
+S16 cmPkTfuDciFormat1dInfo
(
TfuDciFormat1dInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1dInfo(param, mBuf)
+S16 cmPkTfuDciFormat1dInfo(param, mBuf)
TfuDciFormat1dInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1dInfo
+S16 cmUnpkTfuDciFormat1dInfo
(
TfuDciFormat1dInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1dInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1dInfo(param, mBuf)
TfuDciFormat1dInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1cInfo
+S16 cmPkTfuDciFormat1cInfo
(
TfuDciFormat1cInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1cInfo(param, mBuf)
+S16 cmPkTfuDciFormat1cInfo(param, mBuf)
TfuDciFormat1cInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1cInfo
+S16 cmUnpkTfuDciFormat1cInfo
(
TfuDciFormat1cInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1cInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1cInfo(param, mBuf)
TfuDciFormat1cInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1bAllocInfo
+S16 cmPkTfuDciFormat1bAllocInfo
(
TfuDciFormat1bAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1bAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1bAllocInfo(param, mBuf)
TfuDciFormat1bAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1bAllocInfo
+S16 cmUnpkTfuDciFormat1bAllocInfo
(
TfuDciFormat1bAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1bAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1bAllocInfo(param, mBuf)
TfuDciFormat1bAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchOrderInfo
+S16 cmPkTfuPdcchOrderInfo
(
TfuPdcchOrderInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPdcchOrderInfo(param, mBuf)
+S16 cmPkTfuPdcchOrderInfo(param, mBuf)
TfuPdcchOrderInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchOrderInfo
+S16 cmUnpkTfuPdcchOrderInfo
(
TfuPdcchOrderInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPdcchOrderInfo(param, mBuf)
+S16 cmUnpkTfuPdcchOrderInfo(param, mBuf)
TfuPdcchOrderInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1aAllocInfo
+S16 cmPkTfuDciFormat1aAllocInfo
(
TfuDciFormat1aAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1aAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1aAllocInfo(param, mBuf)
TfuDciFormat1aAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1aAllocInfo
+S16 cmUnpkTfuDciFormat1aAllocInfo
(
TfuDciFormat1aAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1aAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1aAllocInfo(param, mBuf)
TfuDciFormat1aAllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfudciformat1aPdsch
+S16 cmPkTfudciformat1aPdsch
(
Tfudciformat1aPdsch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfudciformat1aPdsch(param, mBuf)
+S16 cmPkTfudciformat1aPdsch(param, mBuf)
Tfudciformat1aPdsch *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfudciformat1aPdsch
+S16 cmUnpkTfudciformat1aPdsch
(
Tfudciformat1aPdsch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfudciformat1aPdsch(param, mBuf)
+S16 cmUnpkTfudciformat1aPdsch(param, mBuf)
Tfudciformat1aPdsch *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfudciformat61aPdsch
+S16 cmUnpkTfudciformat61aPdsch
(
Tfudciformat61aPdsch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfudciformat61aPdsch(param, mBuf)
+S16 cmUnpkTfudciformat61aPdsch(param, mBuf)
Tfudciformat61aPdsch *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat62AllocInfo
+S16 cmUnpkTfuDciFormat62AllocInfo
(
TfuDciFormat62AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat62AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat62AllocInfo(param, mBuf)
TfuDciFormat62AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat62Info
+S16 cmUnpkTfuDciFormat62Info
(
TfuDciFormat62Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat62Info(param, mBuf)
+S16 cmUnpkTfuDciFormat62Info(param, mBuf)
TfuDciFormat62Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat62AllocInfo
+S16 cmPkTfuDciFormat62AllocInfo
(
TfuDciFormat62AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat62AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat62AllocInfo(param, mBuf)
TfuDciFormat62AllocInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat62Info
+S16 cmPkTfuDciFormat62Info
(
TfuDciFormat62Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat62Info(param, mBuf)
+S16 cmPkTfuDciFormat62Info(param, mBuf)
TfuDciFormat62Info *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1aInfo
+S16 cmPkTfuDciFormat1aInfo
(
TfuDciFormat1aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1aInfo(param, mBuf)
+S16 cmPkTfuDciFormat1aInfo(param, mBuf)
TfuDciFormat1aInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1aInfo
+S16 cmUnpkTfuDciFormat1aInfo
(
TfuDciFormat1aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1aInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1aInfo(param, mBuf)
TfuDciFormat1aInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1bInfo
+S16 cmPkTfuDciFormat1bInfo
(
TfuDciFormat1bInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1bInfo(param, mBuf)
+S16 cmPkTfuDciFormat1bInfo(param, mBuf)
TfuDciFormat1bInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1bInfo
+S16 cmUnpkTfuDciFormat1bInfo
(
TfuDciFormat1bInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1bInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1bInfo(param, mBuf)
TfuDciFormat1bInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciInfo
+S16 cmPkTfuDciInfo
(
TfuDciInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciInfo(param, mBuf)
+S16 cmPkTfuDciInfo(param, mBuf)
TfuDciInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciInfo
+S16 cmUnpkTfuDciInfo
(
TfuDciInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciInfo(param, mBuf)
+S16 cmUnpkTfuDciInfo(param, mBuf)
TfuDciInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandInfo
+S16 cmPkTfuSubbandInfo
(
TfuSubbandInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandInfo(param, mBuf)
+S16 cmPkTfuSubbandInfo(param, mBuf)
TfuSubbandInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandInfo
+S16 cmUnpkTfuSubbandInfo
(
TfuSubbandInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandInfo(param, mBuf)
+S16 cmUnpkTfuSubbandInfo(param, mBuf)
TfuSubbandInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandCqiInfo
+S16 cmPkTfuSubbandCqiInfo
(
TfuSubbandCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandCqiInfo(param, mBuf)
+S16 cmPkTfuSubbandCqiInfo(param, mBuf)
TfuSubbandCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandCqiInfo
+S16 cmUnpkTfuSubbandCqiInfo
(
TfuSubbandCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandCqiInfo(param, mBuf)
+S16 cmUnpkTfuSubbandCqiInfo(param, mBuf)
TfuSubbandCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchCceInfo
+S16 cmPkTfuPdcchCceInfo
(
TfuPdcchCceInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPdcchCceInfo(param, mBuf)
+S16 cmPkTfuPdcchCceInfo(param, mBuf)
TfuPdcchCceInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchCceInfo
+S16 cmUnpkTfuPdcchCceInfo
(
TfuPdcchCceInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPdcchCceInfo(param, mBuf)
+S16 cmUnpkTfuPdcchCceInfo(param, mBuf)
TfuPdcchCceInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode10
+S16 cmPkTfuCqiPucchMode10
(
TfuCqiPucchMode10 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPucchMode10(param, mBuf)
+S16 cmPkTfuCqiPucchMode10(param, mBuf)
TfuCqiPucchMode10 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode10
+S16 cmUnpkTfuCqiPucchMode10
(
TfuCqiPucchMode10 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode10(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode10(param, mBuf)
TfuCqiPucchMode10 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode11Cqi
+S16 cmPkTfuCqiMode11Cqi
(
TfuCqiMode11Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode11Cqi(param, mBuf)
+S16 cmPkTfuCqiMode11Cqi(param, mBuf)
TfuCqiMode11Cqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode11Cqi
+S16 cmUnpkTfuCqiMode11Cqi
(
TfuCqiMode11Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode11Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode11Cqi(param, mBuf)
TfuCqiMode11Cqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode11
+S16 cmPkTfuCqiPucchMode11
(
TfuCqiPucchMode11 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPucchMode11(param, mBuf)
+S16 cmPkTfuCqiPucchMode11(param, mBuf)
TfuCqiPucchMode11 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode11
+S16 cmUnpkTfuCqiPucchMode11
(
TfuCqiPucchMode11 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode11(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode11(param, mBuf)
TfuCqiPucchMode11 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode20SubCqi
+S16 cmPkTfuCqiMode20SubCqi
(
TfuCqiMode20SubCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode20SubCqi(param, mBuf)
+S16 cmPkTfuCqiMode20SubCqi(param, mBuf)
TfuCqiMode20SubCqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode20SubCqi
+S16 cmUnpkTfuCqiMode20SubCqi
(
TfuCqiMode20SubCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode20SubCqi(param, mBuf)
+S16 cmUnpkTfuCqiMode20SubCqi(param, mBuf)
TfuCqiMode20SubCqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode20Cqi
+S16 cmPkTfuCqiMode20Cqi
(
TfuCqiMode20Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode20Cqi(param, mBuf)
+S16 cmPkTfuCqiMode20Cqi(param, mBuf)
TfuCqiMode20Cqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode20Cqi
+S16 cmUnpkTfuCqiMode20Cqi
(
TfuCqiMode20Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode20Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode20Cqi(param, mBuf)
TfuCqiMode20Cqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode20
+S16 cmPkTfuCqiPucchMode20
(
TfuCqiPucchMode20 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPucchMode20(param, mBuf)
+S16 cmPkTfuCqiPucchMode20(param, mBuf)
TfuCqiPucchMode20 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode20
+S16 cmUnpkTfuCqiPucchMode20
(
TfuCqiPucchMode20 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode20(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode20(param, mBuf)
TfuCqiPucchMode20 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode21SubCqi
+S16 cmPkTfuCqiMode21SubCqi
(
TfuCqiMode21SubCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode21SubCqi(param, mBuf)
+S16 cmPkTfuCqiMode21SubCqi(param, mBuf)
TfuCqiMode21SubCqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode21SubCqi
+S16 cmUnpkTfuCqiMode21SubCqi
(
TfuCqiMode21SubCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode21SubCqi(param, mBuf)
+S16 cmUnpkTfuCqiMode21SubCqi(param, mBuf)
TfuCqiMode21SubCqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode21WideCqi
+S16 cmPkTfuCqiMode21WideCqi
(
TfuCqiMode21WideCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode21WideCqi(param, mBuf)
+S16 cmPkTfuCqiMode21WideCqi(param, mBuf)
TfuCqiMode21WideCqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode21WideCqi
+S16 cmUnpkTfuCqiMode21WideCqi
(
TfuCqiMode21WideCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode21WideCqi(param, mBuf)
+S16 cmUnpkTfuCqiMode21WideCqi(param, mBuf)
TfuCqiMode21WideCqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode21Cqi
+S16 cmPkTfuCqiMode21Cqi
(
TfuCqiMode21Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode21Cqi(param, mBuf)
+S16 cmPkTfuCqiMode21Cqi(param, mBuf)
TfuCqiMode21Cqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode21Cqi
+S16 cmUnpkTfuCqiMode21Cqi
(
TfuCqiMode21Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode21Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode21Cqi(param, mBuf)
TfuCqiMode21Cqi *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode21
+S16 cmPkTfuCqiPucchMode21
(
TfuCqiPucchMode21 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPucchMode21(param, mBuf)
+S16 cmPkTfuCqiPucchMode21(param, mBuf)
TfuCqiPucchMode21 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode21
+S16 cmUnpkTfuCqiPucchMode21
(
TfuCqiPucchMode21 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode21(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode21(param, mBuf)
TfuCqiPucchMode21 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiPucch
+S16 cmPkTfuDlCqiPucch
(
TfuDlCqiPucch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiPucch(param, mBuf)
+S16 cmPkTfuDlCqiPucch(param, mBuf)
TfuDlCqiPucch *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPucch
+S16 cmUnpkTfuDlCqiPucch
(
TfuDlCqiPucch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiPucch(param, mBuf)
+S16 cmUnpkTfuDlCqiPucch(param, mBuf)
TfuDlCqiPucch *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode12
+S16 cmPkTfuSubbandMode12
(
TfuSubbandMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandMode12(param, mBuf)
+S16 cmPkTfuSubbandMode12(param, mBuf)
TfuSubbandMode12 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode12
+S16 cmUnpkTfuSubbandMode12
(
TfuSubbandMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandMode12(param, mBuf)
+S16 cmUnpkTfuSubbandMode12(param, mBuf)
TfuSubbandMode12 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode12
+S16 cmPkTfuCqiPuschMode12
(
TfuCqiPuschMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode12(param, mBuf)
+S16 cmPkTfuCqiPuschMode12(param, mBuf)
TfuCqiPuschMode12 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode12
+S16 cmUnpkTfuCqiPuschMode12
(
TfuCqiPuschMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode12(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode12(param, mBuf)
TfuCqiPuschMode12 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode20
+S16 cmPkTfuCqiPuschMode20
(
TfuCqiPuschMode20 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode20(param, mBuf)
+S16 cmPkTfuCqiPuschMode20(param, mBuf)
TfuCqiPuschMode20 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode20
+S16 cmUnpkTfuCqiPuschMode20
(
TfuCqiPuschMode20 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode20(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode20(param, mBuf)
TfuCqiPuschMode20 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode22
+S16 cmPkTfuCqiPuschMode22
(
TfuCqiPuschMode22 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode22(param, mBuf)
+S16 cmPkTfuCqiPuschMode22(param, mBuf)
TfuCqiPuschMode22 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode22
+S16 cmUnpkTfuCqiPuschMode22
(
TfuCqiPuschMode22 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode22(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode22(param, mBuf)
TfuCqiPuschMode22 *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode30
+S16 cmPkTfuSubbandMode30
(
TfuSubbandMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandMode30(param, mBuf)
+S16 cmPkTfuSubbandMode30(param, mBuf)
TfuSubbandMode30 *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode30
+S16 cmUnpkTfuSubbandMode30
(
TfuSubbandMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandMode30(param, mBuf)
+S16 cmUnpkTfuSubbandMode30(param, mBuf)
TfuSubbandMode30 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode30
+S16 cmPkTfuCqiPuschMode30
(
TfuCqiPuschMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode30(param, mBuf)
+S16 cmPkTfuCqiPuschMode30(param, mBuf)
TfuCqiPuschMode30 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode30
+S16 cmUnpkTfuCqiPuschMode30
(
TfuCqiPuschMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode30(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode30(param, mBuf)
TfuCqiPuschMode30 *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode31
+S16 cmPkTfuSubbandMode31
(
TfuSubbandMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandMode31(param, mBuf)
+S16 cmPkTfuSubbandMode31(param, mBuf)
TfuSubbandMode31 *param;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode31
+S16 cmUnpkTfuSubbandMode31
(
TfuSubbandMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandMode31(param, mBuf)
+S16 cmUnpkTfuSubbandMode31(param, mBuf)
TfuSubbandMode31 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode31
+S16 cmPkTfuCqiPuschMode31
(
TfuCqiPuschMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode31(param, mBuf)
+S16 cmPkTfuCqiPuschMode31(param, mBuf)
TfuCqiPuschMode31 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode31
+S16 cmUnpkTfuCqiPuschMode31
(
TfuCqiPuschMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode31(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode31(param, mBuf)
TfuCqiPuschMode31 *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiPusch
+S16 cmPkTfuDlCqiPusch
(
TfuDlCqiPusch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiPusch(param, mBuf)
+S16 cmPkTfuDlCqiPusch(param, mBuf)
TfuDlCqiPusch *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPusch
+S16 cmUnpkTfuDlCqiPusch
(
TfuDlCqiPusch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiPusch(param, mBuf)
+S16 cmUnpkTfuDlCqiPusch(param, mBuf)
TfuDlCqiPusch *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiInfo
+S16 cmPkTfuDlCqiInfo
(
U8 selector,
TfuDlCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiInfo(selector, param, mBuf)
+S16 cmPkTfuDlCqiInfo(selector, param, mBuf)
U8 selector;
TfuDlCqiInfo *param;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiInfo
+S16 cmUnpkTfuDlCqiInfo
(
U8 selector,
TfuDlCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiInfo(selector, param, mBuf)
+S16 cmUnpkTfuDlCqiInfo(selector, param, mBuf)
U8 selector;
TfuDlCqiInfo *param;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRecpReqInfo
+S16 cmPkTfuRecpReqInfo
(
TfuRecpReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRecpReqInfo(param, mBuf)
+S16 cmPkTfuRecpReqInfo(param, mBuf)
TfuRecpReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRecpReqInfo
+S16 cmUnpkTfuRecpReqInfo
(
TfuRecpReqInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRecpReqInfo(param, memCp, mBuf)
+S16 cmUnpkTfuRecpReqInfo(param, memCp, mBuf)
TfuRecpReqInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchInfo
+S16 cmPkTfuPdcchInfo
(
TfuPdcchInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPdcchInfo(param, mBuf)
+S16 cmPkTfuPdcchInfo(param, mBuf)
TfuPdcchInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchInfo
+S16 cmUnpkTfuPdcchInfo
(
TfuPdcchInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPdcchInfo(param, mBuf)
+S16 cmUnpkTfuPdcchInfo(param, mBuf)
TfuPdcchInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPhichInfo
+S16 cmPkTfuPhichInfo
(
TfuPhichInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPhichInfo(param, mBuf)
+S16 cmPkTfuPhichInfo(param, mBuf)
TfuPhichInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPhichInfo
+S16 cmUnpkTfuPhichInfo
(
TfuPhichInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPhichInfo(param, mBuf)
+S16 cmUnpkTfuPhichInfo(param, mBuf)
TfuPhichInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCntrlReqInfo
+S16 cmPkTfuCntrlReqInfo
(
TfuCntrlReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCntrlReqInfo(param, mBuf)
+S16 cmPkTfuCntrlReqInfo(param, mBuf)
TfuCntrlReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCntrlReqInfo
+S16 cmUnpkTfuCntrlReqInfo
(
TfuCntrlReqInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCntrlReqInfo(param, memCp, mBuf)
+S16 cmUnpkTfuCntrlReqInfo(param, memCp, mBuf)
TfuCntrlReqInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPdschDciInfo
+S16 cmPkTfuPdschDciInfo
(
TfuPdschDciInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPdschDciInfo(param, mBuf)
+S16 cmPkTfuPdschDciInfo(param, mBuf)
TfuPdschDciInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdschDciInfo
+S16 cmUnpkTfuPdschDciInfo
(
TfuPdschDciInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPdschDciInfo(param, mBuf)
+S16 cmUnpkTfuPdschDciInfo(param, mBuf)
TfuPdschDciInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuBfVectorInfo
+S16 cmPkTfuBfVectorInfo
(
TfuBfVectorInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuBfVectorInfo(param, mBuf)
+S16 cmPkTfuBfVectorInfo(param, mBuf)
TfuBfVectorInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuBfVectorInfo
+S16 cmUnpkTfuBfVectorInfo
(
TfuBfVectorInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuBfVectorInfo(param, mBuf)
+S16 cmUnpkTfuBfVectorInfo(param, mBuf)
TfuBfVectorInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatReqPduInfo
+S16 cmPkTfuDatReqPduInfo
(
TfuDatReqPduInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDatReqPduInfo(param, mBuf)
+S16 cmPkTfuDatReqPduInfo(param, mBuf)
TfuDatReqPduInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatReqPduInfo
+S16 cmUnpkTfuDatReqPduInfo
(
TfuDatReqPduInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDatReqPduInfo(param, mBuf)
+S16 cmUnpkTfuDatReqPduInfo(param, mBuf)
TfuDatReqPduInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatReqInfo
+S16 cmPkTfuDatReqInfo
(
TfuDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDatReqInfo(param, mBuf)
+S16 cmPkTfuDatReqInfo(param, mBuf)
TfuDatReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatReqInfo
+S16 cmUnpkTfuDatReqInfo
(
TfuDatReqInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDatReqInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDatReqInfo(param, memCp, mBuf)
TfuDatReqInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatInfo
+S16 cmPkTfuDatInfo
(
TfuDatInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDatInfo(param, mBuf)
+S16 cmPkTfuDatInfo(param, mBuf)
TfuDatInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatInfo
+S16 cmUnpkTfuDatInfo
(
TfuDatInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDatInfo(param, mBuf)
+S16 cmUnpkTfuDatInfo(param, mBuf)
TfuDatInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatIndInfo
+S16 cmPkTfuDatIndInfo
(
TfuDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDatIndInfo(param, mBuf)
+S16 cmPkTfuDatIndInfo(param, mBuf)
TfuDatIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatIndInfo
+S16 cmUnpkTfuDatIndInfo
(
TfuDatIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDatIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDatIndInfo(param, memCp, mBuf)
TfuDatIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrInfo
+S16 cmPkTfuSrInfo
(
TfuSrInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSrInfo(param, mBuf)
+S16 cmPkTfuSrInfo(param, mBuf)
TfuSrInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrInfo
+S16 cmUnpkTfuSrInfo
(
TfuSrInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSrInfo(param, mBuf)
+S16 cmUnpkTfuSrInfo(param, mBuf)
TfuSrInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrIndInfo
+S16 cmPkTfuSrIndInfo
(
TfuSrIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSrIndInfo(param, mBuf)
+S16 cmPkTfuSrIndInfo(param, mBuf)
TfuSrIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrIndInfo
+S16 cmUnpkTfuSrIndInfo
(
TfuSrIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSrIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuSrIndInfo(param, memCp, mBuf)
TfuSrIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuHqInfo
+S16 cmPkTfuHqInfo
(
TfuHqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuHqInfo(param, mBuf)
+S16 cmPkTfuHqInfo(param, mBuf)
TfuHqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuHqInfo
+S16 cmUnpkTfuHqInfo
(
TfuHqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuHqInfo(param, mBuf)
+S16 cmUnpkTfuHqInfo(param, mBuf)
TfuHqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuHqIndInfo
+S16 cmPkTfuHqIndInfo
(
TfuHqIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuHqIndInfo(param, mBuf)
+S16 cmPkTfuHqIndInfo(param, mBuf)
TfuHqIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuHqIndInfo
+S16 cmUnpkTfuHqIndInfo
(
TfuHqIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuHqIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuHqIndInfo(param, memCp, mBuf)
TfuHqIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiInfo
+S16 cmPkTfuUlCqiInfo
(
TfuUlCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUlCqiInfo(param, mBuf)
+S16 cmPkTfuUlCqiInfo(param, mBuf)
TfuUlCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiInfo
+S16 cmUnpkTfuUlCqiInfo
(
TfuUlCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUlCqiInfo(param, mBuf)
+S16 cmUnpkTfuUlCqiInfo(param, mBuf)
TfuUlCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiRpt
+S16 cmPkTfuUlCqiRpt
(
TfuUlCqiRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUlCqiRpt(param, mBuf)
+S16 cmPkTfuUlCqiRpt(param, mBuf)
TfuUlCqiRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiRpt
+S16 cmUnpkTfuUlCqiRpt
(
TfuUlCqiRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUlCqiRpt(param, mBuf)
+S16 cmUnpkTfuUlCqiRpt(param, mBuf)
TfuUlCqiRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiIndInfo
+S16 cmPkTfuUlCqiIndInfo
(
TfuUlCqiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUlCqiIndInfo(param, mBuf)
+S16 cmPkTfuUlCqiIndInfo(param, mBuf)
TfuUlCqiIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiIndInfo
+S16 cmUnpkTfuUlCqiIndInfo
(
TfuUlCqiIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUlCqiIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuUlCqiIndInfo(param, memCp, mBuf)
TfuUlCqiIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiRpt
+S16 cmPkTfuDlCqiRpt
(
TfuDlCqiRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiRpt(param, mBuf)
+S16 cmPkTfuDlCqiRpt(param, mBuf)
TfuDlCqiRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiRpt
+S16 cmUnpkTfuDlCqiRpt
(
TfuDlCqiRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiRpt(param, mBuf)
+S16 cmUnpkTfuDlCqiRpt(param, mBuf)
TfuDlCqiRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiIndInfo
+S16 cmPkTfuDlCqiIndInfo
(
TfuDlCqiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiIndInfo(param, mBuf)
+S16 cmPkTfuDlCqiIndInfo(param, mBuf)
TfuDlCqiIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiIndInfo
+S16 cmUnpkTfuDlCqiIndInfo
(
TfuDlCqiIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDlCqiIndInfo(param, memCp, mBuf)
TfuDlCqiIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCrcInfo
+S16 cmPkTfuCrcInfo
(
TfuCrcInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCrcInfo(param, mBuf)
+S16 cmPkTfuCrcInfo(param, mBuf)
TfuCrcInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCrcInfo
+S16 cmUnpkTfuCrcInfo
(
TfuCrcInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCrcInfo(param, mBuf)
+S16 cmUnpkTfuCrcInfo(param, mBuf)
TfuCrcInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCrcIndInfo
+S16 cmPkTfuCrcIndInfo
(
TfuCrcIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCrcIndInfo(param, mBuf)
+S16 cmPkTfuCrcIndInfo(param, mBuf)
TfuCrcIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCrcIndInfo
+S16 cmUnpkTfuCrcIndInfo
(
TfuCrcIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCrcIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuCrcIndInfo(param, memCp, mBuf)
TfuCrcIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvInfo
+S16 cmPkTfuTimingAdvInfo
(
TfuTimingAdvInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuTimingAdvInfo(param, mBuf)
+S16 cmPkTfuTimingAdvInfo(param, mBuf)
TfuTimingAdvInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuTimingAdvInfo
+S16 cmUnpkTfuTimingAdvInfo
(
TfuTimingAdvInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuTimingAdvInfo(param, mBuf)
+S16 cmUnpkTfuTimingAdvInfo(param, mBuf)
TfuTimingAdvInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvIndInfo
+S16 cmPkTfuTimingAdvIndInfo
(
TfuTimingAdvIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuTimingAdvIndInfo(param, mBuf)
+S16 cmPkTfuTimingAdvIndInfo(param, mBuf)
TfuTimingAdvIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuTimingAdvIndInfo
+S16 cmUnpkTfuTimingAdvIndInfo
(
TfuTimingAdvIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuTimingAdvIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuTimingAdvIndInfo(param, memCp, mBuf)
TfuTimingAdvIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTtiCellInfo
+S16 cmPkTfuTtiCellInfo
(
TfuTtiCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuTtiCellInfo(param, mBuf)
+S16 cmPkTfuTtiCellInfo(param, mBuf)
TfuTtiCellInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTtiIndInfo
+S16 cmPkTfuTtiIndInfo
(
TfuTtiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuTtiIndInfo(param, mBuf)
+S16 cmPkTfuTtiIndInfo(param, mBuf)
TfuTtiIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuTtiCellInfo
+S16 cmUnpkTfuTtiCellInfo
(
TfuTtiCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuTtiCellInfo(param, mBuf)
+S16 cmUnpkTfuTtiCellInfo(param, mBuf)
TfuTtiCellInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqInfo
+S16 cmPkTfuRaReqInfo
(
TfuRaReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRaReqInfo(param, mBuf)
+S16 cmPkTfuRaReqInfo(param, mBuf)
TfuRaReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRaReqInfo
+S16 cmUnpkTfuRaReqInfo
(
TfuRaReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRaReqInfo(param, mBuf)
+S16 cmUnpkTfuRaReqInfo(param, mBuf)
TfuRaReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRachInfo
+S16 cmPkTfuRachInfo
(
CmMemListCp memCp,
TfuRachInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRachInfo(memCp, param, mBuf)
+S16 cmPkTfuRachInfo(memCp, param, mBuf)
CmMemListCp memCp;
TfuRachInfo *param;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRachInfo
+S16 cmUnpkTfuRachInfo
(
CmMemListCp memCp,
TfuRachInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRachInfo(memCp, param, mBuf)
+S16 cmUnpkTfuRachInfo(memCp, param, mBuf)
CmMemListCp memCp;
TfuRachInfo *param;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqIndInfo
+S16 cmPkTfuRaReqIndInfo
(
TfuRaReqIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRaReqIndInfo(param, mBuf)
+S16 cmPkTfuRaReqIndInfo(param, mBuf)
TfuRaReqIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRaReqIndInfo
+S16 cmUnpkTfuRaReqIndInfo
(
TfuRaReqIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRaReqIndInfo(param, mBuf)
+S16 cmUnpkTfuRaReqIndInfo(param, mBuf)
TfuRaReqIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPucchDeltaPwrInfo
+S16 cmPkTfuPucchDeltaPwrInfo
(
TfuPucchDeltaPwr *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPucchDeltaPwrInfo(param, mBuf)
+S16 cmPkTfuPucchDeltaPwrInfo(param, mBuf)
TfuPucchDeltaPwr *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrInfo
+S16 cmUnpkTfuPucchDeltaPwrInfo
(
TfuPucchDeltaPwr *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrInfo(param, mBuf)
+S16 cmUnpkTfuPucchDeltaPwrInfo(param, mBuf)
TfuPucchDeltaPwr *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPucchDeltaPwrIndInfo
+S16 cmPkTfuPucchDeltaPwrIndInfo
(
TfuPucchDeltaPwrIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPucchDeltaPwrIndInfo(param, mBuf)
+S16 cmPkTfuPucchDeltaPwrIndInfo(param, mBuf)
TfuPucchDeltaPwrIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrIndInfo
+S16 cmUnpkTfuPucchDeltaPwrIndInfo
(
TfuPucchDeltaPwrIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuPucchDeltaPwrIndInfo(param, memCp, mBuf)
TfuPucchDeltaPwrIndInfo *param;
Ptr memCp;
Buffer *mBuf;
}
#ifdef ANSI
-PUBLIC S16 cmPkBuffer
+S16 cmPkBuffer
(
Buffer **param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkBuffer(param, mBuf)
+S16 cmPkBuffer(param, mBuf)
Buffer **param;
Buffer *mBuf;
#endif
return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkBuffer
+S16 cmUnpkBuffer
(
Buffer **param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkBuffer(param, mBuf)
+S16 cmUnpkBuffer(param, mBuf)
Buffer **param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDoaInd
+S16 cmPkTfuDoaInd
(
Pst * pst,
SuId suId,
TfuDoaIndInfo * doaInd
)
#else
-PUBLIC S16 cmPkTfuDoaInd(pst, suId, doaInd)
+S16 cmPkTfuDoaInd(pst, suId, doaInd)
Pst * pst;
SuId suId;
TfuDoaIndInfo * doaInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDoaInd
+S16 cmUnpkTfuDoaInd
(
TfuDoaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDoaInd(func, pst, mBuf)
+S16 cmUnpkTfuDoaInd(func, pst, mBuf)
TfuDoaInd func;
Pst *pst;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatTbInfo
+S16 cmPkTfuDciFormatTbInfo
(
TfuDciFormatTbInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormatTbInfo(param, mBuf)
+S16 cmPkTfuDciFormatTbInfo(param, mBuf)
TfuDciFormatTbInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatTbInfo
+S16 cmUnpkTfuDciFormatTbInfo
(
TfuDciFormatTbInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormatTbInfo(param, mBuf)
+S16 cmUnpkTfuDciFormatTbInfo(param, mBuf)
TfuDciFormatTbInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandDlCqiInfo
+S16 cmPkTfuSubbandDlCqiInfo
(
TfuSubbandDlCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandDlCqiInfo(param, mBuf)
+S16 cmPkTfuSubbandDlCqiInfo(param, mBuf)
TfuSubbandDlCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandDlCqiInfo
+S16 cmUnpkTfuSubbandDlCqiInfo
(
TfuSubbandDlCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandDlCqiInfo(param, mBuf)
+S16 cmUnpkTfuSubbandDlCqiInfo(param, mBuf)
TfuSubbandDlCqiInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiPuschInfo
+S16 cmPkTfuDlCqiPuschInfo
(
TfuDlCqiPuschInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiPuschInfo(param, mBuf)
+S16 cmPkTfuDlCqiPuschInfo(param, mBuf)
TfuDlCqiPuschInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPuschInfo
+S16 cmUnpkTfuDlCqiPuschInfo
(
TfuDlCqiPuschInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiPuschInfo(param, mBuf)
+S16 cmUnpkTfuDlCqiPuschInfo(param, mBuf)
TfuDlCqiPuschInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDoaRpt
+S16 cmPkTfuDoaRpt
(
TfuDoaRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDoaRpt(param, mBuf)
+S16 cmPkTfuDoaRpt(param, mBuf)
TfuDoaRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDoaRpt
+S16 cmUnpkTfuDoaRpt
(
TfuDoaRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDoaRpt(param, mBuf)
+S16 cmUnpkTfuDoaRpt(param, mBuf)
TfuDoaRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDoaIndInfo
+S16 cmPkTfuDoaIndInfo
(
TfuDoaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDoaIndInfo(param, mBuf)
+S16 cmPkTfuDoaIndInfo(param, mBuf)
TfuDoaIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDoaIndInfo
+S16 cmUnpkTfuDoaIndInfo
(
TfuDoaIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDoaIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDoaIndInfo(param, memCp, mBuf)
TfuDoaIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrsRpt
+S16 cmPkTfuSrsRpt
(
TfuSrsRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSrsRpt(param, mBuf)
+S16 cmPkTfuSrsRpt(param, mBuf)
TfuSrsRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrsRpt
+S16 cmUnpkTfuSrsRpt
(
TfuSrsRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSrsRpt(param, mBuf)
+S16 cmUnpkTfuSrsRpt(param, mBuf)
TfuSrsRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrsIndInfo
+S16 cmPkTfuSrsIndInfo
(
TfuSrsIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSrsIndInfo(param, mBuf)
+S16 cmPkTfuSrsIndInfo(param, mBuf)
TfuSrsIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrsIndInfo
+S16 cmUnpkTfuSrsIndInfo
(
TfuSrsIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSrsIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuSrsIndInfo(param, memCp, mBuf)
TfuSrsIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiRpt
+S16 cmPkTfuRawCqiRpt
(
TfuRawCqiRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRawCqiRpt(param, mBuf)
+S16 cmPkTfuRawCqiRpt(param, mBuf)
TfuRawCqiRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRawCqiRpt
+S16 cmUnpkTfuRawCqiRpt
(
TfuRawCqiRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRawCqiRpt(param, mBuf)
+S16 cmUnpkTfuRawCqiRpt(param, mBuf)
TfuRawCqiRpt *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiIndInfo
+S16 cmPkTfuRawCqiIndInfo
(
TfuRawCqiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRawCqiIndInfo(param, mBuf)
+S16 cmPkTfuRawCqiIndInfo(param, mBuf)
TfuRawCqiIndInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRawCqiIndInfo
+S16 cmUnpkTfuRawCqiIndInfo
(
TfuRawCqiIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRawCqiIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuRawCqiIndInfo(param, memCp, mBuf)
TfuRawCqiIndInfo *param;
Ptr memCp;
Buffer *mBuf;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo
+S16 cmPkTfuUePucchHqRecpInfo
(
TfuUePucchHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
TfuUePucchHqRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo
+S16 cmUnpkTfuUePucchHqRecpInfo
(
TfuUePucchHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
TfuUePucchHqRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo
+S16 cmPkTfuUePucchHqRecpInfo
(
TfuUePucchHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
TfuUePucchHqRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo
+S16 cmUnpkTfuUePucchHqRecpInfo
(
TfuUePucchHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
TfuUePucchHqRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchSrRecpInfo
+S16 cmPkTfuUePucchSrRecpInfo
(
TfuUePucchSrRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchSrRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchSrRecpInfo(param, mBuf)
TfuUePucchSrRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchSrRecpInfo
+S16 cmUnpkTfuUePucchSrRecpInfo
(
TfuUePucchSrRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchSrRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchSrRecpInfo(param, mBuf)
TfuUePucchSrRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchCqiRecpInfo
+S16 cmPkTfuUePucchCqiRecpInfo
(
TfuUePucchCqiRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchCqiRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchCqiRecpInfo(param, mBuf)
TfuUePucchCqiRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchCqiRecpInfo
+S16 cmUnpkTfuUePucchCqiRecpInfo
(
TfuUePucchCqiRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchCqiRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchCqiRecpInfo(param, mBuf)
TfuUePucchCqiRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchSrsRecpInfo
+S16 cmPkTfuUePucchSrsRecpInfo
(
TfuUePucchSrsRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchSrsRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchSrsRecpInfo(param, mBuf)
TfuUePucchSrsRecpInfo *param;
Buffer *mBuf;
#endif
#ifdef TFU_5GTF
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchUciRecpInfo
+S16 cmPkTfuUePucchUciRecpInfo
(
TfuUePucchUciRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchUciRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchUciRecpInfo(param, mBuf)
TfuUePucchUciRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo
+S16 cmUnpkTfuUePucchSrsRecpInfo
(
TfuUePucchSrsRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
TfuUePucchSrsRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchBsiBriRecpInfo
+S16 cmPkTfuUePucchBsiBriRecpInfo
(
TfuUePucchBsiBriRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchBsiBriRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchBsiBriRecpInfo(param, mBuf)
TfuUePucchBsiBriRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchBsiBriRecpInfo
+S16 cmUnpkTfuUePucchBsiBriRecpInfo
(
TfuUePucchBsiBriRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchBsiBriRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchBsiBriRecpInfo(param, mBuf)
TfuUePucchBsiBriRecpInfo *param;
Buffer *mBuf;
#endif
#ifdef TFU_5GTF
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo
+S16 cmUnpkTfuUePucchUciRecpInfo
(
TfuUePucchUciRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
TfuUePucchUciRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchRecpReq
+S16 cmPkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchRecpReq(param, mBuf)
+S16 cmPkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchRecpReq
+S16 cmUnpkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
+S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUeUlSchRecpInfo
+S16 cmPkTfuUeUlSchRecpInfo
(
TfuUeUlSchRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUeUlSchRecpInfo(param, mBuf)
+S16 cmPkTfuUeUlSchRecpInfo(param, mBuf)
TfuUeUlSchRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeUlSchRecpInfo
+S16 cmUnpkTfuUeUlSchRecpInfo
(
TfuUeUlSchRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUeUlSchRecpInfo(param, mBuf)
+S16 cmUnpkTfuUeUlSchRecpInfo(param, mBuf)
TfuUeUlSchRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschCqiRecpInfo
+S16 cmPkTfuUePuschCqiRecpInfo
(
TfuUePuschCqiRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePuschCqiRecpInfo(param, mBuf)
+S16 cmPkTfuUePuschCqiRecpInfo(param, mBuf)
TfuUePuschCqiRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschCqiRecpInfo
+S16 cmUnpkTfuUePuschCqiRecpInfo
(
TfuUePuschCqiRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschCqiRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePuschCqiRecpInfo(param, mBuf)
TfuUePuschCqiRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschHqRecpInfo
+S16 cmPkTfuUePuschHqRecpInfo
(
TfuUePuschHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePuschHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePuschHqRecpInfo(param, mBuf)
TfuUePuschHqRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschHqRecpInfo
+S16 cmUnpkTfuUePuschHqRecpInfo
(
TfuUePuschHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePuschHqRecpInfo(param, mBuf)
TfuUePuschHqRecpInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschRecpReq
+S16 cmPkTfuUePuschRecpReq
(
TfuUePuschRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePuschRecpReq(param, mBuf)
+S16 cmPkTfuUePuschRecpReq(param, mBuf)
TfuUePuschRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschRecpReq
+S16 cmUnpkTfuUePuschRecpReq
(
TfuUePuschRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
+S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
TfuUePuschRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUeRecpReqInfo
+S16 cmPkTfuUeRecpReqInfo
(
TfuUeRecpReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUeRecpReqInfo(param, mBuf)
+S16 cmPkTfuUeRecpReqInfo(param, mBuf)
TfuUeRecpReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo
+S16 cmUnpkTfuUeRecpReqInfo
(
TfuUeRecpReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
+S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
TfuUeRecpReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchRecpReq
+S16 cmPkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchRecpReq(param, mBuf)
+S16 cmPkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchRecpReq
+S16 cmUnpkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
+S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUeMsg3RecpReq
+S16 cmPkTfuUeMsg3RecpReq
(
TfuUeMsg3RecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUeMsg3RecpReq(param, mBuf)
+S16 cmPkTfuUeMsg3RecpReq(param, mBuf)
TfuUeMsg3RecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeMsg3RecpReq
+S16 cmUnpkTfuUeMsg3RecpReq
(
TfuUeMsg3RecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUeMsg3RecpReq(param, mBuf)
+S16 cmUnpkTfuUeMsg3RecpReq(param, mBuf)
TfuUeMsg3RecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschRecpReq
+S16 cmPkTfuUePuschRecpReq
(
TfuUePuschRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePuschRecpReq(param, mBuf)
+S16 cmPkTfuUePuschRecpReq(param, mBuf)
TfuUePuschRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschRecpReq
+S16 cmUnpkTfuUePuschRecpReq
(
TfuUePuschRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
+S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
TfuUePuschRecpReq *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUeRecpReqInfo
+S16 cmPkTfuUeRecpReqInfo
(
TfuUeRecpReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUeRecpReqInfo(param, mBuf)
+S16 cmPkTfuUeRecpReqInfo(param, mBuf)
TfuUeRecpReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo
+S16 cmUnpkTfuUeRecpReqInfo
(
TfuUeRecpReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
+S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
TfuUeRecpReqInfo *param;
Buffer *mBuf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuErrInd
+S16 cmPkTfuErrInd
(
Pst * pst,
SuId suId,
TfuErrIndInfo * errInd
)
#else
-PUBLIC S16 cmPkTfuErrInd(pst, suId, errInd)
+S16 cmPkTfuErrInd(pst, suId, errInd)
Pst * pst;
SuId suId;
TfuErrIndInfo * errInd;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuErrInd
+S16 cmUnpkTfuErrInd
(
TfuErrInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuErrInd(func, pst, mBuf)
+S16 cmUnpkTfuErrInd(func, pst, mBuf)
TfuErrInd func;
Pst *pst;
Buffer *mBuf;
}
break;
}
- case ENTKW:
+ case ENTRLC:
{
switch(pst->event)
{
uint8_t duBuildRlcCfg(Inst inst);
uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst);
uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst);
-uint8_t DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm);
-uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cfm);
-uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm);
-uint8_t duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm);
+uint8_t DuHdlRlcCfgComplete(Pst *pst, RlcMngmt *cfm);
+uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, RlcMngmt *cfm);
+uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm);
+uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm);
uint8_t duSendMacCfg();
uint8_t duBuildMacGenCfg();
uint8_t duBuildMacUsapCfg(SpId sapId);
break;
}
- case ENTKW:
+ case ENTRLC:
{
switch(pst->event)
{
}
default:
{
- DU_LOG("\nDU_APP : Invalid event %d received at duActvTsk from ENTKW", \
+ DU_LOG("\nDU_APP : Invalid event %d received at duActvTsk from ENTRLC", \
pst->event);
ODU_PUT_MSG(mBuf);
ret = RFAILED;
}
break;
}
- case ENTRG:
+ case ENTMAC:
{
switch(pst->event)
{
default:
{
- DU_LOG("\nDU_APP : Invalid event received at duActvTsk from ENTRG");
+ DU_LOG("\nDU_APP : Invalid event received at duActvTsk from ENTMAC");
ODU_PUT_MSG(mBuf);
ret = RFAILED;
}
uint8_t rlcDlInit(SSTskId sysTskId)
{
/* Register RLC DL TAPA Task */
- if(ODU_REG_TTSK((Ent)ENTKW, (Inst)1, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTRLC, (Inst)1, (Ttype)TTNORM, (Prior)PRIOR0,
rlcDlActvInit, (ActvTsk)rlcDlActvTsk) != ROK)
{
return RFAILED;
}
/* Attach RLC DL Task */
- if (ODU_ATTACH_TTSK((Ent)ENTKW, (Inst)1, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTRLC, (Inst)1, sysTskId)!= ROK)
{
return RFAILED;
}
/* Register MAC TAPA Task */
- if(ODU_REG_TTSK((Ent)ENTRG, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTMAC, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
rgActvInit, (ActvTsk)rgActvTsk) != ROK)
{
return RFAILED;
}
/* Attach MAC Task */
- if (ODU_ATTACH_TTSK((Ent)ENTRG, (Inst)0, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTMAC, (Inst)0, sysTskId)!= ROK)
{
return RFAILED;
}
uint8_t rlcUlInit(SSTskId sysTskId)
{
/* Register RLC UL TAPA Task */
- if(ODU_REG_TTSK((Ent)ENTKW, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTRLC, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
rlcUlActvInit, (ActvTsk)rlcUlActvTsk) != ROK)
{
return RFAILED;
}
/* Attach RLC DL Task */
- if (ODU_ATTACH_TTSK((Ent)ENTKW, (Inst)0, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTRLC, (Inst)0, sysTskId)!= ROK)
{
return RFAILED;
}
uint8_t macCfgInst = 0;
extern DuCfgParams duCfgParam;
-extern uint8_t packRlcConfigReq(Pst *pst, KwMngmt *cfg);
-extern uint8_t cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg);
+extern uint8_t packRlcConfigReq(Pst *pst, RlcMngmt *cfg);
+extern uint8_t cmPkLkwCntrlReq(Pst *pst, RlcMngmt *cfg);
extern uint8_t cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg);
extern uint8_t BuildAndSendE2SetupReq();
extern uint8_t egtpHdlDatInd(EgtpMsg egtpMsg);
***************************************************************************/
uint8_t duBuildRlcCfg(Inst inst)
{
- KwMngmt kwMngmt;
- KwGenCfg *genCfg = NULLP;
+ RlcMngmt rlcMngmt;
+ RlcGenCfg *genCfg = NULLP;
Pst pst;
- DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt));
+ DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
DU_SET_ZERO(&pst, sizeof(Pst));
- genCfg = &(kwMngmt.t.cfg.s.gen);
+ genCfg = &(rlcMngmt.t.cfg.s.gen);
/*----------- Fill General Configuration Parameters ---------*/
genCfg->maxUe = duCfgParam.maxUe;
genCfg->lmPst.srcProcId = DU_PROC;
genCfg->lmPst.dstEnt = ENTDUAPP;
genCfg->lmPst.dstInst = DU_INST;
- genCfg->lmPst.srcEnt = ENTKW;
+ genCfg->lmPst.srcEnt = ENTRLC;
genCfg->lmPst.srcInst = inst;
genCfg->lmPst.prior = PRIOR0;
genCfg->lmPst.route = RTESPEC;
genCfg->lmPst.selector = ODU_SELECTOR_LC;
/* Fill Header */
- kwMngmt.hdr.msgType = TCFG;
- kwMngmt.hdr.msgLen = 0;
- kwMngmt.hdr.entId.ent = ENTKW;
- kwMngmt.hdr.entId.inst = (Inst)0;
- kwMngmt.hdr.elmId.elmnt = STGEN;
- kwMngmt.hdr.seqNmb = 0;
- kwMngmt.hdr.version = 0;
- kwMngmt.hdr.transId = 0;
- kwMngmt.hdr.response.prior = PRIOR0;
- kwMngmt.hdr.response.route = RTESPEC;
- kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
+ rlcMngmt.hdr.msgType = TCFG;
+ rlcMngmt.hdr.msgLen = 0;
+ rlcMngmt.hdr.entId.ent = ENTRLC;
+ rlcMngmt.hdr.entId.inst = (Inst)0;
+ rlcMngmt.hdr.elmId.elmnt = STGEN;
+ rlcMngmt.hdr.seqNmb = 0;
+ rlcMngmt.hdr.version = 0;
+ rlcMngmt.hdr.transId = 0;
+ rlcMngmt.hdr.response.prior = PRIOR0;
+ rlcMngmt.hdr.response.route = RTESPEC;
+ rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
- kwMngmt.hdr.response.mem.pool = DU_POOL;
- kwMngmt.hdr.response.selector = ODU_SELECTOR_LC;
+ rlcMngmt.hdr.response.mem.pool = DU_POOL;
+ rlcMngmt.hdr.response.selector = ODU_SELECTOR_LC;
/* Fill Pst */
pst.selector = ODU_SELECTOR_LC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
+ pst.dstEnt = ENTRLC;
pst.dstInst = inst;
pst.dstProcId = DU_PROC;
pst.srcProcId = DU_PROC;
DU_LOG("\nDU_APP : RLC Gen Cfg Req sent for inst %d", inst);
/* Send the request to RLC */
- packRlcConfigReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &rlcMngmt);
return ROK;
}
uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst)
{
- KwMngmt kwMngmt;
- KwSapCfg *lSap = NULLP;
+ RlcMngmt rlcMngmt;
+ RlcSapCfg *lSap = NULLP;
Pst pst;
- DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt));
+ DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
DU_SET_ZERO(&pst, sizeof(Pst));
/* Fill Header */
- kwMngmt.hdr.msgType = TCFG;
- kwMngmt.hdr.entId.ent = ENTKW;
- kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
+ rlcMngmt.hdr.msgType = TCFG;
+ rlcMngmt.hdr.entId.ent = ENTRLC;
+ rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
- kwMngmt.hdr.response.mem.pool = RLC_POOL;
+ rlcMngmt.hdr.response.mem.pool = RLC_POOL;
/* Fill Pst */
pst.selector = ODU_SELECTOR_LC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
+ pst.dstEnt = ENTRLC;
pst.dstProcId = DU_PROC;
pst.dstInst = inst;
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- lSap = &(kwMngmt.t.cfg.s.sap);
+ lSap = &(rlcMngmt.t.cfg.s.sap);
lSap->mem.region = (inst == RLC_UL_INST) ?
RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
lSap->bndTmrIntvl = 10;
lSap->priority = PRIOR0;
lSap->route = RTESPEC;
- if (ent == ENTRG)
+ if (ent == ENTMAC)
{
lSap->procId = DU_PROC;
- lSap->ent = ENTRG;
+ lSap->ent = ENTMAC;
lSap->inst = lsapInst;
lSap->sapId = lsapInst; /* SapId will be stored as suId in MAC */
lSap->selector = (inst == RLC_UL_INST) ? ODU_SELECTOR_LWLC : ODU_SELECTOR_TC;
- kwMngmt.hdr.elmId.elmnt = STRGUSAP;
+ rlcMngmt.hdr.elmId.elmnt = STRGUSAP;
DU_LOG("\nDU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst);
}
else
{
lSap->procId = DU_PROC;
- lSap->ent = ENTKW;
+ lSap->ent = ENTRLC;
lSap->inst = (inst == RLC_UL_INST) ?
RLC_DL_INST : RLC_UL_INST;
lSap->sapId = 0;
lSap->selector = ODU_SELECTOR_LC;
- kwMngmt.hdr.elmId.elmnt = STUDXSAP;
+ rlcMngmt.hdr.elmId.elmnt = STUDXSAP;
DU_LOG("\nDU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
}
- packRlcConfigReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &rlcMngmt);
return ROK;
}
***************************************************************************/
uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst)
{
- KwMngmt kwMngmt;
- KwSapCfg *uSap = NULLP;
+ RlcMngmt rlcMngmt;
+ RlcSapCfg *uSap = NULLP;
Pst pst;
- DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt));
+ DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
DU_SET_ZERO(&pst, sizeof(Pst));
- uSap = &(kwMngmt.t.cfg.s.sap);
+ uSap = &(rlcMngmt.t.cfg.s.sap);
uSap->selector = ODU_SELECTOR_LC;
uSap->mem.region = (inst == RLC_UL_INST) ?
uSap->mem.spare = 0;
uSap->procId = DU_PROC;
- uSap->ent = ENTKW;
+ uSap->ent = ENTRLC;
uSap->sapId = 0;
uSap->inst = (inst == RLC_UL_INST) ?
uSap->route = RTESPEC;
/* Fill Header */
- kwMngmt.hdr.msgType = TCFG;
- kwMngmt.hdr.entId.ent = ENTKW;
- kwMngmt.hdr.elmId.elmnt = STUDXSAP;
- kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
+ rlcMngmt.hdr.msgType = TCFG;
+ rlcMngmt.hdr.entId.ent = ENTRLC;
+ rlcMngmt.hdr.elmId.elmnt = STUDXSAP;
+ rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
- kwMngmt.hdr.response.mem.pool = RLC_POOL;
+ rlcMngmt.hdr.response.mem.pool = RLC_POOL;
/* Fill Pst */
pst.selector = ODU_SELECTOR_LC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
+ pst.dstEnt = ENTRLC;
pst.dstProcId = DU_PROC;
pst.dstInst = inst;
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
DU_LOG("\nDU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst);
- packRlcConfigReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &rlcMngmt);
return ROK;
}
duBuildRlcCfg((Inst)RLC_UL_INST);
for(cellIdx = 0; cellIdx < DEFAULT_CELLS; cellIdx++)
{
- duBuildRlcLsapCfg(ENTRG, (Inst)RLC_UL_INST, cellIdx);
+ duBuildRlcLsapCfg(ENTMAC, (Inst)RLC_UL_INST, cellIdx);
}
- duBuildRlcLsapCfg(ENTKW, (Inst)RLC_UL_INST, 0);
+ duBuildRlcLsapCfg(ENTRLC, (Inst)RLC_UL_INST, 0);
return ROK;
}
uint8_t cellIdx;
duBuildRlcCfg((Inst)RLC_DL_INST);
- duBuildRlcUsapCfg(STUDXSAP, ENTKW, (Inst)RLC_DL_INST);
+ duBuildRlcUsapCfg(STUDXSAP, ENTRLC, (Inst)RLC_DL_INST);
for(cellIdx = 0; cellIdx < DEFAULT_CELLS; cellIdx++)
{
- duBuildRlcLsapCfg(ENTRG, (Inst)RLC_DL_INST, cellIdx);
+ duBuildRlcLsapCfg(ENTMAC, (Inst)RLC_DL_INST, cellIdx);
}
return ROK;
* Handles Gen Config Confirm from RLC
*
* @param[in] Pst *pst, Post structure of the primitive.
- * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC
+ * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC
* @return ROK - success
* RFAILED - failure
*
***************************************************************************/
-uint8_t DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm)
+uint8_t DuHdlRlcCfgComplete(Pst *pst, RlcMngmt *cfm)
{
uint8_t ret = ROK;
if (pst->srcInst == RLC_UL_INST)
* Handles Control Config Confirm from RLC
*
* @param[in] Pst *pst, Post structure of the primitive.
- * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC
+ * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC
* @return ROK - success
* RFAILED - failure
*
***************************************************************************/
-uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cntrl)
+uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, RlcMngmt *cntrl)
{
uint8_t ret = ROK;
* Handles Config Confirm from RLC UL
*
* @param[in] Pst *pst, Post structure of the primitive.
- * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC UL
+ * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC UL
* @return ROK - success
* RFAILED - failure
*
***************************************************************************/
-uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm)
+uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm)
{
uint8_t ret;
* Handles Config Confirm from RLC DL
*
* @param[in] Pst *pst, Post structure of the primitive.
- * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC DL
+ * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC DL
* @return ROK - success
* RFAILED - failure
*
***************************************************************************/
-uint8_t duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm)
+uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm)
{
DU_LOG("\nDU_APP : RLC DL Cfg Status %d", cfm->cfm.status);
if (cfm->cfm.status == LCM_PRIM_OK)
genCfg->lmPst.srcProcId = DU_PROC;
genCfg->lmPst.dstEnt = ENTDUAPP;
genCfg->lmPst.dstInst = 0;
- genCfg->lmPst.srcEnt = ENTRG;
+ genCfg->lmPst.srcEnt = ENTMAC;
genCfg->lmPst.srcInst = macCfgInst;
genCfg->lmPst.prior = PRIOR0;
genCfg->lmPst.route = RTESPEC;
/* Fill Header */
rgMngmt.hdr.msgType = TCFG;
rgMngmt.hdr.msgLen = 0;
- rgMngmt.hdr.entId.ent = ENTRG;
+ rgMngmt.hdr.entId.ent = ENTMAC;
rgMngmt.hdr.entId.inst = (Inst)0;
rgMngmt.hdr.elmId.elmnt = STGEN;
rgMngmt.hdr.seqNmb = 0;
/* Fill Pst */
pst.selector = ODU_SELECTOR_LC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTRG;
+ pst.dstEnt = ENTMAC;
pst.dstInst = macCfgInst;
pst.dstProcId = DU_PROC;
pst.srcProcId = DU_PROC;
uSap->suId = 0;
uSap->spId = sapId;
uSap->procId = DU_PROC;
- uSap->ent = ENTKW;
+ uSap->ent = ENTRLC;
uSap->inst = sapId;
uSap->prior = PRIOR0;
uSap->route = RTESPEC;
/* fill header */
rgMngmt.hdr.msgType = TCFG;
- rgMngmt.hdr.entId.ent = ENTRG;
+ rgMngmt.hdr.entId.ent = ENTMAC;
rgMngmt.hdr.entId.inst = (Inst)0;
rgMngmt.hdr.elmId.elmnt = STRGUSAP;
rgMngmt.hdr.response.mem.region = MAC_MEM_REGION;
/* fill pst */
pst.selector = ODU_SELECTOR_LC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTRG;
+ pst.dstEnt = ENTMAC;
pst.dstInst = macCfgInst;
pst.dstProcId = DU_PROC;
pst.srcProcId = DU_PROC;
***************************************************************************/
uint8_t duBindUnbindRlcToMacSap(uint8_t inst, uint8_t action)
{
- KwCntrl *cntrl = NULLP;
- KwMngmt kwMngmt;
+ RlcCntrl *cntrl = NULLP;
+ RlcMngmt rlcMngmt;
Pst pst;
TRC2(smBindKwToRguSap)
- DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt));
+ DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
DU_SET_ZERO(&pst, sizeof(Pst));
if (action == ABND)
{
DU_LOG("\nDU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst);
}
- cntrl = &(kwMngmt.t.cntrl);
+ cntrl = &(rlcMngmt.t.cntrl);
cntrl->action = action;
cntrl->subAction = DU_ZERO_VAL;
cntrl->s.sapCntrl.spId = inst;
/* Fill header */
- kwMngmt.hdr.msgType = TCNTRL;
- kwMngmt.hdr.entId.ent = ENTKW;
- kwMngmt.hdr.entId.inst = inst;
- kwMngmt.hdr.elmId.elmnt = 186; /* ambiguous defines in lkw.h and lrg.h so direct hardcoded*/
- kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
+ rlcMngmt.hdr.msgType = TCNTRL;
+ rlcMngmt.hdr.entId.ent = ENTRLC;
+ rlcMngmt.hdr.entId.inst = inst;
+ rlcMngmt.hdr.elmId.elmnt = 186; /* ambiguous defines in lkw.h and lrg.h so direct hardcoded*/
+ rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
- kwMngmt.hdr.response.mem.pool = RLC_POOL;
+ rlcMngmt.hdr.response.mem.pool = RLC_POOL;
/* Fill pst */
pst.selector = ODU_SELECTOR_LC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
+ pst.dstEnt = ENTRLC;
pst.dstProcId = DU_PROC;
pst.dstInst = inst;
pst.srcProcId = DU_PROC;
pst.region = duCb.init.region;
- cmPkLkwCntrlReq(&pst, &kwMngmt);
+ cmPkLkwCntrlReq(&pst, &rlcMngmt);
return ROK;
}
cfg->genCfg.lmPst.srcProcId = DU_PROC;
cfg->genCfg.lmPst.dstEnt = ENTDUAPP;
cfg->genCfg.lmPst.dstInst = DU_INST;
- cfg->genCfg.lmPst.srcEnt = ENTRG;
+ cfg->genCfg.lmPst.srcEnt = ENTMAC;
cfg->genCfg.lmPst.srcInst = DEFAULT_CELLS + 1;
cfg->genCfg.lmPst.prior = PRIOR0;
cfg->genCfg.lmPst.route = RTESPEC;
/* Fill Header */
rgMngmt.hdr.msgType = TCFG;
- rgMngmt.hdr.entId.ent = ENTRG;
+ rgMngmt.hdr.entId.ent = ENTMAC;
rgMngmt.hdr.entId.inst = DU_INST;
rgMngmt.hdr.elmId.elmnt = STSCHINST;
rgMngmt.hdr.response.mem.region = MAC_MEM_REGION;
/* Fill Pst */
pst.selector = ODU_SELECTOR_LC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTRG;
+ pst.dstEnt = ENTMAC;
pst.dstProcId = DU_PROC;
pst.srcProcId = DU_PROC;
pst.srcInst = DU_INST;
/* Filling pst and Sending to RLC DL */
pst.selector = ODU_SELECTOR_LWLC;
pst.srcEnt = ENTDUAPP;
- pst.dstEnt = ENTKW;
+ pst.dstEnt = ENTRLC;
pst.dstInst = RLC_DL_INST;
pst.dstProcId = DU_PROC;
pst.srcProcId = DU_PROC;
{ \
_pst.selector = ODU_SELECTOR_LWLC; \
_pst.srcEnt = ENTDUAPP; \
- _pst.dstEnt = ENTRG; \
+ _pst.dstEnt = ENTMAC; \
_pst.dstInst = 0; \
_pst.srcInst = 0; \
_pst.dstProcId = DU_PROC; \
{ \
_pst.selector = ODU_SELECTOR_LWLC; \
_pst.srcEnt = ENTDUAPP; \
- _pst.dstEnt = ENTKW; \
+ _pst.dstEnt = ENTRLC; \
_pst.dstInst = _dstInst; \
_pst.srcInst = DU_INST; \
_pst.dstProcId = DU_PROC; \
void *(*start_routine) (void *); /* function from which pthread starts */
}SPThreadCreateArg;
-PUBLIC void *pthreadCreateHdlr(void* arg);
+void *pthreadCreateHdlr(void* arg);
#ifdef SS_LOCKLESS_MEMORY
-PUBLIC Buffer *mtTskBuffer1;
-PUBLIC Buffer *mtTskBuffer2;
+Buffer *mtTskBuffer1;
+Buffer *mtTskBuffer2;
EXTERN pthread_t tmpRegTidMap[20];
EXTERN U8 stopBtInfo;
/* forward references */
/* mt003.301 Modifications - Moved to ss_gen.x */
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
-PUBLIC Void *mtTskHdlrT2kL2 ARGS((Void*));
-PUBLIC void mtSigSegvHndlr ARGS((void));
-PUBLIC void mtSigUsr2Hndlr ARGS((void));
+Void *mtTskHdlrT2kL2 ARGS((Void*));
+ void mtSigSegvHndlr ARGS((void));
+ void mtSigUsr2Hndlr ARGS((void));
#endif
PRIVATE S16 ssdSetPthreadAttr ARGS ((S32 tskPrior, pthread_attr_t *attr));
#endif /* SS_SEUM_CAVIUM */
#ifdef SS_THR_REG_MAP
-PUBLIC S32 ssCheckAndAddMemoryRegionMap ARGS((pthread_t threadId,
+S32 ssCheckAndAddMemoryRegionMap ARGS((pthread_t threadId,
Region region));
-PUBLIC S32 ssCheckAndDelMemoryRegionMap ARGS((pthread_t threadId));
+S32 ssCheckAndDelMemoryRegionMap ARGS((pthread_t threadId));
#endif /* SS_THR_REG_MAP */
\f
/* type declarations */
\f
/* public variable declarations */
-PUBLIC Cntr cfgNumRegs = SS_MAX_REGS;
+Cntr cfgNumRegs = SS_MAX_REGS;
/* Set memory configuration as false.
* Set to true if memory configuration through file is successfull.
*/
-PUBLIC Bool memConfigured = FALSE;
+Bool memConfigured = FALSE;
/* mt022.201 - Modification for shared memory relay region and memcal tool */
-PUBLIC SsRegCfg cfgRegInfo[SS_MAX_REGS] =
+SsRegCfg cfgRegInfo[SS_MAX_REGS] =
{
{
SS_DFLT_REGION, SS_MAX_POOLS_PER_REG - 1,
*/
#ifdef SS_LOCKLESS_MEMORY
-PUBLIC MtDynMemCfg mtDynMemoCfg =
+MtDynMemCfg mtDynMemoCfg =
{
SS_MAX_REGS, /* number of regions */
{
};
-PUBLIC MtGlobMemCfg mtGlobMemoCfg =
+MtGlobMemCfg mtGlobMemoCfg =
{
MT_MAX_BKTS, /* number of buckets */
{
/* mt022.201 - Modification for memory calculator tool */
/* mt018.201 - added memory configuration matrix */
-PUBLIC MtMemCfg mtMemoCfg =
+MtMemCfg mtMemoCfg =
{
#ifdef RY_ENBS5SHM
SS_MAX_REGS - 1, /* number of regions */
* bucket info, as different regions may request for different no.
* of blocks
*/
-PUBLIC MtBktCfg mtBktInfo[MT_MAX_BKTS];
-PUBLIC S16 msArgc; /* argc */
-PUBLIC Txt **msArgv; /* argv */
-PUBLIC S16 msOptInd; /* SGetOpt vars */
-PUBLIC S8 *msOptArg; /* SGetOpt vars */
+MtBktCfg mtBktInfo[MT_MAX_BKTS];
+S16 msArgc; /* argc */
+Txt **msArgv; /* argv */
+S16 msOptInd; /* SGetOpt vars */
+S8 *msOptArg; /* SGetOpt vars */
#ifdef INTEL_WLS
*
*/
#ifdef ANSI
-PUBLIC int main
+int main
(
int argc, /* argument count */
char **argv /* argument vector */
)
#else
-PUBLIC int main(argc, argv)
+int main(argc, argv)
int argc; /* argument count */
char **argv; /* argument vector */
#endif
*
*/
#ifdef ANSI
-PUBLIC int ssMain
+int ssMain
(
int argc, /* argument count */
char **argv /* argument vector */
)
#else
-PUBLIC int ssMain(argc, argv)
+int ssMain(argc, argv)
int argc; /* argument count */
char **argv; /* argument vector */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitGen
+S16 ssdInitGen
(
void
)
#else
-PUBLIC S16 ssdInitGen()
+S16 ssdInitGen()
#endif
{
struct sigaction act;
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitGen
+Void ssdDeinitGen
(
void
)
#else
-PUBLIC Void ssdDeinitGen()
+Void ssdDeinitGen()
#endif
{
TRC0(ssdDeinitGen);
*
*/
#ifdef ANSI
-PUBLIC S16 ssPutDynMemBlkSet
+S16 ssPutDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem /* Memory set element which is needs to be
added to global region */
)
#else
-PUBLIC S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is needs to be
added to global region */
*
*/
#ifdef ANSI
-PUBLIC S16 ssGetDynMemBlkSet
+S16 ssGetDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem /* Memory set element which is updated
with new set values */
)
#else
-PUBLIC S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is updated
with new set values */
*
*/
#ifdef ANSI
-PUBLIC S16 ssPutDynMemBlkSet
+S16 ssPutDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem, /* Memory set element which is needs to be
U32 doNotBlockForLock /* Boolean whether to block for lock or not */
)
#else
-PUBLIC S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is needs to be
added to global region */
*
*/
#ifdef ANSI
-PUBLIC S16 ssGetDynMemBlkSet
+S16 ssGetDynMemBlkSet
(
U8 bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem, /* Memory set element which is updated
U32 doNotBlockForLock /* Boolean whether to block for lock or not */
)
#else
-PUBLIC S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
+S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
U8 bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is updated
with new set values */
PRIVATE U32 memoryCheckCounter;
#ifdef ANSI
-PUBLIC U32 isMemThreshReached(
+U32 isMemThreshReached(
Region reg
)
#else
-PUBLIC U32 isMemThreshReached(reg)
+U32 isMemThreshReached(reg)
Region reg;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void * ssGetIccHdl
+Void * ssGetIccHdl
(
Region region
)
#else
-PUBLIC Void * ssGetIccHdl()
+Void * ssGetIccHdl()
Region region;
#endif
{
#ifdef INTEL_WLS
-PUBLIC S16 SPartitionWlsMemory()
+S16 SPartitionWlsMemory()
{
U32 i;
#ifndef ALIGN_64BIT
}
#ifdef SS_MEM_WL_DEBUG
-PUBLIC Void SChkAddrValid(int type, int region, PTR ptr)
+Void SChkAddrValid(int type, int region, PTR ptr)
{
char *tryPtr = NULL;
if(type == 0) //Global
}
#endif /* SS_MEM_WL_DEBUG */
-PUBLIC S16 SPartitionStaticMemory(U8 *startAddr)
+S16 SPartitionStaticMemory(U8 *startAddr)
{
int i;
U32 reqdSz;
}
return ROK;
}
-PUBLIC S16 SAllocateWlsMem()
+S16 SAllocateWlsMem()
{
U32 reqdMemSz;
SPartitionWlsMemory();
return ROK;
}
-PUBLIC S16 SAllocateStaticMem()
+S16 SAllocateStaticMem()
{
U32 reqdMemSz;
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitMem
+S16 ssdInitMem
(
void
)
#else
-PUBLIC S16 ssdInitMem()
+S16 ssdInitMem()
#endif
{
/* mt018.201 - added local variable */
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitMem
+Void ssdDeinitMem
(
void
)
#else
-PUBLIC Void ssdDeinitMem()
+Void ssdDeinitMem()
#endif
{
/* mt018.201 - added local variables */
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitTsk
+S16 ssdInitTsk
(
void
)
#else
-PUBLIC S16 ssdInitTsk()
+S16 ssdInitTsk()
#endif
{
/* mt001.301 : Additions */
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitTsk
+Void ssdDeinitTsk
(
void
)
#else
-PUBLIC Void ssdDeinitTsk()
+Void ssdDeinitTsk()
#endif
{
TRC0(ssdDeinitTsk);
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitDrvr
+S16 ssdInitDrvr
(
void
)
#else
-PUBLIC S16 ssdInitDrvr()
+S16 ssdInitDrvr()
#endif
{
S16 i;
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitDrvr
+Void ssdDeinitDrvr
(
void
)
#else
-PUBLIC Void ssdDeinitDrvr()
+Void ssdDeinitDrvr()
#endif
{
TRC0(ssdDeinitDrvr);
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitTmr
+S16 ssdInitTmr
(
void
)
#else
-PUBLIC S16 ssdInitTmr()
+S16 ssdInitTmr()
#endif
{
pthread_attr_t attr;
*
*/
#ifdef ANSI
-PUBLIC Void ssdDeinitTmr
+Void ssdDeinitTmr
(
void
)
#else
-PUBLIC Void ssdDeinitTmr()
+Void ssdDeinitTmr()
#endif
{
#ifdef SS_MULTICORE_SUPPORT
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitLog
+S16 ssdInitLog
(
void
)
#else
-PUBLIC S16 ssdInitLog()
+S16 ssdInitLog()
#endif
{
/* mt027.201 - Modification to fix warnings with no STDIN and STDOUT */
*/
/* mt008.301: ssdDeinitFinal changed to ssdDeinitLog */
#ifdef ANSI
-PUBLIC Void ssdDeinitLog
+Void ssdDeinitLog
(
void
)
#else
-PUBLIC Void ssdDeinitLog()
+Void ssdDeinitLog()
#endif
{
/* mt008.301: ssdDeinitFinal changed to ssdDeinitLog */
#ifdef ANSI
-PUBLIC S16 ssdInitWatchDog
+S16 ssdInitWatchDog
(
U16 port
)
#else
-PUBLIC S16 ssdInitWatchDog(port)
+S16 ssdInitWatchDog(port)
U16 port;
#endif
{
}
#ifdef ANSI
-PUBLIC S16 ssdInitWatchDgPst
+S16 ssdInitWatchDgPst
(
Pst *pst
)
#else
-PUBLIC S16 ssdInitWatchDgPst(pst)
+S16 ssdInitWatchDgPst(pst)
Pst *pst;
#endif
{
#ifdef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 ssdWatchDgActvTmr
+S16 ssdWatchDgActvTmr
(
ProcId proc,
Ent ent,
Inst inst
)
#else
-PUBLIC S16 ssdWatchDgActvTmr(proc, ent, inst)
+S16 ssdWatchDgActvTmr(proc, ent, inst)
#endif
#else
#ifdef ANSI
-PUBLIC S16 ssdWatchDgActvTmr
+S16 ssdWatchDgActvTmr
(
Void
)
#else
-PUBLIC S16 ssdWatchDgActvTmr()
+S16 ssdWatchDgActvTmr()
#endif
#endif /* SS_MULTIPLE_PROCS */
{
}
#ifdef ANSI
-PUBLIC Void ssdWatchDgTmrEvt
+Void ssdWatchDgTmrEvt
(
PTR cb, /* control block */
S16 event /* timer number */
)
#else
-PUBLIC Void ssdWatchDgTmrEvt(cb, event)
+Void ssdWatchDgTmrEvt(cb, event)
PTR cb; /* control block */
S16 event; /* timer number */
#endif
}
#ifdef ANSI
-PUBLIC Void ssdStartWatchDgTmr
+Void ssdStartWatchDgTmr
(
void *cb,
S16 event,
U16 wait
)
#else
-PUBLIC Void ssdStartWatchDgTmr(cb, event, wait)
+Void ssdStartWatchDgTmr(cb, event, wait)
void *cb;
S16 event;
U16 wait;
}
#ifdef ANSI
-PUBLIC Void ssdStopWatchDgTmr
+Void ssdStopWatchDgTmr
(
void *cb,
S16 event
)
#else
-PUBLIC Void ssdStopWatchDgTmr(cb, event)
+Void ssdStopWatchDgTmr(cb, event)
void *cb;
S16 event;
#endif
}
#ifdef ANSI
-PUBLIC S16 ssdSndHrtBtMsg
+S16 ssdSndHrtBtMsg
(
Bool restart,
U32 type
)
#else
-PUBLIC S16 ssdSndHrtBtMsg(restart, type)
+S16 ssdSndHrtBtMsg(restart, type)
Bool restart;
U32 type;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGetOpt
+S16 SGetOpt
(
int argc, /* argument count */
char **argv, /* argument value */
char *opts /* options */
)
#else
-PUBLIC S16 SGetOpt(argc, argv, opts)
+S16 SGetOpt(argc, argv, opts)
int argc; /* argument count */
char **argv; /* argument value */
char *opts; /* options */
*
*/
#ifdef ANSI
-PUBLIC Void ssdStart
+Void ssdStart
(
void
)
#else
-PUBLIC Void ssdStart()
+Void ssdStart()
#endif
{
S16 i;
*
*/
#ifdef ANSI
-PUBLIC S16 ssdAttachTTsk
+S16 ssdAttachTTsk
(
SsTTskEntry *tTsk /* pointer to TAPA task entry */
)
#else
-PUBLIC S16 ssdAttachTTsk(tTsk)
+S16 ssdAttachTTsk(tTsk)
SsTTskEntry *tTsk; /* pointer to TAPA task entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDetachTTsk
+S16 ssdDetachTTsk
(
SsTTskEntry *tTsk /* pointer to TAPA task entry */
)
#else
-PUBLIC S16 ssdDetachTTsk(tTsk)
+S16 ssdDetachTTsk(tTsk)
SsTTskEntry *tTsk; /* pointer to TAPA task entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdCreateSTsk
+S16 ssdCreateSTsk
(
SsSTskEntry *sTsk /* pointer to system task entry */
)
#else
-PUBLIC S16 ssdCreateSTsk(sTsk)
+S16 ssdCreateSTsk(sTsk)
SsSTskEntry *sTsk; /* pointer to system task entry */
#endif
{
#ifdef ANSI
-PUBLIC int SCreatePThread
+int SCreatePThread
(
pthread_t* tid,
pthread_attr_t* attr,
void* arg
)
#else
-PUBLIC int SCreatePThread(tid, attr, start_routine, arg)
+int SCreatePThread(tid, attr, start_routine, arg)
pthread_t* tid;
pthread_attr_t* attr;
void *(*start_routine) (void *);
*
*/
#ifdef ANSI
-PUBLIC S16 ssdGetAffinity
+S16 ssdGetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
U32 *coreId /* the core/processor id to which the affinity is set */
)
#else
-PUBLIC S16 ssdGetAffinity(tskId, coreId)
+S16 ssdGetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
U32 *coreId; /* the core/processor id to which the affinity is set */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssdSetAffinity
+S16 ssdSetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
U32 coreId /* the core/processor id to which the affinity has to be set */
)
#else
-PUBLIC S16 ssdSetAffinity(tskId, coreId)
+S16 ssdSetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
U32 coreId; /* the core/processor id to which the affinity has to be set */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDestroySTsk
+S16 ssdDestroySTsk
(
SsSTskEntry *sTsk /* pointer to system task entry */
)
#else
-PUBLIC S16 ssdDestroySTsk(sTsk)
+S16 ssdDestroySTsk(sTsk)
SsSTskEntry *sTsk; /* pointer to system task entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SThreadYield
+S16 SThreadYield
(
void
)
#else
-PUBLIC S16 SThreadYield()
+S16 SThreadYield()
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdRegTmr
+S16 ssdRegTmr
(
SsTmrEntry *tmr /* pointer to timer entry */
)
#else
-PUBLIC S16 ssdRegTmr(tmr)
+S16 ssdRegTmr(tmr)
SsTmrEntry *tmr; /* pointer to timer entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDeregTmr
+S16 ssdDeregTmr
(
SsTmrEntry *tmr /* pointer to timer entry */
)
#else
-PUBLIC S16 ssdDeregTmr(tmr)
+S16 ssdDeregTmr(tmr)
SsTmrEntry *tmr; /* pointer to timer entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdError
+S16 ssdError
(
Seq seq, /* sequence number */
Reason reason /* reset reason */
)
#else
-PUBLIC S16 ssdError(seq, reason)
+S16 ssdError(seq, reason)
Seq seq; /* sequence number */
Reason reason; /* reset reason */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void ssdLogError
+Void ssdLogError
(
Ent ent, /* Calling layer's entity id */
Inst inst, /* Calling layer's instance id */
Txt *errDesc /* description of error */
)
#else
-PUBLIC Void ssdLogError(ent, inst, procId, file, line,
+Void ssdLogError(ent, inst, procId, file, line,
errCls, errCode, errVal, errDesc)
Ent ent; /* Calling layer's entity id */
Inst inst; /* Calling layer's instance id */
*
*/
#ifdef ANSI
-PUBLIC S16 ssdRegDrvrTsk
+S16 ssdRegDrvrTsk
(
SsDrvrTskEntry *drvrTsk /* driver task entry */
)
#else
-PUBLIC S16 ssdRegDrvrTsk(drvrTsk)
+S16 ssdRegDrvrTsk(drvrTsk)
SsDrvrTskEntry *drvrTsk; /* driver task entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDeregDrvrTsk
+S16 ssdDeregDrvrTsk
(
SsDrvrTskEntry *drvrTsk /* driver task entry */
)
#else
-PUBLIC S16 ssdDeregDrvrTsk(drvrTsk)
+S16 ssdDeregDrvrTsk(drvrTsk)
SsDrvrTskEntry *drvrTsk; /* driver task entry */
#endif
{
*/
#ifdef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 ssdProcTTskTerm
+S16 ssdProcTTskTerm
(
ProcId procIdx,
SsTTskEntry *tTsk,
SsIdx idx
)
#else
-PUBLIC S16 ssdProcTTskTerm(procIdx, tTsk, idx)
+S16 ssdProcTTskTerm(procIdx, tTsk, idx)
ProcId procIdx;
SsTTskEntry *tTsk;
SsIdx idx;
#endif
#else /*SS_MULTIPLE_PROCS*/
#ifdef ANSI
-PUBLIC S16 ssdProcTTskTerm
+S16 ssdProcTTskTerm
(
SsTTskEntry *tTsk,
SsIdx idx
)
#else
-PUBLIC S16 ssdProcTTskTerm(tTsk, idx)
+S16 ssdProcTTskTerm(tTsk, idx)
SsTTskEntry *tTsk;
SsIdx idx;
#endif
EXTERN Void ysMtPollPhyMsg(U8 region);
EXTERN Void ysMtRcvPhyMsg(Void);
#ifdef ANSI
-PUBLIC Void *mtTskHdlrT2kL2
+Void *mtTskHdlrT2kL2
(
Ptr tskPtr /* pointer to task entry */
)
#else
-PUBLIC Void *mtTskHdlrT2kL2(tskPtr)
+Void *mtTskHdlrT2kL2(tskPtr)
Ptr tskPtr; /* pointer to task entry */
#endif
{
EXTERN Void ysMtTskHdlr(Void);
EXTERN Void YsPhyRecvMsg();
#ifdef ANSI
-PUBLIC Void *mtTskHdlrT2kL2
+Void *mtTskHdlrT2kL2
(
Ptr tskPtr /* pointer to task entry */
)
#else
-PUBLIC Void *mtTskHdlrT2kL2(tskPtr)
+Void *mtTskHdlrT2kL2(tskPtr)
Ptr tskPtr; /* pointer to task entry */
#endif
{
#endif
#ifdef ANSI
-PUBLIC void *pthreadCreateHdlr
+void *pthreadCreateHdlr
(
void * arg
)
#else
-PUBLIC void *pthreadCreateHdlr(pthreadCreateArg)
+void *pthreadCreateHdlr(pthreadCreateArg)
void *arg;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void *mtTskHdlr
+Void *mtTskHdlr
(
Ptr tskPtr /* pointer to task entry */
)
#else
-PUBLIC Void *mtTskHdlr(tskPtr)
+Void *mtTskHdlr(tskPtr)
Ptr tskPtr; /* pointer to task entry */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 mtTskHdlMsg
+S16 mtTskHdlMsg
(
SsSTskEntry *sTsk
)
#else
-PUBLIC S16 mtTskHdlMsg(sTsk)
+S16 mtTskHdlMsg(sTsk)
SsSTskEntry *sTsk
#endif
{
* Fun: mtTmrHdlrPublic
*/
#ifdef ANSI
-PUBLIC Void mtTmrHdlrPublic
+Void mtTmrHdlrPublic
(
)
#else
-PUBLIC Void mtTmrHdlrPublic()
+Void mtTmrHdlrPublic()
#endif
{
if (SLock(&osCp.tmrTblLock) != ROK)
*
*/
#ifdef ANSI
-PUBLIC Void mtTimeout
+Void mtTimeout
(
PTR tCb, /* control block */
S16 evnt /* event */
)
#else
-PUBLIC Void mtTimeout(tCb, evnt)
+Void mtTimeout(tCb, evnt)
PTR tCb; /* control block */
S16 evnt; /* event */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void mtIntSigHndlr
+Void mtIntSigHndlr
(
int arg
)
#else
-PUBLIC Void mtIntSigHndlr(arg)
+Void mtIntSigHndlr(arg)
int arg;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void mtExitClnup
+Void mtExitClnup
(
void
)
#else
-PUBLIC Void mtExitClnup()
+Void mtExitClnup()
#endif
{
Ticks ticks;
*
*/
#ifdef ANSI
-PUBLIC S16 SDisplay
+S16 SDisplay
(
S16 chan, /* channel */
Txt *buf /* buffer */
)
#else
-PUBLIC S16 SDisplay(chan, buf)
+S16 SDisplay(chan, buf)
S16 chan; /* channel */
Txt *buf; /* buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SFini
+S16 SFini
(
void
)
#else
-PUBLIC S16 SFini()
+S16 SFini()
#endif
{
TRC1(SFini);
*
*/
#ifdef ANSI
-PUBLIC S16 SSetDateTime
+S16 SSetDateTime
(
REG1 DateTime *dt /* date and time */
)
#else
-PUBLIC S16 SSetDateTime(dt)
+S16 SSetDateTime(dt)
REG1 DateTime *dt; /* date and time */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SGetDateTime
+S16 SGetDateTime
(
REG1 DateTime *dt /* date and time */
)
#else
-PUBLIC S16 SGetDateTime(dt)
+S16 SGetDateTime(dt)
REG1 DateTime *dt; /* date and time */
#endif
{
*/
/* mt003.301 Modifications */
#ifdef ANSI
-PUBLIC S16 SGetEpcTime
+S16 SGetEpcTime
(
EpcTime *et /* date and time */
)
#else
-PUBLIC S16 SGetEpcTime(et)
+S16 SGetEpcTime(et)
EpcTime *et; /* date and time */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SGetSysTime
+S16 SGetSysTime
(
Ticks *sysTime /* system time */
)
#else
-PUBLIC S16 SGetSysTime(sysTime)
+S16 SGetSysTime(sysTime)
Ticks *sysTime; /* system time */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SGetRefTime
+S16 SGetRefTime
(
U32 refTime, /* reference time */
U32 *sec,
U32 *usec
)
#else
-PUBLIC S16 SGetRefTime(refTime, sec, usec)
+S16 SGetRefTime(refTime, sec, usec)
U32 refTime; /* reference time */
U32 *sec;
U32 *usec;
*
*/
#ifdef ANSI
-PUBLIC S16 SRandom
+S16 SRandom
(
Random *value /* random number */
)
#else
-PUBLIC S16 SRandom(value)
+S16 SRandom(value)
Random *value; /* random number */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SExitTsk
+S16 SExitTsk
(
void
)
#else
-PUBLIC S16 SExitTsk()
+S16 SExitTsk()
#endif
{
TRC1(SExitTsk);
*
*/
#ifdef ANSI
-PUBLIC S16 SExitInt
+S16 SExitInt
(
void
)
#else
-PUBLIC S16 SExitInt()
+S16 SExitInt()
#endif
{
TRC1(SExitInt);
*
*/
#ifdef ANSI
-PUBLIC S16 SHoldInt
+S16 SHoldInt
(
void
)
#else
-PUBLIC S16 SHoldInt()
+S16 SHoldInt()
#endif
{
TRC1(SHoldInt);
*
*/
#ifdef ANSI
-PUBLIC S16 SRelInt
+S16 SRelInt
(
void
)
#else
-PUBLIC S16 SRelInt()
+S16 SRelInt()
#endif
{
TRC1(SRelInt);
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SEnbInt
+INLINE S16 SEnbInt
(
void
)
#else
-PUBLIC INLINE S16 SEnbInt()
+INLINE S16 SEnbInt()
#endif
{
TRC1(SEnbInt);
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SDisInt
+INLINE S16 SDisInt
(
void
)
#else
-PUBLIC INLINE S16 SDisInt()
+INLINE S16 SDisInt()
#endif
{
TRC1(SDisInt);
*
*/
#ifdef ANSI
-PUBLIC S16 SGetVect
+S16 SGetVect
(
VectNmb vectNmb, /* vector number */
PIF *vectFnct /* vector function */
)
#else
-PUBLIC S16 SGetVect(vectNmb, vectFnct)
+S16 SGetVect(vectNmb, vectFnct)
VectNmb vectNmb; /* vector number */
PIF *vectFnct; /* vector function */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SPutVect
+S16 SPutVect
(
VectNmb vectNmb, /* vector number */
PIF vectFnct /* vector function */
)
#else
-PUBLIC S16 SPutVect(vectNmb, vectFnct)
+S16 SPutVect(vectNmb, vectFnct)
VectNmb vectNmb; /* vector number */
PIF vectFnct; /* vector function */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGetEntInst
+S16 SGetEntInst
(
Ent *ent, /* entity */
Inst *inst /* instance */
)
#else
-PUBLIC S16 SGetEntInst(ent, inst)
+S16 SGetEntInst(ent, inst)
Ent *ent; /* entity */
Inst *inst; /* instance */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SSetEntInst
+S16 SSetEntInst
(
Ent ent, /* entity */
Inst inst /* instance */
)
#else
-PUBLIC S16 SSetEntInst(ent, inst)
+S16 SSetEntInst(ent, inst)
Ent ent; /* entity */
Inst inst; /* instance */
#endif
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SSetIntPend
+INLINE S16 SSetIntPend
(
U16 id, /* driver task identifier */
Bool flag /* flag */
)
#else
-PUBLIC INLINE S16 SSetIntPend(id, flag)
+INLINE S16 SSetIntPend(id, flag)
U16 id; /* driver task identifier */
Bool flag; /* flag */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGlobMemInfoShow
+S16 SGlobMemInfoShow
(
Void
)
#else
-PUBLIC S16 SGlobMemInfoShow()
+S16 SGlobMemInfoShow()
#endif
{
U16 idx;
*
*/
#ifdef ANSI
-PUBLIC S16 SRegInfoShow
+S16 SRegInfoShow
(
Region region,
U32 *availmem
)
#else
-PUBLIC S16 SRegInfoShow(region, availmem)
+S16 SRegInfoShow(region, availmem)
Region region;
U32 *availmem;
#endif
}
#ifdef ANSI
-PUBLIC S16 SRegReachedMemThreshold
+S16 SRegReachedMemThreshold
(
Region region,
U8 maxBkt
)
#else
-PUBLIC S16 SRegReachedMemThreshold(region, maxBkt)
+S16 SRegReachedMemThreshold(region, maxBkt)
Region region;
U8 maxBkt;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGetRegInfo
+S16 SGetRegInfo
(
Region region,
SsMemDbgInfo *dbgInfo
)
#else
-PUBLIC S16 SGetRegInfo(region, dbgInfo)
+S16 SGetRegInfo(region, dbgInfo)
Region region;
SsMemDbgInfo *dbgInfo;
#endif
}
#ifdef ANSI
-PUBLIC S16 SGetRegPoolInfo
+S16 SGetRegPoolInfo
(
U8 *numRegion,
U8 *numPool
)
#else
-PUBLIC S16 SGetRegPoolInfo(numRegion, numPool)
+S16 SGetRegPoolInfo(numRegion, numPool)
U8 *numRegion;
U8 *numPool;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SPrintRegMemStatusInfo
+S16 SPrintRegMemStatusInfo
(
Region region,
U8 typeFlag
)
#else
-PUBLIC S16 SPrintRegMemStatusInfo(region, typeFlag)
+S16 SPrintRegMemStatusInfo(region, typeFlag)
Region region;
U8 typeFlag;
#endif
*
*/
#ifdef ANSI
-PUBLIC Void SRegMemErrHdlr
+Void SRegMemErrHdlr
(
Region region,
Data *ptr,
S16 errCode
)
#else
-PUBLIC Void SRegMemErrHdlr(region, ptr, errCode)
+Void SRegMemErrHdlr(region, ptr, errCode)
Region region;
Data *ptr;
S16 errCode;
*
*/
#ifdef ANSI
-PUBLIC S16 SPrintRegMemProfile
+S16 SPrintRegMemProfile
(
Region region
)
#else
-PUBLIC S16 SPrintRegMemProfile(region)
+S16 SPrintRegMemProfile(region)
Region region;
#endif
{
*
--*/
#ifdef ANSI
-PUBLIC S16 SGetTimeStamp
+S16 SGetTimeStamp
(
S8 *ts
)
#else
-PUBLIC S16 SGetTimeStamp(ts)
+S16 SGetTimeStamp(ts)
S8 *ts;
#endif
{
*
--*/
#ifdef ANSI
-PUBLIC U32 SGetSystemTsk
+U32 SGetSystemTsk
(
Void
)
#else
-PUBLIC U32 SGetSystemTsk()
+U32 SGetSystemTsk()
#endif
{
TRC1(SGetSystemTskS);
*
*/
#ifdef ANSI
-PUBLIC S16 ssdInitLockNew
+S16 ssdInitLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdInitLockNew(lockId, lockType)
+S16 ssdInitLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssdLockNew
+S16 ssdLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdLockNew(lockId, lockType)
+S16 ssdLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssdUnlockNew
+S16 ssdUnlockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdUnlockNew(lockId, lockType)
+S16 ssdUnlockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssdDestroyLockNew
+S16 ssdDestroyLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 ssdDestroyLockNew(lockId, lockType)
+S16 ssdDestroyLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 ssInitRcvWork
+S16 ssInitRcvWork
(
void
)
#else
-PUBLIC S16 ssInitRcvWork()
+S16 ssInitRcvWork()
#endif
{
pthread_attr_t attr;
#endif /* SS_SEUM_CAVIUM */
#ifdef TENB_RTLIN_CHANGES
-PUBLIC S16 SInitLock(SLockId *l, U8 t)
+S16 SInitLock(SLockId *l, U8 t)
{
S16 r = 0;
pthread_mutexattr_t prior;
*
*/
-PUBLIC Void ssRegMainThread(Void)
+Void ssRegMainThread(Void)
{
if(SS_INVALID_THREAD_REG_MAP != SS_GET_THREAD_MEM_REGION())
* File: mt_ss.c
*
*/
-PUBLIC S32 ssCheckAndAddMemoryRegionMap
+S32 ssCheckAndAddMemoryRegionMap
(
pthread_t threadId, /* Thread Id of system task */
Region region /* Region associated with thread */
* File: mt_ss.c
*
*/
-PUBLIC S32 ssCheckAndDelMemoryRegionMap
+S32 ssCheckAndDelMemoryRegionMap
(
pthread_t threadId /* Thread Id of system task */
)
*
*/
#ifdef ANSI
-PUBLIC S16 SStartTask
+S16 SStartTask
(
VOLATILE U32 *startTime,
U32 taskId
)
#else
-PUBLIC S16 SStartTask(startTime, taskId)
+S16 SStartTask(startTime, taskId)
VOLATILE U32 *startTime;
U32 taskId;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SStopTask
+S16 SStopTask
(
VOLATILE U32 startTime,
U32 taskId
)
#else
-PUBLIC S16 SStopTask(startTime, taskId)
+S16 SStopTask(startTime, taskId)
VOLATILE U32 startTime;
U32 taskId;
#endif
}
#else
#ifdef ANSI
-PUBLIC S16 SStartTask
+S16 SStartTask
(
VOLATILE U32 * startTime,
U32 taskId
)
#else
-PUBLIC S16 SStartTask(startTime, taskId)
+S16 SStartTask(startTime, taskId)
VOLATILE U32 * startTime;
U32 taskId;
#endif
}
#ifdef ANSI
-PUBLIC S16 SStopTask
+S16 SStopTask
(
VOLATILE U32 startTime,
U32 taskId
)
#else
-PUBLIC S16 SStopTask(startTime, taskId)
+S16 SStopTask(startTime, taskId)
VOLATILE U32 startTime;
U32 taskId;
#endif
* @return Void - function is always success
*/
#ifdef ANSI
-PUBLIC Void UpdateSocCpuInfo
+Void UpdateSocCpuInfo
(
CmCpuStatsInfo *cpuInfo,
U8 idx
)
#else
-PUBLIC Void UpdateSocCpuInfo(*cpuInfo, idx)
+Void UpdateSocCpuInfo(*cpuInfo, idx)
CmCpuStatsInfo *cpuInfo;
U8 idx;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssdReInitTmr
+S16 ssdReInitTmr
(
void
)
#else
-PUBLIC S16 ssdReInitTmr()
+S16 ssdReInitTmr()
#endif
{
pthread_attr_t attr;
*
*/
#ifdef ANSI
-PUBLIC S16 SRegDrvrTsk
+S16 SRegDrvrTsk
(
Inst channel, /* channel instance */
ProcId low, /* processor ID -- low */
ISTsk isTsk /* interrupt service function */
)
#else
-PUBLIC S16 SRegDrvrTsk(channel, low, high, actvTsk, isTsk)
+S16 SRegDrvrTsk(channel, low, high, actvTsk, isTsk)
Inst channel; /* channel instance */
ProcId low; /* processor ID -- low */
ProcId high; /* processor ID -- high */
*
*/
#ifdef ANSI
-PUBLIC S16 SDeregDrvrTsk
+S16 SDeregDrvrTsk
(
Inst channel /* channel instance */
)
#else
-PUBLIC S16 SDeregDrvrTsk(channel)
+S16 SDeregDrvrTsk(channel)
Inst channel;
#endif
{
/*ss014.301: SSI-4GMX related changes*/
#ifdef SS_4GMX_LCORE
-PUBLIC VOLATILE SsOs osCp; /* common OS control point */
+VOLATILE SsOs osCp; /* common OS control point */
#else
-PUBLIC SsOs osCp; /* common OS control point */
+SsOs osCp; /* common OS control point */
#endif
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
PRIVATE void InitializeForStaticMemLeak ARGS((void));
PRIVATE void InitializeStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo));
-PUBLIC U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
-PUBLIC void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo* memAllocInfo,U32 size, char*
+U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
+void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo* memAllocInfo,U32 size, char*
file, U32 line));
-PUBLIC void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char* file,
+void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char* file,
U32 line, U32 size, void* ptr, U32 idx));
PRIVATE void PrintStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo, FILE
*opFile));
#endif
/* ss001.301: additions */
-PUBLIC void DumpSSIDemandQDebugInformation()
+void DumpSSIDemandQDebugInformation()
{
U32 i,j;
RTLIN_DUMP_DEBUG("Demand Q Information\n");
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
pthread_mutex_t dumpingLock = PTHREAD_MUTEX_INITIALIZER;
-PUBLIC Void mtSigSegvHndlr()
+Void mtSigSegvHndlr()
{
int i;
sleep(5);
}
-PUBLIC Void mtSigUsr2Hndlr()
+Void mtSigUsr2Hndlr()
{
printf("Backtrace for thread Id (%lu) cause:SIGUSR2(%d)\n",(unsigned long) pthread_self(),SIGUSR2);
*
*/
#ifdef ANSI
-PUBLIC S16 SInit
+S16 SInit
(
void
)
#else
-PUBLIC S16 SInit()
+S16 SInit()
#endif
{
S16 ret;
*
*/
#ifdef ANSI
-PUBLIC S16 SDeInit
+S16 SDeInit
(
void
)
#else
-PUBLIC S16 SDeInit()
+S16 SDeInit()
#endif
{
/* ss007.301 */
/* ss001.301: additions */
#ifdef SS_LOGGER_SUPPORT
#ifdef ANSI
-PUBLIC S16 SWrtLogBuf
+S16 SWrtLogBuf
(
Txt *buf /* buffer */
)
#else
-PUBLIC S16 SWrtLogBuf(buf)
+S16 SWrtLogBuf(buf)
Txt *buf; /* buffer */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SPrint
+S16 SPrint
(
Txt *buf /* buffer */
)
#else
-PUBLIC S16 SPrint(buf)
+S16 SPrint(buf)
Txt *buf; /* buffer */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SError
+S16 SError
(
Seq seq, /* sequence */
Reason reason /* reason */
)
#else
-PUBLIC S16 SError(seq, reason)
+S16 SError(seq, reason)
Seq seq; /* sequence */
Reason reason; /* reason */
#endif
*
*/
#ifdef ANSI
-PUBLIC Void SLogError
+Void SLogError
(
Ent ent, /* Calling layer's entity id */
Inst inst, /* Calling layer's instance id */
Txt *errDesc /* description of error */
)
#else
-PUBLIC Void SLogError(ent, inst, procId, file, line,
+Void SLogError(ent, inst, procId, file, line,
errCls, errCode, errVal, errDesc)
Ent ent; /* Calling layer's entity id */
Inst inst; /* Calling layer's instance id */
*
*/
#ifdef ANSI
-PUBLIC ProcId SFndProcId
+ProcId SFndProcId
(
void
)
#else
-PUBLIC ProcId SFndProcId()
+ProcId SFndProcId()
#endif
{
TRC1(SFndProcId);
*
*/
#ifdef ANSI
-PUBLIC Void SSetProcId
+Void SSetProcId
(
ProcId procId
)
#else
-PUBLIC Void SSetProcId(procId)
+Void SSetProcId(procId)
ProcId procId;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC U16 SGetProcIdIdx
+U16 SGetProcIdIdx
(
ProcId proc
)
#else
-PUBLIC U16 SGetProcIdIdx(proc)
+U16 SGetProcIdIdx(proc)
ProcId proc;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SAddProcIdLst
+S16 SAddProcIdLst
(
U16 numPIds,
ProcId *pIdLst
)
#else
-PUBLIC S16 SAddProcIdLst(numPIds, pIdLst)
+S16 SAddProcIdLst(numPIds, pIdLst)
U16 numPIds;
ProcId *pIdLst;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SRemProcIdLst
+S16 SRemProcIdLst
(
U16 numPIds,
ProcId *pIdLst
)
#else
-PUBLIC S16 SRemProcIdLst(numPIds, pIdLst)
+S16 SRemProcIdLst(numPIds, pIdLst)
U16 numPIds;
ProcId *pIdLst;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGetProcIdLst
+S16 SGetProcIdLst
(
U16 *numPIds,
ProcId *pIdLst
)
#else
-PUBLIC S16 SGetProcIdLst(numPIds, pIdLst)
+S16 SGetProcIdLst(numPIds, pIdLst)
U16 *numPIds;
ProcId *pIdLst;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGetXxCb
+S16 SGetXxCb
(
ProcId proc,
Ent ent,
Void **xxCb
)
#else
-PUBLIC S16 SGetXxCb(proc, ent, inst, xxCb)
+S16 SGetXxCb(proc, ent, inst, xxCb)
ProcId proc;
Ent ent;
Inst inst;
*
*/
#ifdef ANSI
-PUBLIC S16 SFillEntIds
+S16 SFillEntIds
(
Void
)
#else
-PUBLIC S16 SFillEntIds(Void)
+S16 SFillEntIds(Void)
#endif
{
W X Y Z */
{ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
/* K */ ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
- ENTKW, ENTNC, ENTNC, ENTNC},
+ ENTRLC, ENTNC, ENTNC, ENTNC},
/* A B C D E F G H I J K *
L M N O P Q R S T U V *
W X Y Z */
*
*/
#ifdef ANSI
-PUBLIC S16 SGetEntInd
+S16 SGetEntInd
(
Ent *entId,
U8 *fileName
)
#else
-PUBLIC S16 SGetEntInd(entId, fileName)
+S16 SGetEntInd(entId, fileName)
Ent *entId;
U8 *fileName;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SLockNew
+S16 SLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SLockNew(lockId, lockType)
+S16 SLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SInitLockNew
+S16 SInitLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SInitLockNew(lockId, lockType)
+S16 SInitLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SUnlockNew
+S16 SUnlockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SUnlockNew(lockId, lockType)
+S16 SUnlockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SDestroyLockNew
+S16 SDestroyLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SDestroyLockNew(lockId, lockType)
+S16 SDestroyLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
}
}
-PUBLIC void DumpStaticMemLeakFiles()
+void DumpStaticMemLeakFiles()
{
int i;
*
*/
#ifdef ANSI
-PUBLIC S16 SReInitTmr
+S16 SReInitTmr
(
void
)
#else
-PUBLIC S16 SReInitTmr()
+S16 SReInitTmr()
#endif
{
U8 ret = ROK;
* File: ss_gen.c
*
*/
-PUBLIC S8* SGetConfigPath(Void)
+S8* SGetConfigPath(Void)
{
return osCp.configFilePath;
}
*
*/
#ifdef ANSI
-PUBLIC S16 SRegDynRegion
+S16 SRegDynRegion
(
Region region, /* region ID */
SRegInfo *regInfo /* information about the region */
)
#else
-PUBLIC S16 SRegDynRegion(region, regInfo)
+S16 SRegDynRegion(region, regInfo)
Region region; /* region ID */
SRegInfo *regInfo; /* information about the region */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SRegRegion
+S16 SRegRegion
(
Region region, /* region ID */
SRegInfo *regInfo /* information about the region */
)
#else
-PUBLIC S16 SRegRegion(region, regInfo)
+S16 SRegRegion(region, regInfo)
Region region; /* region ID */
SRegInfo *regInfo; /* information about the region */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SDeregRegion
+S16 SDeregRegion
(
Region region /* region ID */
)
#else
-PUBLIC S16 SDeregRegion(region)
+S16 SDeregRegion(region)
Region region; /* region ID */
#endif
{
/* ss001.301: Additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 SAlloc
+S16 SAlloc
(
Region region, /* region ID */
Size *size, /* size of block required/allocated */
U8 entId
)
#else
-PUBLIC S16 SAlloc(region, size, flags, ptr, line, fileName, entId)
+S16 SAlloc(region, size, flags, ptr, line, fileName, entId)
Region region; /* region ID */
Size *size; /* size of block required/allocated */
U32 flags; /* allocation flags */
#endif
#else
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAllocNew
+S16 SAllocNew
(
Region region, /* region ID */
Size *size, /* size of block required/allocated */
)
#else
#ifdef ANSI
-PUBLIC S16 SAlloc
+S16 SAlloc
(
Region region, /* region ID */
Size *size, /* size of block required/allocated */
Data **ptr /* filled with pointer to block */
)
#else
-PUBLIC S16 SAlloc(region, size, flags, ptr)
+S16 SAlloc(region, size, flags, ptr)
Region region; /* region ID */
Size *size; /* size of block required/allocated */
U32 flags; /* allocation flags */
/* ss001.301: Additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 SFree
+S16 SFree
(
Region region, /* region ID */
Data *ptr, /* pointer to the allocated block */
U8 entId
)
#else
-PUBLIC S16 SFree(region, ptr, size, line, fileName, entId)
+S16 SFree(region, ptr, size, line, fileName, entId)
Region region; /* region ID */
Data *ptr; /* pointer to the allocated block */
Size size; /* size of block */
#else
#ifdef ANSI
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SFreeNew
+S16 SFreeNew
(
Region region, /* region ID */
Data *ptr, /* pointer to the allocated block */
U32 line
)
#else
-PUBLIC S16 SFree
+S16 SFree
(
Region region, /* region ID */
Data *ptr, /* pointer to the allocated block */
)
#endif
#else
-PUBLIC S16 SFree(region, ptr, size)
+S16 SFree(region, ptr, size)
Region region; /* region ID */
Data *ptr; /* pointer to the allocated block */
Size size; /* size of block */
*
*/
#ifdef ANSI
-PUBLIC S16 SHstGrmInfoShow
+S16 SHstGrmInfoShow
(
Ent *entId
)
#else
-PUBLIC S16 SHstGrmInfoShow(entId)
+S16 SHstGrmInfoShow(entId)
Ent *entId;
#endif
{
#include "mt_plat_t33.x"
#endif
/* forward declarations */
-PUBLIC S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
-PUBLIC S16 SIncMsgRef(Buffer *srcBuf,Region dstRegion, Pool dstPool,Buffer **dstBuf);
+S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
+S16 SIncMsgRef(Buffer *srcBuf,Region dstRegion, Pool dstPool,Buffer **dstBuf);
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
-EXTERN PUBLIC U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
-EXTERN PUBLIC void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char*
+EXTERN U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
+EXTERN void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char*
file, U32 line, U32 size, void* ptr, U32 idx));
-EXTERN PUBLIC void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo*
+EXTERN void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo*
memAllocInfo,U32 size, char* file, U32 line));
#endif
#else
PRIVATE S16 SPutZbcDBuf ARGS((Region region, Buffer *buf));
-PUBLIC S16 SAttachPtrToBuf ARGS(( Region region, Pool pool, Data *ptr,
+S16 SAttachPtrToBuf ARGS(( Region region, Pool pool, Data *ptr,
MsgLen totalLen, Buffer** mBuf));
#endif
#endif
#else
#ifdef INTEL_WLS
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAttachPtrToMBuf1 ARGS(( Region region, Pool pool, Data *ptr, MsgLen totalLen,
+S16 SAttachPtrToMBuf1 ARGS(( Region region, Pool pool, Data *ptr, MsgLen totalLen,
MsgLen ptrLen, Buffer** mBuf, char* file, U32 line));
#else
-PUBLIC S16 SAttachPtrToMBuf ARGS(( Region region, Pool pool, Data *ptr, MsgLen totalLen,
+S16 SAttachPtrToMBuf ARGS(( Region region, Pool pool, Data *ptr, MsgLen totalLen,
MsgLen ptrLen, Buffer** mBuf));
#endif
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAttachWlsPtrToMBuf1 ARGS(( Region region, Pool pool, Data *ptr,
+S16 SAttachWlsPtrToMBuf1 ARGS(( Region region, Pool pool, Data *ptr,
Data *readPtr, MsgLen totalLen,
MsgLen ptrLen, Buffer** mBuf, char* file, U32 line));
-PUBLIC S16 SAttachWlsPtrToMBuf ARGS(( Region region, Pool pool, Data *ptr,
+S16 SAttachWlsPtrToMBuf ARGS(( Region region, Pool pool, Data *ptr,
Data *readPtr, MsgLen totalLen,
MsgLen ptrLen, Buffer** mBuf));
#endif
#ifdef TENB_DPDK_BUF
-PUBLIC S16 SDetachDpdkPtrFrmMBuf ARGS((Buffer *mBuf, Data **ptr));
-PUBLIC S16 SDetachDpdkPtrFrmDBuf ARGS((Buffer *mBuf, Data **ptr));
-PUBLIC S16 SPutSBufDpdk ARGS(( Data *ptr));
+S16 SDetachDpdkPtrFrmMBuf ARGS((Buffer *mBuf, Data **ptr));
+S16 SDetachDpdkPtrFrmDBuf ARGS((Buffer *mBuf, Data **ptr));
+S16 SPutSBufDpdk ARGS(( Data *ptr));
#endif /* TENB_DPDK_BUF */
*
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 ssGetDBufOfSizeNew
+S16 ssGetDBufOfSizeNew
(
Region region,
Size size,
)
#else
#ifdef ANSI
-PUBLIC S16 ssGetDBufOfSize
+S16 ssGetDBufOfSize
(
Region region,
Size size,
Buffer **dBuf
)
#else
-PUBLIC S16 ssGetDBufOfSize(region, size, dBuf)
+S16 ssGetDBufOfSize(region, size, dBuf)
Region region;
Size size;
Buffer **dBuf;
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 SGetMsgNew
+S16 SGetMsgNew
(
Region region, /* region id */
Pool pool, /* pool id */
U8 *fileName
)
#else
-PUBLIC S16 SGetMsgNew(region, pool, mBuf, line, fileName)
+S16 SGetMsgNew(region, pool, mBuf, line, fileName)
Region region; /* region id */
Pool pool; /* pool id */
Buffer **mBuf; /* pointer to message buffer */
#endif
#else /* SS_HISTOGRAM_SUPPORT */
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SGetMsgNew
+S16 SGetMsgNew
(
Region region, /* region id */
Pool pool, /* pool id */
)
#else
#ifdef ANSI
-PUBLIC S16 SGetMsg
+S16 SGetMsg
(
Region region, /* region id */
Pool pool, /* pool id */
Buffer **mBuf /* pointer to message buffer */
)
#else
-PUBLIC S16 SGetMsg(region, pool, mBuf)
+S16 SGetMsg(region, pool, mBuf)
Region region; /* region id */
Pool pool; /* pool id */
Buffer **mBuf; /* pointer to message buffer */
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 SPutMsgNew
+S16 SPutMsgNew
(
Buffer *mBuf,
U32 line,
U8 *fileName
)
#else
-PUBLIC S16 SPutMsgNew(mBuf, line, fileName)
+S16 SPutMsgNew(mBuf, line, fileName)
Buffer *mBuf;
U32 line;
U8 *fileName;
#endif
#else /* SS_HISTOGRAM_SUPPORT */
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SPutMsgNew
+S16 SPutMsgNew
(
Buffer *mBuf,
char* file,
)
#else
#ifdef ANSI
-PUBLIC S16 SPutMsg
+S16 SPutMsg
(
Buffer *mBuf
)
#else
-PUBLIC S16 SPutMsg(mBuf)
+S16 SPutMsg(mBuf)
Buffer *mBuf;
#endif
#endif
*/
/* ss001.301: additions */
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SPutStaticBufferNew
+S16 SPutStaticBufferNew
(
Region region, /* region ID */
Pool pool, /* pool ID */
)
#else
#ifdef ANSI
-PUBLIC S16 SPutStaticBuffer
+S16 SPutStaticBuffer
(
Region region, /* region ID */
Pool pool, /* pool ID */
U8 memType /* memory type used if shareable or not */
)
#else
-PUBLIC S16 SPutStaticBuffer(region, pool, ptr, size)
+S16 SPutStaticBuffer(region, pool, ptr, size)
Region region; /* region ID */
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
*
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SGetStaticBufferNew
+S16 SGetStaticBufferNew
(
Region region, /* region ID */
Pool pool, /* pool ID */
)
#else
#ifdef ANSI
-PUBLIC S16 SGetStaticBuffer
+S16 SGetStaticBuffer
(
Region region, /* region ID */
Pool pool, /* pool ID */
U8 memType /* memory type used if shareable or not */
)
#else
-PUBLIC S16 SGetStaticBuffer(region, pool, ptr, size)
+S16 SGetStaticBuffer(region, pool, ptr, size)
Region region; /* region ID */
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
#ifdef INTEL_WLS
#ifndef SS_LOCKLESS_MEMORY
#ifdef ANSI
-PUBLIC S16 SGetStaticBuffer
+S16 SGetStaticBuffer
(
Region region, /* region ID */
Pool pool, /* pool ID */
U8 memType /* memory type used if shareable or not */
)
#else
-PUBLIC S16 SGetStaticBuffer(region, pool, ptr, size)
+S16 SGetStaticBuffer(region, pool, ptr, size)
Region region; /* region ID */
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
#ifdef ANSI
-PUBLIC S16 SPutStaticBuffer
+S16 SPutStaticBuffer
(
Region region, /* region ID */
Pool pool, /* pool ID */
U8 memType /* memory type used if shareable or not */
)
#else
-PUBLIC S16 SPutStaticBuffer(region, pool, ptr, size)
+S16 SPutStaticBuffer(region, pool, ptr, size)
Region region; /* region ID */
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
}
#endif
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SGetSBufWls1
+S16 SGetSBufWls1
(
Region region, /* region ID */
Pool pool, /* pool ID */
U32 line
)
#else
-PUBLIC S16 SGetSBufWls
+S16 SGetSBufWls
(
Region region, /* region ID */
Pool pool, /* pool ID */
}
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SPutSBufWls1
+S16 SPutSBufWls1
(
Region region, /* region ID */
Pool pool, /* pool ID */
U32 line
)
#else
-PUBLIC S16 SPutSBufWls
+S16 SPutSBufWls
(
Region region, /* region ID */
Pool pool, /* pool ID */
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 SGetSBufNew
+S16 SGetSBufNew
(
Region region, /* region ID */
Pool pool, /* pool ID */
U8 *fileName
)
#else
-PUBLIC S16 SGetSBufNew(region, pool, ptr, size, line, fileName)
+S16 SGetSBufNew(region, pool, ptr, size, line, fileName)
Region region; /* region ID */
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
#else /* SS_HISTOGRAM_SUPPORT */
#if (defined(SSI_STATIC_MEM_LEAK_DETECTION) || defined(T2K_MEM_LEAK_DBG))
#ifdef ANSI
-PUBLIC S16 SGetSBuf1
+S16 SGetSBuf1
(
Region region, /* region ID */
Pool pool, /* pool ID */
U32 line
)
#else
-PUBLIC S16 SGetSBuf1(region, pool, ptr, size, file, line)
+S16 SGetSBuf1(region, pool, ptr, size, file, line)
Region region; /* region ID */
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
#endif
#else
#ifdef ANSI
-PUBLIC S16 SGetSBuf
+S16 SGetSBuf
(
Region region, /* region ID */
Pool pool, /* pool ID */
Size size /* size requested */
)
#else
-PUBLIC S16 SGetSBuf(region, pool, ptr, size)
+S16 SGetSBuf(region, pool, ptr, size)
Region region; /* region ID */
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 SPutSBufNew
+S16 SPutSBufNew
(
Region region, /* region ID */
Pool pool, /* pool ID */
U8 *fileName
)
#else
-PUBLIC S16 SPutSBufNew(region, pool, ptr, size, line, fileName)
+S16 SPutSBufNew(region, pool, ptr, size, line, fileName)
Region region; /* region ID */
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
#else /* SS_HISTOGRAM_SUPPORT */
#if (defined(SSI_STATIC_MEM_LEAK_DETECTION) || defined(T2K_MEM_LEAK_DBG))
#ifdef ANSI
-PUBLIC S16 SPutSBuf1
+S16 SPutSBuf1
(
Region region, /* region ID */
Pool pool, /* pool ID */
U32 line
)
#else
-PUBLIC S16 SPutSBuf1(region, pool, ptr, size, file, line)
+S16 SPutSBuf1(region, pool, ptr, size, file, line)
Region region; /* region ID */
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
#endif
#else
#ifdef ANSI
-PUBLIC S16 SPutSBuf
+S16 SPutSBuf
(
Region region, /* region ID */
Pool pool, /* pool ID */
Size size /* size */
)
#else
-PUBLIC S16 SPutSBuf(region, pool, ptr, size)
+S16 SPutSBuf(region, pool, ptr, size)
Region region; /* region ID */
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
*/
#ifdef ANSI
-PUBLIC S16 SInitMsg
+S16 SInitMsg
(
Buffer *mBuf
)
#else
-PUBLIC S16 SInitMsg(mBuf)
+S16 SInitMsg(mBuf)
Buffer *mBuf;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SAddPreMsgMultInOrder
+S16 SAddPreMsgMultInOrder
(
Data *src,
MsgLen cnt,
Buffer *mBuf
)
#else
-PUBLIC S16 SAddPreMsgMultInOrder(src, cnt, mBuf)
+S16 SAddPreMsgMultInOrder(src, cnt, mBuf)
Data *src;
MsgLen cnt;
Buffer *mBuf;
#ifdef ANSI
-PUBLIC S16 SAddPreMsg
+S16 SAddPreMsg
(
Data data,
Buffer *mBuf
)
#else
-PUBLIC S16 SAddPreMsg (data, mBuf)
+S16 SAddPreMsg (data, mBuf)
Data data;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 SAddPstMsg
+S16 SAddPstMsg
(
Data data,
Buffer *mBuf
)
#else
-PUBLIC S16 SAddPstMsg (data, mBuf)
+S16 SAddPstMsg (data, mBuf)
Data data;
Buffer *mBuf;
#endif
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAddPreMsgMult1
+S16 SAddPreMsgMult1
(
Data *src,
MsgLen cnt,
#else
#ifdef ANSI
-PUBLIC S16 SAddPreMsgMult
+S16 SAddPreMsgMult
(
Data *src,
MsgLen cnt,
Buffer *mBuf
)
#else
-PUBLIC S16 SAddPreMsgMult(src, cnt, mBuf)
+S16 SAddPreMsgMult(src, cnt, mBuf)
Data *src;
MsgLen cnt;
Buffer *mBuf;
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAddPstMsgMult1
+S16 SAddPstMsgMult1
(
Data *src,
MsgLen cnt,
)
#else
#ifdef ANSI
-PUBLIC S16 SAddPstMsgMult
+S16 SAddPstMsgMult
(
Data *src,
MsgLen cnt,
Buffer *mBuf
)
#else
-PUBLIC S16 SAddPstMsgMult(src, cnt, mBuf)
+S16 SAddPstMsgMult(src, cnt, mBuf)
Data *src;
MsgLen cnt;
Buffer *mBuf;
#ifdef ANSI
-PUBLIC S16 SRemPreMsg
+S16 SRemPreMsg
(
Data *dataPtr,
Buffer *mBuf
)
#else
-PUBLIC S16 SRemPreMsg(dataPtr, mBuf)
+S16 SRemPreMsg(dataPtr, mBuf)
Data *dataPtr;
Buffer *mBuf;
#endif
#ifdef ANSI
-PUBLIC S16 SRemPstMsg
+S16 SRemPstMsg
(
Data *dataPtr, /* pointer to data */
Buffer *mBuf
)
#else
-PUBLIC S16 SRemPstMsg(dataPtr, mBuf)
+S16 SRemPstMsg(dataPtr, mBuf)
Data *dataPtr; /* pointer to data */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SRemPreMsgMult
+S16 SRemPreMsgMult
(
Data *dst, /* destination */
MsgLen cnt, /* count */
Buffer *mBuf
)
#else
-PUBLIC S16 SRemPreMsgMult(dst, cnt, mBuf)
+S16 SRemPreMsgMult(dst, cnt, mBuf)
Data *dst; /* destination */
MsgLen cnt; /* count */
Buffer *mBuf; /* message buffer */
*/
#ifdef ANSI
-PUBLIC S16 SRemPstMsgMult
+S16 SRemPstMsgMult
(
Data *dst, /* destination */
MsgLen cnt, /* count */
Buffer *mBuf
)
#else
-PUBLIC S16 SRemPstMsgMult(dst, cnt, mBuf)
+S16 SRemPstMsgMult(dst, cnt, mBuf)
Data *dst; /* destination */
MsgLen cnt; /* count */
Buffer *mBuf; /* message buffer */
#ifdef ANSI
-PUBLIC S16 SExamMsg
+S16 SExamMsg
(
Data *dataPtr, /* pointer to data */
Buffer *mBuf, /* message buffer */
MsgLen idx
)
#else
-PUBLIC S16 SExamMsg(dataPtr, mBuf, idx)
+S16 SExamMsg(dataPtr, mBuf, idx)
Data *dataPtr; /* pointer to data */
Buffer *mBuf; /* message buffer */
MsgLen idx; /* index */
#ifdef ANSI
-PUBLIC S16 SGetDataFrmMsg
+S16 SGetDataFrmMsg
(
Buffer *mBuf, /* message buffer */
Data *dataPtr, /* pointer to data */
MsgLen dataLen
)
#else
-PUBLIC S16 SGetDataFrmMsg(mBuf, dataPtr, idx, dataLen)
+S16 SGetDataFrmMsg(mBuf, dataPtr, idx, dataLen)
Buffer *mBuf; /* message buffer */
Data *dataPtr; /* pointer to data */
MsgLen idx; /* index */
#ifdef ANSI
-PUBLIC S16 SFndLenMsg
+S16 SFndLenMsg
(
REG1 Buffer *mBuf, /* message buffer */
MsgLen *lngPtr
)
#else
-PUBLIC S16 SFndLenMsg(mBuf, lngPtr)
+S16 SFndLenMsg(mBuf, lngPtr)
REG1 Buffer *mBuf; /* message buffer */
MsgLen *lngPtr; /* pointer to length */
#endif
*
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SSegMsgNew
+S16 SSegMsgNew
(
Buffer *mBuf1, /* message 1 */
MsgLen idx, /* index */
)
#else
#ifdef ANSI
-PUBLIC S16 SSegMsg
+S16 SSegMsg
(
Buffer *mBuf1, /* message 1 */
MsgLen idx, /* index */
Buffer **mBuf2
)
#else
-PUBLIC S16 SSegMsg(mBuf1, idx, mBuf2)
+S16 SSegMsg(mBuf1, idx, mBuf2)
Buffer *mBuf1; /* message 1 */
MsgLen idx; /* index */
Buffer **mBuf2; /* message 2 */
*/
#ifdef ANSI
-PUBLIC S16 SCpyFixMsg
+S16 SCpyFixMsg
(
Data *srcBuf, /* source buffer */
Buffer *dstMbuf, /* destination message buffer */
MsgLen *cCnt
)
#else
-PUBLIC S16 SCpyFixMsg(srcBuf, dstMbuf, dstIdx, cnt, cCnt)
+S16 SCpyFixMsg(srcBuf, dstMbuf, dstIdx, cnt, cCnt)
Data *srcBuf; /* source buffer */
Buffer *dstMbuf; /* destination message buffer */
MsgLen dstIdx; /* destination index */
*/
#ifdef ANSI
-PUBLIC S16 SCpyMsgFix
+S16 SCpyMsgFix
(
Buffer *srcMbuf, /* source message buffer */
MsgLen srcIdx, /* source index */
MsgLen *cCnt
)
#else
-PUBLIC S16 SCpyMsgFix(srcMbuf, srcIdx, cnt, dstBuf, cCnt)
+S16 SCpyMsgFix(srcMbuf, srcIdx, cnt, dstBuf, cCnt)
Buffer *srcMbuf; /* source message buffer */
MsgLen srcIdx; /* source index */
MsgLen cnt; /* count */
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SCpyMsgMsgNew
+S16 SCpyMsgMsgNew
(
Buffer *srcBuf,
Region dstRegion,
)
#else
#ifdef ANSI
-PUBLIC S16 SCpyMsgMsg
+S16 SCpyMsgMsg
(
Buffer *srcBuf,
Region dstRegion,
Buffer **dstBuf
)
#else
-PUBLIC S16 SCpyMsgMsg(srcBuf, dstRegion, dstPool, dstBuf)
+S16 SCpyMsgMsg(srcBuf, dstRegion, dstPool, dstBuf)
Buffer *srcBuf;
Region dstRegion;
Pool dstPool;
*
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAddMsgRefNew
+S16 SAddMsgRefNew
(
Buffer *srcBuf,
Region dstRegion,
)
#else
#ifdef ANSI
-PUBLIC S16 SAddMsgRef
+S16 SAddMsgRef
(
Buffer *srcBuf,
Region dstRegion,
Buffer **dstBuf
)
#else
-PUBLIC S16 SAddMsgRef(srcBuf, dstRegion, dstPool, dstBuf)
+S16 SAddMsgRef(srcBuf, dstRegion, dstPool, dstBuf)
Buffer *srcBuf;
Region dstRegion;
Pool dstPool;
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SGetDBufNew
+S16 SGetDBufNew
(
Region region, /* region id */
Pool pool, /* pool id */
)
#else
#ifdef ANSI
-PUBLIC S16 SGetDBuf
+S16 SGetDBuf
(
Region region, /* region id */
Pool pool, /* pool id */
Buffer **bufPtr
)
#else
-PUBLIC S16 SGetDBuf(region, pool, bufPtr)
+S16 SGetDBuf(region, pool, bufPtr)
Region region; /* region id */
Pool pool; /* pool id */
Buffer **bufPtr; /* pointer to buffer */
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SPutDBufNew
+S16 SPutDBufNew
(
Region region,
Pool pool,
)
#else
#ifdef ANSI
-PUBLIC S16 SPutDBuf
+S16 SPutDBuf
(
Region region,
Pool pool,
Buffer *buf
)
#else
-PUBLIC S16 SPutDBuf(region, pool, buf)
+S16 SPutDBuf(region, pool, buf)
Region region;
Pool pool;
Buffer *buf;
#ifdef ANSI
-PUBLIC S16 SCatMsg
+S16 SCatMsg
(
Buffer *mBuf1, /* message 1 */
Buffer *mBuf2, /* message 2 */
Order order
)
#else
-PUBLIC S16 SCatMsg(mBuf1, mBuf2, order)
+S16 SCatMsg(mBuf1, mBuf2, order)
Buffer *mBuf1; /* message 1 */
Buffer *mBuf2; /* message 2 */
Order order; /* order */
#ifdef ANSI
-PUBLIC S16 SRepMsg
+S16 SRepMsg
(
Data data, /* data */
Buffer *mBuf, /* message buffer */
MsgLen idx
)
#else
-PUBLIC S16 SRepMsg(data, mBuf, idx)
+S16 SRepMsg(data, mBuf, idx)
Data data; /* data */
Buffer *mBuf; /* message buffer */
MsgLen idx; /* index */
#ifdef ANSI
-PUBLIC S16 SUpdMsg
+S16 SUpdMsg
(
Buffer *mBuf, /* message buffer */
Buffer *dBuf, /* data buffer */
MsgLen dLen
)
#else
-PUBLIC S16 SUpdMsg(mBuf, dBuf, dLen)
+S16 SUpdMsg(mBuf, dBuf, dLen)
Buffer *mBuf; /* message buffer */
Buffer *dBuf; /* data buffer */
MsgLen dLen; /* data length */
#ifdef ANSI
-PUBLIC S16 SAddDBufPst
+S16 SAddDBufPst
(
Buffer *mBuf, /* message buffer */
Buffer *dBuf
)
#else
-PUBLIC S16 SAddDBufPst(mBuf, dBuf)
+S16 SAddDBufPst(mBuf, dBuf)
Buffer *mBuf; /* message buffer */
Buffer *dBuf; /* data buffer */
#endif
#ifdef ANSI
-PUBLIC S16 SAddDBufPre
+S16 SAddDBufPre
(
Buffer *mBuf, /* message buffer */
Buffer *dBuf
)
#else
-PUBLIC S16 SAddDBufPre(mBuf, dBuf)
+S16 SAddDBufPre(mBuf, dBuf)
Buffer *mBuf; /* message buffer */
Buffer *dBuf; /* data buffer */
#endif
#ifdef ANSI
-PUBLIC S16 SRemDBufPre
+S16 SRemDBufPre
(
Buffer *mBuf, /* message buffer */
Buffer **dBufPtr
)
#else
-PUBLIC S16 SRemDBufPre(mBuf, dBufPtr)
+S16 SRemDBufPre(mBuf, dBufPtr)
Buffer *mBuf; /* message buffer */
Buffer **dBufPtr; /* pointer to data buffer */
#endif
#ifdef ANSI
-PUBLIC S16 SRemDBufPst
+S16 SRemDBufPst
(
Buffer *mBuf, /* message buffer */
Buffer **dBufPtr
)
#else
-PUBLIC S16 SRemDBufPst(mBuf, dBufPtr)
+S16 SRemDBufPst(mBuf, dBufPtr)
Buffer *mBuf; /* message buffer */
Buffer **dBufPtr; /* pointer to data buffer */
#endif
#ifdef ANSI
-PUBLIC S16 SInitNxtDBuf
+S16 SInitNxtDBuf
(
Buffer *mBuf
)
#else
-PUBLIC S16 SInitNxtDBuf(mBuf)
+S16 SInitNxtDBuf(mBuf)
Buffer *mBuf; /* message buffer */
#endif
{
#ifdef ANSI
-PUBLIC S16 SGetNxtDBuf
+S16 SGetNxtDBuf
(
Buffer *mBuf, /* message buffer */
Buffer **dBuf
)
#else
-PUBLIC S16 SGetNxtDBuf(mBuf, dBuf)
+S16 SGetNxtDBuf(mBuf, dBuf)
Buffer *mBuf; /* message buffer */
Buffer **dBuf; /* data buffer return */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SChkNxtDBuf
+S16 SChkNxtDBuf
(
Buffer *mBuf
)
#else
-PUBLIC S16 SChkNxtDBuf(mBuf)
+S16 SChkNxtDBuf(mBuf)
Buffer *mBuf; /* message buffer */
#endif
{
#ifdef ANSI
-PUBLIC S16 SGetDataRx
+S16 SGetDataRx
(
Buffer *dBuf, /* data buffer */
MsgLen pad, /* pad */
MsgLen *retDatLen
)
#else
-PUBLIC S16 SGetDataRx(dBuf, pad, retDatPtr, retDatLen)
+S16 SGetDataRx(dBuf, pad, retDatPtr, retDatLen)
Buffer *dBuf; /* data buffer */
MsgLen pad; /* pad */
Data **retDatPtr; /* return data pointer */
#ifdef ANSI
-PUBLIC S16 SGetDataTx
+S16 SGetDataTx
(
Buffer *dBuf, /* data buffer */
Data **retDatPtr, /* return data pointer */
MsgLen *retDatLen /* return data length */
)
#else
-PUBLIC S16 SGetDataTx(dBuf, retDatPtr, retDatLen)
+S16 SGetDataTx(dBuf, retDatPtr, retDatLen)
Buffer *dBuf; /* data buffer */
Data **retDatPtr; /* return data pointer */
MsgLen *retDatLen; /* return data length */
*
*/
#ifdef ANSI
-PUBLIC S16 SGetBufRegionPool
+S16 SGetBufRegionPool
(
Buffer *mBuf, /* message buffer */
Region *region, /* region */
Pool *pool /* pool */
)
#else
-PUBLIC S16 SGetBufRegionPool(mBuf, region, pool)
+S16 SGetBufRegionPool(mBuf, region, pool)
Buffer *mBuf; /* message buffer */
Region *region; /* region */
Pool *pool; /* pool */
#ifdef ANSI
-PUBLIC S16 SCompressMsg
+S16 SCompressMsg
(
Buffer *mBuf
)
#else
-PUBLIC S16 SCompressMsg(mBuf)
+S16 SCompressMsg(mBuf)
Buffer *mBuf; /* message buffer */
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 SPrntMsg
+S16 SPrntMsg
(
Buffer *mBuf, /* message buffer */
S16 src, /* source id */
S16 dst /* destination id */
)
#else
-PUBLIC S16 SPrntMsg(mBuf, src, dst)
+S16 SPrntMsg(mBuf, src, dst)
Buffer *mBuf; /* message buffer */
S16 src; /* source id */
S16 dst; /* destination id */
*
*/
#ifdef ANSI
-PUBLIC S16 SGetPstMsgMult
+S16 SGetPstMsgMult
(
MsgLen cnt, /* count */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SGetPstMsgMult(cnt, mBuf)
+S16 SGetPstMsgMult(cnt, mBuf)
MsgLen cnt; /* count */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SChkMsg
+S16 SChkMsg
(
Buffer *mBuf
)
#else
-PUBLIC S16 SChkMsg(mBuf)
+S16 SChkMsg(mBuf)
Buffer *mBuf;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SAlignDBufEven
+S16 SAlignDBufEven
(
Buffer *dBuf /* data buffer */
)
#else
-PUBLIC S16 SAlignDBufEven(dBuf)
+S16 SAlignDBufEven(dBuf)
Buffer *dBuf; /* data buffer */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SAlignDBuf
+S16 SAlignDBuf
(
Buffer *dBuf, /* data buffer */
U32 align /* alignemnt required */
)
#else
-PUBLIC S16 SAlignDBuf(dBuf, align)
+S16 SAlignDBuf(dBuf, align)
Buffer *dBuf; /* data buffer */
U32 align; /* alignemnt required */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SGetSMem
+S16 SGetSMem
(
Region region, /* region ID */
Size size, /* size */
Pool *pool /* pointer to pool ID */
)
#else
-PUBLIC S16 SGetSMem(region, size, pool)
+S16 SGetSMem(region, size, pool)
Region region; /* region ID */
Size size; /* size */
Pool *pool; /* pointer to pool ID */
*
*/
#ifdef ANSI
-PUBLIC S16 SPutSMem
+S16 SPutSMem
(
Region region, /* region ID */
Pool pool /* pool ID */
)
#else
-PUBLIC S16 SPutSMem(region, pool)
+S16 SPutSMem(region, pool)
Region region; /* region ID */
Pool pool; /* pool ID */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SChkRes
+S16 SChkRes
(
Region region, /* region ID */
Pool pool, /* pool ID */
Status *status /* pointer to status */
)
#else
-PUBLIC S16 SChkRes(region, pool, status)
+S16 SChkRes(region, pool, status)
Region region; /* region ID */
Pool pool; /* pool ID */
Status *status; /* pointer to status */
#ifdef ANSI
-PUBLIC S16 SSwapMsg
+S16 SSwapMsg
(
Buffer *mBuf1, /* message 1 */
Buffer *mBuf2 /* message 2 */
)
#else
-PUBLIC S16 SSwapMsg(mBuf1, mBuf2)
+S16 SSwapMsg(mBuf1, mBuf2)
Buffer *mBuf1; /* message 1 */
Buffer *mBuf2; /* message 2 */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SConvPtrPhy
+S16 SConvPtrPhy
(
Buffer **mBuf
)
#else
-PUBLIC S16 SConvPtrPhy (mBuf)
+S16 SConvPtrPhy (mBuf)
Buffer **mBuf;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SConvPhyPtr
+S16 SConvPhyPtr
(
Buffer **workPtr
)
#else
-PUBLIC S16 SConvPhyPtr (workPtr)
+S16 SConvPhyPtr (workPtr)
Buffer **workPtr;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SCpyFpaMsg
+S16 SCpyFpaMsg
(
Buffer *srcBuf,
Region dstRegion,
Buffer **dstBuf
)
#else
-PUBLIC S16 SCpyFpaMsg (srcBuf, dstRegion, dstPool, dstBuf)
+S16 SCpyFpaMsg (srcBuf, dstRegion, dstPool, dstBuf)
Buffer *srcBuf;
Region dstRegion;
Pool dstPool;
*
*/
#ifdef ANSI
-PUBLIC S16 SCpyMsgFpa
+S16 SCpyMsgFpa
(
Buffer *srcBuf,
Buffer **dstBuf
)
#else
-PUBLIC S16 SCpyMsgFpa (srcBuf, dstBuf)
+S16 SCpyMsgFpa (srcBuf, dstBuf)
Buffer *srcBuf;
Buffer **dstBuf;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SPutFpaMsg
+S16 SPutFpaMsg
(
Buffer *fpaBuf
)
#else
-PUBLIC S16 SPutFpaMsg(fpaBuf)
+S16 SPutFpaMsg(fpaBuf)
Buffer *fpaBuf;
#endif
{
*/
#ifdef ANSI
-PUBLIC S16 SCpyPartMsg
+S16 SCpyPartMsg
(
Buffer *srcBuf,
MsgLen idx,
Buffer *dstBuf
)
#else
-PUBLIC S16 SCpyPartMsg(srcBuf, idx, cnt, dstBuf)
+S16 SCpyPartMsg(srcBuf, idx, cnt, dstBuf)
Buffer *srcBuf;
MsgLen idx;
MsgLen cnt;
*/
#ifdef ANSI
-PUBLIC S16 SRepPartMsg
+S16 SRepPartMsg
(
Buffer *srcBuf,
MsgLen idx,
Buffer *dstBuf
)
#else
-PUBLIC S16 SRepPartMsg(srcBuf, idx, cnt, dstBuf)
+S16 SRepPartMsg(srcBuf, idx, cnt, dstBuf)
Buffer *srcBuf;
MsgLen idx;
MsgLen cnt;
#ifdef ANSI
-PUBLIC S16 SMovPartMsg
+S16 SMovPartMsg
(
Buffer *srcBuf, /* message 1 */
MsgLen idx, /* index */
Buffer *dstBuf /* message 2 */
)
#else
-PUBLIC S16 SMovPartMsg(srcBuf, idx, dstBuf)
+S16 SMovPartMsg(srcBuf, idx, dstBuf)
Buffer *srcBuf; /* message 1 */
MsgLen idx; /* index */
Buffer *dstBuf; /* message 2 */
*/
#ifdef ANSI
-PUBLIC S16 SPkMsgMult
+S16 SPkMsgMult
(
Data *src,
MsgLen cnt,
Buffer *mBuf
)
#else
-PUBLIC S16 SPkMsgMult(src, cnt, mBuf)
+S16 SPkMsgMult(src, cnt, mBuf)
Data *src;
MsgLen cnt;
Buffer *mBuf;
*
*/
#ifdef ANSI
-PUBLIC S16 SGetReadPtr
+S16 SGetReadPtr
(
Buffer *mBuf,
U8** data,
MsgLen *len
)
#else
-PUBLIC S16 SGetReadPtr (mBuf, data, len)
+S16 SGetReadPtr (mBuf, data, len)
Buffer *mBuf;
U8** data;
MsgLen *len;
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAttachPtrToBufNew
+S16 SAttachPtrToBufNew
(
Region region,
Pool pool,
)
#else
#ifdef ANSI
-PUBLIC S16 SAttachPtrToBuf
+S16 SAttachPtrToBuf
(
Region region,
Pool pool,
Buffer** mBuf
)
#else
-PUBLIC S16 SAttachPtrToBuf(region, pool, ptr, totalLen, mBuf)
+S16 SAttachPtrToBuf(region, pool, ptr, totalLen, mBuf)
Region region;
Pool pool;
Data *ptr;
*
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAttachPtrToMBuf1
+S16 SAttachPtrToMBuf1
(
Region region,
Pool pool,
)
#else
#ifdef ANSI
-PUBLIC S16 SAttachPtrToMBuf
+S16 SAttachPtrToMBuf
(
Region region,
Pool pool,
Buffer** mBuf
)
#else
-PUBLIC S16 SAttachPtrToMBuf(region, pool, ptr, totalLen, ptrLen, mBuf)
+S16 SAttachPtrToMBuf(region, pool, ptr, totalLen, ptrLen, mBuf)
Region region;
Pool pool;
Data *ptr;
return ROK;
}
#endif /* INTEL_WLS */
-PUBLIC S16 SIncMsgRef(Buffer *srcBuf,Region dstRegion, Pool dstPool,Buffer **dstBuf)
+S16 SIncMsgRef(Buffer *srcBuf,Region dstRegion, Pool dstPool,Buffer **dstBuf)
{
#ifndef L2_OPTMZ
return (SAddMsgRef(srcBuf,dstRegion, dstPool,dstBuf));
return ROK;
}
#ifdef L2_OPTMZ
-PUBLIC Void SResetMBuf(Buffer *mbuf)
+Void SResetMBuf(Buffer *mbuf)
{
SsMsgInfo *minfo;
Buffer *tmp;
*
*/
#ifdef T2K_MEM_LEAK_DBG
-PUBLIC S16 SAttachWlsPtrToMBuf1
+S16 SAttachWlsPtrToMBuf1
(
Region region,
Pool pool,
)
#else
#ifdef ANSI
-PUBLIC S16 SAttachWlsPtrToMBuf
+S16 SAttachWlsPtrToMBuf
(
Region region,
Pool pool,
Buffer** mBuf
)
#else
-PUBLIC S16 SAttachWlsPtrToMBuf(region, pool, ptr, readPtr, totalLen, ptrLen, mBuf)
+S16 SAttachWlsPtrToMBuf(region, pool, ptr, readPtr, totalLen, ptrLen, mBuf)
Region region;
Pool pool;
Data *ptr;
extern U32 numeTti;
-PUBLIC S16 SGetSBufDpdk
+S16 SGetSBufDpdk
(
Data **ptr, /* pointer to buffer */
Size size /* size requested */
return (ret);
}
-PUBLIC S16 SPutSBufDpdk
+S16 SPutSBufDpdk
(
Data *ptr /* pointer to buffer */
)
return (ret);
}
-PUBLIC S16 SDetachDpdkPtrFrmDBuf
+S16 SDetachDpdkPtrFrmDBuf
(
Buffer *mBuf,
Data **ptr
}
-PUBLIC S16 SDetachDpdkPtrFrmMBuf
+S16 SDetachDpdkPtrFrmMBuf
(
Buffer *mBuf,
Data **ptr
#ifdef ANSI
-PUBLIC S16 SAttachDpdkPtrToMBuf
+S16 SAttachDpdkPtrToMBuf
(
Region region,
Pool pool,
Buffer** mBuf
)
#else
-PUBLIC S16 SAttachDpdkPtrToMBuf(region, pool, ptr, readPtr, msgLen, totalLen, mBuf)
+S16 SAttachDpdkPtrToMBuf(region, pool, ptr, readPtr, msgLen, totalLen, mBuf)
Region region;
Pool pool;
Data *ptr;
*/
#ifdef ANSI
-PUBLIC S16 SPkS8
+S16 SPkS8
(
S8 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkS8(val, mBuf)
+S16 SPkS8(val, mBuf)
S8 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduUnpackUInt8
+S16 oduUnpackUInt8
(
U8 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduUnpackUInt8(val, mBuf)
+S16 oduUnpackUInt8(val, mBuf)
U8 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SPkS16
+S16 SPkS16
(
S16 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkS16(val, mBuf)
+S16 SPkS16(val, mBuf)
S16 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduUnpackUInt16
+S16 oduUnpackUInt16
(
U16 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduUnpackUInt16(val, mBuf)
+S16 oduUnpackUInt16(val, mBuf)
U16 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SPkS32
+S16 SPkS32
(
S32 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkS32(val, mBuf)
+S16 SPkS32(val, mBuf)
S32 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduUnpackUInt32
+S16 oduUnpackUInt32
(
U32 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduUnpackUInt32(val, mBuf)
+S16 oduUnpackUInt32(val, mBuf)
U32 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SPkF32
+S16 SPkF32
(
F32 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkF32(val, mBuf)
+S16 SPkF32(val, mBuf)
F32 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SPkF64
+S16 SPkF64
(
F64 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkF64(val, mBuf)
+S16 SPkF64(val, mBuf)
F64 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SUnpkS8
+S16 SUnpkS8
(
S8 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkS8(val, mBuf)
+S16 SUnpkS8(val, mBuf)
S8 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduPackUInt8
+S16 oduPackUInt8
(
U8 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduPackUInt8(val, mBuf)
+S16 oduPackUInt8(val, mBuf)
U8 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SUnpkS16
+S16 SUnpkS16
(
S16 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkS16(val, mBuf)
+S16 SUnpkS16(val, mBuf)
S16 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduPackUInt16
+S16 oduPackUInt16
(
U16 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduPackUInt16(val, mBuf)
+S16 oduPackUInt16(val, mBuf)
U16 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SUnpkS32
+S16 SUnpkS32
(
S32 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkS32(val, mBuf)
+S16 SUnpkS32(val, mBuf)
S32 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 oduPackUInt32
+S16 oduPackUInt32
(
U32 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 oduPackUInt32(val, mBuf)
+S16 oduPackUInt32(val, mBuf)
U32 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SUnpkF32
+S16 SUnpkF32
(
F32 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkF32(val, mBuf)
+S16 SUnpkF32(val, mBuf)
F32 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef ANSI
-PUBLIC S16 SUnpkF64
+S16 SUnpkF64
(
F64 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkF64(val, mBuf)
+S16 SUnpkF64(val, mBuf)
F64 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SInitQueue
+S16 SInitQueue
(
Queue *q /* queue */
)
#else
-PUBLIC S16 SInitQueue(q)
+S16 SInitQueue(q)
Queue *q; /* queue */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SFlushQueue
+S16 SFlushQueue
(
Queue *q /* queue */
)
#else
-PUBLIC S16 SFlushQueue(q)
+S16 SFlushQueue(q)
Queue *q; /* queue */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SCatQueue
+S16 SCatQueue
(
Queue *q1, /* queue 1 */
Queue *q2, /* queue 2 */
Order order /* order */
)
#else
-PUBLIC S16 SCatQueue(q1, q2, order)
+S16 SCatQueue(q1, q2, order)
Queue *q1; /* queue 1 */
Queue *q2; /* queue 2 */
Order order; /* order */
*
*/
#ifdef ANSI
-PUBLIC S16 SFndLenQueue
+S16 SFndLenQueue
(
Queue *q, /* queue */
QLen *lngPtr /* pointer to length */
)
#else
-PUBLIC S16 SFndLenQueue(q, lngPtr)
+S16 SFndLenQueue(q, lngPtr)
Queue *q; /* queue */
QLen *lngPtr; /* pointer to length */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SExamQueue
+S16 SExamQueue
(
Buffer **bufPtr, /* pointer to buffer */
Queue *q, /* queue */
QLen idx /* index */
)
#else
-PUBLIC S16 SExamQueue(bufPtr, q, idx)
+S16 SExamQueue(bufPtr, q, idx)
Buffer **bufPtr; /* pointer to buffer */
Queue *q; /* queue */
QLen idx; /* index */
*
*/
#ifdef ANSI
-PUBLIC S16 SAddQueue
+S16 SAddQueue
(
Buffer *mBuf, /* buffer */
Queue *q, /* queue */
QLen idx /* index */
)
#else
-PUBLIC S16 SAddQueue(mBuf, q, idx)
+S16 SAddQueue(mBuf, q, idx)
Buffer *mBuf; /* buffer */
Queue *q; /* queue */
QLen idx; /* index */
*
*/
#ifdef ANSI
-PUBLIC S16 SRemQueue
+S16 SRemQueue
(
Buffer **bufPtr, /* pointer to buffer */
Queue *q, /* queue */
QLen idx /* index */
)
#else
-PUBLIC S16 SRemQueue(bufPtr, q, idx)
+S16 SRemQueue(bufPtr, q, idx)
Buffer **bufPtr; /* pointer to buffer */
Queue *q; /* queue */
QLen idx; /* index */
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SQueueFirst
+INLINE S16 SQueueFirst
(
Buffer *buf, /* buffer */
Queue *q /* queue */
)
#else
-PUBLIC INLINE S16 SQueueFirst(buf, q)
+INLINE S16 SQueueFirst(buf, q)
Buffer *buf; /* buffer */
Queue *q; /* queue */
#endif
*
*/
#ifdef ANSI
-PUBLIC INLINE S16 SDequeueFirst
+INLINE S16 SDequeueFirst
(
Buffer **bufPtr, /* pointer to buffer */
Queue *q /* queue */
)
#else
-PUBLIC INLINE S16 SDequeueFirst(bufPtr, q)
+INLINE S16 SDequeueFirst(bufPtr, q)
Buffer **bufPtr; /* pointer to buffer */
Queue *q; /* queue */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SQueueLast
+S16 SQueueLast
(
Buffer *buf, /* buffer */
Queue *q /* queue */
)
#else
-PUBLIC S16 SQueueLast(buf, q)
+S16 SQueueLast(buf, q)
Buffer *buf; /* buffer */
Queue *q; /* queue */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SDequeueLast
+S16 SDequeueLast
(
Buffer **bufPtr, /* pointer to buffer */
Queue *q /* queue */
)
#else
-PUBLIC S16 SDequeueLast(bufPtr, q)
+S16 SDequeueLast(bufPtr, q)
Buffer **bufPtr; /* pointer to buffer */
Queue *q; /* queue */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 ssInitDmndQ
+S16 ssInitDmndQ
(
SsDmndQ *dQueue /* Demand Queue */
)
#else
-PUBLIC S16 ssInitDmndQ(dQueue)
+S16 ssInitDmndQ(dQueue)
SsDmndQ *dQueue; /* Demand Queue */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssDestroyDmndQ
+S16 ssDestroyDmndQ
(
SsDmndQ *dQueue /* demand Queue */
)
#else
-PUBLIC S16 ssDestroyDmndQ(dQueue)
+S16 ssDestroyDmndQ(dQueue)
SsDmndQ *dQueue; /* demand Queue */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssDmndQPut
+S16 ssDmndQPut
(
SsDmndQ *dQueue, /* demand Queue */
Buffer *mBuf, /* message buffer */
Order order /* position */
)
#else
-PUBLIC S16 ssDmndQPut(dQueue, mBuf, priority, order)
+S16 ssDmndQPut(dQueue, mBuf, priority, order)
SsDmndQ *dQueue; /* demand Queue */
Buffer *mBuf; /* message buffer */
Prior priority; /* priority */
*
*/
#ifdef ANSI
-PUBLIC S16 ssDmndQWait
+S16 ssDmndQWait
(
SsDmndQ *dQueue /* demand queue */
)
#else
-PUBLIC S16 ssDmndQWait(dQueue)
+S16 ssDmndQWait(dQueue)
SsDmndQ *dQueue; /* demand queue */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssDmndQGet
+S16 ssDmndQGet
(
SsDmndQ *dQueue, /* demand queue */
Buffer **mBuf, /* message buffer */
Order order /* position */
)
#else
-PUBLIC S16 ssDmndQGet(dQueue, mBuf, order)
+S16 ssDmndQGet(dQueue, mBuf, order)
SsDmndQ *dQueue; /* demand queue */
Buffer **mBuf; /* message buffer */
Order order; /* position */
*
*/
#ifdef ANSI
-PUBLIC S16 ssFndLenDmndQ
+S16 ssFndLenDmndQ
(
SsDmndQ *dQueue, /* demand queue */
Prior priority, /* priority */
QLen *len /* queue length */
)
#else
-PUBLIC S16 ssFndLenDmndQ(dQueue, priority, len)
+S16 ssFndLenDmndQ(dQueue, priority, len)
SsDmndQ *dQueue; /* demand queue */
Prior priority; /* priority */
QLen *len; /* queue length */
SsRngBufTbl SsRngInfoTbl[SS_RNG_BUF_MAX];
-PUBLIC Void SsRngBufEnable(Void)
+Void SsRngBufEnable(Void)
{
ssRngBufStatus = TRUE;
}
-PUBLIC Void SsRngBufDisable(Void)
+Void SsRngBufDisable(Void)
{
ssRngBufStatus = FALSE;
Region and Pool
*/
#ifdef ANSI
-PUBLIC S16 SCreateSRngBuf
+S16 SCreateSRngBuf
(
U32 id,
Region region,
U32 rngSize
)
#else
-PUBLIC S16 SCreateSRngBuf (id, region, pool, elmSize, rngSize)
+S16 SCreateSRngBuf (id, region, pool, elmSize, rngSize)
U32 id;
Region region;
Pool pool;
as consumer(Rx) or producer (Tx)
*/
#ifdef ANSI
-PUBLIC S16 SAttachSRngBuf
+S16 SAttachSRngBuf
(
U32 id,
U32 ent,
U32 txRx
)
#else
-PUBLIC S16 SAttachSRngBuf (id, ent, txRx)
+S16 SAttachSRngBuf (id, ent, txRx)
U32 id;
U32 ent;
U32 txRx;
*/
#ifdef ANSI
-PUBLIC S16 SConnectSRngBuf
+S16 SConnectSRngBuf
(
U32 id,
U32 rxEnt
)
#else
-PUBLIC S16 SConnectSRngBuf (id, rxEnt)
+S16 SConnectSRngBuf (id, rxEnt)
U32 id;
U32 rxEnt;
#endif
return (rBuf->write == rBuf->read);
}
-PUBLIC S16 isRngEmpty(U32 id)
+S16 isRngEmpty(U32 id)
{
return (IsEmpty(SsRngInfoTbl[id].r_addr));
}
Desc: Perform Queue operation on Ring bufer
*/
#ifdef ANSI
-PUBLIC S16 SEnqSRngBuf
+S16 SEnqSRngBuf
(
U32 id,
Void* elem
)
#else
-PUBLIC S16 SEnqSRngBuf(id,elem)
+S16 SEnqSRngBuf(id,elem)
U32 id;
Void* elem;
#endif
}
#ifdef ANSI
-PUBLIC S16 SGetNumElemInRng
+S16 SGetNumElemInRng
(
U32 id
)
#else
-PUBLIC S16 SGetNumElemInRng (id)
+S16 SGetNumElemInRng (id)
U32 id;
#endif
{
Desc: Perform DeQueue operation on Ring bufer
*/
#ifdef ANSI
-PUBLIC S16 SDeqSRngBuf
+S16 SDeqSRngBuf
(
U32 id,
Void *elem
)
#else
-PUBLIC S16 SDeqSRngBuf (id,elem)
+S16 SDeqSRngBuf (id,elem)
U8 id;
Void *elem;
#endif
}
#ifdef ANSI
-PUBLIC S16 SDestroySRngBuf
+S16 SDestroySRngBuf
(
U32 id,
Region region,
Pool pool
)
#else
-PUBLIC S16 SDestroySRngBuf(id, region, pool)
+S16 SDestroySRngBuf(id, region, pool)
U32 id;
Region region;
Pool pool;
}
#ifdef ANSI
-PUBLIC S16 SPrintSRngStats
+S16 SPrintSRngStats
(
Void
)
#else
-PUBLIC S16 SPrintSRngStats ()
+S16 SPrintSRngStats ()
Void;
#endif
{
}
#ifdef ANSI
-PUBLIC Void* SRngGetWIndx
+Void* SRngGetWIndx
(
U32 rngId
)
#else
-PUBLIC Void* SRngGetWIndx (rngId)
+Void* SRngGetWIndx (rngId)
U32 rngId;
#endif
{
}
#ifdef ANSI
-PUBLIC Void* SRngGetRIndx
+Void* SRngGetRIndx
(
U32 rngId
)
#else
-PUBLIC Void* SRngGetRIndx (rngId)
+Void* SRngGetRIndx (rngId)
U32 rngId;
#endif
{
}
#ifdef ANSI
-PUBLIC Void SRngIncrWIndx
+Void SRngIncrWIndx
(
U32 rngId
)
#else
-PUBLIC Void SRngIncrWIndx (rngId)
+Void SRngIncrWIndx (rngId)
U32 rngId;
#endif
{
}
#ifdef ANSI
-PUBLIC Void SRngIncrRIndx
+Void SRngIncrRIndx
(
U32 rngId
)
#else
-PUBLIC Void SRngIncrRIndx (rngId)
+Void SRngIncrRIndx (rngId)
U32 rngId;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 ssStrmCfg
+S16 ssStrmCfg
(
Region mdRegId, /* region for message and data blocks */
Region datRegId /* region for data buffers */
)
#else
-PUBLIC S16 ssStrmCfg(mdRegId, datRegId)
+S16 ssStrmCfg(mdRegId, datRegId)
Region mdRegId; /* region for message and data blocks */
Region datRegId; /* region for data buffers */
#endif
*
*/
#ifdef ANSI
-PUBLIC S32 ssAdjMsg
+S32 ssAdjMsg
(
SsMblk *mp, /* message */
S32 len /* bytes to remove */
)
#else
-PUBLIC S32 ssAdjMsg(mp, len)
+S32 ssAdjMsg(mp, len)
SsMblk *mp; /* message */
S32 len; /* bytes to remove */
#endif
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssAllocB
+SsMblk *ssAllocB
(
S32 size, /* required size */
U32 pri /* message priority */
)
#else
-PUBLIC SsMblk *ssAllocB(size, pri)
+SsMblk *ssAllocB(size, pri)
S32 size; /* required size */
U32 pri; /* message priority */
#endif
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssCopyB
+SsMblk *ssCopyB
(
SsMblk *mp /* message block */
)
#else
-PUBLIC SsMblk *ssCopyB(mp)
+SsMblk *ssCopyB(mp)
SsMblk *mp; /* message block */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssCopyMsg
+SsMblk *ssCopyMsg
(
SsMblk *mp /* message block */
)
#else
-PUBLIC SsMblk *ssCopyMsg(mp)
+SsMblk *ssCopyMsg(mp)
SsMblk *mp; /* message block */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssDupB
+SsMblk *ssDupB
(
SsMblk *mp /* message block */
)
#else
-PUBLIC SsMblk *ssDupB(mp)
+SsMblk *ssDupB(mp)
SsMblk *mp; /* message block */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssDupMsg
+SsMblk *ssDupMsg
(
SsMblk *mp /* message block */
)
#else
-PUBLIC SsMblk *ssDupMsg(mp)
+SsMblk *ssDupMsg(mp)
SsMblk *mp; /* message block */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssESBAlloc
+SsMblk *ssESBAlloc
(
U8 *base, /* client supplied data buffer */
S32 size, /* size of data buffer */
SsFrtn *fr_rtn /* free routine */
)
#else
-PUBLIC SsMblk *ssESBAlloc(base, size, pri, fr_rtn)
+SsMblk *ssESBAlloc(base, size, pri, fr_rtn)
U8 *base; /* client supplied data buffer */
S32 size; /* size of data buffer */
S32 pri; /* message priority */
*
*/
#ifdef ANSI
-PUBLIC Void ssFreeB
+Void ssFreeB
(
SsMblk *mp /* message block */
)
#else
-PUBLIC Void ssFreeB(mp)
+Void ssFreeB(mp)
SsMblk *mp; /* message block */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void ssFreeMsg
+Void ssFreeMsg
(
SsMblk *mp /* message block */
)
#else
-PUBLIC Void ssFreeMsg(mp)
+Void ssFreeMsg(mp)
SsMblk *mp; /* message block */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void ssLinkB
+Void ssLinkB
(
SsMblk *mp, /* first message block */
SsMblk *bp /* second message block */
)
#else
-PUBLIC Void ssLinkB(mp, bp)
+Void ssLinkB(mp, bp)
SsMblk *mp; /* first message block */
SsMblk *bp; /* second message block */
#endif
*
*/
#ifdef ANSI
-PUBLIC S32 ssMsgDSize
+S32 ssMsgDSize
(
SsMblk *mp /* message block */
)
#else
-PUBLIC S32 ssMsgDSize(mp)
+S32 ssMsgDSize(mp)
SsMblk *mp; /* message block */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S32 ssPullupMsg
+S32 ssPullupMsg
(
SsMblk *mp, /* message block */
S32 len /* number of bytes to align */
)
#else
-PUBLIC S32 ssPullupMsg(mp, len)
+S32 ssPullupMsg(mp, len)
SsMblk *mp; /* message block */
S32 len; /* number of bytes to align */
#endif
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssRmvB
+SsMblk *ssRmvB
(
SsMblk *mp, /* message */
SsMblk *bp /* message block */
)
#else
-PUBLIC SsMblk *ssRmvB(mp, bp)
+SsMblk *ssRmvB(mp, bp)
SsMblk *mp; /* message */
SsMblk *bp; /* message block */
#endif
*
*/
#ifdef ANSI
-PUBLIC S32 ssTestB
+S32 ssTestB
(
S32 size, /* size required */
U32 pri /* priority of the message buffer */
)
#else
-PUBLIC S32 ssTestB(size, pri)
+S32 ssTestB(size, pri)
S32 size; /* size required */
U32 pri; /* priority of the message buffer */
#endif
*
*/
#ifdef ANSI
-PUBLIC SsMblk *ssUnlinkB
+SsMblk *ssUnlinkB
(
SsMblk *mp /* message */
)
#else
-PUBLIC SsMblk *ssUnlinkB(mp)
+SsMblk *ssUnlinkB(mp)
SsMblk *mp; /* message */
#endif
{
/* STREAMS functions prototypes */
-PUBLIC S16 ssStrmCfg ARGS((Region, Region));
-PUBLIC S32 ssAdjMsg ARGS((SsMblk *, S32));
-PUBLIC SsMblk *ssAllocB ARGS((S32, U32));
-PUBLIC SsMblk *ssCopyB ARGS((SsMblk *));
-PUBLIC SsMblk *ssCopyMsg ARGS((SsMblk *));
-PUBLIC SsMblk *ssDupB ARGS((SsMblk *));
-PUBLIC SsMblk *ssDupMsg ARGS((SsMblk *));
-PUBLIC SsMblk *ssESBAlloc ARGS((U8 *, S32, S32, SsFrtn *));
-PUBLIC void ssFreeB ARGS((SsMblk *));
-PUBLIC void ssFreeMsg ARGS((SsMblk *));
-PUBLIC void ssLinkB ARGS((SsMblk *, SsMblk *));
-PUBLIC S32 ssMsgDSize ARGS((SsMblk *));
-PUBLIC S32 ssPullupMsg ARGS((SsMblk *, S32));
-PUBLIC SsMblk *ssRmvB ARGS((SsMblk *, SsMblk *));
-PUBLIC S32 ssTestB ARGS((S32, U32));
-PUBLIC SsMblk *ssUnlinkB ARGS((SsMblk *));
+S16 ssStrmCfg ARGS((Region, Region));
+S32 ssAdjMsg ARGS((SsMblk *, S32));
+SsMblk *ssAllocB ARGS((S32, U32));
+SsMblk *ssCopyB ARGS((SsMblk *));
+SsMblk *ssCopyMsg ARGS((SsMblk *));
+SsMblk *ssDupB ARGS((SsMblk *));
+SsMblk *ssDupMsg ARGS((SsMblk *));
+SsMblk *ssESBAlloc ARGS((U8 *, S32, S32, SsFrtn *));
+void ssFreeB ARGS((SsMblk *));
+void ssFreeMsg ARGS((SsMblk *));
+void ssLinkB ARGS((SsMblk *, SsMblk *));
+S32 ssMsgDSize ARGS((SsMblk *));
+S32 ssPullupMsg ARGS((SsMblk *, S32));
+SsMblk *ssRmvB ARGS((SsMblk *, SsMblk *));
+S32 ssTestB ARGS((S32, U32));
+SsMblk *ssUnlinkB ARGS((SsMblk *));
#ifdef __cplusplus
EXTERN S32 clusterMode;
#endif
-PUBLIC pthread_t tmpRegTidMap[20];
+pthread_t tmpRegTidMap[20];
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
EXTERN unsigned int tlPost(void *handle);
*/
#ifdef ANSI
-PUBLIC S16 SRegInit
+S16 SRegInit
(
Ent ent, /* entity */
Inst inst, /* instance */
PAIFS16 initFnct /* initialization function */
)
#else
-PUBLIC S16 SRegInit(ent, inst, initFnct)
+S16 SRegInit(ent, inst, initFnct)
Ent ent; /* entity */
Inst inst; /* instance */
PAIFS16 initFnct; /* initialization function */
*
*/
#ifdef ANSI
-PUBLIC S16 SRegActvTsk
+S16 SRegActvTsk
(
Ent ent, /* entity */
Inst inst, /* instance */
ActvTsk actvTsk /* activate task function */
)
#else
-PUBLIC S16 SRegActvTsk(ent, inst, ttype, prior, actvTsk)
+S16 SRegActvTsk(ent, inst, ttype, prior, actvTsk)
Ent ent; /* entity */
Inst inst; /* instance */
Ttype ttype; /* task type */
*
*/
#ifdef ANSI
-PUBLIC S16 SDeregInitTskTmr
+S16 SDeregInitTskTmr
(
Ent ent, /* entity */
Inst inst /* instance */
)
#else
-PUBLIC S16 SDeregInitTskTmr(ent, inst)
+S16 SDeregInitTskTmr(ent, inst)
Ent ent; /* entity */
Inst inst; /* instance */
#endif
#ifndef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SRegTTsk
+S16 SRegTTsk
(
Ent ent, /* entity */
Inst inst, /* instance */
ActvTsk actvTsk /* activation function */
)
#else
-PUBLIC S16 SRegTTsk(ent, inst, type, prior, initTsk, actvTsk)
+S16 SRegTTsk(ent, inst, type, prior, initTsk, actvTsk)
Ent ent; /* entity */
Inst inst; /* instance */
Ttype type; /* task type */
#else /* SS_MULTIPLE_PROCS */
#ifdef ANSI
-PUBLIC S16 SRegTTsk
+S16 SRegTTsk
(
ProcId proc, /* processor */
Ent ent, /* entity */
ActvTsk actvTsk /* activation function */
)
#else
-PUBLIC S16 SRegTTsk(proc, ent, inst, type, prior, initTsk, actvTsk)
+S16 SRegTTsk(proc, ent, inst, type, prior, initTsk, actvTsk)
ProcId proc; /* processor */
Ent ent; /* entity */
Inst inst; /* instance */
**/
#ifndef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SRegCbTsk
+S16 SRegCbTsk
(
Ent ent, /* entity */
Inst inst, /* instance */
ActvTsk cbTsk /* Callback Function */
)
#else
-PUBLIC S16 SRegCbTsk(ent, inst, cbTsk)
+S16 SRegCbTsk(ent, inst, cbTsk)
Ent ent; /* entity */
Inst inst; /* instance */
ActvTsk cbTsk;
#else /* SS_MULTIPLE_PROCS */
#ifdef ANSI
-PUBLIC S16 SRegCbTsk
+S16 SRegCbTsk
(
ProcId proc, /* processor */
Ent ent, /* entity */
ActvTsk cbTsk
)
#else
-PUBLIC S16 SRegCbTsk(proc, ent, inst, cbTsk)
+S16 SRegCbTsk(proc, ent, inst, cbTsk)
ProcId proc; /* processor */
Ent ent; /* entity */
Inst inst; /* instance */
#ifndef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SDeregTTsk
+S16 SDeregTTsk
(
Ent ent, /* entity */
Inst inst /* instance */
)
#else
-PUBLIC S16 SDeregTTsk(ent, inst)
+S16 SDeregTTsk(ent, inst)
Ent ent; /* entity */
Inst inst; /* instance */
#endif
#else /* SS_MULTIPLE_PROCS */
#ifdef ANSI
-PUBLIC S16 SDeregTTsk
+S16 SDeregTTsk
(
ProcId proc, /* processor */
Ent ent, /* entity */
Inst inst /* instance */
)
#else
-PUBLIC S16 SDeregTTsk(proc, ent, inst)
+S16 SDeregTTsk(proc, ent, inst)
ProcId proc; /* processor */
Ent ent; /* entity */
Inst inst; /* instance */
*
*/
#ifdef ANSI
-PUBLIC S16 SCreateSTsk
+S16 SCreateSTsk
(
SSTskPrior tskPrior, /* task priority */
SSTskId *tskId /* filled in with system task ID */
)
#else
-PUBLIC S16 SCreateSTsk(tskPrior, tskId)
+S16 SCreateSTsk(tskPrior, tskId)
SSTskPrior tskPrior; /* task priority */
SSTskId *tskId; /* filled in with system task ID */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SRegLogCfg
+S16 SRegLogCfg
(
U8 mode,
S8 *path,
U16 port
)
#else
-PUBLIC S16 SRegLogCfg(mode, path, size, IPA, port)
+S16 SRegLogCfg(mode, path, size, IPA, port)
U8 mode;
S8 *path;
U32 size;
*
--*/
#ifdef ANSI
-PUBLIC S16 SFlushBufToLog
+S16 SFlushBufToLog
(
S8 *logBuf
)
#else
-PUBLIC S16 SFlushBufToLog(logBuf)
+S16 SFlushBufToLog(logBuf)
S8 *logBuf
#endif
{
*
--*/
#ifdef ANSI
-PUBLIC S16 SCleanUp
+S16 SCleanUp
(
Void
)
#else
-PUBLIC S16 SCleanUp()
+S16 SCleanUp()
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SDeregLogCfg
+S16 SDeregLogCfg
(
)
#else
-PUBLIC S16 SDeregLogCfg()
+S16 SDeregLogCfg()
#endif
{
*
*/
#ifdef ANSI
-PUBLIC Void SStartLogger
+Void SStartLogger
(
void
)
#else
-PUBLIC Void SStartLogger()
+Void SStartLogger()
#endif
{
if (osCp.logger.configured == TRUE)
*
*/
#ifdef ANSI
-PUBLIC Void SStopLogger
+Void SStopLogger
(
void
)
#else
-PUBLIC Void SStopLogger()
+Void SStopLogger()
#endif
{
osCp.logger.started = FALSE;
*
*/
#ifdef ANSI
-PUBLIC S16 SRegCpuInfo
+S16 SRegCpuInfo
(
SCpuInfo *cpuInfo /* Information about the cores/threads per core */
)
#else
-PUBLIC S16 SRegCpuInfo (cpuInfo)
+S16 SRegCpuInfo (cpuInfo)
SCpuInfo *cpuInfo; /* Information about the cores/threads per core */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SGetAffinity
+S16 SGetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
U32 *coreId /* the core/processor id to which the affinity is set */
)
#else
-PUBLIC S16 SGetAffinity(tskId, coreId)
+S16 SGetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
U32 *coreId; /* the core/processor id to which the affinity is set */
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 SSetAffinity
+S16 SSetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
SsAffinityMode mode, /* the mode according to which the affinty is set */
SSTskId *tskAssociatedTskId /* filled in with system task ID of the associated layer */
)
#else
-PUBLIC S16 SSetAffinity(tskId, mode, coreId, tskAssociatedTskId)
+S16 SSetAffinity(tskId, mode, coreId, tskAssociatedTskId)
SSTskId *tskId; /* filled in with system task ID */
SsAffinityMode mode; /* the mode according to which the affinty is set */
U32 coreId; /* the core/processor id to which the affinity has to be set */
*
*/
#ifdef ANSI
-PUBLIC S16 SDestroySTsk
+S16 SDestroySTsk
(
SSTskId tskId /* system task to be destroyed */
)
#else
-PUBLIC S16 SDestroySTsk(tskId)
+S16 SDestroySTsk(tskId)
SSTskId tskId; /* system task to be destroyed */
#endif
{
#ifndef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SAttachTTsk
+S16 SAttachTTsk
(
Ent ent, /* entity ID of the task */
Inst inst, /* instance ID of the task */
SSTskId sTskId /* system task to use */
)
#else
-PUBLIC S16 SAttachTTsk(ent, inst, sTskId)
+S16 SAttachTTsk(ent, inst, sTskId)
Ent ent; /* entity ID of the task */
Inst inst; /* instance ID of the task */
SSTskId sTskId; /* system task to use */
#else /* SS_MULTIPLE_PROCS */
#ifdef ANSI
-PUBLIC S16 SAttachTTsk
+S16 SAttachTTsk
(
ProcId proc, /* processor ID of the task */
Ent ent, /* entity ID of the task */
SSTskId sTskId /* system task to use */
)
#else
-PUBLIC S16 SAttachTTsk(proc, ent, inst, sTskId)
+S16 SAttachTTsk(proc, ent, inst, sTskId)
ProcId proc; /* processor ID of the task */
Ent ent; /* entity ID of the task */
Inst inst; /* instance ID of the task */
#ifndef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SDetachTTsk
+S16 SDetachTTsk
(
Ent ent, /* entity ID of the task */
Inst inst /* instance ID of the task */
)
#else
-PUBLIC S16 SDetachTTsk(ent, inst)
+S16 SDetachTTsk(ent, inst)
Ent ent; /* entity ID of the task */
Inst inst; /* instance ID of the task */
#endif
#else /* SS_MULTIPLE_PROCS */
#ifdef ANSI
-PUBLIC S16 SDetachTTsk
+S16 SDetachTTsk
(
ProcId proc, /* processor ID of the task */
Ent ent, /* entity ID of the task */
Inst inst /* instance ID of the task */
)
#else
-PUBLIC S16 SDetachTTsk(proc, ent, inst)
+S16 SDetachTTsk(proc, ent, inst)
ProcId proc; /* processor ID of the task */
Ent ent; /* entity ID of the task */
Inst inst; /* instance ID of the task */
*
*/
#ifdef ANSI
-PUBLIC S16 SPstTsk
+S16 SPstTsk
(
Pst *pst, /* post information */
Buffer *mBuf /* message to post */
)
#else
-PUBLIC S16 SPstTsk(pst, mBuf)
+S16 SPstTsk(pst, mBuf)
Pst *pst; /* post information */
Buffer *mBuf; /* message to post */
#endif
if ((srctTsk->sTsk == tTsk->sTsk)
#if defined(SPLIT_RLC_DL_TASK) && !defined(RLC_MAC_DAT_REQ_RBUF)
||
- ((pst->dstEnt == ENTRG) &&
- (pst->srcEnt == ENTKW) &&
+ ((pst->dstEnt == ENTMAC) &&
+ (pst->srcEnt == ENTRLC) &&
(pst->event == EVTRGUDDATREQ))
#endif
)
/* ss029.103: modification: procId added */
#ifdef ANSI
-PUBLIC S16 SGetTapaTskEntIds
+S16 SGetTapaTskEntIds
(
Ent *ent /* entity */
)
#else
-PUBLIC S16 SGetTapaTskEntIds(ent)
+S16 SGetTapaTskEntIds(ent)
Ent *ent; /* entity */
#endif
{
/* ss029.103: modification: procId added */
#ifdef ANSI
-PUBLIC S16 SRegForHstGrm
+S16 SRegForHstGrm
(
Ent ent /* entity */
)
#else
-PUBLIC S16 SRegForHstGrm(ent)
+S16 SRegForHstGrm(ent)
Ent ent; /* entity */
#endif
{
*
*/
#ifdef ANSI
-PUBLIC S16 SGetHstGrmInfo
+S16 SGetHstGrmInfo
(
Ent *entId,
Bool *hstReg /* entity */
)
#else
-PUBLIC S16 SGetHstGrmInfo(entId, hstReg)
+S16 SGetHstGrmInfo(entId, hstReg)
Ent *entId;
Bool *hstReg; /* entity */
#endif
#ifdef SS_WATCHDOG
#ifdef ANSI
-PUBLIC S16 SInitWatchdog
+S16 SInitWatchdog
(
U16 port
)
#else
-PUBLIC S16 SInitWatchdog(port)
+S16 SInitWatchdog(port)
U16 port;
#endif
{
}
#ifdef ANSI
-PUBLIC S16 SRegCfgWd
+S16 SRegCfgWd
(
U32 numNodes,
U8 *addr[],
void *data
)
#else
-PUBLIC S16 SRegCfgWd(numNodes, addr, port, timeout, callback, data)
+S16 SRegCfgWd(numNodes, addr, port, timeout, callback, data)
U32 numNodes;
U8 *addr[];
U16 port[];
}
#ifdef ANSI
-PUBLIC S16 SDeregCfgWd
+S16 SDeregCfgWd
(
void
)
#else
-PUBLIC S16 SDeregCfgWd(void)
+S16 SDeregCfgWd(void)
void;
#endif
{
}
#ifdef ANSI
-PUBLIC S16 SStartHrtBt
+S16 SStartHrtBt
(
U8 timeInterval /* time interval */
)
#else
-PUBLIC S16 SStartHrtBt(timeInterval)
+S16 SStartHrtBt(timeInterval)
U8 timeInterval;
#endif
{
}
#ifdef ANSI
-PUBLIC S16 SStopHrtBt
+S16 SStopHrtBt
(
void
)
#else
-PUBLIC S16 SStopHrtBt()
+S16 SStopHrtBt()
void
#endif
{
}
#ifdef ANSI
-PUBLIC S16 watchDgActvTsk
+S16 watchDgActvTsk
(
Pst *pst, /* post */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 watchDgActvTsk(pst, mBuf)
+S16 watchDgActvTsk(pst, mBuf)
Pst *pst; /* post */
Buffer *mBuf; /* message buffer */
#endif
}
#ifdef ANSI
-PUBLIC S16 watchDgRcvrActvTsk
+S16 watchDgRcvrActvTsk
(
Pst *pst, /* post */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 watchDgRcvrActvTsk(pst, mBuf)
+S16 watchDgRcvrActvTsk(pst, mBuf)
Pst *pst; /* post */
Buffer *mBuf; /* message buffer */
#endif
*/
#ifdef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SGetThrdProf
+S16 SGetThrdProf
(
SSTskId *sTskId,
ProcId procId,
U64 *totTime
)
#else
-PUBLIC S16 SGetThrdProf(sTskId, procId, ent, inst, evnt, curEvent, curEvtTime, totTime)
+S16 SGetThrdProf(sTskId, procId, ent, inst, evnt, curEvent, curEvtTime, totTime)
SSTskId *sTskId;
ProcId procId;
Ent ent; /* entity */
#endif
#else
#ifdef ANSI
-PUBLIC S16 SGetThrdProf
+S16 SGetThrdProf
(
SSTskId *sTskId,
Ent ent, /* entity */
U64 *totTime
)
#else
-PUBLIC S16 SGetThrdProf(sTskId, ent, inst, curEvent,curEvtTime, totTime)
+S16 SGetThrdProf(sTskId, ent, inst, curEvent,curEvtTime, totTime)
SSTskId *sTskId;
Ent ent; /* entity */
Inst inst;
*
*/
#ifdef ANSI
-PUBLIC S16 SRegTskInfo
+S16 SRegTskInfo
(
U8 *cfgFile
)
#else
-PUBLIC S16 SRegTskInfo(cfgFile)
+S16 SRegTskInfo(cfgFile)
U8 *cfgFile;
#endif
{
/* ss029.103: addition: procId added and timer function type modified */
#ifndef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SRegCfgTmr
+S16 SRegCfgTmr
(
Ent ent, /* entity */
Inst inst, /* instance */
PFS16 tmrFnct /* timer function, typically SActvTmr */
)
#else
-PUBLIC S16 SRegCfgTmr(ent, inst, period, units, tmrFnct)
+S16 SRegCfgTmr(ent, inst, period, units, tmrFnct)
Ent ent; /* entity */
Inst inst; /* instance */
S16 period; /* period */
#else /* SS_MULTIPLE_PROCS */
#ifdef ANSI
-PUBLIC S16 SRegCfgTmr
+S16 SRegCfgTmr
(
ProcId proc, /* processor */
Ent ent, /* entity */
PAIFTMRS16 tmrFnct /* timer function, typically SActvTmr */
)
#else
-PUBLIC S16 SRegCfgTmr(proc, ent, inst, period, units, tmrFnct)
+S16 SRegCfgTmr(proc, ent, inst, period, units, tmrFnct)
ProcId proc; /* processor */
Ent ent; /* entity */
Inst inst; /* instance */
*
*/
#ifdef ANSI
-PUBLIC S16 SRegCfgTmrMt
+S16 SRegCfgTmrMt
(
Ent ent, /* entity */
Inst inst, /* instance */
PAIFTMRS16 tmrFnctMt /* timer function, typically SActvTmr */
)
#else
-PUBLIC S16 SRegCfgTmrMt(ent, inst, period, units, tmrFnctMt)
+S16 SRegCfgTmrMt(ent, inst, period, units, tmrFnctMt)
Ent ent; /* entity */
Inst inst; /* instance */
S16 period; /* period */
#ifndef SS_MULTIPLE_PROCS
#ifdef ANSI
-PUBLIC S16 SDeregCfgTmr
+S16 SDeregCfgTmr
(
Ent ent, /* entity */
Inst inst, /* instance */
PFS16 tmrFnct /* timer function */
)
#else
-PUBLIC S16 SDeregCfgTmr(ent, inst, period, units, tmrFnct)
+S16 SDeregCfgTmr(ent, inst, period, units, tmrFnct)
Ent ent; /* entity */
Inst inst; /* instance */
S16 period; /* period */
#else /* SS_MULTIPLE_PROCS */
#ifdef ANSI
-PUBLIC S16 SDeregCfgTmr
+S16 SDeregCfgTmr
(
ProcId proc, /* processor */
Ent ent, /* entity */
PAIFTMRS16 tmrFnct /* timer function */
)
#else
-PUBLIC S16 SDeregCfgTmr(proc, ent, inst, period, units, tmrFnct)
+S16 SDeregCfgTmr(proc, ent, inst, period, units, tmrFnct)
ProcId proc; /* processor */
Ent ent; /* entity */
Inst inst; /* instance */
*
*/
#ifdef ANSI
-PUBLIC S16 SDeregCfgTmrMt
+S16 SDeregCfgTmrMt
(
Ent ent, /* entity */
Inst inst, /* instance */
PAIFTMRS16 tmrFnctMt /* timer function */
)
#else
-PUBLIC S16 SDeregCfgTmrMt(ent, inst, period, units, tmrFnctMt)
+S16 SDeregCfgTmrMt(ent, inst, period, units, tmrFnctMt)
Ent ent; /* entity */
Inst inst; /* instance */
S16 period; /* period */
*
* ****************************************************************/
-PUBLIC void l1HdlParamReq(uint32_t msgLen, void *msg)
+void l1HdlParamReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
DU_LOG("\nPHY_STUB: Received Param Request in PHY");
*
* ****************************************************************/
-PUBLIC void l1HdlConfigReq(uint32_t msgLen, void *msg)
+void l1HdlConfigReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
fapi_config_req_t *configReq = (fapi_config_req_t *)msg;
* @return void
*
* ****************************************************************/
-PUBLIC uint16_t l1BuildAndSendSlotIndication()
+uint16_t l1BuildAndSendSlotIndication()
{
#ifdef INTEL_FAPI
fapi_slot_ind_t *slotIndMsg;
*
* ****************************************************************/
-PUBLIC S16 l1HdlStartReq(uint32_t msgLen, void *msg)
+S16 l1HdlStartReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
fapi_start_req_t *startReq = (fapi_start_req_t *)msg;
*
* ****************************************************************/
-PUBLIC S16 l1HdlDlTtiReq(uint16_t msgLen, void *msg)
+S16 l1HdlDlTtiReq(uint16_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
fapi_dl_tti_req_t *dlTtiReq;
*
* ****************************************************************/
-PUBLIC S16 l1HdlTxDataReq(uint16_t msgLen, void *msg)
+S16 l1HdlTxDataReq(uint16_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
fapi_tx_data_req_t *txDataReq;
*
* ****************************************************************/
-PUBLIC S16 l1HdlUlTtiReq(uint16_t msgLen, void *msg)
+S16 l1HdlUlTtiReq(uint16_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
fapi_ul_tti_req_t *ulTtiReq = NULLP;
* @return void
*
* ****************************************************************/
-PUBLIC uint16_t l1BuildAndSendStopInd()
+uint16_t l1BuildAndSendStopInd()
{
#ifdef INTEL_FAPI
fapi_stop_ind_t *stopIndMsg = NULLP;
*
* ****************************************************************/
-PUBLIC S16 l1HdlStopReq(uint32_t msgLen, void *msg)
+S16 l1HdlStopReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
fapi_stop_req_t *stopReq = (fapi_stop_req_t *)msg;
*
* ****************************************************************/
-PUBLIC S16 l1HdlUlDciReq(uint16_t msgLen, void *msg)
+S16 l1HdlUlDciReq(uint16_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
fapi_ul_dci_req_t *ulDciReq = NULLP;
*/
#ifdef ANSI
-PUBLIC Void rlProcessLogBufFromL2
+Void rlProcessLogBufFromL2
(
void *mBuf
)
#else
-PUBLIC Void rlProcessLogBufFromL2(mBuf)
+Void rlProcessLogBufFromL2(mBuf)
void *mBuf;
#endif
{
/* This function will get tick from RLC/CL and will process logs
according to tick threshold. Tick threshold is SOC specific */
-PUBLIC Void rlProcessTicks(void)
+Void rlProcessTicks(void)
{
static U32 rlogTickCount;
numTtiTicks++;
// @out : void
//////////////////////////////////////////////////////////////////////////
-PUBLIC Void readL2LogBuff(void)
+Void readL2LogBuff(void)
{
/* Validate global buffer pointer and length */
U8 ret;
//////////////////////////////////////////////////////////////////////////
#ifdef ANSI
-PUBLIC S16 rlValidateL2LogBuf(void)
+S16 rlValidateL2LogBuf(void)
#else
-PUBLIC S16 rlValidateL2LogBuf(void)
+S16 rlValidateL2LogBuf(void)
#endif
{
S16 ret = ROK;
//////////////////////////////////////////////////////////////////////////
#ifdef ANSI
-PUBLIC void rlSetL2LogBuf
+void rlSetL2LogBuf
(
U8 *l2LogBuf,
U32 l2logLen
)
#else
-PUBLIC void rlSetL2LogBuf(l2LogBuf,l2logLen)
+void rlSetL2LogBuf(l2LogBuf,l2logLen)
U8 *l2LogBuf;
U32 l2logLen;
#endif
//////////////////////////////////////////////////////////////////////////
#ifdef ANSI
-PUBLIC void rlResetL2LogBuf
+void rlResetL2LogBuf
(
void
)
#else
-PUBLIC void rlResetL2LogBuf(void)
+void rlResetL2LogBuf(void)
#endif
{
g_logBufRcvdFromL2 = NULL;
// @out : void
//////////////////////////////////////////////////////////////////////////
-PUBLIC void rlInitL2SocSpecific(void)
+void rlInitL2SocSpecific(void)
{
#ifndef RLOG_ENABLE_TEXT_LOGGING
// @out : void
//////////////////////////////////////////////////////////////////////////
-PUBLIC void processL2LogBuff(void)
+void processL2LogBuff(void)
{
#ifndef RLOG_ENABLE_TEXT_LOGGING
if(g_l2LogBufLen > 0)
// logPtr - Address of log Buffer
//////////////////////////////////////////////////////////////////////////
-PUBLIC void rlGetL2LogBufPtr
+void rlGetL2LogBufPtr
(
void *mBuf,
U32 *logLen,
// @out : void
//////////////////////////////////////////////////////////////////////////
-PUBLIC void rlInvalidateL2LogsInCache
+void rlInvalidateL2LogsInCache
(
Data *ptr,
U32 len
#define RLOG_LIMIT_L2_COUNT 100
#define RLOG_LIMIT_L3_COUNT 500
-PUBLIC void rlInitL2SocSpecific(void);
-PUBLIC void processL2LogBuff(void);
-PUBLIC void rlGetL2LogBufPtr(void *mBuf,U32 *logLen,Data **logPtr);
-PUBLIC void rlInvalidateL2LogsInCache(Data *ptr,U32 len);
+void rlInitL2SocSpecific(void);
+void processL2LogBuff(void);
+void rlGetL2LogBufPtr(void *mBuf,U32 *logLen,Data **logPtr);
+void rlInvalidateL2LogsInCache(Data *ptr,U32 len);
extern void rlInitL2SocSpecific(void);
extern void processL2LogBuff(void);
Code Review / o-du / l2.git / commitdiff