replaced cmMemSet, cmMemcpy with memset and memcpy resp AND Removed TRC() traces...

[o-du/l2.git] / src / cm / lrg.c

diff --git a/src/cm/lrg.c b/src/cm/lrg.c
index d00e157..e28c1ea 100755 (executable)
--- a/src/cm/lrg.c
+++ b/src/cm/lrg.c
@@ -57,19 +57,18 @@ Configuration Request from LM to MAC.
 *      -# 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)
@@ -109,14 +108,14 @@ Configuration Request from LM to MAC.
 *      -# 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;
@@ -125,7 +124,6 @@ Buffer *mBuf;
    /* lrg_c_001.main_2: Changed Pointer across Interface */
    RgMngmt cfg;
    
-   TRC3(cmUnpkLrgCfgReq)
    
    if (cmUnpkRgMngmt(pst, &cfg, EVTLRGCFGREQ, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -155,19 +153,18 @@ Configuration Request from LM to SCH.
 *      -# 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)
@@ -207,14 +204,14 @@ Configuration Request from LM to SCH.
 *      -# 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;
@@ -223,7 +220,6 @@ Buffer *mBuf;
    /* lrg_c_001.main_2: Changed Pointer across Interface */
    RgMngmt cfg;
    
-   TRC3(cmUnpkLrgSchCfgReq)
 
    if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -253,19 +249,18 @@ Configuration Confirm from MAC to LM.
 *      -# 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)
@@ -306,14 +301,14 @@ Configuration Confirm from MAC to LM.
 *      -# 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;
@@ -321,7 +316,6 @@ Buffer *mBuf;
 {
    RgMngmt cfm;
    
-   TRC3(cmUnpkLrgCfgCfm)
 
    if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCFGCFM, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -351,19 +345,18 @@ Configuration Confirm from SCH to LM.
 *      -# 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)
@@ -404,14 +397,14 @@ Configuration Confirm from SCH to LM.
 *      -# 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;
@@ -419,8 +412,6 @@ Buffer *mBuf;
 {
    RgMngmt cfg;
    
-   TRC3(cmUnpkLrgSchCfgCfm)
-  
    if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -449,19 +440,18 @@ Statistics Request from LM to MAC.
 *      -# 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)
@@ -502,14 +492,14 @@ Statistics Request from LM to MAC.
 *      -# 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;
@@ -517,7 +507,6 @@ Buffer *mBuf;
 {
    RgMngmt sts;
    
-   TRC3(cmUnpkLrgStsReq)
 
    if (cmUnpkRgMngmt(pst, &sts, EVTLRGSTSREQ, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -547,19 +536,18 @@ Statistics Confirm from MAC to LM.
 *      -# 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)
@@ -600,14 +588,14 @@ Statistics Confirm from MAC to LM.
 *      -# 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;
@@ -615,7 +603,6 @@ Buffer *mBuf;
 {
    RgMngmt cfm;
    
-   TRC3(cmUnpkLrgStsCfm)
 
    if (cmUnpkRgMngmt(pst, &cfm, EVTLRGSTSCFM, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -645,19 +632,18 @@ Status Request from LM to MAC.
 *      -# 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)
@@ -696,14 +682,14 @@ Status Request from LM to MAC.
 *      -# 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;
@@ -711,9 +697,8 @@ 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,
@@ -742,19 +727,18 @@ Status Confirm from MAC to LM.
 *      -# 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)
@@ -793,14 +777,14 @@ Status Confirm from MAC to LM.
 *      -# 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;
@@ -808,9 +792,8 @@ 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,
@@ -839,19 +822,18 @@ Status Indication from MAC to LM.
 *      -# 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)
@@ -892,14 +874,14 @@ Status Indication from MAC to LM.
 *      -# 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;
@@ -907,7 +889,6 @@ Buffer *mBuf;
 {
    RgMngmt usta;
    
-   TRC3(cmUnpkLrgStaInd)
 
    if (cmUnpkRgMngmt(pst, &usta, EVTLRGUSTAIND, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -937,19 +918,18 @@ Status Indication from SCH to LM.
 *      -# 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)
@@ -990,14 +970,14 @@ Status Indication from SCH to LM.
 *      -# 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;
@@ -1005,7 +985,6 @@ Buffer *mBuf;
 {
    RgMngmt sta;
    
-   TRC3(cmUnpkLrgSchStaInd)
 
    if (cmUnpkRgMngmt(pst, &sta, EVTLRGSCHSTAIND, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -1035,19 +1014,18 @@ Control Request from LM to MAC.
 *      -# 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)
@@ -1088,14 +1066,14 @@ Control Request from LM to MAC.
 *      -# 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;
@@ -1103,7 +1081,6 @@ Buffer *mBuf;
 {
    RgMngmt cntrl;
    
-   TRC3(cmUnpkLrgCntrlReq)
 
    if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGCNTRLREQ, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -1133,19 +1110,18 @@ Control Request from LM to SCH.
 *      -# 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)
@@ -1186,14 +1162,14 @@ Control Request from LM to SCH.
 *      -# 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;
@@ -1201,7 +1177,6 @@ Buffer *mBuf;
 {
    RgMngmt cntrl;
    
-   TRC3(cmUnpkLrgSchCntrlReq)
 
    if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLREQ, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -1231,19 +1206,18 @@ Control Confirm from MAC to LM.
 *      -# 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)
@@ -1284,14 +1258,14 @@ Control Confirm from MAC to LM.
 *      -# 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;
@@ -1299,7 +1273,6 @@ Buffer *mBuf;
 {
    RgMngmt cfm;
    
-   TRC3(cmUnpkLrgCntrlCfm)
 
    if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCNTRLCFM, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -1329,19 +1302,18 @@ Control Confirm from SCH to LM.
 *      -# 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)
@@ -1382,14 +1354,14 @@ Control Confirm from SCH to LM.
 *      -# 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;
@@ -1397,7 +1369,6 @@ Buffer *mBuf;
 {
    RgMngmt cntrl;
    
-   TRC3(cmUnpkLrgSchCntrlCfm)
 
    if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLCFM, mBuf) != ROK) {
       SPutMsg(mBuf);
@@ -1428,21 +1399,20 @@ Trace Indication from MAC to LM.
 *      -# 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)
@@ -1507,14 +1477,14 @@ Trace Indication from MAC to LM.
 *      -# 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;
@@ -1524,7 +1494,6 @@ 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);
@@ -1564,19 +1533,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgGenCfg
+S16 cmPkRgGenCfg
 (
 RgGenCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgGenCfg(param, mBuf)
+S16 cmPkRgGenCfg(param, mBuf)
 RgGenCfg *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkRgGenCfg)
 
 #ifdef LTE_ADV
    CMCHKPK(oduUnpackUInt8, param->isSCellActDeactAlgoEnable, mBuf);
@@ -1608,19 +1576,18 @@ Buffer *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, &param->lmPst, mBuf);
    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
@@ -1652,19 +1619,18 @@ Buffer *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);
@@ -1696,19 +1662,18 @@ Buffer *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, &param->selector, mBuf);
    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
@@ -1740,19 +1705,18 @@ Buffer *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, &param->bndTmr, mBuf);
    CMCHKPK(SPkS16, param->suId, mBuf);
@@ -1785,19 +1749,18 @@ Buffer *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, &param->selector, mBuf);
    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
@@ -1831,19 +1794,18 @@ Buffer *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);
@@ -1869,20 +1831,19 @@ Buffer *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, &param->ulCqiStat[i], mBuf);
@@ -1912,18 +1873,17 @@ Buffer *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);
@@ -1952,20 +1912,19 @@ Buffer *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, &param->ulCqiStat[i], mBuf);
@@ -1996,19 +1955,18 @@ Buffer *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, &param->mcs, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->numOfNacks, mBuf);
@@ -2034,19 +1992,18 @@ Buffer *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, &param->dlCqiStat[i], mBuf);
@@ -2076,18 +2033,17 @@ Buffer *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, &param->mcs, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->numOfHQ_1, mBuf);
@@ -2116,19 +2072,18 @@ Buffer *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, &param->dlCqiStat[i], mBuf);
@@ -2160,19 +2115,18 @@ Buffer *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, &param->hqRetxStats, mBuf);
@@ -2202,19 +2156,18 @@ Buffer *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, &param->numHarqFail, mBuf);
    CMCHKUNPK(oduPackUInt32, &param->numUeCfg, mBuf);
@@ -2244,19 +2197,18 @@ Buffer *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);
@@ -2282,19 +2234,18 @@ Buffer *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, &param->numPduRcvd, mBuf);
    CMCHKUNPK(oduPackUInt32, &param->numPduTxmit, mBuf);
@@ -2320,20 +2271,19 @@ Buffer *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, &param->tfuSap[i], mBuf);
@@ -2368,20 +2318,19 @@ Buffer *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, &param->instId, mBuf);
    CMCHKUNPK(cmUnpkRgGenCfg, &param->genCfg, mBuf);
@@ -2416,21 +2365,20 @@ Buffer *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:
@@ -2472,21 +2420,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgCfg
+S16 cmUnpkRgCfg
 (
 RgCfg *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgCfg(param, elmnt, mBuf)
+S16 cmUnpkRgCfg(param, elmnt, mBuf)
 RgCfg *param;
 S16 elmnt;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkRgCfg)
 
       switch(elmnt) {
          case STGEN:
@@ -2528,19 +2475,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSapSta
+S16 cmPkRgSapSta
 (
 RgSapSta *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSapSta(param, mBuf)
+S16 cmPkRgSapSta(param, mBuf)
 RgSapSta *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkRgSapSta)
 
    CMCHKPK(oduUnpackUInt8, param->sapState, mBuf);
    return ROK;
@@ -2564,19 +2510,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #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, &param->sapState, mBuf);
    return ROK;
@@ -2600,21 +2545,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #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:
@@ -2659,21 +2603,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSts
+S16 cmUnpkRgSts
 (
 RgSts *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSts(param, elmnt, mBuf)
+S16 cmUnpkRgSts(param, elmnt, mBuf)
 RgSts *param;
 S16 elmnt;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkRgSts)
 
    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->sapInst, mBuf);
@@ -2718,7 +2661,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSsta
+S16 cmPkRgSsta
 (
 Pst *pst,
 RgSsta *param,
@@ -2729,7 +2672,7 @@ U8 eventType,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
+S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
 Pst *pst;
 RgSsta *param;
 S16 elmnt;
@@ -2741,7 +2684,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkRgSsta)
 
       switch(elmnt) {
          case STTFUSAP:
@@ -2803,7 +2745,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSsta
+S16 cmUnpkRgSsta
 (
 Pst    *pst,
 RgSsta *param,
@@ -2811,7 +2753,7 @@ S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
+S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
 Pst    *pst;
 RgSsta *param;
 S16 elmnt;
@@ -2819,7 +2761,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkRgSsta)
 
    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->sapInst, mBuf);
@@ -2842,7 +2783,7 @@ Buffer *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, &param->s.sysId, mBuf);
                }
             }
@@ -2883,19 +2824,18 @@ Buffer *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:
@@ -2926,19 +2866,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #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, &param->type, mBuf);
       switch(param->type) {
@@ -2969,19 +2908,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #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, &param->dgn, mBuf);
    CMCHKPK(cmPkCmAlarm, &param->cmAlarm, mBuf);
@@ -3006,19 +2944,18 @@ Buffer *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, &param->cmAlarm, mBuf);
    CMCHKUNPK(cmUnpkRgUstaDgn, &param->dgn, mBuf);
@@ -3043,19 +2980,18 @@ Buffer *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, &param->dt, mBuf);
@@ -3080,19 +3016,18 @@ Buffer *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, &param->dt, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->evnt, mBuf);
@@ -3117,19 +3052,18 @@ Buffer *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;
@@ -3152,18 +3086,17 @@ Buffer *mBuf;
 *
 **********************************************************/
 #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);
@@ -3191,18 +3124,17 @@ Buffer *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, &param->logTime, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->enaLog, mBuf);
@@ -3233,19 +3165,18 @@ Buffer *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, &param->dbgMask, mBuf);
    return ROK;
@@ -3269,19 +3200,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #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);
@@ -3306,19 +3236,18 @@ Buffer *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, &param->suId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->spId, mBuf);
@@ -3343,21 +3272,20 @@ Buffer *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:
@@ -3421,21 +3349,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgCntrl
+S16 cmUnpkRgCntrl
 (
 RgCntrl *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgCntrl(param, elmnt, mBuf)
+S16 cmUnpkRgCntrl(param, elmnt, mBuf)
 RgCntrl *param;
 S16 elmnt;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkRgCntrl)
 
    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->action, mBuf);
@@ -3499,7 +3426,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgMngmt
+S16 cmPkRgMngmt
 (
 Pst *pst,
 RgMngmt *param,
@@ -3507,7 +3434,7 @@ U8 eventType,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgMngmt(pst, param, eventType, mBuf)
+S16 cmPkRgMngmt(pst, param, eventType, mBuf)
 Pst *pst;
 RgMngmt *param;
 U8 eventType;
@@ -3515,7 +3442,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkRgMngmt)
 
       switch(eventType) {
          case EVTLRGCNTRLREQ:
@@ -3585,7 +3511,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgMngmt
+S16 cmUnpkRgMngmt
 (
 Pst *pst,
 RgMngmt *param,
@@ -3593,7 +3519,7 @@ U8 eventType,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
+S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
 Pst *pst;
 RgMngmt *param;
 U8 eventType;
@@ -3601,7 +3527,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkRgMngmt)
 
    CMCHKUNPK(cmUnpkHeader, &param->hdr, mBuf);
    CMCHKUNPK(cmUnpkCmStatus, &param->cfm, mBuf);
@@ -3673,7 +3598,6 @@ Buffer        *mBuf;
 {
    U8      idx;
 
-   TRC3(cmPkNmbActvUeQciReq)
    
    for(idx = 0; idx < nmbActvUeQci->numQci; idx++)
    {
@@ -3711,8 +3635,6 @@ Buffer        *mBuf;
 {
    U8      idx;
 
-   TRC3(cmPkAvgPrbQciReq)
-   
    for(idx = 0; idx < avgPrbQciReq->numQci; idx++)
    {
        CMCHKPK(oduUnpackUInt8, avgPrbQciReq->qci[idx], mBuf);
@@ -3736,19 +3658,18 @@ L2 Measurement Request from LM to MAC.
 *      -# 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)
@@ -3796,19 +3717,18 @@ L2 Measurement Request from LM to MAC.
 *      -# 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)
@@ -3840,19 +3760,18 @@ L2 Measurement Request from LM to MAC.
 *      -# 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,
@@ -3895,8 +3814,6 @@ Buffer           *mBuf;
 {
    U8     idx;
 
-   TRC3(cmUnpkNmbActvUeQciReq)
-
    CMCHKUNPK(oduPackUInt8, &param->sampPrd, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
@@ -3933,7 +3850,6 @@ Buffer           *mBuf;
 {
    U8     idx;
 
-   TRC3(cmUnpkAvgPrbQciReq)
 
    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
@@ -3959,14 +3875,14 @@ Measurement  Request from LM to SCH.
 *      -# 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;
@@ -3974,7 +3890,6 @@ Buffer *mBuf;
 {
    LrgSchMeasReqInfo  measInfo;
 
-   TRC3(cmUnpkLrgSchL2MeasReq)
 
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
@@ -4015,14 +3930,14 @@ Measurement  Request from LM to SCH.
 *      -# 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;
@@ -4030,8 +3945,6 @@ Buffer *mBuf;
 {
    LrgSchMeasStopReqInfo measInfo;
 
-   TRC3(cmUnpkLrgSchL2MeasStopReq)
-
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
    /*CMCHKUNPK(oduPackUInt16, &measInfo.timePrd, mBuf);*/
@@ -4055,14 +3968,14 @@ Measurement  Request from LM to SCH.
 *      -# 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;
@@ -4091,20 +4004,19 @@ L2 Measurement confirm from MAC to LM
 *      -# 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,
@@ -4134,14 +4046,14 @@ Measurement  Confirm from SCH to LM.
 *      -# 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;
@@ -4149,7 +4061,6 @@ Buffer *mBuf;
 {
    LrgSchMeasCfmInfo  measInfo;
 
-   TRC3(cmUnpkLrgSchL2MeasCfm)
 
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
@@ -4186,7 +4097,6 @@ Buffer             *mBuf;
 {
    U8         idx;
 
-   TRC3(cmPkNumUeQciCfm)
    
    for(idx = 0; idx < param->numQci; idx++)
    {
@@ -4225,7 +4135,6 @@ Buffer             *mBuf;
 {
    U8         idx;
 
-   TRC3(cmPkAvgPrbQciCfm)
    for(idx = 0; idx < param->numQci; idx++)
    {
 /*LRG : Review Tag*/
@@ -4262,7 +4171,6 @@ Buffer             *mBuf;
 #endif
 {
 
-   TRC3(cmPkRaPrmbsCfm)
    CMCHKPK(oduUnpackUInt16, param->randSelPreHighRange, mBuf);
    CMCHKPK(oduUnpackUInt16, param->randSelPreLowRange, mBuf);
    CMCHKPK(oduUnpackUInt16, param->dedPreambles, mBuf);
@@ -4294,7 +4202,6 @@ Buffer        *mBuf;
 #endif
 {
 
-   TRC3(cmPkAvgPrbCfm)
    CMCHKPK(oduUnpackUInt8, param->prbPerc, mBuf);
    return ROK;
 }
@@ -4313,20 +4220,19 @@ L2 Measurement confirm from MAC to LM
 *      -# 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)
@@ -4414,7 +4320,6 @@ Buffer          *mBuf;
 {
    U8          idx;
 
-   TRC3(cmUnpkNumUeQciCfm)
    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
    {
@@ -4452,7 +4357,6 @@ Buffer          *mBuf;
 {
    U8          idx;
 
-   TRC3(cmUnpkAvgPrbQciCfm)
 
    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
@@ -4490,7 +4394,6 @@ Buffer         *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkRaPrmbsCfm)
 
    CMCHKUNPK(oduPackUInt16, &param->dedPreambles, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->randSelPreLowRange, mBuf);
@@ -4523,7 +4426,6 @@ Buffer         *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkAvgPrbCfm)
 
    CMCHKUNPK(oduPackUInt8, &param->prbPerc, mBuf);
    return ROK;
@@ -4543,14 +4445,14 @@ Measurement  Confirm from LM to SCH.
 *      -# 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;
@@ -4558,7 +4460,6 @@ Buffer *mBuf;
 {
    LrgSchMeasCfmInfo  measInfo;
 
-   TRC3(cmUnpkLrgSchL2MeasCfm)
 
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);