* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCfgReq
+S16 cmPkLrgCfgReq
(
Pst * pst,
RgMngmt * cfg
)
#else
-PUBLIC S16 cmPkLrgCfgReq(pst, cfg)
+S16 cmPkLrgCfgReq(pst, cfg)
Pst * pst;
RgMngmt * cfg;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCfgReq
+S16 cmUnpkLrgCfgReq
(
LrgCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCfgReq(func, pst, mBuf)
+S16 cmUnpkLrgCfgReq(func, pst, mBuf)
LrgCfgReq func;
Pst *pst;
Buffer *mBuf;
/* lrg_c_001.main_2: Changed Pointer across Interface */
RgMngmt cfg;
- TRC3(cmUnpkLrgCfgReq)
if (cmUnpkRgMngmt(pst, &cfg, EVTLRGCFGREQ, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCfgReq
+S16 cmPkLrgSchCfgReq
(
Pst * pst,
RgMngmt * cfg
)
#else
-PUBLIC S16 cmPkLrgSchCfgReq(pst, cfg)
+S16 cmPkLrgSchCfgReq(pst, cfg)
Pst * pst;
RgMngmt * cfg;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCfgReq
+S16 cmUnpkLrgSchCfgReq
(
LrgSchCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCfgReq(func, pst, mBuf)
+S16 cmUnpkLrgSchCfgReq(func, pst, mBuf)
LrgSchCfgReq func;
Pst *pst;
Buffer *mBuf;
/* lrg_c_001.main_2: Changed Pointer across Interface */
RgMngmt cfg;
- TRC3(cmUnpkLrgSchCfgReq)
if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCfgCfm
+uint8_t cmPkLrgCfgCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgCfgCfm(pst, cfm)
+uint8_t cmPkLrgCfgCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCfgCfm
+S16 cmUnpkLrgCfgCfm
(
LrgCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCfgCfm(func, pst, mBuf)
+S16 cmUnpkLrgCfgCfm(func, pst, mBuf)
LrgCfgCfm func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cfm;
- TRC3(cmUnpkLrgCfgCfm)
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCFGCFM, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCfgCfm
+uint8_t cmPkLrgSchCfgCfm
(
Pst * pst,
RgMngmt * cfg
)
#else
-PUBLIC S16 cmPkLrgSchCfgCfm(pst, cfg)
+uint8_t cmPkLrgSchCfgCfm(pst, cfg)
Pst * pst;
RgMngmt * cfg;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCfgCfm
+S16 cmUnpkLrgSchCfgCfm
(
LrgSchCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCfgCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchCfgCfm(func, pst, mBuf)
LrgSchCfgCfm func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cfg;
- TRC3(cmUnpkLrgSchCfgCfm)
-
if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStsReq
+S16 cmPkLrgStsReq
(
Pst * pst,
RgMngmt * sts
)
#else
-PUBLIC S16 cmPkLrgStsReq(pst, sts)
+S16 cmPkLrgStsReq(pst, sts)
Pst * pst;
RgMngmt * sts;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStsReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStsReq
+S16 cmUnpkLrgStsReq
(
LrgStsReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStsReq(func, pst, mBuf)
+S16 cmUnpkLrgStsReq(func, pst, mBuf)
LrgStsReq func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt sts;
- TRC3(cmUnpkLrgStsReq)
if (cmUnpkRgMngmt(pst, &sts, EVTLRGSTSREQ, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStsCfm
+S16 cmPkLrgStsCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgStsCfm(pst, cfm)
+S16 cmPkLrgStsCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStsCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStsCfm
+S16 cmUnpkLrgStsCfm
(
LrgStsCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStsCfm(func, pst, mBuf)
+S16 cmUnpkLrgStsCfm(func, pst, mBuf)
LrgStsCfm func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cfm;
- TRC3(cmUnpkLrgStsCfm)
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGSTSCFM, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStaReq
+S16 cmPkLrgStaReq
(
Pst * pst,
RgMngmt * sta
)
#else
-PUBLIC S16 cmPkLrgStaReq(pst, sta)
+S16 cmPkLrgStaReq(pst, sta)
Pst * pst;
RgMngmt * sta;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStaReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaReq
+S16 cmUnpkLrgStaReq
(
LrgStaReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStaReq(func, pst, mBuf)
+S16 cmUnpkLrgStaReq(func, pst, mBuf)
LrgStaReq func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt sta;
- TRC3(cmUnpkLrgStaReq)
- cmMemset((U8 *)&sta, 0, sizeof(RgMngmt));
+ memset(&sta, 0, sizeof(RgMngmt));
if (cmUnpkRgMngmt(pst, &sta, EVTLRGSSTAREQ, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStaCfm
+S16 cmPkLrgStaCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgStaCfm(pst, cfm)
+S16 cmPkLrgStaCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStaCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaCfm
+S16 cmUnpkLrgStaCfm
(
LrgStaCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStaCfm(func, pst, mBuf)
+S16 cmUnpkLrgStaCfm(func, pst, mBuf)
LrgStaCfm func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cfm;
- TRC3(cmUnpkLrgStaCfm)
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGSSTACFM, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgStaInd
+S16 cmPkLrgStaInd
(
Pst * pst,
RgMngmt * usta
)
#else
-PUBLIC S16 cmPkLrgStaInd(pst, usta)
+S16 cmPkLrgStaInd(pst, usta)
Pst * pst;
RgMngmt * usta;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaInd
+S16 cmUnpkLrgStaInd
(
LrgStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgStaInd(func, pst, mBuf)
+S16 cmUnpkLrgStaInd(func, pst, mBuf)
LrgStaInd func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt usta;
- TRC3(cmUnpkLrgStaInd)
if (cmUnpkRgMngmt(pst, &usta, EVTLRGUSTAIND, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchStaInd
+S16 cmPkLrgSchStaInd
(
Pst * pst,
RgMngmt * sta
)
#else
-PUBLIC S16 cmPkLrgSchStaInd(pst, sta)
+S16 cmPkLrgSchStaInd(pst, sta)
Pst * pst;
RgMngmt * sta;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchStaInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchStaInd
+S16 cmUnpkLrgSchStaInd
(
LrgSchStaInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchStaInd(func, pst, mBuf)
+S16 cmUnpkLrgSchStaInd(func, pst, mBuf)
LrgSchStaInd func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt sta;
- TRC3(cmUnpkLrgSchStaInd)
if (cmUnpkRgMngmt(pst, &sta, EVTLRGSCHSTAIND, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCntrlReq
+S16 cmPkLrgCntrlReq
(
Pst * pst,
RgMngmt * cntrl
)
#else
-PUBLIC S16 cmPkLrgCntrlReq(pst, cntrl)
+S16 cmPkLrgCntrlReq(pst, cntrl)
Pst * pst;
RgMngmt * cntrl;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCntrlReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCntrlReq
+S16 cmUnpkLrgCntrlReq
(
LrgCntrlReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCntrlReq(func, pst, mBuf)
+S16 cmUnpkLrgCntrlReq(func, pst, mBuf)
LrgCntrlReq func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cntrl;
- TRC3(cmUnpkLrgCntrlReq)
if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGCNTRLREQ, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCntrlReq
+S16 cmPkLrgSchCntrlReq
(
Pst * pst,
RgMngmt * cntrl
)
#else
-PUBLIC S16 cmPkLrgSchCntrlReq(pst, cntrl)
+S16 cmPkLrgSchCntrlReq(pst, cntrl)
Pst * pst;
RgMngmt * cntrl;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCntrlReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCntrlReq
+S16 cmUnpkLrgSchCntrlReq
(
LrgSchCntrlReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCntrlReq(func, pst, mBuf)
+S16 cmUnpkLrgSchCntrlReq(func, pst, mBuf)
LrgSchCntrlReq func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cntrl;
- TRC3(cmUnpkLrgSchCntrlReq)
if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLREQ, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgCntrlCfm
+S16 cmPkLrgCntrlCfm
(
Pst * pst,
RgMngmt * cfm
)
#else
-PUBLIC S16 cmPkLrgCntrlCfm(pst, cfm)
+S16 cmPkLrgCntrlCfm(pst, cfm)
Pst * pst;
RgMngmt * cfm;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgCntrlCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgCntrlCfm
+S16 cmUnpkLrgCntrlCfm
(
LrgCntrlCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgCntrlCfm(func, pst, mBuf)
+S16 cmUnpkLrgCntrlCfm(func, pst, mBuf)
LrgCntrlCfm func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cfm;
- TRC3(cmUnpkLrgCntrlCfm)
if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCNTRLCFM, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchCntrlCfm
+S16 cmPkLrgSchCntrlCfm
(
Pst * pst,
RgMngmt * cntrl
)
#else
-PUBLIC S16 cmPkLrgSchCntrlCfm(pst, cntrl)
+S16 cmPkLrgSchCntrlCfm(pst, cntrl)
Pst * pst;
RgMngmt * cntrl;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchCntrlCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCntrlCfm
+S16 cmUnpkLrgSchCntrlCfm
(
LrgSchCntrlCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchCntrlCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchCntrlCfm(func, pst, mBuf)
LrgSchCntrlCfm func;
Pst *pst;
Buffer *mBuf;
{
RgMngmt cntrl;
- TRC3(cmUnpkLrgSchCntrlCfm)
if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLCFM, mBuf) != ROK) {
SPutMsg(mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgTrcInd
+S16 cmPkLrgTrcInd
(
Pst * pst,
RgMngmt * trc,
Buffer * trcBuf
)
#else
-PUBLIC S16 cmPkLrgTrcInd(pst, trc, trcBuf)
+S16 cmPkLrgTrcInd(pst, trc, trcBuf)
Pst * pst;
RgMngmt * trc;
Buffer * trcBuf;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgTrcInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgTrcInd
+S16 cmUnpkLrgTrcInd
(
LrgTrcInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgTrcInd(func, pst, mBuf)
+S16 cmUnpkLrgTrcInd(func, pst, mBuf)
LrgTrcInd func;
Pst *pst;
Buffer *mBuf;
/* lrg_c_001.main_3 - MODIFY - Modified trcBuf to have it initialized to NULLP */
Buffer *trcBuf = NULLP;
- TRC3(cmUnpkLrgTrcInd)
if (cmUnpkRgMngmt(pst, &trc, EVTLRGTRCIND, mBuf) != ROK) {
SPutMsg(mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgGenCfg
+S16 cmPkRgGenCfg
(
RgGenCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgGenCfg(param, mBuf)
+S16 cmPkRgGenCfg(param, mBuf)
RgGenCfg *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgGenCfg)
#ifdef LTE_ADV
CMCHKPK(oduUnpackUInt8, param->isSCellActDeactAlgoEnable, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgGenCfg
+S16 cmUnpkRgGenCfg
(
RgGenCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgGenCfg(param, mBuf)
+S16 cmUnpkRgGenCfg(param, mBuf)
RgGenCfg *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgGenCfg)
CMCHKUNPK(cmUnpkPst, ¶m->lmPst, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgUpSapCfg
+S16 cmPkRgUpSapCfg
(
RgUpSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgUpSapCfg(param, mBuf)
+S16 cmPkRgUpSapCfg(param, mBuf)
RgUpSapCfg *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgUpSapCfg)
CMCHKPK(SPkS16, param->suId, mBuf);
CMCHKPK(SPkS16, param->spId, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgUpSapCfg
+S16 cmUnpkRgUpSapCfg
(
RgUpSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgUpSapCfg(param, mBuf)
+S16 cmUnpkRgUpSapCfg(param, mBuf)
RgUpSapCfg *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgUpSapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->selector, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgLowSapCfg
+S16 cmPkRgLowSapCfg
(
RgLowSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgLowSapCfg(param, mBuf)
+S16 cmPkRgLowSapCfg(param, mBuf)
RgLowSapCfg *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgLowSapCfg)
CMCHKPK(cmPkTmrCfg, ¶m->bndTmr, mBuf);
CMCHKPK(SPkS16, param->suId, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgLowSapCfg
+S16 cmUnpkRgLowSapCfg
(
RgLowSapCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgLowSapCfg(param, mBuf)
+S16 cmUnpkRgLowSapCfg(param, mBuf)
RgLowSapCfg *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgLowSapCfg)
CMCHKUNPK(oduPackUInt8, ¶m->selector, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgAckNack
+S16 cmPkRgAckNack
(
RgAckNack *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgAckNack (param, mBuf)
+S16 cmPkRgAckNack (param, mBuf)
RgAckNack *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgAckNack)
CMCHKPK(oduUnpackUInt16, param->numOfAcks, mBuf);
CMCHKPK(oduUnpackUInt16, param->numOfNacks, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchNackAckStats
+S16 cmPkRgSchNackAckStats
(
RgSchNackAckStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchNackAckStats (param, mBuf)
+S16 cmPkRgSchNackAckStats (param, mBuf)
RgSchNackAckStats *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkRgSchNackAckStats)
for (i=14; i >= 0; i--) {
CMCHKPK(cmPkRgAckNack, ¶m->ulCqiStat[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgHqNumRetx
+S16 cmPkRgHqNumRetx
(
RgSchHqNumRetx *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgHqNumRetx (param, mBuf)
+S16 cmPkRgHqNumRetx (param, mBuf)
RgSchHqNumRetx *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgHqNumRetx)
CMCHKPK(oduUnpackUInt32, param->totalTx, mBuf);
CMCHKPK(oduUnpackUInt16, param->numOfHQ_4, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchHqRetxStats
+S16 cmPkRgSchHqRetxStats
(
RgSchHqRetxStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchHqRetxStats (param, mBuf)
+S16 cmPkRgSchHqRetxStats (param, mBuf)
RgSchHqRetxStats *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkRgSchHqRetxStats)
for (i=14; i >= 0; i--) {
CMCHKPK(cmPkRgHqNumRetx, ¶m->ulCqiStat[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgAckNack
+S16 cmUnpkRgAckNack
(
RgAckNack *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgAckNack (param, mBuf)
+S16 cmUnpkRgAckNack (param, mBuf)
RgAckNack *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgAckNack)
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->numOfNacks, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchNackAckStats
+S16 cmUnpkRgSchNackAckStats
(
RgSchNackAckStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchNackAckStats (param, mBuf)
+S16 cmUnpkRgSchNackAckStats (param, mBuf)
RgSchNackAckStats *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkRgSchNackAckStats)
for (i=0; i <= 14; i++) {
CMCHKUNPK(cmUnpkRgAckNack, ¶m->dlCqiStat[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgHqNumRetx
+S16 cmUnpkRgHqNumRetx
(
RgSchHqNumRetx *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgHqNumRetx (param, mBuf)
+S16 cmUnpkRgHqNumRetx (param, mBuf)
RgSchHqNumRetx *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgHqNumRetx)
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->numOfHQ_1, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchHqRetxStats
+S16 cmUnpkRgSchHqRetxStats
(
RgSchHqRetxStats *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchHqRetxStats (param, mBuf)
+S16 cmUnpkRgSchHqRetxStats (param, mBuf)
RgSchHqRetxStats *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkRgSchHqRetxStats)
for (i=0; i <= 14; i++) {
CMCHKUNPK(cmUnpkRgHqNumRetx, ¶m->dlCqiStat[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgGenSts
+S16 cmPkRgGenSts
(
RgGenSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgGenSts(param, mBuf)
+S16 cmPkRgGenSts(param, mBuf)
RgGenSts *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgGenSts)
#ifdef MAC_SCH_STATS
CMCHKPK(cmPkRgSchHqRetxStats, ¶m->hqRetxStats, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgGenSts
+S16 cmUnpkRgGenSts
(
RgGenSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgGenSts(param, mBuf)
+S16 cmUnpkRgGenSts(param, mBuf)
RgGenSts *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgGenSts)
CMCHKUNPK(oduPackUInt32, ¶m->numHarqFail, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numUeCfg, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSapSts
+S16 cmPkRgSapSts
(
RgSapSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSapSts(param, mBuf)
+S16 cmPkRgSapSts(param, mBuf)
RgSapSts *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgSapSts)
CMCHKPK(oduUnpackUInt32, param->numPduDrop, mBuf);
CMCHKPK(oduUnpackUInt32, param->numPduTxmit, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSapSts
+S16 cmUnpkRgSapSts
(
RgSapSts *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSapSts(param, mBuf)
+S16 cmUnpkRgSapSts(param, mBuf)
RgSapSts *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgSapSts)
CMCHKUNPK(oduPackUInt32, ¶m->numPduRcvd, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numPduTxmit, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchInstCfg
+S16 cmPkRgSchInstCfg
(
RgSchInstCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchInstCfg(param, mBuf)
+S16 cmPkRgSchInstCfg(param, mBuf)
RgSchInstCfg *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkRgSchInstCfg)
for (i=param->numSaps-1; i >= 0; i--) {
CMCHKPK(cmPkRgLowSapCfg, ¶m->tfuSap[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchInstCfg
+S16 cmUnpkRgSchInstCfg
(
RgSchInstCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchInstCfg(param, mBuf)
+S16 cmUnpkRgSchInstCfg(param, mBuf)
RgSchInstCfg *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkRgSchInstCfg)
CMCHKUNPK(oduPackUInt8, ¶m->instId, mBuf);
CMCHKUNPK(cmUnpkRgGenCfg, ¶m->genCfg, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgCfg
+S16 cmPkRgCfg
(
RgCfg *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgCfg(param, elmnt, mBuf)
+S16 cmPkRgCfg(param, elmnt, mBuf)
RgCfg *param;
S16 elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgCfg)
switch(elmnt) {
case STSCHINST:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgCfg
+S16 cmUnpkRgCfg
(
RgCfg *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgCfg(param, elmnt, mBuf)
+S16 cmUnpkRgCfg(param, elmnt, mBuf)
RgCfg *param;
S16 elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgCfg)
switch(elmnt) {
case STGEN:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSapSta
+S16 cmPkRgSapSta
(
RgSapSta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSapSta(param, mBuf)
+S16 cmPkRgSapSta(param, mBuf)
RgSapSta *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgSapSta)
CMCHKPK(oduUnpackUInt8, param->sapState, mBuf);
return ROK;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSapSta
+S16 cmUnpkRgSapSta
(
RgSapSta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSapSta(param, mBuf)
+S16 cmUnpkRgSapSta(param, mBuf)
RgSapSta *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgSapSta)
CMCHKUNPK(oduPackUInt8, ¶m->sapState, mBuf);
return ROK;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSts
+S16 cmPkRgSts
(
RgSts *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSts(param, elmnt, mBuf)
+S16 cmPkRgSts(param, elmnt, mBuf)
RgSts *param;
S16 elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgSts)
switch(elmnt) {
case STTFUSAP:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSts
+S16 cmUnpkRgSts
(
RgSts *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSts(param, elmnt, mBuf)
+S16 cmUnpkRgSts(param, elmnt, mBuf)
RgSts *param;
S16 elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgSts)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sapInst, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSsta
+S16 cmPkRgSsta
(
Pst *pst,
RgSsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
+S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
Pst *pst;
RgSsta *param;
S16 elmnt;
#endif
{
- TRC3(cmPkRgSsta)
switch(elmnt) {
case STTFUSAP:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSsta
+S16 cmUnpkRgSsta
(
Pst *pst,
RgSsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
+S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
Pst *pst;
RgSsta *param;
S16 elmnt;
#endif
{
- TRC3(cmUnpkRgSsta)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sapInst, mBuf);
/* KWORK_FIX: Moved the memset under the NULL check */
if (param->s.sysId.ptNmb != NULLP)
{
- cmMemset((U8 *)param->s.sysId.ptNmb, 0, LRG_MAX_PT_NUM_SIZE);
+ memset(param->s.sysId.ptNmb, 0, LRG_MAX_PT_NUM_SIZE);
CMCHKUNPK(cmUnpkSystemId, ¶m->s.sysId, mBuf);
}
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgUstaDgn
+S16 cmPkRgUstaDgn
(
RgUstaDgn *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgUstaDgn(param, mBuf)
+S16 cmPkRgUstaDgn(param, mBuf)
RgUstaDgn *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgUstaDgn)
switch(param->type) {
case LRG_USTA_DGNVAL_MEM:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgUstaDgn
+S16 cmUnpkRgUstaDgn
(
RgUstaDgn *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgUstaDgn(param, mBuf)
+S16 cmUnpkRgUstaDgn(param, mBuf)
RgUstaDgn *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgUstaDgn)
CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
switch(param->type) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgUsta
+S16 cmPkRgUsta
(
RgUsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgUsta(param, mBuf)
+S16 cmPkRgUsta(param, mBuf)
RgUsta *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgUsta)
CMCHKPK(cmPkRgUstaDgn, ¶m->dgn, mBuf);
CMCHKPK(cmPkCmAlarm, ¶m->cmAlarm, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgUsta
+S16 cmUnpkRgUsta
(
RgUsta *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgUsta(param, mBuf)
+S16 cmUnpkRgUsta(param, mBuf)
RgUsta *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgUsta)
CMCHKUNPK(cmUnpkCmAlarm, ¶m->cmAlarm, mBuf);
CMCHKUNPK(cmUnpkRgUstaDgn, ¶m->dgn, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgTrc
+S16 cmPkRgTrc
(
RgTrc *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgTrc(param, mBuf)
+S16 cmPkRgTrc(param, mBuf)
RgTrc *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgTrc)
CMCHKPK(oduUnpackUInt8, param->evnt, mBuf);
CMCHKPK(cmPkDateTime, ¶m->dt, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgTrc
+S16 cmUnpkRgTrc
(
RgTrc *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgTrc(param, mBuf)
+S16 cmUnpkRgTrc(param, mBuf)
RgTrc *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgTrc)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->evnt, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgDbgCntrl
+S16 cmPkRgDbgCntrl
(
RgDbgCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgDbgCntrl(param, mBuf)
+S16 cmPkRgDbgCntrl(param, mBuf)
RgDbgCntrl *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgDbgCntrl)
CMCHKPK(oduUnpackUInt32, param->dbgMask, mBuf);
return ROK;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSchUlAllocCntrl
+S16 cmPkRgSchUlAllocCntrl
(
RgSchUlAllocCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSchUlAllocCntrl(param, mBuf)
+S16 cmPkRgSchUlAllocCntrl(param, mBuf)
RgSchUlAllocCntrl *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgSchUlAllocCntrl)
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(oduUnpackUInt16, param->numOfRb, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSchUlAllocCntrl
+S16 cmUnpkRgSchUlAllocCntrl
(
RgSchUlAllocCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSchUlAllocCntrl(param, mBuf)
+S16 cmUnpkRgSchUlAllocCntrl(param, mBuf)
RgSchUlAllocCntrl *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgSchUlAllocCntrl)
CMCHKUNPK(oduPackUInt16, ¶m->logTime, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->enaLog, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgDbgCntrl
+S16 cmUnpkRgDbgCntrl
(
RgDbgCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgDbgCntrl(param, mBuf)
+S16 cmUnpkRgDbgCntrl(param, mBuf)
RgDbgCntrl *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgDbgCntrl)
CMCHKUNPK(oduPackUInt32, ¶m->dbgMask, mBuf);
return ROK;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgSapCntrl
+S16 cmPkRgSapCntrl
(
RgSapCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgSapCntrl(param, mBuf)
+S16 cmPkRgSapCntrl(param, mBuf)
RgSapCntrl *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgSapCntrl)
CMCHKPK(SPkS16, param->spId, mBuf);
CMCHKPK(SPkS16, param->suId, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgSapCntrl
+S16 cmUnpkRgSapCntrl
(
RgSapCntrl *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgSapCntrl(param, mBuf)
+S16 cmUnpkRgSapCntrl(param, mBuf)
RgSapCntrl *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgSapCntrl)
CMCHKUNPK(SUnpkS16, ¶m->suId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->spId, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgCntrl
+S16 cmPkRgCntrl
(
RgCntrl *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgCntrl(param, elmnt, mBuf)
+S16 cmPkRgCntrl(param, elmnt, mBuf)
RgCntrl *param;
S16 elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmPkRgCntrl)
switch(elmnt) {
case STTFUSAP:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgCntrl
+S16 cmUnpkRgCntrl
(
RgCntrl *param,
S16 elmnt,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgCntrl(param, elmnt, mBuf)
+S16 cmUnpkRgCntrl(param, elmnt, mBuf)
RgCntrl *param;
S16 elmnt;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkRgCntrl)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkRgMngmt
+S16 cmPkRgMngmt
(
Pst *pst,
RgMngmt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkRgMngmt(pst, param, eventType, mBuf)
+S16 cmPkRgMngmt(pst, param, eventType, mBuf)
Pst *pst;
RgMngmt *param;
U8 eventType;
#endif
{
- TRC3(cmPkRgMngmt)
switch(eventType) {
case EVTLRGCNTRLREQ:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkRgMngmt
+S16 cmUnpkRgMngmt
(
Pst *pst,
RgMngmt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
+S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
Pst *pst;
RgMngmt *param;
U8 eventType;
#endif
{
- TRC3(cmUnpkRgMngmt)
CMCHKUNPK(cmUnpkHeader, ¶m->hdr, mBuf);
CMCHKUNPK(cmUnpkCmStatus, ¶m->cfm, mBuf);
{
U8 idx;
- TRC3(cmPkNmbActvUeQciReq)
for(idx = 0; idx < nmbActvUeQci->numQci; idx++)
{
{
U8 idx;
- TRC3(cmPkAvgPrbQciReq)
-
for(idx = 0; idx < avgPrbQciReq->numQci; idx++)
{
CMCHKPK(oduUnpackUInt8, avgPrbQciReq->qci[idx], mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasReq
+S16 cmPkLrgSchL2MeasReq
(
Pst * pst,
LrgSchMeasReqInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasReq(pst, measInfo)
Pst * pst;
LrgSchMeasReqInfo *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasStopReq
+S16 cmPkLrgSchL2MeasStopReq
(
Pst * pst,
LrgSchMeasStopReqInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasStopReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasStopReq(pst, measInfo)
Pst * pst;
LrgSchMeasStopReqInfo *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasStopReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasSendReq
+S16 cmPkLrgSchL2MeasSendReq
(
Pst * pst,
LrgSchMeasSndReqInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasSendReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasSendReq(pst, measInfo)
Pst * pst;
LrgSchMeasSndReqInfo *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasSendReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
{
U8 idx;
- TRC3(cmUnpkNmbActvUeQciReq)
-
CMCHKUNPK(oduPackUInt8, ¶m->sampPrd, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
U8 idx;
- TRC3(cmUnpkAvgPrbQciReq)
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasReq
+S16 cmUnpkLrgSchL2MeasReq
(
LrgSchL2MeasReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasReq(func, pst, mBuf)
LrgSchL2MeasReq func;
Pst *pst;
Buffer *mBuf;
{
LrgSchMeasReqInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasReq)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasStopReq
+S16 cmUnpkLrgSchL2MeasStopReq
(
LrgSchL2MeasStopReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasStopReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasStopReq(func, pst, mBuf)
LrgSchL2MeasStopReq func;
Pst *pst;
Buffer *mBuf;
{
LrgSchMeasStopReqInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasStopReq)
-
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
/*CMCHKUNPK(oduPackUInt16, &measInfo.timePrd, mBuf);*/
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasSendReq
+S16 cmUnpkLrgSchL2MeasSendReq
(
LrgSchL2MeasSendReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasSendReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasSendReq(func, pst, mBuf)
LrgSchL2MeasSendReq func;
Pst *pst;
Buffer *mBuf;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasStopCfm
+S16 cmPkLrgSchL2MeasStopCfm
(
Pst * pst,
LrgSchMeasCfmInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasStopCfm(pst, measInfo)
+S16 cmPkLrgSchL2MeasStopCfm(pst, measInfo)
Pst * pst;
LrgSchMeasCfmInfo *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasStopCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasStopCfm
+S16 cmUnpkLrgSchL2MeasStopCfm
(
LrgSchL2MeasStopCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasStopCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasStopCfm(func, pst, mBuf)
LrgSchL2MeasStopCfm func;
Pst *pst;
Buffer *mBuf;
{
LrgSchMeasCfmInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasCfm)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
{
U8 idx;
- TRC3(cmPkNumUeQciCfm)
for(idx = 0; idx < param->numQci; idx++)
{
{
U8 idx;
- TRC3(cmPkAvgPrbQciCfm)
for(idx = 0; idx < param->numQci; idx++)
{
/*LRG : Review Tag*/
#endif
{
- TRC3(cmPkRaPrmbsCfm)
CMCHKPK(oduUnpackUInt16, param->randSelPreHighRange, mBuf);
CMCHKPK(oduUnpackUInt16, param->randSelPreLowRange, mBuf);
CMCHKPK(oduUnpackUInt16, param->dedPreambles, mBuf);
#endif
{
- TRC3(cmPkAvgPrbCfm)
CMCHKPK(oduUnpackUInt8, param->prbPerc, mBuf);
return ROK;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasCfm
+S16 cmPkLrgSchL2MeasCfm
(
Pst * pst,
LrgSchMeasCfmInfo *measInfo
)
#else
-PUBLIC S16 cmPkLrgSchL2MeasCfm(pst, measInfo)
+S16 cmPkLrgSchL2MeasCfm(pst, measInfo)
Pst * pst;
LrgSchMeasCfmInfo *measInfo;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkLrgSchL2MeasCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
{
U8 idx;
- TRC3(cmUnpkNumUeQciCfm)
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
{
U8 idx;
- TRC3(cmUnpkAvgPrbQciCfm)
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
#endif
{
- TRC3(cmUnpkRaPrmbsCfm)
CMCHKUNPK(oduPackUInt16, ¶m->dedPreambles, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->randSelPreLowRange, mBuf);
#endif
{
- TRC3(cmUnpkAvgPrbCfm)
CMCHKUNPK(oduPackUInt8, ¶m->prbPerc, mBuf);
return ROK;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasCfm
+S16 cmUnpkLrgSchL2MeasCfm
(
LrgSchL2MeasCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkLrgSchL2MeasCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasCfm(func, pst, mBuf)
LrgSchL2MeasCfm func;
Pst *pst;
Buffer *mBuf;
{
LrgSchMeasCfmInfo measInfo;
- TRC3(cmUnpkLrgSchL2MeasCfm)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);