*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignA1Val324
+S16 cmPkTfuRbAssignA1Val324
(
TfuRbAssignA1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRbAssignA1Val324(param, mBuf)
+S16 cmPkTfuRbAssignA1Val324(param, mBuf)
TfuRbAssignA1Val324 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuRbAssignA1Val324)
CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignB1Val324
+S16 cmPkTfuRbAssignB1Val324
(
TfuRbAssignB1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRbAssignB1Val324(param, mBuf)
+S16 cmPkTfuRbAssignB1Val324(param, mBuf)
TfuRbAssignB1Val324 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuRbAssignB1Val324)
CMCHKPK(oduUnpackUInt8, param->bmiHqAckNack, mBuf);
CMCHKPK(oduUnpackUInt8, param->RV, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRbAssignVal326
+S16 cmPkTfuRbAssignVal326
(
TfuRbAssignVal326 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRbAssignVal326(param, mBuf)
+S16 cmPkTfuRbAssignVal326(param, mBuf)
TfuRbAssignVal326 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuRbAssignVal326)
CMCHKPK(oduUnpackUInt8, param->CyclicShiftInd, mBuf);
CMCHKPK(oduUnpackUInt8, param->OCCInd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignA1Val324
+S16 cmUnpkTfuRbAssignA1Val324
(
TfuRbAssignA1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRbAssignA1Val324(param, mBuf)
+S16 cmUnpkTfuRbAssignA1Val324(param, mBuf)
TfuRbAssignA1Val324 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuRbAssignA1Val324)
CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignB1Val324
+S16 cmUnpkTfuRbAssignB1Val324
(
TfuRbAssignB1Val324 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRbAssignB1Val324(param, mBuf)
+S16 cmUnpkTfuRbAssignB1Val324(param, mBuf)
TfuRbAssignB1Val324 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuRbAssignB1Val324)
CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRbAssignVal326
+S16 cmUnpkTfuRbAssignVal326
(
TfuRbAssignVal326 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRbAssignVal326(param, mBuf)
+S16 cmUnpkTfuRbAssignVal326(param, mBuf)
TfuRbAssignVal326 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuRbAssignVal326)
CMCHKUNPK(oduPackUInt8, ¶m->FreqBandIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->OCCInd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatA1A2Info
+S16 cmPkTfuDciFormatA1A2Info
(
TfuDciFormatA1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormatA1A2Info(param, mBuf)
+S16 cmPkTfuDciFormatA1A2Info(param, mBuf)
TfuDciFormatA1Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormatA1A2Info)
//printf("5GTF_DBG: cmPkTfuDciFormatA1Info() called by eNB\n");
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatB1B2Info
+S16 cmPkTfuDciFormatB1B2Info
(
TfuDciFormatB1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormatB1B2Info(param, mBuf)
+S16 cmPkTfuDciFormatB1B2Info(param, mBuf)
TfuDciFormatB1Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormatB1B2Info)
CMCHKPK(oduUnpackUInt8, param->DL_PCRS, mBuf);
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatA1A2Info
+S16 cmUnpkTfuDciFormatA1A2Info
(
TfuDciFormatA1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormatA1A2Info(param, mBuf)
+S16 cmUnpkTfuDciFormatA1A2Info(param, mBuf)
TfuDciFormatA1Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormatA1A2Info)
CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->xPUSCHRange, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatB1B2Info
+S16 cmUnpkTfuDciFormatB1B2Info
(
TfuDciFormatB1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormatB1B2Info(param, mBuf)
+S16 cmUnpkTfuDciFormatB1B2Info(param, mBuf)
TfuDciFormatB1Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormatB1B2Info)
CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->xPDSCHRange, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat0Info
+S16 cmPkTfuDciFormat0Info
(
TfuDciFormat0Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat0Info(param, mBuf)
+S16 cmPkTfuDciFormat0Info(param, mBuf)
TfuDciFormat0Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat0Info)
/* tfu_c_001.main_3: Adding pack for hqProcId */
CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat0Info
+S16 cmUnpkTfuDciFormat0Info
(
TfuDciFormat0Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat0Info(param, mBuf)
+S16 cmUnpkTfuDciFormat0Info(param, mBuf)
TfuDciFormat0Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormat0Info)
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuAllocMapOrRiv
+S16 cmPkTfuAllocMapOrRiv
(
TfuAllocMapOrRiv *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuAllocMapOrRiv(param, mBuf)
+S16 cmPkTfuAllocMapOrRiv(param, mBuf)
TfuAllocMapOrRiv *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuAllocMapOrRiv)
switch(param->type) {
/*tfu_c_001.main_7 - ADD - TFU_RESMAP_CHANGE support */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuAllocMapOrRiv
+S16 cmUnpkTfuAllocMapOrRiv
(
TfuAllocMapOrRiv *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuAllocMapOrRiv(param, mBuf)
+S16 cmUnpkTfuAllocMapOrRiv(param, mBuf)
TfuAllocMapOrRiv *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuAllocMapOrRiv)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_ALLOC_TYPE_RIV:
CMCHKUNPK(oduPackUInt32, ¶m->u.riv, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1AllocInfo
+S16 cmPkTfuDciFormat1AllocInfo
(
TfuDciFormat1AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1AllocInfo(param, mBuf)
TfuDciFormat1AllocInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuDciFormat1AllocInfo)
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1AllocInfo
+S16 cmUnpkTfuDciFormat1AllocInfo
(
TfuDciFormat1AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1AllocInfo(param, mBuf)
TfuDciFormat1AllocInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuDciFormat1AllocInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1Info
+S16 cmPkTfuDciFormat1Info
(
TfuDciFormat1Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1Info(param, mBuf)
+S16 cmPkTfuDciFormat1Info(param, mBuf)
TfuDciFormat1Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat1Info)
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
*
**********************************************************/
#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 ANSI
-PUBLIC S16 cmPkTfuDciFormat2AAllocInfo
+S16 cmPkTfuDciFormat2AAllocInfo
(
TfuDciFormat2AAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat2AAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AAllocInfo(param, mBuf)
TfuDciFormat2AAllocInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuDciFormat2AAllocInfo)
CMCHKPK(oduUnpackUInt8, param->transSwap, mBuf);
CMCHKPK(oduUnpackUInt8, param->precoding, mBuf);
*
**********************************************************/
#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 */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat6AAllocInfo
+S16 cmPkTfuDciFormat6AAllocInfo
(
TfuDciFormat61AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat6AAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat6AAllocInfo(param, mBuf)
TfuDciFormat61AllocInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat6AAllocInfo)
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat6AAllocInfo
+S16 cmUnpkTfuDciFormat6AAllocInfo
(
TfuDciFormat61AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat6AAllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat6AAllocInfo(param, mBuf)
TfuDciFormat61AllocInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormat6AAllocInfo)
CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat2AInfo
+S16 cmPkTfuDciFormat2AInfo
(
TfuDciFormat2AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat2AInfo(param, mBuf)
+S16 cmPkTfuDciFormat2AInfo(param, mBuf)
TfuDciFormat2AInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat2AInfo)
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
*
**********************************************************/
#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 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 */
*
**********************************************************/
#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 */
*
**********************************************************/
#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 */
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat3Info
+S16 cmPkTfuDciFormat3Info
(
TfuDciFormat3Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat3Info(param, mBuf)
+S16 cmPkTfuDciFormat3Info(param, mBuf)
TfuDciFormat3Info *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuDciFormat3Info)
CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat3Info
+S16 cmUnpkTfuDciFormat3Info
(
TfuDciFormat3Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat3Info(param, mBuf)
+S16 cmUnpkTfuDciFormat3Info(param, mBuf)
TfuDciFormat3Info *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuDciFormat3Info)
for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat3AInfo
+S16 cmPkTfuDciFormat3AInfo
(
TfuDciFormat3AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat3AInfo(param, mBuf)
+S16 cmPkTfuDciFormat3AInfo(param, mBuf)
TfuDciFormat3AInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuDciFormat3AInfo)
CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->tpcCmd[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat3AInfo
+S16 cmUnpkTfuDciFormat3AInfo
(
TfuDciFormat3AInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat3AInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat3AInfo(param, mBuf)
TfuDciFormat3AInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuDciFormat3AInfo)
for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
#endif
{
- TRC3(cmPkTfuDciFormat60aInfo)
CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
CMCHKPK(oduUnpackUInt8, param->isSrs, mBuf);
#endif
{
- TRC3(cmPkTfuPdcchOrderInfoEmtc)
CMCHKPK(oduUnpackUInt8, param->ceLevel, mBuf);
CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
#endif
{
- TRC3(cmPkTfudciformat61aPdsch)
CMCHKPK(oduUnpackUInt8, param->isTBMsg4, mBuf);
CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat61aInfo
+S16 cmPkTfuDciFormat61aInfo
(
TfuDciFormat61aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat61aInfo(param, mBuf)
+S16 cmPkTfuDciFormat61aInfo(param, mBuf)
TfuDciFormat61aInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat61aInfo)
switch(param->isPdcchOrder) {
case FALSE:
#endif
{
- TRC3(cmUnpkTfuDciFormat60aInfo)
printf("In cmUnpkTfuDciFormat60aInfo :: Entry \n");
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
#endif
{
- TRC3(cmUnpkTfuPdcchOrderInfoEmtc)
printf("In cmUnpkTfuPdcchOrderInfoEmtc :: Entry \n");
CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat61aInfo
+S16 cmUnpkTfuDciFormat61aInfo
(
TfuDciFormat61aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat61aInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat61aInfo(param, mBuf)
TfuDciFormat61aInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormat61aInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
printf("1. cmUnpkTfuDciFormat61aInfo :: isPdcchOrder %d \n", param->isPdcchOrder);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1dAllocInfo
+S16 cmPkTfuDciFormat1dAllocInfo
(
TfuDciFormat1dAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1dAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1dAllocInfo(param, mBuf)
TfuDciFormat1dAllocInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat1dAllocInfo)
CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
+ 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(oduPackUInt8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1dInfo
+S16 cmPkTfuDciFormat1dInfo
(
TfuDciFormat1dInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1dInfo(param, mBuf)
+S16 cmPkTfuDciFormat1dInfo(param, mBuf)
TfuDciFormat1dInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat1dInfo)
CMCHKPK(oduUnpackUInt8, param->dlPwrOffset, mBuf);
*
**********************************************************/
#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(oduPackUInt8, ¶m->harqProcId, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1cInfo
+S16 cmPkTfuDciFormat1cInfo
(
TfuDciFormat1cInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1cInfo(param, mBuf)
+S16 cmPkTfuDciFormat1cInfo(param, mBuf)
TfuDciFormat1cInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat1cInfo)
CMCHKPK(oduUnpackUInt8, param->iTbs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
+ 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(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(oduUnpackUInt8, param->pmiCfm, 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(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(oduPackUInt8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchOrderInfo
+S16 cmPkTfuPdcchOrderInfo
(
TfuPdcchOrderInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPdcchOrderInfo(param, mBuf)
+S16 cmPkTfuPdcchOrderInfo(param, mBuf)
TfuPdcchOrderInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuPdcchOrderInfo)
CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->preambleIdx, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchOrderInfo
+S16 cmUnpkTfuPdcchOrderInfo
(
TfuPdcchOrderInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPdcchOrderInfo(param, mBuf)
+S16 cmUnpkTfuPdcchOrderInfo(param, mBuf)
TfuPdcchOrderInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuPdcchOrderInfo)
CMCHKUNPK(oduPackUInt8, ¶m->preambleIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->prachMaskIdx, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1aAllocInfo
+S16 cmPkTfuDciFormat1aAllocInfo
(
TfuDciFormat1aAllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1aAllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat1aAllocInfo(param, mBuf)
TfuDciFormat1aAllocInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat1aAllocInfo)
CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->harqProcId, 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(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(oduPackUInt8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->harqProcId, 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(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(cmPkTknU8, ¶m->dai, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1aAllocInfo, ¶m->allocInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfudciformat1aPdsch
+S16 cmUnpkTfudciformat1aPdsch
(
Tfudciformat1aPdsch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfudciformat1aPdsch(param, mBuf)
+S16 cmUnpkTfudciformat1aPdsch(param, mBuf)
Tfudciformat1aPdsch *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfudciformat1aPdsch)
CMCHKUNPK(cmUnpkTfuDciFormat1aAllocInfo, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(cmUnpkTknU8, ¶m->dai, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->dai, mBuf);
#endif
CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfudciformat61aPdsch
+S16 cmUnpkTfudciformat61aPdsch
(
Tfudciformat61aPdsch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfudciformat61aPdsch(param, mBuf)
+S16 cmUnpkTfudciformat61aPdsch(param, mBuf)
Tfudciformat61aPdsch *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfudciformat61aPdsch)
printf("1. cmUnpkTfudciformat61aPdsch :: Entry \n");
CMCHKUNPK(cmUnpkTfuDciFormat6AAllocInfo, ¶m->allocInfo, mBuf);
#endif
{
- TRC3(cmUnpkTfuDirectIndication)
CMCHKUNPK(oduPackUInt8, ¶m->directInd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat62AllocInfo
+S16 cmUnpkTfuDciFormat62AllocInfo
(
TfuDciFormat62AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat62AllocInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat62AllocInfo(param, mBuf)
TfuDciFormat62AllocInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormat62AllocInfo)
CMCHKUNPK(oduPackUInt8, ¶m->riv, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
#endif
{
- TRC3(cmUnpkTfudciformat62Pdsch)
-
CMCHKUNPK(cmUnpkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->repNum, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat62Info
+S16 cmUnpkTfuDciFormat62Info
(
TfuDciFormat62Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat62Info(param, mBuf)
+S16 cmUnpkTfuDciFormat62Info(param, mBuf)
TfuDciFormat62Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormat62Info)
CMCHKUNPK(oduPackUInt8, ¶m->isPaging, mBuf);
switch(param->isPaging) {
case FALSE:
#endif
{
- TRC3(cmPkTfuDirectIndication)
CMCHKPK(oduUnpackUInt8, param->directInd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat62AllocInfo
+S16 cmPkTfuDciFormat62AllocInfo
(
TfuDciFormat62AllocInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat62AllocInfo(param, mBuf)
+S16 cmPkTfuDciFormat62AllocInfo(param, mBuf)
TfuDciFormat62AllocInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat6AAllocInfo)
-
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(oduUnpackUInt8, param->riv, mBuf);
#endif
{
- TRC3(cmPkTfudciformat62Pdsch)
CMCHKPK(oduUnpackUInt8, param->dciSubRepNum, mBuf);
CMCHKPK(oduUnpackUInt8, param->repNum, mBuf);
CMCHKPK(cmPkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat62Info
+S16 cmPkTfuDciFormat62Info
(
TfuDciFormat62Info *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat62Info(param, mBuf)
+S16 cmPkTfuDciFormat62Info(param, mBuf)
TfuDciFormat62Info *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat62Info)
-
switch(param->isPaging) {
case TRUE:
CMCHKPK(cmPkTfudciformat62Pdsch, ¶m->t.pdschInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1aInfo
+S16 cmPkTfuDciFormat1aInfo
(
TfuDciFormat1aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1aInfo(param, mBuf)
+S16 cmPkTfuDciFormat1aInfo(param, mBuf)
TfuDciFormat1aInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat1aInfo)
switch(param->isPdcchOrder) {
case FALSE:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormat1aInfo
+S16 cmUnpkTfuDciFormat1aInfo
(
TfuDciFormat1aInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormat1aInfo(param, mBuf)
+S16 cmUnpkTfuDciFormat1aInfo(param, mBuf)
TfuDciFormat1aInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormat1aInfo)
CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
switch(param->isPdcchOrder) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormat1bInfo
+S16 cmPkTfuDciFormat1bInfo
(
TfuDciFormat1bInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormat1bInfo(param, mBuf)
+S16 cmPkTfuDciFormat1bInfo(param, mBuf)
TfuDciFormat1bInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormat1bInfo)
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
*
**********************************************************/
#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 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
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciInfo
+S16 cmUnpkTfuDciInfo
(
TfuDciInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciInfo(param, mBuf)
+S16 cmUnpkTfuDciInfo(param, mBuf)
TfuDciInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciInfo)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->dciFormat, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->dciFormat, mBuf);
switch(param->dciFormat) {
case TFU_DCI_FORMAT_0:
CMCHKUNPK(cmUnpkTfuDciFormat0Info, ¶m->u.format0Info, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandInfo
+S16 cmPkTfuSubbandInfo
(
TfuSubbandInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandInfo(param, mBuf)
+S16 cmPkTfuSubbandInfo(param, mBuf)
TfuSubbandInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuSubbandInfo)
CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandInfo
+S16 cmUnpkTfuSubbandInfo
(
TfuSubbandInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandInfo(param, mBuf)
+S16 cmUnpkTfuSubbandInfo(param, mBuf)
TfuSubbandInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuSubbandInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandCqiInfo
+S16 cmPkTfuSubbandCqiInfo
(
TfuSubbandCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandCqiInfo(param, mBuf)
+S16 cmPkTfuSubbandCqiInfo(param, mBuf)
TfuSubbandCqiInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuSubbandCqiInfo)
CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subband, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandCqiInfo
+S16 cmUnpkTfuSubbandCqiInfo
(
TfuSubbandCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandCqiInfo(param, mBuf)
+S16 cmUnpkTfuSubbandCqiInfo(param, mBuf)
TfuSubbandCqiInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuSubbandCqiInfo)
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subband, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchCceInfo
+S16 cmPkTfuPdcchCceInfo
(
TfuPdcchCceInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPdcchCceInfo(param, mBuf)
+S16 cmPkTfuPdcchCceInfo(param, mBuf)
TfuPdcchCceInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuPdcchCceInfo)
CMCHKPK(cmPkLteAggrLvl, param->aggrLvl, mBuf);
CMCHKPK(oduUnpackUInt8, param->cceIdx, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdcchCceInfo
+S16 cmUnpkTfuPdcchCceInfo
(
TfuPdcchCceInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPdcchCceInfo(param, mBuf)
+S16 cmUnpkTfuPdcchCceInfo(param, mBuf)
TfuPdcchCceInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuPdcchCceInfo)
CMCHKUNPK(oduPackUInt8, ¶m->cceIdx, mBuf);
- CMCHKUNPK(cmUnpkLteAggrLvl,(U32 *)¶m->aggrLvl, 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:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode10
+S16 cmUnpkTfuCqiPucchMode10
(
TfuCqiPucchMode10 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode10(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode10(param, mBuf)
TfuCqiPucchMode10 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode10)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode11Cqi
+S16 cmPkTfuCqiMode11Cqi
(
TfuCqiMode11Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode11Cqi(param, mBuf)
+S16 cmPkTfuCqiMode11Cqi(param, mBuf)
TfuCqiMode11Cqi *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuCqiMode11Cqi)
- CMCHKPK(cmPkTknU8, ¶m->wideDiffCqi, mBuf);
+ 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(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->wideDiffCqi, 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:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode11
+S16 cmUnpkTfuCqiPucchMode11
(
TfuCqiPucchMode11 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode11(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode11(param, mBuf)
TfuCqiPucchMode11 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode11)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode20SubCqi
+S16 cmPkTfuCqiMode20SubCqi
(
TfuCqiMode20SubCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode20SubCqi(param, mBuf)
+S16 cmPkTfuCqiMode20SubCqi(param, mBuf)
TfuCqiMode20SubCqi *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuCqiMode20SubCqi)
CMCHKPK(oduUnpackUInt8, param->l, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode20SubCqi
+S16 cmUnpkTfuCqiMode20SubCqi
(
TfuCqiMode20SubCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode20SubCqi(param, mBuf)
+S16 cmUnpkTfuCqiMode20SubCqi(param, mBuf)
TfuCqiMode20SubCqi *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuCqiMode20SubCqi)
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode20Cqi
+S16 cmPkTfuCqiMode20Cqi
(
TfuCqiMode20Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode20Cqi(param, mBuf)
+S16 cmPkTfuCqiMode20Cqi(param, mBuf)
TfuCqiMode20Cqi *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuCqiMode20Cqi)
switch(param->isWideband) {
case FALSE:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode20Cqi
+S16 cmUnpkTfuCqiMode20Cqi
(
TfuCqiMode20Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode20Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode20Cqi(param, mBuf)
TfuCqiMode20Cqi *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuCqiMode20Cqi)
CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
*
**********************************************************/
#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:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode20
+S16 cmUnpkTfuCqiPucchMode20
(
TfuCqiPucchMode20 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode20(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode20(param, mBuf)
TfuCqiPucchMode20 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode20)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiMode21SubCqi
+S16 cmPkTfuCqiMode21SubCqi
(
TfuCqiMode21SubCqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiMode21SubCqi(param, mBuf)
+S16 cmPkTfuCqiMode21SubCqi(param, mBuf)
TfuCqiMode21SubCqi *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuCqiMode21SubCqi)
- CMCHKPK(cmPkTknU8, ¶m->diffCqi, mBuf);
+ 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(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, 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(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(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, 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:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiMode21Cqi
+S16 cmUnpkTfuCqiMode21Cqi
(
TfuCqiMode21Cqi *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiMode21Cqi(param, mBuf)
+S16 cmUnpkTfuCqiMode21Cqi(param, mBuf)
TfuCqiMode21Cqi *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuCqiMode21Cqi)
CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
*
**********************************************************/
#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:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPucchMode21
+S16 cmUnpkTfuCqiPucchMode21
(
TfuCqiPucchMode21 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPucchMode21(param, mBuf)
+S16 cmUnpkTfuCqiPucchMode21(param, mBuf)
TfuCqiPucchMode21 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuCqiPucchMode21)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiPucch
+S16 cmPkTfuDlCqiPucch
(
TfuDlCqiPucch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiPucch(param, mBuf)
+S16 cmPkTfuDlCqiPucch(param, mBuf)
TfuDlCqiPucch *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDlCqiPucch)
switch(param->mode) {
case TFU_PUCCH_CQI_MODE21:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPucch
+S16 cmUnpkTfuDlCqiPucch
(
TfuDlCqiPucch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiPucch(param, mBuf)
+S16 cmUnpkTfuDlCqiPucch(param, mBuf)
TfuDlCqiPucch *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDlCqiPucch)
CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
switch(param->mode) {
case TFU_PUCCH_CQI_MODE10:
CMCHKUNPK(cmUnpkTfuCqiPucchMode10, ¶m->u.mode10Info, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode12
+S16 cmPkTfuSubbandMode12
(
TfuSubbandMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandMode12(param, mBuf)
+S16 cmPkTfuSubbandMode12(param, mBuf)
TfuSubbandMode12 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuSubbandMode12)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode12
+S16 cmUnpkTfuSubbandMode12
(
TfuSubbandMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandMode12(param, mBuf)
+S16 cmUnpkTfuSubbandMode12(param, mBuf)
TfuSubbandMode12 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuSubbandMode12)
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode12
+S16 cmPkTfuCqiPuschMode12
(
TfuCqiPuschMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode12(param, mBuf)
+S16 cmPkTfuCqiPuschMode12(param, mBuf)
TfuCqiPuschMode12 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode12)
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuSubbandMode12, ¶m->subbandArr[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode12
+S16 cmUnpkTfuCqiPuschMode12
(
TfuCqiPuschMode12 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode12(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode12(param, mBuf)
TfuCqiPuschMode12 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode12)
CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode20
+S16 cmUnpkTfuCqiPuschMode20
(
TfuCqiPuschMode20 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode20(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode20(param, mBuf)
TfuCqiPuschMode20 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode20)
CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode22
+S16 cmPkTfuCqiPuschMode22
(
TfuCqiPuschMode22 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode22(param, mBuf)
+S16 cmPkTfuCqiPuschMode22(param, mBuf)
TfuCqiPuschMode22 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode22)
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode22
+S16 cmUnpkTfuCqiPuschMode22
(
TfuCqiPuschMode22 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode22(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode22(param, mBuf)
TfuCqiPuschMode22 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode22)
for (i=0; i<TFU_MAX_TB; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode30
+S16 cmPkTfuSubbandMode30
(
TfuSubbandMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandMode30(param, mBuf)
+S16 cmPkTfuSubbandMode30(param, mBuf)
TfuSubbandMode30 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuSubbandMode30)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode30
+S16 cmUnpkTfuSubbandMode30
(
TfuSubbandMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandMode30(param, mBuf)
+S16 cmUnpkTfuSubbandMode30(param, mBuf)
TfuSubbandMode30 *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuSubbandMode30)
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode30
+S16 cmPkTfuCqiPuschMode30
(
TfuCqiPuschMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode30(param, mBuf)
+S16 cmPkTfuCqiPuschMode30(param, mBuf)
TfuCqiPuschMode30 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode30)
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuSubbandMode30, ¶m->subbandArr[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode30
+S16 cmUnpkTfuCqiPuschMode30
(
TfuCqiPuschMode30 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode30(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode30(param, mBuf)
TfuCqiPuschMode30 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode30)
CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandMode31
+S16 cmPkTfuSubbandMode31
(
TfuSubbandMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandMode31(param, mBuf)
+S16 cmPkTfuSubbandMode31(param, mBuf)
TfuSubbandMode31 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuSubbandMode31)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuSubbandMode31
+S16 cmUnpkTfuSubbandMode31
(
TfuSubbandMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuSubbandMode31(param, mBuf)
+S16 cmUnpkTfuSubbandMode31(param, mBuf)
TfuSubbandMode31 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuSubbandMode31)
for (i=0; i<TFU_MAX_TB; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCqiPuschMode31
+S16 cmPkTfuCqiPuschMode31
(
TfuCqiPuschMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCqiPuschMode31(param, mBuf)
+S16 cmPkTfuCqiPuschMode31(param, mBuf)
TfuCqiPuschMode31 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuCqiPuschMode31)
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCqiPuschMode31
+S16 cmUnpkTfuCqiPuschMode31
(
TfuCqiPuschMode31 *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCqiPuschMode31(param, mBuf)
+S16 cmUnpkTfuCqiPuschMode31(param, mBuf)
TfuCqiPuschMode31 *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuCqiPuschMode31)
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
*
**********************************************************/
#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:
return RFAILED;
}
- CMCHKPK(cmPkTknU8, ¶m->ri, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->ri, mBuf);
CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
CMCHKPK(oduUnpackUInt8, param->cellIdx, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPusch
+S16 cmUnpkTfuDlCqiPusch
(
TfuDlCqiPusch *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiPusch(param, mBuf)
+S16 cmUnpkTfuDlCqiPusch(param, mBuf)
TfuDlCqiPusch *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDlCqiPusch)
CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->ri, 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);
*
**********************************************************/
#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:
*
**********************************************************/
#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:
*
**********************************************************/
#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 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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPdcchInfo
+S16 cmPkTfuPdcchInfo
(
TfuPdcchInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPdcchInfo(param, mBuf)
+S16 cmPkTfuPdcchInfo(param, mBuf)
TfuPdcchInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuPdcchInfo)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
*
**********************************************************/
#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(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
CMCHKUNPK(oduPackUInt16, ¶m->nCce, mBuf);
- CMCHKUNPK(cmUnpkLteAggrLvl, (U32*)¶m->aggrLvl, mBuf);
+ CMCHKUNPK(cmUnpkLteAggrLvl, (uint32_t*)¶m->aggrLvl, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->dciNumOfBits, mBuf);
CMCHKUNPK(cmUnpkTfuDciInfo, ¶m->dci, mBuf);
#ifdef TFU_5GTF
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuPhichInfo
+S16 cmPkTfuPhichInfo
(
TfuPhichInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuPhichInfo(param, mBuf)
+S16 cmPkTfuPhichInfo(param, mBuf)
TfuPhichInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuPhichInfo)
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
CMCHKPK(oduUnpackUInt16, param->txPower, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPhichInfo
+S16 cmUnpkTfuPhichInfo
(
TfuPhichInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPhichInfo(param, mBuf)
+S16 cmUnpkTfuPhichInfo(param, mBuf)
TfuPhichInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuPhichInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuCntrlReqInfo
+S16 cmPkTfuCntrlReqInfo
(
TfuCntrlReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuCntrlReqInfo(param, mBuf)
+S16 cmPkTfuCntrlReqInfo(param, mBuf)
TfuCntrlReqInfo *param;
Buffer *mBuf;
#endif
TfuPdcchInfo *tfuPdcchInfo;
TfuPhichInfo *tfuPhichInfo;
CmLList *node;
- U32 count;
+ uint32_t count;
- TRC3(cmPkTfuCntrlReqInfo)
#ifdef EMTC_ENABLE
count = param->dlMpdcchLst.count;
node = param->dlMpdcchLst.last;
*
**********************************************************/
#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);
*
**********************************************************/
#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
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuPdschDciInfo
+S16 cmUnpkTfuPdschDciInfo
(
TfuPdschDciInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuPdschDciInfo(param, mBuf)
+S16 cmUnpkTfuPdschDciInfo(param, mBuf)
TfuPdschDciInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuPdschDciInfo)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->format, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->format, mBuf);
switch(param->format) {
case TFU_DCI_FORMAT_1:
CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, ¶m->u.format1AllocInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuBfVectorInfo
+S16 cmPkTfuBfVectorInfo
(
TfuBfVectorInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuBfVectorInfo(param, mBuf)
+S16 cmPkTfuBfVectorInfo(param, mBuf)
TfuBfVectorInfo *param;
Buffer *mBuf;
#endif
{
S32 idx, idx2;
- TRC3(cmPkTfuBfVectorInfo)
for(idx=TFU_MAX_DL_SUBBAND-1;idx>=0; idx--)
{
for (idx2=param->numPhyAnt -1; idx2 >= 0; idx2--) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuBfVectorInfo
+S16 cmUnpkTfuBfVectorInfo
(
TfuBfVectorInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuBfVectorInfo(param, mBuf)
+S16 cmUnpkTfuBfVectorInfo(param, mBuf)
TfuBfVectorInfo *param;
Buffer *mBuf;
#endif
{
S32 idx, idx2;
- TRC3(cmUnpkTfuBfVectorInfo)
for(idx=0;idx<TFU_MAX_DL_SUBBAND; idx++)
{
CMCHKUNPK(oduPackUInt8, ¶m->sbIndex, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatReqPduInfo
+S16 cmPkTfuDatReqPduInfo
(
TfuDatReqPduInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDatReqPduInfo(param, mBuf)
+S16 cmPkTfuDatReqPduInfo(param, mBuf)
TfuDatReqPduInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- U8 tbMask = 0;
+ uint8_t tbMask = 0;
#ifdef L2_OPTMZ
- U32 lchIdx, pduIdx;
+ uint32_t lchIdx, pduIdx;
#endif
- TRC3(cmPkTfuDatReqPduInfo)
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKPK(oduUnpackUInt8, param->isEnbSFR, mBuf);
CMCHKPK(oduUnpackUInt8, param->numLayers, mBuf);
#endif
CMCHKPK(oduPackBool, param->isTApres, mBuf);
- CMCHKPK(cmPkTknU32, ¶m->doa, mBuf);
+ CMCHKPK(cmPkTknUInt32, ¶m->doa, mBuf);
CMCHKPK(oduUnpackUInt32, param->transMode, mBuf);
CMCHKPK(cmPkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
CMCHKPK(oduUnpackUInt8, param->puschRptUsd, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDatReqPduInfo
+S16 cmUnpkTfuDatReqPduInfo
(
TfuDatReqPduInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDatReqPduInfo(param, mBuf)
+S16 cmUnpkTfuDatReqPduInfo(param, mBuf)
TfuDatReqPduInfo *param;
Buffer *mBuf;
#endif
{
- U8 i;
- U8 tbMask = 0;
+ uint8_t i;
+ uint8_t tbMask = 0;
#ifdef L2_OPTMZ
- U32 lchIdx, pduIdx;
+ uint32_t lchIdx, pduIdx;
#endif
- TRC3(cmUnpkTfuDatReqPduInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkTfuPdschDciInfo, ¶m->dciInfo, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macHdr, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macCes, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->tbInfo[i].padSize, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->tbInfo[i].numLch, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->tbInfo[i].numLch, mBuf);
for(lchIdx = 0; lchIdx < param->tbInfo[i].numLch; lchIdx++)
{
- CMCHKUNPK(oduPackUInt32, (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++)
CMCHKUNPK(oduPackUInt8, ¶m->puschRptUsd, mBuf);
CMCHKUNPK(cmUnpkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->transMode, mBuf);
- CMCHKUNPK(cmUnpkTknU32, ¶m->doa, 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
*
**********************************************************/
#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;
*
**********************************************************/
#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);
*
**********************************************************/
#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);
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDatIndInfo
+S16 cmPkTfuDatIndInfo
(
TfuDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDatIndInfo(param, mBuf)
+S16 cmPkTfuDatIndInfo(param, mBuf)
TfuDatIndInfo *param;
Buffer *mBuf;
#endif
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuDatInfo *tfuDatInfo;
- TRC3(cmPkTfuDatIndInfo)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrInfo
+S16 cmPkTfuSrInfo
(
TfuSrInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSrInfo(param, mBuf)
+S16 cmPkTfuSrInfo(param, mBuf)
TfuSrInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuSrInfo)
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
return ROK;
*
**********************************************************/
#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);
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;
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuHqInfo
+S16 cmPkTfuHqInfo
(
TfuHqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuHqInfo(param, mBuf)
+S16 cmPkTfuHqInfo(param, mBuf)
TfuHqInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuHqInfo)
CMCHKPK(oduUnpackUInt8, param->isPusch, mBuf);
for (i=TFU_MAX_HARQ_FDBKS-1; i >= 0; i--) {
*
**********************************************************/
#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(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->noOfTbs, mBuf);
#ifdef TFU_TDD
CMCHKUNPK(oduPackUInt8, ¶m->M, mBuf);
#endif
for (i=0; i<TFU_MAX_HARQ_FDBKS; i++) {
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->isAck[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->isAck[i], mBuf);
}
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;
*
**********************************************************/
#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);
*
**********************************************************/
#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);
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);
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);
*
**********************************************************/
#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(oduPackUInt8, ¶m->isTxPort0, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUlCqiIndInfo
+S16 cmPkTfuUlCqiIndInfo
(
TfuUlCqiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUlCqiIndInfo(param, mBuf)
+S16 cmPkTfuUlCqiIndInfo(param, mBuf)
TfuUlCqiIndInfo *param;
Buffer *mBuf;
#endif
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuUlCqiRpt *tfuUlCqiRpt;
- TRC3(cmPkTfuUlCqiIndInfo)
count = param->ulCqiRpt.count;
node = param->ulCqiRpt.last;
*
**********************************************************/
#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);
*
**********************************************************/
#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)
return RFAILED;
*
**********************************************************/
#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(oduPackUInt8, ¶m->isPucchInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDlCqiIndInfo
+S16 cmPkTfuDlCqiIndInfo
(
TfuDlCqiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDlCqiIndInfo(param, mBuf)
+S16 cmPkTfuDlCqiIndInfo(param, mBuf)
TfuDlCqiIndInfo *param;
Buffer *mBuf;
#endif
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuDlCqiRpt *tfuDlCqiRpt;
- TRC3(cmPkTfuDlCqiIndInfo)
count = param->dlCqiRptsLst.count;
node = param->dlCqiRptsLst.last;
*
**********************************************************/
#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);
*
**********************************************************/
#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(cmPkTknUInt8, ¶m->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->isFailure, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
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(oduPackUInt8, ¶m->isFailure, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->rv, 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(oduUnpackUInt8, param->sccIdx, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuCrcIndInfo
+S16 cmUnpkTfuCrcIndInfo
(
TfuCrcIndInfo *param,
Ptr memCp,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuCrcIndInfo(param, memCp, mBuf)
+S16 cmUnpkTfuCrcIndInfo(param, memCp, mBuf)
TfuCrcIndInfo *param;
Ptr memCp;
Buffer *mBuf;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuCrcInfo *tfuCrcIndInfo;
- TRC3(cmUnpkTfuCrcIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvInfo
+S16 cmPkTfuTimingAdvInfo
(
TfuTimingAdvInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuTimingAdvInfo(param, mBuf)
+S16 cmPkTfuTimingAdvInfo(param, mBuf)
TfuTimingAdvInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuTimingAdvInfo)
CMCHKPK(oduUnpackUInt8, param->timingAdv, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
*
**********************************************************/
#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(oduPackUInt8, ¶m->timingAdv, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTimingAdvIndInfo
+S16 cmPkTfuTimingAdvIndInfo
(
TfuTimingAdvIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuTimingAdvIndInfo(param, mBuf)
+S16 cmPkTfuTimingAdvIndInfo(param, mBuf)
TfuTimingAdvIndInfo *param;
Buffer *mBuf;
#endif
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuTimingAdvInfo *tfuTimingAdvInfo;
- TRC3(cmPkTfuTimingAdvIndInfo)
count = param->timingAdvLst.count;
node = param->timingAdvLst.last;
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuTtiCellInfo
+S16 cmPkTfuTtiCellInfo
(
TfuTtiCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuTtiCellInfo(param, mBuf)
+S16 cmPkTfuTtiCellInfo(param, mBuf)
TfuTtiCellInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuTtiCellInfo)
CMCHKPK(oduUnpackUInt8, param->ulBlankSf, mBuf);
CMCHKPK(oduUnpackUInt8, param->dlBlankSf, mBuf);
*
**********************************************************/
#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--) {
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqInfo
+S16 cmPkTfuRaReqInfo
(
TfuRaReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRaReqInfo(param, mBuf)
+S16 cmPkTfuRaReqInfo(param, mBuf)
TfuRaReqInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuRaReqInfo)
CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiPres, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRaReqInfo
+S16 cmUnpkTfuRaReqInfo
(
TfuRaReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRaReqInfo(param, mBuf)
+S16 cmUnpkTfuRaReqInfo(param, mBuf)
TfuRaReqInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuRaReqInfo)
CMCHKUNPK(oduPackUInt8, ¶m->rapId, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->ta, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRachInfo
+S16 cmPkTfuRachInfo
(
CmMemListCp memCp,
TfuRachInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRachInfo(memCp, param, mBuf)
+S16 cmPkTfuRachInfo(memCp, param, mBuf)
CmMemListCp memCp;
TfuRachInfo *param;
Buffer *mBuf;
{
S32 i;
- TRC3(cmPkTfuRachInfo)
for (i= (param->numRaReqInfo - 1); i >= 0; i--) {
CMCHKPK(cmPkTfuRaReqInfo, &(param->raReqInfoArr[i]), mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuRachInfo
+S16 cmUnpkTfuRachInfo
(
CmMemListCp memCp,
TfuRachInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuRachInfo(memCp, param, mBuf)
+S16 cmUnpkTfuRachInfo(memCp, param, mBuf)
CmMemListCp memCp;
TfuRachInfo *param;
Buffer *mBuf;
{
S32 i;
- TRC3(cmUnpkTfuRachInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->raRnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numRaReqInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRaReqIndInfo
+S16 cmPkTfuRaReqIndInfo
(
TfuRaReqIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRaReqIndInfo(param, mBuf)
+S16 cmPkTfuRaReqIndInfo(param, mBuf)
TfuRaReqIndInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuRaReqIndInfo)
for (i= (param->nmbOfRaRnti-1); i >= 0; i--)
{
*
**********************************************************/
#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);
*
**********************************************************/
#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);
*
**********************************************************/
#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);
*
**********************************************************/
#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;
*
**********************************************************/
#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);
}
#ifdef ANSI
-PUBLIC S16 cmPkBuffer
+S16 cmPkBuffer
(
Buffer **param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkBuffer(param, mBuf)
+S16 cmPkBuffer(param, mBuf)
Buffer **param;
Buffer *mBuf;
#endif
{
MsgLen msgLen=0;
- TRC3(cmPkBuffer)
if (SFndLenMsg(*param, &msgLen) != ROK)
return RFAILED;
if (SCatMsg(mBuf, *param, M1M2) != ROK)
return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkBuffer
+S16 cmUnpkBuffer
(
Buffer **param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkBuffer(param, mBuf)
+S16 cmUnpkBuffer(param, mBuf)
Buffer **param;
Buffer *mBuf;
#endif
{
MsgLen msgLen=0, totalMsgLen=0;
- TRC3(cmUnpkBuffer)
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
return RFAILED;
*
**********************************************************/
#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)
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDciFormatTbInfo
+S16 cmPkTfuDciFormatTbInfo
(
TfuDciFormatTbInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDciFormatTbInfo(param, mBuf)
+S16 cmPkTfuDciFormatTbInfo(param, mBuf)
TfuDciFormatTbInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDciFormatTbInfo)
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDciFormatTbInfo
+S16 cmUnpkTfuDciFormatTbInfo
(
TfuDciFormatTbInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDciFormatTbInfo(param, mBuf)
+S16 cmUnpkTfuDciFormatTbInfo(param, mBuf)
TfuDciFormatTbInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDciFormatTbInfo)
CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSubbandDlCqiInfo
+S16 cmPkTfuSubbandDlCqiInfo
(
TfuSubbandDlCqiInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSubbandDlCqiInfo(param, mBuf)
+S16 cmPkTfuSubbandDlCqiInfo(param, mBuf)
TfuSubbandDlCqiInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuSubbandDlCqiInfo)
for (i=TFU_MAX_TB-1; i >= 0; i--) {
CMCHKPK(oduUnpackUInt8, param->cqiIdx[i], mBuf);
*
**********************************************************/
#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++) {
*
**********************************************************/
#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:
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuDlCqiPuschInfo
+S16 cmUnpkTfuDlCqiPuschInfo
(
TfuDlCqiPuschInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuDlCqiPuschInfo(param, mBuf)
+S16 cmUnpkTfuDlCqiPuschInfo(param, mBuf)
TfuDlCqiPuschInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuDlCqiPuschInfo)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDoaRpt
+S16 cmPkTfuDoaRpt
(
TfuDoaRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDoaRpt(param, mBuf)
+S16 cmPkTfuDoaRpt(param, mBuf)
TfuDoaRpt *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuDoaRpt)
CMCHKPK(oduUnpackUInt32, param->doa, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
*
**********************************************************/
#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(oduPackUInt32, ¶m->doa, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuDoaIndInfo
+S16 cmPkTfuDoaIndInfo
(
TfuDoaIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuDoaIndInfo(param, mBuf)
+S16 cmPkTfuDoaIndInfo(param, mBuf)
TfuDoaIndInfo *param;
Buffer *mBuf;
#endif
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuDoaRpt *tfuDoaRpt;
- TRC3(cmPkTfuDoaIndInfo)
count = param->doaRpt.count;
node = param->doaRpt.last;
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrsRpt
+S16 cmPkTfuSrsRpt
(
TfuSrsRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSrsRpt(param, mBuf)
+S16 cmPkTfuSrsRpt(param, mBuf)
TfuSrsRpt *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuSrsRpt)
CMCHKPK(oduUnpackUInt8, param->wideCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->wideCqiPres, mBuf);
*
**********************************************************/
#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(oduPackUInt16, ¶m->dopEst, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuSrsIndInfo
+S16 cmPkTfuSrsIndInfo
(
TfuSrsIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuSrsIndInfo(param, mBuf)
+S16 cmPkTfuSrsIndInfo(param, mBuf)
TfuSrsIndInfo *param;
Buffer *mBuf;
#endif
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuSrsRpt *tfuSrsRpt;
- TRC3(cmPkTfuSrsIndInfo)
count = param->srsRpt.count;
node = param->srsRpt.last;
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiRpt
+S16 cmPkTfuRawCqiRpt
(
TfuRawCqiRpt *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRawCqiRpt(param, mBuf)
+S16 cmPkTfuRawCqiRpt(param, mBuf)
TfuRawCqiRpt *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuRawCqiRpt)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt32, param->uciPayload, mBuf);
#else
*
**********************************************************/
#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(oduPackUInt8, ¶m->numBits, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuRawCqiIndInfo
+S16 cmPkTfuRawCqiIndInfo
(
TfuRawCqiIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuRawCqiIndInfo(param, mBuf)
+S16 cmPkTfuRawCqiIndInfo(param, mBuf)
TfuRawCqiIndInfo *param;
Buffer *mBuf;
#endif
{
- U32 count;
+ uint32_t count;
TfuRawCqiRpt *tfuRawCqiRpt;
CmLList *node;
- TRC3(cmPkTfuRawCqiIndInfo)
count = param->rawCqiRpt.count;
node = param->rawCqiRpt.last;
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo
+S16 cmPkTfuUePucchHqRecpInfo
(
TfuUePucchHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchHqRecpInfo(param, mBuf)
TfuUePucchHqRecpInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkTfuUePucchHqRecpInfo)
CMCHKPK(oduUnpackUInt8, param->a, mBuf);
for (i=TFU_MAX_HQ_RES-1; i >= 0; i--) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo
+S16 cmUnpkTfuUePucchHqRecpInfo
(
TfuUePucchHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
TfuUePucchHqRecpInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkTfuUePucchHqRecpInfo)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, 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++) {
*
**********************************************************/
#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--) {
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo
+S16 cmUnpkTfuUePucchHqRecpInfo
(
TfuUePucchHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchHqRecpInfo(param, mBuf)
TfuUePucchHqRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchHqRecpInfo)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pucchResCnt, mBuf);
#ifdef LTE_ADV
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchSrRecpInfo
+S16 cmPkTfuUePucchSrRecpInfo
(
TfuUePucchSrRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchSrRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchSrRecpInfo(param, mBuf)
TfuUePucchSrRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUePucchSrRecpInfo)
CMCHKPK(oduUnpackUInt16, param->n1PucchIdx, mBuf);
return ROK;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchSrRecpInfo
+S16 cmUnpkTfuUePucchSrRecpInfo
(
TfuUePucchSrRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchSrRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchSrRecpInfo(param, mBuf)
TfuUePucchSrRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchSrRecpInfo)
CMCHKUNPK(oduPackUInt16, ¶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(oduUnpackUInt8, param->cqiPmiSz, mBuf);
CMCHKPK(oduUnpackUInt16, param->n2PucchIdx, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchCqiRecpInfo
+S16 cmUnpkTfuUePucchCqiRecpInfo
(
TfuUePucchCqiRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchCqiRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchCqiRecpInfo(param, mBuf)
TfuUePucchCqiRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchCqiRecpInfo)
CMCHKUNPK(oduPackUInt16, ¶m->n2PucchIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSz, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchSrsRecpInfo
+S16 cmPkTfuUePucchSrsRecpInfo
(
TfuUePucchSrsRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchSrsRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchSrsRecpInfo(param, mBuf)
TfuUePucchSrsRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUePucchSrsRecpInfo)
CMCHKPK(oduUnpackUInt32, param->srsCyclicShft, mBuf);
CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
#ifdef TFU_5GTF
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchUciRecpInfo
+S16 cmPkTfuUePucchUciRecpInfo
(
TfuUePucchUciRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchUciRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchUciRecpInfo(param, mBuf)
TfuUePucchUciRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUePucchUciRecpInfo)
CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
CMCHKPK(oduUnpackUInt8, param->pucchIndex, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo
+S16 cmUnpkTfuUePucchSrsRecpInfo
(
TfuUePucchSrsRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchSrsRecpInfo(param, mBuf)
TfuUePucchSrsRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchSrsRecpInfo)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nRrc, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsHopBw, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsHopBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->transComb, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsCyclicShft, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsCyclicShft, mBuf);
return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchBsiBriRecpInfo
+S16 cmPkTfuUePucchBsiBriRecpInfo
(
TfuUePucchBsiBriRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchBsiBriRecpInfo(param, mBuf)
+S16 cmPkTfuUePucchBsiBriRecpInfo(param, mBuf)
TfuUePucchBsiBriRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUePucchBsiBriRecpInfo)
CMCHKPK(oduUnpackUInt8, param->briRpt, mBuf);
CMCHKPK(oduUnpackUInt8, param->bsiRpt, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchBsiBriRecpInfo
+S16 cmUnpkTfuUePucchBsiBriRecpInfo
(
TfuUePucchBsiBriRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchBsiBriRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchBsiBriRecpInfo(param, mBuf)
TfuUePucchBsiBriRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchBsiBriRecpInfo)
CMCHKUNPK(oduPackUInt8, ¶m->puschFlag, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
#ifdef TFU_5GTF
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo
+S16 cmUnpkTfuUePucchUciRecpInfo
(
TfuUePucchUciRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePucchUciRecpInfo(param, mBuf)
TfuUePucchUciRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchUciRecpInfo)
CMCHKUNPK(oduPackUInt8, ¶m->numBits, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePucchRecpReq
+S16 cmPkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePucchRecpReq(param, mBuf)
+S16 cmPkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUePucchRecpReq)
#ifdef TFU_5GTF
CMCHKPK(cmPkTfuUePucchBsiBriRecpInfo, ¶m->bsiBriInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePucchRecpReq
+S16 cmUnpkTfuUePucchRecpReq
(
TfuUePucchRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
+S16 cmUnpkTfuUePucchRecpReq(param, mBuf)
TfuUePucchRecpReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePucchRecpReq)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUeUlSchRecpInfo
+S16 cmPkTfuUeUlSchRecpInfo
(
TfuUeUlSchRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUeUlSchRecpInfo(param, mBuf)
+S16 cmPkTfuUeUlSchRecpInfo(param, mBuf)
TfuUeUlSchRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUeUlSchRecpInfo)
#ifdef TFU_5GTF
CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
CMCHKPK(oduUnpackUInt8, param->uciWoTBFlag, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeUlSchRecpInfo
+S16 cmUnpkTfuUeUlSchRecpInfo
(
TfuUeUlSchRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUeUlSchRecpInfo(param, mBuf)
+S16 cmUnpkTfuUeUlSchRecpInfo(param, mBuf)
TfuUeUlSchRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUeUlSchRecpInfo)
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->modType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschCqiRecpInfo
+S16 cmPkTfuUePuschCqiRecpInfo
(
TfuUePuschCqiRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePuschCqiRecpInfo(param, mBuf)
+S16 cmPkTfuUePuschCqiRecpInfo(param, mBuf)
TfuUePuschCqiRecpInfo *param;
Buffer *mBuf;
#endif
{
- U32 idx = 0;
- TRC3(cmPkTfuUePuschCqiRecpInfo)
+ uint32_t idx = 0;
CMCHKPK(oduUnpackUInt8, param->riBetaOff, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiBetaOff, mBuf);
for (idx = 0; idx < param->cCNum; idx++)
{
- CMCHKPK(cmPkTknU8, ¶m->riSz[idx], mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->riSz[idx], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiPmiSzRn1[idx], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiPmiSzR1[idx], mBuf);
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschCqiRecpInfo
+S16 cmUnpkTfuUePuschCqiRecpInfo
(
TfuUePuschCqiRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschCqiRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePuschCqiRecpInfo(param, mBuf)
TfuUePuschCqiRecpInfo *param;
Buffer *mBuf;
#endif
{
- U32 idx;
- TRC3(cmUnpkTfuUePuschCqiRecpInfo)
+ uint32_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->reportType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cCNum, mBuf);
{
CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzR1[idx-1], mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzRn1[idx-1], mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->riSz[idx-1], mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->riSz[idx-1], mBuf);
}
CMCHKUNPK(oduPackUInt8, ¶m->cqiBetaOff, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->riBetaOff, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUePuschHqRecpInfo
+S16 cmPkTfuUePuschHqRecpInfo
(
TfuUePuschHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUePuschHqRecpInfo(param, mBuf)
+S16 cmPkTfuUePuschHqRecpInfo(param, mBuf)
TfuUePuschHqRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUePuschHqRecpInfo)
#ifdef TFU_TDD
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschHqRecpInfo
+S16 cmUnpkTfuUePuschHqRecpInfo
(
TfuUePuschHqRecpInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschHqRecpInfo(param, mBuf)
+S16 cmUnpkTfuUePuschHqRecpInfo(param, mBuf)
TfuUePuschHqRecpInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePuschHqRecpInfo)
CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqBetaOff, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nBundled, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulDai, mBuf);
#endif
*
**********************************************************/
#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);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschRecpReq
+S16 cmUnpkTfuUePuschRecpReq
(
TfuUePuschRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
+S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
TfuUePuschRecpReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePuschRecpReq)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶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);
+ 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:
*
**********************************************************/
#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(oduPackUInt8, ¶m->groupId, mBuf);
#endif /* TFU_5GTF */
- CMCHKUNPK(oduPackUInt32, (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);
*
**********************************************************/
#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
*
**********************************************************/
#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(oduPackUInt32, (U32 *)¶m->hqType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqType, mBuf);
switch(param->hqType) {
#ifndef TFU_TDD
default :
return RFAILED;
}
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
#ifdef TFU_TDD
CMCHKUNPK(oduPackUInt8, ¶m->multCnt, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuUeMsg3RecpReq
+S16 cmPkTfuUeMsg3RecpReq
(
TfuUeMsg3RecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkTfuUeMsg3RecpReq(param, mBuf)
+S16 cmPkTfuUeMsg3RecpReq(param, mBuf)
TfuUeMsg3RecpReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkTfuUeMsg3RecpReq)
CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUeMsg3RecpReq
+S16 cmUnpkTfuUeMsg3RecpReq
(
TfuUeMsg3RecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUeMsg3RecpReq(param, mBuf)
+S16 cmUnpkTfuUeMsg3RecpReq(param, mBuf)
TfuUeMsg3RecpReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUeMsg3RecpReq)
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, 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(oduUnpackUInt32, param->modType, mBuf);
CMCHKPK(oduUnpackUInt16, param->size, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkTfuUePuschRecpReq
+S16 cmUnpkTfuUePuschRecpReq
(
TfuUePuschRecpReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
+S16 cmUnpkTfuUePuschRecpReq(param, mBuf)
TfuUePuschRecpReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkTfuUePuschRecpReq)
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->expCqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->expHarq, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, 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:
*
**********************************************************/
#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(oduPackUInt32, (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);
#endif
{
- TRC3(cmPkTfuErrIndInfo)
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#endif
{
- TRC3(cmUnpkTfuErrIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkTfuErrInd
+S16 cmPkTfuErrInd
(
Pst * pst,
SuId suId,
TfuErrIndInfo * errInd
)
#else
-PUBLIC S16 cmPkTfuErrInd(pst, suId, errInd)
+S16 cmPkTfuErrInd(pst, suId, errInd)
Pst * pst;
SuId suId;
TfuErrIndInfo * errInd;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkTfuErrInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
*
**********************************************************/
#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);
Code Review / o-du / l2.git / blobdiff