1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /********************************************************************20**
21 Name: UDX RRC Control Interface
25 Desc: This file Contains the packing and unpacking functions for
30 *********************************************************************21*/
31 #include "common_def.h"
33 #include "kw_udx.h" /* UDX defines */
36 /* extern (.x) include files */
47 * Desc: pack the primitive UdxBndReq
57 PRIVATE S16 cmUnpkUdxStruct
65 PRIVATE S16 cmUnpkUdxStruct(dstMBuf,srcBuf,size)
75 RETVALUE(SCpyMsgFix(srcMBuf,offset,size,dstBuf,&tmpLen));
77 } /*end of function cmPkUdxBndReq*/
83 * Desc: pack the primitive UdxBndReq
93 PRIVATE S16 cmPkUdxStruct
100 PRIVATE S16 cmPkUdxStruct(dstMBuf,srcBuf,size)
108 RETVALUE(SAddPstMsgMult(srcBuf,size,dstMBuf));
110 } /*end of function cmPkUdxBndReq*/
115 * Desc: pack the primitive UdxBndReq
125 PUBLIC S16 cmPkUdxBndReq
132 PUBLIC S16 cmPkUdxBndReq(pst, suId, spId)
143 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
145 #if (ERRCLASS & ERRCLS_ADD_RES)
148 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
149 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
150 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
152 #endif /* ERRCLASS & ERRCLS_ADD_RES */
155 CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
156 CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
157 pst->event = (Event) UDX_EVT_BND_REQ;
159 RETVALUE(SPstTsk(pst,mBuf));
160 } /*end of function cmPkUdxBndReq*/
164 * Fun: cmPkUdxUbndReq
166 * Desc: pack the primitive UdxUbndReq
176 PUBLIC S16 cmPkUdxUbndReq
183 PUBLIC S16 cmPkUdxUbndReq(pst, spId, reason)
194 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
196 #if (ERRCLASS & ERRCLS_ADD_RES)
199 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
200 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
201 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
203 #endif /* ERRCLASS & ERRCLS_ADD_RES */
206 CMCHKPKLOG(SPkS16, reason, mBuf, EUDXXXX, pst);
207 CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
208 pst->event = (Event) UDX_EVT_UBND_REQ;
210 RETVALUE(SPstTsk(pst,mBuf));
211 } /*end of function cmPkUdxUbndReq*/
217 * Desc: pack the primitive UdxBndCfm
227 PUBLIC S16 cmPkUdxBndCfm
234 PUBLIC S16 cmPkUdxBndCfm(pst, suId, status)
245 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
247 #if (ERRCLASS & ERRCLS_ADD_RES)
250 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
251 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
252 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
255 #endif /* ERRCLASS & ERRCLS_ADD_RES */
258 CMCHKPKLOG(SPkU8, status, mBuf, EUDXXXX, pst);
259 CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
260 pst->event = (Event) UDX_EVT_BND_CFM;
262 RETVALUE(SPstTsk(pst,mBuf));
263 } /*end of function cmPkUdxBndCfm*/
270 * Desc: pack the primitive KwUiUdxCfgReq
280 PUBLIC S16 cmPkUdxCfgReq
287 PUBLIC S16 cmPkUdxCfgReq(pst, spId, cfgInfo)
298 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
300 #if (ERRCLASS & ERRCLS_ADD_RES)
303 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
304 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
305 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
307 #endif /* ERRCLASS & ERRCLS_ADD_RES */
311 switch(pst->selector)
316 cmPkUdxStruct((U8 *)cfgInfo, sizeof(CkwCfgInfo),mBuf);
317 /* Need Not free CfgInfo here as it is stored
323 CMCHKPKLOG(cmPkPtr,(PTR)cfgInfo,mBuf,EUDXXXX,pst);
329 CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
330 pst->event = (Event) UDX_EVT_CFG_REQ;
332 RETVALUE(SPstTsk(pst,mBuf));
333 } /* cmPkUdxCfgReq */
340 * Desc: pack the primitive KwUiUdxCfgCfm
350 PUBLIC S16 cmPkUdxCfgCfm
354 CkwCfgCfmInfo *cfgCfmInfo
357 PUBLIC S16 cmPkUdxCfgCfm(pst, suId, cfgCfmInfo)
360 CkwCfgCfmInfo *cfgCfmInfo;
368 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
370 #if (ERRCLASS & ERRCLS_ADD_RES)
373 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
374 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
375 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
377 #endif /* ERRCLASS & ERRCLS_ADD_RES */
381 switch(pst->selector)
386 cmPkUdxStruct((U8 *)cfgCfmInfo, sizeof(CkwCfgCfmInfo),mBuf);
387 /* Need to free the cfgCfmInfo here as it is allocated
388 buffer call SPutStaticBuffer */
389 SPutStaticBuffer(pst->region,pst->pool,(Data *) cfgCfmInfo,
390 sizeof(CkwCfgCfmInfo),0);
395 CMCHKPKLOG(cmPkPtr,(PTR)cfgCfmInfo,mBuf,EUDXXXX,pst);
401 CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
402 pst->event = (Event) UDX_EVT_CFG_CFM;
404 RETVALUE(SPstTsk(pst,mBuf));
405 } /* cmPkUdxCfgCfm */
410 * Fun: cmPkUdxUeIdChgReq
412 * Desc: pack the primitive KwUiUdxUeIdChgReq
422 PUBLIC S16 cmPkUdxUeIdChgReq
431 PUBLIC S16 cmPkUdxUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
436 CkwUeInfo *newUeInfo;
440 Buffer *mBuf = NULLP;
442 TRC3(cmPkUdxUeIdChgReq)
444 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
446 #if (ERRCLASS & ERRCLS_ADD_RES)
449 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
450 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
451 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
453 #endif /* ERRCLASS & ERRCLS_ADD_RES */
458 switch(pst->selector)
463 cmPkUdxStruct((U8 *)newUeInfo, sizeof(CkwUeInfo),mBuf);
464 cmPkUdxStruct((U8 *)ueInfo, sizeof(CkwUeInfo),mBuf);
465 /* No need to free ueInfo here as it is stored */
470 CMCHKPKLOG(cmPkPtr,(PTR)newUeInfo,mBuf,EUDXXXX,pst);
471 CMCHKPKLOG(cmPkPtr,(PTR)ueInfo,mBuf,EUDXXXX,pst);
476 printf("cmPkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
481 CMCHKPKLOG(SPkU32, transId, mBuf, EUDXXXX, pst);
482 CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
483 pst->event = (Event) UDX_EVT_UEIDCHG_REQ;
485 RETVALUE(SPstTsk(pst, mBuf));
487 } /* cmPkUdxUeIdChgReq */
491 * Fun: cmPkUdxUeIdChgCfm
493 * Desc: pack the primitive KwUiUdxUeIdChgCfm
503 PUBLIC S16 cmPkUdxUeIdChgCfm
511 PUBLIC S16 cmPkUdxUeIdChgCfm(pst, suId, transId, status)
519 Buffer *mBuf = NULLP;
520 TRC3(cmPkUdxUeIdChgCfm)
522 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
524 #if (ERRCLASS & ERRCLS_ADD_RES)
527 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
528 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
529 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
531 #endif /* ERRCLASS & ERRCLS_ADD_RES */
536 CMCHKPK(cmPkCmStatus, &status, mBuf);
537 CMCHKPKLOG(SPkU32, transId, mBuf, EUDXXXX, pst);
538 CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
539 pst->event = (Event) UDX_EVT_UEIDCHG_CFM;
541 RETVALUE(SPstTsk(pst, mBuf));
543 } /* cmPkUdxUeIdChgCfm */
547 * Fun: cmPkUdxStaUpdCfm
549 * Desc: pack the primitive KwUiUdxUeIdChgCfm
559 PUBLIC S16 cmPkUdxStaUpdCfm
567 PUBLIC S16 cmPkUdxStaUpdCfm(pst, suId, rlcId,pStaPdu)
571 KwUdxBufLst *pStaPdu;
575 Buffer *mBuf = NULLP;
577 TRC3(cmPkUdxStaUpdCfm)
579 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
581 #if (ERRCLASS & ERRCLS_ADD_RES)
584 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
585 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
586 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
588 #endif /* ERRCLASS & ERRCLS_ADD_RES */
593 switch (pst->selector)
597 cmPkUdxStruct((U8 *)pStaPdu, sizeof(KwUdxBufLst),mBuf);
598 cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
603 CMCHKPK(cmPkPtr,(PTR) pStaPdu, mBuf);
604 CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
608 CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
609 pst->event = (Event) UDX_EVT_STA_UPD_CFM;
611 RETVALUE(SPstTsk(pst, mBuf));
613 } /* cmPkUdxStaUpdCfm */
617 * Fun: cmPkUdxStaProhTmrStart
619 * Desc: pack the primitive
629 PUBLIC S16 cmPkUdxStaProhTmrStart
636 PUBLIC S16 cmPkUdxStaProhTmrStart(pst, suId, rlcId)
643 Buffer *mBuf = NULLP;
645 TRC3(cmPkUdxStaProhTmrStart)
647 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
649 #if (ERRCLASS & ERRCLS_ADD_RES)
652 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
653 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
654 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
656 #endif /* ERRCLASS & ERRCLS_ADD_RES */
661 switch (pst->selector)
665 cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
670 CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
674 CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
675 pst->event = (Event) UDX_EVT_STA_PHBT_TMR_START;
677 RETVALUE(SPstTsk(pst, mBuf));
679 } /* cmPkUdxStaProhTmrStart */
683 * Fun: cmPkUdxStaUpdReq
685 * Desc: pack the primitive KwUiUdxUeIdChgCfm
695 PUBLIC S16 cmPkUdxStaUpdReq
703 PUBLIC S16 cmPkUdxStaUpdReq(pst, suId, rlcId,pStaPdu)
707 KwUdxStaPdu *pStaPdu;
711 Buffer *mBuf = NULLP;
713 TRC3(cmPkUdxStaUpdReq)
715 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
717 #if (ERRCLASS & ERRCLS_ADD_RES)
720 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
721 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
722 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
724 #endif /* ERRCLASS & ERRCLS_ADD_RES */
729 switch (pst->selector)
733 cmPkUdxStruct((U8 *)pStaPdu, sizeof(KwUdxStaPdu),mBuf);
734 cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
735 SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
736 sizeof(KwUdxStaPdu),0);
742 CMCHKPK(cmPkPtr,(PTR) pStaPdu, mBuf);
743 CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
747 CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
748 pst->event = (Event) UDX_EVT_STA_UPD_REQ;
750 RETVALUE(SPstTsk(pst, mBuf));
752 } /* cmPkUdxStaUpdReq */
756 * Fun: cmPkUdxStaPduReq
758 * Desc: pack the primitive KwUiUdxUeIdChgCfm
768 PUBLIC S16 cmPkUdxStaPduReq
773 KwUdxDlStaPdu *pStaPdu
776 PUBLIC S16 cmPkUdxStaPduReq(pst, suId, rlcId,pStaPdu)
780 KwUdxDlStaPdu *pStaPdu;
784 Buffer *mBuf = NULLP;
786 TRC3(cmPkUdxStaUpdReq)
788 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
790 #if (ERRCLASS & ERRCLS_ADD_RES)
793 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
794 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
795 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
797 #endif /* ERRCLASS & ERRCLS_ADD_RES */
802 switch (pst->selector)
806 cmPkUdxStruct((U8 *)pStaPdu, sizeof(KwUdxDlStaPdu),mBuf);
807 cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
808 /* Free status Pdu here for LC */
809 SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
810 sizeof(KwUdxDlStaPdu),0);
815 CMCHKPK(cmPkPtr,(PTR) pStaPdu, mBuf);
816 CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
820 CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
821 pst->event = (Event) UDX_EVT_STA_PDU_REQ;
823 RETVALUE(SPstTsk(pst, mBuf));
825 } /* cmPkUdxStaUpdReq */
830 * Fun: cmPkUdxL2MeasReq
839 PUBLIC S16 cmPkUdxL2MeasReq
842 KwL2MeasReqEvt *measReqEvt
845 PUBLIC S16 cmPkUdxL2MeasReq(pst, measReqEvt)
847 KwL2MeasReqEvt *measReqEvt;
851 Buffer *mBuf = NULLP;
853 TRC3(cmPkUdxL2MeasReq)
855 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
857 #if (ERRCLASS & ERRCLS_ADD_RES)
860 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
861 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
862 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
864 #endif /* ERRCLASS & ERRCLS_ADD_RES */
869 switch (pst->selector)
873 cmPkUdxStruct((U8 *)measReqEvt, sizeof(KwL2MeasReqEvt),mBuf);
878 CMCHKPK(cmPkPtr,(PTR) measReqEvt, mBuf);
882 pst->event = (Event) UDX_EVT_L2MEAS_REQ;
884 RETVALUE(SPstTsk(pst, mBuf));
886 } /* cmPkUdxStaUpdReq */
890 * Fun: cmPkUdxL2MeasReq
899 PUBLIC S16 cmPkUdxL2MeasSendReq
905 PUBLIC S16 cmPkUdxL2MeasSendReq(pst, measReqEvt)
911 Buffer *mBuf = NULLP;
913 TRC3(cmPkUdxL2MeasSendReq)
915 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
917 #if (ERRCLASS & ERRCLS_ADD_RES)
920 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
921 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
922 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
924 #endif /* ERRCLASS & ERRCLS_ADD_RES */
929 switch (pst->selector)
934 CMCHKPKLOG(SPkU8, measType, mBuf, EUDXXXX, pst);
938 pst->event = (Event) UDX_EVT_L2MEAS_SEND_REQ;
940 RETVALUE(SPstTsk(pst, mBuf));
946 * Fun: cmPkUdxL2MeasStopReq
955 PUBLIC S16 cmPkUdxL2MeasStopReq
961 PUBLIC S16 cmPkUdxL2MeasStopReq(pst, measType)
967 Buffer *mBuf = NULLP;
969 TRC3(cmPkUdxL2MeasStopReq)
971 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
973 #if (ERRCLASS & ERRCLS_ADD_RES)
976 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
977 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
978 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
980 #endif /* ERRCLASS & ERRCLS_ADD_RES */
985 switch (pst->selector)
990 CMCHKPKLOG(SPkU8, measType, mBuf, EUDXXXX, pst);
994 pst->event = (Event) UDX_EVT_L2MEAS_STOP_REQ;
996 RETVALUE(SPstTsk(pst, mBuf));
1000 /******************************************************************************
1002 *****************************************************************************/
1006 * Fun: cmUnpkUdxBndReq
1008 * Desc: unpack the primitive UdxBndReq
1018 PUBLIC S16 cmUnpkUdxBndReq
1025 PUBLIC S16 cmUnpkUdxBndReq(func, pst, mBuf)
1034 TRC3(cmUnpkUdxBndReq)
1036 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
1037 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
1040 RETVALUE((*func)(pst, suId, spId));
1041 } /*end of function cmUnpkUdxBndReq*/
1045 * Fun: cmUnpkUdxUbndReq
1047 * Desc: unpack the primitive UdxUbndReq
1057 PUBLIC S16 cmUnpkUdxUbndReq
1064 PUBLIC S16 cmUnpkUdxUbndReq(func, pst, mBuf)
1073 TRC3(cmUnpkUdxUbndReq)
1075 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
1076 CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EUDXXXX, pst);
1078 RETVALUE((*func)(pst, spId, reason));
1079 } /*end of function cmUnpkUdxUbndReq*/
1083 * Fun: cmUnpkUdxBndCfm
1085 * Desc: unpack the primitive UdxBndCfm
1095 PUBLIC S16 cmUnpkUdxBndCfm
1102 PUBLIC S16 cmUnpkUdxBndCfm(func, pst, mBuf)
1111 TRC3(cmUnpkUdxBndCfm)
1113 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
1114 CMCHKUNPKLOG(SUnpkU8, &status, mBuf, EUDXXXX, pst);
1117 RETVALUE((*func)(pst, suId, status));
1118 } /*end of function cmUnpkUdxBndCfm*/
1123 * Fun: cmUnpkUdxCfgReq
1125 * Desc: unpack the primitive KwUiUdxCfgReq
1135 PUBLIC S16 cmUnpkUdxCfgReq
1142 PUBLIC S16 cmUnpkUdxCfgReq(func, pst, mBuf)
1148 #if(ERRCLASS & ERRCLS_DEBUG)
1150 #endif /* ERRCLASS & ERRCLS_DEBUG */
1152 CkwCfgInfo tmpCfgInfo;
1153 CkwCfgInfo *cfgInfo; /*stack Variable because it is not freed */
1155 TRC3(cmUnpkUdxCfgReq)
1157 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1158 switch(pst->selector)
1163 #if(ERRCLASS & ERRCLS_DEBUG)
1164 ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(CkwCfgInfo));
1168 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1169 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1170 (ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
1174 cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(CkwCfgInfo));
1175 #endif /* ERRCLASS & ERRCLS_DEBUG */
1176 cfgInfo = &tmpCfgInfo;
1181 CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgInfo, mBuf);
1188 RETVALUE((*func)(pst, spId, cfgInfo));
1189 } /* cmUnpkUdxCfgReq */
1194 * Fun: cmUnpkUdxCfgCfm
1196 * Desc: unpack the primitive KwUiUdxCfgCfm
1206 PUBLIC S16 cmUnpkUdxCfgCfm
1213 PUBLIC S16 cmUnpkUdxCfgCfm(func, pst, mBuf)
1221 CkwCfgCfmInfo *cfgCfmInfo = NULLP;
1223 TRC3(cmUnpkUdxCfgCfm)
1225 CMCHKUNPK(SUnpkS16, &suId, mBuf);
1227 switch(pst->selector)
1232 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
1233 sizeof(CkwCfgCfmInfo),0)) != ROK)
1235 #if (ERRCLASS & ERRCLS_ADD_RES)
1238 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1239 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1240 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
1242 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1246 ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)cfgCfmInfo, sizeof(CkwCfgCfmInfo));
1247 #if(ERRCLASS & ERRCLS_DEBUG)
1251 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1252 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1253 (ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
1256 #endif /* ERRCLASS & ERRCLS_DEBUG */
1261 CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgCfmInfo, mBuf);
1268 RETVALUE((*func)(pst, suId, cfgCfmInfo));
1269 } /* cmUnpkUdxCfgCfm */
1273 * Fun: cmUnpkUdxUeIdChgReq
1275 * Desc: unpack the primitive KwUiUdxUeIdChgReq
1285 PUBLIC S16 cmUnpkUdxUeIdChgReq
1292 PUBLIC S16 cmUnpkUdxUeIdChgReq(func, pst, mBuf)
1300 CkwUeInfo tmpUeInfo;
1301 CkwUeInfo tmpNewUeInfo;
1303 CkwUeInfo *newUeInfo;
1305 TRC3(cmUnpkUdxUeIdChgReq)
1308 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1309 CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, EUDXXXX, pst);
1311 switch(pst->selector)
1316 cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpNewUeInfo, sizeof(CkwUeInfo));
1317 cmUnpkUdxStruct(mBuf,sizeof(CkwUeInfo),(U8 *)&tmpUeInfo, sizeof(CkwUeInfo));
1319 ueInfo = &tmpUeInfo;
1320 newUeInfo = &tmpNewUeInfo;
1325 CMCHKUNPK(cmUnpkPtr,(PTR *) &ueInfo, mBuf);
1326 CMCHKUNPK(cmUnpkPtr,(PTR *) &newUeInfo, mBuf);
1331 printf("cmUnpkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
1339 RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
1341 } /* cmUnpkUdxUeIdChgReq */
1345 * Fun: cmUnpkUdxUeIdChgCfm
1347 * Desc: unpack the primitive KwUiUdxUeIdChgCfm
1357 PUBLIC S16 cmUnpkUdxUeIdChgCfm
1364 PUBLIC S16 cmUnpkUdxUeIdChgCfm(func, pst, mBuf)
1374 TRC3(cmUnpkUdxUeIdChgCfm)
1376 cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
1378 CMCHKUNPK(SUnpkS16, &suId, mBuf);
1379 CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, EUDXXXX, pst);
1381 CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
1385 RETVALUE((*func)(pst, suId, transId, status));
1387 } /* cmUnpkUdxUeIdChgCfm */
1391 * Fun: cmUnpkUdxStaUpdCfm
1393 * Desc: unpack the primitive KwUiUdxUeIdChgCfm
1403 PUBLIC S16 cmUnpkUdxStaUpdCfm
1410 PUBLIC S16 cmUnpkUdxStaUpdCfm(func, pst, mBuf)
1417 CmLteRlcId *rlcId = NULLP; /* KW_FIX */
1418 KwUdxBufLst *pBufLst = NULLP; /* KW_FIX*/
1420 TRC3(cmUnpkUdxStaUpdCfm)
1422 CMCHKUNPK(SUnpkS16, &suId, mBuf);
1423 switch (pst->selector)
1431 CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
1432 CMCHKUNPK(cmUnpkPtr, (PTR *)&pBufLst,mBuf);
1439 RETVALUE((*func)(pst, suId, rlcId, pBufLst));
1441 } /* cmUnpkUdxUeIdChgCfm */
1445 * Fun: cmUnpkUdxStaUpdReq
1447 * Desc: unpack the primitive KwUiUdxUeIdChgCfm
1457 PUBLIC S16 cmUnpkUdxStaUpdReq
1464 PUBLIC S16 cmUnpkUdxStaUpdReq(func, pst, mBuf)
1471 CmLteRlcId *rlcId = NULLP; /* KW_FIX */
1472 KwUdxStaPdu *pStaPdu = NULLP; /* KW_FIX */
1474 CmLteRlcId tmpRlcId;
1476 TRC3(cmUnpkUdxStaUpdCfm)
1478 CMCHKUNPK(SUnpkS16, &spId, mBuf);
1479 switch (pst->selector)
1483 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
1484 sizeof(KwUdxStaPdu),0)) != ROK)
1486 #if (ERRCLASS & ERRCLS_ADD_RES)
1489 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1490 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1491 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
1493 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1496 ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)pStaPdu, sizeof(KwUdxStaPdu));
1497 ret1 = cmUnpkUdxStruct(mBuf,sizeof(KwUdxStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
1503 CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
1504 CMCHKUNPK(cmUnpkPtr, (PTR *)&pStaPdu,mBuf);
1511 RETVALUE((*func)(pst, spId, rlcId, pStaPdu));
1513 } /* cmUnpkUdxUeIdChgCfm */
1517 * Fun: cmUnpkUdxStaPduReq
1519 * Desc: unpack the primitive KwUiUdxUeIdChgCfm
1529 PUBLIC S16 cmUnpkUdxStaPduReq
1536 PUBLIC S16 cmUnpkUdxStaPduReq(func, pst, mBuf)
1544 CmLteRlcId tmpRlcId;
1545 CmLteRlcId *rlcId = NULLP; /* KW_FIX */
1546 KwUdxDlStaPdu *pStaPdu = NULLP; /* KW_FIX */
1548 TRC3(cmUnpkUdxStaUpdCfm)
1550 CMCHKUNPK(SUnpkS16, &spId, mBuf);
1551 switch (pst->selector)
1555 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
1556 sizeof(KwUdxDlStaPdu),0)) != ROK)
1558 #if (ERRCLASS & ERRCLS_ADD_RES)
1561 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1562 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1563 (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
1565 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1568 ret1 = cmUnpkUdxStruct(mBuf,0, (U8 *)pStaPdu, sizeof(KwUdxDlStaPdu));
1569 ret1 = cmUnpkUdxStruct(mBuf,sizeof(KwUdxDlStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
1575 CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
1576 CMCHKUNPK(cmUnpkPtr, (PTR *)&pStaPdu,mBuf);
1582 RETVALUE((*func)(pst, spId, rlcId, pStaPdu));
1584 } /* cmUnpkUdxUeIdChgCfm */
1588 * Fun: cmUnpkUdxStaProhTmrStart
1590 * Desc: unpack the Status prohibit timer start Msg
1600 PUBLIC S16 cmUnpkUdxStaProhTmrStart
1602 UdxStaProhTmrStart func,
1607 PUBLIC S16 cmUnpkUdxStaProhTmrStart(func, pst, mBuf)
1608 UdxStaProhTmrStart func;
1614 CmLteRlcId tmpRlcId;
1615 CmLteRlcId *rlcId = NULLP; /* KW_FIX */
1617 TRC3(cmUnpkUdxStaProhTmrStart)
1619 CMCHKUNPK(SUnpkS16, &spId, mBuf);
1620 switch (pst->selector)
1624 cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
1630 CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
1637 RETVALUE((*func)(pst, spId, rlcId));
1639 } /* cmUnpkUdxStaProhTmrStart */
1645 * Fun: cmUnpkUdxL2MeasReq
1654 PUBLIC S16 cmUnpkUdxL2MeasReq
1661 PUBLIC S16 cmUnpkUdxL2MeasReq(func, pst, mBuf)
1667 KwL2MeasReqEvt tmpMeasReqEvt;
1668 KwL2MeasReqEvt *measReqEvt = NULLP; /* KW_FIX */
1670 TRC3(cmUnpkUdxL2MeasReq)
1672 switch (pst->selector)
1676 cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpMeasReqEvt,sizeof(KwL2MeasReqEvt));
1677 measReqEvt = &tmpMeasReqEvt;
1682 CMCHKUNPK(cmUnpkPtr, (PTR *)&measReqEvt,mBuf);
1689 RETVALUE((*func)(pst, measReqEvt));
1690 } /* cmUnpkUdxL2MeasReq */
1694 * Fun: cmUnpkUdxL2MeasSendReq
1703 PUBLIC S16 cmUnpkUdxL2MeasSendReq
1705 UdxL2MeasSendReq func,
1710 PUBLIC S16 cmUnpkUdxL2MeasSendReq(func, pst, mBuf)
1711 UdxL2MeasSendReq func;
1716 U8 measType = 0; /* KW_FIX */
1718 TRC3(cmUnpkUdxL2MeasSendReq)
1720 switch (pst->selector)
1725 CMCHKUNPK(SUnpkU8, &measType, mBuf);
1732 RETVALUE((*func)(pst, measType));
1733 } /* cmUnpkUdxL2MeasReq */
1737 * Fun: cmUnpkUdxL2MeasStopReq
1746 PUBLIC S16 cmUnpkUdxL2MeasStopReq
1748 UdxL2MeasStopReq func,
1753 PUBLIC S16 cmUnpkUdxL2MeasStopReq(func, pst, mBuf)
1754 UdxL2MeasSendReq func;
1759 U8 measType = 0; /* KW_FIX */
1761 TRC3(cmUnpkUdxL2MeasStopReq)
1763 switch (pst->selector)
1768 CMCHKUNPK(SUnpkU8, &measType, mBuf);
1775 RETVALUE((*func)(pst, measType));
1776 } /* cmUnpkUdxL2MeasStopReq */
1781 /********************************************************************30**
1783 **********************************************************************/