Docs and build updates along with prachCfgTableIdx completion
[o-du/l2.git] / src / cm / lkw.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 \f
19 /********************************************************************20**
20   
21         Name:     LTE-RLC Layer 
22     
23         Type:     C source file
24   
25         Desc:     C Source code for common packing and unpacking functions
26                   for RLC Layer Manager Interfaces.  It contains the 
27                   following function definitions
28
29                      -- cmPkLkwCfgReq
30                      -- cmPkLkwCntrlReq
31                      -- cmPkLkwCntrlCfm 
32                      -- cmPkLkwCfgCfm
33                      -- cmPkLkwStaInd
34
35                      -- cmUnpkLkwCfgReq 
36                      -- cmUnpkLkwCntrlReq
37                      -- cmUnpkLkwCntrlCfm
38                      -- cmUnpkLkwCfgCfm 
39                      -- cmUnpkLkwStaInd
40  
41         File:     lkw.c
42
43 *********************************************************************21*/
44  
45 \f  
46 /* header include files (.h) */
47   
48 #include "envopt.h"             /* environment options */
49 #include "envdep.h"             /* environment dependent */
50 #include "envind.h"             /* environment independent */
51
52 #include "gen.h"                /* general */
53 #include "ssi.h"                /* system services interface */
54 #include "cm_lte.h"                /* layer manager */
55 #include "lkw.h"                /* Layer manager */
56
57 /* header/extern include files (.x) */
58
59 #include "gen.x"                /* general */
60 #include "ssi.x"                /* system services interface */
61 #include "cm_lib.x"             /* common library header file */
62 #include "cm_lte.x"                /* layer manager */
63 #include "lkw.x"                /* layer manager */
64
65 #ifdef LCLKW
66
67 Txt ptNmb[LKW_PART_NUM_STR_LEN];         /* Part number */
68
69 \f  
70 /* forward references */
71
72 PRIVATE S16 cmPkKwMngmt ARGS ((KwMngmt *param ,Event eventType, 
73                                Buffer *mBuf));
74 PRIVATE S16 cmPkKwCfg ARGS ((KwMngmt *param ,Elmnt elmnt, Buffer *mBuf));
75 PRIVATE S16 cmPkKwCntrl ARGS ((KwMngmt *cntrl, Elmnt elmnt, Buffer *mBuf));
76 PRIVATE S16 cmPkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
77 PRIVATE S16 cmPkKwSsta ARGS ((KwMngmt *ssta, Elmnt etmnt, Event eventType,
78                               Buffer *mBuf));
79 PRIVATE S16 cmPkKwSts ARGS ((KwMngmt *sts, Elmnt elmnt, Buffer *mBuf));
80 PRIVATE S16 cmPkGenSts ARGS ((KwGenSts *gen, Buffer *mBuf));
81 PRIVATE S16 cmPkCkwSapSts ARGS ((KwCkwCntSts *rcSap, Buffer *mBuf));
82 PRIVATE S16 cmPkKwuSapSts ARGS ((KwKwuSapSts *ruSap, Buffer *mBuf));
83 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
84  * in general statstics.
85  * */
86 PRIVATE S16 cmPkKwTrc ARGS ((KwMngmt *trc, Buffer *mBuf));
87
88 PRIVATE S16 cmUnpkKwMngmt ARGS ((KwMngmt *param, Event eventType,
89                                  Buffer * mBuf));
90 PRIVATE S16 cmUnpkKwCfg ARGS ((KwMngmt *cfg, Elmnt elmnt, Buffer *mBuf));
91 PRIVATE S16 cmUnpkKwCntrl ARGS ((KwMngmt *param, Elmnt elmnt, Buffer *mBuf));
92 PRIVATE S16 cmUnpkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
93 PRIVATE S16 cmUnpkKwSsta ARGS ((KwMngmt *ssta, Elmnt elmnt, Event eventType,
94                                 Buffer *mBuf));
95 PRIVATE S16 cmUnpkKwSts ARGS ((KwMngmt *sts, Elmnt elmnt, Buffer *mBuf));
96 PRIVATE S16 cmUnpkGenSts ARGS ((KwGenSts *gen, Buffer *mBuf));
97 PRIVATE S16 cmUnpkCkwSapSts ARGS ((KwCkwCntSts *rcSap, Buffer *mBuf));
98 PRIVATE S16 cmUnpkKwuSapSts ARGS ((KwKwuSapSts *ruSap, Buffer *mBuf));
99 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
100  * in general statstics.
101  * */
102 PRIVATE S16 cmUnpkKwTrc ARGS ((KwMngmt *trc, Buffer *mBuf));
103
104
105 PRIVATE S16 cmPkCkwSapSta ARGS ((KwCkwCntSapSta *rcSap, Buffer *mBuf));
106 PRIVATE S16 cmUnpkCkwSapSta ARGS ((KwCkwCntSapSta *rcSap, Buffer *mBuf));
107
108 PRIVATE S16 cmPkKwuSapSta ARGS ((KwKwuSapSta *rlSap, Buffer *mBuf));
109 PRIVATE S16 cmUnpkKwuSapSta ARGS ((KwKwuSapSta *rlSap, Buffer *mBuf));
110
111 PRIVATE S16 cmPkRguSapSta ARGS ((KwRguSapSta *mkSap, Buffer *mBuf));
112 PRIVATE S16 cmUnpkRguSapSta ARGS ((KwRguSapSta *mkSap, Buffer *mBuf));
113
114 /**
115  * @brief
116      Pack Config Request
117  *
118  * @param[in] pst  : post structure 
119  * @param[in] cfg  : RLC LM structure 
120  *  @return  S16
121  *      -# Success : ROK 
122  *      -# Failure : RFAILED 
123  */
124
125 #ifdef ANSI
126 PUBLIC S16 cmPkLkwCfgReq
127 (
128 Pst *pst,                    /* post structure */
129 KwMngmt *cfg                 /* RLC LM structure */
130 )
131 #else
132 PUBLIC S16 cmPkLkwCfgReq(pst, cfg)
133 Pst *pst;                    /* post structure */
134 KwMngmt *cfg;                /* RLC LM structure */
135 #endif
136 {
137    Buffer *mBuf;             /* message buffer */
138    S16 ret1;                 /* return value */
139
140    TRC3(cmPkLkwCfgReq)
141
142    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
143    if (ret1 != ROK)
144    {
145 #if (ERRCLASS & ERRCLS_ADD_RES)
146        if(ret1 != ROK)
147        {
148           LKWLOGERROR(pst, ERRCLS_ADD_RES, ELKW001, (ErrVal) ret1,
149              "SGetMsg failed ...!\n");
150        }
151 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
152       RETVALUE(ret1);
153    }
154
155    ret1 = cmPkKwMngmt(cfg, LKW_EVT_CFG_REQ, mBuf);
156
157    if(ret1 != ROK)
158    {
159       SPutMsg(mBuf);
160 #if (ERRCLASS & ERRCLS_ADD_RES)
161        if(ret1 != ROK)
162        {
163           LKWLOGERROR(pst, ERRCLS_ADD_RES, ELKW002, (ErrVal) ret1,
164                "cmPkKwMngmt failure ......!");
165        }
166 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
167       RETVALUE(RFAILED);
168    }
169
170    pst->event = (Event) LKW_EVT_CFG_REQ;   /* event */
171    SPstTsk(pst, mBuf);
172
173    RETVALUE(ROK);
174
175 }  /* end of cmPkLkwCfgReq */
176
177 /**
178  * @brief
179      Unpack Config Request
180  *
181  * @param[in] func  : primitive to call
182  * @param[in] pst   : post structure
183  * @param[in] mBuf  : message buffer
184  *  @return  S16
185  *      -# Success : ROK
186  *      -# Failure : RFAILED
187  */
188  
189 #ifdef ANSI
190 PUBLIC S16 cmUnpkLkwCfgReq
191 (
192 LkwCfgReq func,              /* primitive to call */
193 Pst *pst,                    /* post structure */
194 Buffer *mBuf                 /* message buffer */
195 )
196 #else
197 PUBLIC S16 cmUnpkLkwCfgReq(func, pst, mBuf)
198 LkwCfgReq func;              /* primitive to call */
199 Pst *pst;                    /* post structure */
200 Buffer *mBuf;                /* message buffer */
201 #endif
202 {
203    S16 ret1;                 /* Return value */
204    KwMngmt cfg;              /* RLC LM structure */
205
206    TRC3(cmUnpkLkwCfgReq)
207
208    cmMemset((U8 *) &cfg, (U8) 0, (S16) sizeof(KwMngmt));
209    ret1 = cmUnpkKwMngmt(&cfg, LKW_EVT_CFG_REQ, mBuf);
210
211     if(ret1 != ROK)
212     {
213        SPutMsg(mBuf);
214 #if (ERRCLASS & ERRCLS_DEBUG)
215       /*MBUF_FIXX*/
216           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW003, (ErrVal) ret1,
217                "cmUnpkKwMngmt failure ......!");
218       
219 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
220        RETVALUE(RFAILED);
221     }
222
223    SPutMsg(mBuf);
224    (Void) (*func)(pst, &cfg);
225
226    RETVALUE(ROK);
227
228 } /* end of cmUnpkLkwCfgReq */
229
230
231
232 /**
233  * @brief
234      Pack Control Request
235  *
236  * @param[in] pst  : post structure
237  * @param[in] cntrl  : RLC LM structure
238  *  @return  S16
239  *      -# Success : ROK
240  *      -# Failure : RFAILED
241  */
242
243 #ifdef ANSI
244 PUBLIC S16 cmPkLkwCntrlReq
245 (
246 Pst *pst,                    /* post structure */
247 KwMngmt *cntrl               /* RLC LM structure */  
248 )
249 #else
250 PUBLIC S16 cmPkLkwCntrlReq(pst,cntrl)
251 Pst *pst;                    /* post structure */
252 KwMngmt *cntrl;              /* RLC LM structure */
253 #endif
254 {
255    Buffer *mBuf;             /* message buffer */
256    S16 ret1;                 /* return value */
257
258    TRC3(cmPkLkwCntrlReq)
259
260    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
261    if (ret1 != ROK)
262    {
263 #if (ERRCLASS & ERRCLS_ADD_RES)
264        if(ret1 != ROK)
265        {
266           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW004, (ErrVal) ret1,
267                "SGetMsg failure ......!");
268        }
269 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
270       RETVALUE(ret1);
271    }
272
273    ret1 = cmPkKwMngmt(cntrl, LKW_EVT_CNTRL_REQ, mBuf);
274
275    if(ret1 != ROK)
276    {
277       SPutMsg(mBuf);
278 #if (ERRCLASS & ERRCLS_ADD_RES)
279        if(ret1 != ROK)
280        {
281           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW005, (ErrVal) ret1,
282                "cmPkKwMngmt failure ......!");
283        }
284 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
285       RETVALUE(ret1);
286    }
287
288    pst->event = (Event) LKW_EVT_CNTRL_REQ;   /* event */
289    SPstTsk(pst, mBuf);
290
291    RETVALUE(ROK);
292
293 }  /* end of cmPkLkwCntrlReq */
294
295 /**
296  * @brief
297      Unpack Control Request
298  *
299  * @param[in] func  : primitive to call
300  * @param[in] pst   : post structure
301  * @param[in] mBuf  : message buffer
302  *  @return  S16
303  *      -# Success : ROK
304  *      -# Failure : RFAILED
305  */
306
307 #ifdef ANSI
308 PUBLIC S16 cmUnpkLkwCntrlReq
309 (
310 LkwCntrlReq func,            /* primitive to call */
311 Pst *pst,                    /* post structure */
312 Buffer *mBuf                 /* message buffer */
313 )
314 #else
315 PUBLIC S16 cmUnpkLkwCntrlReq(func, pst, mBuf)
316 LkwCntrlReq func;            /* primitive to call */
317 Pst *pst;                    /* post structure */
318 Buffer *mBuf;                /* message buffer */
319 #endif
320 {
321    S16 ret1;                 /* return value */
322    KwMngmt cfm;              /* Confirmation */
323
324    TRC3(cmUnpkLkwCntrlReq)
325
326    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CNTRL_REQ, mBuf);
327
328     if(ret1 != ROK)
329     {
330        SPutMsg(mBuf);
331 #if (ERRCLASS & ERRCLS_DEBUG)
332       /*MBUF_FIXX*/
333           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW006, (ErrVal) ret1,
334                "cmUnpkKwMngmt failure ......!");
335      
336 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
337        RETVALUE(RFAILED);
338     }
339
340    SPutMsg(mBuf);
341    RETVALUE((*func)(pst, &cfm));
342
343 } /* end of cmUnpkLkwCntrlReq */
344
345 /**
346  * @brief
347      Pack Control Confirm
348  *
349  * @param[in] pst  : post structure
350  * @param[in] cfg  : RLC LM structure
351  *  @return  S16
352  *      -# Success : ROK
353  *      -# Failure : RFAILED
354  */
355
356 #ifdef ANSI
357 PUBLIC S16 cmPkLkwCntrlCfm
358 (
359 Pst *pst,                    /* post structure */
360 KwMngmt *cfm                 /* RLC LM structure */
361 )
362 #else
363 PUBLIC S16 cmPkLkwCntrlCfm(pst, cfm)
364 Pst *pst;                    /* post structure */
365 KwMngmt *cfm;                /* RLC LM structure */
366 #endif
367 {
368    Buffer *mBuf;             /* message buffer */
369    S16 ret1;                 /* return value */
370
371    TRC3(cmPkLkwCntrlCfm)
372
373    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
374    if (ret1 != ROK)
375    {
376 #if (ERRCLASS & ERRCLS_ADD_RES)
377        if(ret1 != ROK)
378        {
379           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW007, (ErrVal) ret1,
380                "SGetMsg failure ......!");
381        }
382 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
383       RETVALUE(ret1);
384    }
385
386    ret1 = cmPkKwMngmt(cfm, LKW_EVT_CNTRL_CFM, mBuf);
387
388    if(ret1 != ROK)
389    {
390       SPutMsg(mBuf);
391 #if (ERRCLASS & ERRCLS_ADD_RES)
392        if(ret1 != ROK)
393        {
394           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW008, (ErrVal) ret1,
395                "Packing failure ......!");
396        }
397 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
398       RETVALUE(RFAILED);
399    }
400
401    pst->event = (Event) LKW_EVT_CNTRL_CFM;   /* event */
402    SPstTsk(pst, mBuf);
403
404    RETVALUE(ROK);
405
406 }  /* end of cmPkLkwCntrlCfm */
407
408
409 /**
410  * @brief
411      Unpack Control confirm
412  *
413  * @param[in] func  : primitive to call
414  * @param[in] pst   : post structure
415  * @param[in] mBuf  : message buffer
416  *  @return  S16
417  *      -# Success : ROK
418  *      -# Failure : RFAILED
419  */
420
421 #ifdef ANSI
422 PUBLIC S16 cmUnpkLkwCntrlCfm
423 (
424 LkwCntrlCfm func,            /* primitive to call */
425 Pst *pst,                    /* post structure */
426 Buffer *mBuf                 /* message buffer */
427 )
428 #else
429 PUBLIC S16 cmUnpkLkwCntrlCfm(func, pst, mBuf)
430 LkwCntrlCfm func;            /* primitive to call */
431 Pst *pst;                    /* post structure */
432 Buffer *mBuf;                /* message buffer */
433 #endif
434 {
435    KwMngmt cfm;              /* RLC LM structure */
436    S16 ret1;                 /* return value */
437
438    TRC3(cmUnpkLkwCntrlCfm)
439
440    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CNTRL_CFM, mBuf);
441
442    if(ret1 != ROK)
443    {
444       SPutMsg(mBuf);
445 #if (ERRCLASS & ERRCLS_DEBUG)
446        if(ret1 != ROK)
447        {
448           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW009, (ErrVal) ret1,
449                "cmUnpkKwMngmt failure ......!");
450        }
451 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
452       RETVALUE(RFAILED);
453    }
454       
455    SPutMsg(mBuf); 
456
457    RETVALUE((*func)(pst, &cfm));
458
459 } /* end of cmUnpkLkwCntrlCfm */
460
461 /**
462  * @brief
463      Unpack statistics Confirm
464  *
465  * @param[in] func  : primitive to call
466  * @param[in] pst   : post structure
467  * @param[in] mBuf  : message buffer
468  *  @return  S16
469  *      -# Success : ROK
470  *      -# Failure : RFAILED
471  */
472 #ifdef ANSI
473 PUBLIC S16 cmUnpkLkwStsCfm
474 (
475 LkwStsCfm func,              /* primitive to call */
476 Pst *pst,                    /* post structure */
477 Buffer *mBuf                 /* message buffer */
478 )
479 #else
480 PUBLIC S16 cmUnpkLkwStsCfm(func, pst, mBuf)
481 LkwStsCfm func;              /* primitive to call */
482 Pst *pst;                    /* post structure */
483 Buffer *mBuf;                /* message buffer */
484 #endif
485 {
486    KwMngmt cfm;              /* RLC LM structure */
487    S16 ret1;                 /* return value */
488
489    TRC3(cmUnpkLkwStsCfm)
490
491    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_STS_CFM, mBuf);
492
493    if(ret1 != ROK)
494    {
495       SPutMsg(mBuf);
496 #if (ERRCLASS & ERRCLS_DEBUG)
497        if(ret1 != ROK)
498        {
499           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW010, (ErrVal) ret1,
500                "SPutMsg failure ......!");
501        }
502 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
503       RETVALUE(RFAILED);
504    }
505      
506    SPutMsg(mBuf);
507
508    RETVALUE((*func)(pst, 0, &cfm));
509
510 } /* end of cmUnpkLkwStsCfm */
511
512 /**
513  * @brief
514      Pack Config Confirm 
515  *
516  * @param[in] pst  : post structure
517  * @param[in] cfg  : RLC LM structure
518  *  @return  S16
519  *      -# Success : ROK
520  *      -# Failure : RFAILED
521  */
522
523
524 #ifdef ANSI
525 PUBLIC S16 cmPkLkwCfgCfm
526 (
527 Pst *pst,                    /* post structure */
528 KwMngmt *cfm                 /* RLC LM structure */
529 )
530 #else
531 PUBLIC S16 cmPkLkwCfgCfm(pst,cfm)
532 Pst *pst;                    /* post structure */
533 KwMngmt *cfm;                /* RLC LM structure */
534 #endif
535 {
536    Buffer *mBuf;             /* message buffer */
537    S16 ret1;                 /* return value */
538
539    TRC3(cmPkLkwCfgCfm)
540
541    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
542    if (ret1 != ROK)
543    {
544 #if (ERRCLASS & ERRCLS_ADD_RES)
545        if(ret1 != ROK)
546        {
547           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW011, (ErrVal) ret1,
548                "SGetMsg failure ......!");
549        }
550 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
551       RETVALUE(ret1);
552    }
553
554    ret1 = cmPkKwMngmt(cfm, LKW_EVT_CFG_CFM, mBuf);
555
556    if(ret1 != ROK)
557    {
558       SPutMsg(mBuf);
559 #if (ERRCLASS & ERRCLS_ADD_RES)
560        if(ret1 != ROK)
561        {
562           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW012, (ErrVal) ret1,
563                "SPutMsg failure ......!");
564        }
565 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
566       RETVALUE(RFAILED);
567    }
568
569    pst->event = (Event) LKW_EVT_CFG_CFM;   /* event */
570    SPstTsk(pst, mBuf);
571
572    RETVALUE(ROK);
573
574 }  /* end of cmPkLkwCfgCfm */
575
576
577 /**
578  * @brief
579      Unpack Config Confirm 
580  *
581  * @param[in] func  : primitive to call
582  * @param[in] pst   : post structure
583  * @param[in] mBuf  : message buffer
584  *  @return  S16
585  *      -# Success : ROK
586  *      -# Failure : RFAILED
587  */
588 #ifdef ANSI
589 PUBLIC S16 cmUnpkLkwCfgCfm
590 (
591 LkwCfgCfm func,              /* primitive to call */
592 Pst *pst,                    /* post structure */
593 Buffer *mBuf                 /* message buffer */
594 )
595 #else
596 PUBLIC S16 cmUnpkLkwCfgCfm(func, pst, mBuf)
597 LkwCfgCfm func;              /* primitive to call */
598 Pst *pst;                    /* post structure */
599 Buffer *mBuf;                /* message buffer */
600 #endif
601 {
602    S16 ret1;                 /* return value */
603    KwMngmt cfm;              /* RLC LM structure */
604
605    TRC3(cmUnpkLkwCfgCfm)
606
607    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CFG_CFM, mBuf);
608
609    if(ret1 != ROK)
610    {
611       SPutMsg(mBuf);
612 #if (ERRCLASS & ERRCLS_DEBUG)
613        if(ret1 != ROK)
614        {
615           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW013, (ErrVal) ret1,
616                "SPutMsg failure ......!");
617        }
618 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
619       RETVALUE(RFAILED);
620    }
621
622    SPutMsg(mBuf);
623    RETVALUE((*func)(pst, &cfm));
624
625 } /* end of cmUnpkLkwCfgCfm */
626
627
628
629 /**
630  * @brief
631      Pack Status Indication 
632  *
633  * @param[in] pst  : post structure
634  * @param[in] usta  : RLC LM structure
635  *  @return  S16
636  *      -# Success : ROK
637  *      -# Failure : RFAILED
638  */
639
640 #ifdef ANSI
641 PUBLIC S16 cmPkLkwStaInd
642 (
643 Pst *pst,                    /* post structure */
644 KwMngmt *usta                /* RLC LM structure */
645 )
646 #else
647 PUBLIC S16 cmPkLkwStaInd(pst,usta)
648 Pst *pst;                    /* post structure */
649 KwMngmt *usta;               /* RLC LM structure */
650 #endif
651 {
652    Buffer *mBuf;             /* message buffer */
653    S16 ret1;                 /* return value */
654
655    TRC3(cmPkLkwStaInd)
656
657    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
658    if (ret1 != ROK)
659    {
660 #if (ERRCLASS & ERRCLS_ADD_RES)
661        if(ret1 != ROK)
662        {
663           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW014, (ErrVal) ret1,
664                "SGetMsg() failed");
665        }
666 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
667       RETVALUE(ret1);
668    }
669
670    ret1 = cmPkKwMngmt(usta, LKW_EVT_STA_IND, mBuf);
671
672    if(ret1 != ROK)
673    {
674       SPutMsg(mBuf);
675 #if (ERRCLASS & ERRCLS_ADD_RES)
676        if(ret1 != ROK)
677        {
678           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW015, (ErrVal) ret1,
679                "cmPkKwMngmt failure ......!");
680        }
681 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
682       RETVALUE(ret1);
683    }
684
685    pst->event = (Event) LKW_EVT_STA_IND;   /* event */
686    SPstTsk(pst, mBuf);
687
688    RETVALUE(ROK);
689
690 }  /* end of cmPkLkwStaInd */
691
692
693 /**
694  * @brief
695      Unpack Unsolicited Status indication 
696  *
697  * @param[in] func  : primitive to call
698  * @param[in] pst   : post structure
699  * @param[in] mBuf  : message buffer
700  *  @return  S16
701  *      -# Success : ROK
702  *      -# Failure : RFAILED
703  */
704
705 #ifdef ANSI
706 PUBLIC S16 cmUnpkLkwStaInd
707 (
708 LkwStaInd func,             /* primitive pointer */
709 Pst *pst,                   /* post structure */
710 Buffer *mBuf                /* message buffer */
711 )
712 #else
713 PUBLIC S16 cmUnpkLkwStaInd(func, pst, mBuf)
714 LkwStaInd func;             /* primitive pointer */
715 Pst *pst;                   /* post structure */
716 Buffer *mBuf;               /* message buffer */
717 #endif
718 {
719    KwMngmt usta;            /* RLC LM structure */
720    S16 ret1;                /* return value */
721
722    TRC3(cmUnpkLkwStaInd)
723    
724    ret1 = cmUnpkKwMngmt(&usta, LKW_EVT_STA_IND, mBuf);
725
726    if(ret1 != ROK)
727    {
728       SPutMsg(mBuf);
729 #if (ERRCLASS & ERRCLS_DEBUG)
730        if(ret1 != ROK)
731        {
732           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW016, (ErrVal) ret1,
733                "cmUnpkKwMngmt failure ......!");
734        }
735 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
736       RETVALUE(RFAILED);
737    }
738
739    SPutMsg(mBuf);
740
741    RETVALUE((*func)(pst, &usta));
742 } /* end of cmUnpkLsnStaInd */
743
744 /**
745  * @brief
746      Pack Status Request
747  *
748  * @param[in] pst  : post structure
749  * @param[in] sta : RLC LM structure
750  *  @return  S16
751  *      -# Success : ROK
752  *      -# Failure : RFAILED
753  */
754
755 #ifdef ANSI
756 PUBLIC S16 cmPkLkwStaReq
757 (
758 Pst *pst,                    /* post structure */
759 KwMngmt *sta                 /* status */
760 )
761 #else
762 PUBLIC S16 cmPkLkwStaReq(pst,sta)
763 Pst *pst;                    /* post structure */
764 KwMngmt *sta;                /* status */
765 #endif
766 {
767    Buffer *mBuf;             /* message buffer */
768    S16 ret1;                 /* return value */
769
770    TRC3(cmPkLkwStaReq)
771
772    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
773    if (ret1 != ROK)
774    {
775 #if (ERRCLASS & ERRCLS_ADD_RES)
776        if(ret1 != ROK)
777        {
778           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW017, (ErrVal) ret1,
779                "SGetMsg failure ......!");
780        }
781 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
782       RETVALUE(RFAILED);
783    }
784  
785    ret1 = cmPkKwMngmt(sta, LKW_EVT_STA_REQ, mBuf);
786
787    if(ret1 != ROK)
788    {
789       SPutMsg(mBuf);
790 #if (ERRCLASS & ERRCLS_ADD_RES)
791        if(ret1 != ROK)
792        {
793           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW018, (ErrVal) ret1,
794                "SGetMsg() failure ......!");
795        }
796 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
797       RETVALUE(RFAILED);
798    }
799
800    pst->event = (Event) LKW_EVT_STA_REQ;   /* event */
801    SPstTsk(pst, mBuf);
802
803    RETVALUE(ROK);
804
805 }  /* end of cmPkLkwStaReq */
806
807 /**
808  * @brief
809      Unpack status confirmation 
810  *
811  * @param[in] func  : primitive to call
812  * @param[in] pst   : post structure
813  * @param[in] mBuf  : message buffer
814  *  @return  S16
815  *      -# Success : ROK
816  *      -# Failure : RFAILED
817  */
818 #ifdef ANSI
819 PUBLIC S16 cmUnpkLkwStaCfm
820 (
821 LkwStaReq func,              /* primitive pointer */
822 Pst *pst,                    /* post structure */
823 Buffer *mBuf                 /* message buffer */
824 )
825 #else
826 PUBLIC S16 cmUnpkLkwStaCfm(func, pst, mBuf)
827 LkwStaReq func;              /* primitive pointer */
828 Pst *pst;                    /* post structure */
829 Buffer *mBuf;                /* message buffer */
830 #endif
831 {
832    KwMngmt cfm;              /* RLC LM structure */
833    S16 ret1;                 /* return value */
834
835    TRC3(cmUnpkLkwStaReq)
836
837    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_STA_CFM, mBuf);
838
839     if(ret1 != ROK)
840     {
841        SPutMsg(mBuf);
842 #if (ERRCLASS & ERRCLS_DEBUG)
843        if(ret1 != ROK)
844        {
845           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW019, (ErrVal) ret1,
846                "Unpacking failure ......!");
847        }
848 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
849        RETVALUE(RFAILED);
850     }
851
852    SPutMsg(mBuf);
853   
854    RETVALUE((*func)(pst, &cfm));
855
856 } /* end of function cmUnpkLkwStaCfm */
857
858 /**
859  * @brief
860      Unpack Status request 
861  *
862  * @param[in] func  : primitive to call
863  * @param[in] pst   : post structure
864  * @param[in] mBuf  : message buffer
865  *  @return  S16
866  *      -# Success : ROK
867  *      -# Failure : RFAILED
868  */
869 #ifdef ANSI
870 PUBLIC S16 cmUnpkLkwStsReq
871 (
872 LkwStsReq func,              /* primitive pointer */
873 Pst *pst,                    /* post structure */
874 Buffer *mBuf                 /* message buffer */
875 )
876 #else
877 PUBLIC S16 cmUnpkLkwStsReq(func, pst, mBuf)
878 LkwStsReq func;              /* primitive pointer */
879 Pst *pst;                    /* post structure */
880 Buffer *mBuf;                /* message buffer */
881 #endif
882 {
883    KwMngmt sts;              /* RLC LM structure */
884    S16 ret1;                 /* return value */
885    Action action;            /* Action */
886
887    TRC3(cmUnpkLkwStsReq)
888
889    CMCHKUNPK(SUnpkS16, &action, mBuf);
890
891    ret1 = cmUnpkKwMngmt(&sts, LKW_EVT_STS_REQ, mBuf);
892
893     if(ret1 != ROK)
894     {
895        SPutMsg(mBuf);
896 #if (ERRCLASS & ERRCLS_DEBUG)
897        /*MBUF_FIXX*/
898           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW020, (ErrVal) ret1,
899                "Unpacking failure ......!");
900       
901 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
902        RETVALUE(RFAILED);
903     }
904
905    SPutMsg(mBuf);
906
907    RETVALUE((*func)(pst, action, &sts));
908
909 } /* end of function cmUnpkLkwStsReq */
910
911
912 /**
913  * @brief
914      Unpack ssta 
915  *
916  * @param[in] func  : primitive to call
917  * @param[in] pst   : post structure
918  * @param[in] mBuf  : message buffer
919  *  @return  S16
920  *      -# Success : ROK
921  *      -# Failure : RFAILED
922  */
923 #ifdef ANSI
924 PUBLIC S16 cmUnpkLkwStaReq
925 (
926 LkwStaReq func,              /* primitive pointer */
927 Pst *pst,                    /* post structure */
928 Buffer *mBuf                 /* message buffer */
929 )
930 #else
931 PUBLIC S16 cmUnpkLkwStaReq(func, pst, mBuf)
932 LkwStaReq func;              /* primitive pointer */
933 Pst *pst;                    /* post structure */
934 Buffer *mBuf;                /* message buffer */
935 #endif
936 {
937    KwMngmt sta;              /* RLC LM structure */
938    S16 ret1;                 /* return value */
939
940    TRC3(cmUnpkLkwStaReq)
941
942    ret1 = cmUnpkKwMngmt(&sta, LKW_EVT_STA_REQ, mBuf);
943
944     if(ret1 != ROK)
945     {
946        SPutMsg(mBuf);
947 #if (ERRCLASS & ERRCLS_DEBUG)
948       /*MBUF_FIXX*/
949           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW021, (ErrVal) ret1,
950                "Unpacking failure ......!");
951       
952 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
953        RETVALUE(RFAILED);
954     }
955
956    SPutMsg(mBuf);
957
958    RETVALUE((*func)(pst, &sta));
959
960 } /* end of function cmUnpkLkwStaReq */
961
962
963 /**
964  * @brief
965      Unpack Trace Indication 
966  *
967  * @param[in] func  : primitive to call
968  * @param[in] pst   : post structure
969  * @param[in] mBuf  : message buffer
970  *  @return  S16
971  *      -# Success : ROK
972  *      -# Failure : RFAILED
973  */
974
975 #ifdef ANSI
976 PUBLIC S16 cmUnpkLkwTrcInd
977 (
978 LkwTrcInd func,              /* primitive to call */
979 Pst *pst,                    /* post structure */
980 Buffer *mBuf                 /* message buffer */
981 )
982 #else
983 PUBLIC S16 cmUnpkLkwTrcInd(func, pst, mBuf)
984 LkwTrcInd func;              /* primitive to call */
985 Pst *pst;                    /* post structure */
986 Buffer *mBuf;                /* message buffer */
987 #endif
988 {
989    S16 ret1;                 /* return value */
990    KwMngmt trc;              /* RLC LM structure */
991
992    TRC3(cmUnpkLkwTrcInd)
993
994    ret1 = cmUnpkKwMngmt(&trc, LKW_EVT_TRC_IND, mBuf);
995
996     if(ret1 != ROK)
997     {
998        SPutMsg(mBuf);
999 #if (ERRCLASS & ERRCLS_DEBUG)
1000        if(ret1 != ROK)
1001        {
1002           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW022, (ErrVal) ret1,
1003                "Unpacking failure ......!");
1004        }
1005 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
1006        RETVALUE(RFAILED);
1007     }
1008
1009    (Void) (*func)(pst, &trc, mBuf);
1010
1011    RETVALUE(ROK);
1012
1013 } /* end of cmUnpkLkwTrcInd */
1014
1015
1016 /**
1017  * @brief
1018      Pack Config Request
1019  *
1020  * @param[in] pst  : post structure
1021  * @param[in] cfg  : RLC LM structure
1022  *  @return  S16
1023  *      -# Success : ROK
1024  *      -# Failure : RFAILED
1025  */
1026
1027 #ifdef ANSI
1028 PRIVATE S16 cmPkCkwSapSta 
1029
1030 KwCkwCntSapSta *rcSap,         /* SAP statistics */      
1031 Buffer *mBuf                 /* Message buffer */
1032 )
1033 #else
1034 PRIVATE S16 cmPkCkwSapSta(rcSap, mBuf)
1035 KwCkwCntSapSta *rcSap;         /* SAP statistics */
1036 Buffer *mBuf;                /* Message buffer */
1037 #endif
1038 {
1039    TRC3(cmPkCkwSapSta)
1040
1041    CMCHKPK(cmPkState, rcSap->state, mBuf);
1042    CMCHKPK(SPkS16, rcSap->spId, mBuf);   
1043
1044    RETVALUE(ROK);
1045
1046 } /* end of cmPkCkwSapSta */
1047
1048 /**
1049  * @brief
1050      Unpack CKW sap Sta 
1051  *
1052  * @param[out] rcSap: RLC LM structure 
1053  * @param[in] buffer: Buffer
1054  *  @return  S16
1055  *      -# Success : ROK
1056  *      -# Failure : RFAILED
1057  */
1058 #ifdef ANSI
1059 PRIVATE S16 cmUnpkCkwSapSta 
1060 (
1061 KwCkwCntSapSta *rcSap,         /* SAP statistics */ 
1062 Buffer *mBuf                 /* Message buffer */
1063 )
1064 #else
1065 PRIVATE S16 cmUnpkCkwSapSta(rcSap, mBuf)
1066 KwCkwCntSapSta *rcSap;         /* SAP statistics */ 
1067 Buffer *mBuf;                /* Message buffer */
1068 #endif
1069 {
1070    TRC3(cmUnpkCkwSapSta)
1071
1072    CMCHKUNPK(SUnpkS16, &rcSap->spId, mBuf);
1073    CMCHKUNPK(cmUnpkState, &rcSap->state, mBuf);
1074   
1075    RETVALUE(ROK);
1076 } /* end of function cmUnpkCkwSapSta */
1077
1078 /**
1079  * @brief
1080      Pack Config Request
1081  *
1082  * @param[in] pst  : post structure
1083  * @param[in] cfg  : RLC LM structure
1084  *  @return  S16
1085  *      -# Success : ROK
1086  *      -# Failure : RFAILED
1087  */
1088 #ifdef ANSI
1089 PRIVATE S16 cmPkKwuSapSta
1090 (
1091 KwKwuSapSta *rlSap,           /* SAP statistics */       
1092 Buffer *mBuf                 /* Message buffer */
1093 )
1094 #else
1095 PRIVATE S16 cmPkKwuSapSta(rlSap, mBuf)
1096 KwKwuSapSta *rlSap;           /* SAP statistics */
1097 Buffer *mBuf;                /* Message buffer */
1098 #endif
1099 {
1100    TRC3(cmPkKwuSapSta)
1101
1102    CMCHKPK(cmPkState, rlSap->state, mBuf);
1103    CMCHKPK(SPkS16, rlSap->spId, mBuf);
1104
1105    RETVALUE(ROK);
1106
1107 } /* end of cmPkKwuSapSta */
1108
1109 /**
1110  * @brief
1111      Unpack Kwu Sap Sta 
1112  *
1113  * @param[out] rlSap  : KwRLSapSta structure 
1114  * @param[in] mBuf  : message buffer
1115  *  @return  S16
1116  *      -# Success : ROK
1117  *      -# Failure : RFAILED
1118  */
1119 #ifdef ANSI
1120 PRIVATE S16 cmUnpkKwuSapSta
1121 (
1122 KwKwuSapSta *rlSap,           /* SAP statistics */                   
1123 Buffer *mBuf                 /* Message buffer */
1124 )
1125 #else
1126 PRIVATE S16 cmUnpkKwuSapSta(rlSap, mBuf)
1127 KwKwuSapSta *rlSap;           /* SAP statistics */
1128 Buffer *mBuf;                /* Message buffer */
1129 #endif
1130 {
1131    TRC3(cmUnpkKwuSapSta)
1132
1133    CMCHKUNPK(SUnpkS16, &rlSap->spId, mBuf);
1134    CMCHKUNPK(cmUnpkState, &rlSap->state, mBuf);
1135
1136    RETVALUE(ROK);
1137  
1138 } /* end of function cmUnpkKwuSapSta */
1139
1140 /**
1141  * @brief
1142      Pack 
1143  *
1144  * @param[in] pst  : post structure
1145  * @param[in] cfg  : RLC LM structure
1146  *  @return  S16
1147  *      -# Success : ROK
1148  *      -# Failure : RFAILED
1149  */
1150 #ifdef ANSI
1151 PRIVATE S16 cmPkRguSapSta
1152 (
1153 KwRguSapSta *mkSap,           /* SAP statistics */             
1154 Buffer *mBuf                 /* Message buffer */
1155 )
1156 #else
1157 PRIVATE S16 cmPkRguSapSta(mkSap, mBuf)
1158 KwRguSapSta *mkSap;           /* SAP statistics */
1159 Buffer *mBuf;                /* Message buffer */
1160 #endif
1161 {
1162    TRC3(cmPkRguSapSta)
1163
1164    CMCHKPK(cmPkState, mkSap->state, mBuf);
1165    CMCHKPK(cmPkSuId, mkSap->suId, mBuf);
1166
1167    RETVALUE(ROK);
1168
1169 } /* end of cmPkRguSapSta */
1170
1171 /**
1172  * @brief
1173      Unpack Rgu Sap Sta 
1174  *
1175  * @param[out] mkSap: KwRguSapSta structure 
1176  * @param[in] mBuf  : message buffer
1177  *  @return  S16
1178  *      -# Success : ROK
1179  *      -# Failure : RFAILED
1180  */
1181 #ifdef ANSI
1182 PRIVATE S16 cmUnpkRguSapSta
1183 (
1184 KwRguSapSta *mkSap,           /* SAP statistics */              
1185 Buffer *mBuf                 /* Message buffer */
1186 )
1187 #else
1188 PRIVATE S16 cmUnpkRguSapSta(mkSap, mBuf)
1189 KwRguSapSta *mkSap;           /* SAP statistics */
1190 Buffer *mBuf;                /* Message buffer */
1191 #endif
1192 {
1193    TRC3(cmUnpkRguSapSta)
1194
1195    CMCHKUNPK(cmUnpkSuId, &mkSap->suId, mBuf);
1196    CMCHKUNPK(cmUnpkState, &mkSap->state, mBuf);
1197
1198    RETVALUE(ROK);
1199
1200 } /* end of function cmUnpkRguSapSta */
1201
1202 /**
1203  * @brief
1204      Pack 
1205  *
1206  * @param[in] pst  : post structure
1207  * @param[in] cfg  : RLC LM structure
1208  *  @return  S16
1209  *      -# Success : ROK
1210  *      -# Failure : RFAILED
1211  */
1212 #ifdef ANSI
1213 PUBLIC S16 cmPkLkwStaCfm
1214 (
1215 Pst *pst,                    /* post structure */
1216 KwMngmt *cfm                 /* solicited status confirm */
1217 )
1218 #else
1219 PUBLIC S16 cmPkLkwStaCfm(pst, cfm)
1220 Pst *pst;                    /* post structure */
1221 KwMngmt *cfm;                /* solicited status confirm */
1222 #endif
1223 {
1224    Buffer *mBuf;             /* message buffer */
1225    S16 ret1;                 /* return value */
1226
1227    TRC3(cmPkLkwStaCfm);
1228
1229    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1230    if (ret1 != ROK)
1231    {
1232 #if (ERRCLASS & ERRCLS_ADD_RES)
1233        if(ret1 != ROK)
1234        {
1235           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW023, (ErrVal) ret1,
1236                "SGetMsg() failure ......!");
1237        }
1238 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1239       RETVALUE(RFAILED);
1240    }
1241
1242    ret1 = cmPkKwMngmt(cfm, LKW_EVT_STA_CFM, mBuf);
1243
1244    if(ret1 != ROK)
1245    {
1246       SPutMsg(mBuf);
1247 #if (ERRCLASS & ERRCLS_ADD_RES)
1248        if(ret1 != ROK)
1249        {
1250           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW024, (ErrVal) ret1,
1251                "packing failure ......!");
1252        }
1253 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1254       RETVALUE(RFAILED);
1255    }
1256
1257    pst->event = (Event) LKW_EVT_STA_CFM;   /* event */
1258    SPstTsk(pst, mBuf);
1259
1260    RETVALUE(ROK);
1261 } /* end of cmPkLkwStaCfm */
1262
1263
1264 /**
1265  * @brief
1266      Pack 
1267  *
1268  * @param[in] pst  : post structure
1269  * @param[in] cfg  : RLC LM structure
1270  *  @return  S16
1271  *      -# Success : ROK
1272  *      -# Failure : RFAILED
1273  */
1274 #ifdef ANSI
1275 PUBLIC S16 cmPkLkwTrcInd
1276 (
1277 Pst *pst,                    /* post structure */
1278 KwMngmt *trc,                /* trace */
1279 Buffer *trcBuf                 /* trace buffer */
1280 )
1281 #else
1282 PUBLIC S16 cmPkLkwTrcInd(pst, trc, trcBuf)
1283 Pst *pst;                     /* post structure */
1284 KwMngmt *trc;                 /* trace */
1285 Buffer *trcBuf;               /* trace buffer */
1286 #endif
1287 {
1288    S16      ret1 = ROK;       /* return value */
1289    Buffer   *mBuf = NULLP;    /* Buffer to trace */
1290
1291    TRC3(cmPkLkwTrcInd);
1292
1293    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1294    if (ret1 != ROK)
1295    {
1296 #if (ERRCLASS & ERRCLS_ADD_RES)
1297       if(ret1 != ROK)
1298       {
1299          LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW025, (ErrVal) ret1,
1300                "SGetMsg() failure ......!");
1301       }
1302 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1303       RETVALUE(RFAILED);
1304    }
1305
1306    if (trcBuf)
1307    {
1308       ret1 = SCatMsg(mBuf, trcBuf, M1M2);
1309       if (ret1 != ROK)
1310       {
1311          SPutMsg(mBuf);
1312          SPutMsg(trcBuf);
1313 #if (ERRCLASS & ERRCLS_ADD_RES)
1314          if(ret1 != ROK)
1315          {
1316             LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW026, (ErrVal) ret1,
1317                   "SGetMsg() failure ......!");
1318          }
1319 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1320          RETVALUE(RFAILED);
1321       }
1322
1323       SPutMsg(trcBuf);
1324    }
1325
1326    ret1 = cmPkKwMngmt(trc, LKW_EVT_TRC_IND, mBuf);
1327
1328    if(ret1 != ROK)
1329    {
1330       SPutMsg(mBuf);
1331 #if (ERRCLASS & ERRCLS_ADD_RES)
1332       if(ret1 != ROK)
1333       {
1334          LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW027, (ErrVal) ret1,
1335                "packing failure ......!");
1336       }
1337 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1338       /* log error */
1339       RETVALUE(RFAILED);
1340    }
1341
1342    pst->event = (Event) LKW_EVT_TRC_IND;   /* event */
1343    SPstTsk(pst, mBuf);
1344
1345    RETVALUE(ROK);
1346
1347 } /* end of cmPkLkwTrcInd */
1348
1349
1350 /**
1351  * @brief
1352      Pack 
1353  *
1354  * @param[in] pst  : post structure
1355  * @param[in] cfg  : RLC LM structure
1356  *  @return  S16
1357  *      -# Success : ROK
1358  *      -# Failure : RFAILED
1359  */
1360 #ifdef ANSI
1361 PUBLIC S16 cmPkLkwStsReq
1362 (
1363 Pst *pst,                    /* post structure */
1364 Action action,               /* action */
1365 KwMngmt *sts                 /* statistics request */
1366 )
1367 #else
1368 PUBLIC S16 cmPkLkwStsReq(pst, action, sts)
1369 Pst *pst;                    /* post structure */
1370 Action action;               /* action */
1371 KwMngmt *sts;                /* statistics request */
1372 #endif
1373 {
1374
1375    Buffer *mBuf;             /* message buffer */
1376    S16 ret1;                 /* return value */
1377
1378    TRC3(cmPkLkwStsReq)
1379
1380    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1381    if (ret1 != ROK)
1382    {
1383 #if (ERRCLASS & ERRCLS_ADD_RES)
1384        if(ret1 != ROK)
1385        {
1386           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW028, (ErrVal) ret1,
1387                "SGetMsg() failure ......!");
1388        }
1389 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1390       RETVALUE(RFAILED);
1391    }
1392
1393    ret1 = cmPkKwMngmt(sts, LKW_EVT_STS_REQ, mBuf);
1394
1395    if(ret1 != ROK)
1396    {
1397       SPutMsg(mBuf);
1398 #if (ERRCLASS & ERRCLS_ADD_RES)
1399        if(ret1 != ROK)
1400        {
1401           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW029, (ErrVal) ret1,
1402                "Packing failure ......!");
1403        }
1404 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1405       RETVALUE(RFAILED);
1406    }
1407
1408    CMCHKPK(SPkS16, action, mBuf); 
1409    pst->event = (Event) LKW_EVT_STS_REQ;   /* event */
1410    SPstTsk(pst, mBuf);
1411
1412    RETVALUE(ROK);
1413
1414 } /* end of cmPkLkwStsReq */
1415
1416
1417 /**
1418  * @brief
1419      Pack 
1420  *
1421  * @param[in] pst  : post structure
1422  * @param[in] cfg  : RLC LM structure
1423  *  @return  S16
1424  *      -# Success : ROK
1425  *      -# Failure : RFAILED
1426  */
1427 #ifdef ANSI
1428 PUBLIC S16 cmPkLkwStsCfm
1429 (
1430 Pst *pst,                    /* post structure */
1431 Action action,               /* action */
1432 KwMngmt *cfm                 /* statistics confirmation */
1433 )
1434 #else
1435 PUBLIC S16 cmPkLkwStsCfm(pst, action, cfm)
1436 Pst *pst;                    /* post structure */
1437 Action action;               /* action */
1438 KwMngmt *cfm;                /* statistics confirmation */
1439 #endif
1440 {
1441    Buffer *mBuf;             /* message buffer */
1442    S16 ret1;                 /* return value */
1443
1444    TRC3(cmPkLkwStsCfm);
1445    /* lkw_c_001.main_2 removed warning */
1446    UNUSED(action);
1447    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1448    if (ret1 != ROK)
1449    {
1450 #if (ERRCLASS & ERRCLS_ADD_RES)
1451        if(ret1 != ROK)
1452        {
1453           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW030, (ErrVal) ret1,
1454                "SGetMsg() failure ......!");
1455        }
1456 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1457       RETVALUE(RFAILED);
1458    }
1459
1460    ret1 = cmPkKwMngmt(cfm, LKW_EVT_STS_CFM, mBuf);
1461
1462    if(ret1 != ROK)
1463    {
1464       SPutMsg(mBuf);
1465 #if (ERRCLASS & ERRCLS_ADD_RES)
1466        if(ret1 != ROK)
1467        {
1468           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW031, (ErrVal) ret1,
1469                "Packing  failure ......!");
1470        }
1471 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1472       RETVALUE(RFAILED);
1473    }
1474
1475    pst->event = (Event) LKW_EVT_STS_CFM;   /* event */
1476    SPstTsk(pst, mBuf);
1477
1478    RETVALUE(ROK);
1479 } /* end of cmPkLkwStsCfm */
1480
1481
1482 /**
1483  * @brief
1484      Pack  
1485  *
1486  * @param[in] pst  : post structure
1487  * @param[in] cfg  : RLC LM structure
1488  *  @return  S16
1489  *      -# Success : ROK
1490  *      -# Failure : RFAILED
1491  */
1492
1493 #ifdef ANSI
1494 PRIVATE S16 cmPkKwMngmt
1495 (
1496 KwMngmt *param,              /* Managment */             
1497 Event eventType,             /* Event type */
1498 Buffer *mBuf                 /* Message Buffer */
1499 )
1500 #else
1501 PRIVATE S16 cmPkKwMngmt(param ,eventType, mBuf)
1502 KwMngmt *param;              /* Managment */
1503 Event eventType;             /* Event type */
1504 Buffer *mBuf;                /* Message Buffer */
1505 #endif
1506 {
1507     S16 ret1;                /* return value */
1508
1509     TRC3(cmPkKwMngmt)
1510
1511     switch( eventType )
1512     {
1513        case LKW_EVT_CFG_REQ:
1514           ret1 = cmPkKwCfg(param, param->hdr.elmId.elmnt ,mBuf);
1515           if (ret1 != ROK)
1516           {
1517              RETVALUE(RFAILED);
1518           }
1519           break;
1520
1521        case LKW_EVT_CNTRL_REQ:
1522          ret1 = cmPkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
1523           if (ret1 != ROK)
1524           {
1525              RETVALUE(RFAILED);
1526           }
1527           break;
1528
1529        case LKW_EVT_STA_IND:
1530           ret1 = cmPkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
1531           if (ret1 != ROK)
1532           {
1533              RETVALUE(RFAILED);
1534           }
1535           break;
1536
1537        case LKW_EVT_STA_REQ:
1538        case LKW_EVT_STA_CFM:
1539           ret1 = cmPkKwSsta(param, param->hdr.elmId.elmnt , eventType, mBuf);
1540           if (ret1 != ROK)
1541           {
1542              RETVALUE(RFAILED);
1543           }
1544           break;
1545
1546        case LKW_EVT_STS_REQ:
1547        case LKW_EVT_STS_CFM:
1548           ret1 = cmPkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
1549           if (ret1 != ROK)
1550           {
1551              RETVALUE(RFAILED);
1552           }
1553           break;
1554        case LKW_EVT_TRC_IND:
1555           ret1 = cmPkKwTrc(param, mBuf);
1556           if (ret1 != ROK)
1557           {
1558              RETVALUE(RFAILED);
1559           }
1560           break;
1561        case LKW_EVT_CNTRL_CFM:
1562        case LKW_EVT_CFG_CFM:
1563           break;
1564     }
1565
1566    CMCHKPK(cmPkCmStatus, &param->cfm, mBuf);
1567    CMCHKPK(cmPkHeader, &param->hdr, mBuf);
1568
1569    RETVALUE(ROK);
1570 } /* end of function cmPkKwMngmt */
1571
1572
1573 /**
1574  * @brief
1575      Pack 
1576  *
1577  * @param[in] pst  : post structure
1578  * @param[in] cfg  : RLC LM structure
1579  *  @return  S16
1580  *      -# Success : ROK
1581  *      -# Failure : RFAILED
1582  */
1583 #ifdef ANSI
1584 PRIVATE S16 cmPkKwCfg
1585 (
1586 KwMngmt *cfg,
1587 Elmnt elmnt,
1588 Buffer *mBuf
1589 )
1590 #else
1591 PRIVATE S16 cmPkKwCfg(cfg, elmnt, mBuf)
1592 KwMngmt *cfg;
1593 Elmnt elmnt;
1594 Buffer *mBuf;
1595 #endif
1596 {
1597     TRC3(cmPkKwCfg)
1598
1599     switch( elmnt )
1600     {
1601       case STGEN:
1602       {
1603          CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxRguSaps, mBuf);
1604          CMCHKPK(SPkU8, cfg->t.cfg.s.gen.rlcMode, mBuf);
1605          CMCHKPK(SPkU32, cfg->t.cfg.s.gen.timeRes, mBuf);
1606          CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
1607          CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
1608          CMCHKPK(SPkU32, cfg->t.cfg.s.gen.maxUe, mBuf);
1609          CMCHKPK(cmPkPst, &cfg->t.cfg.s.gen.lmPst,mBuf);
1610
1611          break;
1612       }
1613       case STCKWSAP:
1614       case STKWUSAP:
1615       case STUDXSAP:
1616       case STRGUSAP:
1617       {
1618          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.route,mBuf);
1619          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.priority,mBuf);
1620          CMCHKPK(SPkU16, cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
1621          CMCHKPK(SPkS16, cfg->t.cfg.s.sap.sapId, mBuf);
1622          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.inst, mBuf);
1623          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.ent, mBuf);
1624          CMCHKPK(SPkU16, cfg->t.cfg.s.sap.procId, mBuf);
1625          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.mem.pool, mBuf);
1626          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.mem.region, mBuf);
1627          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.selector, mBuf);
1628          break;
1629       }
1630        default:
1631           RETVALUE(RFAILED);
1632     }
1633     RETVALUE(ROK);
1634 } /*end of function cmPkKwCfg*/
1635
1636
1637 /**
1638  * @brief
1639      Pack kw control request
1640  *
1641  * @param[in] cntrl  : LM management structure
1642  * @param[in] elmnt  : element 
1643  * @param[in] mBuf   : Buffer 
1644  *  @return  S16
1645  *      -# Success : ROK
1646  *      -# Failure : RFAILED
1647  */
1648 #ifdef ANSI
1649 PRIVATE S16 cmPkKwCntrl
1650 (
1651 KwMngmt *cntrl,
1652 Elmnt elmnt,
1653 Buffer *mBuf
1654 )
1655 #else
1656 PRIVATE S16 cmPkKwCntrl(cntrl, elmnt, mBuf)
1657 KwMngmt *cntrl;
1658 Elmnt elmnt;
1659 Buffer *mBuf;
1660 #endif
1661 {
1662     U8 subAction;            /* sub action */     
1663
1664     TRC3(cmPkKwCntrl)
1665
1666     switch( elmnt )
1667     {
1668       case STGEN:
1669          {
1670             subAction = cntrl->t.cntrl.subAction;
1671             switch(subAction)
1672             {
1673                case SAUSTA:
1674                   break;
1675                case SADBG:
1676                   {
1677                       CMCHKPK(SPkU32, cntrl->t.cntrl.s.dbgCntrl.dbgMask,
1678                                                            mBuf);
1679                   }
1680                   break;
1681                case SATRC:
1682                   {
1683                      CMCHKPK(SPkS16, cntrl->t.cntrl.s.trcCntrl.trcLen, 
1684                                                            mBuf);
1685                      CMCHKPK(SPkU8, cntrl->t.cntrl.s.trcCntrl.trcMask,
1686                                                            mBuf);
1687                   }
1688                   break;
1689 #ifdef SS_DIAG
1690                case SALOG:
1691                   {
1692                       CMCHKPK(SPkU32, cntrl->t.cntrl.s.logMask,  mBuf);
1693                   }
1694                   break;
1695 #endif
1696                default:
1697                   break;
1698             }
1699             break;
1700          }
1701       case STRGUSAP:
1702       case STUDXSAP:
1703          CMCHKPK(SPkS16, cntrl->t.cntrl.s.sapCntrl.spId, mBuf);
1704          CMCHKPK(SPkS16, cntrl->t.cntrl.s.sapCntrl.suId, mBuf);
1705          break;
1706       default:
1707          break;
1708    }
1709
1710    CMCHKPK(SPkU8, cntrl->t.cntrl.action, mBuf);
1711    CMCHKPK(SPkU8, cntrl->t.cntrl.subAction, mBuf);
1712    CMCHKPK(cmPkDateTime, &cntrl->t.cntrl.dt, mBuf);
1713
1714    RETVALUE(ROK);
1715 } /*end of function cmPkKwCntrl */
1716
1717 /**
1718  * @brief
1719      Pack unsolicit status  
1720  *
1721  * @param[in] usta  : RLC LM structure 
1722  * @param[in] elmnt : element
1723  * @param[in] mBuf  : Buffer 
1724  *  @return  S16
1725  *      -# Success : ROK
1726  *      -# Failure : RFAILED
1727  */
1728 #ifdef ANSI
1729 PRIVATE S16 cmPkKwUsta
1730 (
1731 KwMngmt *usta,
1732 Elmnt elmnt,
1733 Buffer *mBuf
1734 )
1735 #else
1736 PRIVATE S16 cmPkKwUsta(usta, elmnt, mBuf)
1737 KwMngmt *usta;
1738 Elmnt elmnt;
1739 Buffer *mBuf;
1740 #endif
1741 {
1742    TRC3(cmPkKwUsta)
1743
1744    /* lkw_c_001.main_2 removed warning */
1745    UNUSED(elmnt);
1746    /* lkw_c_001.main_2 added support for L2 Measurement */
1747 #ifdef LTE_L2_MEAS
1748    CMCHKPK(SPkU8, usta->t.usta.qci, mBuf);
1749 #endif
1750    CMCHKPK(SPkU32, usta->t.usta.ueId, mBuf);
1751    CMCHKPK(SPkS16, usta->t.usta.suId, mBuf);
1752    CMCHKPK(cmPkCmAlarm, &usta->t.usta.alarm,mBuf);
1753    CMCHKPK(cmPkDateTime, &usta->t.usta.dt, mBuf);
1754
1755    RETVALUE(ROK);
1756
1757 } /* end of cmPkKwUsta */
1758
1759
1760 /**
1761  * @brief
1762      Pack 
1763  *
1764  * @param[in] pst  : post structure
1765  * @param[in] cfg  : RLC LM structure
1766  *  @return  S16
1767  *      -# Success : ROK
1768  *      -# Failure : RFAILED
1769  */
1770 #ifdef ANSI
1771 PRIVATE S16 cmPkKwSsta
1772 (
1773 KwMngmt *ssta,
1774 Elmnt elmnt,
1775 Event eventType,
1776 Buffer *mBuf
1777 )
1778 #else
1779 PRIVATE S16 cmPkKwSsta(ssta, elmnt, eventType, mBuf)
1780 KwMngmt *ssta;
1781 Elmnt elmnt;
1782 Event eventType;
1783 Buffer *mBuf;
1784 #endif
1785 {
1786    S16 ret1;
1787    TRC3(cmPkKwSsta)
1788
1789    ret1 = RFAILED;
1790    switch(elmnt)
1791    {
1792       case STSID:
1793          ret1 = ROK;
1794          if(eventType == LKW_EVT_STA_CFM)
1795          {
1796             CMCHKPK(cmPkSystemId, &ssta->t.ssta.s.sysId,mBuf);
1797          }
1798          break;
1799       case STCKWSAP:
1800          ret1 = cmPkCkwSapSta(&ssta->t.ssta.s.ckwSap, mBuf);
1801          break;
1802       case STKWUSAP:
1803          ret1 = cmPkKwuSapSta(&ssta->t.ssta.s.kwuSap, mBuf);
1804          break;
1805       case STRGUSAP:
1806       case STUDXSAP:
1807          ret1 = cmPkRguSapSta(&ssta->t.ssta.s.rguSap, mBuf);
1808          break;
1809       default:
1810          ret1 = RFAILED;
1811         break;
1812    }
1813
1814    if(ret1 != ROK)
1815    {
1816       RETVALUE(RFAILED);
1817    }
1818
1819    CMCHKPK(cmPkDateTime, &ssta->t.ssta.dt, mBuf);
1820
1821    RETVALUE(ROK);
1822
1823 } /* end of cmPkKwSsta */
1824
1825 /**
1826  * @brief
1827      Pack Trace Indication
1828  *
1829  * @param[in] trc  : RLC LM structure 
1830  * @param[in] mBuf : Buffer 
1831  *  @return  S16
1832  *      -# Success : ROK
1833  *      -# Failure : RFAILED
1834  */
1835 #ifdef ANSI
1836 PRIVATE S16 cmPkKwTrc
1837 (
1838 KwMngmt *trc,                /* trace */                 
1839 Buffer *mBuf                 /* data buffer */
1840 )
1841 #else
1842 PRIVATE S16 cmPkKwTrc(trc, mBuf)
1843 KwMngmt *trc;                /* trace */
1844 Buffer *mBuf;                /* data buffer */
1845 #endif
1846 {
1847    TRC3(cmPkKwTrc)
1848
1849    CMCHKPK(SPkU16, trc->t.trc.event, mBuf); 
1850    CMCHKPK(cmPkDateTime, &trc->t.trc.dt, mBuf);
1851
1852    RETVALUE(ROK);
1853 } /* end of cmPkKwTrc */
1854
1855
1856 /**
1857  * @brief
1858      Pack Statistics request 
1859  *
1860  * @param[in] pst  : post structure
1861  * @param[in] cfg  : RLC LM structure
1862  *  @return  S16
1863  *      -# Success : ROK
1864  *      -# Failure : RFAILED
1865  */
1866
1867 #ifdef ANSI
1868 PRIVATE S16 cmPkKwSts
1869 (
1870 KwMngmt *sts,
1871 Elmnt elmnt,
1872 Buffer *mBuf
1873 )
1874 #else
1875 PRIVATE S16 cmPkKwSts(sts, elmnt, mBuf)
1876 KwMngmt *sts;
1877 Elmnt elmnt;
1878 Buffer *mBuf;
1879 #endif
1880 {
1881    S16 ret1;
1882    TRC3(cmPkKwSts)
1883
1884    ret1 = RFAILED;
1885    switch(elmnt)
1886    {
1887       case STGEN:
1888          ret1 = cmPkGenSts(&sts->t.sts.s.gen, mBuf); 
1889          break;
1890       case STCKWSAP:
1891          ret1 = cmPkCkwSapSts(&sts->t.sts.s.ckwSap, mBuf);
1892          break;
1893       case STKWUSAP:
1894          ret1 = cmPkKwuSapSts(&sts->t.sts.s.kwuSap, mBuf);
1895          break;
1896 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
1897  * in general statstics.
1898  * */
1899       default:
1900          ret1 = RFAILED;
1901         break;
1902    } /* end of switch */
1903
1904    if(ret1 != ROK)
1905    {
1906       RETVALUE(RFAILED);
1907    }
1908
1909    CMCHKPK(cmPkDateTime, &sts->t.sts.dt, mBuf);
1910
1911    RETVALUE(ROK);
1912 } /* end of cmPkKwSts */
1913
1914
1915
1916 /**
1917  * @brief
1918      Pack general statistics 
1919  *
1920  * @param[in] gen  : KwGenSts structure 
1921  * @param[in] mBuf : Buffer 
1922  *  @return  S16
1923  *      -# Success : ROK
1924  *      -# Failure : RFAILED
1925  */
1926 #ifdef ANSI
1927 PRIVATE S16 cmPkGenSts
1928 (
1929 KwGenSts *gen,
1930 Buffer *mBuf
1931 )
1932 #else
1933 PRIVATE S16 cmPkGenSts(gen, mBuf)
1934 KwGenSts *gen;
1935 Buffer *mBuf;
1936 #endif
1937 {
1938    TRC3(cmPkGenSts)
1939
1940    CMCHKPK(SPkU32, gen->numSduDisc, mBuf);
1941    CMCHKPK(SPkU32, gen->numOfRb, mBuf);
1942    CMCHKPK(SPkU32, gen->protTimeOut, mBuf);
1943    CMCHKPK(SPkU32, gen->errorPdusRecv, mBuf);
1944    CMCHKPK(SPkU32, gen->unexpPdusRecv, mBuf);
1945    CMCHKPK(SPkU32, gen->bytesSent, mBuf);
1946    CMCHKPK(SPkU32, gen->bytesRecv, mBuf);
1947    CMCHKPK(SPkU32, gen->pdusRetx, mBuf);
1948    CMCHKPK(SPkU32, gen->pdusSent, mBuf);
1949    CMCHKPK(SPkU32, gen->pdusRecv, mBuf);
1950    CMCHKPK(SPkU32, gen->numUe, mBuf);
1951
1952    RETVALUE(ROK);
1953
1954 } /* end of cmPkGenSts */
1955
1956 /**
1957  * @brief
1958      Pack CKW statistics
1959  *
1960  * @param[in] pst  : post structure
1961  * @param[in] cfg  : RLC LM structure
1962  *  @return  S16
1963  *      -# Success : ROK
1964  *      -# Failure : RFAILED
1965  */
1966 #ifdef ANSI
1967 PRIVATE S16 cmPkCkwSapSts
1968 (
1969 KwCkwCntSts *rcSap,
1970 Buffer *mBuf
1971 )
1972 #else
1973 PRIVATE S16 cmPkCkwSapSts(rcSap, mBuf)
1974 KwCkwCntSts *rcSap;
1975 Buffer *mBuf;
1976 #endif
1977 {
1978    TRC3(cmPkCkwSapSts)
1979
1980    CMCHKPK(SPkU32, rcSap->statMsgs, mBuf);
1981
1982    RETVALUE(ROK);
1983 } /* end of cmPkCkwSapSts */
1984
1985 /**
1986  * @brief
1987      Pack Config Request
1988  *
1989  * @param[in] pst  : post structure
1990  * @param[in] cfg  : RLC LM structure
1991  *  @return  S16
1992  *      -# Success : ROK
1993  *      -# Failure : RFAILED
1994  */
1995 #ifdef ANSI
1996 PRIVATE S16 cmPkKwuSapSts
1997 (
1998 KwKwuSapSts *ruSap,
1999 Buffer *mBuf
2000 )
2001 #else
2002 PRIVATE S16 cmPkKwuSapSts(ruSap, mBuf)
2003 KwKwuSapSts *ruSap;
2004 Buffer *mBuf;
2005 #endif
2006 {
2007    TRC3(cmPkCkwSapSts)
2008
2009    CMCHKPK(SPkU32, ruSap->sduTx, mBuf);
2010    CMCHKPK(SPkU32, ruSap->sduRx, mBuf);
2011    /* lkw_c_001.main_2 changed from suId to spId */
2012    CMCHKPK(cmPkSuId, ruSap->spId, mBuf);
2013
2014    RETVALUE(ROK);
2015 } /* end of cmPkCkwSapSts */
2016
2017 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
2018  * in general statstics.
2019  * */
2020
2021 /**
2022  * @brief
2023      Unpack RLC Layer Management structure 
2024  *
2025  * @param[in] param  : RLC LM structure
2026  * @param[in] eventType   : event type 
2027  * @param[in] mBuf  : message buffer
2028  *  @return  S16
2029  *      -# Success : ROK
2030  *      -# Failure : RFAILED
2031  */
2032 #ifdef ANSI
2033 PRIVATE S16 cmUnpkKwMngmt
2034 (
2035 KwMngmt *param,
2036 Event eventType,
2037 Buffer *mBuf
2038 )
2039 #else
2040 PRIVATE S16 cmUnpkKwMngmt(param ,eventType, mBuf)
2041 KwMngmt *param;
2042 Event eventType;
2043 Buffer *mBuf;
2044 #endif
2045 {
2046     S16 ret1;
2047     TRC3(cmUnpkKwMngmt)
2048
2049    cmMemset((U8 *) param, (U8) 0, (S16) sizeof(KwMngmt));
2050
2051    CMCHKUNPK(cmUnpkHeader, &param->hdr, mBuf);
2052    CMCHKUNPK(cmUnpkCmStatus, &param->cfm, mBuf);
2053
2054     switch( eventType )
2055     {
2056        case  LKW_EVT_CFG_REQ:
2057           ret1 = cmUnpkKwCfg(param, param->hdr.elmId.elmnt ,mBuf);
2058           if (ret1 != ROK)
2059           {
2060              RETVALUE(RFAILED);
2061           }
2062           break;
2063        case LKW_EVT_CNTRL_REQ:
2064           ret1 = cmUnpkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
2065           if (ret1 != ROK)
2066           {
2067              RETVALUE(RFAILED);
2068           }
2069           break;
2070
2071        case LKW_EVT_STA_IND:
2072           ret1 = cmUnpkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
2073           if (ret1 != ROK)
2074           {
2075              RETVALUE(RFAILED);
2076           }
2077           break;
2078
2079        case LKW_EVT_STA_REQ:
2080        case LKW_EVT_STA_CFM:
2081           ret1 = cmUnpkKwSsta(param, param->hdr.elmId.elmnt, eventType,mBuf);
2082           if (ret1 != ROK)
2083           {
2084              RETVALUE(RFAILED);
2085           }
2086           break;
2087
2088        case LKW_EVT_STS_REQ:
2089        case LKW_EVT_STS_CFM:
2090           
2091           ret1 = cmUnpkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
2092           if (ret1 != ROK)
2093           {
2094              RETVALUE(RFAILED);
2095           }
2096           break;
2097        case LKW_EVT_TRC_IND:
2098           ret1 = cmUnpkKwTrc(param, mBuf);
2099           if (ret1 != ROK)
2100           {
2101              RETVALUE(RFAILED);
2102           }
2103           break;
2104
2105        case LKW_EVT_CNTRL_CFM:
2106        case LKW_EVT_CFG_CFM:
2107        break;
2108
2109        default:
2110           break;
2111     }
2112     RETVALUE(ROK);
2113 } /*end of function cmUnpkKwMngmt*/
2114
2115 /**
2116  * @brief
2117      Unpack Kw configuration structure 
2118  *
2119  * @param[out] cfg  : RLC LM structure 
2120  * @param[in] elmnt  : element 
2121  * @param[in] mBuf  : message buffer
2122  *  @return  S16
2123  *      -# Success : ROK
2124  *      -# Failure : RFAILED
2125  */
2126 #ifdef ANSI
2127 PRIVATE S16 cmUnpkKwCfg
2128 (
2129 KwMngmt *cfg,
2130 Elmnt elmnt,
2131 Buffer *mBuf
2132 )
2133 #else
2134 PRIVATE S16 cmUnpkKwCfg(cfg ,elmnt, mBuf)
2135 KwMngmt *cfg;
2136 Elmnt elmnt;
2137 Buffer *mBuf;
2138 #endif
2139 {
2140    TRC3(cmUnpkKwCfg)
2141
2142    switch(elmnt)
2143    {
2144       case STGEN:
2145       {
2146          CMCHKUNPK(cmUnpkPst, &cfg->t.cfg.s.gen.lmPst,mBuf);
2147          CMCHKUNPK(SUnpkU32, &cfg->t.cfg.s.gen.maxUe, mBuf);
2148          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
2149          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
2150          CMCHKUNPK(SUnpkU32, &cfg->t.cfg.s.gen.timeRes, mBuf);
2151          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.gen.rlcMode, mBuf);
2152          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxRguSaps, mBuf);
2153       }
2154       break;
2155
2156       case STCKWSAP:
2157       case STKWUSAP:
2158       case STRGUSAP:
2159       case STUDXSAP:
2160       {
2161          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.selector, mBuf);
2162          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.mem.region, mBuf);
2163          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.mem.pool, mBuf);
2164          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.sap.procId, mBuf);
2165          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.ent, mBuf);
2166          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.inst, mBuf);
2167          CMCHKUNPK(SUnpkS16, &cfg->t.cfg.s.sap.sapId, mBuf);
2168          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
2169          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.priority,mBuf);
2170          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.route,mBuf);
2171       }
2172       break;
2173       default:
2174         RETVALUE(RFAILED);
2175    } /* end of switch */     
2176
2177    RETVALUE(ROK);
2178 } /* end of cmUnpkKwCfg */
2179
2180 /**
2181  * @brief
2182      Unpack Control Structure 
2183  *
2184  * @param[in] cfm   : RLC LM structure 
2185  * @param[in] elmnt : element 
2186  * @param[in] mBuf  : message buffer
2187  *  @return  S16
2188  *      -# Success : ROK
2189  *      -# Failure : RFAILED
2190  */
2191 #ifdef ANSI
2192 PRIVATE S16 cmUnpkKwCntrl
2193 (
2194 KwMngmt *cfm,
2195 Elmnt elmnt,
2196 Buffer *mBuf
2197 )
2198 #else
2199 PRIVATE S16 cmUnpkKwCntrl(cfm, elmnt, mBuf)
2200 KwMngmt *cfm;
2201 Elmnt elmnt;
2202 Buffer *mBuf;
2203 #endif
2204 {
2205    U8 subAction;
2206    KwDbgCntrl *dbgCntrl;
2207    KwTrcCntrl *trcCntrl;
2208
2209    TRC3(cmUnpkKwCntrl);
2210    
2211    /* lkw_c_001.main_2 removed warning */
2212    UNUSED(elmnt);
2213
2214    CMCHKUNPK(cmUnpkDateTime, &cfm->t.cntrl.dt, mBuf);
2215    CMCHKUNPK(SUnpkU8, &cfm->t.cntrl.subAction, mBuf);
2216    CMCHKUNPK(SUnpkU8, &cfm->t.cntrl.action, mBuf);
2217
2218    subAction = cfm->t.cntrl.subAction;
2219
2220    switch(cfm->hdr.elmId.elmnt)
2221    {
2222       case STGEN:
2223          {
2224             switch(subAction)
2225             {
2226                case SAUSTA:
2227                   break;
2228                case SADBG:
2229                   {
2230                      dbgCntrl = &cfm->t.cntrl.s.dbgCntrl;
2231                      CMCHKUNPK(SUnpkU32, &dbgCntrl->dbgMask, mBuf);
2232                   }
2233                   break;
2234                case SATRC:
2235                   {
2236                     trcCntrl = &cfm->t.cntrl.s.trcCntrl; 
2237                     CMCHKUNPK(SUnpkU8, &trcCntrl->trcMask, mBuf);
2238                     CMCHKUNPK(SUnpkS16,&trcCntrl->trcLen, mBuf);
2239                   }
2240                   break;
2241 #ifdef SS_DIAG
2242                case SALOG:
2243                   {
2244                       CMCHKUNPK(SUnpkU32, &cfm->t.cntrl.s.logMask, mBuf);
2245                   }
2246                   break;
2247 #endif
2248                default:
2249                   break;
2250             }
2251             break;
2252          }
2253       case STRGUSAP:
2254       case STUDXSAP:
2255            CMCHKUNPK(SUnpkS16, &cfm->t.cntrl.s.sapCntrl.suId, mBuf);
2256            CMCHKUNPK(SUnpkS16, &cfm->t.cntrl.s.sapCntrl.spId, mBuf);
2257            break;
2258       default:
2259            break;
2260    }
2261
2262    RETVALUE(ROK);
2263
2264 } /* end of cmUnpkKwCntrl */
2265
2266
2267 /**
2268  * @brief
2269      Unpack USta 
2270  *
2271  * @param[in] usta  : RLC LM Structure
2272  * @param[in] elmnt : element
2273  * @param[out] mBuf  : message buffer
2274  *  @return  S16
2275  *      -# Success : ROK
2276  *      -# Failure : RFAILED
2277  */
2278 #ifdef ANSI
2279 PRIVATE S16 cmUnpkKwUsta
2280 (
2281 KwMngmt *usta,
2282 Elmnt elmnt,
2283 Buffer *mBuf
2284 )
2285 #else
2286 PRIVATE S16 cmUnpkKwUsta(usta ,elmnt, mBuf)
2287 KwMngmt *usta;
2288 Elmnt elmnt;
2289 Buffer *mBuf;
2290 #endif
2291 {
2292    TRC3(cmUnpkKwUsta);
2293
2294    /* lkw_c_001.main_2 removed warning */
2295    UNUSED(elmnt);
2296
2297    CMCHKUNPK(cmUnpkDateTime, &usta->t.usta.dt, mBuf);
2298    CMCHKUNPK(cmUnpkCmAlarm, &usta->t.usta.alarm,mBuf);
2299    CMCHKUNPK(SUnpkS16, &usta->t.usta.suId, mBuf);
2300    CMCHKUNPK(SUnpkU32, &usta->t.usta.ueId, mBuf);
2301    /* lkw_c_001.main_2 added support for L2 Measurement */
2302 #ifdef LTE_L2_MEAS
2303    CMCHKUNPK(SUnpkU8, &usta->t.usta.qci, mBuf);
2304 #endif
2305    RETVALUE(ROK);
2306 }
2307
2308 /**
2309  * @brief
2310      Unpack SSta 
2311  *
2312  * @param[out] ssta: RLC LM structure 
2313  * @param[in] elmnt  : element 
2314  * @param[in] mBuf  : message buffer
2315  *  @return  S16
2316  *      -# Success : ROK
2317  *      -# Failure : RFAILED
2318  */
2319 #ifdef ANSI
2320 PRIVATE S16 cmUnpkKwSsta
2321 (
2322 KwMngmt *ssta,
2323 Elmnt elmnt,
2324 Event eventType,
2325 Buffer *mBuf
2326 )
2327 #else
2328 PRIVATE S16 cmUnpkKwSsta(ssta ,elmnt, eventType, mBuf)
2329 KwMngmt *ssta;
2330 Elmnt elmnt;
2331 Event eventType;
2332 Buffer *mBuf;
2333 #endif
2334 {
2335    S16 ret1;           /* return value */
2336    TRC3(cmUnpkKwSsta);
2337
2338    CMCHKUNPK(cmUnpkDateTime, &ssta->t.ssta.dt, mBuf);
2339    switch(elmnt)
2340    {
2341       case STSID:
2342          ret1 = ROK;
2343          if(eventType == LKW_EVT_STA_CFM)
2344          {
2345             cmMemset((U8 *) ptNmb, (U8) 0, LKW_PART_NUM_STR_LEN);
2346             ssta->t.ssta.s.sysId.ptNmb = ptNmb;
2347             CMCHKUNPK(cmUnpkSystemId, &ssta->t.ssta.s.sysId,mBuf);
2348          }
2349          break;
2350       case STCKWSAP:
2351          ret1 = cmUnpkCkwSapSta(&ssta->t.ssta.s.ckwSap, mBuf);
2352          break;
2353       case STKWUSAP:
2354          ret1 = cmUnpkKwuSapSta(&ssta->t.ssta.s.kwuSap, mBuf);
2355          break;
2356       case STRGUSAP:
2357       case STUDXSAP:
2358          ret1 = cmUnpkRguSapSta(&ssta->t.ssta.s.rguSap, mBuf);
2359          break;
2360       default:
2361          ret1 = RFAILED;
2362         break;
2363    }
2364
2365    if(ret1 != ROK)
2366    {
2367       RETVALUE(RFAILED);
2368    }
2369
2370    RETVALUE(ROK);
2371 }
2372
2373
2374 /**
2375  * @brief
2376      Unpack trace Indication 
2377  *
2378  * @param[out] trc   : RLC LM Structure 
2379  * @param[in] mBuf  : message buffer
2380  *  @return  S16
2381  *      -# Success : ROK
2382  *      -# Failure : RFAILED
2383  */
2384 #ifdef ANSI
2385 PRIVATE S16 cmUnpkKwTrc
2386 (
2387 KwMngmt *trc,
2388 Buffer *mBuf
2389 )
2390 #else
2391 PRIVATE S16 cmUnpkKwTrc(trc, mBuf)
2392 KwMngmt *trc;
2393 Buffer *mBuf;
2394 #endif
2395 {
2396    TRC3(cmUnpkKwTrc);
2397
2398    CMCHKUNPK(cmUnpkDateTime, &trc->t.trc.dt, mBuf);
2399    CMCHKUNPK(SUnpkU16, &trc->t.trc.event, mBuf);
2400
2401    RETVALUE(ROK);
2402 } /* end of cmUnpkKwTrc */
2403
2404
2405 /**
2406  * @brief
2407      Unpack Statistics 
2408  *
2409  * @param[out] sts  : RLC LM structure 
2410  * @param[in] elmnt : element 
2411  * @param[in] mBuf  : message buffer
2412  *  @return  S16
2413  *      -# Success : ROK
2414  *      -# Failure : RFAILED
2415  */
2416 #ifdef ANSI
2417 PRIVATE S16 cmUnpkKwSts
2418 (
2419 KwMngmt *sts,
2420 Elmnt elmnt,
2421 Buffer *mBuf
2422 )
2423 #else
2424 PRIVATE S16 cmUnpkKwSts(sts ,elmnt, mBuf)
2425 KwMngmt *sts;
2426 Elmnt elmnt;
2427 Buffer *mBuf;
2428 #endif
2429 {
2430    S16 ret1;           /* return value */
2431    TRC3(cmUnpkKwSts);
2432
2433    CMCHKUNPK(cmUnpkDateTime, &sts->t.sts.dt, mBuf);
2434
2435    switch(elmnt)
2436    {
2437       case STGEN:
2438          ret1 = cmUnpkGenSts(&sts->t.sts.s.gen, mBuf);
2439          break;
2440       case STCKWSAP:
2441          ret1 = cmUnpkCkwSapSts(&sts->t.sts.s.ckwSap, mBuf);
2442          break;
2443       case STKWUSAP:
2444          ret1 = cmUnpkKwuSapSts(&sts->t.sts.s.kwuSap, mBuf);
2445          break;
2446 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
2447  * in general statstics.
2448  * */
2449       default:
2450          ret1 = RFAILED;
2451         break;
2452    } /* end of switch */
2453
2454    if(ret1 != ROK)
2455    {
2456       RETVALUE(RFAILED);
2457    }
2458
2459    RETVALUE(ROK);
2460 } /* end of cmUnpkKwSts */
2461
2462
2463 /**
2464  * @brief
2465      Unpack General statistics 
2466  *
2467  * @param[out] gen  : KwGenSts structure 
2468  * @param[in] mBuf  : message buffer
2469  *  @return  S16
2470  *      -# Success : ROK
2471  *      -# Failure : RFAILED
2472  */
2473 #ifdef ANSI
2474 PRIVATE S16 cmUnpkGenSts
2475 (
2476 KwGenSts *gen,
2477 Buffer *mBuf
2478 )
2479 #else
2480 PRIVATE S16 cmUnpkGenSts(gen, mBuf)
2481 KwGenSts *gen;
2482 Buffer *mBuf;
2483 #endif
2484 {
2485    TRC3(cmUnpkGenSts);
2486
2487    CMCHKUNPK(SUnpkU32, &gen->numUe, mBuf);
2488    CMCHKUNPK(SUnpkU32, &gen->pdusRecv, mBuf);
2489    CMCHKUNPK(SUnpkU32, &gen->pdusSent, mBuf);
2490    CMCHKUNPK(SUnpkU32, &gen->pdusRetx, mBuf);
2491    CMCHKUNPK(SUnpkU32, &gen->bytesRecv, mBuf);
2492    CMCHKUNPK(SUnpkU32, &gen->bytesSent, mBuf);
2493    CMCHKUNPK(SUnpkU32, &gen->unexpPdusRecv, mBuf);
2494    CMCHKUNPK(SUnpkU32, &gen->errorPdusRecv, mBuf);
2495    CMCHKUNPK(SUnpkU32, &gen->protTimeOut, mBuf);
2496    CMCHKUNPK(SUnpkU32, &gen->numOfRb, mBuf);
2497    CMCHKUNPK(SUnpkU32, &gen->numSduDisc, mBuf);
2498
2499    RETVALUE(ROK);
2500 } /* end of cmUnpkGenSts */
2501
2502 /**
2503  * @brief
2504      Unpack Ckw Sap Statistics 
2505  *
2506  * @param[out] rcSap  : KwCkwCntSts structure
2507  * @param[in] mBuf  : message buffer
2508  *  @return  S16
2509  *      -# Success : ROK
2510  *      -# Failure : RFAILED
2511  */
2512 #ifdef ANSI
2513 PRIVATE S16 cmUnpkCkwSapSts
2514 (
2515 KwCkwCntSts *rcSap,
2516 Buffer *mBuf
2517 )
2518 #else
2519 PRIVATE S16 cmUnpkCkwSapSts(rcSap ,mBuf)
2520 KwCkwCntSts *rcSap;
2521 Buffer *mBuf;
2522 #endif
2523 {
2524
2525    TRC3(cmUnpkCkwSapSts);
2526
2527    CMCHKUNPK(SUnpkU32, &rcSap->statMsgs, mBuf); 
2528
2529    RETVALUE(ROK);
2530
2531 } /* end of cmUnpkCkwSapSts */
2532
2533 /**
2534  * @brief
2535      Unpack Kwu Sap statistics
2536  *
2537  * @param[out]       : KwKwuSapSts structure
2538  * @param[in] mBuf  : message buffer
2539  *  @return  S16
2540  *      -# Success : ROK
2541  *      -# Failure : RFAILED
2542  */
2543 #ifdef ANSI
2544 PRIVATE S16 cmUnpkKwuSapSts
2545 (
2546 KwKwuSapSts *ruSap,
2547 Buffer *mBuf
2548 )
2549 #else
2550 PRIVATE S16 cmUnpkKwuSapSts(ruSap, mBuf)
2551 KwKwuSapSts *ruSap;
2552 Buffer *mBuf;
2553 #endif
2554 {
2555    TRC3(cmUnpkKwuSapSts)
2556
2557    /* lkw_c_001.main_2 changed from suId to spId */
2558    CMCHKUNPK(cmUnpkSuId, &ruSap->spId, mBuf);
2559    CMCHKUNPK(SUnpkU32, &ruSap->sduRx, mBuf);
2560    CMCHKUNPK(SUnpkU32, &ruSap->sduTx, mBuf);
2561
2562    RETVALUE(ROK);
2563
2564 } /* end of cmUnpkKwuSapSts */
2565
2566 /* lkw_c_001.main_2 added support for L2 Measurement */
2567 #ifdef LTE_L2_MEAS
2568 #ifdef ANSI
2569 PUBLIC S16 cmPkLkwL2MeasReq
2570 (
2571 Pst * pst,
2572 KwL2MeasReqEvt *measReqEvt
2573 )
2574 #else
2575 PUBLIC S16 cmPkLkwL2MeasReq(pst, measReqEvt)
2576 Pst * pst;
2577 KwL2MeasReqEvt *measReqEvt;
2578 #endif
2579 {
2580    Buffer *mBuf = NULLP;
2581    TRC3(cmPkLkwL2MeasReq)
2582
2583    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2584 #if (ERRCLASS & ERRCLS_ADD_RES)
2585       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2586             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2587             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2588 #endif
2589       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2590       RETVALUE(RFAILED);
2591    }       
2592    if (cmPkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK) {
2593 #if (ERRCLASS & ERRCLS_ADD_RES)
2594       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2595             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2596             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2597 #endif
2598       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2599       SPutMsg(mBuf);
2600       RETVALUE(RFAILED);
2601    }
2602    if (SPkU16(measReqEvt->measPeriod, mBuf) != ROK) {
2603 #if (ERRCLASS & ERRCLS_ADD_RES)
2604       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2605             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2606             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2607 #endif
2608       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2609       SPutMsg(mBuf);
2610       RETVALUE(RFAILED);
2611    }
2612    if (SPkU32(measReqEvt->transId, mBuf) != ROK) {
2613 #if (ERRCLASS & ERRCLS_ADD_RES)
2614       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2615             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2616             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2617 #endif
2618       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2619       SPutMsg(mBuf);
2620       RETVALUE(RFAILED);
2621    }
2622
2623    pst->event = (Event) LKW_EVT_L2MEAS_REQ;
2624    RETVALUE(SPstTsk(pst,mBuf));
2625 }
2626
2627 #ifdef ANSI
2628 PUBLIC S16 cmPkKwL2MeasReqInfo
2629 (
2630 KwL2MeasReqInfo *param,
2631 Buffer *mBuf
2632 )
2633 #else
2634 PUBLIC S16 cmPkKwL2MeasReqInfo(param, mBuf)
2635 KwL2MeasReqInfo *param;
2636 Buffer *mBuf;
2637 #endif
2638 {
2639    U8 idx;
2640    U16 idx1;
2641
2642    TRC3(cmPkKwL2MeasReqInfo)
2643
2644    if((param->measType & LKW_L2MEAS_DL_IP) ||
2645          (param->measType & LKW_L2MEAS_UL_IP))
2646    {
2647       for(idx1 = 0;idx1 < param->val.ipThMeas.numUes;idx1++)
2648       {
2649
2650          CMCHKPK(cmPkLteCellId, param->val.ipThMeas.ueInfoLst[idx1].cellId, mBuf);
2651          CMCHKPK(cmPkLteRnti,   param->val.ipThMeas.ueInfoLst[idx1].ueId, mBuf);
2652          for(idx = 0; idx < param->val.ipThMeas.ueInfoLst[idx1].numQci; idx++)
2653          {
2654             CMCHKPK(SPkU8, param->val.ipThMeas.ueInfoLst[idx1].qci[idx], mBuf);
2655          }
2656          CMCHKPK(SPkU8, param->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
2657       }
2658       CMCHKPK(SPkU16, param->val.ipThMeas.numUes, mBuf);
2659       CMCHKPK(SPkU8, param->measType, mBuf);
2660       RETVALUE(ROK);
2661    }
2662    else
2663    {
2664       for(idx = 0; idx < param->val.nonIpThMeas.numQci; idx++)
2665       {
2666          CMCHKPK(SPkU8, param->val.nonIpThMeas.qci[idx], mBuf);
2667       }
2668       CMCHKPK(SPkU8, param->val.nonIpThMeas.numQci, mBuf);
2669       CMCHKPK(SPkU16, param->val.nonIpThMeas.numSamples, mBuf);
2670    }
2671    CMCHKPK(SPkU8, param->measType, mBuf);
2672    RETVALUE(ROK);
2673 }
2674
2675 #ifdef ANSI
2676 PUBLIC S16 cmPkLkwL2MeasStopReq
2677 (
2678 Pst *pst,
2679 U8  measType
2680 )
2681 #else
2682 PUBLIC S16 cmPkLkwL2MeasStopReq(pst, measType)
2683 Pst *pst;
2684 U8 measType;
2685 #endif
2686 {
2687    Buffer *mBuf = NULLP;
2688
2689    TRC3(cmPkLkwL2MeasStopReq)
2690    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2691 #if (ERRCLASS & ERRCLS_ADD_RES)
2692       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2693             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2694             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2695 #endif
2696       RETVALUE(RFAILED);
2697    }
2698    CMCHKPK(SPkU8, measType, mBuf);
2699    pst->event = (Event) LKW_EVT_L2MEAS_STOP_REQ;
2700    RETVALUE(SPstTsk(pst,mBuf));
2701 }
2702
2703 #ifdef ANSI
2704 PUBLIC S16 cmPkLkwL2MeasSendReq
2705 (
2706 Pst *pst,
2707 U8  measType
2708 )
2709 #else
2710 PUBLIC S16 cmPkLkwL2MeasSendReq(pst, measType)
2711 Pst *pst;
2712 U8 measType;
2713 #endif
2714 {
2715    Buffer *mBuf = NULLP;
2716
2717    TRC3(cmPkLkwL2MeasSendReq)
2718    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2719 #if (ERRCLASS & ERRCLS_ADD_RES)
2720       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2721             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2722             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2723 #endif
2724       RETVALUE(RFAILED);
2725    }
2726    CMCHKPK(SPkU8, measType, mBuf);
2727    pst->event = (Event) LKW_EVT_L2MEAS_SEND_REQ;
2728    RETVALUE(SPstTsk(pst,mBuf));
2729 }
2730 #ifdef TENB_SPLIT_ARCH
2731 #ifdef ANSI
2732 PUBLIC S16 cmUnpkLkwL2MeasReq
2733 (
2734 LkwL2MeasReq func,
2735 Pst *pst,
2736 Buffer *mBuf
2737 )
2738 #else
2739 PUBLIC S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
2740 LkwL2MeasReq func;
2741 Pst *pst;
2742 Buffer *mBuf;
2743 #endif
2744 {
2745    KwL2MeasReqEvt measReqEvt;
2746    
2747    TRC3(cmUnpkLkwL2MeasReq)
2748
2749    if (SUnpkU32(&measReqEvt.transId, mBuf) != ROK) {
2750       SPutMsg(mBuf);
2751 #if (ERRCLASS & ERRCLS_ADD_RES)
2752       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2753          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2754          (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2755 #endif
2756       RETVALUE(RFAILED);
2757    }
2758    if (SUnpkU16(&measReqEvt.measPeriod, mBuf) != ROK) {
2759       SPutMsg(mBuf);
2760 #if (ERRCLASS & ERRCLS_ADD_RES)
2761       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2762          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2763          (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2764 #endif
2765       RETVALUE(RFAILED);
2766    }
2767    if (cmUnpkKwL2MeasReqInfo(&measReqEvt.measReq, mBuf) != ROK) 
2768    {
2769       /*SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));*/
2770       SPutMsg(mBuf);
2771 #if (ERRCLASS & ERRCLS_ADD_RES)
2772       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2773            __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2774            (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2775 #endif
2776       RETVALUE(RFAILED);
2777    }
2778    SPutMsg(mBuf);
2779    RETVALUE((*func)(pst, &measReqEvt));
2780 }
2781 #else
2782 #ifdef ANSI
2783 PUBLIC S16 cmUnpkLkwL2MeasReq
2784 (
2785 LkwL2MeasReq func,
2786 Pst *pst,
2787 Buffer *mBuf
2788 )
2789 #else
2790 PUBLIC S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
2791 LkwL2MeasReq func;
2792 Pst *pst;
2793 Buffer *mBuf;
2794 #endif
2795 {
2796    S16   ret;
2797    KwL2MeasReqEvt *measReqEvt;
2798
2799    TRC3(cmUnpkLkwL2MeasReq)
2800
2801
2802    if((ret = SGetSBuf(pst->region, pst->pool, (Data **)&measReqEvt,\
2803                sizeof(KwL2MeasReqEvt))) != ROK)
2804    {
2805 #if (ERRCLASS & ERRCLS_ADD_RES)
2806       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2807             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2808             (ErrVal)ERRLKW, (ErrVal)0, "SGetMsg() failed");
2809 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
2810       RETVALUE(ret);
2811    }
2812
2813    if (SUnpkU32(&measReqEvt->transId, mBuf) != ROK) {
2814       SPutMsg(mBuf);
2815 #if (ERRCLASS & ERRCLS_ADD_RES)
2816       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2817             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2818             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2819 #endif
2820       RETVALUE(RFAILED);
2821    }
2822    if (SUnpkU16(&measReqEvt->measPeriod, mBuf) != ROK) {
2823       SPutMsg(mBuf);
2824 #if (ERRCLASS & ERRCLS_ADD_RES)
2825       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2826             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2827             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2828 #endif
2829       RETVALUE(RFAILED);
2830    }
2831    if (cmUnpkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK) 
2832    {
2833       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2834       SPutMsg(mBuf);
2835 #if (ERRCLASS & ERRCLS_ADD_RES)
2836       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2837             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2838             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2839 #endif
2840       RETVALUE(RFAILED);
2841    }
2842    SPutMsg(mBuf);
2843    RETVALUE((*func)(pst, measReqEvt));
2844 }
2845 #endif
2846
2847 #ifdef ANSI
2848 PUBLIC S16 cmUnpkKwL2MeasReqInfo
2849 (
2850 KwL2MeasReqInfo *param,
2851 Buffer *mBuf
2852 )
2853 #else
2854 PUBLIC S16 cmUnpkKwL2MeasReqInfo(param, mBuf)
2855 KwL2MeasReqInfo *param;
2856 Buffer *mBuf;
2857 #endif
2858 {
2859    U8 idx;
2860    U16 idx1; 
2861
2862    TRC3(cmUnpkKwL2MeasReqInfo)
2863
2864    CMCHKUNPK(SUnpkU8, &param->measType, mBuf);
2865
2866    if((param->measType & LKW_L2MEAS_DL_IP) ||
2867          (param->measType & LKW_L2MEAS_UL_IP))
2868    {
2869       CMCHKUNPK(SUnpkU16, &param->val.ipThMeas.numUes, mBuf);
2870       for(idx1 = 0;idx1 < param->val.ipThMeas.numUes;idx1++)
2871       {
2872          CMCHKUNPK(SUnpkU8, &param->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
2873          for(idx = param->val.ipThMeas.ueInfoLst[idx1].numQci; idx > 0; idx--)
2874          {
2875             CMCHKUNPK(SUnpkU8, &param->val.ipThMeas.ueInfoLst[idx1].\
2876                   qci[idx - 1], mBuf);
2877          }
2878          CMCHKUNPK(cmUnpkLteRnti, &param->val.ipThMeas.ueInfoLst[idx1].\
2879                ueId, mBuf);
2880          CMCHKUNPK(cmUnpkLteCellId, &param->val.ipThMeas.\
2881                ueInfoLst[idx1].cellId, mBuf);
2882       }
2883       RETVALUE(ROK);
2884    }
2885    else
2886    {
2887       CMCHKUNPK(SUnpkU16, &param->val.nonIpThMeas.numSamples, mBuf);
2888       CMCHKUNPK(SUnpkU8, &param->val.nonIpThMeas.numQci, mBuf);
2889       for(idx = param->val.nonIpThMeas.numQci; idx > 0; idx--)
2890       {
2891          CMCHKUNPK(SUnpkU8, &param->val.nonIpThMeas.qci[idx - 1], mBuf);
2892       }
2893    }
2894    RETVALUE(ROK);
2895 }
2896
2897 #ifdef ANSI
2898 PUBLIC S16 cmUnpkLkwL2MeasStopReq
2899 (
2900 LkwL2MeasStopReq func,
2901 Pst *pst,
2902 Buffer *mBuf
2903 )
2904 #else
2905 PUBLIC S16 cmUnpkLkwL2MeasStopReq(func, pst, mBuf)
2906 LkwL2MeasStopReq func;
2907 Pst *pst;
2908 Buffer *mBuf;
2909 #endif
2910 {
2911    U8 measType;
2912    TRC3(cmUnpkLkwL2MeasReq)
2913
2914    CMCHKUNPK(SUnpkU8, &measType, mBuf);
2915    SPutMsg(mBuf);
2916    RETVALUE((*func)(pst, measType));
2917 }
2918
2919 #ifdef ANSI
2920 PUBLIC S16 cmUnpkLkwL2MeasSendReq
2921 (
2922 LkwL2MeasSendReq func,
2923 Pst *pst,
2924 Buffer *mBuf
2925 )
2926 #else
2927 PUBLIC S16 cmUnpkLkwL2MeasSendReq(func, pst, mBuf)
2928 LkwL2MeasSendReq func;
2929 Pst *pst;
2930 Buffer *mBuf;
2931 #endif
2932 {
2933    U8    measType;
2934
2935    TRC3(cmUnpkLkwL2MeasSendReq)
2936
2937    CMCHKUNPK(SUnpkU8, &measType, mBuf); 
2938    SPutMsg(mBuf);
2939    RETVALUE((*func)(pst, measType));
2940 }
2941
2942 #ifdef ANSI
2943 PUBLIC S16 cmPkLkwL2MeasCfm
2944 (
2945 Pst * pst,
2946 KwL2MeasCfmEvt *measCfmEvt
2947 )
2948 #else
2949 PUBLIC S16 cmPkLkwL2MeasCfm(pst, measCfmEvt)
2950 Pst * pst;
2951 KwL2MeasCfmEvt *measCfmEvt;
2952 #endif
2953 {
2954    Buffer *mBuf = NULLP;
2955    U8 idx;
2956    U8 idx1;
2957
2958    TRC3(cmPkLkwL2MeasCfm)
2959
2960    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2961 #if (ERRCLASS & ERRCLS_ADD_RES)
2962       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2963             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2964             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2965 #endif
2966       SPutSBuf(pst->region, pst->pool, (Data *)measCfmEvt, sizeof(KwL2MeasCfmEvt));
2967       RETVALUE(RFAILED);
2968    }
2969
2970    if((measCfmEvt->measType & LKW_L2MEAS_ACT_UE) || \
2971          (measCfmEvt->measType & LKW_L2MEAS_UU_LOSS) || \
2972          (measCfmEvt->measType & LKW_L2MEAS_DL_DISC) ||  \
2973          (measCfmEvt->measType & LKW_L2MEAS_DL_DELAY)) 
2974    {
2975       for(idx = 0; idx < measCfmEvt->val.nonIpThMeas.numCfm; idx++)
2976       {
2977          if (cmPkKwL2MeasCfmInfo(&measCfmEvt->val.nonIpThMeas.measCfm[idx], \
2978                   mBuf, measCfmEvt->measType) != ROK) {
2979 #if (ERRCLASS & ERRCLS_ADD_RES)
2980             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2981                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2982                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2983 #endif
2984             SPutMsg(mBuf);
2985             RETVALUE(RFAILED);
2986          }
2987       }
2988
2989       if (SPkU16(measCfmEvt->val.nonIpThMeas.numCfm, mBuf) != ROK) {
2990 #if (ERRCLASS & ERRCLS_ADD_RES)
2991          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2992                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2993                (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2994 #endif
2995          SPutMsg(mBuf);
2996          RETVALUE(RFAILED);
2997       }
2998    }
2999    else
3000    {
3001       for(idx1 =0 ;idx1< measCfmEvt->val.ipThMeas.numUes;idx1++)
3002       {
3003
3004          for(idx = 0; idx < measCfmEvt->val.ipThMeas.ueInfoLst[idx1].numCfm; idx++)
3005          {
3006             if (cmPkKwL2MeasCfmInfo(&measCfmEvt->val.ipThMeas.ueInfoLst[idx1].\
3007                      measCfm[idx], mBuf, measCfmEvt->measType) != ROK) {
3008 #if (ERRCLASS & ERRCLS_ADD_RES)
3009                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3010                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3011                      (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3012 #endif
3013                SPutMsg(mBuf);
3014                RETVALUE(RFAILED);
3015             }
3016          }
3017
3018          if (SPkU16(measCfmEvt->val.ipThMeas.ueInfoLst[idx1].numCfm, mBuf) != ROK) {
3019 #if (ERRCLASS & ERRCLS_ADD_RES)
3020             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3021                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3022                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3023 #endif
3024             SPutMsg(mBuf);
3025             RETVALUE(RFAILED);
3026          }
3027
3028          CMCHKPK(cmPkLteCellId, measCfmEvt->val.ipThMeas.ueInfoLst[idx1].cellId, mBuf);
3029          CMCHKPK(cmPkLteRnti,   measCfmEvt->val.ipThMeas.ueInfoLst[idx1].ueId, mBuf);
3030       }
3031       SPkU16(measCfmEvt->val.ipThMeas.numUes, mBuf);
3032    }
3033
3034    CMCHKPK(SPkU8, measCfmEvt->measType, mBuf);
3035    CMCHKPK(cmPkCmStatus, &measCfmEvt->status, mBuf);
3036    if (SPkU32(measCfmEvt->transId, mBuf) != ROK) {
3037 #if (ERRCLASS & ERRCLS_ADD_RES)
3038       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3039             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3040             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3041 #endif
3042       SPutMsg(mBuf);
3043       RETVALUE(RFAILED);
3044    }
3045    pst->event = (Event) LKW_EVT_L2MEAS_CFM;
3046    RETVALUE(SPstTsk(pst,mBuf));
3047 }
3048
3049 #ifdef ANSI
3050 PUBLIC S16 cmPkKwL2MeasCfmInfo
3051 (
3052 KwL2MeasCfmInfo *param,
3053 Buffer *mBuf,
3054 U8 measType
3055 )
3056 #else
3057 PUBLIC S16 cmPkKwL2MeasCfmInfo(param, mBuf, measType)
3058 KwL2MeasCfmInfo *param;
3059 Buffer *mBuf;
3060 U8 measType;
3061 #endif
3062 {
3063    TRC3(cmPkKwL2MeasCfmInfo)
3064
3065    if((measType & LKW_L2MEAS_DL_IP) ||
3066          (measType & LKW_L2MEAS_UL_IP))
3067    {
3068       CMCHKPK(SPkF32, param->val.ipThrput.ulIpThPut, mBuf);
3069       CMCHKPK(SPkF32, param->val.ipThrput.dlIpThPut, mBuf);
3070       CMCHKPK(SPkU8, param->qci, mBuf);
3071       RETVALUE(ROK);
3072    }
3073    else  
3074    {
3075       CMCHKPK(SPkU32, param->val.nonIpThrput.dlDiscRate, mBuf);
3076       CMCHKPK(SPkU32, param->val.nonIpThrput.uuLoss, mBuf);
3077       CMCHKPK(SPkU32, param->val.nonIpThrput.numActUe, mBuf);
3078       CMCHKPK(SPkU32, param->val.nonIpThrput.dlSduDelay, mBuf);
3079       CMCHKPK(SPkU8,  param->qci, mBuf);
3080    } 
3081    RETVALUE(ROK);
3082 }
3083
3084 #ifdef ANSI
3085 PUBLIC S16 cmUnpkLkwL2MeasCfm
3086 (
3087 LkwL2MeasCfm func,
3088 Pst *pst,
3089 Buffer *mBuf
3090 )
3091 #else
3092 PUBLIC S16 cmUnpkLkwL2MeasCfm(func, pst, mBuf)
3093 LkwL2MeasCfm func;
3094 Pst *pst;
3095 Buffer *mBuf;
3096 #endif
3097 {
3098    U8 idx;
3099    U16 idx1;
3100    KwL2MeasCfmEvt measCfmEvt;
3101
3102    TRC3(cmUnpkLkwL2MeasCfm)
3103
3104    cmMemset((U8 *)&measCfmEvt, 0 , sizeof(KwL2MeasCfmEvt));
3105
3106    if (SUnpkU32(&measCfmEvt.transId, mBuf) != ROK) {
3107       SPutMsg(mBuf);
3108 #if (ERRCLASS & ERRCLS_ADD_RES)
3109       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3110             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3111             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3112 #endif
3113       RETVALUE(RFAILED);
3114    }
3115    CMCHKUNPK(cmUnpkCmStatus, &measCfmEvt.status, mBuf);
3116    CMCHKUNPK(SUnpkU8, &measCfmEvt.measType, mBuf);  
3117
3118    if(measCfmEvt.measType & LKW_L2MEAS_DL_IP || measCfmEvt.measType & LKW_L2MEAS_UL_IP)
3119    { 
3120       CMCHKUNPK(SUnpkU16, &measCfmEvt.val.ipThMeas.numUes, mBuf);
3121       for(idx1 = 0;idx1<measCfmEvt.val.ipThMeas.numUes;idx1++)
3122       {
3123          CMCHKUNPK(cmUnpkLteRnti, &measCfmEvt.val.ipThMeas.\
3124                ueInfoLst[idx1].ueId, mBuf);
3125          CMCHKUNPK(cmUnpkLteCellId, &measCfmEvt.val.ipThMeas.\
3126                ueInfoLst[idx1].cellId, mBuf);
3127          if (SUnpkU16(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
3128                   numCfm, mBuf) != ROK) {
3129             SPutMsg(mBuf);
3130 #if (ERRCLASS & ERRCLS_ADD_RES)
3131             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3132                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3133                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3134 #endif
3135             RETVALUE(RFAILED);
3136          }
3137          for(idx = measCfmEvt.val.ipThMeas.ueInfoLst[idx1].numCfm; idx > 0; idx--)
3138          {
3139             if (cmUnpkKwL2MeasCfmInfo(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
3140                      measCfm[idx - 1], mBuf, measCfmEvt.measType) != ROK) {
3141                SPutMsg(mBuf);
3142 #if (ERRCLASS & ERRCLS_ADD_RES)
3143                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3144                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3145                      (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3146 #endif
3147                RETVALUE(RFAILED);
3148             }
3149          }
3150       }
3151    }
3152    else
3153    {
3154       if (SUnpkU16(&measCfmEvt.val.nonIpThMeas.numCfm, mBuf) != ROK) {
3155          SPutMsg(mBuf);
3156 #if (ERRCLASS & ERRCLS_ADD_RES)
3157          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3158                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3159                (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3160 #endif
3161          RETVALUE(RFAILED);
3162       }
3163       for(idx = measCfmEvt.val.nonIpThMeas.numCfm; idx > 0; idx--)
3164       {
3165          if (cmUnpkKwL2MeasCfmInfo(&measCfmEvt.val.nonIpThMeas.measCfm[idx - 1], \
3166                   mBuf, measCfmEvt.measType) != ROK) {
3167             SPutMsg(mBuf);
3168 #if (ERRCLASS & ERRCLS_ADD_RES)
3169             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3170                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3171                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3172 #endif
3173             RETVALUE(RFAILED);
3174          }
3175       }
3176    }
3177    SPutMsg(mBuf);
3178    RETVALUE((*func)(pst, &measCfmEvt));
3179 }
3180
3181 #ifdef ANSI
3182 PUBLIC S16 cmUnpkKwL2MeasCfmInfo
3183 (
3184 KwL2MeasCfmInfo *param,
3185 Buffer *mBuf,
3186 U8 measType
3187 )
3188 #else
3189 PUBLIC S16 cmUnpkKwL2MeasCfmInfo(param, mBuf, measType)
3190 KwL2MeasCfmInfo *param;
3191 Buffer *mBuf;
3192 U8 measType;
3193 #endif
3194 {
3195    TRC3(cmUnpkKwL2MeasCfmInfo)
3196
3197    if((measType & LKW_L2MEAS_DL_IP) ||
3198          (measType & LKW_L2MEAS_UL_IP))
3199    {
3200       CMCHKUNPK(SUnpkU8,  &param->qci, mBuf);
3201       CMCHKUNPK(SUnpkF32, &param->val.ipThrput.dlIpThPut, mBuf);
3202       CMCHKUNPK(SUnpkF32, &param->val.ipThrput.ulIpThPut, mBuf);
3203    }
3204    else
3205
3206    {
3207       CMCHKUNPK(SUnpkU8,  &param->qci, mBuf);
3208       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.dlSduDelay, mBuf);
3209       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.numActUe, mBuf);
3210       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.uuLoss, mBuf);
3211       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.dlDiscRate, mBuf);
3212    }
3213    RETVALUE(ROK);
3214 }
3215
3216
3217 #ifdef ANSI
3218 PUBLIC S16 cmPkLkwL2MeasStopCfm
3219 (
3220 Pst * pst,
3221 U8 measType,
3222 U8 status
3223 )
3224 #else
3225 PUBLIC S16 cmPkLkwL2MeasStopCfm(pst, measType,status)
3226 Pst * pst;
3227 U8  measType;
3228 U8  status
3229 #endif
3230 {
3231    Buffer *mBuf = NULLP;
3232    TRC3(cmPkLkwL2MeasStopCfm)
3233
3234    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3235 #if (ERRCLASS & ERRCLS_ADD_RES)
3236       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3237             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3238             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3239 #endif
3240       RETVALUE(RFAILED);
3241    }
3242    CMCHKPK(SPkU8, status, mBuf);
3243    CMCHKPK(SPkU8, measType, mBuf);
3244    pst->event = (Event) LKW_EVT_L2MEAS_STOP_CFM;
3245    RETVALUE(SPstTsk(pst,mBuf));
3246 }
3247
3248 #ifdef ANSI
3249 PUBLIC S16 cmUnpkLkwL2MeasStopCfm
3250 (
3251 LkwL2MeasStopCfm func,
3252 Pst *pst,
3253 Buffer *mBuf
3254 )
3255 #else
3256 PUBLIC S16 cmUnpkLkwL2MeasStopCfm(func, pst, mBuf)
3257 LkwL2MeasStopCfm func;
3258 Pst *pst;
3259 Buffer *mBuf;
3260 #endif
3261 {
3262    U8 measType;
3263    U8 status;
3264    TRC3(cmUnpkLkwL2MeasCfm)
3265    CMCHKUNPK(SUnpkU8,  &measType, mBuf);
3266    CMCHKUNPK(SUnpkU8,  &status, mBuf);
3267    SPutMsg(mBuf);
3268    RETVALUE((*func)(pst, measType,status));
3269 }
3270 #endif /* LTE_L2_MEAS */
3271 #endif /* LCLKW */
3272
3273 \f  
3274 /**********************************************************************
3275          End of file
3276  **********************************************************************/