FAPI Slot Indication Changes
[o-du/l2.git] / src / cm / rgm.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 /************************************************************************
21  
22      Name:     LTE-MAC layer
23   
24      Type:     C source file
25   
26      Desc:     C source code for packing/unpacking of RGM interface
27                primitives.
28   
29      File:     rgm.c 
30   
31 **********************************************************************/
32
33 /** @file rgm.c
34 @brief This file contains the packing/unpacking code for the RGM interface 
35        primitives.
36 */
37
38 /* header include files (.h) */
39 #include "envopt.h"        /* environment options */
40 #include "envdep.h"        /* environment dependent */
41 #include "envind.h"        /* environment independent */
42 #include "gen.h"           /* general */
43 #include "ssi.h"           /* system services */
44 #include "cm_tkns.h"       /* Common Token Defines */
45 #include "cm_llist.h"      /* Common Link List Defines */
46 #include "cm_hash.h"       /* Common Hash List Defines */
47 #include "cm_lte.h"        /* Common LTE Defines */
48 #include "rgm.h"           /* RGM Interface defines */
49
50 /* header/extern include files (.x) */
51 #include "gen.x"           /* general */
52 #include "ssi.x"           /* system services */
53 #include "cm_tkns.x"       /* Common Token Definitions */
54 #include "cm_llist.x"      /* Common Link List Definitions */
55 #include "cm_lib.x"        /* Common Library Definitions */
56 #include "cm_hash.x"       /* Common Hash List Definitions */
57 #include "cm_lte.x"        /* Common LTE Defines */
58 #include "rgm.x"           /* RGM Interface includes */
59
60 #ifdef RGM_LWLC
61
62 \f
63 /**
64 * @brief Request from RRM to MAC to bind the interface saps
65 *
66 * @details
67 *
68 *     Function : cmPkLwLcRgmBndReq
69 *
70 *  @param[in]   Pst*  pst
71 *  @param[in]   SuId  suId
72 *  @param[in]   SpId  spId
73 *  @return   S16
74 *      -# ROK
75 **/
76 #ifdef ANSI
77 PUBLIC S16 cmPkLwLcRgmBndReq
78 (
79 Pst* pst,
80 SuId suId,
81 SpId spId
82 )
83 #else
84 PUBLIC S16 cmPkLwLcRgmBndReq(pst, suId, spId)
85 Pst* pst;
86 SuId suId;
87 SpId spId;
88 #endif
89 {
90    Buffer *mBuf = NULLP;
91    TRC3(cmPkLwLcRgmBndReq)
92
93    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
94    {
95       RETVALUE(RFAILED);
96    }
97
98    if (SPkS16(spId, mBuf) != ROK) 
99    {
100       SPutMsg(mBuf);
101       RETVALUE(RFAILED);
102    }
103
104    if (SPkS16(suId, mBuf) != ROK) 
105    {
106       SPutMsg(mBuf);
107       RETVALUE(RFAILED);
108    }
109
110    pst->event = (Event) EVTRGMBNDREQ;
111    RETVALUE(SPstTsk(pst,mBuf));
112 }
113
114 \f
115 /**
116 * @brief Request from RRM to MAC to bind the interface saps
117 *
118 * @details
119 *
120 *     Function : cmUnpkLwLcRgmBndReq
121 *
122 *  @param[in]   Pst*  pst
123 *  @param[in]   SuId  suId
124 *  @param[in]   SpId  spId
125 *  @return   S16
126 *      -# ROK
127 **/
128 #ifdef ANSI
129 PUBLIC S16 cmUnpkLwLcRgmBndReq
130 (
131 RgmBndReq func,
132 Pst *pst,
133 Buffer *mBuf
134 )
135 #else
136 PUBLIC S16 cmUnpkLwLcRgmBndReq(func, pst, mBuf)
137 RgmBndReq func;
138 Pst *pst;
139 Buffer *mBuf;
140 #endif
141 {
142    SuId suId;
143    SpId spId;
144    S16  ret;
145    
146    TRC3(cmUnpkLwLcRgmBndReq)
147
148    if (SUnpkS16(&suId, mBuf) != ROK) 
149    {
150       SPutMsg(mBuf);
151       RETVALUE(RFAILED);
152    }
153
154    if (SUnpkS16(&spId, mBuf) != ROK) 
155    {
156       SPutMsg(mBuf);
157       RETVALUE(RFAILED);
158    }
159
160    ret = ((*func)(pst, suId, spId));
161
162    SPutMsg(mBuf);
163
164    RETVALUE(ret);
165 }
166
167 /**
168 * @brief Request from RRM to MAC to Unbind the interface saps
169 *
170 * @details
171 *
172 *     Function : cmPkLwLcRgmUbndReq
173 *
174 *  @param[in]   Pst*  pst
175 *  @param[in]   SpId  spId
176 *  @param[in]   Reason  reason
177 *  @return   S16
178 *      -# ROK
179 **/
180 #ifdef ANSI
181 PUBLIC S16 cmPkLwLcRgmUbndReq
182 (
183 Pst* pst,
184 SpId spId,
185 Reason reason
186 )
187 #else
188 PUBLIC S16 cmPkLwLcRgmUbndReq(pst, spId, reason)
189 Pst* pst;
190 SpId spId;
191 Reason reason;
192 #endif
193 {
194    Buffer *mBuf = NULLP;
195    TRC3(cmPkLwLcRgmUbndReq)
196
197    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
198    {
199       RETVALUE(RFAILED);
200    }
201    if (SPkS16(reason, mBuf) != ROK) 
202    {
203       SPutMsg(mBuf);
204       RETVALUE(RFAILED);
205    }
206    if (SPkS16(spId, mBuf) != ROK) 
207    {
208       SPutMsg(mBuf);
209       RETVALUE(RFAILED);
210    }
211
212    pst->event = (Event) EVTRGMUBNDREQ;
213    RETVALUE(SPstTsk(pst,mBuf));
214 }
215
216 /**
217 * @brief Confirmation from MAC to RRM for the bind/Unbind 
218  * request for the interface saps
219 *
220 * @details
221 *
222 *     Function : cmPkLwLcRgmBndCfm
223 *
224 *  @param[in]   Pst*  pst
225 *  @param[in]   SuId  suId
226 *  @param[in]   U8  status
227 *  @return   S16
228 *      -# ROK
229 **/
230 #ifdef ANSI
231 PUBLIC S16 cmPkLwLcRgmBndCfm
232 (
233 Pst* pst,
234 SuId suId,
235 U8 status
236 )
237 #else
238 PUBLIC S16 cmPkLwLcRgmBndCfm(pst, suId, status)
239 Pst* pst;
240 SuId suId;
241 U8 status;
242 #endif
243 {
244    Buffer *mBuf = NULLP;
245    TRC3(cmPkLwLcRgmBndCfm)
246
247    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
248    {
249       RETVALUE(RFAILED);
250    }
251
252    if (SPkS16(suId, mBuf) != ROK) 
253    {
254       SPutMsg(mBuf);
255       RETVALUE(RFAILED);
256    }
257
258    if (SPkU8(status, mBuf) != ROK) 
259    {
260       SPutMsg(mBuf);
261       RETVALUE(RFAILED);
262    }
263
264   pst->event = (Event) EVTRGMBNDCFM;
265    RETVALUE(SPstTsk(pst,mBuf));
266 }
267
268 \f
269 /**
270 * @brief Confirmation from MAC to RRM for the bind/Unbind 
271  * request for the interface saps
272 *
273 * @details
274 *
275 *     Function : cmUnpkLwLcRgmBndCfm
276 *
277 *  @param[in]   Pst*  pst
278 *  @param[in]   SuId  suId
279 *  @param[in]   U8  status
280 *  @return   S16
281 *      -# ROK
282 **/
283 #ifdef ANSI
284 PUBLIC S16 cmUnpkLwLcRgmBndCfm
285 (
286 RgmBndCfm func,
287 Pst *pst,
288 Buffer *mBuf
289 )
290 #else
291 PUBLIC S16 cmUnpkLwLcRgmBndCfm(func, pst, mBuf)
292 RgmBndCfm func;
293 Pst *pst;
294 Buffer *mBuf;
295 #endif
296 {
297    SuId suId;
298    U8 status;
299    
300    TRC3(cmUnpkLwLcRgmBndCfm)
301
302    if (SUnpkU8(&status, mBuf) != ROK) 
303    {
304       SPutMsg(mBuf);
305       RETVALUE(RFAILED);
306    }
307
308    if (SUnpkS16(&suId, mBuf) != ROK) 
309    {
310       SPutMsg(mBuf);
311       RETVALUE(RFAILED);
312    }
313    SPutMsg(mBuf);
314    RETVALUE((*func)(pst, suId, status));
315 }
316
317 \f
318 /**
319 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
320 *
321 * @details
322 *
323 *     Function : cmPkLwLcRgmCfgPrbRprt
324 *
325 *  @param[in]   Pst*  pst
326 *  @param[in]   SpId  spId
327 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
328 *  @return   S16
329 *      -# ROK
330 **/
331 #ifdef ANSI
332 PUBLIC S16 cmPkLwLcRgmCfgPrbRprt
333 (
334 Pst* pst,
335 SpId spId,
336 RgmPrbRprtCfg  * prbRprtCfg
337 )
338 #else
339 PUBLIC S16 cmPkLwLcRgmCfgPrbRprt(pst, spId, prbRprtCfg)
340 Pst* pst;
341 SpId spId;
342 RgmPrbRprtCfg  * prbRprtCfg;
343 #endif
344 {
345    Buffer *mBuf = NULLP;
346    U32 len = sizeof(RgmPrbRprtCfg);
347    TRC3(cmPkLwLcRgmCfgPrbRprt)
348
349    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
350    {
351       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
352       RETVALUE(RFAILED);
353    }
354
355     if(cmPkPtr((PTR)prbRprtCfg, mBuf) != ROK)
356     {
357        SPutMsg(mBuf); 
358        SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
359        RETVALUE(RFAILED);
360     }
361
362    if (SPkS16(spId, mBuf) != ROK) 
363    {
364       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
365       SPutMsg(mBuf);
366       RETVALUE(RFAILED);
367    }
368
369    pst->event = (Event) EVTRGMCFGPRBRPRT;
370    RETVALUE(SPstTsk(pst,mBuf));
371 }
372
373 \f
374 /**
375 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
376 *
377 * @details
378 *
379 *     Function : cmUnpkLwLcRgmCfgPrbRprt
380 *
381 *  @param[in]   Pst*  pst
382 *  @param[in]   SpId  spId
383 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
384 *  @return   S16
385 *      -# ROK
386 **/
387 #ifdef ANSI
388 PUBLIC S16 cmUnpkLwLcRgmCfgPrbRprt
389 (
390 RgmCfgPrbRprtFptr func,
391 Pst *pst,
392 Buffer *mBuf
393 )
394 #else
395 PUBLIC S16 cmUnpkLwLcRgmCfgPrbRprt(func, pst, mBuf)
396 RgmCfgPrbRprtFptr func;
397 Pst *pst;
398 Buffer *mBuf;
399 #endif
400 {
401    S16 ret;
402    SpId spId;
403    RgmPrbRprtCfg *prbRprtCfg;
404    
405    TRC3(cmUnpkLwLcRgmCfgPrbRprt)
406
407    if (SUnpkS16(&spId, mBuf) != ROK) 
408    {
409       SPutMsg(mBuf);
410       RETVALUE(RFAILED);
411    }
412
413    if (cmUnpkPtr((PTR *)&prbRprtCfg, mBuf) != ROK)
414    {
415       SPutMsg(mBuf);
416       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
417       RETVALUE(RFAILED);
418    }
419
420    ret =  ((*func)(pst, spId, prbRprtCfg));
421
422    SPutMsg(mBuf);
423    RETVALUE(ret);
424 }
425
426
427 /**
428 * @brief PRB Usage Report Indication  from MAC to RRM 
429 *
430 * @details
431 *
432 *     Function : cmPkLwLcRgmPrbRprtInd
433 *
434 *  @param[in]   Pst*  pst
435 *  @param[in]   SuId  suId
436 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
437 *  @return   S16
438 *      -# ROK
439 **/
440 #ifdef ANSI
441 PUBLIC S16 cmPkLwLcRgmPrbRprtInd
442 (
443 Pst* pst,
444 SuId suId,
445 RgmPrbRprtInd  * prbRprtInd
446 )
447 #else
448 PUBLIC S16 cmPkLwLcRgmPrbRprtInd(pst, suId, prbRprtInd)
449 Pst* pst;
450 SuId suId;
451 RgmPrbRprtInd  * prbRprtInd;
452 #endif
453 {
454    Buffer *mBuf = NULLP;
455
456    TRC3(cmPkLwLcRgmPrbRprtInd)
457
458    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
459       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
460       RETVALUE(RFAILED);
461    }
462
463    if(cmPkPtr((PTR)prbRprtInd, mBuf) != ROK)
464    {
465       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
466       SPutMsg(mBuf);
467       RETVALUE(RFAILED);
468    }
469
470    if (SPkS16(suId, mBuf) != ROK) 
471    {
472       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
473       SPutMsg(mBuf);
474       RETVALUE(RFAILED);
475    }
476
477    pst->event = (Event) EVTRGMCFGPRBRPRT;
478    RETVALUE(SPstTsk(pst,mBuf));
479 }
480
481
482 /**
483 * @brief PRB Usage Report Indication from MAC to RRM 
484 *
485 * @details
486 *
487 *     Function : cmUnpkLwLcRgmPrbRprtInd
488 *
489 *  @param[in]   Pst*  pst
490 *  @param[in]   SuId  suId
491 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
492 *  @return   S16
493 *      -# ROK
494 **/
495 #ifdef ANSI
496 PUBLIC S16 cmUnpkLwLcRgmPrbRprtInd
497 (
498 RgmPrbRprtIndFptr func,
499 Pst *pst,
500 Buffer *mBuf
501 )
502 #else
503 PUBLIC S16 cmUnpkLwLcRgmPrbRprtInd(func, pst, mBuf)
504 RgmPrbRprtIndFptr func;
505 Pst *pst;
506 Buffer *mBuf;
507 #endif
508 {
509    SuId suId;
510    RgmPrbRprtInd *prbRprtInd;
511    S16 ret;
512    
513    TRC3(cmUnpkLwLcRgmPrbRprtInd)
514
515    if (SUnpkS16(&suId, mBuf) != ROK) 
516    {
517       SPutMsg(mBuf);
518       RETVALUE(RFAILED);
519    }
520
521    if (cmUnpkPtr((PTR *)&prbRprtInd, mBuf) != ROK) 
522    {
523       SPutMsg(mBuf);
524       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
525       RETVALUE(RFAILED);
526    }
527
528
529    ret = ((*func)(pst, suId, prbRprtInd));
530
531    SPutMsg(mBuf);
532
533    RETVALUE(ret);
534 }
535 #endif
536
537
538 /**
539 * @brief Request from RRM to MAC to bind the interface saps
540 *
541 * @details
542 *
543 *     Function : cmPkRgmBndReq
544 *
545 *  @param[in]   Pst*  pst
546 *  @param[in]   SuId  suId
547 *  @param[in]   SpId  spId
548 *  @return   S16
549 *      -# ROK
550 **/
551 #ifdef ANSI
552 PUBLIC S16 cmPkRgmBndReq
553 (
554 Pst* pst,
555 SuId suId,
556 SpId spId
557 )
558 #else
559 PUBLIC S16 cmPkRgmBndReq(pst, suId, spId)
560 Pst* pst;
561 SuId suId;
562 SpId spId;
563 #endif
564 {
565    Buffer *mBuf = NULLP;
566    TRC3(cmPkRgmBndReq)
567
568    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
569    {
570       RETVALUE(RFAILED);
571    }
572
573    if (SPkS16(spId, mBuf) != ROK) 
574    {
575       SPutMsg(mBuf);
576       RETVALUE(RFAILED);
577    }
578
579    if (SPkS16(suId, mBuf) != ROK) 
580    {
581       SPutMsg(mBuf);
582       RETVALUE(RFAILED);
583    }
584
585    pst->event = (Event) EVTRGMBNDREQ;
586    RETVALUE(SPstTsk(pst,mBuf));
587 }
588
589 \f
590 /**
591 * @brief Request from RRM to MAC to bind the interface saps
592 *
593 * @details
594 *
595 *     Function : cmUnpkRgmBndReq
596 *
597 *  @param[in]   Pst*  pst
598 *  @param[in]   SuId  suId
599 *  @param[in]   SpId  spId
600 *  @return   S16
601 *      -# ROK
602 **/
603 #ifdef ANSI
604 PUBLIC S16 cmUnpkRgmBndReq
605 (
606 RgmBndReq func,
607 Pst *pst,
608 Buffer *mBuf
609 )
610 #else
611 PUBLIC S16 cmUnpkRgmBndReq(func, pst, mBuf)
612 RgmBndReq func;
613 Pst *pst;
614 Buffer *mBuf;
615 #endif
616 {
617    SuId suId;
618    SpId spId;
619    S16  ret;
620    
621    TRC3(cmUnpkRgmBndReq)
622
623    if (SUnpkS16(&suId, mBuf) != ROK) 
624    {
625       SPutMsg(mBuf);
626       RETVALUE(RFAILED);
627    }
628
629    if (SUnpkS16(&spId, mBuf) != ROK) 
630    {
631       SPutMsg(mBuf);
632       RETVALUE(RFAILED);
633    }
634
635    ret = ((*func)(pst, suId, spId));
636
637    SPutMsg(mBuf);
638
639    RETVALUE(ret);
640 }
641
642 /**
643 * @brief Request from RRM to MAC to Unbind the interface saps
644 *
645 * @details
646 *
647 *     Function : cmPkRgmUbndReq
648 *
649 *  @param[in]   Pst*  pst
650 *  @param[in]   SpId  spId
651 *  @param[in]   Reason  reason
652 *  @return   S16
653 *      -# ROK
654 **/
655 #ifdef ANSI
656 PUBLIC S16 cmPkRgmUbndReq
657 (
658 Pst* pst,
659 SpId spId,
660 Reason reason
661 )
662 #else
663 PUBLIC S16 cmPkRgmUbndReq(pst, spId, reason)
664 Pst* pst;
665 SpId spId;
666 Reason reason;
667 #endif
668 {
669    Buffer *mBuf = NULLP;
670    TRC3(cmPkRgmUbndReq)
671
672    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
673    {
674       RETVALUE(RFAILED);
675    }
676    if (SPkS16(reason, mBuf) != ROK) 
677    {
678       SPutMsg(mBuf);
679       RETVALUE(RFAILED);
680    }
681    if (SPkS16(spId, mBuf) != ROK) 
682    {
683       SPutMsg(mBuf);
684       RETVALUE(RFAILED);
685    }
686
687    pst->event = (Event) EVTRGMUBNDREQ;
688    RETVALUE(SPstTsk(pst,mBuf));
689 }
690
691 #if 1 
692 \f
693 /**
694 * @brief Request from RRM to MAC to Unbind the interface saps
695 *
696 * @details
697 *
698 *     Function : cmUnpkRgmUbndReq
699 *
700 *  @param[in]   Pst*  pst
701 *  @param[in]   SpId  spId
702 *  @param[in]   Reason  reason
703 *  @return   S16
704 *      -# ROK
705 **/
706 #ifdef ANSI
707 PUBLIC S16 cmUnpkRgmUbndReq
708 (
709 RgmUbndReq func,
710 Pst *pst,
711 Buffer *mBuf
712 )
713 #else
714 PUBLIC S16 cmUnpkRgmUbndReq(func, pst, mBuf)
715 RgmUbndReq func;
716 Pst *pst;
717 Buffer *mBuf;
718 #endif
719 {
720    SpId spId;
721    Reason reason;
722    
723    TRC3(cmUnpkRgmUbndReq)
724
725    if (SUnpkS16(&spId, mBuf) != ROK) 
726    {
727       SPutMsg(mBuf);
728       RETVALUE(RFAILED);
729    }
730    if (SUnpkS16(&reason, mBuf) != ROK)
731    {
732       SPutMsg(mBuf);
733       RETVALUE(RFAILED);
734    }
735    SPutMsg(mBuf);
736    RETVALUE((*func)(pst, spId, reason));
737 }
738 #endif
739
740 /**
741 * @brief Confirmation from MAC to RRM for the bind/Unbind 
742  * request for the interface saps
743 *
744 * @details
745 *
746 *     Function : cmPkRgmBndCfm
747 *
748 *  @param[in]   Pst*  pst
749 *  @param[in]   SuId  suId
750 *  @param[in]   U8  status
751 *  @return   S16
752 *      -# ROK
753 **/
754 #ifdef ANSI
755 PUBLIC S16 cmPkRgmBndCfm
756 (
757 Pst* pst,
758 SuId suId,
759 U8 status
760 )
761 #else
762 PUBLIC S16 cmPkRgmBndCfm(pst, suId, status)
763 Pst* pst;
764 SuId suId;
765 U8 status;
766 #endif
767 {
768    Buffer *mBuf = NULLP;
769    TRC3(cmPkRgmBndCfm)
770
771    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
772    {
773       RETVALUE(RFAILED);
774    }
775
776    if (SPkS16(suId, mBuf) != ROK) 
777    {
778       SPutMsg(mBuf);
779       RETVALUE(RFAILED);
780    }
781
782    if (SPkU8(status, mBuf) != ROK) 
783    {
784       SPutMsg(mBuf);
785       RETVALUE(RFAILED);
786    }
787
788   pst->event = (Event) EVTRGMBNDCFM;
789    RETVALUE(SPstTsk(pst,mBuf));
790 }
791
792 \f
793 /**
794 * @brief Confirmation from MAC to RRM for the bind/Unbind 
795  * request for the interface saps
796 *
797 * @details
798 *
799 *     Function : cmUnpkRgmBndCfm
800 *
801 *  @param[in]   Pst*  pst
802 *  @param[in]   SuId  suId
803 *  @param[in]   U8  status
804 *  @return   S16
805 *      -# ROK
806 **/
807 #ifdef ANSI
808 PUBLIC S16 cmUnpkRgmBndCfm
809 (
810 RgmBndCfm func,
811 Pst *pst,
812 Buffer *mBuf
813 )
814 #else
815 PUBLIC S16 cmUnpkRgmBndCfm(func, pst, mBuf)
816 RgmBndCfm func;
817 Pst *pst;
818 Buffer *mBuf;
819 #endif
820 {
821    SuId suId;
822    U8 status;
823    
824    TRC3(cmUnpkRgmBndCfm)
825
826    if (SUnpkU8(&status, mBuf) != ROK) 
827    {
828       SPutMsg(mBuf);
829       RETVALUE(RFAILED);
830    }
831
832    if (SUnpkS16(&suId, mBuf) != ROK) 
833    {
834       SPutMsg(mBuf);
835       RETVALUE(RFAILED);
836    }
837    SPutMsg(mBuf);
838    RETVALUE((*func)(pst, suId, status));
839 }
840
841 \f
842
843
844 /**
845 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
846 *
847 * @details
848 *
849 *     Function : cmPkCfgPrbRprt
850 *
851 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
852 *  @param[in]   Buffer *mBuf 
853 *  @return   S16
854 *      -# ROK
855 **/
856 #ifdef ANSI
857 PUBLIC S16 cmPkCfgPrbRprt
858 (
859 RgmPrbRprtCfg  * prbRprtCfg,
860 Buffer *mBuf
861 )
862 #else
863 PUBLIC S16 cmPkCfgPrbRprt(prbRprtCfg, mBuf)
864 RgmPrbRprtCfg  * prbRprtCfg;
865 Buffer *mBuf;
866 #endif
867 {
868    TRC3(cmPkCfgPrbRprt);
869    CMCHKPK(SPkU16, prbRprtCfg->usPrbAvgPeriodicty, mBuf);
870    CMCHKPK(SPkU8, prbRprtCfg->bConfigType, mBuf);
871    CMCHKPK(SPkU8, prbRprtCfg->bCellId, mBuf);
872    RETVALUE(ROK);
873 }
874 /**
875 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
876 *
877 * @details
878 *
879 *     Function : cmUnPkCfgPrbRprt
880 *
881 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
882 *  @param[in]   Buffer *mBuf 
883 *  @return   S16
884 *      -# ROK
885 **/
886 #ifdef ANSI
887 PUBLIC S16 cmUnPkCfgPrbRprt
888 (
889 RgmPrbRprtCfg  * prbRprtCfg,
890 Buffer *mBuf
891 )
892 #else
893 PUBLIC S16 cmUnPkCfgPrbRprt(prbRprtCfg, mBuf)
894 RgmPrbRprtCfg  * prbRprtCfg;
895 Buffer *mBuf;
896 #endif
897 {
898    TRC3(cmUnPkCfgPrbRprt);
899    CMCHKUNPK(SUnpkU8, &prbRprtCfg->bCellId, mBuf);
900    CMCHKUNPK(SUnpkU8, &prbRprtCfg->bConfigType, mBuf);
901    CMCHKUNPK(SUnpkU16, &prbRprtCfg->usPrbAvgPeriodicty, mBuf);
902    RETVALUE(ROK);
903 }
904
905
906
907 \f
908 /**
909 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
910 *
911 * @details
912 *
913 *     Function : cmPkRgmCfgPrbRprt
914 *
915 *  @param[in]   Pst*  pst
916 *  @param[in]   SpId  spId
917 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
918 *  @return   S16
919 *      -# ROK
920 **/
921 #ifdef ANSI
922 PUBLIC S16 cmPkRgmCfgPrbRprt
923 (
924 Pst* pst,
925 SpId spId,
926 RgmPrbRprtCfg  * prbRprtCfg
927 )
928 #else
929 PUBLIC S16 cmPkRgmCfgPrbRprt(pst, spId, prbRprtCfg)
930 Pst* pst;
931 SpId spId;
932 RgmPrbRprtCfg  * prbRprtCfg;
933 #endif
934 {
935    Buffer *mBuf = NULLP;
936    U32 len = sizeof(RgmPrbRprtCfg);
937    TRC3(cmPkRgmCfgPrbRprt)
938
939    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
940    {
941       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
942       RETVALUE(RFAILED);
943    }
944
945     if(cmPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
946     {
947        SPutMsg(mBuf); 
948        SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
949        RETVALUE(RFAILED);
950     }
951
952    if (SPkS16(spId, mBuf) != ROK) 
953    {
954       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
955       SPutMsg(mBuf);
956       RETVALUE(RFAILED);
957    }
958
959    SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
960
961    pst->event = (Event) EVTRGMCFGPRBRPRT;
962    RETVALUE(SPstTsk(pst,mBuf));
963 }
964
965
966
967 /**
968 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
969 *
970 * @details
971 *
972 *     Function : cmUnpkRgmCfgPrbRprt
973 *
974 *  @param[in]   Pst*  pst
975 *  @param[in]   SpId  spId
976 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
977 *  @return   S16
978 *      -# ROK
979 **/
980 #ifdef ANSI
981 PUBLIC S16 cmUnpkRgmCfgPrbRprt
982 (
983 RgmCfgPrbRprtFptr func,
984 Pst *pst,
985 Buffer *mBuf
986 )
987 #else
988 PUBLIC S16 cmUnpkRgmCfgPrbRprt(func, pst, mBuf)
989 RgmCfgPrbRprtFptr func;
990 Pst *pst;
991 Buffer *mBuf;
992 #endif
993 {
994    SpId spId;
995    RgmPrbRprtCfg *prbRprtCfg;
996
997    TRC3(cmUnpkRgmCfgPrbRprt)
998    if ((SGetSBuf(pst->region, pst->pool, (Data **)&prbRprtCfg, sizeof(RgmPrbRprtCfg))) != ROK)
999       {
1000          SPutMsg(mBuf);
1001          RETVALUE(RFAILED);
1002       }
1003
1004    if (SUnpkS16(&spId, mBuf) != ROK) 
1005    {
1006       SPutMsg(mBuf);
1007       RETVALUE(RFAILED);
1008    }
1009
1010    if (cmUnPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
1011    {
1012       SPutMsg(mBuf);
1013       RETVALUE(RFAILED);
1014    }
1015
1016    SPutMsg(mBuf);
1017    RETVALUE((*func)(pst, spId, prbRprtCfg));
1018 }
1019
1020 /* RRM_SP1_START */
1021 /**
1022 * @brief Packing of PRB Usage Report for qci for sending 
1023 *        to RRM from MAC 
1024 *
1025 * @details
1026 *
1027 *     Function : cmPkRgmPrbQciRpt 
1028 *
1029 *  @param[in]   RgmPrbRptPerQci * qciPrbRprt 
1030 *  @param[out]   Buffer *mBuf 
1031 *  @return   S16
1032 *      -# ROK
1033 **/
1034 #ifdef ANSI
1035 PUBLIC S16 cmPkRgmPrbQciRpt 
1036 (
1037  RgmPrbRptPerQci *qciPrbRprt,
1038  Buffer *mBuf
1039  )
1040 #else
1041 PUBLIC S16 cmPkRgmPrbQciRpt(qciPrbRprt, mBuf)
1042 RgmPrbRptPerQci *qciPrbRprt;
1043 Buffer *mBuf = NULLP;
1044 #endif
1045 {
1046    CMCHKPK(SPkU8, qciPrbRprt->bQci, mBuf);
1047    CMCHKPK(SPkU8, qciPrbRprt->bAvgPrbUlUsage, mBuf);
1048    CMCHKPK(SPkU8, qciPrbRprt->bAvgPrbDlUsage, mBuf);
1049
1050    RETVALUE(ROK);
1051 }
1052
1053 /**
1054 * @brief Unpacking of PRB Usage Report for qci received from MAC 
1055 *
1056 * @details
1057 *
1058 *     Function : cmUnpkRgmPrbQciRpt 
1059 *
1060 *  @param[out]   RgmPrbRptPerQci * qciPrbRprt 
1061 *  @param[in]   Buffer *mBuf 
1062 *  @return   S16
1063 *      -# ROK
1064 **/
1065 #ifdef ANSI
1066 PUBLIC S16 cmUnpkRgmPrbQciRpt 
1067 (
1068  RgmPrbRptPerQci *qciPrbRprt,
1069  Buffer *mBuf
1070  )
1071 #else
1072 PUBLIC S16 cmUnpkRgmPrbQciRpt(qciPrbRprt, mBuf)
1073 RgmPrbRptPerQci *qciPrbRprt;
1074 Buffer *mBuf = NULLP;
1075 #endif
1076 {
1077    CMCHKUNPK(SUnpkU8, &qciPrbRprt->bAvgPrbDlUsage, mBuf);
1078    CMCHKUNPK(SUnpkU8, &qciPrbRprt->bAvgPrbUlUsage, mBuf);
1079    CMCHKUNPK(SUnpkU8, &qciPrbRprt->bQci, mBuf);
1080
1081    RETVALUE(ROK);
1082 }
1083 /* RRM_SP1_END */
1084
1085 /**
1086 * @brief PRB Usage Report Indication  from MAC to RRM 
1087 *
1088 * @details
1089 *
1090 *     Function : cmPkPrbRprtInd
1091 *
1092 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1093 *  @param[in]   Buffer *mBuf 
1094 *  @return   S16
1095 *      -# ROK
1096 **/
1097 #ifdef ANSI
1098 PUBLIC S16 cmPkPrbRprtInd
1099 (
1100  RgmPrbRprtInd  * prbRprtInd,
1101  Buffer *mBuf
1102  )
1103 #else
1104 PUBLIC S16 cmPkPrbRprtInd(prbRprtInd, mBuf)
1105    RgmPrbRprtInd  * prbRprtInd;
1106    Buffer *mBuf = NULLP;
1107 #endif
1108 {
1109    S32 idx = 0;
1110
1111    TRC3(cmPkPrbRprtInd); 
1112    
1113    /* RRM_SP1_START */
1114    for(idx = RGM_MAX_QCI_REPORTS-1; idx >= 0; idx--)
1115    {
1116       CMCHKPK(cmPkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
1117    }
1118    CMCHKPK(SPkU8, prbRprtInd->bPrbUsageMask, mBuf);
1119    CMCHKPK(SPkU8, prbRprtInd->bCellId, mBuf);
1120    /* RRM_SP1_END */
1121    RETVALUE(ROK);
1122 }
1123
1124 /**
1125 * @brief PRB Usage Report Indication  from MAC to RRM 
1126 *
1127 * @details
1128 *
1129 *     Function : cmUnpkPrbRprtInd
1130 *
1131 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1132 *  @param[in]   Buffer *mBuf 
1133 *  @return   S16
1134 *      -# ROK
1135 **/
1136 #ifdef ANSI
1137 PUBLIC S16 cmUnpkPrbRprtInd
1138 (
1139  RgmPrbRprtInd  * prbRprtInd,
1140  Buffer *mBuf
1141  )
1142 #else
1143 PUBLIC S16 cmUnpkPrbRprtInd(prbRprtInd, mBuf)
1144    RgmPrbRprtInd  * prbRprtInd;
1145    Buffer *mBuf;
1146 #endif
1147 {
1148    U32 idx = 0;
1149
1150    TRC3(cmUnpkPrbRprtInd);
1151
1152    /* RRM_SP1_START */
1153    CMCHKUNPK(SUnpkU8, &prbRprtInd->bCellId, mBuf);
1154    CMCHKUNPK(SUnpkU8, &prbRprtInd->bPrbUsageMask, mBuf);
1155    for(idx = 0; idx < RGM_MAX_QCI_REPORTS; idx++)
1156    {
1157       CMCHKUNPK(cmUnpkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
1158    }
1159
1160    /* RRM_SP1_END */
1161    RETVALUE(ROK);
1162 }
1163
1164
1165
1166 /**
1167 * @brief PRB Usage Report Indication  from MAC to RRM 
1168 *
1169 * @details
1170 *
1171 *     Function : cmPkRgmPrbRprtInd
1172 *
1173 *  @param[in]   Pst*  pst
1174 *  @param[in]   SuId  suId
1175 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1176 *  @return   S16
1177 *      -# ROK
1178 **/
1179 #ifdef ANSI
1180 PUBLIC S16 cmPkRgmPrbRprtInd
1181 (
1182 Pst* pst,
1183 SuId suId,
1184 RgmPrbRprtInd  * prbRprtInd
1185 )
1186 #else
1187 PUBLIC S16 cmPkRgmPrbRprtInd(pst, suId, prbRprtInd)
1188 Pst* pst;
1189 SuId suId;
1190 RgmPrbRprtInd  * prbRprtInd;
1191 #endif
1192 {
1193    Buffer *mBuf = NULLP;
1194
1195    TRC3(cmPkRgmPrbRprtInd)
1196
1197    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1198       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1199       RETVALUE(RFAILED);
1200    }
1201
1202    if(cmPkPrbRprtInd(prbRprtInd, mBuf) != ROK)
1203    {
1204       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1205       SPutMsg(mBuf);
1206       RETVALUE(RFAILED);
1207    }
1208
1209    if (SPkS16(suId, mBuf) != ROK) 
1210    {
1211       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1212       SPutMsg(mBuf);
1213       RETVALUE(RFAILED);
1214    }
1215
1216    SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1217
1218    pst->event = (Event) EVTRGMPRBRPRTIND;
1219    RETVALUE(SPstTsk(pst,mBuf));
1220 }
1221 /**
1222 * @brief PRB Usage Report Indication from MAC to RRM 
1223 *
1224 * @details
1225 *
1226 *     Function : cmUnpkRgmPrbRprtInd
1227 *
1228 *  @param[in]   Pst*  pst
1229 *  @param[in]   SuId  suId
1230 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1231 *  @return   S16
1232 *      -# ROK
1233 **/
1234 #ifdef ANSI
1235 PUBLIC S16 cmUnpkRgmPrbRprtInd
1236 (
1237 RgmPrbRprtIndFptr func,
1238 Pst *pst,
1239 Buffer *mBuf
1240 )
1241 #else
1242 PUBLIC S16 cmUnpkRgmPrbRprtInd(func, pst, mBuf)
1243 RgmPrbRprtIndFptr func;
1244 Pst *pst;
1245 Buffer *mBuf;
1246 #endif
1247 {
1248    SuId suId;
1249    RgmPrbRprtInd prbRprtInd;
1250    
1251    TRC3(cmUnpkRgmPrbRprtInd)
1252
1253    if (SUnpkS16(&suId, mBuf) != ROK) 
1254    {
1255       SPutMsg(mBuf);
1256       RETVALUE(RFAILED);
1257    }
1258
1259    if (cmUnpkPrbRprtInd(&prbRprtInd, mBuf) != ROK) 
1260    {
1261       SPutMsg(mBuf);
1262       RETVALUE(RFAILED);
1263    }
1264
1265    SPutMsg(mBuf);
1266    RETVALUE((*func)(pst, suId, &prbRprtInd));
1267 }
1268
1269 /**
1270 * @brief Transmission Mode Change Indication  from MAC to RRM 
1271 *
1272 * @details
1273 *
1274 *     Function : cmPkTransModeInd
1275 *
1276 *  @param[in]   RgmTransModeInd *transModeInd
1277 *  @param[in]   Buffer *mBuf 
1278 *  @return   S16
1279 *      -# ROK
1280 **/
1281 #ifdef ANSI
1282 PUBLIC S16 cmPkTransModeInd
1283 (
1284  RgmTransModeInd *transModeInd,
1285  Buffer *mBuf
1286  )
1287 #else
1288 PUBLIC S16 cmPkTransModeInd(transModeInd, mBuf)
1289    RgmTransModeInd *transModeInd;
1290    Buffer *mBuf;
1291 #endif
1292 {
1293    TRC3(cmPkTransModeInd); 
1294    CMCHKPK(SPkU32, transModeInd->eMode, mBuf);
1295    CMCHKPK(SPkU16, transModeInd->usCrnti, mBuf);
1296    CMCHKPK(SPkU8, transModeInd->bCellId, mBuf);
1297    RETVALUE(ROK);
1298 }
1299
1300 /**
1301 * @brief  Transmission Mode Change Indication from MAC to RRM 
1302 *
1303 * @details
1304 *
1305 *     Function : cmUnpkTransModeInd
1306 *
1307 *  @param[in]   RgmTransModeInd *transModeInd 
1308 *  @param[in]   Buffer *mBuf 
1309 *  @return   S16
1310 *      -# ROK
1311 **/
1312 #ifdef ANSI
1313 PUBLIC S16 cmUnpkTransModeInd
1314 (
1315  RgmTransModeInd *transModeInd,
1316  Buffer *mBuf
1317  )
1318 #else
1319 PUBLIC S16 cmUnpkTransModeInd(transModeInd, mBuf)
1320    RgmTransModeInd *transModeInd;
1321    Buffer *mBuf;
1322 #endif
1323 {
1324    U32 tmpModeEnum;
1325    TRC3(cmUnpkTransModeInd);
1326    CMCHKUNPK(SUnpkU8, &transModeInd->bCellId, mBuf);
1327    CMCHKUNPK(SUnpkU16, &transModeInd->usCrnti, mBuf);
1328    CMCHKUNPK(SUnpkU32, (U32 *)&tmpModeEnum, mBuf);
1329    transModeInd->eMode = (RgmTxnMode)tmpModeEnum;
1330    RETVALUE(ROK);
1331 }
1332 /**
1333 * @brief Transmission Mode Change Indication  from MAC to RRM 
1334 *
1335 * @details
1336 *
1337 *     Function : cmPkRgmTransModeInd
1338 *
1339 *  @param[in]   Pst*  pst
1340 *  @param[in]   SuId  suId
1341 *  @param[in]   RgmTransModeInd *transModeInd 
1342 *  @return   S16
1343 *      -# ROK
1344 **/
1345 #ifdef ANSI
1346 PUBLIC S16 cmPkRgmTransModeInd 
1347 (
1348 Pst* pst,
1349 SuId suId,
1350 RgmTransModeInd *transModeInd
1351 )
1352 #else
1353 PUBLIC S16 cmPkRgmTransModeInd(pst, suId, transModeInd)
1354 Pst* pst;
1355 SuId suId;
1356 RgmTransModeInd *transModeInd;
1357 #endif
1358 {
1359    Buffer *mBuf = NULLP;
1360
1361    TRC3(cmPkRgmTransModeInd)
1362
1363    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1364       SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1365       RETVALUE(RFAILED);
1366    }
1367
1368    if(cmPkTransModeInd(transModeInd, mBuf) != ROK)
1369    {
1370       SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1371       SPutMsg(mBuf);
1372       RETVALUE(RFAILED);
1373    }
1374
1375    if (SPkS16(suId, mBuf) != ROK) 
1376    {
1377       SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1378       SPutMsg(mBuf);
1379       RETVALUE(RFAILED);
1380    }
1381
1382    SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1383
1384    pst->event = (Event) EVTRGMTRANSMODEIND;
1385    RETVALUE(SPstTsk(pst,mBuf));
1386 }
1387 /**
1388 * @brief Transmission Mode Change Indication  from MAC to RRM 
1389 *
1390 * @details
1391 *
1392 *     Function : cmUnpkRgmTransModeInd
1393 *
1394 *  @param[in]   Pst*  pst
1395 *  @param[in]   SuId  suId
1396 *  @param[in]   RgmTransModeInd *transModeInd 
1397 *  @return   S16
1398 *      -# ROK
1399 **/
1400 #ifdef ANSI
1401 PUBLIC S16 cmUnpkRgmTransModeInd
1402 (
1403 RgmTransModeIndFptr func,
1404 Pst *pst,
1405 Buffer *mBuf
1406 )
1407 #else
1408 PUBLIC S16 cmUnpkRgmTransModeInd(func, pst, mBuf)
1409 RgmTransModeIndFptr func;
1410 Pst *pst;
1411 Buffer *mBuf;
1412 #endif
1413 {
1414    SuId suId;
1415    RgmTransModeInd transModeInd;
1416    
1417    TRC3(cmUnpkRgmTransModeInd)
1418
1419    if (SUnpkS16(&suId, mBuf) != ROK) 
1420    {
1421       SPutMsg(mBuf);
1422       RETVALUE(RFAILED);
1423    }
1424
1425    if (cmUnpkTransModeInd(&transModeInd, mBuf) != ROK) 
1426    {
1427       SPutMsg(mBuf);
1428       RETVALUE(RFAILED);
1429    }
1430
1431    SPutMsg(mBuf);
1432    RETVALUE((*func)(pst, suId, &transModeInd));
1433 }
1434 /**********************************************************************
1435  
1436          End of file
1437  
1438 **********************************************************************/