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: CKW RRC Control Interface
25 Desc: This file Contains the packing and unpacking functions for
30 *********************************************************************21*/
32 #include "envopt.h" /* environment options */
33 #include "envdep.h" /* environment dependent */
34 #include "envind.h" /* environment independent */
36 #include "gen.h" /* general */
37 #include "ssi.h" /* system services */
38 #include "cm5.h" /* common timer defines */
39 #include "cm_tkns.h" /* common tokens defines */
40 #include "cm_mblk.h" /* common memory allocation library defines */
41 #include "cm_llist.h" /* common link list defines */
42 #include "cm_hash.h" /* common hash list defines */
43 #include "cm_lte.h" /* common LTE defines */
44 #include "ckw.h" /* CKW defines */
46 /* extern (.x) include files */
47 #include "gen.x" /* general */
48 #include "ssi.x" /* system services */
50 #include "cm5.x" /* common timer library */
51 #include "cm_tkns.x" /* common tokens */
52 #include "cm_mblk.x" /* common memory allocation */
53 #include "cm_llist.x" /* common link list */
54 #include "cm_hash.x" /* common hash list */
55 #include "cm_lte.x" /* common LTE includes */
56 #include "cm_lib.x" /* common memory allocation library */
57 #include "ckw.x" /* CKW */
62 #endif /*for extern "C"*/
69 * Desc: pack the primitive CkwBndReq
79 PUBLIC S16 cmPkCkwBndReq
86 PUBLIC S16 cmPkCkwBndReq(pst, suId, spId)
97 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
99 #if (ERRCLASS & ERRCLS_ADD_RES)
102 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
103 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
104 (ErrVal)ECKW001, (ErrVal)0, "SGetMsg() failed");
106 #endif /* ERRCLASS & ERRCLS_ADD_RES */
109 CMCHKPKLOG(SPkS16, spId, mBuf, ECKW002, pst);
110 CMCHKPKLOG(SPkS16, suId, mBuf, ECKW003, pst);
111 pst->event = (Event) CKW_EVT_BND_REQ;
113 RETVALUE(SPstTsk(pst,mBuf));
114 } /*end of function cmPkCkwBndReq*/
118 * Fun: cmPkCkwUbndReq
120 * Desc: pack the primitive CkwUbndReq
130 PUBLIC S16 cmPkCkwUbndReq
137 PUBLIC S16 cmPkCkwUbndReq(pst, spId, reason)
148 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
150 #if (ERRCLASS & ERRCLS_ADD_RES)
153 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
154 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
155 (ErrVal)ECKW004, (ErrVal)0, "SGetMsg() failed");
157 #endif /* ERRCLASS & ERRCLS_ADD_RES */
160 CMCHKPKLOG(SPkS16, reason, mBuf, ECKW005, pst);
161 CMCHKPKLOG(SPkS16, spId, mBuf, ECKW006, pst);
162 pst->event = (Event) CKW_EVT_UBND_REQ;
164 RETVALUE(SPstTsk(pst,mBuf));
165 } /*end of function cmPkCkwUbndReq*/
171 * Desc: pack the primitive CkwBndCfm
181 PUBLIC S16 cmPkCkwBndCfm
188 PUBLIC S16 cmPkCkwBndCfm(pst, suId, status)
199 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
201 #if (ERRCLASS & ERRCLS_ADD_RES)
204 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
205 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
206 (ErrVal)ECKW007, (ErrVal)0, "SGetMsg() failed");
209 #endif /* ERRCLASS & ERRCLS_ADD_RES */
212 CMCHKPKLOG(SPkU8, status, mBuf, ECKW008, pst);
213 CMCHKPKLOG(SPkS16, suId, mBuf, ECKW009, pst);
214 pst->event = (Event) CKW_EVT_BND_CFM;
216 RETVALUE(SPstTsk(pst,mBuf));
217 } /*end of function cmPkCkwBndCfm*/
224 * Desc: pack the structure CkwTmInfo
234 PUBLIC S16 cmPkCkwTmInfo
240 PUBLIC S16 cmPkCkwTmInfo(param, mBuf)
247 CMCHKPK(SPkU32, param->dl.buffSize, mBuf);
250 } /* cmPkCkwTmInfo */
257 * Desc: pack the structure CkwUmInfo
267 PUBLIC S16 cmPkCkwUmInfo
269 CkwEntCfgInfo *param,
273 PUBLIC S16 cmPkCkwUmInfo(param, mBuf)
274 CkwEntCfgInfo *param;
284 CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
289 CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
290 CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
293 /* Patch ckw_c_001.main_3 */
294 case CKW_CFG_DIR_BOTH:
296 CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
297 CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
298 CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
304 } /* cmPkCkwUmInfo */
311 * Desc: pack the structure CkwAmInfo
321 PUBLIC S16 cmPkCkwAmInfo
327 PUBLIC S16 cmPkCkwAmInfo(param, mBuf)
335 CMCHKPK(SPkU8, param->ul.reOrdTmr, mBuf);
336 CMCHKPK(SPkU16, param->ul.staProhTmr, mBuf);
337 CMCHKPK(SPkU8, param->ul.snLen, mBuf);
340 CMCHKPK(SPkU8, param->dl.maxRetx, mBuf);
341 CMCHKPK(SPkS32, param->dl.pollByte, mBuf);
342 CMCHKPK(SPkS16, param->dl.pollPdu, mBuf);
343 CMCHKPK(SPkU16, param->dl.pollRetxTmr, mBuf);
344 CMCHKPK(SPkU8, param->dl.snLen, mBuf);
347 } /* cmPkCkwAmInfo */
354 * Desc: pack the structure CkwLChInfo
364 PUBLIC S16 cmPkCkwLChInfo
370 PUBLIC S16 cmPkCkwLChInfo(param, mBuf)
377 CMCHKPK(SPkU8, param->type, mBuf);
378 CMCHKPK(SPkU8, param->lChId, mBuf);
381 } /* cmPkCkwLChInfo */
386 * Fun: cmPkCkwEntCfgInfo
388 * Desc: pack the structure CkwEntCfgInfo
398 PUBLIC S16 cmPkCkwEntCfgInfo
400 CkwEntCfgInfo *param,
404 PUBLIC S16 cmPkCkwEntCfgInfo(param, mBuf)
405 CkwEntCfgInfo *param;
409 TRC3(cmPkCkwEntCfgInfo)
411 switch(param->entMode)
415 CMCHKPK(cmPkCkwTmInfo, &(param->m.tmInfo), mBuf);
420 CMCHKPK(cmPkCkwUmInfo, param, mBuf);
425 CMCHKPK(cmPkCkwAmInfo, &(param->m.amInfo), mBuf);
430 /* Logical Channel Information */
431 switch(param->entMode)
435 CMCHKPK(cmPkCkwLChInfo, &(param->lCh[0]), mBuf);
438 /* ccpu00128195: Packing lCh[0] and lCh[1] for UM bearer as well */
442 CMCHKPK(cmPkCkwLChInfo, &(param->lCh[1]), mBuf);
443 CMCHKPK(cmPkCkwLChInfo, &(param->lCh[0]), mBuf);
448 #ifdef TENB_MULT_CELL_SUPPRT
449 CMCHKPK(SPkS16, param->rguSapId, mBuf);
451 CMCHKPK(SPkS16, param->discardTmr, mBuf);
452 CMCHKPK(SPkU8, param->dir, mBuf);
453 CMCHKPK(cmPkLteRlcMode, param->entMode, mBuf);
454 CMCHKPK(SPkU8, param->qci, mBuf);
455 CMCHKPK(SPkU8, param->rbType, mBuf);
456 CMCHKPK(SPkU8, param->rbId, mBuf);
457 CMCHKPK(SPkU8, param->cfgType, mBuf);
460 } /* cmPkCkwEntCfgInfo */
465 * Fun: cmPkCkwCfgInfo
467 * Desc: pack the structure CkwCfgInfo
477 PUBLIC S16 cmPkCkwCfgInfo
484 PUBLIC S16 cmPkCkwCfgInfo(param, pst, mBuf)
494 for (idx = param->numEnt-1; idx >= 0; idx--)
496 CMCHKPK(cmPkCkwEntCfgInfo, &(param->entCfg[idx]), mBuf);
499 CMCHKPK(SPkU8, param->numEnt, mBuf);
500 CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
501 CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
502 CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW010, pst);
505 } /* cmPkCkwCfgInfo */
512 * Desc: pack the primitive KwUiCkwCfgReq
522 PUBLIC S16 cmPkCkwCfgReq
529 PUBLIC S16 cmPkCkwCfgReq(pst, spId, cfgInfo)
540 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
542 #if (ERRCLASS & ERRCLS_ADD_RES)
545 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
546 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
547 (ErrVal)ECKW011, (ErrVal)0, "SGetMsg() failed");
549 #endif /* ERRCLASS & ERRCLS_ADD_RES */
553 switch(pst->selector)
558 ret1 = cmPkCkwCfgInfo( (cfgInfo), pst, mBuf);
559 #if (ERRCLASS & ERRCLS_ADD_RES)
563 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
564 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
565 (ErrVal)ECKW012, (ErrVal)ret1, "Packing failure");
568 #endif /* ERRCLASS & ERRCLS_ADD_RES */
569 if (SPutSBuf(pst->region, pst->pool, (Data *)cfgInfo,
570 sizeof(CkwCfgInfo)) != ROK)
581 CMCHKPKLOG(SPkS16, spId, mBuf, ECKW013, pst);
582 pst->event = (Event) CKW_EVT_CFG_REQ;
584 RETVALUE(SPstTsk(pst,mBuf));
585 } /* cmPkCkwCfgReq */
590 * Fun: cmPkCkwEntCfgCfmInfo
592 * Desc: pack the structure CkwEntCfgInfo
602 PUBLIC S16 cmPkCkwEntCfgCfmInfo
604 CkwEntCfgCfmInfo *param,
608 PUBLIC S16 cmPkCkwEntCfgCfmInfo(param, mBuf)
609 CkwEntCfgCfmInfo *param;
613 TRC3(cmPkCkwEntCfgCfmInfo)
615 CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
616 CMCHKPK(SPkU8, param->rbType, mBuf);
617 CMCHKPK(SPkU8, param->rbId, mBuf);
620 } /* cmPkCkwEntCfgCfmInfo */
625 * Fun: cmPkCkwCfgCfmInfo
627 * Desc: pack the structure CkwCfgCfmInfo
637 PUBLIC S16 cmPkCkwCfgCfmInfo
639 CkwCfgCfmInfo *param,
644 PUBLIC S16 cmPkCkwCfgCfmInfo(param, pst, mBuf)
645 CkwCfgCfmInfo *param;
652 TRC3(cmPkCkwCfgCfmInfo)
654 for (idx = param->numEnt-1; idx >= 0; idx--)
656 CMCHKPK(cmPkCkwEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
659 CMCHKPK(SPkU8, param->numEnt, mBuf);
660 CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
661 CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
662 CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW014, pst);
665 } /* cmPkCkwCfgCfmInfo */
672 * Desc: pack the primitive KwUiCkwCfgCfm
682 PUBLIC S16 cmPkCkwCfgCfm
686 CkwCfgCfmInfo *cfgCfmInfo
689 PUBLIC S16 cmPkCkwCfgCfm(pst, suId, cfgCfmInfo)
692 CkwCfgCfmInfo *cfgCfmInfo;
700 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
702 #if (ERRCLASS & ERRCLS_ADD_RES)
705 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
706 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
707 (ErrVal)ECKW015, (ErrVal)0, "SGetMsg() failed");
709 #endif /* ERRCLASS & ERRCLS_ADD_RES */
713 switch(pst->selector)
718 ret1 = cmPkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
719 #if (ERRCLASS & ERRCLS_ADD_RES)
723 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
724 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
725 (ErrVal)ECKW016, (ErrVal)ret1, "Packing failure");
728 #endif /* ERRCLASS & ERRCLS_ADD_RES */
729 if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
730 sizeof(CkwCfgCfmInfo)) != ROK)
741 CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
742 pst->event = (Event) CKW_EVT_CFG_CFM;
744 RETVALUE(SPstTsk(pst,mBuf));
745 } /* cmPkCkwCfgCfm */
751 * Desc: pack the primitive KwUiCkwUeInfo
761 PUBLIC S16 cmPkCkwUeInfo
767 PUBLIC S16 cmPkCkwUeInfo(param, mBuf)
774 CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
775 CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
782 * Fun: cmPkCkwUeIdChgReq
784 * Desc: pack the primitive KwUiCkwUeIdChgReq
794 PUBLIC S16 cmPkCkwUeIdChgReq
803 PUBLIC S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
808 CkwUeInfo *newUeInfo;
812 Buffer *mBuf = NULLP;
814 TRC3(cmPkCkwUeIdChgReq)
816 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
818 #if (ERRCLASS & ERRCLS_ADD_RES)
821 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
822 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
823 (ErrVal)ECKW018, (ErrVal)0, "SGetMsg() failed");
825 #endif /* ERRCLASS & ERRCLS_ADD_RES */
830 CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
831 if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo,
832 sizeof(CkwUeInfo)) != ROK)
837 CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
838 if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
839 sizeof(CkwUeInfo)) != ROK)
844 CMCHKPKLOG(SPkU32, transId, mBuf, ECKW019, pst);
845 CMCHKPKLOG(SPkS16, spId, mBuf, ECKW020, pst);
846 pst->event = (Event) CKW_EVT_UEIDCHG_REQ;
848 RETVALUE(SPstTsk(pst, mBuf));
850 } /* cmPkCkwUeIdChgReq */
854 * Fun: cmPkCkwUeIdChgCfm
856 * Desc: pack the primitive KwUiCkwUeIdChgCfm
866 PUBLIC S16 cmPkCkwUeIdChgCfm
875 PUBLIC S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
884 Buffer *mBuf = NULLP;
886 TRC3(cmPkCkwUeIdChgCfm)
888 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
890 #if (ERRCLASS & ERRCLS_ADD_RES)
893 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
894 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
895 (ErrVal)ECKW021, (ErrVal)0, "SGetMsg() failed");
897 #endif /* ERRCLASS & ERRCLS_ADD_RES */
902 CMCHKPK(cmPkCmStatus, &status, mBuf);
903 CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
904 if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
905 sizeof(CkwUeInfo)) != ROK)
910 CMCHKPKLOG(SPkU32, transId, mBuf, ECKW022, pst);
911 CMCHKPKLOG(SPkS16, suId, mBuf, ECKW023, pst);
912 pst->event = (Event) CKW_EVT_UEIDCHG_CFM;
914 RETVALUE(SPstTsk(pst, mBuf));
916 } /* cmPkCkwUeIdChgCfm */
919 /******************************************************************************
921 *****************************************************************************/
925 * Fun: cmUnpkCkwBndReq
927 * Desc: unpack the primitive CkwBndReq
937 PUBLIC S16 cmUnpkCkwBndReq
944 PUBLIC S16 cmUnpkCkwBndReq(func, pst, mBuf)
953 TRC3(cmUnpkCkwBndReq)
955 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW024, pst);
956 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
959 RETVALUE((*func)(pst, suId, spId));
960 } /*end of function cmUnpkCkwBndReq*/
964 * Fun: cmUnpkCkwUbndReq
966 * Desc: unpack the primitive CkwUbndReq
976 PUBLIC S16 cmUnpkCkwUbndReq
983 PUBLIC S16 cmUnpkCkwUbndReq(func, pst, mBuf)
992 TRC3(cmUnpkCkwUbndReq)
994 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW026, pst);
995 CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, ECKW027, pst);
997 RETVALUE((*func)(pst, spId, reason));
998 } /*end of function cmUnpkCkwUbndReq*/
1002 * Fun: cmUnpkCkwBndCfm
1004 * Desc: unpack the primitive CkwBndCfm
1014 PUBLIC S16 cmUnpkCkwBndCfm
1021 PUBLIC S16 cmUnpkCkwBndCfm(func, pst, mBuf)
1030 TRC3(cmUnpkCkwBndCfm)
1032 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
1033 CMCHKUNPKLOG(SUnpkU8, &status, mBuf, ECKW029, pst);
1036 RETVALUE((*func)(pst, suId, status));
1037 } /*end of function cmUnpkCkwBndCfm*/
1042 * Fun: cmUnpkCkwTmInfo
1044 * Desc: pack the structure CkwTmInfo
1054 PUBLIC S16 cmUnpkCkwTmInfo
1060 PUBLIC S16 cmUnpkCkwTmInfo(param, mBuf)
1065 TRC3(cmUnpkCkwTmInfo)
1067 CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
1070 } /* cmUnpkCkwTmInfo */
1075 * Fun: cmUnpkCkwUmInfo
1077 * Desc: pack the structure CkwUmInfo
1087 PUBLIC S16 cmUnpkCkwUmInfo
1089 CkwEntCfgInfo *param,
1093 PUBLIC S16 cmUnpkCkwUmInfo(param, mBuf)
1094 CkwEntCfgInfo *param;
1098 TRC3(cmUnpkCkwUmInfo)
1102 case CKW_CFG_DIR_DL:
1104 CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1107 case CKW_CFG_DIR_UL:
1109 CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1110 CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1113 /* Patch ckw_c_001.main_3 */
1114 case CKW_CFG_DIR_BOTH:
1116 CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1117 CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1118 CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1124 } /* cmUnpkCkwUmInfo */
1129 * Fun: cmUnpkCkwAmInfo
1131 * Desc: pack the structure CkwAmInfo
1141 PUBLIC S16 cmUnpkCkwAmInfo
1147 PUBLIC S16 cmUnpkCkwAmInfo(param, mBuf)
1152 TRC3(cmUnpkCkwAmInfo)
1155 CMCHKUNPK(SUnpkU8, &(param->dl.snLen), mBuf);
1156 CMCHKUNPK(SUnpkU16, &(param->dl.pollRetxTmr), mBuf);
1157 CMCHKUNPK(SUnpkS16, &(param->dl.pollPdu), mBuf);
1158 CMCHKUNPK(SUnpkS32, &(param->dl.pollByte), mBuf);
1159 CMCHKUNPK(SUnpkU8, &(param->dl.maxRetx), mBuf);
1162 CMCHKUNPK(SUnpkU8, &(param->ul.snLen), mBuf);
1163 CMCHKUNPK(SUnpkU16, &(param->ul.staProhTmr), mBuf);
1164 CMCHKUNPK(SUnpkU8, &(param->ul.reOrdTmr), mBuf);
1167 } /* cmUnpkCkwAmInfo */
1172 * Fun: cmUnpkCkwLChInfo
1174 * Desc: pack the structure CkwLChInfo
1184 PUBLIC S16 cmUnpkCkwLChInfo
1190 PUBLIC S16 cmUnpkCkwLChInfo(param, mBuf)
1195 TRC3(cmUnpkCkwLChInfo)
1197 CMCHKUNPK(SUnpkU8, &(param->lChId), mBuf);
1198 CMCHKUNPK(SUnpkU8, &(param->type), mBuf);
1201 } /* cmUnpkCkwLChInfo */
1206 * Fun: cmUnpkCkwEntCfgCfmInfo
1208 * Desc: unpack the structure CkwEntCfgInfo
1218 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo
1220 CkwEntCfgCfmInfo *param,
1224 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo(param, mBuf)
1225 CkwEntCfgCfmInfo *param;
1229 TRC3(cmUnpkCkwEntCfgCfmInfo)
1231 CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1232 CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1233 CMCHKUNPK(cmUnpkCmStatus, &(param->status), mBuf);
1236 } /* cmUnpkCkwEntCfgCfmInfo */
1241 * Fun: cmUnpkCkwCfgCfmInfo
1243 * Desc: pack the structure CkwCfgCfmInfo
1253 PUBLIC S16 cmUnpkCkwCfgCfmInfo
1255 CkwCfgCfmInfo *param,
1260 PUBLIC S16 cmUnpkCkwCfgCfmInfo(param, pst, mBuf)
1261 CkwCfgCfmInfo *param;
1268 TRC3(cmUnpkCkwCfgCfmInfo)
1270 CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW030, pst);
1271 CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1272 CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1273 CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1275 for (idx = 0; idx < param->numEnt; idx++)
1277 CMCHKUNPK(cmUnpkCkwEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
1281 } /* cmUnpkCkwCfgCfmInfo */
1286 * Fun: cmUnpkCkwEntCfgInfo
1288 * Desc: pack the structure CkwEntCfgCfmInfo
1298 PUBLIC S16 cmUnpkCkwEntCfgInfo
1300 CkwEntCfgInfo *param,
1304 PUBLIC S16 cmUnpkCkwEntCfgInfo(param, mBuf)
1305 CkwEntCfgInfo *param;
1309 TRC3(cmUnpkCkwEntCfgInfo)
1311 CMCHKUNPK(SUnpkU8, &(param->cfgType), mBuf);
1312 CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1313 CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1314 CMCHKUNPK(SUnpkU8, &(param->qci), mBuf);
1315 CMCHKUNPK(cmUnpkLteRlcMode, &(param->entMode), mBuf);
1316 CMCHKUNPK(SUnpkU8, &(param->dir), mBuf);
1317 CMCHKUNPK(SUnpkS16, &(param->discardTmr), mBuf);
1318 #ifdef TENB_MULT_CELL_SUPPRT
1319 CMCHKUNPK(SUnpkS16, &(param->rguSapId), mBuf);
1322 /* Logical Channel Information */
1323 switch(param->entMode)
1325 case CM_LTE_MODE_TM:
1327 CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1330 /* ccpu00128195: Unpacking lCh[0] and lCh[1] for UM bearer as well */
1331 case CM_LTE_MODE_UM:
1332 case CM_LTE_MODE_AM:
1334 CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1335 CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[1]), mBuf);
1341 switch(param->entMode)
1343 case CM_LTE_MODE_TM:
1345 CMCHKUNPK(cmUnpkCkwTmInfo, &(param->m.tmInfo), mBuf);
1348 case CM_LTE_MODE_UM:
1350 CMCHKUNPK(cmUnpkCkwUmInfo, param, mBuf);
1353 case CM_LTE_MODE_AM:
1355 CMCHKUNPK(cmUnpkCkwAmInfo, &(param->m.amInfo), mBuf);
1361 } /* cmUnpkCkwEntCfgInfo */
1366 * Fun: cmUnpkCkwCfgInfo
1368 * Desc: unpack the structure CkwCfgInfo
1378 PUBLIC S16 cmUnpkCkwCfgInfo
1385 PUBLIC S16 cmUnpkCkwCfgInfo(param, pst, mBuf)
1393 TRC3(cmUnpkCkwCfgInfo)
1395 CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW031, pst);
1396 CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1397 CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1398 CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1400 for (idx = 0; idx < param->numEnt; idx++)
1402 CMCHKUNPKLOG(cmUnpkCkwEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
1406 } /* cmUnpkCkwCfgInfo */
1411 * Fun: cmUnpkCkwCfgReq
1413 * Desc: unpack the primitive KwUiCkwCfgReq
1423 PUBLIC S16 cmUnpkCkwCfgReq
1430 PUBLIC S16 cmUnpkCkwCfgReq(func, pst, mBuf)
1438 CkwCfgInfo *cfgInfo = NULLP;
1440 TRC3(cmUnpkCkwCfgReq)
1442 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgInfo,\
1443 sizeof(CkwCfgInfo))) != ROK)
1445 #if (ERRCLASS & ERRCLS_ADD_RES)
1447 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1448 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1449 (ErrVal)ECKW033, (ErrVal)0, "SGetMsg() failed");
1451 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1455 cmMemset((U8 *)cfgInfo, 0, sizeof(CkwCfgInfo));
1457 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1458 switch(pst->selector)
1463 ret1 = cmUnpkCkwCfgInfo( (cfgInfo), pst, mBuf);
1464 #if(ERRCLASS & ERRCLS_DEBUG)
1468 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1469 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1470 (ErrVal)ECKW034, (ErrVal)ret1, "Unpacking failure");
1473 #endif /* ERRCLASS & ERRCLS_DEBUG */
1480 RETVALUE((*func)(pst, spId, cfgInfo));
1481 } /* cmUnpkCkwCfgReq */
1486 * Fun: cmUnpkCkwCfgCfm
1488 * Desc: unpack the primitive KwUiCkwCfgCfm
1498 PUBLIC S16 cmUnpkCkwCfgCfm
1505 PUBLIC S16 cmUnpkCkwCfgCfm(func, pst, mBuf)
1513 CkwCfgCfmInfo *cfgCfmInfo = NULLP;
1515 TRC3(cmUnpkCkwCfgCfm)
1517 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
1518 sizeof(CkwCfgCfmInfo))) != ROK)
1520 #if (ERRCLASS & ERRCLS_ADD_RES)
1523 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1524 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1525 (ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
1527 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1531 cmMemset((U8 *)cfgCfmInfo, 0, sizeof(CkwCfgCfmInfo));
1533 CMCHKUNPK(SUnpkS16, &suId, mBuf);
1535 switch(pst->selector)
1540 ret1 = cmUnpkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
1541 #if(ERRCLASS & ERRCLS_DEBUG)
1545 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1546 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1547 (ErrVal)ECKW036, (ErrVal)ret1, "Unpacking failure");
1550 #endif /* ERRCLASS & ERRCLS_DEBUG */
1557 RETVALUE((*func)(pst, suId, cfgCfmInfo));
1558 } /* cmUnpkCkwCfgCfm */
1562 * Fun: cmUnpkCkwUeInfo
1564 * Desc: Unpack the primitive KwUiCkwUeInfo
1574 PUBLIC S16 cmUnpkCkwUeInfo
1580 PUBLIC S16 cmUnpkCkwUeInfo(param, mBuf)
1585 TRC2(cmUnpkCkwUeInfo)
1587 CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1588 CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1595 * Fun: cmUnpkCkwUeIdChgReq
1597 * Desc: unpack the primitive KwUiCkwUeIdChgReq
1607 PUBLIC S16 cmUnpkCkwUeIdChgReq
1614 PUBLIC S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
1623 CkwUeInfo *ueInfo = NULLP;
1624 CkwUeInfo *newUeInfo = NULLP;
1626 TRC3(cmUnpkCkwUeIdChgReq)
1629 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1630 CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW037, pst);
1632 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1633 sizeof(CkwUeInfo))) != ROK)
1635 #if (ERRCLASS & ERRCLS_ADD_RES)
1637 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1638 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1639 (ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
1641 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1645 cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1647 ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1648 #if(ERRCLASS & ERRCLS_DEBUG)
1652 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1653 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1654 (ErrVal)ECKW039, (ErrVal)ret1, "Unpacking failure");
1657 #endif /* ERRCLASS & ERRCLS_DEBUG */
1659 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo,\
1660 sizeof(CkwUeInfo))) != ROK)
1662 #if (ERRCLASS & ERRCLS_ADD_RES)
1664 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1665 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1666 (ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
1668 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1672 cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
1674 ret1 = cmUnpkCkwUeInfo((newUeInfo), mBuf);
1675 #if(ERRCLASS & ERRCLS_DEBUG)
1679 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1680 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1681 (ErrVal)ECKW041, (ErrVal)ret1, "Unpacking failure");
1684 #endif /* ERRCLASS & ERRCLS_DEBUG */
1688 RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
1690 } /* cmUnpkCkwUeIdChgReq */
1694 * Fun: cmUnpkCkwUeIdChgCfm
1696 * Desc: unpack the primitive KwUiCkwUeIdChgCfm
1706 PUBLIC S16 cmUnpkCkwUeIdChgCfm
1713 PUBLIC S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
1722 CkwUeInfo *ueInfo = NULLP;
1725 TRC3(cmUnpkCkwUeIdChgCfm)
1727 cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
1729 CMCHKUNPK(SUnpkS16, &suId, mBuf);
1730 CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW042, pst);
1732 if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1733 sizeof(CkwUeInfo))) != ROK)
1735 #if (ERRCLASS & ERRCLS_ADD_RES)
1738 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1739 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1740 (ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
1742 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1746 cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1748 ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1749 #if(ERRCLASS & ERRCLS_DEBUG)
1753 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1754 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1755 (ErrVal)ECKW044, (ErrVal)ret1, "Unpacking failure");
1758 #endif /* ERRCLASS & ERRCLS_DEBUG */
1760 CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
1764 RETVALUE((*func)(pst, suId, transId, ueInfo, status));
1766 } /* cmUnpkCkwUeIdChgCfm */
1771 #endif /* __cplusplus */
1774 /**********************************************************************
1776 **********************************************************************/