cu link failure fix
[o-du/l2.git] / src / 5gnrrlc / kw_ptmi.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may not use this file except in compliance with the License.           #
7 #   You may obtain a copy of the License at                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
11 #   Unless required by applicable law or agreed to in writing, software        #
12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
14 #   See the License for the specific language governing permissions and        #
15 #   limitations under the License.                                             #
16 ################################################################################
17 *******************************************************************************/
18
19 /********************************************************************20**
20
21         Name:     RLC Layer Management interface
22
23         Type:     C source file
24
25         Desc:     This file contains source code for RLC layer management
26                   interface primitives. It includes the definition of the
27                   following functions and their portable function
28                   definitions.
29                      -- PjMiLpjCfgCfm
30                      -- PjMiLpjCntrlCfm
31                      -- PjMiLpjStaInd
32
33
34         File:     kw_ptmi.c
35
36 *********************************************************************21*/
37
38 \f
39 /* header (.h) include files */
40 #include "envopt.h"        /* environment options */
41 #include "envdep.h"        /* environment dependent */
42 #include "envind.h"        /* environment independent */
43
44 #include "gen.h"           /* general */
45 #include "ssi.h"           /* system services */
46 #include "cm5.h"           /* common timer defines */
47 #include "cm_tkns.h"       /* common tokens defines */
48 #include "cm_mblk.h"       /* common memory allocation library defines */
49 #include "cm_llist.h"      /* common link list  defines  */
50 #include "cm_hash.h"       /* common hash list  defines */
51 #include "cm_lte.h"        /* common LTE defines */
52 #include "lkw.h"           /* LKW defines */
53 #include "ckw.h"           /* CKW defines */
54 #include "kwu.h"           /* KWU defines */
55 #include "rgu.h"           /* RGU defines */
56
57 #include "kw_env.h"        /* RLC environment options */
58 #include "kw.h"            /* RLC defines */
59
60 /* extern (.x) include files */
61 #include "gen.x"           /* general */
62 #include "ssi.x"           /* system services */
63
64 #include "cm5.x"           /* common timer library */
65 #include "cm_tkns.x"       /* common tokens */
66 #include "cm_mblk.x"       /* common memory allocation */
67 #include "cm_llist.x"      /* common link list */
68 #include "cm_hash.x"       /* common hash list */
69 #include "cm_lte.x"        /* common LTE includes */
70 #include "cm_lib.x"        /* common memory allocation library */
71 #include "lkw.x"           /* LKW */
72 #include "ckw.x"           /* CKW */
73 #include "kwu.x"           /* KWU */
74 #include "rgu.x"           /* RGU */
75
76 #include "kw.x"
77
78 /* local defines */
79 #define MAXKWMI 2               /* max. layer management interfaces */
80
81 #ifndef LCKWMILKW
82 #define PTKWLKW
83 #endif
84
85
86 #ifndef SM
87 #define PTKWLKW
88 #endif
89
90
91 \f
92 #ifdef PTKWLKW
93 /* portable functions */
94
95 PRIVATE S16 PtMiLkwCfgCfm    ARGS((Pst *pst, KwMngmt *cfm));
96 PRIVATE S16 PtMiLkwCntrlCfm  ARGS((Pst *pst, KwMngmt *cfm));
97 PRIVATE S16 PtMiLkwStaInd    ARGS((Pst *pst, KwMngmt *usta));
98
99 PRIVATE S16 PtMiLkwStaCfm    ARGS((Pst *pst, KwMngmt *cfm));
100 PRIVATE S16 PtMiLkwStsCfm    ARGS((Pst *pst, Action action,
101                                 KwMngmt *cfm));
102 PRIVATE S16 PtMiLkwTrcInd    ARGS((Pst *pst, KwMngmt *trc,
103                                 Buffer *mBuf));
104 /* kw005.201 added support for L2 Measurement */
105 #ifdef LTE_L2_MEAS
106 PRIVATE S16 PtMiLkwL2MeasCfm   ARGS((Pst *pst, KwL2MeasCfmEvt *measEvt));
107 PRIVATE S16 PtMiLkwL2MeasStopCfm   ARGS((Pst *pst, U8 measType,U8 status));
108 #endif /*  LTE_L2_MEAS */
109 #endif /* PTKWLKW */
110
111 \f
112 /*********************************************************************
113  *             Primitives for LKW interface 
114  ********************************************************************/
115 /* Configuration confirmation primitive */
116
117 PRIVATE LkwCfgCfm kwMiLkwCfgCfmMt[MAXKWMI] =
118 {
119 #ifdef LCKWMILKW
120    cmPkLkwCfgCfm,            /* 0 - loosely coupled - fc */
121 #else
122    PtMiLkwCfgCfm,            /* 0 - tightly coupled portable */
123 #endif /* LCRLMILKW */
124 #ifdef SM
125    SmMiLkwCfgCfm,            /* 1 - tightly coupled layer management*/
126 #else
127    PtMiLkwCfgCfm,            /* 1 - tightly coupled portable */
128 #endif /* SM */
129 };
130
131 /* control confirmation primitives */
132
133 PRIVATE LkwCntrlCfm kwMiLkwCntrlCfmMt[MAXKWMI] =
134 {
135 #ifdef LCKWMILKW 
136    cmPkLkwCntrlCfm,          /* 0 - loosely coupled - fc */
137 #else
138    PtMiLkwCntrlCfm,          /* 0 - tightly coupled portable */
139 #endif /* LCRLMILKW */
140 #ifdef SM
141    SmMiLkwCntrlCfm,          /* 1 - tightly coupled layer management*/
142 #else
143    PtMiLkwCntrlCfm,          /* 1 - tightly coupled portable */
144 #endif /* SM */
145 };
146
147 /* Status Indication primitive */
148
149 PRIVATE LkwStaInd kwMiLkwStaIndMt[MAXKWMI] =
150 {
151 #ifdef LCKWMILKW 
152    cmPkLkwStaInd,            /* 0 - loosely coupled  */
153 #else
154    PtMiLkwStaInd,            /* 0 - tightly coupled, portable */
155 #endif /* LCKWMILKW */
156 #ifdef SM
157    SmMiLkwStaInd,            /* 1 - tightly coupled, layer management */
158 #else
159    PtMiLkwStaInd,            /* 1 - tightly coupled, portable */
160 #endif /* SM */
161 };
162
163 /* Status confirm primitive */
164
165 PRIVATE LkwStaCfm kwMiLkwStaCfmMt[MAXKWMI] =
166 {
167 #ifdef LCKWMILKW 
168    cmPkLkwStaCfm,            /* 0 - loosely coupled  */
169 #else
170    PtMiLkwStaCfm,            /* 0 - tightly coupled, portable */
171 #endif /* LCKWMILKW */
172 #ifdef SM
173    SmMiLkwStaCfm,            /* 1 - tightly coupled, layer management */
174 #else
175    PtMiLkwStaCfm,            /* 1 - tightly coupled, portable */
176 #endif /* SM */
177 };
178
179 /* Statistics confirm primitive */
180
181 PRIVATE LkwStsCfm kwMiLkwStsCfmMt[MAXKWMI] =
182 {
183 #ifdef LCKWMILKW
184    cmPkLkwStsCfm,            /* 0 - loosely coupled  */
185 #else
186    PtMiLkwStsCfm,            /* 0 - tightly coupled, portable */
187 #endif /* LCRLMILKW */
188 #ifdef SM
189    SmMiLkwStsCfm,            /* 1 - tightly coupled, layer management */
190 #else
191    PtMiLkwStsCfm,            /* 1 - tightly coupled, portable */
192 #endif /* SM */
193 };
194
195 /* Trace indication primitive */
196
197 PRIVATE LkwTrcInd kwMiLkwTrcIndMt[MAXKWMI] =
198 {
199 #ifdef LCKWMILKW
200    cmPkLkwTrcInd,            /* 0 - loosely coupled  */
201 #else
202    PtMiLkwTrcInd,            /* 0 - tightly coupled, portable */
203 #endif /* LCKWMILKW */
204 #ifdef SM
205    SmMiLkwTrcInd,            /* 1 - tightly coupled, layer management */
206 #else
207    PtMiLkwTrcInd,            /* 1 - tightly coupled, portable */
208 #endif /* SM */
209 };
210
211 /* kw005.201 added support for L2 Measurement */
212 #ifdef LTE_L2_MEAS
213 PRIVATE CONSTANT LkwL2MeasCfm KwMiLkwL2MeasCfmMt[] =
214 {
215 #ifdef LCKWMILKW
216    cmPkLkwL2MeasCfm,
217 #else
218    PtMiLkwL2MeasCfm,
219 #endif
220 #ifdef SM
221    SmMiLkwL2MeasCfm,
222 #else
223    PtMiLkwL2MeasCfm,
224 #endif
225 };
226 PRIVATE CONSTANT LkwL2MeasStopCfm KwMiLkwL2MeasStopCfmMt[] =
227 {
228 #ifdef LCKWMILKW
229    cmPkLkwL2MeasStopCfm,
230 #else
231    PtMiLkwL2MeasStopCfm,
232 #endif
233 #ifdef SM
234    SmMiLkwL2MeasStopCfm,
235 #else
236    PtMiLkwL2MeasStopCfm,
237 #endif
238 };
239 #endif /*  LTE_L2_MEAS */
240 \f  
241 /****************************************************************************
242  *                         LKW Interface Mt functions
243  ***************************************************************************/
244 /**
245    @brief
246    This function is called by the KwMiLkwCfgReq function for responding
247    to configuration requests.The cfm field in the KwMngmt  structure contains
248  the response value.
249
250    - This function calls the mapping matrix for sending the configuration
251      confirmation.
252    - The actual function called depends on the coupling at the LKW interface.
253    - For a loosely coupled interface, a common packing function is called.
254    - The packing function packs the parameter in a message buffer and posts
255      the message to the target task.
256    - For a tightly coupled interface, the actual function called depends on
257      the layer manager API provided.
258
259 */
260 #ifdef ANSI
261 PUBLIC S16 KwMiLkwCfgCfm
262 (
263 Pst        *pst,                /* post structure */
264 KwMngmt    *cfm                 /* Layer Management structure */
265 )
266 #else
267 PUBLIC S16 KwMiLkwCfgCfm(pst, cfm)
268 Pst        *pst;                /* post structure */
269 KwMngmt    *cfm;                /* Layer Management structure */
270 #endif
271 {
272    TRC3(KwMiLkwCfgCfm);
273
274    /* jump to specific primitive depending on configured selector */
275    (*kwMiLkwCfgCfmMt[pst->selector])(pst, cfm);
276    
277    RETVALUE(ROK);
278 }
279
280
281 /**
282    @brief
283    This function is called by the KwMiLkwCntrlReq function to send a control confirm to the layer management module.
284
285    - This function calls the mapping matrix for sending the control confirmation.
286    - Actual function called depends on the coupling of the LKW interface.
287    - For a loosely coupled interface, a common packing function is called.
288    - The packing function packs the parameter in a message buffer and posts the
289      message to the target task.
290    - For a tightly coupled interface, the actual function called depends on the
291      layer manager API provided.
292
293 */
294 #ifdef ANSI
295 PUBLIC S16 KwMiLkwCntrlCfm
296 (
297 Pst *pst,                    /* post structure */
298 KwMngmt *cfm                 /* configure */
299 )
300 #else
301 PUBLIC S16 KwMiLkwCntrlCfm(pst, cfm)
302 Pst *pst;                    /* post structure */
303 KwMngmt *cfm;                /* confirm */
304 #endif
305 {
306    TRC3(KwMiLkwCntrlCfm)
307
308    /* jump to specific primitive depending on configured selector */
309    (*kwMiLkwCntrlCfmMt[pst->selector])(pst, cfm);
310
311    RETVALUE(ROK);
312
313 } /* end of KwMiLkwCntrlCfm */
314
315 /**
316    @brief
317    Description:
318    - This function can be used by RLC to send unsolicited status information
319      to the layer manager, when the unsolicited status flag is enabled by the
320      layer manager through a previous control request.
321
322    - This function calls the mapping matrix for sending the unsolicited status
323      indication.The actual function called depends on the coupling of the
324      LKW interface.
325
326    - For a loosely coupled interface, a common packing function is called. The
327      packing function packs the parameter in a message buffer and posts the
328      message to the target task.
329
330    - For a tightly coupled interface, the actual function called depends on
331      the layer manager API provided.
332 */
333 #ifdef ANSI
334 PUBLIC S16 KwMiLkwStaInd
335 (
336 Pst     *pst,                /* post structure */
337 KwMngmt *usta                /* unsolicited status */
338 )
339 #else
340 PUBLIC S16 KwMiLkwStaInd(pst, usta)
341 Pst     *pst;                /* post structure */
342 KwMngmt *usta;               /* unsolicited status */
343 #endif
344 {
345    TRC3(KwMiLkwStaInd);
346
347    /* jump to specific primitive depending on configured selector */
348    (*kwMiLkwStaIndMt[pst->selector])(pst, usta);
349
350    RETVALUE(ROK);
351 } /* end of KwMiLkwStaInd */
352
353
354 /**
355    @brief
356    - This function is called by the KwMiLkwStaReq function to send
357       the requested status information to the layer manager.
358
359    - This function calls the mapping matrix for sending the status
360       confirmation. The actual function called depends on the coupling
361       of the LKW interface.
362
363    - For a loosely coupled interface, a common packing function is called.
364       The packing function packs the parameter in a message buffer and
365       posts the message to the target task.
366
367    - For a tightly coupled interface, the actual function called depends
368       on the layer manager API provided.
369
370 */
371 #ifdef ANSI
372 PUBLIC S16 KwMiLkwStaCfm
373 (
374 Pst *pst,                    /* post structure */
375 KwMngmt *cfm                 /* solicited status confirmation */
376 )
377 #else
378 PUBLIC S16 KwMiLkwStaCfm(pst, cfm)
379 Pst *pst;                    /* post structure */
380 KwMngmt *cfm;                /* solicited status confirmation */
381 #endif
382 {
383    TRC3(KwMiLkwStaCfm);
384
385    /* jump to specific primitive depending on configured selector */
386    (*kwMiLkwStaCfmMt[pst->selector])(pst, cfm);
387
388    RETVALUE(ROK);
389
390 } /* end of KwMiLkwStaCfm */
391
392
393 /**
394    @brief
395    - This function is called by the KwMiLkwStsReq function for responding
396       to statistics requests.
397
398    - This function calls the mapping matrix for sending the statistics
399       confirmation. The actual function called depends on the coupling
400       of the LKW interface.
401
402    - For a loosely coupled interface, a common packing function is called.
403       The packing function packs the parameter in a message buffer and
404       posts the message to the target task.
405
406    - For a tightly coupled interface, the actual function called depends
407       on the layer manager API provided.
408
409 */
410 #ifdef ANSI
411 PUBLIC S16 KwMiLkwStsCfm
412 (
413 Pst *pst,                    /* post structure */
414 Action action,               /* action */
415 KwMngmt *cfm                 /* statistics confirmation */
416 )
417 #else
418 PUBLIC S16 KwMiLkwStsCfm(pst, action, cfm)
419 Pst *pst;                    /* post structure */
420 Action action;               /* action */
421 KwMngmt *cfm;                /* statistics confirmation */
422 #endif
423 {
424    TRC3(KwMiLkwStsCfm);
425
426    /* jump to specific primitive depending on configured selector */
427    (*kwMiLkwStsCfmMt[pst->selector])(pst, action, cfm);
428
429    RETVALUE(ROK);
430
431 } /* end of KwMiLkwStsCfm */
432
433 /**
434    @brief
435    - This function can be used by RLC module to send unsolicited trace
436       indications to the layer manager, when tracing is enabled by the
437       layer manager through a previous control request.
438
439    - This function calls the mapping matrix for sending the trace indication.
440       The actual function called depends on the coupling of the LKW interface.
441
442    - For a loosely coupled interface, a common packing function is called.
443       The packing function packs the parameter in a message buffer and posts
444       the message to the target task.
445
446    - For a tightly coupled interface, the actual function called depends on
447       the layer manager API provided.
448
449 */
450 #ifdef ANSI
451 PUBLIC S16 KwMiLkwTrcInd
452 (
453 Pst *pst,                    /* post structure */
454 KwMngmt *trc,                /* trace indication */
455 Buffer *mBuf                 /* message buffer */
456 )
457 #else
458 PUBLIC S16 KwMiLkwTrcInd(pst, trc, mBuf)
459 Pst *pst;                    /* post structure */
460 KwMngmt *trc;                /* trace indication */
461 Buffer *mBuf;                /* message buffer */
462 #endif
463 {
464    TRC3(KwMiLkwTrcInd);
465
466    /* jump to specific primitive depending on configured selector */
467    (*kwMiLkwTrcIndMt[pst->selector])(pst, trc, mBuf);
468
469    RETVALUE(ROK);
470
471 } /* end of KwMiLkwTrcInd */
472
473
474 /* kw005.201 added support for L2 Measurement */
475 #ifdef LTE_L2_MEAS
476 #ifdef ANSI
477 PUBLIC S16 KwMiLkwL2MeasCfm
478 (
479 Pst * pst,
480 KwL2MeasCfmEvt *measEvt
481 )
482 #else
483 PUBLIC S16 KwMiLkwL2MeasCfm(pst, measEvt)
484 Pst * pst;
485 KwL2MeasCfmEvt *measEvt;
486 #endif
487 {
488
489    TRC3(KwMiLkwL2MeasCfm)
490
491    (*KwMiLkwL2MeasCfmMt[pst->selector])(pst, measEvt);
492
493    RETVALUE(ROK);
494
495 }
496 #ifdef ANSI
497 PUBLIC S16 KwMiLkwL2MeasStopCfm
498 (  
499 Pst *pst,
500 U8  measType,
501 U8  status
502 )
503 #else
504 PUBLIC S16 KwMiLkwL2MeasStopCfm(pst, measType,status)
505 Pst *pst;
506 U8  measType;
507 U8  status;
508 #endif
509 {
510
511    TRC3(KwMiLkwL2MeasStopCfm)
512
513    (*KwMiLkwL2MeasStopCfmMt[pst->selector])(pst, measType,status);
514
515    RETVALUE(ROK);
516
517 }
518 #endif /*  LTE_L2_MEAS */
519 #ifdef PTKWLKW
520
521 \f
522 /*************************************************************************
523  *                         Porting Functions
524  ************************************************************************/
525 /*
526  *
527  *       Fun:   configuration  Confirm
528  *
529  *       Desc:  This function is used to confirm the receipt of configuration
530  *              request from layer management.
531  *
532  *       Ret:   ROK      - ok
533  *
534  *       Notes: None
535  *
536  *       File:  kw_ptmi.c
537  *
538  */
539
540 #ifdef ANSI
541 PUBLIC S16 PtMiLkwCfgCfm
542 (
543 Pst *pst,                    /* post structure */
544 KwMngmt *cfm                 /* Layer Management structure */
545 )
546 #else
547 PUBLIC S16 PtMiLkwCfgCfm(pst, cfm)
548 Pst *pst;                    /* post structure */
549 KwMngmt *cfm;                /* Layer Management structure */
550 #endif
551 {
552    TRC3(PtMiLkwCfgCfm)
553
554    UNUSED(pst);
555    UNUSED(cfm);
556
557    TRC2(PtMiLkwCfgCfm() : function is not implemented)
558
559    RETVALUE(ROK);
560 } /* end of PtMiLkwCfgCfm */
561
562 /*
563  *
564  *       Fun:   Control Confirmation
565  *
566  *       Desc:  This function is the portable version of used to
567  *              confirm the receipt of configuration request from
568  *              layer management.
569  *
570  *       Ret:   ROK      - ok
571  *
572  *       Notes: None
573  *
574  *       File:  kw_ptmi.c
575  *
576  */
577
578 #ifdef ANSI
579 PRIVATE S16 PtMiLkwCntrlCfm
580 (
581 Pst *pst,                 /* Post structure */
582 KwMngmt *cfm              /* Layer Management structure */
583 )
584 #else
585 PRIVATE S16 PtMiLkwCntrlCfm(pst, cfm)
586 Pst *pst;                 /* Post structure */
587 KwMngmt *cfm;             /* Layer Management structure */
588 #endif
589 {
590    TRC3(PtMiLkwCntrlCfm);
591
592    UNUSED(pst);
593    UNUSED(cfm);
594
595    TRC2(PtMiLkwCntrlCfm() :  function is not implemented)
596
597    RETVALUE(ROK);
598 } /* end of PtMiLkwCntrlCfm */
599
600
601 /*
602  *
603  *       Fun:   unsolicited status indication
604  *
605  *       Desc:  This function is the portable version  used to
606  *              send the status indication to the layer manager
607  *
608  *       Ret:   ROK      - ok
609  *
610  *       Notes: None
611  *
612  *       File:  kw_ptmi.c
613  *
614  */
615 #ifdef ANSI
616 PRIVATE S16 PtMiLkwStaInd
617 (
618 Pst *pst,                    /* post structure */
619 KwMngmt *usta                /* unsolicited status */
620 )
621 #else
622 PRIVATE S16 PtMiLkwStaInd(pst, usta)
623 Pst *pst;                    /* post structure */
624 KwMngmt *usta;               /* unsolicited status */
625 #endif
626 {
627    TRC3(PtMiLkwStaInd)
628
629    UNUSED(pst);
630    UNUSED(usta);
631
632    TRC2(PtMiLkwStaInd() : function is not implemented)
633
634    RETVALUE(ROK);
635 } /* end of PtMiLkwStaInd */
636
637
638 /*
639  *
640  *       Fun:   portable function for solicited status confirmation
641  *
642  *       Desc:  This function is the portable version  used to
643  *              send the status confirmation to the layer manager
644  *
645  *       Ret:   ROK      - ok
646  *
647  *       Notes: None
648  *
649  *       File:  kw_ptmi.c
650  *
651  */
652 #ifdef ANSI
653 PRIVATE S16 PtMiLkwStaCfm
654 (
655 Pst *pst,                    /* post structure */
656 KwMngmt *cfm                 /* solicited status confirmation */
657 )
658 #else
659 PRIVATE S16 PtMiLkwStaCfm(pst, cfm)
660 Pst *pst;                    /* post structure */
661 KwMngmt *cfm;                /* solicited status confirmation */
662 #endif
663 {
664    TRC3(PtMiLkwStaCfm)
665
666    UNUSED(pst);
667    UNUSED(cfm);
668
669    RETVALUE(ROK);
670 } /* end of PtMiLkwStaCfm */
671
672
673 /*
674  *
675  *       Fun:   portable function for statistics confirmation
676  *
677  *       Desc:  This function is the portable version  used to
678  *              send the statistics confirmation to the layer manager
679  *
680  *       Ret:   ROK      - ok
681  *
682  *       Notes: None
683  *
684  *       File:  kw_ptmi.c
685  *
686  */
687 #ifdef ANSI
688 PRIVATE S16 PtMiLkwStsCfm
689 (
690 Pst *pst,                    /* post structure */
691 Action action,               /* action */
692 KwMngmt *cfm                 /* statistics confirmation */
693 )
694 #else
695 PRIVATE S16 PtMiLkwStsCfm(pst, action, cfm)
696 Pst *pst;                    /* post structure */
697 Action action;               /* action */
698 KwMngmt *cfm;                /* statistics confirmation */
699 #endif
700 {
701    TRC3(PtMiLkwStsCfm)
702
703    UNUSED(pst);
704    UNUSED(action);
705    UNUSED(cfm);
706
707    RETVALUE(ROK);
708 } /* end of PtMiLkwStsCfm */
709
710
711 /*
712  *
713  *       Fun:   portable function for trace indication
714  *
715  *       Desc:  This function is the portable version  used to
716  *              send trace indication to the layer manager
717  *
718  *       Ret:   ROK      - ok
719  *
720  *       Notes: None
721  *
722  *       File:  kw_ptmi.c
723  *
724  */
725 #ifdef ANSI
726 PRIVATE S16 PtMiLkwTrcInd
727 (
728 Pst *pst,                    /* post structure */
729 KwMngmt *trc,                /* trace indication */
730 Buffer *mBuf                 /* message buffer */
731 )
732 #else
733 PRIVATE S16 PtMiLkwTrcInd(pst, trc, mBuf)
734 Pst *pst;                    /* post structure */
735 KwMngmt *trc;                /* trace indication */
736 Buffer *mBuf;                /* message buffer */
737 #endif
738 {
739    TRC3(PtMiLkwTrcInd)
740
741    UNUSED(pst);
742    UNUSED(trc);
743    UNUSED(mBuf);
744
745    RETVALUE(ROK);
746 } /* end of PtMiLkwTrcInd */
747
748 /* kw005.201 added support for L2 Measurement */
749 #ifdef LTE_L2_MEAS
750 #ifdef ANSI
751 PRIVATE S16 PtMiLkwL2MeasCfm
752 (
753 Pst * pst,
754 KwL2MeasCfmEvt * measEvt
755 )
756 #else
757 PRIVATE S16 PtMiLkwL2MeasCfm(pst, measEvt)
758 Pst * pst;
759 KwL2MeasCfmEvt * measEvt;
760 #endif
761 {
762
763    TRC3(PtMiLkwL2MeasCfm)
764
765    UNUSED(pst);
766    UNUSED(measEvt);
767
768    RETVALUE(ROK);
769
770 }
771 #ifdef ANSI
772 PRIVATE S16 PtMiLkwL2MeasStopCfm
773 (
774 Pst * pst,
775 U8 measType,
776 U8 status
777 )
778 #else
779 PRIVATE S16 PtMiLkwL2MeasStopCfm(pst, measType,status)
780 Pst * pst;
781 U8  measType;
782 U8  status;
783 #endif
784 {
785
786    TRC3(PtMiLkwL2MeasStopCfm)
787
788    UNUSED(pst);
789    UNUSED(measType);
790    UNUSED(status);
791
792    RETVALUE(ROK);
793
794 }
795 #endif /*  LTE_L2_MEAS */
796 #endif /* PTKWLKW */
797
798
799 /********************************************************************30**
800
801          End of file
802 **********************************************************************/