cleanup of BuildAndSendUESetReq
[o-du/l2.git] / src / 5gnrmac / rg_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  
21      Name:     LTE-MAC layer
22   
23      Type:     C source file
24   
25      Desc:     C source code for portable definitions for Layer Manager
26                Interface primitives.
27   
28      File:     rg_ptmi.c 
29   
30 **********************************************************************/
31
32 /** @file rg_ptmi.c
33 @brief This file contains the definitions for Layer Manager
34        Interface primitives that are invoked from MAC to Layer Manager
35        (Confirmations and Indications) Portable functions corresponding
36        to these primitives are also defined.
37 */
38
39 /* header include files (.h) */
40 #include "envopt.h"        /* environment options */
41 #include "envdep.h"        /* environment dependent */
42 #include "envind.h"        /* environment independent */
43 #include "gen.h"           /* general */
44 #include "ssi.h"           /* system services */
45 #include "cm_tkns.h"       /* Common Token Defines */
46 #include "cm_llist.h"      /* Common Link List Defines */
47 #include "cm_hash.h"       /* Common Hash List Defines */
48 #include "cm_lte.h"        /* Common LTE Defines */
49 #include "lrg.h"           /* LRG Interface defines */
50
51 /* header/extern include files (.x) */
52 #include "gen.x"           /* general */
53 #include "ssi.x"           /* system services */
54 #include "cm_tkns.x"       /* Common Token Definitions */
55 #include "cm_llist.x"      /* Common Link List Definitions */
56 #include "cm_lib.x"        /* Common Library Definitions */
57 #include "cm_hash.x"       /* Common Hash List Definitions */
58 #include "cm_lte.x"        /* Common LTE Defines */
59 #include "lrg.x"           /* LRG Interface includes */
60
61 #ifdef __cplusplus
62 extern "C" {
63 #endif /* __cplusplus */
64
65 #if !(defined(LCRGMILRG) && defined(SM))
66 #define PTRGMILRG
67 #endif
68
69 #define RG_MAX_LRG_USR 2 
70
71 /* portable functions at LRG interface */
72 #ifdef PTRGMILRG
73 EXTERN S16 PtMiLrgCfgCfm ARGS((Pst *pst, RgMngmt *cfm));
74 EXTERN S16 PtMiLrgSchCfgCfm ARGS((Pst *pst, RgMngmt *cfm));
75 EXTERN S16 PtMiLrgStsCfm ARGS((Pst *pst, RgMngmt *cfm));
76 EXTERN S16 PtMiLrgStaCfm ARGS((Pst *pst, RgMngmt *cfm));
77 EXTERN S16 PtMiLrgStaInd ARGS((Pst *pst, RgMngmt *usta));
78 EXTERN S16 PtMiLrgSchStaInd ARGS((Pst *pst, RgMngmt *usta));
79 EXTERN S16 PtMiLrgCntrlCfm ARGS((Pst *pst, RgMngmt *cfm));
80 EXTERN S16 PtMiLrgSchCntrlCfm ARGS((Pst *pst, RgMngmt *cfm));
81 EXTERN S16 PtMiLrgTrcInd ARGS((Pst *pst, RgMngmt *trc,Buffer *mBuf));
82 #ifdef LTE_L2_MEAS
83 EXTERN S16 PtMiLrgSchL2MeasCfm ARGS((Pst *pst, LrgSchMeasCfmInfo *cfm));
84 EXTERN S16 PtMiLrgSchL2MeasStopCfm ARGS((Pst *pst,LrgSchMeasCfmInfo *cfm ));
85 #endif
86 #endif
87
88 /* ***********LRG interface Mapping matrices ********************/
89
90 /** @brief Configuration Confirm primitive Matrix 
91  *  This matrix defines the mapping between the configuration confirm
92  *  primitive called by the upper interface of MAC layer and the 
93  *  corresponding primitives of the MAC layer service user(s).
94  *
95  *  The parameter RG_MAX_LRG_USR defines the maximum number of Layer 
96  *  managers of MAC at the LRG interface. This is an array of functions
97  *  per primitive invoked by MAC whose size is RG_MAX_LRG_USR.
98  * 
99  *  The dispatching is performed by the configurable variable: selector.
100  *  The selector is configured on a per SAP basis. The selectors are:
101  *
102  *  LCRGMILRG - loosely coupled LMK interface
103  *  TCRGMILRG - Tightly coupled LMK interface
104  *  
105  *  In a similar fashion, the matrices for Status, Statistics and
106  *  Control confirms and, Status and trace indications are defined.
107  **/
108 PRIVATE CONSTANT LrgCfgCfm RgMiLrgCfgCfmMt[RG_MAX_LRG_USR] =
109 {
110 #ifdef LCRGMILRG
111    cmPkLrgCfgCfm,                  /* 0 - loosely coupled */
112 #else
113    PtMiLrgCfgCfm,                  /* 0 - loosely coupled */
114 #endif
115 #ifdef SM 
116    SmMiLrgCfgCfm,                  /* 1 - Tightly coupled SM */
117 #else
118    PtMiLrgCfgCfm,                  /* 1 - Tightly coupled SM  */
119 #endif
120 };
121
122 /** @brief Scheduler Config Confirm primitive Matrix */
123 PRIVATE CONSTANT LrgSchCfgCfm RgMiLrgSchCfgCfmMt[RG_MAX_LRG_USR] =
124 {
125 #ifdef LCRGMILRG
126    cmPkLrgSchCfgCfm,                  /* 0 - loosely coupled */
127 #else
128    PtMiLrgSchCfgCfm,                  /* 0 - loosely coupled */
129 #endif
130 #ifdef SM 
131    SmMiLrgSchCfgCfm,                  /* 1 - Tightly coupled SM */
132 #else
133    PtMiLrgSchCfgCfm,                  /* 1 - Tightly coupled SM  */
134 #endif
135 };
136
137 /** @brief Statistics Confirm primitive Matrix */
138 PRIVATE CONSTANT LrgStsCfm RgMiLrgStsCfmMt[RG_MAX_LRG_USR] =
139 {
140 #ifdef LCRGMILRG
141    cmPkLrgStsCfm,                  /* 0 - loosely coupled */
142 #else
143    PtMiLrgStsCfm,                  /* 0 - loosely coupled */
144 #endif
145 #ifdef SM 
146    SmMiLrgStsCfm,                  /* 1 - Tightly coupled SM */
147 #else
148    PtMiLrgStsCfm,                  /* 1 - Tightly coupled SM  */
149 #endif
150 };
151
152 /** @brief Status Confirm primitive Matrix */
153 PRIVATE CONSTANT LrgStaCfm RgMiLrgStaCfmMt[RG_MAX_LRG_USR] =
154 {
155 #ifdef LCRGMILRG
156    cmPkLrgStaCfm,                  /* 0 - loosely coupled */
157 #else
158    PtMiLrgStaCfm,                  /* 0 - loosely coupled */
159 #endif
160 #ifdef SM 
161    SmMiLrgStaCfm,                  /* 1 - Tightly coupled SM */
162 #else
163    PtMiLrgStaCfm,                  /* 1 - Tightly coupled SM  */
164 #endif
165 };
166
167
168 /** @brief Status Indication primitive Matrix */
169 PRIVATE CONSTANT LrgStaInd RgMiLrgStaIndMt[RG_MAX_LRG_USR] =
170 {
171 #ifdef LCRGMILRG
172    cmPkLrgStaInd,                  /* 0 - loosely coupled */
173 #else
174    PtMiLrgStaInd,                  /* 0 - loosely coupled */
175 #endif
176 #ifdef SM 
177    SmMiLrgStaInd,                  /* 1 - Tightly coupled SM */
178 #else
179    PtMiLrgStaInd,                  /* 1 - Tightly coupled SM  */
180 #endif
181 };
182
183 /** @brief Scheduler  Status Indication primitive Matrix */
184 PRIVATE CONSTANT LrgSchStaInd RgMiLrgSchStaIndMt[RG_MAX_LRG_USR] =
185 {
186 #ifdef LCRGMILRG
187    cmPkLrgSchStaInd,                  /* 0 - loosely coupled */
188 #else
189    PtMiLrgSchStaInd,                  /* 0 - loosely coupled */
190 #endif
191 #ifdef SM 
192    SmMiLrgSchStaInd,                  /* 1 - Tightly coupled SM */
193 #else
194    PtMiLrgSchStaInd,                  /* 1 - Tightly coupled SM  */
195 #endif
196 };
197
198
199 /** @brief Control Confirm primitive Matrix */
200 PRIVATE CONSTANT LrgCntrlCfm RgMiLrgCntrlCfmMt[RG_MAX_LRG_USR] =
201 {
202 #ifdef LCRGMILRG
203    cmPkLrgCntrlCfm,                  /* 0 - loosely coupled */
204 #else
205    PtMiLrgCntrlCfm,                  /* 0 - loosely coupled */
206 #endif
207 #ifdef SM 
208    SmMiLrgCntrlCfm,                  /* 1 - Tightly coupled SM */
209 #else
210    PtMiLrgCntrlCfm,                  /* 1 - Tightly coupled SM  */
211 #endif
212 };
213
214 /** @brief Scheduler Control Confirm primitive Matrix */
215 PRIVATE CONSTANT LrgSchCntrlCfm RgMiLrgSchCntrlCfmMt[RG_MAX_LRG_USR] =
216 {
217 #ifdef LCRGMILRG
218    cmPkLrgSchCntrlCfm,                  /* 0 - loosely coupled */
219 #else
220    PtMiLrgSchCntrlCfm,                  /* 0 - loosely coupled */
221 #endif
222 #ifdef SM 
223    SmMiLrgSchCntrlCfm,                  /* 1 - Tightly coupled SM */
224 #else
225    PtMiLrgSchCntrlCfm,                  /* 1 - Tightly coupled SM  */
226 #endif
227 };
228
229 /** @brief Trace Indication primitive Matrix */
230 PRIVATE CONSTANT LrgTrcInd RgMiLrgTrcIndMt[RG_MAX_LRG_USR] =
231 {
232 #ifdef LCRGMILRG
233    cmPkLrgTrcInd,                  /* 0 - loosely coupled */
234 #else
235    PtMiLrgTrcInd,                  /* 0 - loosely coupled */
236 #endif
237 #ifdef SM 
238    SmMiLrgTrcInd,                  /* 1 - Tightly coupled SM */
239 #else
240    PtMiLrgTrcInd,                  /* 1 - Tightly coupled SM  */
241 #endif
242 };
243 #ifdef LTE_L2_MEAS
244 /** @brief L2 Meas Cfm primitive Matrix */
245 PRIVATE CONSTANT LrgSchL2MeasCfm RgMiLrgSchL2mMeasCfmMt[RG_MAX_LRG_USR] =
246 {
247 #ifdef LCRGMILRG
248    cmPkLrgSchL2MeasCfm,                /* 0 - loosely coupled */
249 #else
250    PtMiLrgSchL2MeasCfm,                  /* 0 - loosely coupled */
251 #endif
252 #ifdef SM 
253    SmMiLrgSchL2MeasCfm,                  /* 1 - Tightly coupled SM */
254 #else
255    PtMiLrgSchL2MeasCfm,                  /* 1 - loosely coupled */
256 #endif
257 };
258 /** @brief L2 Meas Stop Cfm primitive Matrix */
259 PRIVATE CONSTANT LrgSchL2MeasStopCfm RgMiLrgSchL2mMeasStopCfmMt[RG_MAX_LRG_USR] =
260 {
261 #ifdef LCRGMILRG
262    cmPkLrgSchL2MeasStopCfm,                /* 0 - loosely coupled */
263 #else
264    PtMiLrgSchL2MeasStopCfm,                  /* 0 - loosely coupled */
265 #endif
266 #ifdef SM 
267    SmMiLrgSchL2MeasStopCfm,                  /* 1 - Tightly coupled SM */
268 #else
269    PtMiLrgSchL2MeasStopCfm,                  /* 1 - loosely coupled */
270 #endif
271 };
272 #endif /* LTE_L2_MEAS */
273
274 #ifdef __cplusplus
275 }
276 #endif /* __cplusplus */
277
278 #ifdef RG
279
280 \f
281 /**
282  * @brief Layer Manager Configuration confirm handler. 
283  *
284  * @details
285  *
286  *     Function : RgMiLrgCfgCfm
287  *     
288  *     This function handles the configuration
289  *     confirm invoked by MAC to Layer Manager.
290  *     -# Based on the pst->selector value it invokes one of the
291  *        functions cmPkLrgCfgCfm() or SmMiLrgCfgCfm().
292  *     
293  *  @param[in]  Pst *pst, the post structure     
294  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
295  *  @return  S16
296  *      -# ROK
297  **/
298 #ifdef ANSI
299 PUBLIC S16 RgMiLrgCfgCfm
300 (
301 Pst      *pst,    /* post structure  */
302 RgMngmt  *cfm     /* config confirm structure  */
303 )
304 #else
305 PUBLIC S16 RgMiLrgCfgCfm(pst, cfm)
306 Pst      *pst;    /* post structure  */
307 RgMngmt  *cfm;    /* config confirm structure  */
308 #endif    
309 {
310    
311    TRC3(RgMiLrgCfgCfm);
312
313    (*RgMiLrgCfgCfmMt[pst->selector])(pst, cfm);
314
315    RETVALUE(ROK);
316    
317 }/*-- RgMiLrgCfgCfm --*/
318
319 /**
320  * @brief Layer Manager scheduler Configuration confirm handler. 
321  *
322  * @details
323  *
324  *     Function : RgMiLrgSchCfgCfm
325  *     
326  *     This function handles the configuration
327  *     confirm invoked by Scheduler to Layer Manager.
328  *     -# Based on the pst->selector value it invokes one of the
329  *        functions cmPkLrgSchCfgCfm() or SmMiLrgSchCfgCfm().
330  *     
331  *  @param[in]  Pst *pst, the post structure     
332  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
333  *  @return  S16
334  *      -# ROK
335  **/
336 #ifdef ANSI
337 PUBLIC S16 RgMiLrgSchCfgCfm
338 (
339 Pst      *pst,    /* post structure  */
340 RgMngmt  *cfm     /* config confirm structure  */
341 )
342 #else
343 PUBLIC S16 RgMiLrgSchCfgCfm(pst, cfm)
344 Pst      *pst;    /* post structure  */
345 RgMngmt  *cfm;    /* config confirm structure  */
346 #endif    
347 {
348    
349    TRC3(RgMiLrgSchCfgCfm);
350
351    (*RgMiLrgSchCfgCfmMt[pst->selector])(pst, cfm);
352
353    RETVALUE(ROK);
354    
355 }/*-- RgMiLrgSchCfgCfm --*/
356
357
358 \f
359 /**
360  * @brief Layer Manager Statistics confirm handler. 
361  *
362  * @details
363  *
364  *     Function : RgMiLrgStsCfm
365  *     
366  *     This function handles the statistics
367  *     confirm invoked by MAC to Layer Manager.
368  *     -# Based on the pst->selector value it invokes one of the
369  *        functions cmPkLrgStsCfm() or SmMiLrgStsCfm().
370  *     
371  *  @param[in]  Pst *pst, the post structure     
372  *  @param[in]  RgMngmt *cfm, the statistics confirm structure
373  *  @return  S16
374  *      -# ROK
375  **/
376 #ifdef ANSI
377 PUBLIC S16 RgMiLrgStsCfm
378 (
379 Pst      *pst,    /* post structure  */
380 RgMngmt  *cfm     /* statistics confirm structure  */
381 )
382 #else
383 PUBLIC S16 RgMiLrgStsCfm(pst, cfm)
384 Pst      *pst;    /* post structure  */
385 RgMngmt  *cfm;    /* statistics confirm structure  */
386 #endif    
387 {
388    
389    TRC3(RgMiLrgStsCfm);
390
391    (*RgMiLrgStsCfmMt[pst->selector])(pst, cfm);
392
393    RETVALUE(ROK);
394    
395 }/*-- RgMiLrgStsCfm --*/
396
397 \f
398 /**
399  * @brief Layer Manager Status confirm handler. 
400  *
401  * @details
402  *
403  *     Function : RgMiLrgStaCfm
404  *     
405  *     This function handles the status
406  *     confirm invoked by MAC to Layer Manager.
407  *     -# Based on the pst->selector value it invokes one of the
408  *        functions cmPkLrgStaCfm() or SmMiLrgStaCfm().
409  *     
410  *  @param[in]  Pst *pst, the post structure     
411  *  @param[in]  RgMngmt *cfm, the status confirm structure
412  *  @return  S16
413  *      -# ROK
414  **/
415 #ifdef ANSI
416 PUBLIC S16 RgMiLrgStaCfm
417 (
418 Pst      *pst,    /* post structure  */
419 RgMngmt  *cfm     /* status confirm structure  */
420 )
421 #else
422 PUBLIC S16 RgMiLrgStaCfm(pst, cfm)
423 Pst      *pst;    /* post structure  */
424 RgMngmt  *cfm;    /* status confirm structure  */
425 #endif    
426 {
427    
428    TRC3(RgMiLrgStaCfm);
429     
430    (*RgMiLrgStaCfmMt[pst->selector])(pst,cfm);
431
432    RETVALUE(ROK);
433    
434 }/*-- RgMiLrgStaCfm --*/
435
436 \f
437 /**
438  * @brief Layer Manager Control confirm handler. 
439  *
440  * @details
441  *
442  *     Function : RgMiLrgCntrlCfm
443  *     
444  *     This function handles the control
445  *     confirm invoked by MAC to Layer Manager.
446  *     -# Based on the pst->selector value it invokes one of the
447  *        functions cmPkLrgCntrlCfm() or SmMiLrgCntrlCfm().
448  *     
449  *  @param[in]  Pst *pst, the post structure     
450  *  @param[in]  RgMngmt *cfm, the control confirm structure
451  *  @return  S16
452  *      -# ROK
453  **/
454 #ifdef ANSI
455 PUBLIC S16 RgMiLrgCntrlCfm
456 (
457 Pst      *pst,    /* post structure  */
458 RgMngmt  *cfm     /* control confirm structure  */
459 )
460 #else
461 PUBLIC S16 RgMiLrgCntrlCfm(pst, cfm)
462 Pst      *pst;    /* post structure  */
463 RgMngmt  *cfm;    /* control confirm structure  */
464 #endif    
465 {
466    
467    TRC3(RgMiLrgCntrlCfm);
468
469    (*RgMiLrgCntrlCfmMt[pst->selector])(pst,cfm);
470
471    RETVALUE(ROK);
472    
473 }/*-- RgMiLrgCntrlCfm --*/
474
475 /**
476  * @brief Layer Manager scheduler Control confirm handler. 
477  *
478  * @details
479  *
480  *     Function : RgMiLrgSchCntrlCfm
481  *     
482  *     This function handles the control
483  *     confirm invoked by scheduler to Layer Manager.
484  *     -# Based on the pst->selector value it invokes one of the
485  *        functions cmPkLrgSchCntrlCfm() or SmMiLrgSchCntrlCfm().
486  *     
487  *  @param[in]  Pst *pst, the post structure     
488  *  @param[in]  RgMngmt *cfm, the control confirm structure
489  *  @return  S16
490  *      -# ROK
491  **/
492 #ifdef ANSI
493 PUBLIC S16 RgMiLrgSchCntrlCfm
494 (
495 Pst      *pst,    /* post structure  */
496 RgMngmt  *cfm     /* control confirm structure  */
497 )
498 #else
499 PUBLIC S16 RgMiLrgSchCntrlCfm(pst, cfm)
500 Pst      *pst;    /* post structure  */
501 RgMngmt  *cfm;    /* control confirm structure  */
502 #endif    
503 {
504    
505    TRC3(RgMiLrgSchCntrlCfm);
506
507    (*RgMiLrgSchCntrlCfmMt[pst->selector])(pst,cfm);
508
509    RETVALUE(ROK);
510    
511 }/*-- RgMiLrgSchCntrlCfm --*/
512
513 \f
514 /**
515  * @brief Layer Manager Unsolicited Status Indication handler. 
516  *
517  * @details
518  *
519  *     Function : RgMiLrgStaInd
520  *     
521  *     This function handles the unsolicited status
522  *     Indication invoked by MAC to Layer Manager.
523  *     -# Based on the pst->selector value it invokes one of the
524  *        functions cmPkLrgStaInd() or SmMiLrgStaInd().
525  *     
526  *  @param[in]  Pst *pst, the post structure     
527  *  @param[in]  RgMngmt *usta, the status indication structure
528  *  @return  S16
529  *      -# ROK
530  **/
531 #ifdef ANSI
532 PUBLIC S16 RgMiLrgStaInd
533 (
534 Pst      *pst,    /* post structure  */
535 RgMngmt  *usta    /* status indication structure  */
536 )
537 #else
538 PUBLIC S16 RgMiLrgStaInd(pst, usta)
539 Pst      *pst;    /* post structure  */
540 RgMngmt  *usta;    /* status indication structure  */
541 #endif    
542 {
543    
544    TRC3(RgMiLrgStaInd);
545
546    (*RgMiLrgStaIndMt[pst->selector])(pst,usta);
547
548    RETVALUE(ROK);
549    
550 }/*-- RgMiLrgStaInd --*/
551
552 /**
553  * @brief Layer Manager Unsolicited Status Indication handler from scheduler 
554  *
555  * @details
556  *
557  *     Function : RgMiLrgSchStaInd
558  *     
559  *     This function handles the unsolicited status
560  *     Indication invoked by Scheduler to Layer Manager.
561  *     -# Based on the pst->selector value it invokes one of the
562  *        functions cmPkLrgSchStaInd() or SmMiLrgSchStaInd().
563  *     
564  *  @param[in]  Pst *pst, the post structure     
565  *  @param[in]  RgMngmt *usta, the status indication structure
566  *  @return  S16
567  *      -# ROK
568  **/
569 #ifdef ANSI
570 PUBLIC S16 RgMiLrgSchStaInd
571 (
572 Pst      *pst,    /* post structure  */
573 RgMngmt  *usta    /* status indication structure  */
574 )
575 #else
576 PUBLIC S16 RgMiLrgSchStaInd(pst, usta)
577 Pst      *pst;    /* post structure  */
578 RgMngmt  *usta;    /* status indication structure  */
579 #endif    
580 {
581    
582    TRC3(RgMiLrgSchStaInd);
583
584    (*RgMiLrgSchStaIndMt[pst->selector])(pst,usta);
585
586    RETVALUE(ROK);
587    
588 }/*-- RgMiLrgSchStaInd --*/
589
590 \f
591 /**
592  * @brief Layer Manager Trace Indication handler. 
593  *
594  * @details
595  *
596  *     Function : RgMiLrgTrcInd
597  *     
598  *     This function handles the trace
599  *     Indication invoked by MAC to Layer Manager.
600  *     -# Based on the pst->selector value it invokes one of the
601  *        functions cmPkLrgTrcInd() or SmMiLrgTrcInd().
602  *     
603  *  @param[in]  Pst *pst, the post structure     
604  *  @param[in]  RgMngmt *trc, the trace event
605  *  @param[in]  Buffer *mBuf, the trace message
606  *  @return  S16
607  *      -# ROK
608  **/
609 #ifdef ANSI
610 PUBLIC S16 RgMiLrgTrcInd
611 (
612 Pst      *pst,    /* post structure  */
613 RgMngmt  *trc,    /* Trace event  */
614 Buffer   *mBuf    /* Trace message  */
615 )
616 #else
617 PUBLIC S16 RgMiLrgTrcInd(pst, trc, mBuf)
618 Pst      *pst;    /* post structure  */
619 RgMngmt  *trc;    /* Trace event  */
620 Buffer   *mBuf;   /* Trace message  */
621 #endif    
622 {
623    
624    TRC3(RgMiLrgTrcInd);
625
626    (*RgMiLrgTrcIndMt[pst->selector])(pst,trc,mBuf);
627
628    RETVALUE(ROK);
629    
630 }/*-- RgMiLrgTrcInd --*/
631
632 #ifdef LTE_L2_MEAS
633
634 /* TODO: Function header */
635 #ifdef ANSI
636 PUBLIC S16 RgMiLrgSchL2MeasCfm
637 (
638 Pst               *pst,          /* post structure  */
639 LrgSchMeasCfmInfo *cfm       /* Meas Cfm Info */
640 )
641 #else
642 PUBLIC S16 RgMiLrgSchL2MeasCfm(pst, cfm)
643 Pst               *pst;          /* post structure  */
644 LrgSchMeasCfmInfo *cfm;       /* Meas Cfm Info */
645 #endif    
646 {
647    TRC3(RgMiLrgSchL2MeasCfm)
648    
649    (*RgMiLrgSchL2mMeasCfmMt[pst->selector])(pst,cfm);
650    
651    RETVALUE(ROK);
652
653 } /* RgMiLrgSchL2MeasCfm */
654
655 /**
656  * @brief This function used to send L2 measurement stop confirmation 
657  *        to Layer manager.
658  *         
659  *
660  * @details
661  *
662  *     Function : RgMiLrgSchL2MeasStopCfm
663  *     This function sends reposnes to L2 Measurement stop request
664  *
665  *
666  *  @param[in]  Pst *pst, the post structure
667  *  @param[in]  LrgSchMeasCfmInfo *cfm, theconfirm structure
668  *  @return  S16
669  *      -# ROK
670  **/
671
672 #ifdef ANSI 
673 PUBLIC S16 RgMiLrgSchL2MeasStopCfm
674 (        
675 Pst               *pst,          /* post structure  */
676 LrgSchMeasCfmInfo *cfm       /* Meas Cfm Info */
677 )        
678 #else    
679 PUBLIC S16 RgMiLrgSchL2MeasStopCfm(pst, cfm)
680 Pst               *pst;          /* post structure  */
681 LrgSchMeasCfmInfo *cfm;       /* Meas Cfm Info */
682 #endif    
683 {
684    TRC3(RgMiLrgSchL2MeasStopCfm)
685         
686    (*RgMiLrgSchL2mMeasStopCfmMt[pst->selector])(pst,cfm);
687           
688    RETVALUE(ROK);
689         
690 } /* RgMiLrgSchL2MeasStopCfm */
691
692 #endif /* LTE_L2_MEAS */
693
694 #endif /*-- MK --*/
695
696 #ifdef PTRGMILRG
697 \f
698 /**
699  * @brief Portable Function definition for Layer Manager Configuration
700  *         confirm handler. 
701  *
702  * @details
703  *
704  *     Function : PtMiLrgCfgCfm
705  *     
706  *     This function handles the configuration
707  *     confirm invoked by MAC to Layer Manager.
708  *     Users of MAC who intend to provide a glue logic 
709  *     for portability of Configuration Confirm are expected 
710  *     to fill in the code in this function definition.
711  *     
712  *  @param[in]  Pst *pst, the post structure     
713  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
714  *  @return  S16
715  *      -# ROK
716  **/
717 #ifdef ANSI
718 PUBLIC S16 PtMiLrgCfgCfm
719 (
720 Pst *pst,               /* post structure */
721 RgMngmt *cfm            /* Config Confirm */
722 )
723 #else
724 PUBLIC S16 PtMiLrgCfgCfm  (pst, cfm)
725 Pst *pst;               /* post structure */
726 RgMngmt *cfm;           /* Config Confirm */
727 #endif
728 {
729    TRC3(PtMiLrgCfgCfm)
730
731    RETVALUE(ROK);
732 }/* end of PtMiLrgCfgCfm */
733
734 /**
735  * @brief Portable Function definition for Layer Manager Configuration
736  *         confirm handler. 
737  *
738  * @details
739  *
740  *     Function : PtMiLrgSchCfgCfm
741  *     
742  *     This function handles the configuration
743  *     confirm invoked by scheduler to Layer Manager.
744  *     Users of MAC who intend to provide a glue logic 
745  *     for portability of Configuration Confirm are expected 
746  *     to fill in the code in this function definition.
747  *     
748  *  @param[in]  Pst *pst, the post structure     
749  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
750  *  @return  S16
751  *      -# ROK
752  **/
753 #ifdef ANSI
754 PUBLIC S16 PtMiLrgSchCfgCfm
755 (
756 Pst *pst,               /* post structure */
757 RgMngmt *cfm            /* Config Confirm */
758 )
759 #else
760 PUBLIC S16 PtMiLrgSchCfgCfm  (pst, cfm)
761 Pst *pst;               /* post structure */
762 RgMngmt *cfm;           /* Config Confirm */
763 #endif
764 {
765    TRC3(PtMiLrgSchCfgCfm)
766
767    RETVALUE(ROK);
768 }/* end of PtMiLrgSchCfgCfm */
769
770
771 \f
772 /**
773  * @brief Portable Function definition for Layer Manager Statistics 
774  *         confirm handler. 
775  *
776  * @details
777  *
778  *     Function : PtMiLrgStsCfm 
779  *     
780  *     This function handles the statistics 
781  *     confirm invoked by MAC to Layer Manager.
782  *     Users of MAC who intend to provide a glue logic 
783  *     for portability of statistics Confirm are expected 
784  *     to fill in the code in this function definition.
785  *     
786  *  @param[in]  Pst *pst, the post structure     
787  *  @param[in]  RgMngmt *cfm, the statistics confirm structure
788  *  @return  S16
789  *      -# ROK
790  **/
791 #ifdef ANSI
792 PUBLIC S16 PtMiLrgStsCfm
793 (
794 Pst *pst,               /* post structure */
795 RgMngmt *cfm            /* Statistics Confirm */
796 )
797 #else
798 PUBLIC S16 PtMiLrgStsCfm  (pst, cfm)
799 Pst *pst;               /* post structure */
800 RgMngmt *cfm;           /* Statistics Confirm */
801 #endif
802 {
803    TRC3(PtMiLrgStsCfm)
804
805    RETVALUE(ROK);
806 }/* end of PtMiLrgStsCfm */
807
808
809 \f
810 /**
811  * @brief Portable Function definition for Layer Manager Status 
812  *         confirm handler. 
813  *
814  * @details
815  *
816  *     Function : PtMiLrgStaCfm 
817  *     
818  *     This function handles the status 
819  *     confirm invoked by MAC to Layer Manager.
820  *     Users of MAC who intend to provide a glue logic 
821  *     for portability of status Confirm are expected 
822  *     to fill in the code in this function definition.
823  *     
824  *  @param[in]  Pst *pst, the post structure     
825  *  @param[in]  RgMngmt *cfm, the status confirm structure
826  *  @return  S16
827  *      -# ROK
828  **/
829 #ifdef ANSI
830 PUBLIC S16 PtMiLrgStaCfm
831 (
832 Pst *pst,               /* post structure */
833 RgMngmt *cfm            /* Status Confirm */
834 )
835 #else
836 PUBLIC S16 PtMiLrgStaCfm  (pst, cfm)
837 Pst *pst;               /* post structure */
838 RgMngmt *cfm;           /* Status Confirm */
839 #endif
840 {
841    TRC3(PtMiLrgStaCfm)
842    RETVALUE(ROK);
843 }/* end of PtMiLrgStaCfm */
844
845
846 \f
847 /**
848  * @brief Portable Function definition for Layer Manager Status 
849  *        Indication handler. 
850  *
851  * @details
852  *
853  *     Function : PtMiLrgStaInd 
854  *     
855  *     This function handles the status 
856  *     indication invoked by MAC to Layer Manager.
857  *     Users of MAC who intend to provide a glue logic 
858  *     for portability of status indication are expected 
859  *     to fill in the code in this function definition.
860  *     
861  *  @param[in]  Pst *pst, the post structure     
862  *  @param[in]  RgMngmt *cfm, the status indication structure
863  *  @return  S16
864  *      -# ROK
865  **/
866 #ifdef ANSI
867 PUBLIC S16 PtMiLrgStaInd
868 (
869 Pst *pst,               /* post structure */
870 RgMngmt *usta           /* Status Indication */
871 )
872 #else
873 PUBLIC S16 PtMiLrgStaInd  (pst, usta)
874 Pst *pst;               /* post structure */
875 RgMngmt *usta;          /* Status indication */
876 #endif
877 {
878    TRC3(PtMiLrgStaInd)
879    RETVALUE(ROK);
880 }/* end of PtMiLrgStaInd */
881
882 /**
883  * @brief Portable Function definition for Layer Manager Status 
884  *        Indication handler. 
885  *
886  * @details
887  *
888  *     Function : PtMiLrgSchStaInd 
889  *     
890  *     This function handles the status 
891  *     indication invoked by Scheduler to Layer Manager.
892  *     Users of MAC who intend to provide a glue logic 
893  *     for portability of status indication are expected 
894  *     to fill in the code in this function definition.
895  *     
896  *  @param[in]  Pst *pst, the post structure     
897  *  @param[in]  RgMngmt *cfm, the status indication structure
898  *  @return  S16
899  *      -# ROK
900  **/
901 #ifdef ANSI
902 PUBLIC S16 PtMiLrgSchStaInd
903 (
904 Pst *pst,               /* post structure */
905 RgMngmt *usta           /* Status Indication */
906 )
907 #else
908 PUBLIC S16 PtMiLrgSchStaInd  (pst, usta)
909 Pst *pst;               /* post structure */
910 RgMngmt *usta;          /* Status indication */
911 #endif
912 {
913    TRC3(PtMiLrgSchStaInd)
914    RETVALUE(ROK);
915 }/* end of PtMiLrgSchStaInd */
916
917 \f
918 /**
919  * @brief Portable Function definition for Layer Manager Control 
920  *         confirm handler. 
921  *
922  * @details
923  *
924  *     Function : PtMiLrgCntrlCfm 
925  *     
926  *     This function handles the control 
927  *     confirm invoked by MAC to Layer Manager.
928  *     Users of MAC who intend to provide a glue logic 
929  *     for portability of control Confirm are expected 
930  *     to fill in the code in this function definition.
931  *     
932  *  @param[in]  Pst *pst, the post structure     
933  *  @param[in]  RgMngmt *cfm, the control confirm structure
934  *  @return  S16
935  *      -# ROK
936  **/
937 #ifdef ANSI
938 PUBLIC S16 PtMiLrgCntrlCfm
939 (
940 Pst *pst,               /* post structure */
941 RgMngmt *cfm            /* Control Confirm */
942 )
943 #else
944 PUBLIC S16 PtMiLrgCntrlCfm (pst, cfm)
945 Pst *pst;               /* post structure */
946 RgMngmt *cfm;           /* Control Confirm */
947 #endif
948 {
949    TRC3(PtMiLrgCntrlCfm)
950    RETVALUE(ROK);
951 }/* end of PtMiLrgCntrlCfm */
952
953 /**
954  * @brief Portable Function definition for Layer Manager Control 
955  *         confirm handler. 
956  *
957  * @details
958  *
959  *     Function : PtMiLrgSchCntrlCfm 
960  *     
961  *     This function handles the control 
962  *     confirm invoked by scheduler to Layer Manager.
963  *     Users of MAC who intend to provide a glue logic 
964  *     for portability of control Confirm are expected 
965  *     to fill in the code in this function definition.
966  *     
967  *  @param[in]  Pst *pst, the post structure     
968  *  @param[in]  RgMngmt *cfm, the control confirm structure
969  *  @return  S16
970  *      -# ROK
971  **/
972 #ifdef ANSI
973 PUBLIC S16 PtMiLrgSchCntrlCfm
974 (
975 Pst *pst,               /* post structure */
976 RgMngmt *cfm            /* Control Confirm */
977 )
978 #else
979 PUBLIC S16 PtMiLrgSchCntrlCfm (pst, cfm)
980 Pst *pst;               /* post structure */
981 RgMngmt *cfm;           /* Control Confirm */
982 #endif
983 {
984    TRC3(PtMiLrgSchCntrlCfm)
985    RETVALUE(ROK);
986 }/* end of PtMiLrgSchCntrlCfm */
987
988 \f
989 /**
990  * @brief Portable Function definition for Layer Manager Trace 
991  *        Indication handler. 
992  *
993  * @details
994  *
995  *     Function : PtMiLrgTrcInd 
996  *     
997  *     This function handles the trace 
998  *     indication invoked by MAC to Layer Manager.
999  *     Users of MAC who intend to provide a glue logic 
1000  *     for portability of trace indication are expected 
1001  *     to fill in the code in this function definition.
1002  *     
1003  *  @param[in]  Pst *pst, the post structure     
1004  *  @param[in]  RgMngmt *cfm, the trace indication structure
1005  *  @return  S16
1006  *      -# ROK
1007  **/
1008 #ifdef ANSI
1009 PUBLIC S16 PtMiLrgTrcInd
1010 (
1011 Pst *pst,               /* post structure */
1012 RgMngmt *trc,           /* Trace Event */
1013 Buffer *mBuf            /* Trace message */
1014 )
1015 #else
1016 PUBLIC S16 PtMiLrgTrcInd (pst, trc,mBuf)
1017 Pst *pst;               /* post structure */
1018 RgMngmt *trc;           /* Trace Event */
1019 Buffer *mBuf;           /* Trace message */
1020 #endif
1021 {
1022    TRC3(PtMiLrgTrcInd)
1023    RETVALUE(ROK);
1024 }/* end of PtMiLrgTrcInd */
1025 #ifdef LTE_L2_MEAS
1026 /**
1027  * @brief Portable Function definition for L2 Measurement Configuration
1028  *         confirm handler. 
1029  *
1030  * @details
1031  *
1032  *     Function : PtMiLrgSchL2MeasCfm
1033  *     
1034  *     
1035  *  @param[in]  Pst *pst, the post structure     
1036  *  @param[in]  *cfm, the measurement confirm structure
1037  *  @return  S16
1038  *      -# ROK
1039  **/
1040 #ifdef ANSI
1041 PUBLIC S16 PtMiLrgSchL2MeasCfm
1042 (
1043 Pst *pst,               /* post structure */
1044 LrgSchMeasCfmInfo *cfm  /* Measurement Confirm */
1045 )
1046 #else
1047 PUBLIC S16 PtMiLrgSchL2MeasCfm(pst, cfm)
1048 Pst *pst;               /* post structure */
1049 LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
1050 #endif
1051 {
1052    TRC3(PtMiLrgSchL2MeasCfm)
1053
1054    RETVALUE(ROK);
1055 }/* end of PtMiLrgSchL2MeasCfm */
1056
1057 /**
1058  * @brief Portable Function definition for L2 Measurement stop 
1059  *         confirm handler. 
1060  *
1061  * @details
1062  *
1063  *     Function : PtMiLrgSchL2MeasStopCfm
1064  *     
1065  *     
1066  *  @param[in]  Pst *pst, the post structure     
1067  *  @param[in]  *cfm, the measurement confirm structure
1068  *  @return  S16
1069  *      -# ROK
1070  **/
1071 #ifdef ANSI
1072 PUBLIC S16 PtMiLrgSchL2MeasStopCfm
1073 (
1074 Pst *pst,               /* post structure */
1075 LrgSchMeasCfmInfo *cfm  /* Measurement Confirm */
1076 )
1077 #else
1078 PUBLIC S16 PtMiLrgSchL2MeasStopCfm(pst, cfm)
1079 Pst *pst;               /* post structure */
1080 LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
1081 #endif
1082 {
1083    TRC3(PtMiLrgSchL2MeasStopCfm)
1084
1085    RETVALUE(ROK);
1086 }/* end of PtMiLrgSchL2MeasStopCfm */
1087 #endif
1088 #endif /*--PTRGMILRG--*/
1089
1090 \f
1091 /**********************************************************************
1092  
1093          End of file
1094 **********************************************************************/