Updated IP and Port configurations
[o-du/l2.git] / src / cm / ckw.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
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                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
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 *******************************************************************************/
18
19 /********************************************************************20**
20   
21         Name:    CKW RRC Control Interface
22     
23         Type:    C file
24   
25         Desc:    This file Contains the packing and unpacking functions for
26                  CKW Interface
27  
28         File:    ckw.c
29
30 *********************************************************************21*/
31
32 #include "common_def.h"
33 #include "ckw.h"
34 #include "ckw.x"
35 /* extern (.x) include files */
36
37 \f
38 #ifdef __cplusplus
39 EXTERN "C" {
40 #endif  /*for extern "C"*/
41
42 #ifdef LCCKW
43 /*
44 *
45 *    Fun:    cmPkCkwBndReq
46 *
47 *    Desc:    pack the primitive CkwBndReq
48 *
49 *    Ret:    ROK  -ok
50 *
51 *    Notes:    None
52 *
53 *    File:     ckw.c
54 *
55 */
56 #ifdef ANSI
57 PUBLIC S16 cmPkCkwBndReq
58 (
59 Pst *pst,
60 SuId suId,
61 SpId spId
62 )
63 #else
64 PUBLIC S16 cmPkCkwBndReq(pst, suId, spId)
65 Pst *pst;
66 SuId suId;
67 SpId spId;
68 #endif
69 {
70     S16 ret1;
71     Buffer *mBuf;
72     mBuf = NULLP;
73     TRC3(cmPkCkwBndReq)
74
75     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
76     {
77 #if (ERRCLASS & ERRCLS_ADD_RES)
78        if(ret1 != ROK)
79        {
80           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
81                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
82                (ErrVal)ECKW001, (ErrVal)0, "SGetMsg() failed");
83        }
84 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
85        RETVALUE(ret1);
86     }
87     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW002, pst);
88     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW003, pst);
89     pst->event = (Event) CKW_EVT_BND_REQ;
90
91     RETVALUE(SPstTsk(pst,mBuf));
92 } /*end of function cmPkCkwBndReq*/
93 \f
94 /*
95 *
96 *    Fun:    cmPkCkwUbndReq
97 *
98 *    Desc:    pack the primitive CkwUbndReq
99 *
100 *    Ret:    ROK  -ok
101 *
102 *    Notes:    None
103 *
104 *    File:     ckw.c
105 *
106 */
107 #ifdef ANSI
108 PUBLIC S16 cmPkCkwUbndReq
109 (
110 Pst *pst,
111 SpId spId,
112 Reason reason
113 )
114 #else
115 PUBLIC S16 cmPkCkwUbndReq(pst, spId, reason)
116 Pst *pst;
117 SpId spId;
118 Reason reason;
119 #endif
120 {
121     S16 ret1;
122     Buffer *mBuf;
123     mBuf = NULLP;
124     TRC3(cmPkCkwUbndReq)
125
126     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
127     {
128 #if (ERRCLASS & ERRCLS_ADD_RES)
129        if(ret1 != ROK)
130        {
131           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
132                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
133                (ErrVal)ECKW004, (ErrVal)0, "SGetMsg() failed");
134        }
135 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
136        RETVALUE(ret1);
137     }
138     CMCHKPKLOG(SPkS16, reason, mBuf, ECKW005, pst);
139     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW006, pst);
140     pst->event = (Event) CKW_EVT_UBND_REQ;
141
142     RETVALUE(SPstTsk(pst,mBuf));
143 } /*end of function cmPkCkwUbndReq*/
144 \f
145 /*
146 *
147 *    Fun:    cmPkCkwBndCfm
148 *
149 *    Desc:    pack the primitive CkwBndCfm
150 *
151 *    Ret:    ROK  -ok
152 *
153 *    Notes:    None
154 *
155 *    File:     ckw.c
156 *
157 */
158 #ifdef ANSI
159 PUBLIC S16 cmPkCkwBndCfm
160 (
161 Pst *pst,
162 SuId suId,
163 U8 status
164 )
165 #else
166 PUBLIC S16 cmPkCkwBndCfm(pst, suId, status)
167 Pst *pst;
168 SuId suId;
169 U8 status;
170 #endif
171 {
172     S16 ret1;
173     Buffer *mBuf;
174     mBuf = NULLP;
175     TRC3(cmPkCkwBndCfm)
176
177     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
178     {
179 #if (ERRCLASS & ERRCLS_ADD_RES)
180        if(ret1 != ROK)
181        {
182           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
183                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
184                (ErrVal)ECKW007, (ErrVal)0, "SGetMsg() failed");
185        }
186
187 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
188        RETVALUE(ret1);
189     }
190     CMCHKPKLOG(SPkU8, status, mBuf, ECKW008, pst);
191     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW009, pst);
192     pst->event = (Event) CKW_EVT_BND_CFM;
193
194     RETVALUE(SPstTsk(pst,mBuf));
195 } /*end of function cmPkCkwBndCfm*/
196
197 \f
198 /*
199 *
200 *    Fun:    cmPkCkwTmInfo
201 *
202 *    Desc:    pack the structure CkwTmInfo
203 *
204 *    Ret:    ROK  -ok
205 *
206 *    Notes:    None
207 *
208 *    File:     ckw.c
209 *
210 */
211 #ifdef ANSI
212 PUBLIC S16 cmPkCkwTmInfo
213 (
214 CkwTmInfo      *param,
215 Buffer         *mBuf
216 )
217 #else
218 PUBLIC S16 cmPkCkwTmInfo(param, mBuf)
219 CkwTmInfo      *param;
220 Buffer         *mBuf;
221 #endif
222 {
223     TRC3(cmPkCkwTmInfo)
224
225     CMCHKPK(SPkU32, param->dl.buffSize, mBuf);
226
227     RETVALUE(ROK);
228 } /* cmPkCkwTmInfo */
229
230 \f
231 /*
232 *
233 *    Fun:    cmPkCkwUmInfo
234 *
235 *    Desc:    pack the structure CkwUmInfo
236 *
237 *    Ret:    ROK  -ok
238 *
239 *    Notes:    None
240 *
241 *    File:     ckw.c
242 *
243 */
244 #ifdef ANSI
245 PUBLIC S16 cmPkCkwUmInfo
246 (
247 CkwEntCfgInfo  *param,
248 Buffer         *mBuf
249 )
250 #else
251 PUBLIC S16 cmPkCkwUmInfo(param, mBuf)
252 CkwEntCfgInfo  *param;
253 Buffer         *mBuf;
254 #endif
255 {
256     TRC3(cmPkCkwUmInfo)
257
258     switch(param->dir)
259     {
260        case CKW_CFG_DIR_DL:
261           {
262              CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
263              break;
264           }
265        case CKW_CFG_DIR_UL:
266           {
267              CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
268              CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
269              break;
270           }
271        /* Patch ckw_c_001.main_3 */
272        case CKW_CFG_DIR_BOTH:
273           {
274              CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
275              CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
276              CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
277              break;
278           }
279     }
280
281     RETVALUE(ROK);
282 } /* cmPkCkwUmInfo */
283
284 \f
285 /*
286 *
287 *    Fun:    cmPkCkwAmInfo
288 *
289 *    Desc:    pack the structure CkwAmInfo
290 *
291 *    Ret:    ROK  -ok
292 *
293 *    Notes:    None
294 *
295 *    File:     ckw.c
296 *
297 */
298 #ifdef ANSI
299 PUBLIC S16 cmPkCkwAmInfo
300 (
301 CkwAmInfo      *param,
302 Buffer         *mBuf
303 )
304 #else
305 PUBLIC S16 cmPkCkwAmInfo(param, mBuf)
306 CkwAmInfo      *param;
307 Buffer         *mBuf;
308 #endif
309 {
310     TRC3(cmPkCkwAmInfo)
311
312     /* UP LINK */
313     CMCHKPK(SPkU8, param->ul.reOrdTmr, mBuf);
314     CMCHKPK(SPkU16, param->ul.staProhTmr, mBuf);
315     CMCHKPK(SPkU8, param->ul.snLen, mBuf);
316
317     /* DOWN LINK */
318     CMCHKPK(SPkU8, param->dl.maxRetx, mBuf);
319     CMCHKPK(SPkS32, param->dl.pollByte, mBuf);
320     CMCHKPK(SPkS16, param->dl.pollPdu, mBuf);
321     CMCHKPK(SPkU16, param->dl.pollRetxTmr, mBuf);
322     CMCHKPK(SPkU8, param->dl.snLen, mBuf);
323
324     RETVALUE(ROK);
325 } /* cmPkCkwAmInfo */
326
327 \f
328 /*
329 *
330 *    Fun:    cmPkCkwLInfo
331 *
332 *    Desc:    pack the structure CkwLChInfo
333 *
334 *    Ret:    ROK  -ok
335 *
336 *    Notes:    None
337 *
338 *    File:     ckw.c
339 *
340 */
341 #ifdef ANSI
342 PUBLIC S16 cmPkCkwLChInfo
343 (
344 CkwLChInfo     *param,
345 Buffer         *mBuf
346 )
347 #else
348 PUBLIC S16 cmPkCkwLChInfo(param, mBuf)
349 CkwLChInfo     *param;
350 Buffer         *mBuf;
351 #endif
352 {
353     TRC3(cmPkCkwLChInfo)
354
355     CMCHKPK(SPkU8, param->type, mBuf);
356     CMCHKPK(SPkU8, param->lChId, mBuf);
357
358     RETVALUE(ROK);
359 } /* cmPkCkwLChInfo */
360
361 \f
362 /*
363 *
364 *    Fun:    cmPkCkwEntCfgInfo
365 *
366 *    Desc:    pack the structure CkwEntCfgInfo
367 *
368 *    Ret:    ROK  -ok
369 *
370 *    Notes:    None
371 *
372 *    File:     ckw.c
373 *
374 */
375 #ifdef ANSI
376 PUBLIC S16 cmPkCkwEntCfgInfo
377 (
378 CkwEntCfgInfo  *param,
379 Buffer         *mBuf
380 )
381 #else
382 PUBLIC S16 cmPkCkwEntCfgInfo(param, mBuf)
383 CkwEntCfgInfo  *param;
384 Buffer         *mBuf;
385 #endif
386 {
387     TRC3(cmPkCkwEntCfgInfo)
388
389     switch(param->entMode)
390     {
391        case CM_LTE_MODE_TM:
392           {
393              CMCHKPK(cmPkCkwTmInfo, &(param->m.tmInfo), mBuf);
394              break;
395           }
396        case CM_LTE_MODE_UM:
397           {
398              CMCHKPK(cmPkCkwUmInfo, param, mBuf);
399              break;
400           }
401        case CM_LTE_MODE_AM:
402           {
403              CMCHKPK(cmPkCkwAmInfo, &(param->m.amInfo), mBuf);
404              break;
405           }
406     }
407
408     /* Logical Channel Information */
409     switch(param->entMode)
410     {
411        case CM_LTE_MODE_TM:
412           {
413              CMCHKPK(cmPkCkwLChInfo, &(param->lCh[0]), mBuf);
414              break;
415           }
416        /* ccpu00128195: Packing lCh[0] and lCh[1] for UM bearer as well */
417        case CM_LTE_MODE_UM:
418        case CM_LTE_MODE_AM:
419           {
420              CMCHKPK(cmPkCkwLChInfo, &(param->lCh[1]), mBuf);
421              CMCHKPK(cmPkCkwLChInfo, &(param->lCh[0]), mBuf);
422              break;
423           }
424     }
425
426 #ifdef TENB_MULT_CELL_SUPPRT
427     CMCHKPK(SPkS16, param->rguSapId, mBuf);
428 #endif
429     CMCHKPK(SPkS16, param->discardTmr, mBuf);
430     CMCHKPK(SPkU8, param->dir, mBuf);
431     CMCHKPK(cmPkLteRlcMode, param->entMode, mBuf);
432     CMCHKPK(SPkU8, param->qci, mBuf);
433     CMCHKPK(SPkU8, param->rbType, mBuf);
434     CMCHKPK(SPkU8, param->rbId, mBuf);
435     CMCHKPK(SPkU8, param->cfgType, mBuf);
436
437     RETVALUE(ROK);
438 } /* cmPkCkwEntCfgInfo */
439
440 \f
441 /*
442 *
443 *    Fun:    cmPkCkwCfgInfo
444 *
445 *    Desc:    pack the structure CkwCfgInfo
446 *
447 *    Ret:    ROK  -ok
448 *
449 *    Notes:    None
450 *
451 *    File:     ckw.c
452 *
453 */
454 #ifdef ANSI
455 PUBLIC S16 cmPkCkwCfgInfo
456 (
457 CkwCfgInfo     *param,
458 Pst            *pst,
459 Buffer         *mBuf
460 )
461 #else
462 PUBLIC S16 cmPkCkwCfgInfo(param, pst, mBuf)
463 CkwCfgInfo     *param;
464 Pst            *pst;
465 Buffer         *mBuf;
466 #endif
467 {
468    S16 idx;
469
470    TRC3(cmPkCkwCfgInfo)
471
472     for (idx = param->numEnt-1; idx >= 0; idx--)
473     {
474        CMCHKPK(cmPkCkwEntCfgInfo, &(param->entCfg[idx]), mBuf);
475     }
476
477     CMCHKPK(SPkU8, param->numEnt, mBuf);
478     CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
479     CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
480     CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW010, pst);
481
482     RETVALUE(ROK);
483 } /* cmPkCkwCfgInfo */
484
485 \f
486 /*
487 *
488 *    Fun:    packUeCreateReq
489 *
490 *    Desc:    pack the primitive UE Create Req
491 *
492 *    Ret:    ROK  -ok
493 *
494 *    Notes:    None
495 *
496 *    File:     ckw.c
497 *
498 */
499 #ifdef ANSI
500 PUBLIC S16 packUeCreateReq
501 (
502 Pst               *pst,
503 CkwCfgInfo        *cfgInfo
504 )
505 #else
506 PUBLIC S16 packUeCreateReq(pst, cfgInfo)
507 Pst               *pst;
508 CkwCfgInfo        *cfgInfo;
509 #endif
510 {
511     S16 ret1;
512     Buffer *mBuf;
513     mBuf = NULLP;
514     TRC3(packUeCreateReq)
515
516     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
517     {
518 #if (ERRCLASS & ERRCLS_ADD_RES)
519        if(ret1 != ROK)
520        {
521           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
522                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
523                (ErrVal)ECKW011, (ErrVal)0, "SGetMsg() failed");
524        }
525 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
526        RETVALUE(ret1);
527     }
528
529     switch(pst->selector)
530     {
531        case ODU_SELECTOR_LWLC:
532           {
533              CMCHKPK(cmPkPtr,(PTR) cfgInfo, mBuf);
534              break;
535           }
536     }
537     pst->event = (Event) RLC_EVT_UE_CREATE_REQ;
538
539     RETVALUE(SPstTsk(pst,mBuf));
540 } /* packUeCreateReq */
541
542 \f
543 /*
544 *
545 *    Fun:    cmPkCkwEntCfgCfmInfo
546 *
547 *    Desc:    pack the structure CkwEntCfgInfo
548 *
549 *    Ret:    ROK  -ok
550 *
551 *    Notes:    None
552 *
553 *    File:     ckw.c
554 *
555 */
556 #ifdef ANSI
557 PUBLIC S16 cmPkCkwEntCfgCfmInfo
558 (
559 CkwEntCfgCfmInfo  *param,
560 Buffer            *mBuf
561 )
562 #else
563 PUBLIC S16 cmPkCkwEntCfgCfmInfo(param, mBuf)
564 CkwEntCfgCfmInfo  *param;
565 Buffer            *mBuf;
566 #endif
567 {
568     TRC3(cmPkCkwEntCfgCfmInfo)
569
570     CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
571     CMCHKPK(SPkU8, param->rbType, mBuf);
572     CMCHKPK(SPkU8, param->rbId, mBuf);
573
574     RETVALUE(ROK);
575 } /* cmPkCkwEntCfgCfmInfo */
576
577 \f
578 /*
579 *
580 *    Fun:    cmPkCkwCfgCfmInfo
581 *
582 *    Desc:    pack the structure CkwCfgCfmInfo
583 *
584 *    Ret:    ROK  -ok
585 *
586 *    Notes:    None
587 *
588 *    File:     ckw.c
589 *
590 */
591 #ifdef ANSI
592 PUBLIC S16 cmPkCkwCfgCfmInfo
593 (
594 CkwCfgCfmInfo  *param,
595 Pst            *pst,
596 Buffer         *mBuf
597 )
598 #else
599 PUBLIC S16 cmPkCkwCfgCfmInfo(param, pst, mBuf)
600 CkwCfgCfmInfo  *param;
601 Pst            *pst;
602 Buffer         *mBuf;
603 #endif
604 {
605     S16         idx;
606
607     TRC3(cmPkCkwCfgCfmInfo)
608
609     for (idx = param->numEnt-1; idx >= 0; idx--)
610     {
611        CMCHKPK(cmPkCkwEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
612     }
613
614     CMCHKPK(SPkU8, param->numEnt, mBuf);
615     CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
616     CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
617     CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW014, pst);
618
619     RETVALUE(ROK);
620 } /* cmPkCkwCfgCfmInfo */
621
622 \f
623 /*
624 *
625 *    Fun:    cmPkCkwCfgCfm
626 *
627 *    Desc:    pack the primitive KwUiCkwCfgCfm
628 *
629 *    Ret:    ROK  -ok
630 *
631 *    Notes:    None
632 *
633 *    File:     ckw.c
634 *
635 */
636 #ifdef ANSI
637 PUBLIC S16 cmPkCkwCfgCfm
638 (
639 Pst               *pst,
640 SuId              suId,
641 CkwCfgCfmInfo     *cfgCfmInfo
642 )
643 #else
644 PUBLIC S16 cmPkCkwCfgCfm(pst, suId, cfgCfmInfo)
645 Pst               *pst;
646 SuId              suId;
647 CkwCfgCfmInfo     *cfgCfmInfo;
648 #endif
649 {
650     S16 ret1;
651     Buffer *mBuf;
652     mBuf = NULLP;
653     TRC3(cmPkCkwCfgCfm)
654
655     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
656     {
657 #if (ERRCLASS & ERRCLS_ADD_RES)
658        if(ret1 != ROK)
659        {
660           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
661                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
662                (ErrVal)ECKW015, (ErrVal)0, "SGetMsg() failed");
663        }
664 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
665        RETVALUE(ret1);
666     }
667
668     switch(pst->selector)
669     {
670 #ifdef LCCKW
671        case ODU_SELECTOR_LC:
672           {
673              ret1 = cmPkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
674 #if (ERRCLASS & ERRCLS_ADD_RES)
675              if(ret1 != ROK)
676              {
677                 SPutMsg(mBuf);
678                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
679                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
680                       (ErrVal)ECKW016, (ErrVal)ret1, "Packing failure");
681                 RETVALUE( ret1 );
682              }
683 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
684              if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
685                       sizeof(CkwCfgCfmInfo)) != ROK)
686              {
687                 SPutMsg(mBuf);
688                 RETVALUE(RFAILED);
689              }
690
691              break;
692           }
693 #endif /* LCCKW */
694     }
695
696     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
697     pst->event = (Event) CKW_EVT_CFG_CFM;
698
699     RETVALUE(SPstTsk(pst,mBuf));
700 } /* cmPkCkwCfgCfm */
701
702 /*
703 *
704 *    Fun:    cmPkCkwUeInfo
705 *
706 *    Desc:   pack the primitive KwUiCkwUeInfo
707 *
708 *    Ret:    ROK  -ok
709 *
710 *    Notes:  None
711 *
712 *    File:   ckw.c
713 *
714 */
715 #ifdef ANSI
716 PUBLIC S16 cmPkCkwUeInfo
717 (
718 CkwUeInfo *param,
719 Buffer    *mBuf
720 )
721 #else
722 PUBLIC S16 cmPkCkwUeInfo(param, mBuf)
723 CkwUeInfo *param;
724 Buffer    *mBuf;
725 #endif
726 {
727    TRC2(cmPkCkwUeInfo)
728
729    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
730    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
731
732    RETVALUE(ROK);
733 }
734
735 /*
736 *
737 *    Fun:    cmPkCkwUeIdChgReq
738 *
739 *    Desc:   pack the primitive KwUiCkwUeIdChgReq
740 *
741 *    Ret:    ROK  -ok
742 *
743 *    Notes:  None
744 *
745 *    File:   ckw.c
746 *
747 */
748 #ifdef ANSI
749 PUBLIC S16 cmPkCkwUeIdChgReq
750 (
751 Pst               *pst,
752 SpId              spId,
753 U32               transId,
754 CkwUeInfo         *ueInfo,
755 CkwUeInfo         *newUeInfo
756 )
757 #else
758 PUBLIC S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
759 Pst               *pst;
760 SpId              spId;
761 U32               transId;
762 CkwUeInfo         *ueInfo;
763 CkwUeInfo         *newUeInfo;
764 #endif
765 {
766     S16    ret1;
767     Buffer *mBuf = NULLP;
768
769     TRC3(cmPkCkwUeIdChgReq)
770
771     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
772     {
773 #if (ERRCLASS & ERRCLS_ADD_RES)
774        if(ret1 != ROK)
775        {
776           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
777                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
778                (ErrVal)ECKW018, (ErrVal)0, "SGetMsg() failed");
779        }
780 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
781
782        RETVALUE(ret1);
783     }
784
785     CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
786     if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo,
787              sizeof(CkwUeInfo)) != ROK)
788     {
789        SPutMsg(mBuf);
790        RETVALUE(RFAILED);
791     }
792     CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
793     if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
794              sizeof(CkwUeInfo)) != ROK)
795     {
796        SPutMsg(mBuf);
797        RETVALUE(RFAILED);
798     }
799     CMCHKPKLOG(SPkU32, transId, mBuf, ECKW019, pst);
800     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW020, pst);
801     pst->event = (Event) CKW_EVT_UEIDCHG_REQ;
802
803     RETVALUE(SPstTsk(pst, mBuf));
804
805 } /* cmPkCkwUeIdChgReq */
806
807 /*
808 *
809 *    Fun:    cmPkCkwUeIdChgCfm
810 *
811 *    Desc:   pack the primitive KwUiCkwUeIdChgCfm
812 *
813 *    Ret:    ROK  -ok
814 *
815 *    Notes:  None
816 *
817 *    File:   ckw.c
818 *
819 */
820 #ifdef ANSI
821 PUBLIC S16 cmPkCkwUeIdChgCfm
822 (
823 Pst               *pst,
824 SuId              suId,
825 U32               transId,
826 CkwUeInfo         *ueInfo,
827 CmStatus          status
828 )
829 #else
830 PUBLIC S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
831 Pst               *pst;
832 SuId              suId;
833 U32               transId;
834 CkwUeInfo         *ueInfo;
835 CmStatus          status;
836 #endif
837 {
838     S16    ret1;
839     Buffer *mBuf = NULLP;
840
841     TRC3(cmPkCkwUeIdChgCfm)
842
843     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
844     {
845 #if (ERRCLASS & ERRCLS_ADD_RES)
846        if(ret1 != ROK)
847        {
848           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
849                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
850                (ErrVal)ECKW021, (ErrVal)0, "SGetMsg() failed");
851        }
852 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
853
854        RETVALUE(ret1);
855     }
856     
857     CMCHKPK(cmPkCmStatus, &status, mBuf); 
858     CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
859     if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
860              sizeof(CkwUeInfo)) != ROK)
861     {
862        SPutMsg(mBuf);
863        RETVALUE(RFAILED);
864     }
865     CMCHKPKLOG(SPkU32, transId, mBuf, ECKW022, pst);
866     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW023, pst);
867     pst->event = (Event) CKW_EVT_UEIDCHG_CFM;
868
869     RETVALUE(SPstTsk(pst, mBuf));
870
871 } /* cmPkCkwUeIdChgCfm */
872
873
874 /******************************************************************************
875  *                            UNPACK FUNCTIONS
876  *****************************************************************************/
877 \f
878 /*
879 *
880 *    Fun:    cmUnpkCkwBndReq
881 *
882 *    Desc:    unpack the primitive CkwBndReq
883 *
884 *    Ret:    ROK  -ok
885 *
886 *    Notes:    None
887 *
888 *    File:     ckw.c
889 *
890 */
891 #ifdef ANSI
892 PUBLIC S16 cmUnpkCkwBndReq
893 (
894 CkwBndReq      func,
895 Pst            *pst,
896 Buffer         *mBuf
897 )
898 #else
899 PUBLIC S16 cmUnpkCkwBndReq(func, pst, mBuf)
900 CkwBndReq      func;
901 Pst            *pst;
902 Buffer         *mBuf;
903 #endif
904 {
905     SuId       suId = 0;
906     SpId       spId = 0;
907     
908     TRC3(cmUnpkCkwBndReq)
909
910     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW024, pst);
911     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
912     SPutMsg(mBuf);
913
914     RETVALUE((*func)(pst, suId, spId));
915 } /*end of function cmUnpkCkwBndReq*/
916 \f
917 /*
918 *
919 *    Fun:    cmUnpkCkwUbndReq
920 *
921 *    Desc:    unpack the primitive CkwUbndReq
922 *
923 *    Ret:    ROK  -ok
924 *
925 *    Notes:    None
926 *
927 *    File:     ckw.c
928 *
929 */
930 #ifdef ANSI
931 PUBLIC S16 cmUnpkCkwUbndReq
932 (
933 CkwUbndReq     func,
934 Pst            *pst,
935 Buffer         *mBuf
936 )
937 #else
938 PUBLIC S16 cmUnpkCkwUbndReq(func, pst, mBuf)
939 CkwUbndReq     func;
940 Pst            *pst;
941 Buffer         *mBuf;
942 #endif
943 {
944     SpId       spId = 0;
945     Reason     reason = 0;
946     
947     TRC3(cmUnpkCkwUbndReq)
948
949     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW026, pst);
950     CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, ECKW027, pst);
951     SPutMsg(mBuf);
952     RETVALUE((*func)(pst, spId, reason));
953 } /*end of function cmUnpkCkwUbndReq*/
954 \f
955 /*
956 *
957 *    Fun:    cmUnpkCkwBndCfm
958 *
959 *    Desc:    unpack the primitive CkwBndCfm
960 *
961 *    Ret:    ROK  -ok
962 *
963 *    Notes:    None
964 *
965 *    File:     ckw.c
966 *
967 */
968 #ifdef ANSI
969 PUBLIC S16 cmUnpkCkwBndCfm
970 (
971 CkwBndCfm      func,
972 Pst            *pst,
973 Buffer         *mBuf
974 )
975 #else
976 PUBLIC S16 cmUnpkCkwBndCfm(func, pst, mBuf)
977 CkwBndCfm      func;
978 Pst            *pst;
979 Buffer         *mBuf;
980 #endif
981 {
982     SuId       suId = 0;
983     U8         status = 0;
984     
985     TRC3(cmUnpkCkwBndCfm)
986
987     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
988     CMCHKUNPKLOG(SUnpkU8, &status, mBuf, ECKW029, pst);
989     SPutMsg(mBuf);
990
991     RETVALUE((*func)(pst, suId, status));
992 } /*end of function cmUnpkCkwBndCfm*/
993
994 \f
995 /*
996 *
997 *    Fun:    cmUnpkCkwTmInfo
998 *
999 *    Desc:    pack the structure CkwTmInfo
1000 *
1001 *    Ret:    ROK  -ok
1002 *
1003 *    Notes:    None
1004 *
1005 *    File:     ckw.c
1006 *
1007 */
1008 #ifdef ANSI
1009 PUBLIC S16 cmUnpkCkwTmInfo
1010 (
1011 CkwTmInfo      *param,
1012 Buffer         *mBuf
1013 )
1014 #else
1015 PUBLIC S16 cmUnpkCkwTmInfo(param, mBuf)
1016 CkwTmInfo      *param;
1017 Buffer         *mBuf;
1018 #endif
1019 {
1020     TRC3(cmUnpkCkwTmInfo)
1021
1022     CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
1023
1024     RETVALUE(ROK);
1025 } /* cmUnpkCkwTmInfo */
1026
1027 \f
1028 /*
1029 *
1030 *    Fun:    cmUnpkCkwUmInfo
1031 *
1032 *    Desc:    pack the structure CkwUmInfo
1033 *
1034 *    Ret:    ROK  -ok
1035 *
1036 *    Notes:    None
1037 *
1038 *    File:     ckw.c
1039 *
1040 */
1041 #ifdef ANSI
1042 PUBLIC S16 cmUnpkCkwUmInfo
1043 (
1044 CkwEntCfgInfo  *param,
1045 Buffer         *mBuf
1046 )
1047 #else
1048 PUBLIC S16 cmUnpkCkwUmInfo(param, mBuf)
1049 CkwEntCfgInfo  *param;
1050 Buffer         *mBuf;
1051 #endif
1052 {
1053     TRC3(cmUnpkCkwUmInfo)
1054
1055     switch(param->dir)
1056     {
1057        case CKW_CFG_DIR_DL:
1058           {
1059              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1060              break;
1061           }
1062        case CKW_CFG_DIR_UL:
1063           {
1064              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1065              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1066              break;
1067           }
1068        /* Patch ckw_c_001.main_3 */
1069        case CKW_CFG_DIR_BOTH:
1070           {
1071              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1072              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1073              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1074              break;
1075           }
1076     }
1077
1078     RETVALUE(ROK);
1079 } /* cmUnpkCkwUmInfo */
1080
1081 \f
1082 /*
1083 *
1084 *    Fun:    cmUnpkCkwAmInfo
1085 *
1086 *    Desc:    pack the structure CkwAmInfo
1087 *
1088 *    Ret:    ROK  -ok
1089 *
1090 *    Notes:    None
1091 *
1092 *    File:     ckw.c
1093 *
1094 */
1095 #ifdef ANSI
1096 PUBLIC S16 cmUnpkCkwAmInfo
1097 (
1098 CkwAmInfo      *param,
1099 Buffer         *mBuf
1100 )
1101 #else
1102 PUBLIC S16 cmUnpkCkwAmInfo(param, mBuf)
1103 CkwAmInfo      *param;
1104 Buffer         *mBuf;
1105 #endif
1106 {
1107     TRC3(cmUnpkCkwAmInfo)
1108
1109     /* DOWN LINK */
1110     CMCHKUNPK(SUnpkU8, &(param->dl.snLen), mBuf);
1111     CMCHKUNPK(SUnpkU16, &(param->dl.pollRetxTmr), mBuf);
1112     CMCHKUNPK(SUnpkS16, &(param->dl.pollPdu), mBuf);
1113     CMCHKUNPK(SUnpkS32, &(param->dl.pollByte), mBuf);
1114     CMCHKUNPK(SUnpkU8, &(param->dl.maxRetx), mBuf);
1115
1116     /* UP LINK */
1117     CMCHKUNPK(SUnpkU8, &(param->ul.snLen), mBuf);
1118     CMCHKUNPK(SUnpkU16, &(param->ul.staProhTmr), mBuf);
1119     CMCHKUNPK(SUnpkU8, &(param->ul.reOrdTmr), mBuf);
1120
1121     RETVALUE(ROK);
1122 } /* cmUnpkCkwAmInfo */
1123
1124 \f
1125 /*
1126 *
1127 *    Fun:    cmUnpkCkwLChInfo
1128 *
1129 *    Desc:    pack the structure CkwLChInfo
1130 *
1131 *    Ret:    ROK  -ok
1132 *
1133 *    Notes:    None
1134 *
1135 *    File:     ckw.c
1136 *
1137 */
1138 #ifdef ANSI
1139 PUBLIC S16 cmUnpkCkwLChInfo
1140 (
1141 CkwLChInfo     *param,
1142 Buffer         *mBuf
1143 )
1144 #else
1145 PUBLIC S16 cmUnpkCkwLChInfo(param, mBuf)
1146 CkwLChInfo     *param;
1147 Buffer         *mBuf;
1148 #endif
1149 {
1150     TRC3(cmUnpkCkwLChInfo)
1151
1152     CMCHKUNPK(SUnpkU8, &(param->lChId), mBuf);
1153     CMCHKUNPK(SUnpkU8, &(param->type), mBuf);
1154
1155     RETVALUE(ROK);
1156 } /* cmUnpkCkwLChInfo */
1157
1158 \f
1159 /*
1160 *
1161 *    Fun:    cmUnpkCkwEntCfgCfmInfo
1162 *
1163 *    Desc:    unpack the structure CkwEntCfgInfo
1164 *
1165 *    Ret:    ROK  -ok
1166 *
1167 *    Notes:    None
1168 *
1169 *    File:     ckw.c
1170 *
1171 */
1172 #ifdef ANSI
1173 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo
1174 (
1175 CkwEntCfgCfmInfo  *param,
1176 Buffer            *mBuf
1177 )
1178 #else
1179 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo(param, mBuf)
1180 CkwEntCfgCfmInfo  *param;
1181 Buffer            *mBuf;
1182 #endif
1183 {
1184     TRC3(cmUnpkCkwEntCfgCfmInfo)
1185
1186     CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1187     CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1188     CMCHKUNPK(cmUnpkCmStatus, &(param->status), mBuf);
1189
1190     RETVALUE(ROK);
1191 } /* cmUnpkCkwEntCfgCfmInfo */
1192
1193 \f
1194 /*
1195 *
1196 *    Fun:    cmUnpkCkwCfgCfmInfo
1197 *
1198 *    Desc:    pack the structure CkwCfgCfmInfo
1199 *
1200 *    Ret:    ROK  -ok
1201 *
1202 *    Notes:    None
1203 *
1204 *    File:     ckw.c
1205 *
1206 */
1207 #ifdef ANSI
1208 PUBLIC S16 cmUnpkCkwCfgCfmInfo
1209 (
1210 CkwCfgCfmInfo  *param,
1211 Pst            *pst,
1212 Buffer         *mBuf
1213 )
1214 #else
1215 PUBLIC S16 cmUnpkCkwCfgCfmInfo(param, pst, mBuf)
1216 CkwCfgCfmInfo  *param;
1217 Pst            *pst;
1218 Buffer         *mBuf;
1219 #endif
1220 {
1221     U8         idx;
1222
1223     TRC3(cmUnpkCkwCfgCfmInfo)
1224
1225     CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW030, pst);
1226     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1227     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1228     CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1229
1230     for (idx = 0; idx < param->numEnt; idx++)
1231     {
1232        CMCHKUNPK(cmUnpkCkwEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
1233     }
1234
1235     RETVALUE(ROK);
1236 } /* cmUnpkCkwCfgCfmInfo */
1237
1238 \f
1239 /*
1240 *
1241 *    Fun:    cmUnpkCkwEntCfgInfo
1242 *
1243 *    Desc:    pack the structure CkwEntCfgCfmInfo
1244 *
1245 *    Ret:    ROK  -ok
1246 *
1247 *    Notes:    None
1248 *
1249 *    File:     ckw.c
1250 *
1251 */
1252 #ifdef ANSI
1253 PUBLIC S16 cmUnpkCkwEntCfgInfo
1254 (
1255 CkwEntCfgInfo  *param,
1256 Buffer         *mBuf
1257 )
1258 #else
1259 PUBLIC S16 cmUnpkCkwEntCfgInfo(param, mBuf)
1260 CkwEntCfgInfo  *param;
1261 Buffer         *mBuf;
1262 #endif
1263 {
1264     TRC3(cmUnpkCkwEntCfgInfo)
1265
1266     CMCHKUNPK(SUnpkU8, &(param->cfgType), mBuf);
1267     CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1268     CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1269     CMCHKUNPK(SUnpkU8, &(param->qci), mBuf);
1270     CMCHKUNPK(cmUnpkLteRlcMode, &(param->entMode), mBuf);
1271     CMCHKUNPK(SUnpkU8, &(param->dir), mBuf);
1272     CMCHKUNPK(SUnpkS16, &(param->discardTmr), mBuf);
1273 #ifdef TENB_MULT_CELL_SUPPRT
1274     CMCHKUNPK(SUnpkS16, &(param->rguSapId), mBuf);
1275 #endif
1276
1277     /* Logical Channel Information */
1278     switch(param->entMode)
1279     {
1280        case CM_LTE_MODE_TM:
1281           {
1282              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1283              break;
1284           }
1285        /* ccpu00128195: Unpacking lCh[0] and lCh[1] for UM bearer as well */
1286        case CM_LTE_MODE_UM:
1287        case CM_LTE_MODE_AM:
1288           {
1289              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1290              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[1]), mBuf);
1291              break;
1292           }
1293     }
1294
1295     /* TM/UM/AM Info */
1296     switch(param->entMode)
1297     {
1298        case CM_LTE_MODE_TM:
1299           {
1300              CMCHKUNPK(cmUnpkCkwTmInfo, &(param->m.tmInfo), mBuf);
1301              break;
1302           }
1303        case CM_LTE_MODE_UM:
1304           {
1305              CMCHKUNPK(cmUnpkCkwUmInfo, param, mBuf);
1306              break;
1307           }
1308        case CM_LTE_MODE_AM:
1309           {
1310              CMCHKUNPK(cmUnpkCkwAmInfo, &(param->m.amInfo), mBuf);
1311              break;
1312           }
1313     }
1314
1315     RETVALUE(ROK);
1316 } /* cmUnpkCkwEntCfgInfo */
1317
1318 \f
1319 /*
1320 *
1321 *    Fun:    cmUnpkCkwCfgInfo
1322 *
1323 *    Desc:    unpack the structure CkwCfgInfo
1324 *
1325 *    Ret:    ROK  -ok
1326 *
1327 *    Notes:    None
1328 *
1329 *    File:     ckw.c
1330 *
1331 */
1332 #ifdef ANSI
1333 PUBLIC S16 cmUnpkCkwCfgInfo
1334 (
1335 CkwCfgInfo     *param,
1336 Pst            *pst,
1337 Buffer         *mBuf
1338 )
1339 #else
1340 PUBLIC S16 cmUnpkCkwCfgInfo(param, pst, mBuf)
1341 CkwCfgInfo     *param;
1342 Pst            *pst;
1343 Buffer         *mBuf;
1344 #endif
1345 {
1346     U8         idx;
1347
1348     TRC3(cmUnpkCkwCfgInfo)
1349
1350     CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW031, pst);
1351     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1352     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1353     CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1354
1355     for (idx = 0; idx < param->numEnt; idx++)
1356     {
1357        CMCHKUNPKLOG(cmUnpkCkwEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
1358     }
1359
1360     RETVALUE(ROK);
1361 } /* cmUnpkCkwCfgInfo */
1362
1363 \f
1364 /*
1365 *
1366 *    Fun:    unpackUeCreateReq
1367 *
1368 *    Desc:    unpack the primitive UE create request
1369 *
1370 *    Ret:    ROK  -ok
1371 *
1372 *    Notes:    None
1373 *
1374 *    File:     ckw.c
1375 *
1376 */
1377 #ifdef ANSI
1378 PUBLIC S16 unpackUeCreateReq
1379 (
1380 CkwCfgReq         func,
1381 Pst               *pst,
1382 Buffer            *mBuf
1383 )
1384 #else
1385 PUBLIC S16 cmUnpkCkwCfgReq(func, pst, mBuf)
1386 CkwCfgReq         func;
1387 Pst               *pst;
1388 Buffer            *mBuf;
1389 #endif
1390 {
1391     S16 ret1;
1392     CkwCfgInfo    *cfgInfo = NULLP;
1393     
1394     TRC3(unpackUeCreateReq)
1395
1396     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgInfo,\
1397                 sizeof(CkwCfgInfo))) != ROK)
1398     {
1399 #if (ERRCLASS & ERRCLS_ADD_RES)
1400       /*MBUF_FIXX*/
1401           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1402                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1403                (ErrVal)ECKW033, (ErrVal)0, "SGetMsg() failed");
1404       
1405 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1406        RETVALUE(ret1);
1407     }
1408
1409     switch(pst->selector)
1410     {
1411        case ODU_SELECTOR_LWLC:
1412           {
1413              CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgInfo, mBuf); 
1414              break;
1415           }
1416     }
1417     SPutMsg(mBuf);
1418
1419     RETVALUE((*func)(pst, cfgInfo));
1420 } /* cmUnpkCkwCfgReq */
1421
1422 \f
1423 /*
1424 *
1425 *    Fun:    cmUnpkCkwCfgCfm
1426 *
1427 *    Desc:    unpack the primitive KwUiCkwCfgCfm
1428 *
1429 *    Ret:    ROK  -ok
1430 *
1431 *    Notes:    None
1432 *
1433 *    File:     ckw.c
1434 *
1435 */
1436 #ifdef ANSI
1437 PUBLIC S16 cmUnpkCkwCfgCfm
1438 (
1439 CkwCfgCfm         func,
1440 Pst               *pst,
1441 Buffer            *mBuf
1442 )
1443 #else
1444 PUBLIC S16 cmUnpkCkwCfgCfm(func, pst, mBuf)
1445 CkwCfgCfm         func;
1446 Pst               *pst;
1447 Buffer            *mBuf;
1448 #endif
1449 {
1450     S16 ret1;
1451     SuId             suId = 0;
1452     CkwCfgCfmInfo    *cfgCfmInfo = NULLP;
1453     
1454     TRC3(cmUnpkCkwCfgCfm)
1455
1456     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
1457                 sizeof(CkwCfgCfmInfo))) != ROK)
1458     {
1459 #if (ERRCLASS & ERRCLS_ADD_RES)
1460        if(ret1 != ROK)
1461        {
1462           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1463                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1464                (ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
1465        }
1466 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1467        RETVALUE(ret1);
1468     }
1469
1470     cmMemset((U8 *)cfgCfmInfo, 0, sizeof(CkwCfgCfmInfo));
1471
1472     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1473
1474     switch(pst->selector)
1475     {
1476 #ifdef LCCKW
1477        case ODU_SELECTOR_LC:
1478        {
1479           ret1 = cmUnpkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
1480 #if(ERRCLASS & ERRCLS_DEBUG)
1481           if(ret1 != ROK)
1482           {
1483              SPutMsg(mBuf);
1484              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1485                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1486                   (ErrVal)ECKW036, (ErrVal)ret1, "Unpacking failure");
1487              RETVALUE( ret1 );
1488           }
1489 #endif /* ERRCLASS & ERRCLS_DEBUG */
1490           break;
1491        }
1492 #endif /* LCCKW */
1493     }
1494     SPutMsg(mBuf);
1495
1496     RETVALUE((*func)(pst, suId, cfgCfmInfo));
1497 } /* cmUnpkCkwCfgCfm */
1498
1499 /*
1500 *
1501 *    Fun:    cmUnpkCkwUeInfo
1502 *
1503 *    Desc:   Unpack the primitive KwUiCkwUeInfo
1504 *
1505 *    Ret:    ROK  -ok
1506 *
1507 *    Notes:  None
1508 *
1509 *    File:   ckw.c
1510 *
1511 */
1512 #ifdef ANSI
1513 PUBLIC S16 cmUnpkCkwUeInfo
1514 (
1515 CkwUeInfo *param,
1516 Buffer    *mBuf
1517 )
1518 #else
1519 PUBLIC S16 cmUnpkCkwUeInfo(param, mBuf)
1520 CkwUeInfo *param;
1521 Buffer    *mBuf;
1522 #endif
1523 {
1524    TRC2(cmUnpkCkwUeInfo)
1525
1526    CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1527    CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1528
1529    RETVALUE(ROK);
1530 }
1531
1532 /*
1533 *
1534 *    Fun:    cmUnpkCkwUeIdChgReq
1535 *
1536 *    Desc:    unpack the primitive KwUiCkwUeIdChgReq
1537 *
1538 *    Ret:    ROK  -ok
1539 *
1540 *    Notes:    None
1541 *
1542 *    File:     ckw.c
1543 *
1544 */
1545 #ifdef ANSI
1546 PUBLIC S16 cmUnpkCkwUeIdChgReq
1547 (
1548 CkwUeIdChgReq     func,
1549 Pst               *pst,
1550 Buffer            *mBuf
1551 )
1552 #else
1553 PUBLIC S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
1554 CkwUeIdChgReq     func;
1555 Pst               *pst;
1556 Buffer            *mBuf;
1557 #endif
1558 {
1559     S16       ret1;
1560     SpId      spId = 0;
1561     U32       transId = 0;
1562     CkwUeInfo *ueInfo = NULLP;
1563     CkwUeInfo *newUeInfo = NULLP;
1564     
1565     TRC3(cmUnpkCkwUeIdChgReq)
1566
1567
1568     CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1569     CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW037, pst);
1570
1571     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1572                 sizeof(CkwUeInfo))) != ROK)
1573     {
1574 #if (ERRCLASS & ERRCLS_ADD_RES)
1575       /*MBUF_FIXX*/
1576           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1577                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1578                (ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
1579       
1580 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1581        RETVALUE(ret1);
1582     }
1583
1584     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1585
1586     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1587 #if(ERRCLASS & ERRCLS_DEBUG)
1588     if(ret1 != ROK)
1589     {
1590        SPutMsg(mBuf);
1591        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1592              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1593              (ErrVal)ECKW039, (ErrVal)ret1, "Unpacking failure");
1594        RETVALUE( ret1 );
1595     }
1596 #endif /* ERRCLASS & ERRCLS_DEBUG */
1597
1598     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo,\
1599                 sizeof(CkwUeInfo))) != ROK)
1600     {
1601 #if (ERRCLASS & ERRCLS_ADD_RES)
1602        /*MBUF_FIXX*/
1603           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1604                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1605                (ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
1606        
1607 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1608        RETVALUE(ret1);
1609     }
1610
1611     cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
1612
1613     ret1 = cmUnpkCkwUeInfo((newUeInfo), mBuf);
1614 #if(ERRCLASS & ERRCLS_DEBUG)
1615     if(ret1 != ROK)
1616     {
1617        SPutMsg(mBuf);
1618        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1619              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1620              (ErrVal)ECKW041, (ErrVal)ret1, "Unpacking failure");
1621        RETVALUE( ret1 );
1622     }
1623 #endif /* ERRCLASS & ERRCLS_DEBUG */
1624
1625     SPutMsg(mBuf);
1626
1627     RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
1628
1629 } /* cmUnpkCkwUeIdChgReq */
1630
1631 /*
1632 *
1633 *    Fun:     cmUnpkCkwUeIdChgCfm
1634 *
1635 *    Desc:    unpack the primitive KwUiCkwUeIdChgCfm
1636 *
1637 *    Ret:     ROK  -ok
1638 *
1639 *    Notes:   None
1640 *
1641 *    File:    ckw.c
1642 *
1643 */
1644 #ifdef ANSI
1645 PUBLIC S16 cmUnpkCkwUeIdChgCfm
1646 (
1647 CkwUeIdChgCfm     func,
1648 Pst               *pst,
1649 Buffer            *mBuf
1650 )
1651 #else
1652 PUBLIC S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
1653 CkwUeIdChgCfm     func;
1654 Pst               *pst;
1655 Buffer            *mBuf;
1656 #endif
1657 {
1658     S16       ret1;
1659     SuId      suId = 0;
1660     U32       transId = 0;
1661     CkwUeInfo *ueInfo = NULLP;
1662     CmStatus  status;
1663     
1664     TRC3(cmUnpkCkwUeIdChgCfm)
1665
1666     cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
1667
1668     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1669     CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW042, pst);
1670
1671     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1672                 sizeof(CkwUeInfo))) != ROK)
1673     {
1674 #if (ERRCLASS & ERRCLS_ADD_RES)
1675        if(ret1 != ROK)
1676        {
1677           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1678                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1679                (ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
1680        }
1681 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1682        RETVALUE(ret1);
1683     }
1684
1685     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1686
1687     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1688 #if(ERRCLASS & ERRCLS_DEBUG)
1689     if(ret1 != ROK)
1690     {
1691        SPutMsg(mBuf);
1692        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1693              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1694              (ErrVal)ECKW044, (ErrVal)ret1, "Unpacking failure");
1695        RETVALUE( ret1 );
1696     }
1697 #endif /* ERRCLASS & ERRCLS_DEBUG */
1698
1699     CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
1700
1701     SPutMsg(mBuf);
1702
1703     RETVALUE((*func)(pst, suId, transId, ueInfo, status));
1704
1705 } /* cmUnpkCkwUeIdChgCfm */
1706
1707 #endif /* LCCKW */
1708 #ifdef __cplusplus
1709 }
1710 #endif /* __cplusplus */
1711
1712 \f  
1713 /**********************************************************************
1714          End of file
1715 **********************************************************************/