X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Fcm%2Ftfu.c;h=7e4a0532a9df8bc9458d08f7f2479a17f3281fb3;hb=def50dc175cebc67238db5f1acd5ff322a2279bd;hp=99c4792ef8ed9b1e4d79ca06945d641a7680e48d;hpb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;p=o-du%2Fl2.git

diff --git a/src/cm/tfu.c b/src/cm/tfu.c
index 99c4792ef..7e4a0532a 100755
--- a/src/cm/tfu.c
+++ b/src/cm/tfu.c
@@ -67,21 +67,20 @@
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuBndReq
+S16 cmPkTfuBndReq
 (
 Pst * pst,
 SuId suId,
 SpId spId
 )
 #else
-PUBLIC S16 cmPkTfuBndReq(pst, suId, spId)
+S16 cmPkTfuBndReq(pst, suId, spId)
 Pst * pst;
 SuId suId;
 SpId spId;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuBndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -134,14 +133,14 @@ SpId spId;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuBndReq
+S16 cmUnpkTfuBndReq
 (
 TfuBndReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuBndReq(func, pst, mBuf)
+S16 cmUnpkTfuBndReq(func, pst, mBuf)
 TfuBndReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -150,7 +149,6 @@ Buffer *mBuf;
    SuId suId;
    SpId spId;
    
-   TRC3(cmUnpkTfuBndReq)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -195,21 +193,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuBndCfm
+S16 cmPkTfuBndCfm
 (
 Pst * pst,
 SuId suId,
-U8 status
+uint8_t status
 )
 #else
-PUBLIC S16 cmPkTfuBndCfm(pst, suId, status)
+S16 cmPkTfuBndCfm(pst, suId, status)
 Pst * pst;
 SuId suId;
-U8 status;
+uint8_t status;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuBndCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -262,23 +259,22 @@ U8 status;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuBndCfm
+S16 cmUnpkTfuBndCfm
 (
 TfuBndCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuBndCfm(func, pst, mBuf)
+S16 cmUnpkTfuBndCfm(func, pst, mBuf)
 TfuBndCfm func;
 Pst *pst;
 Buffer *mBuf;
 #endif
 {
    SuId suId;
-   U8 status;
+   uint8_t status;
    
-   TRC3(cmUnpkTfuBndCfm)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -323,21 +319,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUbndReq
+S16 cmPkTfuUbndReq
 (
 Pst * pst,
 SpId spId,
 Reason reason
 )
 #else
-PUBLIC S16 cmPkTfuUbndReq(pst, spId, reason)
+S16 cmPkTfuUbndReq(pst, spId, reason)
 Pst * pst;
 SpId spId;
 Reason reason;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuUbndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -390,14 +385,14 @@ Reason reason;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUbndReq
+S16 cmUnpkTfuUbndReq
 (
 TfuUbndReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUbndReq(func, pst, mBuf)
+S16 cmUnpkTfuUbndReq(func, pst, mBuf)
 TfuUbndReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -406,7 +401,6 @@ Buffer *mBuf;
    SpId spId;
    Reason reason;
    
-   TRC3(cmUnpkTfuUbndReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -451,21 +445,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSchBndReq
+S16 cmPkTfuSchBndReq
 (
 Pst * pst,
 SuId suId,
 SpId spId
 )
 #else
-PUBLIC S16 cmPkTfuSchBndReq(pst, suId, spId)
+S16 cmPkTfuSchBndReq(pst, suId, spId)
 Pst * pst;
 SuId suId;
 SpId spId;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuSchBndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -518,14 +511,14 @@ SpId spId;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSchBndReq
+S16 cmUnpkTfuSchBndReq
 (
 TfuSchBndReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSchBndReq(func, pst, mBuf)
+S16 cmUnpkTfuSchBndReq(func, pst, mBuf)
 TfuSchBndReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -534,7 +527,6 @@ Buffer *mBuf;
    SuId suId;
    SpId spId;
    
-   TRC3(cmUnpkTfuSchBndReq)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -579,21 +571,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSchBndCfm
+S16 cmPkTfuSchBndCfm
 (
 Pst * pst,
 SuId suId,
-U8 status
+uint8_t status
 )
 #else
-PUBLIC S16 cmPkTfuSchBndCfm(pst, suId, status)
+S16 cmPkTfuSchBndCfm(pst, suId, status)
 Pst * pst;
 SuId suId;
-U8 status;
+uint8_t status;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuSchBndCfm)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -646,23 +637,22 @@ U8 status;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSchBndCfm
+S16 cmUnpkTfuSchBndCfm
 (
 TfuSchBndCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSchBndCfm(func, pst, mBuf)
+S16 cmUnpkTfuSchBndCfm(func, pst, mBuf)
 TfuSchBndCfm func;
 Pst *pst;
 Buffer *mBuf;
 #endif
 {
    SuId suId;
-   U8 status;
+   uint8_t status;
    
-   TRC3(cmUnpkTfuSchBndCfm)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -707,21 +697,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSchUbndReq
+S16 cmPkTfuSchUbndReq
 (
 Pst * pst,
 SpId spId,
 Reason reason
 )
 #else
-PUBLIC S16 cmPkTfuSchUbndReq(pst, spId, reason)
+S16 cmPkTfuSchUbndReq(pst, spId, reason)
 Pst * pst;
 SpId spId;
 Reason reason;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuSchUbndReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -774,14 +763,14 @@ Reason reason;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSchUbndReq
+S16 cmUnpkTfuSchUbndReq
 (
 TfuSchUbndReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSchUbndReq(func, pst, mBuf)
+S16 cmUnpkTfuSchUbndReq(func, pst, mBuf)
 TfuSchUbndReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -790,7 +779,6 @@ Buffer *mBuf;
    SpId spId;
    Reason reason;
    
-   TRC3(cmUnpkTfuSchUbndReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -839,21 +827,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqInd
+S16 cmPkTfuRaReqInd
 (
 Pst * pst,
 SuId suId,
 TfuRaReqIndInfo * raReqInd
 )
 #else
-PUBLIC S16 cmPkTfuRaReqInd(pst, suId, raReqInd)
+S16 cmPkTfuRaReqInd(pst, suId, raReqInd)
 Pst * pst;
 SuId suId;
 TfuRaReqIndInfo * raReqInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuRaReqInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -934,14 +921,14 @@ TfuRaReqIndInfo * raReqInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRaReqInd
+S16 cmUnpkTfuRaReqInd
 (
 TfuRaReqInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRaReqInd(func, pst, mBuf)
+S16 cmUnpkTfuRaReqInd(func, pst, mBuf)
 TfuRaReqInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -950,7 +937,6 @@ Buffer *mBuf;
    SuId suId;
    TfuRaReqIndInfo *raReqInd;
    
-   TRC3(cmUnpkTfuRaReqInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -1043,21 +1029,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRecpReq
+S16 cmPkTfuRecpReq
 (
 Pst * pst,
 SpId spId,
 TfuRecpReqInfo * recpReq
 )
 #else
-PUBLIC S16 cmPkTfuRecpReq(pst, spId, recpReq)
+S16 cmPkTfuRecpReq(pst, spId, recpReq)
 Pst * pst;
 SpId spId;
 TfuRecpReqInfo * recpReq;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuRecpReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -1149,14 +1134,14 @@ TfuRecpReqInfo * recpReq;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRecpReq
+S16 cmUnpkTfuRecpReq
 (
 TfuRecpReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRecpReq(func, pst, mBuf)
+S16 cmUnpkTfuRecpReq(func, pst, mBuf)
 TfuRecpReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -1165,7 +1150,6 @@ Buffer *mBuf;
    SpId spId;
    TfuRecpReqInfo *recpReq;
    
-   TRC3(cmUnpkTfuRecpReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -1263,21 +1247,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiInd
+S16 cmPkTfuUlCqiInd
 (
 Pst * pst,
 SuId suId,
 TfuUlCqiIndInfo * ulCqiInd
 )
 #else
-PUBLIC S16 cmPkTfuUlCqiInd(pst, suId, ulCqiInd)
+S16 cmPkTfuUlCqiInd(pst, suId, ulCqiInd)
 Pst * pst;
 SuId suId;
 TfuUlCqiIndInfo * ulCqiInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuUlCqiInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -1359,14 +1342,14 @@ TfuUlCqiIndInfo * ulCqiInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiInd
+S16 cmUnpkTfuUlCqiInd
 (
 TfuUlCqiInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUlCqiInd(func, pst, mBuf)
+S16 cmUnpkTfuUlCqiInd(func, pst, mBuf)
 TfuUlCqiInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -1375,7 +1358,6 @@ Buffer *mBuf;
    SuId suId;
    TfuUlCqiIndInfo *ulCqiInd;
    
-   TRC3(cmUnpkTfuUlCqiInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -1458,21 +1440,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuHqInd
+S16 cmPkTfuHqInd
 (
 Pst * pst,
 SpId spId,
 TfuHqIndInfo * hqInd
 )
 #else
-PUBLIC S16 cmPkTfuHqInd(pst, spId, hqInd)
+S16 cmPkTfuHqInd(pst, spId, hqInd)
 Pst * pst;
 SpId spId;
 TfuHqIndInfo * hqInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuHqInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -1553,14 +1534,14 @@ TfuHqIndInfo * hqInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuHqInd
+S16 cmUnpkTfuHqInd
 (
 TfuHqInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuHqInd(func, pst, mBuf)
+S16 cmUnpkTfuHqInd(func, pst, mBuf)
 TfuHqInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -1569,7 +1550,6 @@ Buffer *mBuf;
    SpId spId;
    TfuHqIndInfo *hqInd;
    
-   TRC3(cmUnpkTfuHqInd)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -1651,21 +1631,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSrInd
+S16 cmPkTfuSrInd
 (
 Pst * pst,
 SpId spId,
 TfuSrIndInfo * srInd
 )
 #else
-PUBLIC S16 cmPkTfuSrInd(pst, spId, srInd)
+S16 cmPkTfuSrInd(pst, spId, srInd)
 Pst * pst;
 SpId spId;
 TfuSrIndInfo * srInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuSrInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -1745,14 +1724,14 @@ TfuSrIndInfo * srInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrInd
+S16 cmUnpkTfuSrInd
 (
 TfuSrInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSrInd(func, pst, mBuf)
+S16 cmUnpkTfuSrInd(func, pst, mBuf)
 TfuSrInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -1761,7 +1740,6 @@ Buffer *mBuf;
    SpId spId;
    TfuSrIndInfo *srInd;
    
-   TRC3(cmUnpkTfuSrInd)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -1841,21 +1819,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiInd
+S16 cmPkTfuDlCqiInd
 (
 Pst * pst,
 SuId suId,
 TfuDlCqiIndInfo * dlCqiInd
 )
 #else
-PUBLIC S16 cmPkTfuDlCqiInd(pst, suId, dlCqiInd)
+S16 cmPkTfuDlCqiInd(pst, suId, dlCqiInd)
 Pst * pst;
 SuId suId;
 TfuDlCqiIndInfo * dlCqiInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuDlCqiInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -1932,14 +1909,14 @@ TfuDlCqiIndInfo * dlCqiInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiInd
+S16 cmUnpkTfuDlCqiInd
 (
 TfuDlCqiInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDlCqiInd(func, pst, mBuf)
+S16 cmUnpkTfuDlCqiInd(func, pst, mBuf)
 TfuDlCqiInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -1948,7 +1925,6 @@ Buffer *mBuf;
    SuId suId;
    TfuDlCqiIndInfo *dlCqiInd;
    
-   TRC3(cmUnpkTfuDlCqiInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -2035,21 +2011,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiInd
+S16 cmPkTfuRawCqiInd
 (
 Pst * pst,
 SuId suId,
 TfuRawCqiIndInfo * rawCqiInd
 )
 #else
-PUBLIC S16 cmPkTfuRawCqiInd(pst, suId, rawCqiInd)
+S16 cmPkTfuRawCqiInd(pst, suId, rawCqiInd)
 Pst * pst;
 SuId suId;
 TfuRawCqiIndInfo * rawCqiInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuRawCqiInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -2102,14 +2077,14 @@ TfuRawCqiIndInfo * rawCqiInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRawCqiInd
+S16 cmUnpkTfuRawCqiInd
 (
 TfuRawCqiInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRawCqiInd(func, pst, mBuf)
+S16 cmUnpkTfuRawCqiInd(func, pst, mBuf)
 TfuRawCqiInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -2118,7 +2093,6 @@ Buffer *mBuf;
    SuId suId;
    TfuRawCqiIndInfo *rawCqiInd;
    
-   TRC3(cmUnpkTfuRawCqiInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -2173,21 +2147,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSrsInd
+S16 cmPkTfuSrsInd
 (
 Pst * pst,
 SuId suId,
 TfuSrsIndInfo * srsInd
 )
 #else
-PUBLIC S16 cmPkTfuSrsInd(pst, suId, srsInd)
+S16 cmPkTfuSrsInd(pst, suId, srsInd)
 Pst * pst;
 SuId suId;
 TfuSrsIndInfo * srsInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuSrsInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -2239,14 +2212,14 @@ TfuSrsIndInfo * srsInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrsInd
+S16 cmUnpkTfuSrsInd
 (
 TfuSrsInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSrsInd(func, pst, mBuf)
+S16 cmUnpkTfuSrsInd(func, pst, mBuf)
 TfuSrsInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -2255,7 +2228,6 @@ Buffer *mBuf;
    SuId suId;
    TfuSrsIndInfo *srsInd;
    
-   TRC3(cmUnpkTfuSrsInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -2311,21 +2283,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDatInd
+S16 cmPkTfuDatInd
 (
 Pst * pst,
 SpId spId,
 TfuDatIndInfo * datInd
 )
 #else
-PUBLIC S16 cmPkTfuDatInd(pst, spId, datInd)
+S16 cmPkTfuDatInd(pst, spId, datInd)
 Pst * pst;
 SpId spId;
 TfuDatIndInfo * datInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuDatInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -2405,14 +2376,14 @@ TfuDatIndInfo * datInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatInd
+S16 cmUnpkTfuDatInd
 (
 TfuDatInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDatInd(func, pst, mBuf)
+S16 cmUnpkTfuDatInd(func, pst, mBuf)
 TfuDatInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -2421,7 +2392,6 @@ Buffer *mBuf;
    SpId spId;
    TfuDatIndInfo *datInd;
    
-   TRC3(cmUnpkTfuDatInd)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -2507,21 +2477,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCrcInd
+S16 cmPkTfuCrcInd
 (
 Pst * pst,
 SuId suId,
 TfuCrcIndInfo * crcIndInfo
 )
 #else
-PUBLIC S16 cmPkTfuCrcInd(pst, suId, crcIndInfo)
+S16 cmPkTfuCrcInd(pst, suId, crcIndInfo)
 Pst * pst;
 SuId suId;
 TfuCrcIndInfo * crcIndInfo;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuCrcInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -2606,14 +2575,14 @@ TfuCrcIndInfo * crcIndInfo;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCrcInd
+S16 cmUnpkTfuCrcInd
 (
 TfuCrcInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCrcInd(func, pst, mBuf)
+S16 cmUnpkTfuCrcInd(func, pst, mBuf)
 TfuCrcInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -2622,7 +2591,6 @@ Buffer *mBuf;
    SuId suId;
    TfuCrcIndInfo *crcIndInfo;
    
-   TRC3(cmUnpkTfuCrcInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -2705,21 +2673,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvInd
+S16 cmPkTfuTimingAdvInd
 (
 Pst * pst,
 SuId suId,
 TfuTimingAdvIndInfo * timingAdvInd
 )
 #else
-PUBLIC S16 cmPkTfuTimingAdvInd(pst, suId, timingAdvInd)
+S16 cmPkTfuTimingAdvInd(pst, suId, timingAdvInd)
 Pst * pst;
 SuId suId;
 TfuTimingAdvIndInfo * timingAdvInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuTimingAdvInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -2800,14 +2767,14 @@ TfuTimingAdvIndInfo * timingAdvInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuTimingAdvInd
+S16 cmUnpkTfuTimingAdvInd
 (
 TfuTimingAdvInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuTimingAdvInd(func, pst, mBuf)
+S16 cmUnpkTfuTimingAdvInd(func, pst, mBuf)
 TfuTimingAdvInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -2816,7 +2783,6 @@ Buffer *mBuf;
    SuId suId;
    TfuTimingAdvIndInfo *timingAdvInd;
    
-   TRC3(cmUnpkTfuTimingAdvInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -2901,21 +2867,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDatReq
+S16 cmPkTfuDatReq
 (
 Pst * pst,
 SpId spId,
 TfuDatReqInfo * datReq
 )
 #else
-PUBLIC S16 cmPkTfuDatReq(pst, spId, datReq)
+S16 cmPkTfuDatReq(pst, spId, datReq)
 Pst * pst;
 SpId spId;
 TfuDatReqInfo * datReq;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuDatReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -2998,14 +2963,14 @@ TfuDatReqInfo * datReq;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatReq
+S16 cmUnpkTfuDatReq
 (
 TfuDatReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDatReq(func, pst, mBuf)
+S16 cmUnpkTfuDatReq(func, pst, mBuf)
 TfuDatReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -3014,7 +2979,6 @@ Buffer *mBuf;
    SpId spId;
    TfuDatReqInfo *datReq;
    
-   TRC3(cmUnpkTfuDatReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -3100,21 +3064,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCntrlReq
+S16 cmPkTfuCntrlReq
 (
 Pst * pst,
 SpId spId,
 TfuCntrlReqInfo * cntrlReq
 )
 #else
-PUBLIC S16 cmPkTfuCntrlReq(pst, spId, cntrlReq)
+S16 cmPkTfuCntrlReq(pst, spId, cntrlReq)
 Pst * pst;
 SpId spId;
 TfuCntrlReqInfo * cntrlReq;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuCntrlReq)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -3199,14 +3162,14 @@ TfuCntrlReqInfo * cntrlReq;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCntrlReq
+S16 cmUnpkTfuCntrlReq
 (
 TfuCntrlReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCntrlReq(func, pst, mBuf)
+S16 cmUnpkTfuCntrlReq(func, pst, mBuf)
 TfuCntrlReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -3215,7 +3178,6 @@ Buffer *mBuf;
    SpId spId;
    TfuCntrlReqInfo *cntrlReq;
    
-   TRC3(cmUnpkTfuCntrlReq)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -3297,21 +3259,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuTtiInd
+S16 cmPkTfuTtiInd
 (
 Pst * pst,
 SuId suId,
 TfuTtiIndInfo * ttiInd
 )
 #else
-PUBLIC S16 cmPkTfuTtiInd(pst, suId, ttiInd)
+S16 cmPkTfuTtiInd(pst, suId, ttiInd)
 Pst * pst;
 SuId suId;
 TfuTtiIndInfo * ttiInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuTtiInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -3397,19 +3358,18 @@ TfuTtiIndInfo * ttiInd;
  *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuNonRtInd
+S16 cmPkTfuNonRtInd
 (
 Pst * pst,
 SuId suId
 )
 #else
-PUBLIC S16 cmPkTfuNonRtInd(pst, suId)
+S16 cmPkTfuNonRtInd(pst, suId)
 Pst * pst;
 SuId suId;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuNonRtInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -3451,21 +3411,20 @@ SuId suId;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuNonRtInd
+S16 cmUnpkTfuNonRtInd
 (
 TfuNonRtInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuNonRtInd(func, pst, mBuf)
+S16 cmUnpkTfuNonRtInd(func, pst, mBuf)
 TfuNonRtInd func;
 Pst *pst;
 Buffer *mBuf;
 #endif
 {
    SuId suId;
-   TRC3(cmUnpkTfuNonRtInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -3505,21 +3464,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPucchDeltaPwr
+S16 cmPkTfuPucchDeltaPwr
 (
 Pst * pst,
 SuId suId,
 TfuPucchDeltaPwrIndInfo * pucchDeltaPwr
 )
 #else
-PUBLIC S16 cmPkTfuPucchDeltaPwr(pst, suId, pucchDeltaPwr)
+S16 cmPkTfuPucchDeltaPwr(pst, suId, pucchDeltaPwr)
 Pst * pst;
 SuId suId;
 TfuPucchDeltaPwrIndInfo * pucchDeltaPwr;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuPucchDeltaPwr)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -3597,14 +3555,14 @@ TfuPucchDeltaPwrIndInfo * pucchDeltaPwr;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPucchDeltaPwr
+S16 cmUnpkTfuPucchDeltaPwr
 (
 TfuPucchDeltaPwrInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPucchDeltaPwr(func, pst, mBuf)
+S16 cmUnpkTfuPucchDeltaPwr(func, pst, mBuf)
 TfuPucchDeltaPwrInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -3613,7 +3571,6 @@ Buffer *mBuf;
    SuId suId;
    TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
    
-   TRC3(cmUnpkTfuPucchDeltaPwr)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -3688,19 +3645,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignA1Val324
+S16 cmPkTfuRbAssignA1Val324
 (
 TfuRbAssignA1Val324 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRbAssignA1Val324(param, mBuf)
+S16 cmPkTfuRbAssignA1Val324(param, mBuf)
 TfuRbAssignA1Val324 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuRbAssignA1Val324)
 
    CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
@@ -3728,19 +3684,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignB1Val324
+S16 cmPkTfuRbAssignB1Val324
 (
 TfuRbAssignB1Val324 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRbAssignB1Val324(param, mBuf)
+S16 cmPkTfuRbAssignB1Val324(param, mBuf)
 TfuRbAssignB1Val324 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuRbAssignB1Val324)
 
    CMCHKPK(oduUnpackUInt8, param->bmiHqAckNack, mBuf);
    CMCHKPK(oduUnpackUInt8, param->RV, mBuf);
@@ -3767,19 +3722,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignVal326
+S16 cmPkTfuRbAssignVal326
 (
 TfuRbAssignVal326 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRbAssignVal326(param, mBuf)
+S16 cmPkTfuRbAssignVal326(param, mBuf)
 TfuRbAssignVal326 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuRbAssignVal326)
 
    CMCHKPK(oduUnpackUInt8, param->CyclicShiftInd, mBuf);
    CMCHKPK(oduUnpackUInt8, param->OCCInd, mBuf);
@@ -3804,19 +3758,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignA1Val324
+S16 cmUnpkTfuRbAssignA1Val324
 (
 TfuRbAssignA1Val324 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRbAssignA1Val324(param, mBuf)
+S16 cmUnpkTfuRbAssignA1Val324(param, mBuf)
 TfuRbAssignA1Val324 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuRbAssignA1Val324)
 
    CMCHKUNPK(oduPackUInt8, &param->hqProcId, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
@@ -3841,19 +3794,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignB1Val324
+S16 cmUnpkTfuRbAssignB1Val324
 (
 TfuRbAssignB1Val324 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRbAssignB1Val324(param, mBuf)
+S16 cmUnpkTfuRbAssignB1Val324(param, mBuf)
 TfuRbAssignB1Val324 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuRbAssignB1Val324)
 
    CMCHKUNPK(oduPackUInt8, &param->hqProcId, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
@@ -3880,19 +3832,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignVal326
+S16 cmUnpkTfuRbAssignVal326
 (
 TfuRbAssignVal326 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRbAssignVal326(param, mBuf)
+S16 cmUnpkTfuRbAssignVal326(param, mBuf)
 TfuRbAssignVal326 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuRbAssignVal326)
 
    CMCHKUNPK(oduPackUInt8, &param->FreqBandIdx, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->OCCInd, mBuf);
@@ -3918,19 +3869,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatA1A2Info
+S16 cmPkTfuDciFormatA1A2Info
 (
 TfuDciFormatA1Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormatA1A2Info(param, mBuf)
+S16 cmPkTfuDciFormatA1A2Info(param, mBuf)
 TfuDciFormatA1Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormatA1A2Info)
 
    //printf("5GTF_DBG: cmPkTfuDciFormatA1Info() called by eNB\n");   
    CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
@@ -3987,19 +3937,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatB1B2Info
+S16 cmPkTfuDciFormatB1B2Info
 (
 TfuDciFormatB1Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormatB1B2Info(param, mBuf)
+S16 cmPkTfuDciFormatB1B2Info(param, mBuf)
 TfuDciFormatB1Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormatB1B2Info)
 
    CMCHKPK(oduUnpackUInt8, param->DL_PCRS, mBuf);
    CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
@@ -4055,19 +4004,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatA1A2Info
+S16 cmUnpkTfuDciFormatA1A2Info
 (
 TfuDciFormatA1Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormatA1A2Info(param, mBuf)
+S16 cmUnpkTfuDciFormatA1A2Info(param, mBuf)
 TfuDciFormatA1Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormatA1A2Info)
 
    CMCHKUNPK(oduPackUInt8, &param->formatType, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->xPUSCHRange, mBuf);
@@ -4124,19 +4072,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatB1B2Info
+S16 cmUnpkTfuDciFormatB1B2Info
 (
 TfuDciFormatB1Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormatB1B2Info(param, mBuf)
+S16 cmUnpkTfuDciFormatB1B2Info(param, mBuf)
 TfuDciFormatB1Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormatB1B2Info)
 
    CMCHKUNPK(oduPackUInt8, &param->formatType, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->xPDSCHRange, mBuf);
@@ -4193,19 +4140,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat0Info
+S16 cmPkTfuDciFormat0Info
 (
 TfuDciFormat0Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat0Info(param, mBuf)
+S16 cmPkTfuDciFormat0Info(param, mBuf)
 TfuDciFormat0Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat0Info)
 
    /* tfu_c_001.main_3: Adding pack for hqProcId */
    CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
@@ -4251,19 +4197,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat0Info
+S16 cmUnpkTfuDciFormat0Info
 (
 TfuDciFormat0Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat0Info(param, mBuf)
+S16 cmUnpkTfuDciFormat0Info(param, mBuf)
 TfuDciFormat0Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat0Info)
 
    CMCHKUNPK(oduPackUInt8, &param->hoppingEnbld, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rbStart, mBuf);
@@ -4310,20 +4255,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuAllocMapOrRiv
+S16 cmPkTfuAllocMapOrRiv
 (
 TfuAllocMapOrRiv *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuAllocMapOrRiv(param, mBuf)
+S16 cmPkTfuAllocMapOrRiv(param, mBuf)
 TfuAllocMapOrRiv *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuAllocMapOrRiv)
 
       switch(param->type) {
       /*tfu_c_001.main_7 - ADD - TFU_RESMAP_CHANGE support */
@@ -4372,22 +4316,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuAllocMapOrRiv
+S16 cmUnpkTfuAllocMapOrRiv
 (
 TfuAllocMapOrRiv *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuAllocMapOrRiv(param, mBuf)
+S16 cmUnpkTfuAllocMapOrRiv(param, mBuf)
 TfuAllocMapOrRiv *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuAllocMapOrRiv)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
       switch(param->type) {
          case TFU_ALLOC_TYPE_RIV:
             CMCHKUNPK(oduPackUInt32, &param->u.riv, mBuf);
@@ -4439,20 +4382,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1AllocInfo
+S16 cmPkTfuDciFormat1AllocInfo
 (
 TfuDciFormat1AllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1AllocInfo(param, mBuf)
 TfuDciFormat1AllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuDciFormat1AllocInfo)
 
    CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
@@ -4488,20 +4430,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1AllocInfo
+S16 cmUnpkTfuDciFormat1AllocInfo
 (
 TfuDciFormat1AllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1AllocInfo(param, mBuf)
 TfuDciFormat1AllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuDciFormat1AllocInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->isAllocType0, mBuf);
    for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
@@ -4535,19 +4476,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1Info
+S16 cmPkTfuDciFormat1Info
 (
 TfuDciFormat1Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1Info(param, mBuf)
+S16 cmPkTfuDciFormat1Info(param, mBuf)
 TfuDciFormat1Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1Info)
 
    CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
 
@@ -4581,19 +4521,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1Info
+S16 cmUnpkTfuDciFormat1Info
 (
 TfuDciFormat1Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1Info(param, mBuf)
+S16 cmUnpkTfuDciFormat1Info(param, mBuf)
 TfuDciFormat1Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1Info)
 
    CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, &param->allocInfo, mBuf);
 
@@ -4628,20 +4567,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AAllocInfo
+S16 cmPkTfuDciFormat2AAllocInfo
 (
 TfuDciFormat2AAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat2AAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AAllocInfo(param, mBuf)
 TfuDciFormat2AAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuDciFormat2AAllocInfo)
 
    CMCHKPK(oduUnpackUInt8, param->transSwap, mBuf);
    CMCHKPK(oduUnpackUInt8, param->precoding, mBuf);
@@ -4683,20 +4621,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2AAllocInfo
+S16 cmUnpkTfuDciFormat2AAllocInfo
 (
 TfuDciFormat2AAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat2AAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat2AAllocInfo(param, mBuf)
 TfuDciFormat2AAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuDciFormat2AAllocInfo)
 
 
 /* tfu_c_001.main_4 - Changes for MIMO feature addition */
@@ -4747,19 +4684,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat6AAllocInfo
+S16 cmPkTfuDciFormat6AAllocInfo
 (
 TfuDciFormat61AllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat6AAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat6AAllocInfo(param, mBuf)
 TfuDciFormat61AllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat6AAllocInfo)
 
    CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
@@ -4793,19 +4729,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat6AAllocInfo
+S16 cmUnpkTfuDciFormat6AAllocInfo
 (
 TfuDciFormat61AllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat6AAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat6AAllocInfo(param, mBuf)
 TfuDciFormat61AllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat6AAllocInfo)
 
    CMCHKUNPK(oduPackUInt32, &param->riv, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->harqProcId, mBuf);
@@ -4836,19 +4771,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AInfo
+S16 cmPkTfuDciFormat2AInfo
 (
 TfuDciFormat2AInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat2AInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AInfo(param, mBuf)
 TfuDciFormat2AInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat2AInfo)
 
    CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
 
@@ -4879,19 +4813,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2AInfo
+S16 cmUnpkTfuDciFormat2AInfo
 (
 TfuDciFormat2AInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat2AInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat2AInfo(param, mBuf)
 TfuDciFormat2AInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat2AInfo)
 
    CMCHKUNPK(cmUnpkTfuDciFormat2AAllocInfo, &param->allocInfo, mBuf);
 
@@ -4926,20 +4859,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AllocInfo
+S16 cmPkTfuDciFormat2AllocInfo
 (
 TfuDciFormat2AllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat2AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AllocInfo(param, mBuf)
 TfuDciFormat2AllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuDciFormat2AllocInfo)
 
 
 /* tfu_c_001.main_4 - Changes for MIMO feature addition */
@@ -4996,20 +4928,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2AllocInfo
+S16 cmUnpkTfuDciFormat2AllocInfo
 (
 TfuDciFormat2AllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat2AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat2AllocInfo(param, mBuf)
 TfuDciFormat2AllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuDciFormat2AllocInfo)
 
 
 /* tfu_c_001.main_4 - Changes for MIMO feature addition */
@@ -5065,19 +4996,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2Info
+S16 cmPkTfuDciFormat2Info
 (
 TfuDciFormat2Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat2Info(param, mBuf)
+S16 cmPkTfuDciFormat2Info(param, mBuf)
 TfuDciFormat2Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat2Info)
 
 
 /* tfu_c_001.main_4 - Changes for MIMO feature addition */
@@ -5118,19 +5048,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat2Info
+S16 cmUnpkTfuDciFormat2Info
 (
 TfuDciFormat2Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat2Info(param, mBuf)
+S16 cmUnpkTfuDciFormat2Info(param, mBuf)
 TfuDciFormat2Info *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat2Info)
 
    CMCHKUNPK(cmUnpkTfuDciFormat2AllocInfo, &param->allocInfo, mBuf);
 
@@ -5167,20 +5096,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat3Info
+S16 cmPkTfuDciFormat3Info
 (
 TfuDciFormat3Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat3Info(param, mBuf)
+S16 cmPkTfuDciFormat3Info(param, mBuf)
 TfuDciFormat3Info *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuDciFormat3Info)
 
    CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
    for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
@@ -5207,20 +5135,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat3Info
+S16 cmUnpkTfuDciFormat3Info
 (
 TfuDciFormat3Info *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat3Info(param, mBuf)
+S16 cmUnpkTfuDciFormat3Info(param, mBuf)
 TfuDciFormat3Info *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuDciFormat3Info)
 
    for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
       CMCHKUNPK(oduPackUInt8, &param->tpcCmd[i], mBuf);
@@ -5247,20 +5174,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat3AInfo
+S16 cmPkTfuDciFormat3AInfo
 (
 TfuDciFormat3AInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat3AInfo(param, mBuf)
+S16 cmPkTfuDciFormat3AInfo(param, mBuf)
 TfuDciFormat3AInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuDciFormat3AInfo)
    CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
    for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
       CMCHKPK(oduUnpackUInt8, param->tpcCmd[i], mBuf);
@@ -5286,20 +5212,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat3AInfo
+S16 cmUnpkTfuDciFormat3AInfo
 (
 TfuDciFormat3AInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat3AInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat3AInfo(param, mBuf)
 TfuDciFormat3AInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuDciFormat3AInfo)
 
    for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
       CMCHKUNPK(oduPackUInt8, &param->tpcCmd[i], mBuf);
@@ -5341,7 +5266,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat60aInfo)
 
    CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
    CMCHKPK(oduUnpackUInt8, param->isSrs, mBuf);
@@ -5389,7 +5313,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuPdcchOrderInfoEmtc)
 
    CMCHKPK(oduUnpackUInt8, param->ceLevel, mBuf);
    CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
@@ -5427,7 +5350,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfudciformat61aPdsch)
 
    CMCHKPK(oduUnpackUInt8, param->isTBMsg4, mBuf);
    CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
@@ -5467,19 +5389,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat61aInfo
+S16 cmPkTfuDciFormat61aInfo
 (
 TfuDciFormat61aInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat61aInfo(param, mBuf)
+S16 cmPkTfuDciFormat61aInfo(param, mBuf)
 TfuDciFormat61aInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat61aInfo)
 
    switch(param->isPdcchOrder) {
       case FALSE:
@@ -5526,7 +5447,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat60aInfo)
 
    printf("In cmUnpkTfuDciFormat60aInfo :: Entry \n");
    CMCHKUNPK(oduPackUInt8, &param->hoppingEnbld, mBuf);
@@ -5576,7 +5496,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuPdcchOrderInfoEmtc)
 
    printf("In cmUnpkTfuPdcchOrderInfoEmtc :: Entry \n");
    CMCHKUNPK(oduPackUInt32, &param->riv, mBuf);
@@ -5603,19 +5522,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat61aInfo
+S16 cmUnpkTfuDciFormat61aInfo
 (
 TfuDciFormat61aInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat61aInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat61aInfo(param, mBuf)
 TfuDciFormat61aInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat61aInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->isPdcchOrder, mBuf);
    printf("1. cmUnpkTfuDciFormat61aInfo ::  isPdcchOrder %d \n", param->isPdcchOrder); 
@@ -5654,25 +5572,24 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1dAllocInfo
+S16 cmPkTfuDciFormat1dAllocInfo
 (
 TfuDciFormat1dAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1dAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1dAllocInfo(param, mBuf)
 TfuDciFormat1dAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1dAllocInfo)
 
    CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
    CMCHKPK(cmPkTfuAllocMapOrRiv, &param->alloc, mBuf);
-   CMCHKPK(cmPkTknU8, &param->nGap2, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->nGap2, mBuf);
    CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
    return ROK;
 }
@@ -5700,22 +5617,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1dAllocInfo
+S16 cmUnpkTfuDciFormat1dAllocInfo
 (
 TfuDciFormat1dAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1dAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1dAllocInfo(param, mBuf)
 TfuDciFormat1dAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1dAllocInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->isLocal, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->nGap2, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->nGap2, mBuf);
    CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, &param->alloc, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rv, mBuf);
@@ -5745,19 +5661,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1dInfo
+S16 cmPkTfuDciFormat1dInfo
 (
 TfuDciFormat1dInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1dInfo(param, mBuf)
+S16 cmPkTfuDciFormat1dInfo(param, mBuf)
 TfuDciFormat1dInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1dInfo)
 
    CMCHKPK(oduUnpackUInt8, param->dlPwrOffset, mBuf);
 
@@ -5794,19 +5709,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1dInfo
+S16 cmUnpkTfuDciFormat1dInfo
 (
 TfuDciFormat1dInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1dInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1dInfo(param, mBuf)
 TfuDciFormat1dInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1dInfo)
 
    CMCHKUNPK(cmUnpkTfuDciFormat1dAllocInfo, &param->allocInfo, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->harqProcId, mBuf);
@@ -5844,23 +5758,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1cInfo
+S16 cmPkTfuDciFormat1cInfo
 (
 TfuDciFormat1cInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1cInfo(param, mBuf)
+S16 cmPkTfuDciFormat1cInfo(param, mBuf)
 TfuDciFormat1cInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1cInfo)
 
    CMCHKPK(oduUnpackUInt8, param->iTbs, mBuf);
    CMCHKPK(cmPkTfuAllocMapOrRiv, &param->alloc, mBuf);
-   CMCHKPK(cmPkTknU8, &param->nGap2, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->nGap2, mBuf);
    return ROK;
 }
 
@@ -5887,21 +5800,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1cInfo
+S16 cmUnpkTfuDciFormat1cInfo
 (
 TfuDciFormat1cInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1cInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1cInfo(param, mBuf)
 TfuDciFormat1cInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1cInfo)
 
-   CMCHKUNPK(cmUnpkTknU8, &param->nGap2, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->nGap2, mBuf);
    CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, &param->alloc, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->iTbs, mBuf);
    return ROK;
@@ -5930,19 +5842,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1bAllocInfo
+S16 cmPkTfuDciFormat1bAllocInfo
 (
 TfuDciFormat1bAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1bAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1bAllocInfo(param, mBuf)
 TfuDciFormat1bAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1bAllocInfo)
 
    CMCHKPK(oduUnpackUInt8, param->pmiCfm, mBuf);
    CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
@@ -5951,7 +5862,7 @@ Buffer *mBuf;
    CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
    CMCHKPK(cmPkTfuAllocMapOrRiv, &param->alloc, mBuf);
-   CMCHKPK(cmPkTknU8, &param->nGap2, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->nGap2, mBuf);
    CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
    return ROK;
 }
@@ -5979,22 +5890,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1bAllocInfo
+S16 cmUnpkTfuDciFormat1bAllocInfo
 (
 TfuDciFormat1bAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1bAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1bAllocInfo(param, mBuf)
 TfuDciFormat1bAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1bAllocInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->isLocal, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->nGap2, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->nGap2, mBuf);
    CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, &param->alloc, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rv, mBuf);
@@ -6024,19 +5934,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchOrderInfo
+S16 cmPkTfuPdcchOrderInfo
 (
 TfuPdcchOrderInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuPdcchOrderInfo(param, mBuf)
+S16 cmPkTfuPdcchOrderInfo(param, mBuf)
 TfuPdcchOrderInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuPdcchOrderInfo)
 
    CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
    CMCHKPK(oduUnpackUInt8, param->preambleIdx, mBuf);
@@ -6062,19 +5971,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchOrderInfo
+S16 cmUnpkTfuPdcchOrderInfo
 (
 TfuPdcchOrderInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPdcchOrderInfo(param, mBuf)
+S16 cmUnpkTfuPdcchOrderInfo(param, mBuf)
 TfuPdcchOrderInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuPdcchOrderInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->preambleIdx, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->prachMaskIdx, mBuf);
@@ -6104,26 +6012,25 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1aAllocInfo
+S16 cmPkTfuDciFormat1aAllocInfo
 (
 TfuDciFormat1aAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1aAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1aAllocInfo(param, mBuf)
 TfuDciFormat1aAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1aAllocInfo)
 
    CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
-   CMCHKPK(cmPkTknU8, &param->harqProcId, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->harqProcId, mBuf);
    CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
    CMCHKPK(cmPkTfuAllocMapOrRiv, &param->alloc, mBuf);
-   CMCHKPK(cmPkTknU8, &param->nGap2, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->nGap2, mBuf);
    CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
    return ROK;
 }
@@ -6151,26 +6058,25 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1aAllocInfo
+S16 cmUnpkTfuDciFormat1aAllocInfo
 (
 TfuDciFormat1aAllocInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1aAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1aAllocInfo(param, mBuf)
 TfuDciFormat1aAllocInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1aAllocInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->isLocal, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->nGap2, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->nGap2, mBuf);
    CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, &param->alloc, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rv, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->harqProcId, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->harqProcId, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->ndi, mBuf);
    return ROK;
 }
@@ -6194,24 +6100,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfudciformat1aPdsch
+S16 cmPkTfudciformat1aPdsch
 (
 Tfudciformat1aPdsch *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfudciformat1aPdsch(param, mBuf)
+S16 cmPkTfudciformat1aPdsch(param, mBuf)
 Tfudciformat1aPdsch *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfudciformat1aPdsch)
 
    CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
 
 #ifdef TFU_TDD
-   CMCHKPK(cmPkTknU8, &param->dai, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->dai, mBuf);
 
 #endif
    CMCHKPK(cmPkTfuDciFormat1aAllocInfo, &param->allocInfo, mBuf);
@@ -6237,24 +6142,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfudciformat1aPdsch
+S16 cmUnpkTfudciformat1aPdsch
 (
 Tfudciformat1aPdsch *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfudciformat1aPdsch(param, mBuf)
+S16 cmUnpkTfudciformat1aPdsch(param, mBuf)
 Tfudciformat1aPdsch *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfudciformat1aPdsch)
 
    CMCHKUNPK(cmUnpkTfuDciFormat1aAllocInfo, &param->allocInfo, mBuf);
 
 #ifdef TFU_TDD
-   CMCHKUNPK(cmUnpkTknU8, &param->dai, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->dai, mBuf);
 
 #endif
    CMCHKUNPK(oduPackUInt8, &param->tpcCmd, mBuf);
@@ -6281,19 +6185,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfudciformat61aPdsch
+S16 cmUnpkTfudciformat61aPdsch
 (
 Tfudciformat61aPdsch *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfudciformat61aPdsch(param, mBuf)
+S16 cmUnpkTfudciformat61aPdsch(param, mBuf)
 Tfudciformat61aPdsch *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfudciformat61aPdsch)
 
    printf("1. cmUnpkTfudciformat61aPdsch ::  Entry \n"); 
    CMCHKUNPK(cmUnpkTfuDciFormat6AAllocInfo, &param->allocInfo, mBuf);
@@ -6353,7 +6256,6 @@ PRIVATE S16 cmUnpkTfuDirectIndication(param, mBuf)
 #endif
 {
 
-   TRC3(cmUnpkTfuDirectIndication)
    CMCHKUNPK(oduPackUInt8, &param->directInd, mBuf);
 
 
@@ -6381,18 +6283,17 @@ PRIVATE S16 cmUnpkTfuDirectIndication(param, mBuf)
  *
  **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat62AllocInfo
+S16 cmUnpkTfuDciFormat62AllocInfo
 (
  TfuDciFormat62AllocInfo *param,
  Buffer *mBuf
  )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat62AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat62AllocInfo(param, mBuf)
    TfuDciFormat62AllocInfo *param;
    Buffer *mBuf;
 #endif
 {
-   TRC3(cmUnpkTfuDciFormat62AllocInfo)
    CMCHKUNPK(oduPackUInt8, &param->riv, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rv, mBuf);
@@ -6429,8 +6330,6 @@ PRIVATE S16 cmUnpkTfudciformat62Pdsch(param, mBuf)
 #endif
 {
 
-   TRC3(cmUnpkTfudciformat62Pdsch)
-
 
    CMCHKUNPK(cmUnpkTfuDciFormat62AllocInfo, &param->format62AllocInfo, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->repNum, mBuf);
@@ -6458,19 +6357,18 @@ PRIVATE S16 cmUnpkTfudciformat62Pdsch(param, mBuf)
  *
  **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat62Info
+S16 cmUnpkTfuDciFormat62Info
 (
  TfuDciFormat62Info *param,
  Buffer *mBuf
  )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat62Info(param, mBuf)
+S16 cmUnpkTfuDciFormat62Info(param, mBuf)
    TfuDciFormat62Info *param;
    Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat62Info)
       CMCHKUNPK(oduPackUInt8, &param->isPaging, mBuf);
    switch(param->isPaging) {
       case FALSE:
@@ -6527,7 +6425,6 @@ PRIVATE S16 cmPkTfuDirectIndication(param, mBuf)
 #endif
 {
 
-   TRC3(cmPkTfuDirectIndication)
    CMCHKPK(oduUnpackUInt8, param->directInd, mBuf);
 
 
@@ -6557,20 +6454,18 @@ PRIVATE S16 cmPkTfuDirectIndication(param, mBuf)
  *
  **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat62AllocInfo
+S16 cmPkTfuDciFormat62AllocInfo
 (
  TfuDciFormat62AllocInfo *param,
  Buffer *mBuf
  )
 #else
-PUBLIC S16 cmPkTfuDciFormat62AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat62AllocInfo(param, mBuf)
    TfuDciFormat62AllocInfo *param;
    Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat6AAllocInfo)
-
    CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
    CMCHKPK(oduUnpackUInt8, param->riv, mBuf);
@@ -6609,7 +6504,6 @@ PRIVATE S16 cmPkTfudciformat62Pdsch(param, mBuf)
 #endif
 {
 
-   TRC3(cmPkTfudciformat62Pdsch)
    CMCHKPK(oduUnpackUInt8, param->dciSubRepNum, mBuf);
    CMCHKPK(oduUnpackUInt8, param->repNum, mBuf);
    CMCHKPK(cmPkTfuDciFormat62AllocInfo, &param->format62AllocInfo, mBuf);
@@ -6638,20 +6532,18 @@ PRIVATE S16 cmPkTfudciformat62Pdsch(param, mBuf)
  *
  **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat62Info
+S16 cmPkTfuDciFormat62Info
 (
  TfuDciFormat62Info *param,
  Buffer *mBuf
  )
 #else
-PUBLIC S16 cmPkTfuDciFormat62Info(param, mBuf)
+S16 cmPkTfuDciFormat62Info(param, mBuf)
    TfuDciFormat62Info *param;
    Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat62Info)
-
       switch(param->isPaging) {
          case TRUE:
             CMCHKPK(cmPkTfudciformat62Pdsch, &param->t.pdschInfo, mBuf);
@@ -6694,19 +6586,18 @@ PUBLIC S16 cmPkTfuDciFormat62Info(param, mBuf)
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1aInfo
+S16 cmPkTfuDciFormat1aInfo
 (
 TfuDciFormat1aInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1aInfo(param, mBuf)
+S16 cmPkTfuDciFormat1aInfo(param, mBuf)
 TfuDciFormat1aInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1aInfo)
 
    switch(param->isPdcchOrder) {
       case FALSE:
@@ -6744,19 +6635,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1aInfo
+S16 cmUnpkTfuDciFormat1aInfo
 (
 TfuDciFormat1aInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1aInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1aInfo(param, mBuf)
 TfuDciFormat1aInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1aInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->isPdcchOrder, mBuf);
    switch(param->isPdcchOrder) {
@@ -6794,19 +6684,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1bInfo
+S16 cmPkTfuDciFormat1bInfo
 (
 TfuDciFormat1bInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormat1bInfo(param, mBuf)
+S16 cmPkTfuDciFormat1bInfo(param, mBuf)
 TfuDciFormat1bInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormat1bInfo)
 
    CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
 
@@ -6840,19 +6729,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1bInfo
+S16 cmUnpkTfuDciFormat1bInfo
 (
 TfuDciFormat1bInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormat1bInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1bInfo(param, mBuf)
 TfuDciFormat1bInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormat1bInfo)
 
    CMCHKUNPK(cmUnpkTfuDciFormat1bAllocInfo, &param->allocInfo, mBuf);
 
@@ -6896,19 +6784,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciInfo
+S16 cmPkTfuDciInfo
 (
 TfuDciInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciInfo(param, mBuf)
+S16 cmPkTfuDciInfo(param, mBuf)
 TfuDciInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciInfo)
 
       switch(param->dciFormat) {
 #ifdef TFU_5GTF
@@ -7005,22 +6892,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciInfo
+S16 cmUnpkTfuDciInfo
 (
 TfuDciInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciInfo(param, mBuf)
+S16 cmUnpkTfuDciInfo(param, mBuf)
 TfuDciInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciInfo)
 
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->dciFormat, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->dciFormat, mBuf);
       switch(param->dciFormat) {
          case TFU_DCI_FORMAT_0:
             CMCHKUNPK(cmUnpkTfuDciFormat0Info, &param->u.format0Info, mBuf);
@@ -7105,19 +6991,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandInfo
+S16 cmPkTfuSubbandInfo
 (
 TfuSubbandInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSubbandInfo(param, mBuf)
+S16 cmPkTfuSubbandInfo(param, mBuf)
 TfuSubbandInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuSubbandInfo)
 
    CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
    CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
@@ -7143,19 +7028,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandInfo
+S16 cmUnpkTfuSubbandInfo
 (
 TfuSubbandInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSubbandInfo(param, mBuf)
+S16 cmUnpkTfuSubbandInfo(param, mBuf)
 TfuSubbandInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuSubbandInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->rbStart, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->numRb, mBuf);
@@ -7181,19 +7065,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandCqiInfo
+S16 cmPkTfuSubbandCqiInfo
 (
 TfuSubbandCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSubbandCqiInfo(param, mBuf)
+S16 cmPkTfuSubbandCqiInfo(param, mBuf)
 TfuSubbandCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuSubbandCqiInfo)
 
    CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
    CMCHKPK(cmPkTfuSubbandInfo, &param->subband, mBuf);
@@ -7218,19 +7101,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandCqiInfo
+S16 cmUnpkTfuSubbandCqiInfo
 (
 TfuSubbandCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSubbandCqiInfo(param, mBuf)
+S16 cmUnpkTfuSubbandCqiInfo(param, mBuf)
 TfuSubbandCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuSubbandCqiInfo)
 
    CMCHKUNPK(cmUnpkTfuSubbandInfo, &param->subband, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->cqiIdx, mBuf);
@@ -7255,19 +7137,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchCceInfo
+S16 cmPkTfuPdcchCceInfo
 (
 TfuPdcchCceInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuPdcchCceInfo(param, mBuf)
+S16 cmPkTfuPdcchCceInfo(param, mBuf)
 TfuPdcchCceInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuPdcchCceInfo)
 
    CMCHKPK(cmPkLteAggrLvl, param->aggrLvl, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cceIdx, mBuf);
@@ -7292,22 +7173,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchCceInfo
+S16 cmUnpkTfuPdcchCceInfo
 (
 TfuPdcchCceInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPdcchCceInfo(param, mBuf)
+S16 cmUnpkTfuPdcchCceInfo(param, mBuf)
 TfuPdcchCceInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuPdcchCceInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->cceIdx, mBuf);
-   CMCHKUNPK(cmUnpkLteAggrLvl,(U32 *)&param->aggrLvl, mBuf);
+   CMCHKUNPK(cmUnpkLteAggrLvl,(uint32_t *)&param->aggrLvl, mBuf);
    return ROK;
 }
 
@@ -7330,19 +7210,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode10
+S16 cmPkTfuCqiPucchMode10
 (
 TfuCqiPucchMode10 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPucchMode10(param, mBuf)
+S16 cmPkTfuCqiPucchMode10(param, mBuf)
 TfuCqiPucchMode10 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiPucchMode10)
 
       switch(param->type) {
          case TFU_RPT_CQI:
@@ -7377,21 +7256,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode10
+S16 cmUnpkTfuCqiPucchMode10
 (
 TfuCqiPucchMode10 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPucchMode10(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode10(param, mBuf)
 TfuCqiPucchMode10 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiPucchMode10)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
       switch(param->type) {
          case TFU_RPT_RI:
             CMCHKUNPK(oduPackUInt8, &param->u.ri, mBuf);
@@ -7424,21 +7302,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode11Cqi
+S16 cmPkTfuCqiMode11Cqi
 (
 TfuCqiMode11Cqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiMode11Cqi(param, mBuf)
+S16 cmPkTfuCqiMode11Cqi(param, mBuf)
 TfuCqiMode11Cqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiMode11Cqi)
 
-   CMCHKPK(cmPkTknU8, &param->wideDiffCqi, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->wideDiffCqi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
    return ROK;
@@ -7463,23 +7340,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode11Cqi
+S16 cmUnpkTfuCqiMode11Cqi
 (
 TfuCqiMode11Cqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiMode11Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode11Cqi(param, mBuf)
 TfuCqiMode11Cqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiMode11Cqi)
 
    CMCHKUNPK(oduPackUInt8, &param->cqi, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->pmi, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->wideDiffCqi, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->wideDiffCqi, mBuf);
    return ROK;
 }
 
@@ -7502,19 +7378,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode11
+S16 cmPkTfuCqiPucchMode11
 (
 TfuCqiPucchMode11 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPucchMode11(param, mBuf)
+S16 cmPkTfuCqiPucchMode11(param, mBuf)
 TfuCqiPucchMode11 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiPucchMode11)
 
       switch(param->type) {
          case TFU_RPT_CQI:
@@ -7549,21 +7424,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode11
+S16 cmUnpkTfuCqiPucchMode11
 (
 TfuCqiPucchMode11 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPucchMode11(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode11(param, mBuf)
 TfuCqiPucchMode11 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiPucchMode11)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
       switch(param->type) {
          case TFU_RPT_RI:
             CMCHKUNPK(oduPackUInt8, &param->u.ri, mBuf);
@@ -7595,19 +7469,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode20SubCqi
+S16 cmPkTfuCqiMode20SubCqi
 (
 TfuCqiMode20SubCqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiMode20SubCqi(param, mBuf)
+S16 cmPkTfuCqiMode20SubCqi(param, mBuf)
 TfuCqiMode20SubCqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiMode20SubCqi)
 
    CMCHKPK(oduUnpackUInt8, param->l, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
@@ -7632,19 +7505,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode20SubCqi
+S16 cmUnpkTfuCqiMode20SubCqi
 (
 TfuCqiMode20SubCqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiMode20SubCqi(param, mBuf)
+S16 cmUnpkTfuCqiMode20SubCqi(param, mBuf)
 TfuCqiMode20SubCqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiMode20SubCqi)
 
    CMCHKUNPK(oduPackUInt8, &param->cqi, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->l, mBuf);
@@ -7670,19 +7542,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode20Cqi
+S16 cmPkTfuCqiMode20Cqi
 (
 TfuCqiMode20Cqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiMode20Cqi(param, mBuf)
+S16 cmPkTfuCqiMode20Cqi(param, mBuf)
 TfuCqiMode20Cqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiMode20Cqi)
 
       switch(param->isWideband) {
          case FALSE:
@@ -7717,19 +7588,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode20Cqi
+S16 cmUnpkTfuCqiMode20Cqi
 (
 TfuCqiMode20Cqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiMode20Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode20Cqi(param, mBuf)
 TfuCqiMode20Cqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiMode20Cqi)
 
    CMCHKUNPK(oduPackUInt8, &param->isWideband, mBuf);
       switch(param->isWideband) {
@@ -7764,19 +7634,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode20
+S16 cmPkTfuCqiPucchMode20
 (
 TfuCqiPucchMode20 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPucchMode20(param, mBuf)
+S16 cmPkTfuCqiPucchMode20(param, mBuf)
 TfuCqiPucchMode20 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiPucchMode20)
 
       switch(param->type) {
          case TFU_RPT_CQI:
@@ -7811,21 +7680,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode20
+S16 cmUnpkTfuCqiPucchMode20
 (
 TfuCqiPucchMode20 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPucchMode20(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode20(param, mBuf)
 TfuCqiPucchMode20 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiPucchMode20)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
       switch(param->type) {
          case TFU_RPT_RI:
             CMCHKUNPK(oduPackUInt8, &param->u.ri, mBuf);
@@ -7858,21 +7726,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode21SubCqi
+S16 cmPkTfuCqiMode21SubCqi
 (
 TfuCqiMode21SubCqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiMode21SubCqi(param, mBuf)
+S16 cmPkTfuCqiMode21SubCqi(param, mBuf)
 TfuCqiMode21SubCqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiMode21SubCqi)
 
-   CMCHKPK(cmPkTknU8, &param->diffCqi, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->diffCqi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->l, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
    return ROK;
@@ -7897,23 +7764,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode21SubCqi
+S16 cmUnpkTfuCqiMode21SubCqi
 (
 TfuCqiMode21SubCqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiMode21SubCqi(param, mBuf)
+S16 cmUnpkTfuCqiMode21SubCqi(param, mBuf)
 TfuCqiMode21SubCqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiMode21SubCqi)
 
    CMCHKUNPK(oduPackUInt8, &param->cqi, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->l, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->diffCqi, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->diffCqi, mBuf);
    return ROK;
 }
 
@@ -7936,21 +7802,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode21WideCqi
+S16 cmPkTfuCqiMode21WideCqi
 (
 TfuCqiMode21WideCqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiMode21WideCqi(param, mBuf)
+S16 cmPkTfuCqiMode21WideCqi(param, mBuf)
 TfuCqiMode21WideCqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiMode21WideCqi)
 
-   CMCHKPK(cmPkTknU8, &param->diffCqi, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->diffCqi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
    return ROK;
@@ -7975,23 +7840,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode21WideCqi
+S16 cmUnpkTfuCqiMode21WideCqi
 (
 TfuCqiMode21WideCqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiMode21WideCqi(param, mBuf)
+S16 cmUnpkTfuCqiMode21WideCqi(param, mBuf)
 TfuCqiMode21WideCqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiMode21WideCqi)
 
    CMCHKUNPK(oduPackUInt8, &param->cqi, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->pmi, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->diffCqi, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->diffCqi, mBuf);
    return ROK;
 }
 
@@ -8014,19 +7878,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode21Cqi
+S16 cmPkTfuCqiMode21Cqi
 (
 TfuCqiMode21Cqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiMode21Cqi(param, mBuf)
+S16 cmPkTfuCqiMode21Cqi(param, mBuf)
 TfuCqiMode21Cqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiMode21Cqi)
 
       switch(param->isWideband) {
          case FALSE:
@@ -8061,19 +7924,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode21Cqi
+S16 cmUnpkTfuCqiMode21Cqi
 (
 TfuCqiMode21Cqi *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiMode21Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode21Cqi(param, mBuf)
 TfuCqiMode21Cqi *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiMode21Cqi)
 
    CMCHKUNPK(oduPackUInt8, &param->isWideband, mBuf);
       switch(param->isWideband) {
@@ -8108,19 +7970,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPucchMode21
+S16 cmPkTfuCqiPucchMode21
 (
 TfuCqiPucchMode21 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPucchMode21(param, mBuf)
+S16 cmPkTfuCqiPucchMode21(param, mBuf)
 TfuCqiPucchMode21 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCqiPucchMode21)
 
       switch(param->type) {
          case TFU_RPT_CQI:
@@ -8155,21 +8016,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode21
+S16 cmUnpkTfuCqiPucchMode21
 (
 TfuCqiPucchMode21 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPucchMode21(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode21(param, mBuf)
 TfuCqiPucchMode21 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCqiPucchMode21)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
       switch(param->type) {
          case TFU_RPT_RI:
             CMCHKUNPK(oduPackUInt8, &param->u.ri, mBuf);
@@ -8201,19 +8061,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiPucch
+S16 cmPkTfuDlCqiPucch
 (
 TfuDlCqiPucch *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDlCqiPucch(param, mBuf)
+S16 cmPkTfuDlCqiPucch(param, mBuf)
 TfuDlCqiPucch *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDlCqiPucch)
 
       switch(param->mode) {
          case TFU_PUCCH_CQI_MODE21:
@@ -8254,22 +8113,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPucch
+S16 cmUnpkTfuDlCqiPucch
 (
 TfuDlCqiPucch *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDlCqiPucch(param, mBuf)
+S16 cmUnpkTfuDlCqiPucch(param, mBuf)
 TfuDlCqiPucch *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDlCqiPucch)
 
    CMCHKUNPK(oduPackUInt8, &param->cellIdx, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->mode, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->mode, mBuf);
       switch(param->mode) {
          case TFU_PUCCH_CQI_MODE10:
             CMCHKUNPK(cmUnpkTfuCqiPucchMode10, &param->u.mode10Info, mBuf);
@@ -8308,19 +8166,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode12
+S16 cmPkTfuSubbandMode12
 (
 TfuSubbandMode12 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSubbandMode12(param, mBuf)
+S16 cmPkTfuSubbandMode12(param, mBuf)
 TfuSubbandMode12 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuSubbandMode12)
 
    CMCHKPK(cmPkTfuSubbandInfo, &param->subBand, mBuf);
    CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
@@ -8346,19 +8203,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode12
+S16 cmUnpkTfuSubbandMode12
 (
 TfuSubbandMode12 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSubbandMode12(param, mBuf)
+S16 cmUnpkTfuSubbandMode12(param, mBuf)
 TfuSubbandMode12 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuSubbandMode12)
 
    CMCHKUNPK(oduPackUInt8, &param->pmi, mBuf);
    CMCHKUNPK(cmUnpkTfuSubbandInfo, &param->subBand, mBuf);
@@ -8384,20 +8240,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode12
+S16 cmPkTfuCqiPuschMode12
 (
 TfuCqiPuschMode12 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPuschMode12(param, mBuf)
+S16 cmPkTfuCqiPuschMode12(param, mBuf)
 TfuCqiPuschMode12 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuCqiPuschMode12)
 
    for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
       CMCHKPK(cmPkTfuSubbandMode12, &param->subbandArr[i], mBuf);
@@ -8428,20 +8283,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode12
+S16 cmUnpkTfuCqiPuschMode12
 (
 TfuCqiPuschMode12 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPuschMode12(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode12(param, mBuf)
 TfuCqiPuschMode12 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuCqiPuschMode12)
 
    CMCHKUNPK(oduPackUInt8, &param->numSubband, mBuf);
    for (i=0; i<TFU_MAX_TB; i++) {
@@ -8472,20 +8326,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode20
+S16 cmPkTfuCqiPuschMode20
 (
 TfuCqiPuschMode20 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPuschMode20(param, mBuf)
+S16 cmPkTfuCqiPuschMode20(param, mBuf)
 TfuCqiPuschMode20 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuCqiPuschMode20)
 
    for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
       CMCHKPK(cmPkTfuSubbandInfo, &param->subbandArr[i], mBuf);
@@ -8515,20 +8368,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode20
+S16 cmUnpkTfuCqiPuschMode20
 (
 TfuCqiPuschMode20 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPuschMode20(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode20(param, mBuf)
 TfuCqiPuschMode20 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuCqiPuschMode20)
 
    CMCHKUNPK(oduPackUInt8, &param->cqiIdx, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->wideBandCqi, mBuf);
@@ -8557,20 +8409,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode22
+S16 cmPkTfuCqiPuschMode22
 (
 TfuCqiPuschMode22 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPuschMode22(param, mBuf)
+S16 cmPkTfuCqiPuschMode22(param, mBuf)
 TfuCqiPuschMode22 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuCqiPuschMode22)
 
 
    for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
@@ -8608,20 +8459,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode22
+S16 cmUnpkTfuCqiPuschMode22
 (
 TfuCqiPuschMode22 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPuschMode22(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode22(param, mBuf)
 TfuCqiPuschMode22 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuCqiPuschMode22)
 
    for (i=0; i<TFU_MAX_TB; i++) {
       CMCHKUNPK(oduPackUInt8, &param->cqi[i], mBuf);
@@ -8642,19 +8492,18 @@ Buffer *mBuf;
 
 
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode30
+S16 cmPkTfuSubbandMode30
 (
 TfuSubbandMode30 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSubbandMode30(param, mBuf)
+S16 cmPkTfuSubbandMode30(param, mBuf)
 TfuSubbandMode30 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuSubbandMode30)
 
    CMCHKPK(cmPkTfuSubbandInfo, &param->subBand, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
@@ -8663,19 +8512,18 @@ Buffer *mBuf;
 
 
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode30
+S16 cmUnpkTfuSubbandMode30
 (
 TfuSubbandMode30 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSubbandMode30(param, mBuf)
+S16 cmUnpkTfuSubbandMode30(param, mBuf)
 TfuSubbandMode30 *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuSubbandMode30)
 
    CMCHKUNPK(oduPackUInt8, &param->cqi, mBuf);
    CMCHKUNPK(cmUnpkTfuSubbandInfo, &param->subBand, mBuf);
@@ -8701,20 +8549,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode30
+S16 cmPkTfuCqiPuschMode30
 (
 TfuCqiPuschMode30 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPuschMode30(param, mBuf)
+S16 cmPkTfuCqiPuschMode30(param, mBuf)
 TfuCqiPuschMode30 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuCqiPuschMode30)
 
    for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
       CMCHKPK(cmPkTfuSubbandMode30, &param->subbandArr[i], mBuf);
@@ -8743,20 +8590,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode30
+S16 cmUnpkTfuCqiPuschMode30
 (
 TfuCqiPuschMode30 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPuschMode30(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode30(param, mBuf)
 TfuCqiPuschMode30 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuCqiPuschMode30)
 
    CMCHKUNPK(oduPackUInt8, &param->wideBandCqi, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->numSubband, mBuf);
@@ -8768,20 +8614,19 @@ Buffer *mBuf;
 
 
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode31
+S16 cmPkTfuSubbandMode31
 (
 TfuSubbandMode31 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSubbandMode31(param, mBuf)
+S16 cmPkTfuSubbandMode31(param, mBuf)
 TfuSubbandMode31 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuSubbandMode31)
 
    CMCHKPK(cmPkTfuSubbandInfo, &param->subBand, mBuf);
    for (i=TFU_MAX_TB-1; i >= 0; i--) {
@@ -8792,20 +8637,19 @@ Buffer *mBuf;
 
 
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode31
+S16 cmUnpkTfuSubbandMode31
 (
 TfuSubbandMode31 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSubbandMode31(param, mBuf)
+S16 cmUnpkTfuSubbandMode31(param, mBuf)
 TfuSubbandMode31 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuSubbandMode31)
 
    for (i=0; i<TFU_MAX_TB; i++) {
       CMCHKUNPK(oduPackUInt8, &param->cqi[i], mBuf);
@@ -8833,20 +8677,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode31
+S16 cmPkTfuCqiPuschMode31
 (
 TfuCqiPuschMode31 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCqiPuschMode31(param, mBuf)
+S16 cmPkTfuCqiPuschMode31(param, mBuf)
 TfuCqiPuschMode31 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuCqiPuschMode31)
 
 
 /* tfu_c_001.main_4 - Changes for MIMO feature addition */
@@ -8885,20 +8728,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode31
+S16 cmUnpkTfuCqiPuschMode31
 (
 TfuCqiPuschMode31 *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCqiPuschMode31(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode31(param, mBuf)
 TfuCqiPuschMode31 *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuCqiPuschMode31)
 
    CMCHKUNPK(oduPackUInt8, &param->pmi, mBuf);
    for (i=0; i<TFU_MAX_TB; i++) {
@@ -8938,19 +8780,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiPusch
+S16 cmPkTfuDlCqiPusch
 (
 TfuDlCqiPusch *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDlCqiPusch(param, mBuf)
+S16 cmPkTfuDlCqiPusch(param, mBuf)
 TfuDlCqiPusch *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDlCqiPusch)
 
       switch(param->mode) {
          case TFU_PUSCH_CQI_MODE_31:
@@ -8972,7 +8813,7 @@ Buffer *mBuf;
             return RFAILED;
       }
 
-   CMCHKPK(cmPkTknU8, &param->ri, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->ri, mBuf);
    CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
 
    CMCHKPK(oduUnpackUInt8, param->cellIdx, mBuf);
@@ -8998,23 +8839,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPusch
+S16 cmUnpkTfuDlCqiPusch
 (
 TfuDlCqiPusch *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDlCqiPusch(param, mBuf)
+S16 cmUnpkTfuDlCqiPusch(param, mBuf)
 TfuDlCqiPusch *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDlCqiPusch)
 
    CMCHKUNPK(oduPackUInt8, &param->cellIdx, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->mode, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->ri, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->mode, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->ri, mBuf);
    switch(param->mode) {
       case TFU_PUSCH_CQI_MODE_12:
          CMCHKUNPK(cmUnpkTfuCqiPuschMode12, &param->u.mode12Info, mBuf);
@@ -9054,22 +8894,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiInfo
+S16 cmPkTfuDlCqiInfo
 (
-U8 selector,
+uint8_t selector,
 TfuDlCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDlCqiInfo(selector, param, mBuf)
-U8 selector;
+S16 cmPkTfuDlCqiInfo(selector, param, mBuf)
+uint8_t selector;
 TfuDlCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
-   U32 idx;
+   uint32_t idx;
 
-   TRC3(cmPkTfuDlCqiInfo)
 
    switch(selector) {
       case FALSE:
@@ -9106,22 +8945,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiInfo
+S16 cmUnpkTfuDlCqiInfo
 (
-U8 selector,
+uint8_t selector,
 TfuDlCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDlCqiInfo(selector, param, mBuf)
-U8 selector;
+S16 cmUnpkTfuDlCqiInfo(selector, param, mBuf)
+uint8_t selector;
 TfuDlCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   U8 idx;
-   TRC3(cmUnpkTfuDlCqiInfo)
+   uint8_t idx;
 
    switch(selector) {
       case TRUE:
@@ -9165,22 +9003,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRecpReqInfo
+S16 cmPkTfuRecpReqInfo
 (
 TfuRecpReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRecpReqInfo(param, mBuf)
+S16 cmPkTfuRecpReqInfo(param, mBuf)
 TfuRecpReqInfo *param;
 Buffer *mBuf;
 #endif
 {
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuUeRecpReqInfo *tfuUeRecpReqInfo;
 
-   TRC3(cmPkTfuRecpReqInfo)
 
    /*ccpu00116923 - ADD - SRS present support*/
    /*tfu_c_001.main_7 - ADD - SRS present field inclusion */
@@ -9227,24 +9064,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRecpReqInfo
+S16 cmUnpkTfuRecpReqInfo
 (
 TfuRecpReqInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRecpReqInfo(param, memCp, mBuf)
+S16 cmUnpkTfuRecpReqInfo(param, memCp, mBuf)
 TfuRecpReqInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuUeRecpReqInfo *tfuUeRecpReqInfo;
 
-   TRC3(cmUnpkTfuRecpReqInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -9283,19 +9119,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchInfo
+S16 cmPkTfuPdcchInfo
 (
 TfuPdcchInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuPdcchInfo(param, mBuf)
+S16 cmPkTfuPdcchInfo(param, mBuf)
 TfuPdcchInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuPdcchInfo)
 #ifdef TFU_5GTF
    CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
    CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
@@ -9332,19 +9167,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchInfo
+S16 cmUnpkTfuPdcchInfo
 (
 TfuPdcchInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPdcchInfo(param, mBuf)
+S16 cmUnpkTfuPdcchInfo(param, mBuf)
 TfuPdcchInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuPdcchInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
 #ifdef LTEMAC_SPS
@@ -9352,7 +9186,7 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
 #endif
    CMCHKUNPK(oduPackUInt16, &param->nCce, mBuf);
-   CMCHKUNPK(cmUnpkLteAggrLvl, (U32*)&param->aggrLvl, mBuf);
+   CMCHKUNPK(cmUnpkLteAggrLvl, (uint32_t*)&param->aggrLvl, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->dciNumOfBits, mBuf);
    CMCHKUNPK(cmUnpkTfuDciInfo, &param->dci, mBuf);
 #ifdef TFU_5GTF 
@@ -9385,19 +9219,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPhichInfo
+S16 cmPkTfuPhichInfo
 (
 TfuPhichInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuPhichInfo(param, mBuf)
+S16 cmPkTfuPhichInfo(param, mBuf)
 TfuPhichInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuPhichInfo)
 /* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
 #ifdef TFU_UPGRADE
    CMCHKPK(oduUnpackUInt16, param->txPower, mBuf);
@@ -9433,19 +9266,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPhichInfo
+S16 cmUnpkTfuPhichInfo
 (
 TfuPhichInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPhichInfo(param, mBuf)
+S16 cmUnpkTfuPhichInfo(param, mBuf)
 TfuPhichInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuPhichInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->rbStart, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->nDmrs, mBuf);
@@ -9482,13 +9314,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCntrlReqInfo
+S16 cmPkTfuCntrlReqInfo
 (
 TfuCntrlReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCntrlReqInfo(param, mBuf)
+S16 cmPkTfuCntrlReqInfo(param, mBuf)
 TfuCntrlReqInfo *param;
 Buffer *mBuf;
 #endif
@@ -9497,9 +9329,8 @@ Buffer *mBuf;
    TfuPdcchInfo   *tfuPdcchInfo;
    TfuPhichInfo *tfuPhichInfo;
    CmLList *node;
-   U32 count;
+   uint32_t count;
 
-   TRC3(cmPkTfuCntrlReqInfo)
 #ifdef EMTC_ENABLE
    count = param->dlMpdcchLst.count;
    node = param->dlMpdcchLst.last;
@@ -9587,14 +9418,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCntrlReqInfo
+S16 cmUnpkTfuCntrlReqInfo
 (
 TfuCntrlReqInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCntrlReqInfo(param, memCp, mBuf)
+S16 cmUnpkTfuCntrlReqInfo(param, memCp, mBuf)
 TfuCntrlReqInfo *param;
 Ptr memCp;
 Buffer *mBuf;
@@ -9602,10 +9433,9 @@ Buffer *mBuf;
 {
 
    TfuPdcchInfo *tfuPdcchInfo;
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuPhichInfo *tfuPhichInfo;
 
-   TRC3(cmUnpkTfuCntrlReqInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->ulTiming, mBuf);
@@ -9681,19 +9511,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPdschDciInfo
+S16 cmPkTfuPdschDciInfo
 (
 TfuPdschDciInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuPdschDciInfo(param, mBuf)
+S16 cmPkTfuPdschDciInfo(param, mBuf)
 TfuPdschDciInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuPdschDciInfo)
 
       switch(param->format) {
 #ifdef TFU_5GTF
@@ -9781,21 +9610,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdschDciInfo
+S16 cmUnpkTfuPdschDciInfo
 (
 TfuPdschDciInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPdschDciInfo(param, mBuf)
+S16 cmUnpkTfuPdschDciInfo(param, mBuf)
 TfuPdschDciInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuPdschDciInfo)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->format, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->format, mBuf);
       switch(param->format) {
          case TFU_DCI_FORMAT_1:
             CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, &param->u.format1AllocInfo, mBuf);
@@ -9864,19 +9692,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuBfVectorInfo
+S16 cmPkTfuBfVectorInfo
 (
 TfuBfVectorInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuBfVectorInfo(param, mBuf)
+S16 cmPkTfuBfVectorInfo(param, mBuf)
 TfuBfVectorInfo *param;
 Buffer *mBuf;
 #endif
 {
    S32 idx, idx2;
-   TRC3(cmPkTfuBfVectorInfo)
    for(idx=TFU_MAX_DL_SUBBAND-1;idx>=0; idx--)
    {
       for (idx2=param->numPhyAnt -1; idx2 >= 0; idx2--) {
@@ -9904,19 +9731,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuBfVectorInfo
+S16 cmUnpkTfuBfVectorInfo
 (
    TfuBfVectorInfo *param,
    Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuBfVectorInfo(param, mBuf)
+S16 cmUnpkTfuBfVectorInfo(param, mBuf)
  TfuBfVectorInfo *param;
  Buffer *mBuf;
 #endif
 {
    S32 idx, idx2;
-   TRC3(cmUnpkTfuBfVectorInfo)
     for(idx=0;idx<TFU_MAX_DL_SUBBAND; idx++)
    {
       CMCHKUNPK(oduPackUInt8, &param->sbIndex, mBuf);
@@ -9945,25 +9771,24 @@ PUBLIC S16 cmUnpkTfuBfVectorInfo(param, mBuf)
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDatReqPduInfo
+S16 cmPkTfuDatReqPduInfo
 (
 TfuDatReqPduInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDatReqPduInfo(param, mBuf)
+S16 cmPkTfuDatReqPduInfo(param, mBuf)
 TfuDatReqPduInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   U8  tbMask = 0;
+   uint8_t  tbMask = 0;
 #ifdef L2_OPTMZ
-   U32 lchIdx, pduIdx;
+   uint32_t lchIdx, pduIdx;
 #endif
 
-   TRC3(cmPkTfuDatReqPduInfo)
 
    /* LTE_ADV_FLAG_REMOVED_START */
    CMCHKPK(oduUnpackUInt8, param->isEnbSFR, mBuf);
@@ -9985,7 +9810,7 @@ Buffer *mBuf;
    CMCHKPK(oduUnpackUInt8, param->numLayers, mBuf);
 #endif
    CMCHKPK(oduPackBool, param->isTApres, mBuf);
-   CMCHKPK(cmPkTknU32, &param->doa, mBuf);
+   CMCHKPK(cmPkTknUInt32, &param->doa, mBuf);
    CMCHKPK(oduUnpackUInt32, param->transMode, mBuf);
    CMCHKPK(cmPkTfuDlCqiPuschInfo, &param->puschPmiInfo, mBuf);
    CMCHKPK(oduUnpackUInt8, param->puschRptUsd, mBuf);
@@ -10063,24 +9888,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatReqPduInfo
+S16 cmUnpkTfuDatReqPduInfo
 (
 TfuDatReqPduInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDatReqPduInfo(param, mBuf)
+S16 cmUnpkTfuDatReqPduInfo(param, mBuf)
 TfuDatReqPduInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   U8 i;
-   U8  tbMask = 0;
+   uint8_t i;
+   uint8_t  tbMask = 0;
 #ifdef L2_OPTMZ
-   U32 lchIdx, pduIdx;
+   uint32_t lchIdx, pduIdx;
 #endif
-   TRC3(cmUnpkTfuDatReqPduInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(cmUnpkTfuPdschDciInfo, &param->dciInfo, mBuf);
@@ -10103,10 +9927,10 @@ Buffer *mBuf;
       CMCHKUNPK(cmUnpkBuffer, &param->tbInfo[i].macHdr, mBuf);
       CMCHKUNPK(cmUnpkBuffer, &param->tbInfo[i].macCes, mBuf);
       CMCHKUNPK(oduPackUInt32, &param->tbInfo[i].padSize, mBuf);
-      CMCHKUNPK(oduPackUInt32, (U32 *)&param->tbInfo[i].numLch, mBuf);
+      CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->tbInfo[i].numLch, mBuf);
       for(lchIdx = 0; lchIdx < param->tbInfo[i].numLch; lchIdx++)
       {
-         CMCHKUNPK(oduPackUInt32, (U32 *)&param->tbInfo[i].lchInfo[lchIdx].numPdu,
+         CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->tbInfo[i].lchInfo[lchIdx].numPdu,
                mBuf);
          for(pduIdx = 0; pduIdx < param->tbInfo[i].lchInfo[lchIdx].numPdu;
                pduIdx++)
@@ -10128,8 +9952,8 @@ Buffer *mBuf;
 
    CMCHKUNPK(oduPackUInt8, &param->puschRptUsd, mBuf);
    CMCHKUNPK(cmUnpkTfuDlCqiPuschInfo, &param->puschPmiInfo, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->transMode, mBuf);
-   CMCHKUNPK(cmUnpkTknU32, &param->doa, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->transMode, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt32, &param->doa, mBuf);
    CMCHKUNPK(oduUnpackBool, &param->isTApres, mBuf);
 /* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
 #ifdef TFU_UPGRADE
@@ -10175,23 +9999,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDatReqInfo
+S16 cmPkTfuDatReqInfo
 (
 TfuDatReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDatReqInfo(param, mBuf)
+S16 cmPkTfuDatReqInfo(param, mBuf)
 TfuDatReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuDatReqPduInfo *tfuDatReqPduInfo;
 
-   TRC3(cmPkTfuDatReqInfo)
 
    count = param->pdus.count;
    node = param->pdus.last;
@@ -10230,24 +10053,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatReqInfo
+S16 cmUnpkTfuDatReqInfo
 (
 TfuDatReqInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDatReqInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDatReqInfo(param, memCp, mBuf)
 TfuDatReqInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuDatReqPduInfo *tfuDatReqPduInfo;
 
-   TRC3(cmUnpkTfuDatReqInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -10281,19 +10103,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDatInfo
+S16 cmPkTfuDatInfo
 (
 TfuDatInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDatInfo(param, mBuf)
+S16 cmPkTfuDatInfo(param, mBuf)
 TfuDatInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDatInfo)
 
    CMCHKPK(cmPkBuffer, &param->mBuf, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
@@ -10318,19 +10139,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatInfo
+S16 cmUnpkTfuDatInfo
 (
 TfuDatInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDatInfo(param, mBuf)
+S16 cmUnpkTfuDatInfo(param, mBuf)
 TfuDatInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDatInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(cmUnpkBuffer, &param->mBuf, mBuf);
@@ -10357,23 +10177,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDatIndInfo
+S16 cmPkTfuDatIndInfo
 (
 TfuDatIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDatIndInfo(param, mBuf)
+S16 cmPkTfuDatIndInfo(param, mBuf)
 TfuDatIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuDatInfo *tfuDatInfo;
 
-   TRC3(cmPkTfuDatIndInfo)
 
 #ifdef TFU_5GTF
    CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
@@ -10414,24 +10233,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatIndInfo
+S16 cmUnpkTfuDatIndInfo
 (
 TfuDatIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDatIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDatIndInfo(param, memCp, mBuf)
 TfuDatIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuDatInfo *tfuDatInfo;
 
-   TRC3(cmUnpkTfuDatIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -10471,19 +10289,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSrInfo
+S16 cmPkTfuSrInfo
 (
 TfuSrInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSrInfo(param, mBuf)
+S16 cmPkTfuSrInfo(param, mBuf)
 TfuSrInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuSrInfo)
 
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
    return ROK;
@@ -10510,19 +10327,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrInfo
+S16 cmUnpkTfuSrInfo
 (
 TfuSrInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSrInfo(param, mBuf)
+S16 cmUnpkTfuSrInfo(param, mBuf)
 TfuSrInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuSrInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    return ROK;
@@ -10547,23 +10363,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSrIndInfo
+S16 cmPkTfuSrIndInfo
 (
 TfuSrIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSrIndInfo(param, mBuf)
+S16 cmPkTfuSrIndInfo(param, mBuf)
 TfuSrIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuSrInfo *tfuSrInfo;
 
-   TRC3(cmPkTfuSrIndInfo)
 
    count = param->srLst.count;
    node = param->srLst.last;
@@ -10599,24 +10414,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrIndInfo
+S16 cmUnpkTfuSrIndInfo
 (
 TfuSrIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSrIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuSrIndInfo(param, memCp, mBuf)
 TfuSrIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuSrInfo *tfuSrInfo;
 
-   TRC3(cmUnpkTfuSrIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -10651,20 +10465,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuHqInfo
+S16 cmPkTfuHqInfo
 (
 TfuHqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuHqInfo(param, mBuf)
+S16 cmPkTfuHqInfo(param, mBuf)
 TfuHqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuHqInfo)
 
    CMCHKPK(oduUnpackUInt8, param->isPusch, mBuf);
    for (i=TFU_MAX_HARQ_FDBKS-1; i >= 0; i--) {
@@ -10700,29 +10513,28 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuHqInfo
+S16 cmUnpkTfuHqInfo
 (
 TfuHqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuHqInfo(param, mBuf)
+S16 cmUnpkTfuHqInfo(param, mBuf)
 TfuHqInfo *param;
 Buffer *mBuf;
 #endif
 {
    S32 i;
-   TRC3(cmUnpkTfuHqInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
 /* ACC-TDD ccpu00130520 */
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->hqFdbkMode, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->hqFdbkMode, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->noOfTbs, mBuf);
 #ifdef TFU_TDD
    CMCHKUNPK(oduPackUInt8, &param->M, mBuf);
 #endif
    for (i=0; i<TFU_MAX_HARQ_FDBKS; i++) {
-      CMCHKUNPK(oduPackUInt32, (U32 *)&param->isAck[i], mBuf);
+      CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->isAck[i], mBuf);
    }
    CMCHKUNPK(oduPackUInt8, &param->isPusch, mBuf);
    return ROK;
@@ -10750,23 +10562,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuHqIndInfo
+S16 cmPkTfuHqIndInfo
 (
 TfuHqIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuHqIndInfo(param, mBuf)
+S16 cmPkTfuHqIndInfo(param, mBuf)
 TfuHqIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuHqInfo *tfuHqInfo;
 
-   TRC3(cmPkTfuHqIndInfo)
 
    count = param->hqIndLst.count;
    node = param->hqIndLst.last;
@@ -10803,24 +10614,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuHqIndInfo
+S16 cmUnpkTfuHqIndInfo
 (
 TfuHqIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuHqIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuHqIndInfo(param, memCp, mBuf)
 TfuHqIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuHqInfo *tfuHqInfo;
 
-   TRC3(cmUnpkTfuHqIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -10853,19 +10663,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiInfo
+S16 cmPkTfuUlCqiInfo
 (
 TfuUlCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUlCqiInfo(param, mBuf)
+S16 cmPkTfuUlCqiInfo(param, mBuf)
 TfuUlCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUlCqiInfo)
 
    CMCHKPK(cmPkTfuSubbandCqiInfo, &param->subbandCqi, mBuf);
    return ROK;
@@ -10889,19 +10698,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiInfo
+S16 cmUnpkTfuUlCqiInfo
 (
 TfuUlCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUlCqiInfo(param, mBuf)
+S16 cmUnpkTfuUlCqiInfo(param, mBuf)
 TfuUlCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUlCqiInfo)
 
    CMCHKUNPK(cmUnpkTfuSubbandCqiInfo, &param->subbandCqi, mBuf);
    return ROK;
@@ -10926,20 +10734,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiRpt
+S16 cmPkTfuUlCqiRpt
 (
 TfuUlCqiRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUlCqiRpt(param, mBuf)
+S16 cmPkTfuUlCqiRpt(param, mBuf)
 TfuUlCqiRpt *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuUlCqiRpt)
 
    for (i=TFU_MAX_UL_SUBBAND-1; i >= 0; i--) {
       CMCHKPK(cmPkTfuUlCqiInfo, &param->ulCqiInfoArr[i], mBuf);
@@ -10970,20 +10777,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiRpt
+S16 cmUnpkTfuUlCqiRpt
 (
 TfuUlCqiRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUlCqiRpt(param, mBuf)
+S16 cmUnpkTfuUlCqiRpt(param, mBuf)
 TfuUlCqiRpt *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuUlCqiRpt)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->isTxPort0, mBuf);
@@ -11017,23 +10823,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiIndInfo
+S16 cmPkTfuUlCqiIndInfo
 (
 TfuUlCqiIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUlCqiIndInfo(param, mBuf)
+S16 cmPkTfuUlCqiIndInfo(param, mBuf)
 TfuUlCqiIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuUlCqiRpt *tfuUlCqiRpt;
 
-   TRC3(cmPkTfuUlCqiIndInfo)
 
    count = param->ulCqiRpt.count;
    node = param->ulCqiRpt.last;
@@ -11072,24 +10877,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUlCqiIndInfo
+S16 cmUnpkTfuUlCqiIndInfo
 (
 TfuUlCqiIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUlCqiIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuUlCqiIndInfo(param, memCp, mBuf)
 TfuUlCqiIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuUlCqiRpt *tfuUlCqiRpt;
 
-   TRC3(cmUnpkTfuUlCqiIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -11125,19 +10929,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiRpt
+S16 cmPkTfuDlCqiRpt
 (
 TfuDlCqiRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDlCqiRpt(param, mBuf)
+S16 cmPkTfuDlCqiRpt(param, mBuf)
 TfuDlCqiRpt *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDlCqiRpt)
 
       if (cmPkTfuDlCqiInfo(param->isPucchInfo, &param->dlCqiInfo, mBuf) != ROK)
          return RFAILED;
@@ -11166,19 +10969,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiRpt
+S16 cmUnpkTfuDlCqiRpt
 (
 TfuDlCqiRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDlCqiRpt(param, mBuf)
+S16 cmUnpkTfuDlCqiRpt(param, mBuf)
 TfuDlCqiRpt *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDlCqiRpt)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->isPucchInfo, mBuf);
@@ -11207,23 +11009,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiIndInfo
+S16 cmPkTfuDlCqiIndInfo
 (
 TfuDlCqiIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDlCqiIndInfo(param, mBuf)
+S16 cmPkTfuDlCqiIndInfo(param, mBuf)
 TfuDlCqiIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuDlCqiRpt *tfuDlCqiRpt;
 
-   TRC3(cmPkTfuDlCqiIndInfo)
 
    count = param->dlCqiRptsLst.count;
    node = param->dlCqiRptsLst.last;
@@ -11260,24 +11061,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiIndInfo
+S16 cmUnpkTfuDlCqiIndInfo
 (
 TfuDlCqiIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDlCqiIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDlCqiIndInfo(param, memCp, mBuf)
 TfuDlCqiIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuDlCqiRpt *tfuDlCqiRpt;
 
-   TRC3(cmUnpkTfuDlCqiIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -11311,21 +11111,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCrcInfo
+S16 cmPkTfuCrcInfo
 (
 TfuCrcInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCrcInfo(param, mBuf)
+S16 cmPkTfuCrcInfo(param, mBuf)
 TfuCrcInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuCrcInfo)
 
-   CMCHKPK(cmPkTknU8, &param->rv, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->rv, mBuf);
    CMCHKPK(oduUnpackUInt8, param->isFailure, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
    return ROK;
@@ -11350,23 +11149,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCrcInfo
+S16 cmUnpkTfuCrcInfo
 (
 TfuCrcInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCrcInfo(param, mBuf)
+S16 cmUnpkTfuCrcInfo(param, mBuf)
 TfuCrcInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuCrcInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->isFailure, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->rv, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->rv, mBuf);
    return ROK;
 }
 
@@ -11391,23 +11189,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuCrcIndInfo
+S16 cmPkTfuCrcIndInfo
 (
 TfuCrcIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuCrcIndInfo(param, mBuf)
+S16 cmPkTfuCrcIndInfo(param, mBuf)
 TfuCrcIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuCrcInfo *tfuCrcIndInfo;
 
-   TRC3(cmPkTfuCrcIndInfo)
 
 #ifdef TFU_5GTF
    CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
@@ -11449,24 +11246,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuCrcIndInfo
+S16 cmUnpkTfuCrcIndInfo
 (
 TfuCrcIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuCrcIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuCrcIndInfo(param, memCp, mBuf)
 TfuCrcIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuCrcInfo *tfuCrcIndInfo;
 
-   TRC3(cmUnpkTfuCrcIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -11504,19 +11300,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvInfo
+S16 cmPkTfuTimingAdvInfo
 (
 TfuTimingAdvInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuTimingAdvInfo(param, mBuf)
+S16 cmPkTfuTimingAdvInfo(param, mBuf)
 TfuTimingAdvInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuTimingAdvInfo)
 
    CMCHKPK(oduUnpackUInt8, param->timingAdv, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
@@ -11542,19 +11337,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuTimingAdvInfo
+S16 cmUnpkTfuTimingAdvInfo
 (
 TfuTimingAdvInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuTimingAdvInfo(param, mBuf)
+S16 cmUnpkTfuTimingAdvInfo(param, mBuf)
 TfuTimingAdvInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuTimingAdvInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->timingAdv, mBuf);
@@ -11581,23 +11375,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvIndInfo
+S16 cmPkTfuTimingAdvIndInfo
 (
 TfuTimingAdvIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuTimingAdvIndInfo(param, mBuf)
+S16 cmPkTfuTimingAdvIndInfo(param, mBuf)
 TfuTimingAdvIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuTimingAdvInfo *tfuTimingAdvInfo;
 
-   TRC3(cmPkTfuTimingAdvIndInfo)
 
    count = param->timingAdvLst.count;
    node = param->timingAdvLst.last;
@@ -11634,24 +11427,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuTimingAdvIndInfo
+S16 cmUnpkTfuTimingAdvIndInfo
 (
 TfuTimingAdvIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuTimingAdvIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuTimingAdvIndInfo(param, memCp, mBuf)
 TfuTimingAdvIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuTimingAdvInfo *tfuTimingAdvInfo;
 
-   TRC3(cmUnpkTfuTimingAdvIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -11685,19 +11477,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuTtiCellInfo
+S16 cmPkTfuTtiCellInfo
 (
 TfuTtiCellInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuTtiCellInfo(param, mBuf)
+S16 cmPkTfuTtiCellInfo(param, mBuf)
 TfuTtiCellInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuTtiCellInfo)
 
    CMCHKPK(oduUnpackUInt8, param->ulBlankSf, mBuf);
    CMCHKPK(oduUnpackUInt8, param->dlBlankSf, mBuf);
@@ -11726,20 +11517,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuTtiIndInfo
+S16 cmPkTfuTtiIndInfo
 (
 TfuTtiIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuTtiIndInfo(param, mBuf)
+S16 cmPkTfuTtiIndInfo(param, mBuf)
 TfuTtiIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuTtiIndInfo)
 
    /*CA dev Start*/
    for (i=(param->numCells-1); i >= 0; i--) {
@@ -11769,19 +11559,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuTtiCellInfo
+S16 cmUnpkTfuTtiCellInfo
 (
 TfuTtiCellInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuTtiCellInfo(param, mBuf)
+S16 cmUnpkTfuTtiCellInfo(param, mBuf)
 TfuTtiCellInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuTtiCellInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -11816,19 +11605,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqInfo
+S16 cmPkTfuRaReqInfo
 (
 TfuRaReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRaReqInfo(param, mBuf)
+S16 cmPkTfuRaReqInfo(param, mBuf)
 TfuRaReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuRaReqInfo)
 
    CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cqiPres, mBuf);
@@ -11862,19 +11650,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRaReqInfo
+S16 cmUnpkTfuRaReqInfo
 (
 TfuRaReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRaReqInfo(param, mBuf)
+S16 cmUnpkTfuRaReqInfo(param, mBuf)
 TfuRaReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuRaReqInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->rapId, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->ta, mBuf);
@@ -11903,14 +11690,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRachInfo
+S16 cmPkTfuRachInfo
 (
  CmMemListCp   memCp,
 TfuRachInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRachInfo(memCp, param, mBuf)
+S16 cmPkTfuRachInfo(memCp, param, mBuf)
  CmMemListCp   memCp;
 TfuRachInfo *param;
 Buffer *mBuf;
@@ -11918,7 +11705,6 @@ Buffer *mBuf;
 {
 
    S32 i;
-   TRC3(cmPkTfuRachInfo)
 
    for (i= (param->numRaReqInfo - 1); i >= 0; i--) {
       CMCHKPK(cmPkTfuRaReqInfo, &(param->raReqInfoArr[i]), mBuf);
@@ -11956,14 +11742,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRachInfo
+S16 cmUnpkTfuRachInfo
 (
 CmMemListCp   memCp,
 TfuRachInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRachInfo(memCp, param, mBuf)
+S16 cmUnpkTfuRachInfo(memCp, param, mBuf)
 CmMemListCp   memCp;
 TfuRachInfo *param;
 Buffer *mBuf;
@@ -11971,7 +11757,6 @@ Buffer *mBuf;
 {
 
    S32 i;
-   TRC3(cmUnpkTfuRachInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->raRnti, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->numRaReqInfo, mBuf);
@@ -12027,20 +11812,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqIndInfo
+S16 cmPkTfuRaReqIndInfo
 (
 TfuRaReqIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRaReqIndInfo(param, mBuf)
+S16 cmPkTfuRaReqIndInfo(param, mBuf)
 TfuRaReqIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuRaReqIndInfo)
 
    for (i= (param->nmbOfRaRnti-1); i >= 0; i--) 
    {
@@ -12088,20 +11872,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRaReqIndInfo
+S16 cmUnpkTfuRaReqIndInfo
 (
 TfuRaReqIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRaReqIndInfo(param, mBuf)
+S16 cmUnpkTfuRaReqIndInfo(param, mBuf)
 TfuRaReqIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuRaReqIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -12139,19 +11922,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPucchDeltaPwrInfo
+S16 cmPkTfuPucchDeltaPwrInfo
 (
 TfuPucchDeltaPwr *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuPucchDeltaPwrInfo(param, mBuf)
+S16 cmPkTfuPucchDeltaPwrInfo(param, mBuf)
 TfuPucchDeltaPwr *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuPucchDeltaPwrInfo)
 
    CMCHKPK(SPkS8, param->pucchDeltaPwr, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
@@ -12176,19 +11958,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrInfo
+S16 cmUnpkTfuPucchDeltaPwrInfo
 (
 TfuPucchDeltaPwr *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrInfo(param, mBuf)
+S16 cmUnpkTfuPucchDeltaPwrInfo(param, mBuf)
 TfuPucchDeltaPwr *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuPucchDeltaPwrInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(SUnpkS8, &param->pucchDeltaPwr, mBuf);
@@ -12216,23 +11997,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuPucchDeltaPwrIndInfo
+S16 cmPkTfuPucchDeltaPwrIndInfo
 (
 TfuPucchDeltaPwrIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuPucchDeltaPwrIndInfo(param, mBuf)
+S16 cmPkTfuPucchDeltaPwrIndInfo(param, mBuf)
 TfuPucchDeltaPwrIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuPucchDeltaPwr *tfuPucchDeltaPwr;
 
-   TRC3(cmPkTfuPucchDeltaPwrIndInfo)
 
    count = param->pucchDeltaPwrLst.count;
    node = param->pucchDeltaPwrLst.last;
@@ -12270,24 +12050,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrIndInfo
+S16 cmUnpkTfuPucchDeltaPwrIndInfo
 (
 TfuPucchDeltaPwrIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuPucchDeltaPwrIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuPucchDeltaPwrIndInfo(param, memCp, mBuf)
 TfuPucchDeltaPwrIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuPucchDeltaPwr *tfuPucchDeltaPwr;
 
-   TRC3(cmUnpkTfuPucchDeltaPwrIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -12303,19 +12082,18 @@ Buffer *mBuf;
 }
 
 #ifdef ANSI
-PUBLIC S16 cmPkBuffer
+S16 cmPkBuffer
 (
 Buffer **param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkBuffer(param, mBuf)
+S16 cmPkBuffer(param, mBuf)
 Buffer **param;
 Buffer *mBuf;
 #endif
 {
    MsgLen msgLen=0;
-   TRC3(cmPkBuffer)
    if (SFndLenMsg(*param, &msgLen) != ROK)
       return RFAILED;
    if (SCatMsg(mBuf, *param, M1M2) != ROK)
@@ -12326,19 +12104,18 @@ Buffer *mBuf;
    return ROK;
 }
 #ifdef ANSI
-PUBLIC S16 cmUnpkBuffer
+S16 cmUnpkBuffer
 (
 Buffer **param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkBuffer(param, mBuf)
+S16 cmUnpkBuffer(param, mBuf)
 Buffer **param;
 Buffer *mBuf;
 #endif
 {
    MsgLen msgLen=0, totalMsgLen=0;
-   TRC3(cmUnpkBuffer)
    CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
       return RFAILED;
@@ -12370,21 +12147,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDoaInd
+S16 cmPkTfuDoaInd
 (
 Pst * pst,
 SuId suId,
 TfuDoaIndInfo * doaInd
 )
 #else
-PUBLIC S16 cmPkTfuDoaInd(pst, suId, doaInd)
+S16 cmPkTfuDoaInd(pst, suId, doaInd)
 Pst * pst;
 SuId suId;
 TfuDoaIndInfo * doaInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuDoaInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -12434,14 +12210,14 @@ TfuDoaIndInfo * doaInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDoaInd
+S16 cmUnpkTfuDoaInd
 (
 TfuDoaInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDoaInd(func, pst, mBuf)
+S16 cmUnpkTfuDoaInd(func, pst, mBuf)
 TfuDoaInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -12450,7 +12226,6 @@ Buffer *mBuf;
    SuId suId;
    TfuDoaIndInfo *doaInd;
    
-   TRC3(cmUnpkTfuDoaInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);
@@ -12500,19 +12275,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatTbInfo
+S16 cmPkTfuDciFormatTbInfo
 (
 TfuDciFormatTbInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDciFormatTbInfo(param, mBuf)
+S16 cmPkTfuDciFormatTbInfo(param, mBuf)
 TfuDciFormatTbInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDciFormatTbInfo)
 
    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
    CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
@@ -12539,19 +12313,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatTbInfo
+S16 cmUnpkTfuDciFormatTbInfo
 (
 TfuDciFormatTbInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDciFormatTbInfo(param, mBuf)
+S16 cmUnpkTfuDciFormatTbInfo(param, mBuf)
 TfuDciFormatTbInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDciFormatTbInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->ndi, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rv, mBuf);
@@ -12577,20 +12350,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandDlCqiInfo
+S16 cmPkTfuSubbandDlCqiInfo
 (
 TfuSubbandDlCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSubbandDlCqiInfo(param, mBuf)
+S16 cmPkTfuSubbandDlCqiInfo(param, mBuf)
 TfuSubbandDlCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuSubbandDlCqiInfo)
 
    for (i=TFU_MAX_TB-1; i >= 0; i--) {
       CMCHKPK(oduUnpackUInt8, param->cqiIdx[i], mBuf);
@@ -12617,20 +12389,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandDlCqiInfo
+S16 cmUnpkTfuSubbandDlCqiInfo
 (
 TfuSubbandDlCqiInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSubbandDlCqiInfo(param, mBuf)
+S16 cmUnpkTfuSubbandDlCqiInfo(param, mBuf)
 TfuSubbandDlCqiInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuSubbandDlCqiInfo)
 
    CMCHKUNPK(cmUnpkTfuSubbandInfo, &param->subband, mBuf);
    for (i=0; i<TFU_MAX_TB; i++) {
@@ -12656,19 +12427,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiPuschInfo
+S16 cmPkTfuDlCqiPuschInfo
 (
 TfuDlCqiPuschInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDlCqiPuschInfo(param, mBuf)
+S16 cmPkTfuDlCqiPuschInfo(param, mBuf)
 TfuDlCqiPuschInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDlCqiPuschInfo)
 
       switch(param->mode) {
          case TFU_PUSCH_CQI_MODE_31:
@@ -12706,21 +12476,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPuschInfo
+S16 cmUnpkTfuDlCqiPuschInfo
 (
 TfuDlCqiPuschInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDlCqiPuschInfo(param, mBuf)
+S16 cmUnpkTfuDlCqiPuschInfo(param, mBuf)
 TfuDlCqiPuschInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDlCqiPuschInfo)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->mode, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->mode, mBuf);
       switch(param->mode) {
          case TFU_PUSCH_CQI_MODE_12:
             CMCHKUNPK(cmUnpkTfuCqiPuschMode12, &param->u.mode12Info, mBuf);
@@ -12754,19 +12523,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDoaRpt
+S16 cmPkTfuDoaRpt
 (
 TfuDoaRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDoaRpt(param, mBuf)
+S16 cmPkTfuDoaRpt(param, mBuf)
 TfuDoaRpt *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuDoaRpt)
 
    CMCHKPK(oduUnpackUInt32, param->doa, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
@@ -12792,19 +12560,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDoaRpt
+S16 cmUnpkTfuDoaRpt
 (
 TfuDoaRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDoaRpt(param, mBuf)
+S16 cmUnpkTfuDoaRpt(param, mBuf)
 TfuDoaRpt *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuDoaRpt)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
    CMCHKUNPK(oduPackUInt32, &param->doa, mBuf);
@@ -12833,22 +12600,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuDoaIndInfo
+S16 cmPkTfuDoaIndInfo
 (
 TfuDoaIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuDoaIndInfo(param, mBuf)
+S16 cmPkTfuDoaIndInfo(param, mBuf)
 TfuDoaIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuDoaRpt *tfuDoaRpt;
-   TRC3(cmPkTfuDoaIndInfo)
 
    count = param->doaRpt.count;
    node = param->doaRpt.last;
@@ -12886,23 +12652,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuDoaIndInfo
+S16 cmUnpkTfuDoaIndInfo
 (
 TfuDoaIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuDoaIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuDoaIndInfo(param, memCp, mBuf)
 TfuDoaIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuDoaRpt *tfuDoaRpt;
-   TRC3(cmUnpkTfuDoaIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    cmLListInit(&param->doaRpt);
@@ -12939,20 +12704,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSrsRpt
+S16 cmPkTfuSrsRpt
 (
 TfuSrsRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSrsRpt(param, mBuf)
+S16 cmPkTfuSrsRpt(param, mBuf)
 TfuSrsRpt *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuSrsRpt)
 
    CMCHKPK(oduUnpackUInt8, param->wideCqi, mBuf);
    CMCHKPK(oduUnpackUInt8, param->wideCqiPres, mBuf);
@@ -12987,20 +12751,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrsRpt
+S16 cmUnpkTfuSrsRpt
 (
 TfuSrsRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSrsRpt(param, mBuf)
+S16 cmUnpkTfuSrsRpt(param, mBuf)
 TfuSrsRpt *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuSrsRpt)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->dopEst, mBuf);
@@ -13037,23 +12800,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuSrsIndInfo
+S16 cmPkTfuSrsIndInfo
 (
 TfuSrsIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuSrsIndInfo(param, mBuf)
+S16 cmPkTfuSrsIndInfo(param, mBuf)
 TfuSrsIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    CmLList *node;
-   U32 count;
+   uint32_t count;
    TfuSrsRpt *tfuSrsRpt;
 
-   TRC3(cmPkTfuSrsIndInfo)
 
    count = param->srsRpt.count;
    node = param->srsRpt.last;
@@ -13092,24 +12854,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuSrsIndInfo
+S16 cmUnpkTfuSrsIndInfo
 (
 TfuSrsIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuSrsIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuSrsIndInfo(param, memCp, mBuf)
 TfuSrsIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuSrsRpt *tfuSrsRpt;
 
-   TRC3(cmUnpkTfuSrsIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -13148,19 +12909,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiRpt
+S16 cmPkTfuRawCqiRpt
 (
 TfuRawCqiRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRawCqiRpt(param, mBuf)
+S16 cmPkTfuRawCqiRpt(param, mBuf)
 TfuRawCqiRpt *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuRawCqiRpt)
 #ifdef TFU_5GTF
    CMCHKPK(oduUnpackUInt32, param->uciPayload, mBuf);
 #else
@@ -13201,19 +12961,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRawCqiRpt
+S16 cmUnpkTfuRawCqiRpt
 (
 TfuRawCqiRpt *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRawCqiRpt(param, mBuf)
+S16 cmUnpkTfuRawCqiRpt(param, mBuf)
 TfuRawCqiRpt *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuRawCqiRpt)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->numBits, mBuf);
@@ -13252,23 +13011,22 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiIndInfo
+S16 cmPkTfuRawCqiIndInfo
 (
 TfuRawCqiIndInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuRawCqiIndInfo(param, mBuf)
+S16 cmPkTfuRawCqiIndInfo(param, mBuf)
 TfuRawCqiIndInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count;
+   uint32_t count;
    TfuRawCqiRpt *tfuRawCqiRpt;
    CmLList *node;
 
-   TRC3(cmPkTfuRawCqiIndInfo)
 
    count = param->rawCqiRpt.count;
    node = param->rawCqiRpt.last;
@@ -13306,24 +13064,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuRawCqiIndInfo
+S16 cmUnpkTfuRawCqiIndInfo
 (
 TfuRawCqiIndInfo *param,
 Ptr memCp,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuRawCqiIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuRawCqiIndInfo(param, memCp, mBuf)
 TfuRawCqiIndInfo *param;
 Ptr memCp;
 Buffer *mBuf;
 #endif
 {
 
-   U32 count, loopCnt;
+   uint32_t count, loopCnt;
    TfuRawCqiRpt *tfuRawCqiRpt;
 
-   TRC3(cmUnpkTfuRawCqiIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -13361,20 +13118,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo
+S16 cmPkTfuUePucchHqRecpInfo
 (
 TfuUePucchHqRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
 TfuUePucchHqRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmPkTfuUePucchHqRecpInfo)
 
    CMCHKPK(oduUnpackUInt8, param->a, mBuf);
    for (i=TFU_MAX_HQ_RES-1; i >= 0; i--) {
@@ -13405,22 +13161,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo
+S16 cmUnpkTfuUePucchHqRecpInfo
 (
 TfuUePucchHqRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
 TfuUePucchHqRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
    S32 i;
-   TRC3(cmUnpkTfuUePucchHqRecpInfo)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->hqFdbkMode, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->hqFdbkMode, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->hqSz, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->pucchResCnt, mBuf);
    for (i=0; i<TFU_MAX_HQ_RES; i++) {
@@ -13457,19 +13212,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo
+S16 cmPkTfuUePucchHqRecpInfo
 (
 TfuUePucchHqRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
 TfuUePucchHqRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePucchHqRecpInfo)
 #ifdef LTE_ADV
    S32 idx;
    for (idx=(TFU_MAX_HQ_RES-1); idx >= 0; idx--) {
@@ -13504,20 +13258,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo
+S16 cmUnpkTfuUePucchHqRecpInfo
 (
 TfuUePucchHqRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
 TfuUePucchHqRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
-   TRC3(cmUnpkTfuUePucchHqRecpInfo)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->hqFdbkMode, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->hqFdbkMode, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->hqSz, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->pucchResCnt, mBuf);
 #ifdef LTE_ADV
@@ -13555,19 +13308,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchSrRecpInfo
+S16 cmPkTfuUePucchSrRecpInfo
 (
 TfuUePucchSrRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchSrRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchSrRecpInfo(param, mBuf)
 TfuUePucchSrRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePucchSrRecpInfo)
 
    CMCHKPK(oduUnpackUInt16, param->n1PucchIdx, mBuf);
    return ROK;
@@ -13592,19 +13344,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchSrRecpInfo
+S16 cmUnpkTfuUePucchSrRecpInfo
 (
 TfuUePucchSrRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchSrRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchSrRecpInfo(param, mBuf)
 TfuUePucchSrRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePucchSrRecpInfo)
 
    CMCHKUNPK(oduPackUInt16, &param->n1PucchIdx, mBuf);
    return ROK;
@@ -13629,19 +13380,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchCqiRecpInfo
+S16 cmPkTfuUePucchCqiRecpInfo
 (
 TfuUePucchCqiRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchCqiRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchCqiRecpInfo(param, mBuf)
 TfuUePucchCqiRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePucchCqiRecpInfo)
 
    CMCHKPK(oduUnpackUInt8, param->cqiPmiSz, mBuf);
    CMCHKPK(oduUnpackUInt16, param->n2PucchIdx, mBuf);
@@ -13667,19 +13417,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchCqiRecpInfo
+S16 cmUnpkTfuUePucchCqiRecpInfo
 (
 TfuUePucchCqiRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchCqiRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchCqiRecpInfo(param, mBuf)
 TfuUePucchCqiRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePucchCqiRecpInfo)
 
    CMCHKUNPK(oduPackUInt16, &param->n2PucchIdx, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->cqiPmiSz, mBuf);
@@ -13705,19 +13454,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchSrsRecpInfo
+S16 cmPkTfuUePucchSrsRecpInfo
 (
 TfuUePucchSrsRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchSrsRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchSrsRecpInfo(param, mBuf)
 TfuUePucchSrsRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePucchSrsRecpInfo)
 
    CMCHKPK(oduUnpackUInt32, param->srsCyclicShft, mBuf);
    CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
@@ -13730,19 +13478,18 @@ Buffer *mBuf;
 
 #ifdef TFU_5GTF
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchUciRecpInfo
+S16 cmPkTfuUePucchUciRecpInfo
 (
 TfuUePucchUciRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchUciRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchUciRecpInfo(param, mBuf)
 TfuUePucchUciRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePucchUciRecpInfo)
 
    CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
    CMCHKPK(oduUnpackUInt8, param->pucchIndex, mBuf);
@@ -13769,26 +13516,25 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo
+S16 cmUnpkTfuUePucchSrsRecpInfo
 (
 TfuUePucchSrsRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
 TfuUePucchSrsRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePucchSrsRecpInfo)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->srsBw, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->srsBw, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->nRrc, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->srsHopBw, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->srsHopBw, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->transComb, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->srsCfgIdx, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->srsCyclicShft, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->srsCyclicShft, mBuf);
    return ROK;
 }
 
@@ -13810,19 +13556,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchBsiBriRecpInfo
+S16 cmPkTfuUePucchBsiBriRecpInfo
 (
 TfuUePucchBsiBriRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchBsiBriRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchBsiBriRecpInfo(param, mBuf)
 TfuUePucchBsiBriRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePucchBsiBriRecpInfo)
 
    CMCHKPK(oduUnpackUInt8, param->briRpt, mBuf);
    CMCHKPK(oduUnpackUInt8, param->bsiRpt, mBuf);
@@ -13849,19 +13594,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchBsiBriRecpInfo
+S16 cmUnpkTfuUePucchBsiBriRecpInfo
 (
 TfuUePucchBsiBriRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchBsiBriRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchBsiBriRecpInfo(param, mBuf)
 TfuUePucchBsiBriRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePucchBsiBriRecpInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->puschFlag, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->pucchIndex, mBuf);
@@ -13874,19 +13618,18 @@ Buffer *mBuf;
 
 #ifdef TFU_5GTF
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo
+S16 cmUnpkTfuUePucchUciRecpInfo
 (
 TfuUePucchUciRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
 TfuUePucchUciRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePucchUciRecpInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->numBits, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->pucchIndex, mBuf);
@@ -13925,19 +13668,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchRecpReq
+S16 cmPkTfuUePucchRecpReq
 (
 TfuUePucchRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchRecpReq(param, mBuf)
+S16 cmPkTfuUePucchRecpReq(param, mBuf)
 TfuUePucchRecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePucchRecpReq)
 
 #ifdef TFU_5GTF
    CMCHKPK(cmPkTfuUePucchBsiBriRecpInfo, &param->bsiBriInfo, mBuf);
@@ -13981,21 +13723,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchRecpReq
+S16 cmUnpkTfuUePucchRecpReq
 (
 TfuUePucchRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
+S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
 TfuUePucchRecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePucchRecpReq)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->uciInfo, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->uciInfo, mBuf);
    CMCHKUNPK(cmUnpkTfuUePucchCqiRecpInfo, &param->cqiInfo, mBuf);
    CMCHKUNPK(cmUnpkTfuUePucchSrRecpInfo, &param->srInfo, mBuf);
    CMCHKUNPK(cmUnpkTfuUePucchHqRecpInfo, &param->hqInfo, mBuf);
@@ -14026,19 +13767,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUeUlSchRecpInfo
+S16 cmPkTfuUeUlSchRecpInfo
 (
 TfuUeUlSchRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUeUlSchRecpInfo(param, mBuf)
+S16 cmPkTfuUeUlSchRecpInfo(param, mBuf)
 TfuUeUlSchRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUeUlSchRecpInfo)
 #ifdef TFU_5GTF
    CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
    CMCHKPK(oduUnpackUInt8, param->uciWoTBFlag, mBuf);
@@ -14087,24 +13827,23 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeUlSchRecpInfo
+S16 cmUnpkTfuUeUlSchRecpInfo
 (
 TfuUeUlSchRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUeUlSchRecpInfo(param, mBuf)
+S16 cmUnpkTfuUeUlSchRecpInfo(param, mBuf)
 TfuUeUlSchRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUeUlSchRecpInfo)
 
    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rbStart, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->numRb, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->modType, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->modType, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->nDmrs, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->hoppingEnbld, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->hoppingBits, mBuf);
@@ -14148,26 +13887,25 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschCqiRecpInfo
+S16 cmPkTfuUePuschCqiRecpInfo
 (
 TfuUePuschCqiRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePuschCqiRecpInfo(param, mBuf)
+S16 cmPkTfuUePuschCqiRecpInfo(param, mBuf)
 TfuUePuschCqiRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   U32 idx = 0;
-   TRC3(cmPkTfuUePuschCqiRecpInfo)
+   uint32_t idx = 0;
 
    CMCHKPK(oduUnpackUInt8, param->riBetaOff, mBuf);
    CMCHKPK(oduUnpackUInt8, param->cqiBetaOff, mBuf);
    for (idx = 0; idx < param->cCNum; idx++)
    {
-      CMCHKPK(cmPkTknU8, &param->riSz[idx], mBuf);
+      CMCHKPK(cmPkTknUInt8, &param->riSz[idx], mBuf);
       CMCHKPK(oduUnpackUInt8, param->cqiPmiSzRn1[idx], mBuf);
       CMCHKPK(oduUnpackUInt8, param->cqiPmiSzR1[idx], mBuf);
    }
@@ -14195,20 +13933,19 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschCqiRecpInfo
+S16 cmUnpkTfuUePuschCqiRecpInfo
 (
 TfuUePuschCqiRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePuschCqiRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePuschCqiRecpInfo(param, mBuf)
 TfuUePuschCqiRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   U32 idx;
-   TRC3(cmUnpkTfuUePuschCqiRecpInfo)
+   uint32_t idx;
 
    CMCHKUNPK(oduPackUInt8, &param->reportType, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->cCNum, mBuf);
@@ -14216,7 +13953,7 @@ Buffer *mBuf;
    {
       CMCHKUNPK(oduPackUInt8, &param->cqiPmiSzR1[idx-1], mBuf);
       CMCHKUNPK(oduPackUInt8, &param->cqiPmiSzRn1[idx-1], mBuf);
-      CMCHKUNPK(cmUnpkTknU8, &param->riSz[idx-1], mBuf);
+      CMCHKUNPK(cmUnpkTknUInt8, &param->riSz[idx-1], mBuf);
    }
    CMCHKUNPK(oduPackUInt8, &param->cqiBetaOff, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->riBetaOff, mBuf);
@@ -14242,19 +13979,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschHqRecpInfo
+S16 cmPkTfuUePuschHqRecpInfo
 (
 TfuUePuschHqRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePuschHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePuschHqRecpInfo(param, mBuf)
 TfuUePuschHqRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePuschHqRecpInfo)
 
 
 #ifdef TFU_TDD
@@ -14286,25 +14022,24 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschHqRecpInfo
+S16 cmUnpkTfuUePuschHqRecpInfo
 (
 TfuUePuschHqRecpInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePuschHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePuschHqRecpInfo(param, mBuf)
 TfuUePuschHqRecpInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePuschHqRecpInfo)
 
    CMCHKUNPK(oduPackUInt8, &param->hqSz, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->hqBetaOff, mBuf);
 
 #ifdef TFU_TDD
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->hqFdbkMode, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->hqFdbkMode, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->nBundled, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->ulDai, mBuf);
 #endif
@@ -14338,22 +14073,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschRecpReq
+S16 cmPkTfuUePuschRecpReq
 (
 TfuUePuschRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePuschRecpReq(param, mBuf)
+S16 cmPkTfuUePuschRecpReq(param, mBuf)
 TfuUePuschRecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePuschRecpReq)
 
-   CMCHKPK(cmPkTknU8, &param->initialNumRbs, mBuf);
-   CMCHKPK(cmPkTknU8, &param->initialNSrs, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->initialNumRbs, mBuf);
+   CMCHKPK(cmPkTknUInt8, &param->initialNSrs, mBuf);
    CMCHKPK(cmPkTfuUePucchSrsRecpInfo, &param->srsInfo, mBuf);
    CMCHKPK(cmPkTfuUePuschHqRecpInfo, &param->hqInfo, mBuf);
    CMCHKPK(cmPkTfuUePuschCqiRecpInfo, &param->cqiRiInfo, mBuf);
@@ -14389,27 +14123,26 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschRecpReq
+S16 cmUnpkTfuUePuschRecpReq
 (
 TfuUePuschRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
+S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
 TfuUePuschRecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePuschRecpReq)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->rcpInfo, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->rcpInfo, mBuf);
    CMCHKUNPK(cmUnpkTfuUeUlSchRecpInfo, &param->ulSchInfo, mBuf);
    CMCHKUNPK(cmUnpkTfuUePuschCqiRecpInfo, &param->cqiRiInfo, mBuf);
    CMCHKUNPK(cmUnpkTfuUePuschHqRecpInfo, &param->hqInfo, mBuf);
    CMCHKUNPK(cmUnpkTfuUePucchSrsRecpInfo, &param->srsInfo, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->initialNSrs, mBuf);
-   CMCHKUNPK(cmUnpkTknU8, &param->initialNumRbs, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->initialNSrs, mBuf);
+   CMCHKUNPK(cmUnpkTknUInt8, &param->initialNumRbs, mBuf);
    return ROK;
 }
 
@@ -14433,19 +14166,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUeRecpReqInfo
+S16 cmPkTfuUeRecpReqInfo
 (
 TfuUeRecpReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUeRecpReqInfo(param, mBuf)
+S16 cmPkTfuUeRecpReqInfo(param, mBuf)
 TfuUeRecpReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUeRecpReqInfo)
 
       switch(param->type) {
          case TFU_RECP_REQ_PUSCH:
@@ -14485,25 +14217,24 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo
+S16 cmUnpkTfuUeRecpReqInfo
 (
 TfuUeRecpReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
+S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
 TfuUeRecpReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUeRecpReqInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
 #ifdef TFU_5GTF
    CMCHKUNPK(oduPackUInt8, &param->groupId, mBuf);
 #endif /* TFU_5GTF */
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
       switch(param->type) {
          case TFU_RECP_REQ_PUCCH:
             CMCHKUNPK(cmUnpkTfuUePucchRecpReq, &param->t.pucchRecpReq, mBuf);
@@ -14540,13 +14271,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchRecpReq
+S16 cmPkTfuUePucchRecpReq
 (
 TfuUePucchRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePucchRecpReq(param, mBuf)
+S16 cmPkTfuUePucchRecpReq(param, mBuf)
 TfuUePucchRecpReq *param;
 Buffer *mBuf;
 #endif
@@ -14555,7 +14286,6 @@ Buffer *mBuf;
 #ifdef TFU_TDD
    S32 i;
 #endif
-   TRC3(cmPkTfuUePucchRecpReq)
 
 
 #ifdef TFU_TDD
@@ -14621,13 +14351,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchRecpReq
+S16 cmUnpkTfuUePucchRecpReq
 (
 TfuUePucchRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
+S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
 TfuUePucchRecpReq *param;
 Buffer *mBuf;
 #endif
@@ -14636,9 +14366,8 @@ Buffer *mBuf;
 #ifdef TFU_TDD
    S32 i;
 #endif
-   TRC3(cmUnpkTfuUePucchRecpReq)
 
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->hqType, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->hqType, mBuf);
       switch(param->hqType) {
    
 #ifndef TFU_TDD
@@ -14662,7 +14391,7 @@ Buffer *mBuf;
          default :
             return RFAILED;
       }
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
 
 #ifdef TFU_TDD
    CMCHKUNPK(oduPackUInt8, &param->multCnt, mBuf);
@@ -14697,19 +14426,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUeMsg3RecpReq
+S16 cmPkTfuUeMsg3RecpReq
 (
 TfuUeMsg3RecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUeMsg3RecpReq(param, mBuf)
+S16 cmPkTfuUeMsg3RecpReq(param, mBuf)
 TfuUeMsg3RecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUeMsg3RecpReq)
 
    CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
@@ -14747,19 +14475,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeMsg3RecpReq
+S16 cmUnpkTfuUeMsg3RecpReq
 (
 TfuUeMsg3RecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUeMsg3RecpReq(param, mBuf)
+S16 cmUnpkTfuUeMsg3RecpReq(param, mBuf)
 TfuUeMsg3RecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUeMsg3RecpReq)
 
    CMCHKUNPK(oduPackUInt8, &param->hoppingEnbld, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->rbStart, mBuf);
@@ -14774,7 +14501,7 @@ Buffer *mBuf;
    CMCHKUNPK(oduPackUInt8, &param->rv, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->nDmrs, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->modType, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->modType, mBuf);
    return ROK;
 }
 
@@ -14800,19 +14527,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschRecpReq
+S16 cmPkTfuUePuschRecpReq
 (
 TfuUePuschRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUePuschRecpReq(param, mBuf)
+S16 cmPkTfuUePuschRecpReq(param, mBuf)
 TfuUePuschRecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUePuschRecpReq)
 
    CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
@@ -14854,19 +14580,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschRecpReq
+S16 cmUnpkTfuUePuschRecpReq
 (
 TfuUePuschRecpReq *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
+S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
 TfuUePuschRecpReq *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUePuschRecpReq)
 
    CMCHKUNPK(oduPackUInt8, &param->hoppingEnbld, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->hoppingBits, mBuf);
@@ -14880,9 +14605,9 @@ Buffer *mBuf;
    CMCHKUNPK(oduPackUInt8, &param->nDmrs, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->expCqi, mBuf);
    CMCHKUNPK(oduPackUInt8, &param->expHarq, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->mode, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->mode, mBuf);
    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->modType, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->modType, mBuf);
    return ROK;
 }
 
@@ -14906,19 +14631,18 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuUeRecpReqInfo
+S16 cmPkTfuUeRecpReqInfo
 (
 TfuUeRecpReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkTfuUeRecpReqInfo(param, mBuf)
+S16 cmPkTfuUeRecpReqInfo(param, mBuf)
 TfuUeRecpReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuUeRecpReqInfo)
 
       switch(param->type) {
          case TFU_RECP_REQ_PUSCH:
@@ -14958,22 +14682,21 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo
+S16 cmUnpkTfuUeRecpReqInfo
 (
 TfuUeRecpReqInfo *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
+S16 cmUnpkTfuUeRecpReqInfo(param, mBuf)
 TfuUeRecpReqInfo *param;
 Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuUeRecpReqInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
-   CMCHKUNPK(oduPackUInt32, (U32 *)&param->type, mBuf);
+   CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->type, mBuf);
       switch(param->type) {
          case TFU_RECP_REQ_PUCCH:
             CMCHKUNPK(cmUnpkTfuUePucchRecpReq, &param->t.pucchRecpReq, mBuf);
@@ -15023,7 +14746,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmPkTfuErrIndInfo)
 
    CMCHKPK(cmPkLteTimingInfo, &param->timingInfo, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
@@ -15058,7 +14780,6 @@ Buffer *mBuf;
 #endif
 {
 
-   TRC3(cmUnpkTfuErrIndInfo)
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timingInfo, mBuf);
@@ -15092,21 +14813,20 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkTfuErrInd
+S16 cmPkTfuErrInd
 (
 Pst * pst,
 SuId suId,
 TfuErrIndInfo * errInd
 )
 #else
-PUBLIC S16 cmPkTfuErrInd(pst, suId, errInd)
+S16 cmPkTfuErrInd(pst, suId, errInd)
 Pst * pst;
 SuId suId;
 TfuErrIndInfo * errInd;
 #endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(cmPkTfuErrInd)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -15197,14 +14917,14 @@ TfuErrIndInfo * errInd;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkTfuErrInd
+S16 cmUnpkTfuErrInd
 (
 TfuErrInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkTfuErrInd(func, pst, mBuf)
+S16 cmUnpkTfuErrInd(func, pst, mBuf)
 TfuErrInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -15213,7 +14933,6 @@ Buffer *mBuf;
    SuId suId;
    TfuErrIndInfo *errInd;
    
-   TRC3(cmUnpkTfuErrInd)
 
    if (SUnpkS16(&suId, mBuf) != ROK) {
       TFU_FREE_MSG(mBuf);