*
**********************************************************/
#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;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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;
SuId suId;
SpId spId;
- TRC3(cmUnpkRgrBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrBndCfm
+S16 cmPkRgrBndCfm
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
-PUBLIC S16 cmPkRgrBndCfm(pst, suId, status)
+S16 cmPkRgrBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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;
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
- TRC3(cmUnpkRgrBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(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;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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;
SpId spId;
Reason reason;
- TRC3(cmUnpkRgrUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(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;
RgrCfgTransId transId;
RgrCfgReqInfo *cfgReqInfo;
- TRC3(cmUnpkRgrCfgReq)
#if 0
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
SPutMsg(mBuf);
return RFAILED;
}
- cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
+ memset(cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
*
**********************************************************/
#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
{
- TRC3(cmPkRgrTtiInd)
CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
return ROK;
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrTtiIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->sfn, mBuf);
*
**********************************************************/
#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;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrTtiInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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;
SuId suId;
RgrTtiIndInfo *ttiInd;
- TRC3(cmUnpkRgrTtiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrCfgCfm
+S16 cmPkRgrCfgCfm
(
Pst* pst,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
-PUBLIC S16 cmPkRgrCfgCfm(pst, transId, status)
+S16 cmPkRgrCfgCfm(pst, transId, status)
Pst* pst;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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;
#endif
{
RgrCfgTransId transId;
- U8 status;
+ uint8_t status;
- TRC3(cmUnpkRgrCfgCfm)
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrSiCfgCfm
+S16 cmPkRgrSiCfgCfm
(
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
-PUBLIC S16 cmPkRgrSiCfgCfm(pst, suId, transId, status)
+S16 cmPkRgrSiCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrSiCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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;
{
SuId suId;
RgrCfgTransId transId;
- U8 status;
+ uint8_t status;
- TRC3(cmUnpkRgrSiCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(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
{
S32 i;
- TRC3(cmPkRgrCfgTransId)
for (i=RGR_CFG_TRANSID_SIZE-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmUnpkRgrCfgTransId)
for (i=0; i<RGR_CFG_TRANSID_SIZE; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDlHqCfg)
CMCHKPK(oduUnpackUInt8, param->maxMsg4HqTx, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxDlHqTx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDlHqCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxDlHqTx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->maxMsg4HqTx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrRntiCfg)
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->startRnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->startRnti, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrEmtcRntiCfg)
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->rntiCeModeBRange, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrEmtcRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rntiCeModeAStart, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rntiCeModeARange, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDlCmnCodeRateCfg)
-
CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
CMCHKPK(oduUnpackUInt16, param->pdcchCodeRate, mBuf);
CMCHKPK(oduUnpackUInt16, param->bcchPchRaCodeRate, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDlCmnCodeRateCfg)
-
CMCHKUNPK(oduPackUInt16, ¶m->bcchPchRaCodeRate, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->pdcchCodeRate, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ccchCqi, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCfiCfg)
-
CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrCfiCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->cfi, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmPkRgrPuschSubBandCfg)
for (i=param->numSubbands-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->dmrs[i], mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmUnpkRgrPuschSubBandCfg)
CMCHKUNPK(oduPackUInt8, ¶m->subbandStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSubbands, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUlCmnCodeRateCfg)
-
CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUlCmnCodeRateCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->ccchCqi, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUlTrgCqiCfg)
-
CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUlTrgCqiCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->trgCqi, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrBwCfg)
-
CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
return ROK;
/* 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
{
S32 i;
- TRC3(cmPkRgrEmtcSiCfg)
CMCHKPK(oduUnpackUInt8, param->siHoppingEnable, mBuf);
CMCHKPK(oduUnpackUInt32, param->modPrd, mBuf);
#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
{
S32 i;
- TRC3(cmPkRgrEmtcRachCfg)
CMCHKPK(oduUnpackUInt8, param->emtcCeLvlSupported, mBuf);
#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
{
- TRC3(cmPkRgrEmtcPdschCfg)
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
}
#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
{
- TRC3(cmPkRgrEmtcPuschCfg)
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcHoppingOffset, mBuf);
#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
S32 i;
- TRC3(cmPkRgrEmtcPucchCfg)
for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt16, param->emtcN1pucchAnInfoLst[i], mBuf);
}
#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
{
- TRC3(cmPkRgrEmtcPrachCeParamCfg)
CMCHKPK(oduUnpackUInt8, param->emtcPrachCfgIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcPrachFreqOffset, mBuf);
CMCHKPK(oduUnpackUInt16, param->emtcPrachStartSubFrame, mBuf);
#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
{
S32 i;
- TRC3(cmPkRgrEmtcPrachCfg)
CMCHKPK(oduUnpackUInt8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcPrachHopingOffset, mBuf);
CMCHKPK(oduUnpackUInt8, param->emtcInitialCElevel, mBuf);
#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
{
- TRC3(cmPkRgrEmtcCfg)
CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
CMCHKPK(oduUnpackUInt32, param->emtcT300Tmr, mBuf);
CMCHKPK(oduUnpackUInt32, param->emtcT301Tmr, mBuf);
/* 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
{
S32 i;
- U32 tmpEnum;
- TRC3(cmUnpkRgrEmtcSiCfg)
- CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
+ uint32_t tmpEnum;
+ CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
- for (i=0; i < param->numSi ; i++) {
- CMCHKUNPK(oduPackUInt32,(U32*)&tmpEnum,mBuf);
- param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
+ for (i=0; i < param->numSi ; i++)
+ {
+ CMCHKUNPK(oduPackUInt32,(uint32_t*)&tmpEnum,mBuf);
+ param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
}
- for (i=0; i < param->numSi ; i++) {
- CMCHKUNPK(oduPackUInt16, ¶m->schdInfo[i].emtcSiTbs, mBuf);
- CMCHKUNPK(oduPackUInt8, ¶m->schdInfo[i].emtcSiNarrowBand, mBuf);
+ for (i=0; i < param->numSi ; i++)
+ {
+ CMCHKUNPK(oduPackUInt16, ¶m->schdInfo[i].emtcSiTbs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->schdInfo[i].emtcSiNarrowBand, mBuf);
}
//CMCHKUNPK(oduPackUInt16, ¶m->fddDlOrTddSfBitmapBR, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->siRepetition, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sib1Repetition, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->siWinSizeBr, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32*)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
param->modPrd = (RgrModPeriodicity) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->siHoppingEnable, mBuf);
#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
{
S32 i;
- TRC3(cmUnpkRgrEmtcRachCfg)
for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
#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
{
- TRC3(cmUnpkRgrEmtcPdschCfg)
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeB, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeA, mBuf);
return ROK;
}
#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
{
- TRC3(cmUnpkRgrEmtcPuschCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcHoppingOffset, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeB, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeA, mBuf);
#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
S32 i;
- TRC3(cmUnpkRgrEmtcPucchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl3, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl2, mBuf);
#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
{
- TRC3(cmUnpkRgrEmtcPrachCeParamCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcPrachHoppingCfg, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->emtcMpdcchNumRep, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchNBtoMonitor[1], mBuf);
#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
{
S32 i;
- TRC3(cmUnpkRgrEmtcPrachCfg)
for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
CMCHKUNPK(cmUnpkRgrEmtcPrachCeParamCfg, ¶m->emtcPrachCEparmLst[i], mBuf);
}
}
#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
{
- TRC3(cmUnpkRgrEmtcCfg)
CMCHKUNPK(oduPackUInt8, ¶m->emtcPuschNbIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchNbIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->emtcPdschNbIdx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrBwCfg)
-
CMCHKUNPK(oduPackUInt8, ¶m->dlTotalBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulTotalBw, mBuf);
return ROK;
*
**********************************************************/
#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
{
- TRC3(cmPkRgrPhichCfg)
-
CMCHKPK(oduUnpackUInt8, param->isDurExtend, mBuf);
CMCHKPK(oduUnpackUInt32, param->ngEnum, mBuf);
return ROK;
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrPhichCfg)
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ngEnum = (RgrPhichNg) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->isDurExtend, mBuf);
return ROK;
*
**********************************************************/
#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
{
- TRC3(cmPkRgrPucchCfg)
-
CMCHKPK(oduUnpackUInt8, param->maxPucchRb, mBuf);
CMCHKPK(oduUnpackUInt8, param->cyclicShift, mBuf);
CMCHKPK(oduUnpackUInt8, param->deltaShift, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrPucchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->resourceSize, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->n1PucchAn, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrSrsCfg)
CMCHKPK(oduUnpackUInt8, param->srsSubFrameCfg, mBuf);
CMCHKPK(oduUnpackUInt32, param->srsBwEnum, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrSrsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isSrsCfgSetup, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsCfgPrdEnum = (RgrSrsCfgPrd) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsBwEnum = (RgrSrsBwCfg) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->srsSubFrameCfg, mBuf);
return ROK;
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmPkRgrRachCfg)
CMCHKPK(oduUnpackUInt8, param->prachResource, mBuf);
CMCHKPK(oduUnpackUInt16, param->msgSizeGrpA, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
S32 i;
- TRC3(cmUnpkRgrRachCfg)
#ifdef RGR_V1
/* rgr_c_001.main_5: cccpu00112372: Added contention resolution
* timer configuration */
CMCHKUNPK(oduPackUInt8, ¶m->preambleFormat, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->raWinSize, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->raOccasion.size, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->raOccasion.sfnEnum = (RgrRaSfn) tmpEnum;
for (i=0; i<param->raOccasion.size; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->raOccasion.subFrameNum[i], mBuf);
*
**********************************************************/
#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
S16 idx;
#endif/*RGR_SI_SCH*/
- TRC3(cmPkRgrSiCfg)
#ifdef RGR_SI_SCH
if(param->numSi > sizeof(param->siPeriodicity)/
sizeof(param->siPeriodicity[0]);
for (idx=param->numSi-1; idx >= 0; idx--) {
- /* Enum to be packed/unpacked as U32 instead of S32 */
+ /* Enum to be packed/unpacked as uint32_t instead of S32 */
CMCHKPK(oduUnpackUInt32, param->siPeriodicity[idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
/*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
- CMCHKPK(oduUnpackUInt32, (U32)param->modPrd, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->modPrd, mBuf);
#endif/*RGR_SI_SCH*/
CMCHKPK(oduUnpackUInt8, param->retxCnt, mBuf);
CMCHKPK(oduUnpackUInt8, param->siWinSize, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
/* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
#ifdef RGR_SI_SCH
S16 idx;
#endif/*RGR_SI_SCH*/
- TRC3(cmUnpkRgrSiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->siWinSize, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->retxCnt, mBuf);
#ifdef RGR_SI_SCH
/*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->modPrd = (RgrModPeriodicity) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
param->numSi = sizeof(param->siPeriodicity)/
sizeof(param->siPeriodicity[0]);
- /* Enum to be packed/unpacked as U32 instead of S32 */
+ /* Enum to be packed/unpacked as uint32_t instead of S32 */
for (idx=0; idx < param->numSi; idx++) {
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->siPeriodicity[idx] = (RgrSiPeriodicity) tmpEnum;
}
#endif/*RGR_SI_SCH*/
*
**********************************************************/
#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
{
- TRC3(cmPkRgrTpcRntiCfg)
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->startTpcRnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrTpcRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->startTpcRnti, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUlPwrCfg)
CMCHKPK(cmPkRgrTpcRntiCfg, ¶m->puschPwrFmt3a, mBuf);
CMCHKPK(cmPkRgrTpcRntiCfg, ¶m->puschPwrFmt3, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUlPwrCfg)
CMCHKUNPK(SUnpkS8, ¶m->p0NominalPusch, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->alpha = (RgrPwrAlpha) tmpEnum;
CMCHKUNPK(SUnpkS8, ¶m->p0NominalPucch, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->deltaPreambleMsg3, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrPuschCfg)
CMCHKPK(oduUnpackUInt8, param->hopOffst, mBuf);
CMCHKPK(oduUnpackUInt8, param->isIntraHop, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrPuschCfg)
CMCHKUNPK(oduPackUInt8, ¶m->numSubBands, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isIntraHop, mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmPkRgrCodeBookRstCfg)
for (i=1-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt32, param->pmiBitMap[i], mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmUnpkRgrCodeBookRstCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
for (i=0; i<1; i++) {
*
**********************************************************/
#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
{
- TRC3(cmPkRgrPreambleSetCfg)
CMCHKPK(oduUnpackUInt8, param->size, mBuf);
CMCHKPK(oduUnpackUInt8, param->start, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrPreambleSetCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->start, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCmnLchCfg)
CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrCmnLchCfg)
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDlfsCfg)
CMCHKPK(oduUnpackUInt8, param->thresholdCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->isDlFreqSel, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDlfsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isDlFreqSel, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->thresholdCqi, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrTddPrachInfo)
CMCHKPK(oduUnpackUInt8, param->ulStartSfIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->halfFrm, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrTddPrachInfo)
CMCHKUNPK(oduPackUInt8, ¶m->freqIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->sfn = tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->halfFrm, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulStartSfIdx, mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmPkRgrTddPrachRscInfo)
for (i=param->numRsc-1; i >= 0; i--) {
CMCHKPK(cmPkRgrTddPrachInfo, ¶m->prachInfo[i], mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmUnpkRgrTddPrachRscInfo)
CMCHKUNPK(oduPackUInt8, ¶m->numRsc, mBuf);
for (i=0; i<param->numRsc; i++) {
*
**********************************************************/
#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
{
S32 idx;
- TRC3(cmPkRgrEnbPfs)
for(idx = RGR_MAX_NUM_QCI-1; idx >= 0; idx--)
{
CMCHKPK(oduUnpackUInt32, param->qciWgt[idx], mBuf);
*
**********************************************************/
#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
{
S32 idx;
- TRC3(cmUnpkRgrEnbPfs)
CMCHKUNPK(oduPackUInt8, ¶m->tptCoeffi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->fairCoeffi, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrSpsCellCfg)
CMCHKPK(oduUnpackUInt16, param->maxSpsUePerUlSf, mBuf);
CMCHKPK(oduUnpackUInt16, param->maxSpsUePerDlSf, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxSpsDlBw, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrSpsDlCellCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxSpsDlBw, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->maxSpsUePerDlSf, mBuf);
}
#ifdef RG_5GTF
-PUBLIC S16 cmPkRgr5gtfCellCfg
+S16 cmPkRgr5gtfCellCfg
(
Rgr5gtfCellCfg *param,
Buffer *mBuf
for (idx = MAX_5GTF_SUBFRAME_INFO - 1; idx >= 0 ;--idx)
{
- CMCHKPK(oduUnpackUInt32, param->dynConfig[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dynConfig[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->uePerGrp, mBuf);
CMCHKPK(oduUnpackUInt8, param->ueGrpPerTti, mBuf);
return ROK;
}
-PUBLIC S16 cmUnPkRgr5gtfCellCfg
+S16 cmUnPkRgr5gtfCellCfg
(
Rgr5gtfCellCfg *param,
Buffer *mBuf
for (idx = 0; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
{
- CMCHKUNPK(oduPackUInt32, ¶m->dynConfig[(U8)idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->dynConfig[(uint8_t)idx], mBuf);
}
return ROK;
}
#endif
{
- TRC3(cmPkRgrlteUCellCfg)
CMCHKPK(oduUnpackUInt8, param->isLaaCell, mBuf);
return ROK;
#endif
{
- TRC3(cmUnpkRgrLteUCellCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isLaaCell, 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
{
- TRC3(cmPkRgrLteAdvancedUeConfig)
CMCHKPK(oduUnpackUInt8, param->isUeCellEdge, mBuf);
CMCHKPK(oduUnpackUInt8, param->isAbsUe, mBuf);
CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrLteAdvancedUeConfig)
CMCHKUNPK(oduPackUInt32, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isAbsUe, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isUeCellEdge, mBuf);
*
**********************************************************/
#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
{
S8 indx = 0;
- TRC3(cmPkRgrAbsConfig)
- CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
for (indx = RGR_ABS_PATTERN_LEN-1; indx >= 0; indx--)
{
- CMCHKPK(oduUnpackUInt8, param->absPattern[(U8)indx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->absPattern[(uint8_t)indx], mBuf);
}
CMCHKPK(oduUnpackUInt32, param->absPatternType, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrSfrConfig)
- CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
#ifdef TFU_UPGRADE
CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pHigh, mBuf);
CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pLow, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDsfrConfig)
- CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
return ROK;
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDsfrConfig)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->status, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCellLteAdvancedFeatureCfg)
CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
CMCHKPK(cmPkRgrDsfrConfig, ¶m->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
*
**********************************************************/
#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
{
S8 indx = 0;
- TRC3(cmUnpkRgrAbsConfig)
CMCHKUNPK(oduPackUInt32, ¶m->absLoadPeriodicity, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->absPatternType, mBuf);
for (indx = 0; indx <RGR_ABS_PATTERN_LEN; indx++)
{
- CMCHKUNPK(oduPackUInt8, ¶m->absPattern[(U8)indx], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->absPattern[(uint8_t)indx], mBuf);
}
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->status, mBuf);
return ROK;
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrSfrConfig)
CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.startRb, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.endRb, mBuf);
#ifdef TFU_UPGRADE
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->pwrThreshold.pLow, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->pwrThreshold.pHigh, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->pwrThreshold.pLow, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->pwrThreshold.pHigh, mBuf);
#endif
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->status, mBuf);
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrCellLteAdvancedFeatureCfg)
CMCHKUNPK(cmUnpkRgrAbsConfig, ¶m->absCfg, mBuf);
CMCHKUNPK(cmUnpkRgrSfrConfig, ¶m->sfrCfg, mBuf);
CMCHKUNPK(cmUnpkRgrDsfrConfig, ¶m->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
*
**********************************************************/
#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
{
- TRC3(cmPkMacSchedGnbCfg)
CMCHKPK(oduUnpackUInt8, param->maxDlUePerTti, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxUlUePerTti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkMacSchedGnbCfg)
CMCHKUNPK(oduPackUInt8, ¶m->numTxAntPorts, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulSchdType, mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmPkRgrCellCfg)
#ifdef EMTC_ENABLE
/* EMTC related changes start*/
*
**********************************************************/
#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
S32 i;
- TRC3(cmUnpkRgrCellCfg)
#ifdef EMTC_ENABLE
/* EMTC related changes start*/
CMCHKUNPK(cmUnpkRgrEmtcCfg, ¶m->emtcCellCfg, mBuf);
CMCHKPK(oduPackUInt16, ¶m->phichTxPwrOffset, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isDynCfiEnb, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isAutoCfgModeEnb, mBuf);
- CMCHKPK(oduPackUInt32, (U32*)¶m->msg4pAVal, mBuf);
+ CMCHKPK(oduPackUInt32, (uint32_t*)¶m->msg4pAVal, mBuf);
/*LAA: Unpack LAA Cell params*/
CMCHKUNPK(cmUnpkRgrLteUCellCfg, ¶m->lteUCfg, mBuf);
#ifdef LTE_ADV
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeAprdDlCqiCfg)
/*Pack Aperiodic Trigger List only for Pcell */
#ifdef LTE_ADV
CMCHKPK(oduUnpackUInt8, param->triggerSet2, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeAprdDlCqiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->aprdModeEnum = (RgrAprdCqiMode) tmpEnum;
#ifdef LTE_ADV
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUePrdDlCqiCfg)
CMCHKPK(oduUnpackUInt16, param->cqiPmiCfgIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->k, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUePrdDlCqiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->prdModeEnum = tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->prdicityEnum = tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->subframeOffst, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->cqiOffst, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeDlPCqiSetup)
CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
CMCHKPK(oduUnpackUInt8, param->sANCQI, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeDlPCqiSetup)
CMCHKUNPK(oduPackUInt16, ¶m->cqiPResIdx, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->cqiPCfgIdx, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKUNPK(oduPackUInt16, ¶m->riCfgIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sANCQI, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->prdModeEnum = (RgrPrdCqiMode) tmpEnum;
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUePrdDlCqiCfg)
CMCHKPK(cmPkRgrUeDlPCqiSetup, ¶m->cqiSetup, mBuf);
CMCHKPK(oduUnpackUInt8, param->type, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUePrdDlCqiCfg)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
CMCHKUNPK(cmUnpkRgrUeDlPCqiSetup, ¶m->cqiSetup, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeUlSrsSetupCfg)
CMCHKPK(oduUnpackUInt8, param->fDomPosi, mBuf);
CMCHKPK(oduUnpackUInt8, param->txComb, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeUlSrsSetupCfg)
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsBw = (RgrUlSrsBwInfo) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsHopBw = (RgrUlSrsHoBwInfo) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->cycShift = (RgrUlSrsCycShiftInfo) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->duration, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sANSrs, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeSrSetupCfg)
/* ccpu00131601:DEL - dTMax Packing removed since this param will not
* be required by Scheduler*/
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeSrSetupCfg)
CMCHKUNPK(oduPackUInt16, ¶m->srResIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->srCfgIdx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeSrCfg)
CMCHKPK(cmPkRgrUeSrSetupCfg, ¶m->srSetup, mBuf);
CMCHKPK(oduUnpackUInt8, param->type, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeSrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
CMCHKUNPK(cmUnpkRgrUeSrSetupCfg, ¶m->srSetup, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeUlSrsCfg)
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKPK(cmPkRgrUeUlSrsSetupCfg, ¶m->srsSetup, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeUlSrsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeDlCqiCfg)
/* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeDlCqiCfg)
CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, ¶m->aprdCqiCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, ¶m->prdCqiCfg, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeMeasGapCfg)
CMCHKPK(oduUnpackUInt8, param->gapOffst, mBuf);
CMCHKPK(oduUnpackUInt8, param->gapPrd, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeMeasGapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isMesGapEnabled, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->gapPrd, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDrxLongCycleOffst)
CMCHKPK(oduUnpackUInt16, param->drxStartOffst, mBuf);
CMCHKPK(oduUnpackUInt16, param->longDrxCycle, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDrxLongCycleOffst)
CMCHKUNPK(oduPackUInt16, ¶m->longDrxCycle, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->drxStartOffst, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDrxShortDrx)
CMCHKPK(oduUnpackUInt8, param->drxShortCycleTmr, mBuf);
CMCHKPK(oduUnpackUInt16, param->shortDrxCycle, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDrxShortDrx)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->shortDrxCycle, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeDrxCfg)
CMCHKPK(cmPkRgrDrxShortDrx, ¶m->drxShortDrx, mBuf);
CMCHKPK(cmPkRgrDrxLongCycleOffst, ¶m->drxLongCycleOffst, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeDrxCfg)
/*rgr_c_001.main_9 ADD added changes for R9*/
#ifdef LTEMAC_R9
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeCapCfg)
CMCHKPK(oduUnpackUInt8, param->txAntSel, mBuf);
CMCHKPK(oduUnpackUInt8, param->simCqiAckNack, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeCapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pwrClass, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->intraSfFeqHop, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeAckNackRepCfg)
CMCHKPK(oduUnpackUInt32, param->ackNackRepFactor, mBuf);
CMCHKPK(oduUnpackUInt16, param->pucchAckNackRep, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeAckNackRepCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isAckNackEnabled, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->pucchAckNackRep, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ackNackRepFactor = (RgrAckNackRepFactor) tmpEnum;
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeTxModeCfg)
CMCHKPK(oduUnpackUInt32, param->txModeEnum, mBuf);
CMCHKPK(oduUnpackUInt32, param->tmTrnstnState, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeTxModeCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->tmTrnstnState = (RgrTxModeTrnstn) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->txModeEnum = (RgrTxMode) tmpEnum;
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeUlHqCfg)
CMCHKPK(oduUnpackUInt8, param->deltaHqOffst, mBuf);
CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeUlHqCfg)
CMCHKUNPK(oduPackUInt8, ¶m->maxUlHqTx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->deltaHqOffst, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeGrpPwrCfg)
CMCHKPK(oduUnpackUInt8, param->idx, mBuf);
CMCHKPK(cmPkLteRnti, param->tpcRnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeGrpPwrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->tpcRnti, mBuf);
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmPkRgrUeSpsDlCfg)
CMCHKPK(oduUnpackUInt16, param->explicitRelCnt, mBuf);
CMCHKPK(oduUnpackUInt32, param->dlSpsPrdctyEnum, mBuf);
for (i=param->numPucchVal-1; i >= 0; i--) {
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
S32 i;
- TRC3(cmUnpkRgrUeSpsDlCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isDlSpsEnabled, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSpsHqProc, mBuf);
for (i=0; i<param->numPucchVal; i++) {
CMCHKUNPK(oduPackUInt32, ¶m->n1PucchVal[i], mBuf);
}
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->dlSpsPrdctyEnum = tmpEnum;
CMCHKUNPK(oduPackUInt16, ¶m->explicitRelCnt, mBuf);
return ROK;
*
**********************************************************/
#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
{
S32 i;
- TRC3(cmPkRgrUeSpsUlCfg)
CMCHKPK(oduUnpackUInt8, param->isLcSRMaskEnab, mBuf);
for (i=param->lcCnt-1; i >= 0; i--) {
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
S32 i;
- TRC3(cmUnpkRgrUeSpsUlCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isUlSpsEnabled, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->implicitRelCnt = tmpEnum;
#ifdef LTE_TDD
CMCHKUNPK(oduPackUInt8, ¶m->pwrCfgPres, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pwrCfg.p0NominalPuschVal, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pwrCfg.p0UePuschVal, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ulSpsPrdctyEnum = tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->lcCnt, mBuf);
for (i=0; i<param->lcCnt; i++) {
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeSpsCfg)
CMCHKPK(cmPkRgrUeSpsUlCfg, ¶m->ulSpsCfg, mBuf);
CMCHKPK(cmPkRgrUeSpsDlCfg, ¶m->dlSpsCfg, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeSpsCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->spsRnti, mBuf);
CMCHKUNPK(cmUnpkRgrUeSpsDlCfg, ¶m->dlSpsCfg, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeUlPwrCfg)
CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeUlPwrCfg)
CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, ¶m->uePuschPwr, mBuf);
CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, ¶m->uePucchPwr, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeQosCfg)
CMCHKPK(oduUnpackUInt32, param->ueBr, mBuf);
CMCHKPK(oduUnpackUInt32, param->dlAmbr, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeQosCfg)
CMCHKUNPK(oduPackUInt8, ¶m->ambrPres, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->dlAmbr, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUePuschDedCfg)
CMCHKPK(oduUnpackUInt8, param->bCQIIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->bRIIdx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUePuschDedCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->bACKIdx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeTxAntSelCfg)
CMCHKPK(oduUnpackUInt32, param->selType, mBuf);
CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeTxAntSelCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->selType = (RgrUeTxAntSelType) tmpEnum;
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeTaTmrCfg)
CMCHKPK(oduUnpackUInt16, param->taTmr, mBuf);
CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeTaTmrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->taTmr, mBuf);
#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
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
- CMCHKUNPK(cmUnpkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
- CMCHKUNPK(cmUnpkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
for(idx = 0; idx < 5; idx++)
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->setConfigId),mBuf);
}
- CMCHKUNPK(cmUnpkTknU32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
for(indx = 0; indx < 5; indx++)
{
CMCHKUNPK(oduPackUInt8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
-PUBLIC S16 cmPkRgrEmtcUeCfg
+S16 cmPkRgrEmtcUeCfg
(
RgrUeEmtcCfg *param,
Buffer *mBuf
{
CMCHKPK(oduUnpackUInt8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
}
- CMCHKPK(cmPkTknU32,&emtcEpdcchCfg->startSymbolr11,mBuf);
+ CMCHKPK(cmPkTknUInt32,&emtcEpdcchCfg->startSymbolr11,mBuf);
for(indx = RGR_MAX_EPDCCH_SET-1 ; indx >= 0; indx--)
{
epdcchAddModLst = &(emtcEpdcchCfg->epdcchAddModLst[indx]);
}
CMCHKPK(oduUnpackUInt32,epdcchAddModLst->dmrsScrambSeq,mBuf);
CMCHKPK(oduUnpackUInt32,epdcchAddModLst->pucchResStartoffset,mBuf);
- CMCHKPK(cmPkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
- CMCHKPK(cmPkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
+ CMCHKPK(cmPkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
+ CMCHKPK(cmPkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.pres,mBuf);
CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,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
{
- TRC3(cmPkRgrUeCfg)
#ifdef RG_5GTF
CMCHKPK(cmPkRgr5gtfUeCfg, ¶m->ue5gtfCfg, mBuf);
#endif
CMCHKPK(oduUnpackUInt32, param->ackNackModeEnum, mBuf);
#endif
- CMCHKPK(cmPkTknU8, ¶m->dedPreambleId, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->dedPreambleId, mBuf);
CMCHKPK(cmPkRgrCodeBookRstCfg, ¶m->ueCodeBookRstCfg, mBuf);
CMCHKPK(cmPkRgrUeCapCfg, ¶m->ueCapCfg, mBuf);
CMCHKPK(cmPkRgrUeMeasGapCfg, ¶m->ueMesGapCfg, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
* retxBSR-timer */
CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, ¶m->ueBsrTmrCfg, mBuf);
#endif
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ueCatEnum = (CmLteUeCategory) tmpEnum;
/*rgr_c_001.main_9 ADD added changes for DRX*/
CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, ¶m->ueMesGapCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeCapCfg, ¶m->ueCapCfg, mBuf);
CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, ¶m->ueCodeBookRstCfg, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->dedPreambleId, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->dedPreambleId, mBuf);
#ifdef LTE_TDD
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ackNackModeEnum = tmpEnum;
#endif
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKUNPK(cmUnpkRgrLteAdvancedUeConfig, ¶m->ueLteAdvCfg, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->accessStratumRls, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->accessStratumRls, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->csgMmbrSta, mBuf);
#ifdef EMTC_ENABLE
*
**********************************************************/
#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
{
- TRC3(cmPkRgrLchQosCfg)
CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrLchQosCfg)
CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->gbr, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrLchSpsCfg)
/* SPS_DEV */
CMCHKPK(oduUnpackUInt8, param->isSpsEnabled, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrLchSpsCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isSpsEnabled, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDlLchCfg)
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKPK(oduUnpackUInt8, param->rlcReorderTmr, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDlLchCfg)
CMCHKUNPK(oduPackUInt8, ¶m->dlTrchType, mBuf);
CMCHKUNPK(cmUnpkRgrLchQosCfg, ¶m->dlQos, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUlLchCfg)
CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUlLchCfg)
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
*
**********************************************************/
#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 LTE_L2_MEAS
S32 i;
#endif
- TRC3(cmPkRgrUlLcgCfg)
CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
*
**********************************************************/
#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 LTE_L2_MEAS
S32 i;
#endif
- TRC3(cmUnpkRgrUlLcgCfg)
CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
/*rgr_c_001.main_9 ADD added changes for L2 measurements*/
}
#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
{
- TRC3(cmPkRgrLchCfg)
CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
CMCHKPK(cmPkRgrUlLchQciCfg, ¶m->ulLchQciInfo, mBuf);
CMCHKPK(cmPkRgrDlLchCfg, ¶m->dlInfo, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrLchCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#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
{
- TRC3(cmPkRgrLcgCfg)
CMCHKPK(cmPkRgrUlLcgCfg, ¶m->ulInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
#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
{
- TRC3(cmUnpkRgrLcgCfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCfg)
switch(param->cfgType) {
case RGR_LCG_CFG:
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
*
**********************************************************/
#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
{
- TRC3(cmPkRgrActvTime)
CMCHKPK(cmPkLteTimingInfo, ¶m->actvTime, mBuf);
CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrActvTime)
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->actvTime, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCellRecfg)
CMCHKPK(cmPkRgrCellCntrlCmdCfg, ¶m->cntrlCmdCfg, mBuf);
CMCHKPK(cmPkRgrCellCsgParamCfg, ¶m->csgParamCfg, mBuf);
CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrCellRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->recfgTypes, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeRecfg)
#ifdef EMTC_ENABLE
/* Note: As we add more members to emtcUeRecfg,
create a new function for pkUnpk */
CMCHKPK(cmPkRgrUeAprdDlCqiCfg, ¶m->aprdDlCqiRecfg, mBuf);
CMCHKPK(cmPkRgrUeTxModeCfg, ¶m->txMode, mBuf);
- /*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
+ /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
/* LTE_ADV_FLAG_REMOVED_START */
/* KW fix for LTE_ADV */
CMCHKPK(oduUnpackUInt32, param->ueRecfgTypes, mBuf);
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrUeRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->oldCrnti, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->newCrnti, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
- /*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
+ /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
/* KW fix for LTE_ADV */
CMCHKUNPK(oduPackUInt32, ¶m->ueRecfgTypes, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, ¶m->ueMeasGapRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, ¶m->ueCodeBookRstRecfg, mBuf);
/* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ueCatEnum = (CmLteUeCategory) tmpEnum;
CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, ¶m->ulTxAntSel, mBuf);
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKUNPK(cmUnpkRgrUeSCellAckPucchCfg, ¶m->sCellAckN1ResCfg,mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->simulAckNackCQIFormat3, mBuf);
#endif
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->accessStratumRls, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->accessStratumRls, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->csgMmbrSta, mBuf);
#ifdef EMTC_ENABLE
*
**********************************************************/
#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
{
- TRC3(cmPkRgrLchRecfg)
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrLchRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#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 RG_UNUSED
S32 i;
#endif
- TRC3(cmPkRgrLcgRecfg)
CMCHKPK(oduUnpackUInt32, param->ulRecfg.mbr, mBuf);
CMCHKPK(oduUnpackUInt32, param->ulRecfg.gbr, mBuf);
#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 RG_UNUSED
S32 i;
#endif
- TRC3(cmUnpkRgrLcgRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrRecfg)
switch(param->recfgType) {
case RGR_LCG_CFG:
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrRecfg)
CMCHKUNPK(oduPackUInt8, ¶m->recfgType, mBuf);
switch(param->recfgType) {
*
**********************************************************/
#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
S8 idx;
for(idx = param->numSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkRgrUeDlSecCellRelInfo, ¶m->ueSCellRelDedCfg[(U8)idx],mBuf);
+ CMCHKPK(cmPkRgrUeDlSecCellRelInfo, ¶m->ueSCellRelDedCfg[(uint8_t)idx],mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrDel)
switch(param->delType) {
case RGR_LCG_CFG:
*
**********************************************************/
#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
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrDel)
CMCHKUNPK(oduPackUInt8, ¶m->delType, mBuf);
switch(param->delType) {
*
**********************************************************/
#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
{
S32 count;
- TRC3(cmPkRgrPrbCfg)
for(count = RGR_SCH_MAX_PA_PER_PRB - 1; count >= 0; count --)
{
CMCHKPK(oduUnpackUInt32, param->paLevelPerPrb[count], mBuf);
*
**********************************************************/
#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
{
S32 count;
- TRC3(cmUnpkRgrSonPrbCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isSonIcicEnable, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numCellEdgeUEs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numCellCentreUEs, mBuf);
}
for(count = 0; count < RGR_SCH_MAX_PA_PER_PRB; count ++)
{
- CMCHKUNPK(oduPackUInt32,(U32 *) ¶m->paLevelPerPrb[count], mBuf);
+ CMCHKUNPK(oduPackUInt32,(uint32_t *) ¶m->paLevelPerPrb[count], mBuf);
}
return ROK;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrSonCfg)
switch(param->cfgType)
{
case RGR_SON_PRB_CFG :
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrSonCfg)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->cfgType, mBuf);
switch(param->cfgType)
{
case RGR_SON_PRB_CFG :
*
**********************************************************/
#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
{
- TRC3(cmPkRgrRst)
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrRst)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmUnPkRgrSCellActDeactInfo)
CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
return ROK;
*
**********************************************************/
#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
{
- TRC3(cmUnPkRgrSCellActDeactEvnt)
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numOfSCells, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrSCellActDeactInfo)
CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrSCellActDeactEvnt)
S8 idx;
for(idx = param->numOfSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkRgrSCellActDeactInfo, ¶m->sCellActDeactInfo[(U8)idx], mBuf);
+ CMCHKPK(cmPkRgrSCellActDeactInfo, ¶m->sCellActDeactInfo[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numOfSCells, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCfgReqInfo)
switch(param->action) {
case RGR_SON_CFG:
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrCfgReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
switch(param->action) {
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeBsrTmrCfg)
CMCHKPK(oduUnpackUInt16, param->prdBsrTmr, mBuf);
CMCHKPK(oduUnpackUInt16, param->retxBsrTmr, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeBsrTmrCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isPrdBsrTmrPres, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->retxBsrTmr, mBuf);
*
**********************************************************/
#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;
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrSiCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
*
**********************************************************/
#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;
RgrCfgTransId transId;
RgrSiCfgReqInfo *cfgReqInfo;
- TRC3(cmUnpkRgrSiCfgReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
SPutMsg(mBuf);
return RFAILED;
}
- cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
+ memset(cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
*
**********************************************************/
#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
/* ccpu00111328: S16 is renamed as MsgLen */
MsgLen msgLen;
- TRC3(cmPkRgrSiCfgReqInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(SPkS32, param->cfgType, mBuf);
*
**********************************************************/
#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
/*Merge from Mohit Changes*/
S32 cfgType;
- TRC3(cmUnpkRgrSiCfgReqInfo)
SFndLenMsg(mBuf, &msgLen);
if(msgLen > 0)
*
**********************************************************/
#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;
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrWarningSiCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
*
**********************************************************/
#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;
RgrCfgTransId transId;
RgrWarningSiCfgReqInfo *warningSiCfgReqInfo;
- TRC3(cmUnpkRgrWarningSiCfgReq)
if (SUnpkS16(&spId, mBuf) != ROK)
{
*
**********************************************************/
#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;
#endif
{
MsgLen msgLen;
- U32 count;
+ uint32_t count;
CmLList *node, *prevNode;
RgrSegmentInfo *pdu;
- TRC3(cmPkRgrWarningSiCfgReqInfo)
CMCHKPK(oduUnpackUInt8, param->emtcEnable, 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;
#endif
{
MsgLen msgLen, totalMsgLen;
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
Buffer *pdu;
CmLList *node;
- TRC3(cmUnpkRgrWarningSiCfgReqInfo)
cmLListInit(¶m->siPduLst);
CMCHKUNPK(oduPackUInt32, &count, mBuf);
* File :
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiStopReq
+S16 cmPkRgrWarningSiStopReq
(
Pst *pst,
SpId spId,
RgrCfgTransId transId,
-U8 siId
+uint8_t siId
)
#else
-PUBLIC S16 cmPkRgrWarningSiStopReq(pst,spId, transId, siId)
+S16 cmPkRgrWarningSiStopReq(pst,spId, transId, siId)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
-U8 siId;
+uint8_t siId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrWarningSiStopReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
* 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;
#endif
{
SpId spId;
- U8 siId;
+ uint8_t siId;
RgrCfgTransId transId;
- TRC3(cmUnpkRgrWarningSiStopReq)
if (SUnpkS16(&spId, mBuf) != ROK)
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgrWarningSiCfgCfm
+S16 cmPkRgrWarningSiCfgCfm
(
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 siId,
-U8 status
+uint8_t siId,
+uint8_t status
)
#else
-PUBLIC S16 cmPkRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
+S16 cmPkRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 siId;
-U8 status;
+uint8_t siId;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrWarningSiCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
*
**********************************************************/
#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;
#endif
{
SuId suId;
- U8 siId;
+ uint8_t siId;
RgrCfgTransId transId;
- U8 status;
+ uint8_t status;
- TRC3(cmUnpkRgrWarningSiCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK)
{
*
**********************************************************/
#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;
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrLoadInfReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
*
**********************************************************/
#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;
RgrCfgTransId transId;
RgrLoadInfReqInfo *loadInfReq;
- TRC3(cmUnpkRgrLoadInfReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
return RFAILED;
}
- cmMemset((U8 *)loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
+ memset(loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
*
**********************************************************/
#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
{
- TRC3(cmPkRgrLoadInfReqInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(oduUnpackUInt8, param->rgrCcPHighStartRb, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrLoadInfReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rgrCcPHighEndRb, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rgrCcPHighStartRb, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeCqiReptCfg)
CMCHKPK(oduUnpackUInt8, param->numColltdCqiRept, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeCqiReptCfg)
CMCHKUNPK(oduPackUInt8, ¶m->numColltdCqiRept, mBuf);
*
**********************************************************/
#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;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
*
**********************************************************/
#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;
SuId suId;
RgrStaIndInfo *staInd;
- TRC3(cmUnpkRgrStaInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
*
**********************************************************/
#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
{
- TRC3(cmPkRgrStaIndInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrStaIndInfo)
CMCHKUNPK(cmUnpkRgrUeCqiInfo, ¶m->ueCqiInfo, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
*
**********************************************************/
#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
{
S16 idx;
- TRC3(cmPkRgrUeCqiInfo)
for (idx = param->numCqiRept - 1; idx >= 0; idx--)
{
*
**********************************************************/
#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
{
- U8 idx;
- TRC3(cmUnpkRgrUeCqiInfo)
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numCqiRept, mBuf);
for (idx = 0; idx < param->numCqiRept; idx++)
*
**********************************************************/
#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
{
- TRC3(cmPkRgrSubBandCqiInfo)
CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
*
**********************************************************/
#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
{
S8 idx;
- U8 count;
+ uint8_t count;
- TRC3(cmPkRgrUeCqiRept)
CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrSubBandCqiInfo)
CMCHKUNPK(oduPackUInt8, ¶m->subBandIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqi[1], mBuf);
*
**********************************************************/
#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
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkRgrUeCqiRept)
CMCHKUNPK(oduPackUInt8, ¶m->numSubBand, mBuf);
for (idx = 0; idx < param->numSubBand; idx++)
{
*
**********************************************************/
#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;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrLoadInfInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
*
**********************************************************/
#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;
SuId suId;
RgrLoadInfIndInfo *loadInfInd = NULLP; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
- TRC3(cmUnpkRgrLoadInfInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
*
**********************************************************/
#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
{
- U8 idx;
- TRC3(cmPkRgrLoadInfIndInfo)
+ uint8_t idx;
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(oduUnpackUInt16, param->bw, mBuf);
*
**********************************************************/
#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;
/* dsfr_pal_fixes ** 21-March-2013 ** SKS */
TknStrOSXL *tknStr;
- U16 ndx;
+ uint16_t ndx;
- TRC3(cmUnpkRgrLoadInfIndInfo)
CMCHKUNPK(oduPackUInt32, ¶m->type, mBuf);
if(RGR_ABS == param->type)
{
for(idx = RGR_ABS_PATTERN_LEN -1 ; idx >= 0; idx--)
{
- CMCHKUNPK(oduPackUInt32, ¶m->u.absLoadInfo[(U8)idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->u.absLoadInfo[(uint8_t)idx], mBuf);
}
}
else
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUepACfg)
if(param->pAPrsnt)
{
*
**********************************************************/
#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
{
- U32 tmpEnum;
- TRC3(cmUnpkRgrUepACfg)
+ uint32_t tmpEnum;
- CMCHKUNPK(oduPackUInt8, (U8 *)¶m->pAPrsnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, (uint8_t *)¶m->pAPrsnt, mBuf);
if (param->pAPrsnt)
{
- CMCHKUNPK(oduPackUInt32, (U32*)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
param->pA = (RgrUeDlPwrCntrlPaCfg) tmpEnum;
}
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUePdschDedCfg)
CMCHKPK(cmPkRgrUepACfg, ¶m->uepACfg, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUePdschDedCfg)
CMCHKUNPK(cmUnpkRgrUepACfg, ¶m->uepACfg, mBuf);
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgrUeUlPwrDedSCellCfg)
CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
CMCHKPK(SPkS8, param->p0UePusch, mBuf);
CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
#endif
{
- TRC3(cmUnpkRgrUeUlPwrDedSCellCfg)
CMCHKUNPK(oduPackUInt8, ¶m->isAccumulated, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isDeltaMCSEnabled, mBuf);
CMCHKPK(cmPkRgrUePdschDedCfg, ¶m->uePdschDedCfg, mBuf);
#endif
CMCHKPK(cmPkRgrUeDlCqiCfg,¶m->ueSCellDlCqiCfg, mBuf);
- CMCHKPK(cmPkTknU32, ¶m->sCellDeActTmr, mBuf);
+ CMCHKPK(cmPkTknUInt32, ¶m->sCellDeActTmr, mBuf);
CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
*
**********************************************************/
#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
S8 idx;
for(idx = param->numSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkRgrUeSecCellCfg, ¶m->ueSCellDedCfg[(U8)idx],mBuf);
+ CMCHKPK(cmPkRgrUeSecCellCfg, ¶m->ueSCellDedCfg[(uint8_t)idx],mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
{
CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->sCellId, mBuf);
- CMCHKUNPK(cmUnpkTknU32, ¶m->sCellDeActTmr, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32, ¶m->sCellDeActTmr, mBuf);
CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, ¶m->ueSCellDlCqiCfg, mBuf);
#ifdef TFU_UPGRADE
CMCHKUNPK(cmUnpkRgrUePdschDedCfg, ¶m->uePdschDedCfg, mBuf);
*
**********************************************************/
#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
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->useExtBSRSizes, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
*
**********************************************************/
#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
{
S8 idx;
- TRC3(cmPkRgrUeSCellAckPucchCfg);
if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
{
for(idx = param->u.format1Bcs.sCellAckN1ResTb2Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
for(idx = param->u.format1Bcs.sCellAckN1ResTb1Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
{
for(idx = param->u.format3.sCellAckN3ResAntP1Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
for(idx = param->u.format3.sCellAckN3ResAntP0Count- 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
*
**********************************************************/
#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
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkRgrUeSCellAckPucchCfg);
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->pucchFormatType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->pucchFormatType, mBuf);
//if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS)
if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
{
*
**********************************************************/
#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;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkRgrUeStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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;
SuId suId;
RgrUeStaIndInfo *ueStaInd;
- TRC3(cmUnpkRgrUeStaInd)
if (SUnpkS16(&suId, mBuf) != ROK)
{
*
**********************************************************/
#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
{
- TRC3(cmPkRgrUeStaIndInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrUeStaIndInfo)
CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCellCsgParamCfg)
CMCHKPK(oduUnpackUInt8, param->minUlResNonCsg, mBuf);
CMCHKPK(oduUnpackUInt8, param->minDlResNonCsg, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmUnpkRgrCellCsgParamCfg)
CMCHKUNPK(oduPackUInt8, ¶m->minDlResNonCsg, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->minUlResNonCsg, mBuf);
*
**********************************************************/
#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
{
- TRC3(cmPkRgrCellCntrlCmdCfg)
switch(param->cmdType)
{
*
**********************************************************/
#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
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkRgrCellCntrlCmdCfg)
CMCHKUNPK(oduPackUInt32, &tmpEnum, mBuf);
param->cmdType = (RgrCellCntrlCmdType) tmpEnum;
Code Review / o-du / l2.git / blobdiff