*
**********************************************************/
#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)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU001, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU002, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU003, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
SpId spId;
- TRC3(cmUnpkTfuBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU004, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU005, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
*
**********************************************************/
#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)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU006, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU007, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU008, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU009, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU010, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
*
**********************************************************/
#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)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU011, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU012, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU013, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
Reason reason;
- TRC3(cmUnpkTfuUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU014, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU015, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
*
**********************************************************/
#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)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU016, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU017, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU018, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUSCHBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
SpId spId;
- TRC3(cmUnpkTfuSchBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU019, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU020, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
*
**********************************************************/
#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)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU021, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU022, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU023, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUSCHBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU024, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU025, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
*
**********************************************************/
#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)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU026, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU027, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU028, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUSCHUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
Reason reason;
- TRC3(cmUnpkTfuSchUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU029, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU030, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU031, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(raReqInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuRaReqIndInfo(raReqInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)raReqInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)raReqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(raReqInd);
}
pst->event = (Event) EVTTFURAREQIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuRaReqIndInfo *raReqInd;
- TRC3(cmUnpkTfuRaReqInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU034, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU035, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU036, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&raReqInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&raReqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, raReqInd));
+ return ((*func)(pst, suId, raReqInd));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU037, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(recpReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuRecpReqInfo(recpReq, mBuf) != ROK) {
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)recpReq, mBuf) != ROK)
+ if (oduPackPointer((PTR)recpReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(recpReq);
}
pst->event = (Event) EVTTFURECPREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
TfuRecpReqInfo *recpReq;
- TRC3(cmUnpkTfuRecpReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU040, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU041, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&recpReq, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&recpReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU042, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR*)&recpReq, mBuf) != ROK)
+ if (oduUnpackPointer((PTR*)&recpReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, recpReq));
+ return ((*func)(pst, spId, recpReq));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU043, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(ulCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuUlCqiIndInfo(ulCqiInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)ulCqiInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)ulCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(ulCqiInd);
}
pst->event = (Event) EVTTFUULCQIIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuUlCqiIndInfo *ulCqiInd;
- TRC3(cmUnpkTfuUlCqiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU046, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU047, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU048, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&ulCqiInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&ulCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, ulCqiInd));
+ return ((*func)(pst, suId, ulCqiInd));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU049, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(hqInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuHqIndInfo(hqInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)hqInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)hqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(hqInd);
}
pst->event = (Event) EVTTFUHQIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
TfuHqIndInfo *hqInd;
- TRC3(cmUnpkTfuHqInd)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU052, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU053, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU054, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&hqInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&hqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, hqInd));
+ return ((*func)(pst, spId, hqInd));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU055, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(srInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuSrIndInfo(srInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)srInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)srInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(srInd);
}
pst->event = (Event) EVTTFUSRIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
TfuSrIndInfo *srInd;
- TRC3(cmUnpkTfuSrInd)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU058, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU059, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU060, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&srInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&srInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, srInd));
+ return ((*func)(pst, spId, srInd));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU061, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(dlCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuDlCqiIndInfo(dlCqiInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)dlCqiInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)dlCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(dlCqiInd);
}
pst->event = (Event) EVTTFUDLCQIIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuDlCqiIndInfo *dlCqiInd;
- TRC3(cmUnpkTfuDlCqiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU064, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU065, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU066, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&dlCqiInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&dlCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, dlCqiInd));
+ return ((*func)(pst, suId, dlCqiInd));
}
*
**********************************************************/
#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)
(ErrVal)ETFU067, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(rawCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkTfuRawCqiIndInfo(rawCqiInd, mBuf);
if (SPkS16(suId, mBuf) != ROK) {
#endif
TFU_FREE_MEM(rawCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MEM(rawCqiInd);
pst->event = (Event) EVTTFURAWCQIIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuRawCqiIndInfo *rawCqiInd;
- TRC3(cmUnpkTfuRawCqiInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU069, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
Mem sMem;
(ErrVal)ETFU070, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cmUnpkTfuRawCqiIndInfo(rawCqiInd, (Ptr)&rawCqiInd->memCp, mBuf);
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, rawCqiInd));
+ return ((*func)(pst, suId, rawCqiInd));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU071, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(srsInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkTfuSrsIndInfo(srsInd, mBuf);
if (SPkS16(suId, mBuf) != ROK) {
#endif
TFU_FREE_MEM(srsInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MEM(srsInd);
pst->event = (Event) EVTTFUSRSIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuSrsIndInfo *srsInd;
- TRC3(cmUnpkTfuSrsInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU073, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
Mem sMem;
(ErrVal)ETFU074, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cmUnpkTfuSrsIndInfo(srsInd, (Ptr)&srsInd->memCp, mBuf);
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, srsInd));
+ return ((*func)(pst, suId, srsInd));
}
#endif
*
**********************************************************/
#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)
(ErrVal)ETFU075, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(datInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuDatIndInfo(datInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmPkPtr((PTR)datInd, mBuf) != ROK)
+ if(oduPackPointer((PTR)datInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(datInd);
}
pst->event = (Event) EVTTFUDATIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
TfuDatIndInfo *datInd;
- TRC3(cmUnpkTfuDatInd)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU078, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU079, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU080, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmUnpkPtr((PTR *)&datInd, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&datInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, datInd));
+ return ((*func)(pst, spId, datInd));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU081, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(crcIndInfo);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuCrcIndInfo(crcIndInfo, mBuf) != ROK) {
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)crcIndInfo, mBuf) != ROK)
+ if (oduPackPointer((PTR)crcIndInfo, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(crcIndInfo);
}
pst->event = (Event) EVTTFUCRCIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuCrcIndInfo *crcIndInfo;
- TRC3(cmUnpkTfuCrcInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU084, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU085, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU086, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&crcIndInfo, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&crcIndInfo, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, crcIndInfo));
+ return ((*func)(pst, suId, crcIndInfo));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU087, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(timingAdvInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuTimingAdvIndInfo(timingAdvInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)timingAdvInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)timingAdvInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(timingAdvInd);
}
pst->event = (Event) EVTTFUTIMINGADVIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuTimingAdvIndInfo *timingAdvInd;
- TRC3(cmUnpkTfuTimingAdvInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU090, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU091, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU092, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&timingAdvInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&timingAdvInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, timingAdvInd));
+ return ((*func)(pst, suId, timingAdvInd));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU093, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(datReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuDatReqInfo(datReq, mBuf) != ROK) {
#endif
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmPkPtr((PTR)datReq, mBuf) != ROK)
+ if(oduPackPointer((PTR)datReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(datReq);
}
pst->event = (Event) EVTTFUDATREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
TfuDatReqInfo *datReq;
- TRC3(cmUnpkTfuDatReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU096, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU097, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU098, (ErrVal)0, "Unpacking failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmUnpkPtr((PTR *)&datReq, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&datReq, mBuf) != ROK)
{
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFUXXX, (ErrVal)0, "LWLC Un-Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, datReq));
+ return ((*func)(pst, spId, datReq));
}
\f
*
**********************************************************/
#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)
(ErrVal)ETFU099, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(cntrlReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuCntrlReqInfo(cntrlReq, mBuf) != ROK) {
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)cntrlReq, mBuf) != ROK)
+ if (oduPackPointer((PTR)cntrlReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(cntrlReq);
}
pst->event = (Event) EVTTFUCNTRLREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SpId spId;
TfuCntrlReqInfo *cntrlReq;
- TRC3(cmUnpkTfuCntrlReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU102, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU103, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU104, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&cntrlReq, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&cntrlReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, cntrlReq));
+ return ((*func)(pst, spId, cntrlReq));
}
*
**********************************************************/
#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)
(ErrVal)ETFU105, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuTtiIndInfo(ttiInd, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)ttiInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)ttiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
/*MS_FIX:71858:Changed to SPutSBuf as being allocated with SGetSBuf*/
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo)) != ROK) {
(ErrVal)ETFU108, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
//pst->event = (Event) EVENT_SLOT_IND_TO_MAC;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#if defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
*
**********************************************************/
#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)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU105, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU107, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUNONRTIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/***********************************************************
*
**********************************************************/
#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);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU109, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId));
+ return ((*func)(pst, suId));
}
#endif
*
**********************************************************/
#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)
(ErrVal)ETFU119, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)pucchDeltaPwr, sizeof(TfuPucchDeltaPwrIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuPucchDeltaPwrIndInfo(pucchDeltaPwr, mBuf) != ROK) {
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)pucchDeltaPwr, mBuf) != ROK)
+ if (oduPackPointer((PTR)pucchDeltaPwr, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(pucchDeltaPwr);
}
pst->event = (Event) EVTTFUPUCCHDELPWR;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
- TRC3(cmUnpkTfuPucchDeltaPwr)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU122, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU123, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU124, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&pucchDeltaPwr, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&pucchDeltaPwr, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, pucchDeltaPwr));
+ return ((*func)(pst, suId, pucchDeltaPwr));
}
#ifdef TFU_5GTF
*
**********************************************************/
#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(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->hqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
#ifdef UL_ADPT_DBG
printf("cmPkTfuRbAssignA1Val324 param->ndi %d mcs %d param->hqProcId %d \n",param->ndi,param->mcs,param->hqProcId);
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#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(SPkU8, param->bmiHqAckNack, mBuf);
- CMCHKPK(SPkU8, param->RV, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->hqProcId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->bmiHqAckNack, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->RV, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
+ return ROK;
}
\f
*
**********************************************************/
#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(SPkU8, param->CyclicShiftInd, mBuf);
- CMCHKPK(SPkU8, param->OCCInd, mBuf);
- CMCHKPK(SPkU8, param->FreqBandIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->CyclicShiftInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->OCCInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->FreqBandIdx, mBuf);
+ return ROK;
}
\f
*
**********************************************************/
#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(SUnpkU8, ¶m->hqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ return ROK;
}
\f
*
**********************************************************/
#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(SUnpkU8, ¶m->hqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->RV, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bmiHqAckNack, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->RV, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bmiHqAckNack, mBuf);
+ return ROK;
}
\f
*
**********************************************************/
#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(SUnpkU8, ¶m->FreqBandIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->OCCInd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CyclicShiftInd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->FreqBandIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->OCCInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CyclicShiftInd, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->UL_PCRS, mBuf);
- CMCHKPK(SPkU8, param->PMI, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
-
- CMCHKPK(SPkU8, param->REMapIdx_DMRS_PCRS_numLayers, mBuf);
- CMCHKPK(SPkU8, param->SRS_Symbol, mBuf);
- CMCHKPK(SPkU8, param->SRS_Config, mBuf);
- CMCHKPK(SPkU8, param->beamSwitch, mBuf);
- CMCHKPK(SPkU8, param->uciOnxPUSCH, mBuf);
-
- CMCHKPK(SPkU8, param->numBSI_Reports, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKPK(SPkU8, param->CSI_BRRS_Indicator, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->CSI_BSI_BRI_Req, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->UL_PCRS, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->PMI, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+
+ CMCHKPK(oduUnpackUInt8, param->REMapIdx_DMRS_PCRS_numLayers, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Symbol, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Config, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamSwitch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->uciOnxPUSCH, mBuf);
+
+ CMCHKPK(oduUnpackUInt8, param->numBSI_Reports, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BRRS_Indicator, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BSI_BRI_Req, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKPK(cmPkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->symbIdx, mBuf);
- CMCHKPK(SPkU8, param->beamIndex, mBuf);
- CMCHKPK(SPkU16, param->RBAssign, mBuf);
- CMCHKPK(SPkU8, param->xPUSCH_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->xPUSCHRange, mBuf);
- CMCHKPK(SPkU8, param->formatType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->symbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->RBAssign, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUSCH_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUSCHRange, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->formatType, mBuf);
+ return ROK;
}
\f
*
**********************************************************/
#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(SPkU8, param->DL_PCRS, mBuf);
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->DL_PCRS, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->AntPorts_numLayers, mBuf);
- CMCHKPK(SPkU8, param->SRS_Symbol, mBuf);
- CMCHKPK(SPkU8, param->SRS_Config, mBuf);
- CMCHKPK(SPkU8, param->beamSwitch, mBuf);
- CMCHKPK(SPkU8, param->freqResIdx_xPUCCH, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->AntPorts_numLayers, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Symbol, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Config, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamSwitch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->freqResIdx_xPUCCH, mBuf);
- CMCHKPK(SPkU8, param->xPUCCH_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUCCH_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->numBSI_Reports, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKPK(SPkU8, param->CSI_BRRS_Indicator, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->CSI_BSI_BRI_Req, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBSI_Reports, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BRRS_Indicator, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BSI_BRI_Req, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKPK(cmPkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKPK(SPkU8, param->symbIdx, mBuf);
- CMCHKPK(SPkU8, param->beamIndex, mBuf);
- CMCHKPK(SPkU16, param->RBAssign, mBuf);
- CMCHKPK(SPkU8, param->xPDSCHRange, mBuf);
- CMCHKPK(SPkU8, param->formatType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->symbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->RBAssign, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPDSCHRange, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->formatType, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->formatType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUSCHRange, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUSCH_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->RBAssign, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->symbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUSCHRange, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUSCH_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->RBAssign, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->symbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKUNPK(cmUnpkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BSI_BRI_Req, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BRRS_Indicator, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBSI_Reports, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BSI_BRI_Req, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BRRS_Indicator, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBSI_Reports, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->uciOnxPUSCH, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamSwitch, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Config, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Symbol, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->REMapIdx_DMRS_PCRS_numLayers, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->uciOnxPUSCH, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamSwitch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Config, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Symbol, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->REMapIdx_DMRS_PCRS_numLayers, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->PMI, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->UL_PCRS, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->PMI, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->UL_PCRS, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#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(SUnpkU8, ¶m->formatType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPDSCHRange, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->RBAssign, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->symbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPDSCHRange, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->RBAssign, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->symbIdx, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKUNPK(cmUnpkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BSI_BRI_Req, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BRRS_Indicator, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBSI_Reports, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BSI_BRI_Req, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BRRS_Indicator, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBSI_Reports, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUCCH_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->freqResIdx_xPUCCH, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamSwitch, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Config, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Symbol, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->AntPorts_numLayers, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->DL_PCRS, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUCCH_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->freqResIdx_xPUCCH, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamSwitch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Config, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Symbol, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->AntPorts_numLayers, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->DL_PCRS, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->hqProcId, mBuf);
- CMCHKPK(SPkU8, param->txAntenna, mBuf);
- CMCHKPK(SPkU8, param->numCqiBit, mBuf);
- CMCHKPK(SPkU8, param->cqiReq, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txAntenna, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCqiBit, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiReq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
- CMCHKPK(SPkU8, param->ulIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulIdx, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->hoppingBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingBits, mBuf);
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU32, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
#endif
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
#endif /* TFU_UPGRADE */
- CMCHKUNPK(SUnpkU8, ¶m->hoppingBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->ulIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiReq, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numCqiBit, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txAntenna, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiReq, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCqiBit, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txAntenna, mBuf);
/* tfu_c_001.main_3: Adding unpack for hqProcId */
- CMCHKUNPK(SUnpkU8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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 */
#ifndef TFU_RESMAP_CHANGE
case TFU_ALLOC_TYPE_MAP:
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->u.resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.resAllocMap[i], mBuf);
}
break;
#endif
case TFU_ALLOC_TYPE_RIV:
- CMCHKPK(SPkU32, param->u.riv, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->u.riv, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_ALLOC_TYPE_RIV:
- CMCHKUNPK(SUnpkU32, ¶m->u.riv, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->u.riv, mBuf);
break;
/*tfu_c_001.main_7 - ADD - TFU_RESMAP_CHANGE support */
#ifndef TFU_RESMAP_CHANGE
case TFU_ALLOC_TYPE_MAP:
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->u.resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.resAllocMap[i], mBuf);
}
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resAllocMap[i], mBuf);
}
- CMCHKPK(SPkU8, param->isAllocType0, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isAllocType0, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isAllocType0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resAllocMap[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ return ROK;
}
\f
*
**********************************************************/
#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(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1AllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->transSwap, mBuf);
- CMCHKPK(SPkU8, param->precoding, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->transSwap, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->precoding, mBuf);
for (i=1; i >= 0; i--) {
CMCHKPK(cmPkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resAllocMap[i], mBuf);
}
- CMCHKPK(SPkU8, param->isAllocType0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAllocType0, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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 */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->isAllocType0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resAllocMap[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
CMCHKUNPK(cmUnpkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->precoding, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->transSwap, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->precoding, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->transSwap, mBuf);
+ return ROK;
}
#ifdef EMTC_ENABLE
*
**********************************************************/
#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(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU32, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
printf("In cmUnpkTfuDciFormat6AAllocInfo :: Passed \n");
- RETVALUE(ROK);
+ return ROK;
}
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AInfo
+S16 cmPkTfuDciFormat2AInfo
(
TfuDciFormat2AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat2AInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AInfo(param, mBuf)
TfuDciFormat2AInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat2AInfo)
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat2AAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
*
**********************************************************/
#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 */
for (i=1; i >= 0; i--) {
CMCHKPK(cmPkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->precoding, mBuf);
- CMCHKPK(SPkU8, param->transSwap, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->precoding, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->transSwap, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resAllocMap[i], mBuf);
}
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKPK(SPkU8, param->isAllocType0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAllocType0, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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 */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->isAllocType0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resAllocMap[i], mBuf);
}
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->transSwap, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->precoding, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->transSwap, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->precoding, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
for (i=0; i<=1; i++) {
CMCHKUNPK(cmUnpkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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 */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
CMCHKPK(cmPkTfuDciFormat2AllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->allocInfo, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->isPucch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->tpcCmd[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->tpcCmd[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isPucch, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPucch, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->isPucch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->tpcCmd[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->tpcCmd[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isPucch, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPucch, mBuf);
+ return ROK;
}
#ifdef EMTC_ENABLE
#endif
{
- TRC3(cmPkTfuDciFormat60aInfo)
- CMCHKPK(SPkU8, param->dciRep, mBuf);
- CMCHKPK(SPkU8, param->isSrs, mBuf);
- CMCHKPK(SPkU8, param->cqiReq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiReq, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
- CMCHKPK(SPkU8, param->ulIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulIdx, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->hqProcId, mBuf);
- CMCHKPK(SPkU8, param->rep, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU32, param->riv, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
/***********************************************************
*
#endif
{
- TRC3(cmPkTfuPdcchOrderInfoEmtc)
- CMCHKPK(SPkU8, param->ceLevel, mBuf);
- CMCHKPK(SPkU8, param->prachMaskIdx, mBuf);
- CMCHKPK(SPkU8, param->preambleIdx, mBuf);
- CMCHKPK(SPkU32, param->riv, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->ceLevel, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->preambleIdx, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
+ return ROK;
}
/***********************************************************
#endif
{
- TRC3(cmPkTfudciformat61aPdsch)
- CMCHKPK(SPkU8, param->isTBMsg4, mBuf);
- CMCHKPK(SPkU8, param->dciRep, mBuf);
- CMCHKPK(SPkU8, param->harqAckOffst, mBuf);
- CMCHKPK(SPkU8, param->pmiCfm, mBuf);
- CMCHKPK(SPkU8, param->tPmi, mBuf);
- CMCHKPK(SPkU8, param->isSrs, mBuf);
- CMCHKPK(SPkU8, param->antPortAndScrId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isTBMsg4, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqAckOffst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmiCfm, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->antPortAndScrId, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->rep, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
CMCHKPK(cmPkTfuDciFormat6AAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuPdcchOrderInfoEmtc, ¶m->t.pdcchOrder, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isPdcchOrder, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPdcchOrder, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
#endif
{
- TRC3(cmUnpkTfuDciFormat60aInfo)
printf("In cmUnpkTfuDciFormat60aInfo :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rep, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->ulIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->cqiReq, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isSrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciRep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiReq, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciRep, mBuf);
printf("In cmUnpkTfuDciFormat60aInfo :: Exit \n");
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
#endif
{
- TRC3(cmUnpkTfuPdcchOrderInfoEmtc)
printf("In cmUnpkTfuPdcchOrderInfoEmtc :: Entry \n");
- CMCHKUNPK(SUnpkU32, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->preambleIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachMaskIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ceLevel, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->preambleIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachMaskIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevel, mBuf);
printf("In cmUnpkTfuPdcchOrderInfoEmtc :: Passed \n");
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#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(SUnpkU8, ¶m->isPdcchOrder, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
printf("1. cmUnpkTfuDciFormat61aInfo :: isPdcchOrder %d \n", param->isPdcchOrder);
switch(param->isPdcchOrder) {
case TRUE:
CMCHKUNPK(cmUnpkTfudciformat61aPdsch, ¶m->t.pdschInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
*
**********************************************************/
#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(SPkU8, param->tPmi, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- CMCHKPK(SPkU8, param->isLocal, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tPmi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tPmi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->dlPwrOffset, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlPwrOffset, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
CMCHKPK(cmPkTfuDciFormat1dAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->allocInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->dlPwrOffset, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlPwrOffset, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->iTbs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->iTbs, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->iTbs, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->pmiCfm, mBuf);
- CMCHKPK(SPkU8, param->tPmi, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmiCfm, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- CMCHKPK(SPkU8, param->isLocal, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tPmi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pmiCfm, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tPmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmiCfm, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->prachMaskIdx, mBuf);
- CMCHKPK(SPkU8, param->preambleIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->preambleIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->preambleIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachMaskIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->preambleIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachMaskIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->ndi, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- CMCHKPK(SPkU8, param->isLocal, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(cmPkTknU8, ¶m->dai, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1aAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(cmUnpkTknU8, ¶m->dai, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
#ifdef EMTC_ENABLE
*
**********************************************************/
#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, ¶m->allocInfo, mBuf);
printf("2. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
printf("3. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->rep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rep, mBuf);
printf("4. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
printf("5. cmUnpkTfudciformat61aPdsch :: Entry \n");
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
printf("6. cmUnpkTfudciformat61aPdsch :: Entry \n");
#endif
- CMCHKUNPK(SUnpkU8, ¶m->antPortAndScrId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->antPortAndScrId, mBuf);
printf("7. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->isSrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSrs, mBuf);
printf("8. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->tPmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tPmi, mBuf);
printf("9. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->pmiCfm, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmiCfm, mBuf);
printf("10. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->harqAckOffst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqAckOffst, mBuf);
printf("11. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->dciRep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciRep, mBuf);
printf("12. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->isTBMsg4, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isTBMsg4, mBuf);
printf("1. cmUnpkTfudciformat61aPdsch :: Passed \n");
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
#endif
{
- TRC3(cmUnpkTfuDirectIndication)
- CMCHKUNPK(SUnpkU8, ¶m->directInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->directInd, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
*
**********************************************************/
#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(SUnpkU8, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
#endif
{
- TRC3(cmUnpkTfudciformat62Pdsch)
-
CMCHKUNPK(cmUnpkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->repNum, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciSubRepNum, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->repNum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciSubRepNum, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isPaging, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPaging, mBuf);
switch(param->isPaging) {
case FALSE:
CMCHKUNPK(cmUnpkTfuDirectIndication, ¶m->t.directIndication, mBuf);
CMCHKUNPK(cmUnpkTfudciformat62Pdsch, ¶m->t.pdschInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
- TRC3(cmPkTfuDirectIndication)
- CMCHKPK(SPkU8, param->directInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->directInd, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->riv, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
- TRC3(cmPkTfudciformat62Pdsch)
- CMCHKPK(SPkU8, param->dciSubRepNum, mBuf);
- CMCHKPK(SPkU8, param->repNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciSubRepNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->repNum, mBuf);
CMCHKPK(cmPkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->t.pdschInfo, mBuf);
CMCHKPK(cmPkTfuDirectIndication, ¶m->t.directIndication, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isPaging, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPaging, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuPdcchOrderInfo, ¶m->t.pdcchOrder, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isPdcchOrder, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPdcchOrder, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isPdcchOrder, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
switch(param->isPdcchOrder) {
case TRUE:
CMCHKUNPK(cmUnpkTfuPdcchOrderInfo, ¶m->t.pdcchOrder, mBuf);
CMCHKUNPK(cmUnpkTfudciformat1aPdsch, ¶m->t.pdschInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1bAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
*
**********************************************************/
#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
CMCHKPK(cmPkTfuDciFormat0Info, ¶m->u.format0Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->dciFormat, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->dciFormat, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->dciFormat, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->dciFormat, mBuf);
switch(param->dciFormat) {
case TFU_DCI_FORMAT_0:
CMCHKUNPK(cmUnpkTfuDciFormat0Info, ¶m->u.format0Info, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->cqiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subband, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subband, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->cceIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cceIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cceIdx, mBuf);
- CMCHKUNPK(cmUnpkLteAggrLvl,(U32 *)¶m->aggrLvl, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cceIdx, mBuf);
+ CMCHKUNPK(cmUnpkLteAggrLvl,(uint32_t *)¶m->aggrLvl, mBuf);
+ return ROK;
}
*
**********************************************************/
#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:
- CMCHKPK(SPkU8, param->u.cqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
- CMCHKUNPK(SUnpkU8, ¶m->u.cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->wideDiffCqi, mBuf);
- CMCHKPK(SPkU8, param->pmi, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(cmPkTknUInt8, ¶m->wideDiffCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->wideDiffCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->wideDiffCqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiMode11Cqi, ¶m->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
CMCHKUNPK(cmUnpkTfuCqiMode11Cqi, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->l, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->l, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->l, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiMode20SubCqi, ¶m->u.subCqi, mBuf);
break;
case TRUE:
- CMCHKPK(SPkU8, param->u.wideCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.wideCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isWideband, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isWideband, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isWideband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
case TRUE:
- CMCHKUNPK(SUnpkU8, ¶m->u.wideCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.wideCqi, mBuf);
break;
case FALSE:
CMCHKUNPK(cmUnpkTfuCqiMode20SubCqi, ¶m->u.subCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiMode20Cqi, ¶m->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
CMCHKUNPK(cmUnpkTfuCqiMode20Cqi, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->diffCqi, mBuf);
- CMCHKPK(SPkU8, param->l, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(cmPkTknUInt8, ¶m->diffCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->l, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->l, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->diffCqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->diffCqi, mBuf);
- CMCHKPK(SPkU8, param->pmi, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(cmPkTknUInt8, ¶m->diffCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->diffCqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiMode21WideCqi, ¶m->u.wideCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isWideband, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isWideband, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->isWideband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
case TRUE:
CMCHKUNPK(cmUnpkTfuCqiMode21WideCqi, ¶m->u.wideCqi, mBuf);
CMCHKUNPK(cmUnpkTfuCqiMode21SubCqi, ¶m->u.subCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiMode21Cqi, ¶m->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
CMCHKUNPK(cmUnpkTfuCqiMode21Cqi, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiPucchMode10, ¶m->u.mode10Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->mode, mBuf);
- CMCHKPK(SPkU8, param->cellIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
switch(param->mode) {
case TFU_PUCCH_CQI_MODE10:
CMCHKUNPK(cmUnpkTfuCqiPucchMode10, ¶m->u.mode10Info, mBuf);
CMCHKUNPK(cmUnpkTfuCqiPucchMode21, ¶m->u.mode21Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subBand, mBuf);
- CMCHKPK(SPkU8, param->pmi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subbandArr[i], mBuf);
}
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqiIdx[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx[i], mBuf);
}
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandMode12, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subbandArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideBandCqi, mBuf);
- CMCHKPK(SPkU8, param->cqiIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cqiIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->wideBandCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#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--) {
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideBandPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandPmi, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->wideBandCqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi[i], mBuf);
}
- CMCHKPK(SPkU8, param->pmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->wideBandCqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->wideBandPmi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandPmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#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, ¶m->subBand, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
#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(SUnpkU8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subbandArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideBandCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->wideBandCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandMode30, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#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, ¶m->subBand, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#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(SUnpkU8, ¶m->cqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
}
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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 */
CMCHKPK(cmPkTfuSubbandDlCqiInfo, ¶m->subbandCqiArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->wideBandCqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi[i], mBuf);
}
- CMCHKPK(SPkU8, param->pmi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->wideBandCqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(cmPkTknU8, ¶m->ri, mBuf);
- CMCHKPK(SPkU32, param->mode, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->ri, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
- CMCHKPK(SPkU8, param->cellIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cellIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->mode, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->ri, mBuf);
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_12:
CMCHKUNPK(cmUnpkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
CMCHKUNPK(cmUnpkTfuCqiPuschMode31, ¶m->u.mode31Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#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:
{
CMCHKPK(cmPkTfuDlCqiPusch, ¶m->pusch.puschCqi[idx], mBuf);
}
- CMCHKPK(SPkU8, param->pusch.numOfCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pusch.numOfCells, mBuf);
break;
case TRUE:
CMCHKPK(cmPkTfuDlCqiPucch, ¶m->pucchCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKUNPK(cmUnpkTfuDlCqiPucch, ¶m->pucchCqi, mBuf);
break;
case FALSE:
- CMCHKUNPK(SUnpkU8, ¶m->pusch.numOfCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pusch.numOfCells, mBuf);
for (idx = param->pusch.numOfCells; idx > 0; idx--)
{
CMCHKUNPK(cmUnpkTfuDlCqiPusch, ¶m->pusch.puschCqi[idx-1], mBuf);
}
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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 */
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU8, param->srsPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsPres, mBuf);
#endif
count = param->ueRecpReqLst.count;
node = param->ueRecpReqLst.last;
cmLListDelFrm(¶m->ueRecpReqLst, &tfuUeRecpReqInfo->lnk);
tfuUeRecpReqInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->ueRecpReqLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuUeRecpReqInfo), (Ptr *)&tfuUeRecpReqInfo);
CMCHKUNPK(cmUnpkTfuUeRecpReqInfo, tfuUeRecpReqInfo, mBuf);
/*ccpu00116923 - ADD - SRS present support*/
/*tfu_c_001.main_7 - ADD - SRS present field inclusion */
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU8, ¶m->srsPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsPres, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->grpId, mBuf);
- CMCHKPK(SPkU8, param->sccIdx, mBuf);
- CMCHKPK(SPkU8, param->sectorId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sectorId, mBuf);
#endif /* TFU_5GTF */
CMCHKPK(cmPkTfuDciInfo, ¶m->dci, mBuf);
- CMCHKPK(SPkU8, param->dciNumOfBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciNumOfBits, mBuf);
CMCHKPK(cmPkLteAggrLvl, param->aggrLvl, mBuf);
- CMCHKPK(SPkU16, param->nCce, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nCce, mBuf);
#ifdef LTEMAC_SPS
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
- CMCHKPK(SPkU8, param->isSpsRnti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSpsRnti, mBuf);
#endif
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
#ifdef LTEMAC_SPS
- CMCHKUNPK(SUnpkU8, ¶m->isSpsRnti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSpsRnti, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
- CMCHKUNPK(SUnpkU16, ¶m->nCce, mBuf);
- CMCHKUNPK(cmUnpkLteAggrLvl, (U32*)¶m->aggrLvl, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciNumOfBits, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->nCce, mBuf);
+ CMCHKUNPK(cmUnpkLteAggrLvl, (uint32_t*)¶m->aggrLvl, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciNumOfBits, mBuf);
CMCHKUNPK(cmUnpkTfuDciInfo, ¶m->dci, mBuf);
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->sectorId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sccIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->grpId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sectorId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sccIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->grpId, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU16, param->txPower, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txPower, mBuf);
#endif
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->iPhich, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->iPhich, mBuf);
#endif
- CMCHKPK(SPkU8, param->isAck, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAck, mBuf);
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->iPhich, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->iPhich, mBuf);
#endif
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU16, ¶m->txPower, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txPower, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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
TfuPdcchInfo *tfuPdcchInfo;
TfuPhichInfo *tfuPhichInfo;
CmLList *node;
- U32 count;
+ uint32_t count;
- TRC3(cmPkTfuCntrlReqInfo)
#ifdef EMTC_ENABLE
count = param->dlMpdcchLst.count;
node = param->dlMpdcchLst.last;
cmLListDelFrm(¶m->dlMpdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
count = param->ulMpdcchLst.count;
node = param->ulMpdcchLst.last;
while (node) {
cmLListDelFrm(¶m->ulMpdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
#endif
#ifdef LTEMAC_SPS /* SPS_NEW_CHGS */
- CMCHKPK(cmPkBool, param->isSPSOcc, mBuf);
+ CMCHKPK(oduPackBool, param->isSPSOcc, mBuf);
#endif
count = param->phichLst.count;
node = param->phichLst.last;
cmLListDelFrm(¶m->phichLst, &tfuPhichInfo->lnk);
tfuPhichInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
count = param->dlPdcchLst.count;
node = param->dlPdcchLst.last;
while (node) {
cmLListDelFrm(¶m->dlPdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
count = param->ulPdcchLst.count;
node = param->ulPdcchLst.last;
while (node) {
cmLListDelFrm(¶m->ulPdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
- CMCHKPK(SPkU8, param->cfi, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->dlTiming, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->ulTiming, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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;
{
TfuPdcchInfo *tfuPdcchInfo;
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuPhichInfo *tfuPhichInfo;
- TRC3(cmUnpkTfuCntrlReqInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->ulTiming, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->dlTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cfi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfi, mBuf);
cmLListInit(¶m->ulPdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
CMCHKUNPK(cmUnpkTfuPdcchInfo, tfuPdcchInfo, mBuf);
tfuPdcchInfo->lnk.node = (PTR)tfuPdcchInfo;
}
cmLListInit(¶m->dlPdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
CMCHKUNPK(cmUnpkTfuPdcchInfo, tfuPdcchInfo, mBuf);
tfuPdcchInfo->lnk.node = (PTR)tfuPdcchInfo;
}
cmLListInit(¶m->phichLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPhichInfo), (Ptr *)&tfuPhichInfo);
CMCHKUNPK(cmUnpkTfuPhichInfo, tfuPhichInfo, mBuf);
}
#ifdef LTEMAC_SPS /* SPS_NEW_CHGS */
- CMCHKUNPK(cmUnpkBool, ¶m->isSPSOcc, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->isSPSOcc, mBuf);
#endif
#ifdef EMTC_ENABLE
cmLListInit(¶m->ulMpdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
CMCHKUNPK(cmUnpkTfuPdcchInfo, tfuPdcchInfo, mBuf);
tfuPdcchInfo->lnk.node = (PTR)tfuPdcchInfo;
}
cmLListInit(¶m->dlMpdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
printf("4. cmUnpkTfuCntrlReqInfo :: count %ld \n", count);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
printf("5. cmUnpkTfuCntrlReqInfo :: Failed \n");
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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
CMCHKPK(cmPkTfuDciFormat1AllocInfo, ¶m->u.format1AllocInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->format, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->format, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->format, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->format, mBuf);
switch(param->format) {
case TFU_DCI_FORMAT_1:
CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, ¶m->u.format1AllocInfo, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
*
**********************************************************/
#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--) {
- CMCHKPK(SPkU16, param->bfValue[idx2], mBuf);}
- CMCHKPK(SPkU8, param->numPhyAnt, mBuf);
- CMCHKPK(SPkU8, param->sbIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->bfValue[idx2], mBuf);}
+ CMCHKPK(oduUnpackUInt8, param->numPhyAnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sbIndex, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#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(SUnpkU8, ¶m->sbIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numPhyAnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sbIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numPhyAnt, mBuf);
for (idx2=0; idx2 <param->numPhyAnt; idx2++) {
- CMCHKUNPK(SUnpkU16, ¶m->bfValue[idx2], mBuf);}
+ CMCHKUNPK(oduPackUInt16, ¶m->bfValue[idx2], mBuf);}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
*
**********************************************************/
#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(SPkU8, param->isEnbSFR, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isEnbSFR, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU16, param->txPwrOffset, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txPwrOffset, mBuf);
if(param->transMode == TFU_UE_TM_7)
{
CMCHKPK(cmPkTfuBfVectorInfo, param->bfVector, mBuf);
- CMCHKPK(SPkU8, param->numBfVectors, mBuf);
- CMCHKPK(SPkU8, param->numBfPrbPerSb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBfVectors, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBfPrbPerSb, mBuf);
}
- CMCHKPK(SPkU8, param->deltaPowOffIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->deltaPowOffIdx, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKPK(SPkU8, param->pa, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pa, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKPK(SPkU8, param->numLayers, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numLayers, mBuf);
#endif
- CMCHKPK(cmPkBool, param->isTApres, mBuf);
- CMCHKPK(cmPkTknU32, ¶m->doa, mBuf);
- CMCHKPK(SPkU32, param->transMode, mBuf);
+ CMCHKPK(oduPackBool, param->isTApres, mBuf);
+ CMCHKPK(cmPkTknUInt32, ¶m->doa, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->transMode, mBuf);
CMCHKPK(cmPkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
- CMCHKPK(SPkU8, param->puschRptUsd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschRptUsd, mBuf);
for (i = 0; i < TFU_MAX_TB; i++)
{
#ifndef L2_OPTMZ
mBuf);
}
- CMCHKPK(SPkU32, param->tbInfo[i].lchInfo[lchIdx].numPdu, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbInfo[i].lchInfo[lchIdx].numPdu, mBuf);
}
- CMCHKPK(SPkU32, param->tbInfo[i].numLch, mBuf);
- CMCHKPK(SPkU32, param->tbInfo[i].padSize, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbInfo[i].numLch, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbInfo[i].padSize, mBuf);
CMCHKPK(cmPkBuffer, ¶m->tbInfo[i].macCes, mBuf);
CMCHKPK(cmPkBuffer, ¶m->tbInfo[i].macHdr, mBuf);
CMCHKPK(cmPkMsgLen, param->tbInfo[i].tbSize, mBuf);
- CMCHKPK(cmPkBool, param->tbInfo[i].tbPres, mBuf);
+ CMCHKPK(oduPackBool, param->tbInfo[i].tbPres, mBuf);
#endif
}
- CMCHKPK(SPkU8, tbMask, mBuf);
- CMCHKPK(SPkU8, param->nmbOfTBs, mBuf);
+ CMCHKPK(oduUnpackUInt8, tbMask, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nmbOfTBs, mBuf);
CMCHKPK(cmPkTfuPdschDciInfo, ¶m->dciInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkTfuPdschDciInfo, ¶m->dciInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nmbOfTBs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbOfTBs, mBuf);
- CMCHKUNPK(SUnpkU8, &tbMask, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tbMask, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
#ifndef L2_OPTMZ
if (tbMask & (1<<i))
param->mBuf[i] = NULLP;
}
#else /* L2_OPTMZ*/
- CMCHKUNPK(cmUnpkBool, ¶m->tbInfo[i].tbPres, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->tbInfo[i].tbPres, mBuf);
CMCHKUNPK(cmUnpkMsgLen, ¶m->tbInfo[i].tbSize, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macHdr, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macCes, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->tbInfo[i].padSize, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->tbInfo[i].numLch, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->tbInfo[i].padSize, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->tbInfo[i].numLch, mBuf);
for(lchIdx = 0; lchIdx < param->tbInfo[i].numLch; lchIdx++)
{
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->tbInfo[i].lchInfo[lchIdx].numPdu,
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->tbInfo[i].lchInfo[lchIdx].numPdu,
mBuf);
for(pduIdx = 0; pduIdx < param->tbInfo[i].lchInfo[lchIdx].numPdu;
pduIdx++)
#endif /* L2_OPTMZ*/
}
- CMCHKUNPK(SUnpkU8, ¶m->puschRptUsd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschRptUsd, mBuf);
CMCHKUNPK(cmUnpkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->transMode, mBuf);
- CMCHKUNPK(cmUnpkTknU32, ¶m->doa, mBuf);
- CMCHKUNPK(cmUnpkBool, ¶m->isTApres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->transMode, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32, ¶m->doa, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->isTApres, mBuf);
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU8, ¶m->numLayers, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numLayers, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKUNPK(SUnpkU8, ¶m->pa, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pa, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKUNPK(SUnpkU8, ¶m->deltaPowOffIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->deltaPowOffIdx, mBuf);
if(param->transMode == TFU_UE_TM_7)
{
- CMCHKUNPK(SUnpkU8, ¶m->numBfPrbPerSb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBfVectors, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBfPrbPerSb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBfVectors, mBuf);
CMCHKUNPK(cmUnpkTfuBfVectorInfo, param->bfVector, mBuf);
}
- CMCHKUNPK(SUnpkU16, ¶m->txPwrOffset, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txPwrOffset, mBuf);
#endif
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKUNPK(SUnpkU8, ¶m->isEnbSFR, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isEnbSFR, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->pdus, &tfuDatReqPduInfo->lnk);
tfuDatReqPduInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkTknBuf, ¶m->bchDat, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKUNPK(cmUnpkTknBuf, ¶m->bchDat, &mBuf);
cmLListInit(¶m->pdus);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDatReqPduInfo), (Ptr *)&tfuDatReqPduInfo);
CMCHKUNPK(cmUnpkTfuDatReqPduInfo, tfuDatReqPduInfo, mBuf);
cmLListAdd2Tail(¶m->pdus, &tfuDatReqPduInfo->lnk);
tfuDatReqPduInfo->lnk.node = (PTR)tfuDatReqPduInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->mBuf, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->mBuf, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->sccIdx, mBuf);
- CMCHKPK(SPkU8, param->sectorId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sectorId, mBuf);
#endif /* TFU_5GTF */
count = param->datIndLst.count;
node = param->datIndLst.last;
cmLListDelFrm(¶m->datIndLst, &tfuDatInfo->lnk);
tfuDatInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->datIndLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDatInfo), (Ptr *)&tfuDatInfo);
CMCHKUNPK(cmUnpkTfuDatInfo, tfuDatInfo, mBuf);
tfuDatInfo->lnk.node = (PTR)tfuDatInfo;
}
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->sectorId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sccIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sectorId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sccIdx, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->srLst, &tfuSrInfo->lnk);
tfuSrInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->srLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuSrInfo), (Ptr *)&tfuSrInfo);
CMCHKUNPK(cmUnpkTfuSrInfo, tfuSrInfo, mBuf);
cmLListAdd2Tail(¶m->srLst, &tfuSrInfo->lnk);
tfuSrInfo->lnk.node = (PTR)tfuSrInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
*
**********************************************************/
#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(SPkU8, param->isPusch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPusch, mBuf);
for (i=TFU_MAX_HARQ_FDBKS-1; i >= 0; i--) {
- CMCHKPK(SPkU32, param->isAck[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->isAck[i], mBuf);
}
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->M, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->M, mBuf);
#endif/*TFU_TDD*/
- CMCHKPK(SPkU8, param->noOfTbs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->noOfTbs, mBuf);
/* ACC-TDD ccpu00130520 */
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
*
**********************************************************/
#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, ¶m->rnti, mBuf);
/* ACC-TDD ccpu00130520 */
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->noOfTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->noOfTbs, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->M, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->M, mBuf);
#endif
for (i=0; i<TFU_MAX_HARQ_FDBKS; i++) {
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->isAck[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->isAck[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isPusch, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPusch, mBuf);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->hqIndLst, &tfuHqInfo->lnk);
tfuHqInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->hqIndLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuHqInfo), (Ptr *)&tfuHqInfo);
CMCHKUNPK(cmUnpkTfuHqInfo, tfuHqInfo, mBuf);
cmLListAdd2Tail(¶m->hqIndLst, &tfuHqInfo->lnk);
tfuHqInfo->lnk.node = (PTR)tfuHqInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subbandCqi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subbandCqi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->ulCqiInfoArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideCqi, mBuf);
- CMCHKPK(SPkU8, param->isTxPort0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isTxPort0, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isTxPort0, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->wideCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isTxPort0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_UL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuUlCqiInfo, ¶m->ulCqiInfoArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->ulCqiRpt, &tfuUlCqiRpt->lnk);
tfuUlCqiRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->ulCqiRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuUlCqiRpt), (Ptr *)&tfuUlCqiRpt);
CMCHKUNPK(cmUnpkTfuUlCqiRpt, tfuUlCqiRpt, mBuf);
cmLListAdd2Tail(¶m->ulCqiRpt, &tfuUlCqiRpt->lnk);
tfuUlCqiRpt->lnk.node = (PTR)tfuUlCqiRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->dlCqiInfo, mBuf) != ROK)
- RETVALUE(RFAILED);
- CMCHKPK(SPkU8, param->isPucchInfo, mBuf);
+ return RFAILED;
+ CMCHKPK(oduUnpackUInt8, param->isPucchInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isPucchInfo, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPucchInfo, mBuf);
if (cmUnpkTfuDlCqiInfo (param->isPucchInfo, ¶m->dlCqiInfo, mBuf) != ROK)
- RETVALUE(RFAILED);
- RETVALUE(ROK);
+ return RFAILED;
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->dlCqiRptsLst, &tfuDlCqiRpt->lnk);
tfuDlCqiRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->dlCqiRptsLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDlCqiRpt), (Ptr *)&tfuDlCqiRpt);
CMCHKUNPK(cmUnpkTfuDlCqiRpt, tfuDlCqiRpt, mBuf);
cmLListAdd2Tail(¶m->dlCqiRptsLst, &tfuDlCqiRpt->lnk);
tfuDlCqiRpt->lnk.node = (PTR)tfuDlCqiRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rv, mBuf);
- CMCHKPK(SPkU8, param->isFailure, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isFailure, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isFailure, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->rv, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isFailure, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->rv, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->sccIdx, mBuf);
- CMCHKPK(SPkU8, param->sectorId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sectorId, mBuf);
#endif /* TFU_5GTF */
count = param->crcLst.count;
node = param->crcLst.last;
cmLListDelFrm(¶m->crcLst, &tfuCrcIndInfo->lnk);
tfuCrcIndInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->crcLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuCrcIndInfo), (Ptr *)&tfuCrcIndInfo);
CMCHKUNPK(cmUnpkTfuCrcInfo, tfuCrcIndInfo, mBuf);
tfuCrcIndInfo->lnk.node = (PTR)tfuCrcIndInfo;
}
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->sectorId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sccIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sectorId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sccIdx, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->timingAdv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->timingAdv, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->timingAdv, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->timingAdv, mBuf);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->timingAdvLst, &tfuTimingAdvInfo->lnk);
tfuTimingAdvInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->timingAdvLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuTimingAdvInfo), (Ptr *)&tfuTimingAdvInfo);
CMCHKUNPK(cmUnpkTfuTimingAdvInfo, tfuTimingAdvInfo, mBuf);
cmLListAdd2Tail(¶m->timingAdvLst, &tfuTimingAdvInfo->lnk);
tfuTimingAdvInfo->lnk.node = (PTR)tfuTimingAdvInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
/*CA dev Start*/
*
**********************************************************/
#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(SPkU8, param->ulBlankSf, mBuf);
- CMCHKPK(SPkU8, param->dlBlankSf, mBuf);
- CMCHKPK(SPkU8, param->schTickDelta, mBuf);
- CMCHKPK(cmPkBool, param->isDummyTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulBlankSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlBlankSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->schTickDelta, mBuf);
+ CMCHKPK(oduPackBool, param->isDummyTti, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*CA dev End*/
\f
*
**********************************************************/
#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--) {
CMCHKPK(cmPkTfuTtiCellInfo, ¶m->cells[i], mBuf);
}
- CMCHKPK(SPkU8, param->numCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
/*CA dev End*/
- RETVALUE(ROK);
+ return ROK;
}
/* CA dev Start */
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
- CMCHKUNPK(cmUnpkBool, ¶m->isDummyTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->schTickDelta, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dlBlankSf, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulBlankSf, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduUnpackBool, ¶m->isDummyTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->schTickDelta, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlBlankSf, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulBlankSf, mBuf);
+ return ROK;
}
/* CA dev End */
*
**********************************************************/
#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(SPkU8, param->cqiIdx, mBuf);
- CMCHKPK(SPkU8, param->cqiPres, mBuf);
- CMCHKPK(SPkU8, param->tpc, mBuf);
- CMCHKPK(SPkU16, param->ta, mBuf);
- CMCHKPK(SPkU8, param->rapId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpc, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ta, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rapId, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->rapId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->ta, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->rapId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->ta, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpc, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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;
{
S32 i;
- TRC3(cmPkTfuRachInfo)
for (i= (param->numRaReqInfo - 1); i >= 0; i--) {
CMCHKPK(cmPkTfuRaReqInfo, &(param->raReqInfoArr[i]), mBuf);
}
#ifdef PRACH_5GTF
- CMCHKPK(SPkU16, param->nPwrFactor, mBuf);
- CMCHKPK(SPkU8, param->nPRACHSymbIndex, mBuf);
- CMCHKPK(SPkU8, param->nf1Value, mBuf);
- CMCHKPK(SPkU8, param->nCyclicShift, mBuf);
- CMCHKPK(SPkU8, param->nRootSeq, mBuf);
- CMCHKPK(SPkU8, param->nPRACHConfiguration, mBuf);
- CMCHKPK(SPkU8, param->nPreambleFormat, mBuf);
-#endif
- CMCHKPK(SPkU8, param->numRaReqInfo, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nPwrFactor, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nPRACHSymbIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nf1Value, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nCyclicShift, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nRootSeq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nPRACHConfiguration, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nPreambleFormat, mBuf);
+#endif
+ CMCHKPK(oduUnpackUInt8, param->numRaReqInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->raRnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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;
{
S32 i;
- TRC3(cmUnpkTfuRachInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->raRnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRaReqInfo, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRaReqInfo, mBuf);
#ifdef PRACH_5GTF
- CMCHKUNPK(SPkU8, param->nPreambleFormat, mBuf);
- CMCHKUNPK(SPkU8, param->nPRACHConfiguration, mBuf);
- CMCHKUNPK(SPkU8, param->nRootSeq, mBuf);
- CMCHKUNPK(SPkU8, param->nCyclicShift, mBuf);
- CMCHKUNPK(SPkU8, param->nf1Value, mBuf);
- CMCHKUNPK(SPkU8, param->nPRACHSymbIndex, mBuf);
- CMCHKUNPK(SPkU16, param->nPwrFactor, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nPreambleFormat, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nPRACHConfiguration, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nRootSeq, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nCyclicShift, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nf1Value, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nPRACHSymbIndex, mBuf);
+ CMCHKUNPK(oduUnpackUInt16, param->nPwrFactor, mBuf);
#endif
if (cmGetMem (&(memCp), (sizeof(TfuRaReqInfo) * param->numRaReqInfo),
(Ptr *)¶m->raReqInfoArr) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (i=0; i<param->numRaReqInfo; i++) {
CMCHKUNPK(cmUnpkTfuRaReqInfo, ¶m->raReqInfoArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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--)
{
if (ROK != cmPkTfuRachInfo(param->memCp,
&(param->rachInfoArr[i]), mBuf))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- CMCHKPK(SPkU8, param->nmbOfRaRnti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nmbOfRaRnti, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nmbOfRaRnti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbOfRaRnti, mBuf);
if (cmGetMem (&(param->memCp), (sizeof(TfuRachInfo) * param->nmbOfRaRnti),
(Ptr *)¶m->rachInfoArr) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (i=0; i<param->nmbOfRaRnti; i++)
{
if (ROK != cmUnpkTfuRachInfo(param->memCp, ¶m->rachInfoArr[i], mBuf))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pucchDeltaPwr, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->pucchDeltaPwrLst, &tfuPucchDeltaPwr->lnk);
tfuPucchDeltaPwr->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->pucchDeltaPwrLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPucchDeltaPwr), (Ptr *)&tfuPucchDeltaPwr);
CMCHKUNPK(cmUnpkTfuPucchDeltaPwrInfo, tfuPucchDeltaPwr, mBuf);
cmLListAdd2Tail(¶m->pucchDeltaPwrLst, &tfuPucchDeltaPwr->lnk);
tfuPucchDeltaPwr->lnk.node = (PTR)tfuPucchDeltaPwr;
}
- RETVALUE(ROK);
+ return ROK;
}
#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)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SCatMsg(mBuf, *param, M1M2) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
TFU_FREE_MSG(*param);
*param = NULLP;
CMCHKPK(cmPkMsgLen, msgLen, mBuf);
- RETVALUE(ROK);
+ 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)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SSegMsg(mBuf, totalMsgLen-msgLen, param) != ROK)
- RETVALUE(RFAILED);
- RETVALUE(ROK);
+ return RFAILED;
+ return ROK;
}
*
**********************************************************/
#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)
(ErrVal)ETFU125, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)doaInd, sizeof(TfuDoaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkTfuDoaIndInfo(doaInd, mBuf);
if (SPkS16(suId, mBuf) != ROK) {
#endif
TFU_FREE_MEM(doaInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MEM(doaInd);
pst->event = (Event) EVTTFUDOAIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuDoaIndInfo *doaInd;
- TRC3(cmUnpkTfuDoaInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU127, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
Mem sMem;
(ErrVal)ETFU128, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cmUnpkTfuDoaIndInfo(doaInd, (Ptr)&doaInd->memCp, mBuf);
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, doaInd));
+ return ((*func)(pst, suId, doaInd));
}
*
**********************************************************/
#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(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->cqiIdx[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx[i], mBuf);
}
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subband, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->subband, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->mode, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_12:
CMCHKUNPK(cmUnpkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
CMCHKUNPK(cmUnpkTfuCqiPuschMode31, ¶m->u.mode31Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
*
**********************************************************/
#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(SPkU32, param->doa, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->doa, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->doa, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, ¶m->doa, mBuf);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->doaRpt, &tfuDoaRpt->lnk);
tfuDoaRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
cmLListInit(¶m->doaRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDoaRpt), (Ptr *)&tfuDoaRpt);
CMCHKUNPK(cmUnpkTfuDoaRpt, tfuDoaRpt, mBuf);
cmLListAdd2Tail(¶m->doaRpt, &tfuDoaRpt->lnk);
tfuDoaRpt->lnk.node = (PTR)tfuDoaRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->wideCqi, mBuf);
- CMCHKPK(SPkU8, param->wideCqiPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideCqiPres, mBuf);
for (i=TFU_MAX_UL_RB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->snr[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->snr[i], mBuf);
}
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->numRbs, mBuf);
- CMCHKPK(SPkU16, param->ta, mBuf);
- CMCHKPK(SPkU16, param->dopEst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRbs, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ta, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dopEst, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->ueId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dopEst, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->ta, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRbs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dopEst, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->ta, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRbs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
for (i=0; i<TFU_MAX_UL_RB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->snr[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->snr[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->wideCqiPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->wideCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideCqiPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideCqi, mBuf);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->srsRpt, &tfuSrsRpt->lnk);
tfuSrsRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->srsRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuSrsRpt), (Ptr *)&tfuSrsRpt);
CMCHKUNPK(cmUnpkTfuSrsRpt, tfuSrsRpt, mBuf);
cmLListAdd2Tail(¶m->srsRpt, &tfuSrsRpt->lnk);
tfuSrsRpt->lnk.node = (PTR)tfuSrsRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU32, param->uciPayload, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->uciPayload, mBuf);
#else
S32 i;
for (i=CM_LTE_MAX_CELLS-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->ri[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ri[i], mBuf);
}
for (i=TFU_MAX_CQI_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqiBits[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiBits[i], mBuf);
}
#endif
- CMCHKPK(SPkU8, param->numBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBits, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->crnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBits, mBuf);
#ifndef TFU_5GTF
S32 i;
for (i=0; i<TFU_MAX_CQI_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqiBits[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiBits[i], mBuf);
}
for (i=0; i<CM_LTE_MAX_CELLS; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->ri[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ri[i], mBuf);
}
#else
- CMCHKUNPK(SUnpkU32, ¶m->uciPayload, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->uciPayload, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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;
cmLListDelFrm(¶m->rawCqiRpt, &tfuRawCqiRpt->lnk);
tfuRawCqiRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->rawCqiRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuRawCqiRpt), (Ptr *)&tfuRawCqiRpt);
CMCHKUNPK(cmUnpkTfuRawCqiRpt, tfuRawCqiRpt, mBuf);
cmLListAdd2Tail(¶m->rawCqiRpt, &tfuRawCqiRpt->lnk);
tfuRawCqiRpt->lnk.node = (PTR)tfuRawCqiRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->a, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->a, mBuf);
for (i=TFU_MAX_HQ_RES-1; i >= 0; i--) {
- CMCHKPK(SPkU16, param->hqRes[i], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->hqRes[i], mBuf);
}
- CMCHKPK(SPkU8, param->pucchResCnt, mBuf);
- CMCHKPK(SPkU8, param->hqSz, mBuf);
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pucchResCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqSz, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqSz, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchResCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchResCnt, mBuf);
for (i=0; i<TFU_MAX_HQ_RES; i++) {
- CMCHKUNPK(SUnpkU16, ¶m->hqRes[i], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->hqRes[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->a, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->a, mBuf);
+ return ROK;
}
*
**********************************************************/
#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--) {
- CMCHKPK(SPkU16, param->hqRes[idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->hqRes[idx], mBuf);
}
#else
- CMCHKPK(SPkU16, param->hqRes[0], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->hqRes[0], mBuf);
#endif
- CMCHKPK(SPkU8, param->pucchResCnt, mBuf);
- CMCHKPK(SPkU8, param->hqSz, mBuf);
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchResCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqSz, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqSz, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchResCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchResCnt, mBuf);
#ifdef LTE_ADV
S32 idx;
for (idx=0; idx<TFU_MAX_HQ_RES; idx++) {
- CMCHKUNPK(SUnpkU16, ¶m->hqRes[idx], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->hqRes[idx], mBuf);
}
#else
- CMCHKUNPK(SUnpkU16, ¶m->hqRes[0], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->hqRes[0], mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU16, param->n1PucchIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->n1PucchIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU16, ¶m->n1PucchIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->n1PucchIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->cqiPmiSz, mBuf);
- CMCHKPK(SPkU16, param->n2PucchIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqiPmiSz, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->n2PucchIdx, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU16, ¶m->n2PucchIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiPmiSz, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->n2PucchIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSz, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU32, param->srsCyclicShft, mBuf);
- CMCHKPK(SPkU16, param->srsCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->transComb, mBuf);
- CMCHKPK(SPkU32, param->srsHopBw, mBuf);
- CMCHKPK(SPkU8, param->nRrc, mBuf);
- CMCHKPK(SPkU32, param->srsBw, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->srsCyclicShft, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->transComb, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsHopBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nRrc, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsBw, mBuf);
+ return ROK;
}
#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(SPkU8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->pucchIndex, mBuf);
- CMCHKPK(SPkU8, param->numBits, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBits, mBuf);
+ return ROK;
}
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo
+S16 cmUnpkTfuUePucchSrsRecpInfo
(
TfuUePucchSrsRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
TfuUePucchSrsRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchSrsRecpInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->srsBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nRrc, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->srsHopBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->transComb, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->srsCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->srsCyclicShft, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nRrc, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsHopBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->transComb, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsCyclicShft, mBuf);
+ return ROK;
}
#ifdef TFU_5GTF
*
**********************************************************/
#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(SPkU8, param->briRpt, mBuf);
- CMCHKPK(SPkU8, param->bsiRpt, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->pucchIndex, mBuf);
- CMCHKPK(SPkU8, param->puschFlag, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->briRpt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->bsiRpt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschFlag, mBuf);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#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(SUnpkU8, ¶m->puschFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bsiRpt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->briRpt, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bsiRpt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->briRpt, mBuf);
+ return ROK;
}
#endif
#ifdef TFU_5GTF
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo
+S16 cmUnpkTfuUePucchUciRecpInfo
(
TfuUePucchUciRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
TfuUePucchUciRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchUciRecpInfo)
- CMCHKUNPK(SUnpkU8, ¶m->numBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchRecpReq
+S16 cmPkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchRecpReq(param, mBuf)
+S16 cmPkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUePucchRecpReq)
#ifdef TFU_5GTF
CMCHKPK(cmPkTfuUePucchBsiBriRecpInfo, ¶m->bsiBriInfo, mBuf);
CMCHKPK(cmPkTfuUePucchHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKPK(cmPkTfuUePucchSrRecpInfo, ¶m->srInfo, mBuf);
CMCHKPK(cmPkTfuUePucchCqiRecpInfo, ¶m->cqiInfo, mBuf);
- CMCHKPK(SPkU32, param->uciInfo, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->uciInfo, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->uciInfo, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->uciInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchCqiRecpInfo, ¶m->cqiInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchSrRecpInfo, ¶m->srInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchUciRecpInfo, ¶m->uciPduInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchBsiBriRecpInfo, ¶m->bsiBriInfo, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->beamIndex, mBuf);
- CMCHKPK(SPkU8, param->uciWoTBFlag, mBuf);
- CMCHKPK(SPkU8, param->PMI, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->nAntPortLayer, mBuf);
- CMCHKPK(SPkU8, param->xPUSCHRange, mBuf);
- CMCHKPK(SPkU8, param->numRbg, mBuf);
- CMCHKPK(SPkU8, param->rbgStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->uciWoTBFlag, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->PMI, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nAntPortLayer, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUSCHRange, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRbg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbgStart, mBuf);
#endif
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->nSrs, mBuf);
- CMCHKPK(SPkU8, param->crntTxNb, mBuf);
- CMCHKPK(SPkU8, param->txMode, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->isRtx, mBuf);
- CMCHKPK(SPkU8, param->hoppingBits, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU32, param->modType, mBuf);
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nSrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->crntTxNb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isRtx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU16, ¶m->size, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->modType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hoppingBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isRtx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->crntTxNb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nSrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->modType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isRtx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->crntTxNb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nSrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->rbgStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRbg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUSCHRange, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nAntPortLayer, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->PMI, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->uciWoTBFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbgStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRbg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUSCHRange, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nAntPortLayer, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->PMI, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->uciWoTBFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamIndex, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU8, param->riBetaOff, mBuf);
- CMCHKPK(SPkU8, param->cqiBetaOff, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->riBetaOff, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiBetaOff, mBuf);
for (idx = 0; idx < param->cCNum; idx++)
{
- CMCHKPK(cmPkTknU8, ¶m->riSz[idx], mBuf);
- CMCHKPK(SPkU8, param->cqiPmiSzRn1[idx], mBuf);
- CMCHKPK(SPkU8, param->cqiPmiSzR1[idx], mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->riSz[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPmiSzRn1[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPmiSzR1[idx], mBuf);
}
- CMCHKPK(SPkU8, param->cCNum, mBuf);
- CMCHKPK(SPkU8, param->reportType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cCNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportType, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->reportType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cCNum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->reportType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cCNum, mBuf);
for (idx = param->cCNum; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU8, ¶m->cqiPmiSzR1[idx-1], mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiPmiSzRn1[idx-1], mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->riSz[idx-1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzR1[idx-1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzRn1[idx-1], mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->riSz[idx-1], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->cqiBetaOff, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->riBetaOff, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiBetaOff, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->riBetaOff, mBuf);
+ return ROK;
}
*
**********************************************************/
#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
- CMCHKPK(SPkU8, param->ulDai, mBuf);
- CMCHKPK(SPkU8, param->nBundled, mBuf);
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulDai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nBundled, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
#endif
- CMCHKPK(SPkU8, param->hqBetaOff, mBuf);
- CMCHKPK(SPkU8, param->hqSz, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->hqBetaOff, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqSz, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->hqSz, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqBetaOff, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqBetaOff, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nBundled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulDai, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nBundled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulDai, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->initialNumRbs, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->initialNSrs, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->initialNumRbs, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->initialNSrs, mBuf);
CMCHKPK(cmPkTfuUePucchSrsRecpInfo, ¶m->srsInfo, mBuf);
CMCHKPK(cmPkTfuUePuschHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKPK(cmPkTfuUePuschCqiRecpInfo, ¶m->cqiRiInfo, mBuf);
CMCHKPK(cmPkTfuUeUlSchRecpInfo, ¶m->ulSchInfo, mBuf);
- CMCHKPK(SPkU32, param->rcpInfo, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->rcpInfo, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU32, (U32 *)¶m->rcpInfo, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->rcpInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUeUlSchRecpInfo, ¶m->ulSchInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschCqiRecpInfo, ¶m->cqiRiInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchSrsRecpInfo, ¶m->srsInfo, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->initialNSrs, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->initialNumRbs, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->initialNSrs, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->initialNumRbs, mBuf);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
#ifdef TFU_5GTF
- CMCHKPK(SPkU8, param->groupId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->groupId, mBuf);
#endif /* TFU_5GTF */
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->groupId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->groupId, mBuf);
#endif /* TFU_5GTF */
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RECP_REQ_PUCCH:
CMCHKUNPK(cmUnpkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschRecpReq, ¶m->t.puschRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* TFU_UPGRADE */
#ifndef TFU_UPGRADE /* TFU_UPGRADE */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchRecpReq
+S16 cmPkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchRecpReq(param, mBuf)
+S16 cmPkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
#ifdef TFU_TDD
S32 i;
#endif
- TRC3(cmPkTfuUePucchRecpReq)
#ifdef TFU_TDD
for (i=TFU_MAX_M-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->p[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->p[i], mBuf);
}
for (i=TFU_MAX_M-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->m[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m[i], mBuf);
}
- CMCHKPK(SPkU8, param->M, mBuf);
- CMCHKPK(SPkU8, param->multCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->M, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->multCnt, mBuf);
#endif
- CMCHKPK(SPkU32, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
switch(param->hqType) {
case TFU_HQ_RECP_REQ_N1PUCCH:
- CMCHKPK(SPkU16, param->t.n1Pucch, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->t.n1Pucch, mBuf);
break;
#ifdef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
for (i=TFU_MAX_M-1; i >= 0; i--) {
- CMCHKPK(SPkU16, param->t.nCce[i], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->t.nCce[i], mBuf);
}
break;
#ifndef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
- CMCHKPK(SPkU16, param->t.nCce, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->t.nCce, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->hqType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->hqType, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchRecpReq
+S16 cmUnpkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
+S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
#ifdef TFU_TDD
S32 i;
#endif
- TRC3(cmUnpkTfuUePucchRecpReq)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqType, mBuf);
switch(param->hqType) {
#ifndef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
- CMCHKUNPK(SUnpkU16, ¶m->t.nCce, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t.nCce, mBuf);
break;
#endif
#ifdef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
for (i=0; i<TFU_MAX_M; i++) {
- CMCHKUNPK(SUnpkU16, ¶m->t.nCce[i], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t.nCce[i], mBuf);
}
break;
#endif
case TFU_HQ_RECP_REQ_N1PUCCH:
- CMCHKUNPK(SUnpkU16, ¶m->t.n1Pucch, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t.n1Pucch, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->multCnt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->M, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->multCnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->M, mBuf);
for (i=0; i<TFU_MAX_M; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->m[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->m[i], mBuf);
}
for (i=0; i<TFU_MAX_M; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->p[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->p[i], mBuf);
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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(SPkU32, param->modType, mBuf);
- CMCHKPK(SPkU16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
/*ccpu00128993 - ADD - fix for msg3 softcombining bug*/
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->isRtx, mBuf);
- CMCHKPK(SPkU8, param->ulDelay, mBuf);
- CMCHKPK(SPkU8, param->expCqi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isRtx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulDelay, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->expCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->expCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulDelay, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isRtx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->expCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulDelay, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isRtx, mBuf);
/*ccpu00128993 - ADD - fix for msg3 softcombining bug*/
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->modType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->modType, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SPkU32, param->modType, mBuf);
- CMCHKPK(SPkU16, param->size, mBuf);
- CMCHKPK(SPkU32, param->mode, mBuf);
- CMCHKPK(SPkU8, param->expHarq, mBuf);
- CMCHKPK(SPkU8, param->expCqi, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->isRtx, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->hoppingBits, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->expHarq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->expCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isRtx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
*
**********************************************************/
#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(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hoppingBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isRtx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->expCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->expHarq, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->mode, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->modType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isRtx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->expCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->expHarq, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->modType, mBuf);
+ return ROK;
}
*
**********************************************************/
#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:
CMCHKPK(cmPkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#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, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RECP_REQ_PUCCH:
CMCHKUNPK(cmUnpkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschRecpReq, ¶m->t.puschRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
- TRC3(cmPkTfuErrIndInfo)
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
#endif
{
- TRC3(cmUnpkTfuErrIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#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)
(ErrVal)ETFU105, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuErrIndInfo(errInd, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)errInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)errInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
/*MS_FIX:71858:Changed to SPutSBuf as being allocated with SGetSBuf*/
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo)) != ROK) {
(ErrVal)ETFU108, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTTFUERRIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
**********************************************************/
#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;
SuId suId;
TfuErrIndInfo *errInd;
- TRC3(cmUnpkTfuErrInd)
if (SUnpkS16(&suId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU109, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&errInd, sizeof(TfuErrIndInfo))) != ROK) {
(ErrVal)ETFU110, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU111, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&errInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&errInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
/* [ccpu00141698]-MOD- MAC/SCH does not free the TTI ind anymore */
(*func)(pst, suId, errInd);
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
- RETVALUE(ROK);
+ return ROK;
}
#endif /* if defined(LCTFU) */
Code Review / o-du / l2.git / blobdiff