[Epic-ID: ODUHIGH-462][Task-ID: ODUHIGH-472] Implementation of onduration timer
[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 "common_def.h"
40 #include "rgm.h"           /* RGM Interface defines */
41 /* header/extern include files (.x) */
42 #include "rgm.x"           /* RGM Interface includes */
43
44 #ifdef RGM_LWLC
45
46 \f
47 /**
48 * @brief Request from RRM to MAC to bind the interface saps
49 *
50 * @details
51 *
52 *     Function : cmPkLwLcRgmBndReq
53 *
54 *  @param[in]   Pst*  pst
55 *  @param[in]   SuId  suId
56 *  @param[in]   SpId  spId
57 *  @return   S16
58 *      -# ROK
59 **/
60 S16 cmPkLwLcRgmBndReq
61 (
62 Pst* pst,
63 SuId suId,
64 SpId spId
65 )
66 {
67    Buffer *mBuf = NULLP;
68
69    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
70    {
71       return RFAILED;
72    }
73
74    if (SPkS16(spId, mBuf) != ROK) 
75    {
76       SPutMsg(mBuf);
77       return RFAILED;
78    }
79
80    if (SPkS16(suId, mBuf) != ROK) 
81    {
82       SPutMsg(mBuf);
83       return RFAILED;
84    }
85
86    pst->event = (Event) EVTRGMBNDREQ;
87    return (SPstTsk(pst,mBuf));
88 }
89
90 \f
91 /**
92 * @brief Request from RRM to MAC to bind the interface saps
93 *
94 * @details
95 *
96 *     Function : cmUnpkLwLcRgmBndReq
97 *
98 *  @param[in]   Pst*  pst
99 *  @param[in]   SuId  suId
100 *  @param[in]   SpId  spId
101 *  @return   S16
102 *      -# ROK
103 **/
104 S16 cmUnpkLwLcRgmBndReq
105 (
106 RgmBndReq func,
107 Pst *pst,
108 Buffer *mBuf
109 )
110 {
111    SuId suId;
112    SpId spId;
113    S16  ret;
114    
115
116    if (SUnpkS16(&suId, mBuf) != ROK) 
117    {
118       SPutMsg(mBuf);
119       return RFAILED;
120    }
121
122    if (SUnpkS16(&spId, mBuf) != ROK) 
123    {
124       SPutMsg(mBuf);
125       return RFAILED;
126    }
127
128    ret = ((*func)(pst, suId, spId));
129
130    SPutMsg(mBuf);
131
132    return (ret);
133 }
134
135 /**
136 * @brief Request from RRM to MAC to Unbind the interface saps
137 *
138 * @details
139 *
140 *     Function : cmPkLwLcRgmUbndReq
141 *
142 *  @param[in]   Pst*  pst
143 *  @param[in]   SpId  spId
144 *  @param[in]   Reason  reason
145 *  @return   S16
146 *      -# ROK
147 **/
148 S16 cmPkLwLcRgmUbndReq
149 (
150 Pst* pst,
151 SpId spId,
152 Reason reason
153 )
154 {
155    Buffer *mBuf = NULLP;
156
157    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
158    {
159       return RFAILED;
160    }
161    if (SPkS16(reason, mBuf) != ROK) 
162    {
163       SPutMsg(mBuf);
164       return RFAILED;
165    }
166    if (SPkS16(spId, mBuf) != ROK) 
167    {
168       SPutMsg(mBuf);
169       return RFAILED;
170    }
171
172    pst->event = (Event) EVTRGMUBNDREQ;
173    return (SPstTsk(pst,mBuf));
174 }
175
176 /**
177 * @brief Confirmation from MAC to RRM for the bind/Unbind 
178  * request for the interface saps
179 *
180 * @details
181 *
182 *     Function : cmPkLwLcRgmBndCfm
183 *
184 *  @param[in]   Pst*  pst
185 *  @param[in]   SuId  suId
186 *  @param[in]   uint8_t  status
187 *  @return   S16
188 *      -# ROK
189 **/
190 S16 cmPkLwLcRgmBndCfm
191 (
192 Pst* pst,
193 SuId suId,
194 uint8_t status
195 )
196 {
197    Buffer *mBuf = NULLP;
198
199    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
200    {
201       return RFAILED;
202    }
203
204    if (SPkS16(suId, mBuf) != ROK) 
205    {
206       SPutMsg(mBuf);
207       return RFAILED;
208    }
209
210    if (oduUnpackUInt8(status, mBuf) != ROK) 
211    {
212       SPutMsg(mBuf);
213       return RFAILED;
214    }
215
216   pst->event = (Event) EVTRGMBNDCFM;
217    return (SPstTsk(pst,mBuf));
218 }
219
220 \f
221 /**
222 * @brief Confirmation from MAC to RRM for the bind/Unbind 
223  * request for the interface saps
224 *
225 * @details
226 *
227 *     Function : cmUnpkLwLcRgmBndCfm
228 *
229 *  @param[in]   Pst*  pst
230 *  @param[in]   SuId  suId
231 *  @param[in]   uint8_t  status
232 *  @return   S16
233 *      -# ROK
234 **/
235 S16 cmUnpkLwLcRgmBndCfm
236 (
237 RgmBndCfm func,
238 Pst *pst,
239 Buffer *mBuf
240 )
241 {
242    SuId suId;
243    uint8_t status;
244    
245
246    if (oduPackUInt8(&status, mBuf) != ROK) 
247    {
248       SPutMsg(mBuf);
249       return RFAILED;
250    }
251
252    if (SUnpkS16(&suId, mBuf) != ROK) 
253    {
254       SPutMsg(mBuf);
255       return RFAILED;
256    }
257    SPutMsg(mBuf);
258    return ((*func)(pst, suId, status));
259 }
260
261 \f
262 /**
263 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
264 *
265 * @details
266 *
267 *     Function : cmPkLwLcRgmCfgPrbRprt
268 *
269 *  @param[in]   Pst*  pst
270 *  @param[in]   SpId  spId
271 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
272 *  @return   S16
273 *      -# ROK
274 **/
275 S16 cmPkLwLcRgmCfgPrbRprt
276 (
277 Pst* pst,
278 SpId spId,
279 RgmPrbRprtCfg  * prbRprtCfg
280 )
281 {
282    Buffer *mBuf = NULLP;
283    uint32_t len = sizeof(RgmPrbRprtCfg);
284
285    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
286    {
287       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
288       return RFAILED;
289    }
290
291     if(oduPackPointer((PTR)prbRprtCfg, mBuf) != ROK)
292     {
293        SPutMsg(mBuf); 
294        SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data*)prbRprtCfg, len);
295        return RFAILED;
296     }
297
298    if (SPkS16(spId, mBuf) != ROK) 
299    {
300       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
301       SPutMsg(mBuf);
302       return RFAILED;
303    }
304
305    pst->event = (Event) EVTRGMCFGPRBRPRT;
306    return (SPstTsk(pst,mBuf));
307 }
308
309 \f
310 /**
311 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
312 *
313 * @details
314 *
315 *     Function : cmUnpkLwLcRgmCfgPrbRprt
316 *
317 *  @param[in]   Pst*  pst
318 *  @param[in]   SpId  spId
319 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
320 *  @return   S16
321 *      -# ROK
322 **/
323 S16 cmUnpkLwLcRgmCfgPrbRprt
324 (
325 RgmCfgPrbRprtFptr func,
326 Pst *pst,
327 Buffer *mBuf
328 )
329 {
330    S16 ret;
331    SpId spId;
332    RgmPrbRprtCfg *prbRprtCfg;
333    
334
335    if (SUnpkS16(&spId, mBuf) != ROK) 
336    {
337       SPutMsg(mBuf);
338       return RFAILED;
339    }
340
341    if (oduUnpackPointer((PTR *)&prbRprtCfg, mBuf) != ROK)
342    {
343       SPutMsg(mBuf);
344       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
345       return RFAILED;
346    }
347
348    ret =  ((*func)(pst, spId, prbRprtCfg));
349
350    SPutMsg(mBuf);
351    return (ret);
352 }
353
354
355 /**
356 * @brief PRB Usage Report Indication  from MAC to RRM 
357 *
358 * @details
359 *
360 *     Function : cmPkLwLcRgmPrbRprtInd
361 *
362 *  @param[in]   Pst*  pst
363 *  @param[in]   SuId  suId
364 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
365 *  @return   S16
366 *      -# ROK
367 **/
368 S16 cmPkLwLcRgmPrbRprtInd
369 (
370 Pst* pst,
371 SuId suId,
372 RgmPrbRprtInd  * prbRprtInd
373 )
374 {
375    Buffer *mBuf = NULLP;
376
377
378    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
379       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
380       return RFAILED;
381    }
382
383    if(oduPackPointer((PTR)prbRprtInd, mBuf) != ROK)
384    {
385       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
386       SPutMsg(mBuf);
387       return RFAILED;
388    }
389
390    if (SPkS16(suId, mBuf) != ROK) 
391    {
392       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
393       SPutMsg(mBuf);
394       return RFAILED;
395    }
396
397    pst->event = (Event) EVTRGMCFGPRBRPRT;
398    return (SPstTsk(pst,mBuf));
399 }
400
401
402 /**
403 * @brief PRB Usage Report Indication from MAC to RRM 
404 *
405 * @details
406 *
407 *     Function : cmUnpkLwLcRgmPrbRprtInd
408 *
409 *  @param[in]   Pst*  pst
410 *  @param[in]   SuId  suId
411 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
412 *  @return   S16
413 *      -# ROK
414 **/
415 S16 cmUnpkLwLcRgmPrbRprtInd
416 (
417 RgmPrbRprtIndFptr func,
418 Pst *pst,
419 Buffer *mBuf
420 )
421 {
422    SuId suId;
423    RgmPrbRprtInd *prbRprtInd;
424    S16 ret;
425    
426
427    if (SUnpkS16(&suId, mBuf) != ROK) 
428    {
429       SPutMsg(mBuf);
430       return RFAILED;
431    }
432
433    if (oduUnpackPointer((PTR *)&prbRprtInd, mBuf) != ROK) 
434    {
435       SPutMsg(mBuf);
436       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
437       return RFAILED;
438    }
439
440
441    ret = ((*func)(pst, suId, prbRprtInd));
442
443    SPutMsg(mBuf);
444
445    return (ret);
446 }
447 #endif
448
449
450 /**
451 * @brief Request from RRM to MAC to bind the interface saps
452 *
453 * @details
454 *
455 *     Function : cmPkRgmBndReq
456 *
457 *  @param[in]   Pst*  pst
458 *  @param[in]   SuId  suId
459 *  @param[in]   SpId  spId
460 *  @return   S16
461 *      -# ROK
462 **/
463 S16 cmPkRgmBndReq
464 (
465 Pst* pst,
466 SuId suId,
467 SpId spId
468 )
469 {
470    Buffer *mBuf = NULLP;
471
472    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
473    {
474       return RFAILED;
475    }
476
477    if (SPkS16(spId, mBuf) != ROK) 
478    {
479       SPutMsg(mBuf);
480       return RFAILED;
481    }
482
483    if (SPkS16(suId, mBuf) != ROK) 
484    {
485       SPutMsg(mBuf);
486       return RFAILED;
487    }
488
489    pst->event = (Event) EVTRGMBNDREQ;
490    return (SPstTsk(pst,mBuf));
491 }
492
493 \f
494 /**
495 * @brief Request from RRM to MAC to bind the interface saps
496 *
497 * @details
498 *
499 *     Function : cmUnpkRgmBndReq
500 *
501 *  @param[in]   Pst*  pst
502 *  @param[in]   SuId  suId
503 *  @param[in]   SpId  spId
504 *  @return   S16
505 *      -# ROK
506 **/
507 S16 cmUnpkRgmBndReq
508 (
509 RgmBndReq func,
510 Pst *pst,
511 Buffer *mBuf
512 )
513 {
514    SuId suId;
515    SpId spId;
516    S16  ret;
517    
518
519    if (SUnpkS16(&suId, mBuf) != ROK) 
520    {
521       SPutMsg(mBuf);
522       return RFAILED;
523    }
524
525    if (SUnpkS16(&spId, mBuf) != ROK) 
526    {
527       SPutMsg(mBuf);
528       return RFAILED;
529    }
530
531    ret = ((*func)(pst, suId, spId));
532
533    SPutMsg(mBuf);
534
535    return (ret);
536 }
537
538 /**
539 * @brief Request from RRM to MAC to Unbind the interface saps
540 *
541 * @details
542 *
543 *     Function : cmPkRgmUbndReq
544 *
545 *  @param[in]   Pst*  pst
546 *  @param[in]   SpId  spId
547 *  @param[in]   Reason  reason
548 *  @return   S16
549 *      -# ROK
550 **/
551 S16 cmPkRgmUbndReq
552 (
553 Pst* pst,
554 SpId spId,
555 Reason reason
556 )
557 {
558    Buffer *mBuf = NULLP;
559
560    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
561    {
562       return RFAILED;
563    }
564    if (SPkS16(reason, mBuf) != ROK) 
565    {
566       SPutMsg(mBuf);
567       return RFAILED;
568    }
569    if (SPkS16(spId, mBuf) != ROK) 
570    {
571       SPutMsg(mBuf);
572       return RFAILED;
573    }
574
575    pst->event = (Event) EVTRGMUBNDREQ;
576    return (SPstTsk(pst,mBuf));
577 }
578
579 #if 1 
580 \f
581 /**
582 * @brief Request from RRM to MAC to Unbind the interface saps
583 *
584 * @details
585 *
586 *     Function : cmUnpkRgmUbndReq
587 *
588 *  @param[in]   Pst*  pst
589 *  @param[in]   SpId  spId
590 *  @param[in]   Reason  reason
591 *  @return   S16
592 *      -# ROK
593 **/
594 S16 cmUnpkRgmUbndReq
595 (
596 RgmUbndReq func,
597 Pst *pst,
598 Buffer *mBuf
599 )
600 {
601    SpId spId;
602    Reason reason;
603    
604
605    if (SUnpkS16(&spId, mBuf) != ROK) 
606    {
607       SPutMsg(mBuf);
608       return RFAILED;
609    }
610    if (SUnpkS16(&reason, mBuf) != ROK)
611    {
612       SPutMsg(mBuf);
613       return RFAILED;
614    }
615    SPutMsg(mBuf);
616    return ((*func)(pst, spId, reason));
617 }
618 #endif
619
620 /**
621 * @brief Confirmation from MAC to RRM for the bind/Unbind 
622  * request for the interface saps
623 *
624 * @details
625 *
626 *     Function : cmPkRgmBndCfm
627 *
628 *  @param[in]   Pst*  pst
629 *  @param[in]   SuId  suId
630 *  @param[in]   uint8_t  status
631 *  @return   S16
632 *      -# ROK
633 **/
634 S16 cmPkRgmBndCfm
635 (
636 Pst* pst,
637 SuId suId,
638 uint8_t status
639 )
640 {
641    Buffer *mBuf = NULLP;
642
643    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
644    {
645       return RFAILED;
646    }
647
648    if (SPkS16(suId, mBuf) != ROK) 
649    {
650       SPutMsg(mBuf);
651       return RFAILED;
652    }
653
654    if (oduUnpackUInt8(status, mBuf) != ROK) 
655    {
656       SPutMsg(mBuf);
657       return RFAILED;
658    }
659
660   pst->event = (Event) EVTRGMBNDCFM;
661    return (SPstTsk(pst,mBuf));
662 }
663
664 \f
665 /**
666 * @brief Confirmation from MAC to RRM for the bind/Unbind 
667  * request for the interface saps
668 *
669 * @details
670 *
671 *     Function : cmUnpkRgmBndCfm
672 *
673 *  @param[in]   Pst*  pst
674 *  @param[in]   SuId  suId
675 *  @param[in]   uint8_t  status
676 *  @return   S16
677 *      -# ROK
678 **/
679 S16 cmUnpkRgmBndCfm
680 (
681 RgmBndCfm func,
682 Pst *pst,
683 Buffer *mBuf
684 )
685 {
686    SuId suId;
687    uint8_t status;
688    
689
690    if (oduPackUInt8(&status, mBuf) != ROK) 
691    {
692       SPutMsg(mBuf);
693       return RFAILED;
694    }
695
696    if (SUnpkS16(&suId, mBuf) != ROK) 
697    {
698       SPutMsg(mBuf);
699       return RFAILED;
700    }
701    SPutMsg(mBuf);
702    return ((*func)(pst, suId, status));
703 }
704
705 \f
706
707
708 /**
709 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
710 *
711 * @details
712 *
713 *     Function : cmPkCfgPrbRprt
714 *
715 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
716 *  @param[in]   Buffer *mBuf 
717 *  @return   S16
718 *      -# ROK
719 **/
720 S16 cmPkCfgPrbRprt
721 (
722 RgmPrbRprtCfg  * prbRprtCfg,
723 Buffer *mBuf
724 )
725 {
726    CMCHKPK(oduUnpackUInt16, prbRprtCfg->usPrbAvgPeriodicty, mBuf);
727    CMCHKPK(oduUnpackUInt8, prbRprtCfg->bConfigType, mBuf);
728    CMCHKPK(oduUnpackUInt8, prbRprtCfg->bCellId, mBuf);
729    return ROK;
730 }
731 /**
732 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
733 *
734 * @details
735 *
736 *     Function : cmUnPkCfgPrbRprt
737 *
738 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
739 *  @param[in]   Buffer *mBuf 
740 *  @return   S16
741 *      -# ROK
742 **/
743 S16 cmUnPkCfgPrbRprt
744 (
745 RgmPrbRprtCfg  * prbRprtCfg,
746 Buffer *mBuf
747 )
748 {
749    CMCHKUNPK(oduPackUInt8, &prbRprtCfg->bCellId, mBuf);
750    CMCHKUNPK(oduPackUInt8, &prbRprtCfg->bConfigType, mBuf);
751    CMCHKUNPK(oduPackUInt16, &prbRprtCfg->usPrbAvgPeriodicty, mBuf);
752    return ROK;
753 }
754
755
756
757 \f
758 /**
759 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
760 *
761 * @details
762 *
763 *     Function : cmPkRgmCfgPrbRprt
764 *
765 *  @param[in]   Pst*  pst
766 *  @param[in]   SpId  spId
767 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
768 *  @return   S16
769 *      -# ROK
770 **/
771 S16 cmPkRgmCfgPrbRprt
772 (
773 Pst* pst,
774 SpId spId,
775 RgmPrbRprtCfg  * prbRprtCfg
776 )
777 {
778    Buffer *mBuf = NULLP;
779    uint32_t len = sizeof(RgmPrbRprtCfg);
780
781    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
782    {
783       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
784       return RFAILED;
785    }
786
787     if(cmPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
788     {
789        SPutMsg(mBuf); 
790        SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data*)prbRprtCfg, len);
791        return RFAILED;
792     }
793
794    if (SPkS16(spId, mBuf) != ROK) 
795    {
796       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
797       SPutMsg(mBuf);
798       return RFAILED;
799    }
800
801    SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
802
803    pst->event = (Event) EVTRGMCFGPRBRPRT;
804    return (SPstTsk(pst,mBuf));
805 }
806
807
808
809 /**
810 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC 
811 *
812 * @details
813 *
814 *     Function : cmUnpkRgmCfgPrbRprt
815 *
816 *  @param[in]   Pst*  pst
817 *  @param[in]   SpId  spId
818 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
819 *  @return   S16
820 *      -# ROK
821 **/
822 S16 cmUnpkRgmCfgPrbRprt
823 (
824 RgmCfgPrbRprtFptr func,
825 Pst *pst,
826 Buffer *mBuf
827 )
828 {
829    SpId spId;
830    RgmPrbRprtCfg *prbRprtCfg;
831
832    if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&prbRprtCfg, sizeof(RgmPrbRprtCfg))) != ROK)
833       {
834          SPutMsg(mBuf);
835          return RFAILED;
836       }
837
838    if (SUnpkS16(&spId, mBuf) != ROK) 
839    {
840       SPutMsg(mBuf);
841       return RFAILED;
842    }
843
844    if (cmUnPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
845    {
846       SPutMsg(mBuf);
847       return RFAILED;
848    }
849
850    SPutMsg(mBuf);
851    return ((*func)(pst, spId, prbRprtCfg));
852 }
853
854 /* RRM_SP1_START */
855 /**
856 * @brief Packing of PRB Usage Report for qci for sending 
857 *        to RRM from MAC 
858 *
859 * @details
860 *
861 *     Function : cmPkRgmPrbQciRpt 
862 *
863 *  @param[in]   RgmPrbRptPerQci * qciPrbRprt 
864 *  @param[out]   Buffer *mBuf 
865 *  @return   S16
866 *      -# ROK
867 **/
868 S16 cmPkRgmPrbQciRpt 
869 (
870 RgmPrbRptPerQci *qciPrbRprt,
871 Buffer *mBuf
872 )
873 {
874    CMCHKPK(oduUnpackUInt8, qciPrbRprt->bQci, mBuf);
875    CMCHKPK(oduUnpackUInt8, qciPrbRprt->bAvgPrbUlUsage, mBuf);
876    CMCHKPK(oduUnpackUInt8, qciPrbRprt->bAvgPrbDlUsage, mBuf);
877
878    return ROK;
879 }
880
881 /**
882 * @brief Unpacking of PRB Usage Report for qci received from MAC 
883 *
884 * @details
885 *
886 *     Function : cmUnpkRgmPrbQciRpt 
887 *
888 *  @param[out]   RgmPrbRptPerQci * qciPrbRprt 
889 *  @param[in]   Buffer *mBuf 
890 *  @return   S16
891 *      -# ROK
892 **/
893 S16 cmUnpkRgmPrbQciRpt 
894 (
895 RgmPrbRptPerQci *qciPrbRprt,
896 Buffer *mBuf
897 )
898 {
899    CMCHKUNPK(oduPackUInt8, &qciPrbRprt->bAvgPrbDlUsage, mBuf);
900    CMCHKUNPK(oduPackUInt8, &qciPrbRprt->bAvgPrbUlUsage, mBuf);
901    CMCHKUNPK(oduPackUInt8, &qciPrbRprt->bQci, mBuf);
902
903    return ROK;
904 }
905 /* RRM_SP1_END */
906
907 /**
908 * @brief PRB Usage Report Indication  from MAC to RRM 
909 *
910 * @details
911 *
912 *     Function : cmPkPrbRprtInd
913 *
914 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
915 *  @param[in]   Buffer *mBuf 
916 *  @return   S16
917 *      -# ROK
918 **/
919 S16 cmPkPrbRprtInd
920 (
921 RgmPrbRprtInd  * prbRprtInd,
922 Buffer *mBuf
923 )
924 {
925    S32 idx = 0;
926
927    
928    /* RRM_SP1_START */
929    for(idx = RGM_MAX_QCI_REPORTS-1; idx >= 0; idx--)
930    {
931       CMCHKPK(cmPkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
932    }
933    CMCHKPK(oduUnpackUInt8, prbRprtInd->bPrbUsageMask, mBuf);
934    CMCHKPK(oduUnpackUInt8, prbRprtInd->bCellId, mBuf);
935    /* RRM_SP1_END */
936    return ROK;
937 }
938
939 /**
940 * @brief PRB Usage Report Indication  from MAC to RRM 
941 *
942 * @details
943 *
944 *     Function : cmUnpkPrbRprtInd
945 *
946 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
947 *  @param[in]   Buffer *mBuf 
948 *  @return   S16
949 *      -# ROK
950 **/
951 S16 cmUnpkPrbRprtInd
952 (
953 RgmPrbRprtInd  * prbRprtInd,
954 Buffer *mBuf
955 )
956 {
957    uint32_t idx = 0;
958
959
960    /* RRM_SP1_START */
961    CMCHKUNPK(oduPackUInt8, &prbRprtInd->bCellId, mBuf);
962    CMCHKUNPK(oduPackUInt8, &prbRprtInd->bPrbUsageMask, mBuf);
963    for(idx = 0; idx < RGM_MAX_QCI_REPORTS; idx++)
964    {
965       CMCHKUNPK(cmUnpkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
966    }
967
968    /* RRM_SP1_END */
969    return ROK;
970 }
971
972
973
974 /**
975 * @brief PRB Usage Report Indication  from MAC to RRM 
976 *
977 * @details
978 *
979 *     Function : cmPkRgmPrbRprtInd
980 *
981 *  @param[in]   Pst*  pst
982 *  @param[in]   SuId  suId
983 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
984 *  @return   S16
985 *      -# ROK
986 **/
987 S16 cmPkRgmPrbRprtInd
988 (
989 Pst* pst,
990 SuId suId,
991 RgmPrbRprtInd  * prbRprtInd
992 )
993 {
994    Buffer *mBuf = NULLP;
995
996
997    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
998       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
999       return RFAILED;
1000    }
1001
1002    if(cmPkPrbRprtInd(prbRprtInd, mBuf) != ROK)
1003    {
1004       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1005       SPutMsg(mBuf);
1006       return RFAILED;
1007    }
1008
1009    if (SPkS16(suId, mBuf) != ROK) 
1010    {
1011       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1012       SPutMsg(mBuf);
1013       return RFAILED;
1014    }
1015
1016    SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1017
1018    pst->event = (Event) EVTRGMPRBRPRTIND;
1019    return (SPstTsk(pst,mBuf));
1020 }
1021 /**
1022 * @brief PRB Usage Report Indication from MAC to RRM 
1023 *
1024 * @details
1025 *
1026 *     Function : cmUnpkRgmPrbRprtInd
1027 *
1028 *  @param[in]   Pst*  pst
1029 *  @param[in]   SuId  suId
1030 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1031 *  @return   S16
1032 *      -# ROK
1033 **/
1034 S16 cmUnpkRgmPrbRprtInd
1035 (
1036 RgmPrbRprtIndFptr func,
1037 Pst *pst,
1038 Buffer *mBuf
1039 )
1040 {
1041    SuId suId;
1042    RgmPrbRprtInd prbRprtInd;
1043    
1044
1045    if (SUnpkS16(&suId, mBuf) != ROK) 
1046    {
1047       SPutMsg(mBuf);
1048       return RFAILED;
1049    }
1050
1051    if (cmUnpkPrbRprtInd(&prbRprtInd, mBuf) != ROK) 
1052    {
1053       SPutMsg(mBuf);
1054       return RFAILED;
1055    }
1056
1057    SPutMsg(mBuf);
1058    return ((*func)(pst, suId, &prbRprtInd));
1059 }
1060
1061 /**
1062 * @brief Transmission Mode Change Indication  from MAC to RRM 
1063 *
1064 * @details
1065 *
1066 *     Function : cmPkTransModeInd
1067 *
1068 *  @param[in]   RgmTransModeInd *transModeInd
1069 *  @param[in]   Buffer *mBuf 
1070 *  @return   S16
1071 *      -# ROK
1072 **/
1073 S16 cmPkTransModeInd
1074 (
1075 RgmTransModeInd *transModeInd,
1076 Buffer *mBuf
1077 )
1078 {
1079    CMCHKPK(oduUnpackUInt32, transModeInd->eMode, mBuf);
1080    CMCHKPK(oduUnpackUInt16, transModeInd->usCrnti, mBuf);
1081    CMCHKPK(oduUnpackUInt8, transModeInd->bCellId, mBuf);
1082    return ROK;
1083 }
1084
1085 /**
1086 * @brief  Transmission Mode Change Indication from MAC to RRM 
1087 *
1088 * @details
1089 *
1090 *     Function : cmUnpkTransModeInd
1091 *
1092 *  @param[in]   RgmTransModeInd *transModeInd 
1093 *  @param[in]   Buffer *mBuf 
1094 *  @return   S16
1095 *      -# ROK
1096 **/
1097 S16 cmUnpkTransModeInd
1098 (
1099 RgmTransModeInd *transModeInd,
1100 Buffer *mBuf
1101 )
1102 {
1103    uint32_t tmpModeEnum;
1104    CMCHKUNPK(oduPackUInt8, &transModeInd->bCellId, mBuf);
1105    CMCHKUNPK(oduPackUInt16, &transModeInd->usCrnti, mBuf);
1106    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpModeEnum, mBuf);
1107    transModeInd->eMode = (RgmTxnMode)tmpModeEnum;
1108    return ROK;
1109 }
1110 /**
1111 * @brief Transmission Mode Change Indication  from MAC to RRM 
1112 *
1113 * @details
1114 *
1115 *     Function : cmPkRgmTransModeInd
1116 *
1117 *  @param[in]   Pst*  pst
1118 *  @param[in]   SuId  suId
1119 *  @param[in]   RgmTransModeInd *transModeInd 
1120 *  @return   S16
1121 *      -# ROK
1122 **/
1123
1124 S16 cmPkRgmTransModeInd 
1125 (
1126 Pst* pst,
1127 SuId suId,
1128 RgmTransModeInd *transModeInd
1129 )
1130 {
1131    Buffer *mBuf = NULLP;
1132
1133
1134    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1135       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1136       return RFAILED;
1137    }
1138
1139    if(cmPkTransModeInd(transModeInd, mBuf) != ROK)
1140    {
1141       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1142       SPutMsg(mBuf);
1143       return RFAILED;
1144    }
1145
1146    if (SPkS16(suId, mBuf) != ROK) 
1147    {
1148       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1149       SPutMsg(mBuf);
1150       return RFAILED;
1151    }
1152
1153    SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1154
1155    pst->event = (Event) EVTRGMTRANSMODEIND;
1156    return (SPstTsk(pst,mBuf));
1157 }
1158 /**
1159 * @brief Transmission Mode Change Indication  from MAC to RRM 
1160 *
1161 * @details
1162 *
1163 *     Function : cmUnpkRgmTransModeInd
1164 *
1165 *  @param[in]   Pst*  pst
1166 *  @param[in]   SuId  suId
1167 *  @param[in]   RgmTransModeInd *transModeInd 
1168 *  @return   S16
1169 *      -# ROK
1170 **/
1171 S16 cmUnpkRgmTransModeInd
1172 (
1173 RgmTransModeIndFptr func,
1174 Pst *pst,
1175 Buffer *mBuf
1176 )
1177 {
1178    SuId suId;
1179    RgmTransModeInd transModeInd;
1180    
1181
1182    if (SUnpkS16(&suId, mBuf) != ROK) 
1183    {
1184       SPutMsg(mBuf);
1185       return RFAILED;
1186    }
1187
1188    if (cmUnpkTransModeInd(&transModeInd, mBuf) != ROK) 
1189    {
1190       SPutMsg(mBuf);
1191       return RFAILED;
1192    }
1193
1194    SPutMsg(mBuf);
1195    return ((*func)(pst, suId, &transModeInd));
1196 }
1197 /**********************************************************************
1198  
1199          End of file
1200  
1201 **********************************************************************/