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