Initial commit
[o-du/l2.git] / src / 5gnrmac / rg_sch_inf.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 packing/unpacking of INF interface
26                primitives.
27   
28      File:     rg_sch_inf.c 
29   
30 **********************************************************************/
31
32 /* header include files (.h) */
33 #include "envopt.h"        /* environment options */
34 #include "envdep.h"        /* environment dependent */
35 #include "envind.h"        /* environment independent */
36 #include "gen.h"           /* general */
37 #include "ssi.h"           /* system services */
38 #include "cm_tkns.h"       /* Common Token Defines */
39 #include "cm_llist.h"      /* Common Link List Defines */
40 #include "cm_hash.h"       /* Common Hash List Defines */
41 #include "cm_mblk.h"       /* memory management */
42 #include "cm_lte.h"        /* Common LTE Defines */
43 #include "tfu.h"           /* RGU defines */
44 #ifdef LTE_L2_MEAS
45 #include "lrg.h"
46 #endif
47 #include "rg_sch_inf.h"    /* RGU Interface defines */
48
49 /* header/extern include files (.x) */
50 #include "gen.x"           /* general */
51 #include "ssi.x"           /* system services */
52 #include "cm_tkns.x"       /* Common Token Definitions */
53 #include "cm_llist.x"      /* Common Link List Definitions */
54 #include "cm_lib.x"        /* Common Library Definitions */
55 #include "cm_hash.x"       /* Common Hash List Definitions */
56 #include "cm_mblk.x"       /* memory management */
57 #include "cm_lte.x"        /* Common LTE Defines */
58 #include "tfu.x"           /* RGU defines */
59 #ifdef LTE_L2_MEAS
60 #include "lrg.x"
61 #endif
62 #include "rg_sch_inf.x"    /* RGU Interface includes */
63
64 #ifdef LCSCH
65 /*Fix: start: Inform UE delete to scheduler*/
66 /**
67 * @brief This primitive is used to indicate to scheduler
68 *        that UE has been deleted at MAC.
69 *
70 * @details
71 *
72 *     Function : cmPkMacSchUeDelInd
73 *
74 *  @param[in]   Pst*  pst
75 *  @param[in]   RgInfUeDelInd*  ueDelInd
76 *  @return   S16
77 *      -# ROK
78 **/
79 #ifdef ANSI
80 PUBLIC S16 cmPkMacSchUeDelInd
81 (
82 Pst* pst,
83 RgInfUeDelInd*  ueDelInd
84 )
85 #else
86 PUBLIC S16 cmPkMacSchUeDelInd(pst, ueDelInd)
87 Pst* pst;
88 RgInfUeDelInd*  ueDelInd;
89 #endif
90 {
91    Buffer *mBuf = NULLP;
92    TRC2(cmPkMacSchUeDelInd)
93
94    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) 
95    {
96       RETVALUE(RFAILED);
97    }
98    
99 #ifdef MS_MBUF_CORRUPTION 
100    MS_BUF_ADD_ALLOC_CALLER();
101 #endif 
102    if(SAddPstMsgMult((Data *)ueDelInd, sizeof(RgInfUeDelInd), mBuf) != ROK)
103    {
104       RGSCHINF_FREE_MSG(mBuf);
105       RETVALUE(RFAILED);
106    }
107
108    pst->event = (Event) EVTINFUEDELIND;
109    RETVALUE(SPstTsk(pst,mBuf));
110 }
111
112 /**
113 * @brief This primitive is used to indicate to scheduler
114 *        that UE has been deleted at MAC.
115 *
116 *
117 * @details
118 *
119 *     Function : cmUnpkMacSchUeDelInd
120 *
121 *  @param[in]   Pst*  pst
122 *  @param[in]   SpId  spId
123 *  @param[in]   RguDDatReqInfo  *  datReq
124 *  @return   S16
125 *      -# ROK
126 **/
127 #ifdef ANSI
128 PUBLIC S16 cmUnpkMacSchUeDelInd
129 (
130 UeDelInd func,
131 Pst *pst,
132 Buffer *mBuf
133 )
134 #else
135 PUBLIC S16 cmUnpkMacSchUeDelInd(func, pst, mBuf)
136 UeDelInd func;
137 Pst *pst;
138 Buffer *mBuf;
139 #endif
140 {
141    RgInfUeDelInd ueDelInd;
142    
143    TRC2(cmUnpkMacSchUeDelInd)
144
145    if(SRemPreMsgMult((Data *)&ueDelInd, sizeof(RgInfUeDelInd), mBuf) != ROK)
146    {
147       RGSCHINF_FREE_MSG(mBuf);
148       RETVALUE(RFAILED);
149    }
150
151    RGSCHINF_FREE_MSG(mBuf);
152
153    RETVALUE((*func)(pst, &ueDelInd));
154 }
155 /*Fix: end: Inform UE delete to scheduler*/
156
157 /**
158 * @brief Request from RLC to MAC for forwarding SDUs on 
159  * dedicated channel for transmission.
160 *
161 * @details
162 *
163 *     Function : cmPkMacSchDedBoUpdtReq
164 *
165 *  @param[in]   Pst*  pst
166 *  @param[in]   SpId  spId
167 *  @param[in]   RguDDatReqInfo  *  datReq
168 *  @return   S16
169 *      -# ROK
170 **/
171 #ifdef ANSI
172 PUBLIC S16 cmPkMacSchDedBoUpdtReq
173 (
174 Pst* pst,
175 RgInfDedBoRpt* boRpt
176 )
177 #else
178 PUBLIC S16 cmPkMacSchDedBoUpdtReq(pst, boRpt)
179 Pst* pst;
180 RgInfDedBoRpt* boRpt;
181 #endif
182 {
183    Buffer *mBuf = NULLP;
184    TRC2(cmPkMacSchDedBoUpdtReq)
185
186    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
187       RETVALUE(RFAILED);
188    }
189
190 #ifdef MS_MBUF_CORRUPTION 
191    MS_BUF_ADD_ALLOC_CALLER();
192 #endif 
193    if(SAddPstMsgMult((Data *)boRpt, sizeof(RgInfDedBoRpt), mBuf) != ROK)
194    {
195       RGSCHINF_FREE_MSG(mBuf);
196       RETVALUE(RFAILED);
197    }
198
199    pst->event = (Event) EVTINFDEDBOUPDTREQ;
200    RETVALUE(SPstTsk(pst,mBuf));
201 }
202
203
204 /**
205 * @brief Request from RLC to MAC for forwarding SDUs on 
206  * dedicated channel for transmission.
207 *
208 * @details
209 *
210 *     Function : cmUnpkMacSchDedBoUpdtReq
211 *
212 *  @param[in]   Pst*  pst
213 *  @param[in]   SpId  spId
214 *  @param[in]   RguDDatReqInfo  *  datReq
215 *  @return   S16
216 *      -# ROK
217 **/
218 #ifdef ANSI
219 PUBLIC S16 cmUnpkMacSchDedBoUpdtReq
220 (
221 DedBoUpdtReq func,
222 Pst *pst,
223 Buffer *mBuf
224 )
225 #else
226 PUBLIC S16 cmUnpkMacSchDedBoUpdtReq(func, pst, mBuf)
227 DedBoUpdtReq func;
228 Pst *pst;
229 Buffer *mBuf;
230 #endif
231 {
232    RgInfDedBoRpt boRpt;
233    
234    TRC2(cmUnpkMacSchDedBoUpdtReq)
235
236    if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfDedBoRpt), mBuf) != ROK)
237    {
238       RGSCHINF_FREE_MSG(mBuf);
239       RETVALUE(RFAILED);
240    }
241
242    RGSCHINF_FREE_MSG(mBuf);
243    RETVALUE((*func)(pst, &boRpt));
244 }
245 /**
246 * @brief Request from RLC to MAC for forwarding SDUs on 
247  * dedicated channel for transmission.
248 *
249 * @details
250 *
251 *     Function : cmPkMacSchCmnBoUpdtReq
252 *
253 *  @param[in]   Pst*  pst
254 *  @param[in]   SpId  spId
255 *  @param[in]   RguDDatReqInfo  *  datReq
256 *  @return   S16
257 *      -# ROK
258 **/
259 #ifdef ANSI
260 PUBLIC S16 cmPkMacSchCmnBoUpdtReq
261 (
262 Pst* pst,
263 RgInfCmnBoRpt* boRpt
264 )
265 #else
266 PUBLIC S16 cmPkMacSchCmnBoUpdtReq(pst, boRpt)
267 Pst* pst;
268 RgInfCmnBoRpt* boRpt;
269 #endif
270 {
271    Buffer *mBuf = NULLP;
272    TRC2(cmPkMacSchCmnBoUpdtReq)
273
274    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
275       RETVALUE(RFAILED);
276    }
277
278 #ifdef MS_MBUF_CORRUPTION 
279    MS_BUF_ADD_ALLOC_CALLER();
280 #endif 
281    if(SAddPstMsgMult((Data *)boRpt, sizeof(RgInfCmnBoRpt), mBuf) != ROK)
282    {
283       RGSCHINF_FREE_MSG(mBuf);
284       RETVALUE(RFAILED);
285    }
286
287    pst->event = (Event) EVTINFCMNBOUPDTREQ;
288    RETVALUE(SPstTsk(pst,mBuf));
289 }
290
291
292 /**
293 * @brief Request from RLC to MAC for forwarding SDUs on 
294  * dedicated channel for transmission.
295 *
296 * @details
297 *
298 *     Function : cmUnpkMacSchCmnBoUpdtReq
299 *
300 *  @param[in]   Pst*  pst
301 *  @param[in]   SpId  spId
302 *  @param[in]   RguDDatReqInfo  *  datReq
303 *  @return   S16
304 *      -# ROK
305 **/
306 #ifdef ANSI
307 PUBLIC S16 cmUnpkMacSchCmnBoUpdtReq
308 (
309 CmnBoUpdtReq func,
310 Pst *pst,
311 Buffer *mBuf
312 )
313 #else
314 PUBLIC S16 cmUnpkMacSchCmnBoUpdtReq(func, pst, mBuf)
315 CmnBoUpdtReq func;
316 Pst *pst;
317 Buffer *mBuf;
318 #endif
319 {
320    RgInfCmnBoRpt boRpt;
321    
322    TRC2(cmUnpkMacSchCmnBoUpdtReq)
323
324    if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfCmnBoRpt), mBuf) != ROK)
325    {
326       RGSCHINF_FREE_MSG(mBuf);
327       RETVALUE(RFAILED);
328    }
329
330    RGSCHINF_FREE_MSG(mBuf);
331    RETVALUE((*func)(pst, &boRpt));
332 }
333 /**
334 * @brief Request from RLC to MAC for forwarding SDUs on 
335  * dedicated channel for transmission.
336 *
337 * @details
338 *
339 *     Function : cmPkMacSchSfRecpInd
340 *
341 *  @param[in]   Pst*  pst
342 *  @param[in]   SpId  spId
343 *  @param[in]   RguDDatReqInfo  *  datReq
344 *  @return   S16
345 *      -# ROK
346 **/
347 #ifdef ANSI
348 PUBLIC S16 cmPkMacSchSfRecpInd
349 (
350 Pst* pst,
351 RgInfSfDatInd*  datInd
352 )
353 #else
354 PUBLIC S16 cmPkMacSchSfRecpInd(pst, datInd)
355 Pst* pst;
356 RgInfSfDatInd*  datInd;
357 #endif
358 {
359    Buffer *mBuf = NULLP;
360    TRC2(cmPkMacSchSfRecpInd)
361
362    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
363       RETVALUE(RFAILED);
364    }
365
366    if(cmPkPtr((PTR)datInd, mBuf) != ROK)
367    {
368       RGSCHINF_FREE_MSG(mBuf);
369       RETVALUE(RFAILED);
370    }
371
372    pst->event = (Event) EVTINFSFRECPIND;
373    RETVALUE(SPstTsk(pst,mBuf));
374 }
375
376
377 /**
378 * @brief Request from RLC to MAC for forwarding SDUs on 
379  * dedicated channel for transmission.
380 *
381 * @details
382 *
383 *     Function : cmUnpkMacSchSfRecpInd
384 *
385 *  @param[in]   Pst*  pst
386 *  @param[in]   SpId  spId
387 *  @param[in]   RguDDatReqInfo  *  datReq
388 *  @return   S16
389 *      -# ROK
390 **/
391 #ifdef ANSI
392 PUBLIC S16 cmUnpkMacSchSfRecpInd
393 (
394 SfRecpInd func,
395 Pst *pst,
396 Buffer *mBuf
397 )
398 #else
399 PUBLIC S16 cmUnpkMacSchSfRecpInd(func, pst, mBuf)
400 SfRecpInd func;
401 Pst *pst;
402 Buffer *mBuf;
403 #endif
404 {
405    RgInfSfDatInd* datInd;
406    
407    TRC2(cmUnpkMacSchCmnBoUpdtReq)
408
409    if(cmUnpkPtr((PTR *)&datInd, mBuf) != ROK)
410    {
411       RGSCHINF_FREE_MSG(mBuf);
412       RETVALUE(RFAILED);
413    }
414
415    RGSCHINF_FREE_MSG(mBuf);
416    /* Call cmFreeMem(datInd) in scheduler */
417    RETVALUE((*func)(pst, datInd));
418 }
419
420 #ifdef LTEMAC_SPS
421 /**
422 * @brief Primitive from MAC to SCH to indicate release of UL SPS for a UE
423 *
424 * @details
425 *
426 *     Function : cmPkMacSchSpsRelInd
427 *
428 *  @param[in]   Pst*                 pst
429 *  @param[in]   RgInfSpsRelInfo*     relInfo
430 *  @return   S16
431 *      -# ROK
432 **/
433 #ifdef ANSI
434 PUBLIC S16 cmPkMacSchSpsRelInd
435 (
436 Pst*                 pst,
437 RgInfSpsRelInfo*     relInfo
438 )
439 #else
440 PUBLIC S16 cmPkMacSchSpsRelInd(pst, relInfo)
441 Pst*                 pst;
442 RgInfSpsRelInfo*     relInfo;
443 #endif
444 {
445    Buffer *mBuf = NULLP;
446
447    TRC2(cmPkMacSchSpsRelInd)
448
449    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
450       RETVALUE(RFAILED);
451    }
452
453    if(cmPkPtr((PTR)relInfo, mBuf) != ROK)
454    {
455       RGSCHINF_FREE_MSG(mBuf);
456       RETVALUE(RFAILED);
457    }
458
459    pst->event = (Event) EVTINFSPSRELIND;
460    RETVALUE(SPstTsk(pst,mBuf));
461 } /* end of cmPkMacSchSpsRelInd */
462
463 /**
464 * @brief Primitive from MAC to SCH to indicate release of UL SPS for a UE
465 *
466 * @details
467 *
468 *     Function : cmUnpkMacSchSpsRelInd
469 *
470 *  @param[in]    SpsRelInd            func
471 *  @param[in]    Pst*                 pst
472 *  @param[in]    Buffer               *mBuf
473 *  @return   S16
474 *      -# ROK
475 **/
476 #ifdef ANSI
477 PUBLIC S16 cmUnpkMacSchSpsRelInd
478 (
479 SpsRelInd      func,
480 Pst            *pst,
481 Buffer         *mBuf
482 )
483 #else
484 PUBLIC S16 cmUnpkMacSchSpsRelInd(func, pst, mBuf)
485 SpsRelInd      func;
486 Pst            *pst;
487 Buffer         *mBuf;
488 #endif
489 {
490    RgInfSpsRelInfo *relInfo;
491    
492    TRC2(cmUnpkMacSchSpsRelInd)
493
494    if(cmUnpkPtr((PTR *)&relInfo, mBuf) != ROK)
495    {
496       RGSCHINF_FREE_MSG(mBuf);
497       RETVALUE(RFAILED);
498    }
499
500    RGSCHINF_FREE_MSG(mBuf);
501    RETVALUE((*func)(pst, relInfo));
502 } /* end of cmUnpkMacSchSpsRelInd */
503 #endif /* LTEMAC_SPS */
504
505 #endif
506 #ifdef LCRG
507 /**
508 * @brief Request from RLC to MAC for forwarding SDUs on 
509  * dedicated channel for transmission.
510 *
511 * @details
512 *
513 *     Function : cmPkSchMacSfAllocReq
514 *
515 *  @param[in]   Pst*  pst
516 *  @param[in]   SpId  spId
517 *  @param[in]   RguDDatReqInfo  *  datReq
518 *  @return   S16
519 *      -# ROK
520 **/
521 #ifdef ANSI
522 PUBLIC S16 cmPkSchMacSfAllocReq
523 (
524 Pst* pst,
525 RgInfSfAlloc*   resAllocReq
526 )
527 #else
528 PUBLIC S16 cmPkSchMacSfAllocReq(pst, resAllocReq)
529 Pst* pst;
530 RgInfSfAlloc*   resAllocReq;
531 #endif
532 {
533    Buffer *mBuf = NULLP;
534    TRC2(cmPkSchMacSfAllocReq)
535
536    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
537       RETVALUE(RFAILED);
538    }
539
540    if(cmPkPtr((PTR)resAllocReq, mBuf) != ROK)
541    {
542       RGSCHINF_FREE_MSG(mBuf);
543       RETVALUE(RFAILED);
544    }
545
546    pst->event = (Event) EVTINFSFALLOCREQ;
547    RETVALUE(SPstTsk(pst,mBuf));
548 }
549
550
551 /**
552 * @brief Request from RLC to MAC for forwarding SDUs on 
553  * dedicated channel for transmission.
554 *
555 * @details
556 *
557 *     Function : cmUnpkSchMacSfAllocReq
558 *
559 *  @param[in]   Pst*  pst
560 *  @param[in]   SpId  spId
561 *  @param[in]   RguDDatReqInfo  *  datReq
562 *  @return   S16
563 *      -# ROK
564 **/
565 #ifdef ANSI
566 PUBLIC S16 cmUnpkSchMacSfAllocReq
567 (
568 SfAllocReq func,
569 Pst *pst,
570 Buffer *mBuf
571 )
572 #else
573 PUBLIC S16 cmUnpkSchMacSfAllocReq(func, pst, mBuf)
574 SfAllocReq func;
575 Pst *pst;
576 Buffer *mBuf;
577 #endif
578 {
579    RgInfSfAlloc* resAllocReq;
580    
581    TRC2(cmUnpkSchMacSfAllocReq)
582
583    if(cmUnpkPtr((PTR *)&resAllocReq, mBuf) != ROK)
584    {
585       RGSCHINF_FREE_MSG(mBuf);
586       RETVALUE(RFAILED);
587    }
588
589    RGSCHINF_FREE_MSG(mBuf);
590    RETVALUE((*func)(pst, resAllocReq));
591 }
592 /**
593 * @brief Request from  SCH To MAC for harq entity reset
594 *
595 * @details
596 *
597 *     Function : cmPkSchMacRstHqEntReq
598 *
599 *  @param[in]   Pst*  pst
600 *  @param[in]   RgInfResetHqEnt *hqEntInfo
601 *  @return   S16
602 *      -# ROK
603 **/
604 #ifdef ANSI
605 PUBLIC S16 cmPkSchMacRstHqEntReq
606 (
607 Pst*                 pst,
608 RgInfResetHqEnt*     hqEntInfo
609 )
610 #else
611 PUBLIC S16 cmPkSchMacRstHqEntReq(pst, sfHqInfo)
612 Pst*                 pst,    
613 RgInfResetHqEnt*     hqEntInfo
614 #endif
615 {
616    Buffer *mBuf = NULLP;
617    TRC2(cmPkSchMacRstHqEntReq)
618
619    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
620       RETVALUE(RFAILED);
621    }
622
623    if(cmPkPtr((PTR)hqEntInfo, mBuf) != ROK)
624    {
625       RGSCHINF_FREE_MSG(mBuf);
626       RETVALUE(RFAILED);
627    }
628
629    pst->event = (Event) EVTINFHQENTRESET;
630    RETVALUE(SPstTsk(pst,mBuf));
631 }
632
633 /**
634 * @brief Request from SCH to MAC for resetting the harqentity
635 *
636 * @details
637 *
638 *     Function : cmUnpkSchMacRstHqEntReq
639 *
640 *  @param[in]   Pst*  pst
641 *  @param[in]   RgInfResetHqEnt *hqEntInfo
642 *  @return   S16
643 *      -# ROK
644 **/
645 #ifdef ANSI
646 PUBLIC S16 cmUnpkSchMacRstHqEntReq
647 (
648 RstHqEntReq func,
649 Pst *pst,
650 Buffer *mBuf
651 )
652 #else
653 PUBLIC S16 cmUnpkSchMacRstHqEntReq(func, pst, mBuf)
654 RstHqEntReq func,
655 Pst *pst,
656 Buffer *mBuf
657 #endif
658 {
659    RgInfResetHqEnt* hqEntRstInfo;
660    
661    TRC2(cmUnpkSchMacRstHqEntReq)
662
663    if(cmUnpkPtr((PTR *)&hqEntRstInfo, mBuf) != ROK)
664    {
665       RGSCHINF_FREE_MSG(mBuf);
666       RETVALUE(RFAILED);
667    }
668
669    RGSCHINF_FREE_MSG(mBuf);
670    RETVALUE((*func)(pst, hqEntRstInfo));
671 }
672
673 /**
674 * @brief Request from RLC to MAC for forwarding SDUs on 
675  * dedicated channel for transmission.
676 *
677 * @details
678 *
679 *     Function : cmPkSchMacRlsHqReq
680 *
681 *  @param[in]   Pst*  pst
682 *  @param[in]   SpId  spId
683 *  @param[in]   RguDDatReqInfo  *  datReq
684 *  @return   S16
685 *      -# ROK
686 **/
687 #ifdef ANSI
688 PUBLIC S16 cmPkSchMacRlsHqReq
689 (
690 Pst* pst,
691 RgInfRlsHqInfo* sfHqInfo
692 )
693 #else
694 PUBLIC S16 cmPkSchMacRlsHqReq(pst, sfHqInfo)
695 Pst* pst;
696 RgInfRlsHqInfo* sfHqInfo;
697 #endif
698 {
699    Buffer *mBuf = NULLP;
700    TRC2(cmPkSchMacRlsHqReq)
701
702    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
703       RETVALUE(RFAILED);
704    }
705
706    if(cmPkPtr((PTR)sfHqInfo, mBuf) != ROK)
707    {
708       RGSCHINF_FREE_MSG(mBuf);
709       RETVALUE(RFAILED);
710    }
711
712    pst->event = (Event) EVTINFRLSHQREQ;
713    RETVALUE(SPstTsk(pst,mBuf));
714 }
715
716 /**
717 * @brief Request from RLC to MAC for forwarding SDUs on 
718  * dedicated channel for transmission.
719 *
720 * @details
721 *
722 *     Function : cmUnpkSchMacRlsHqReq
723 *
724 *  @param[in]   Pst*  pst
725 *  @param[in]   SpId  spId
726 *  @param[in]   RguDDatReqInfo  *  datReq
727 *  @return   S16
728 *      -# ROK
729 **/
730 #ifdef ANSI
731 PUBLIC S16 cmUnpkSchMacRlsHqReq
732 (
733 RlsHqReq func,
734 Pst *pst,
735 Buffer *mBuf
736 )
737 #else
738 PUBLIC S16 cmUnpkSchMacRlsHqReq(func, pst, mBuf)
739 RlsHqReq func;
740 Pst *pst;
741 Buffer *mBuf;
742 #endif
743 {
744    RgInfRlsHqInfo* sfHqInfo;
745    
746    TRC2(cmUnpkSchMacRlsHqReq)
747
748    if(cmUnpkPtr((PTR *)&sfHqInfo, mBuf) != ROK)
749    {
750       RGSCHINF_FREE_MSG(mBuf);
751       RETVALUE(RFAILED);
752    }
753
754    RGSCHINF_FREE_MSG(mBuf);
755    RETVALUE((*func)(pst, sfHqInfo));
756 }
757 /**
758 * @brief Request from RLC to MAC for forwarding SDUs on 
759  * dedicated channel for transmission.
760 *
761 * @details
762 *
763 *     Function : cmPkSchMacRlsRntiReq
764 *
765 *  @param[in]   Pst*  pst
766 *  @param[in]   SpId  spId
767 *  @param[in]   RguDDatReqInfo  *  datReq
768 *  @return   S16
769 *      -# ROK
770 **/
771 #ifdef ANSI
772 PUBLIC S16 cmPkSchMacRlsRntiReq
773 (
774 Pst* pst,
775 RgInfRlsRnti* rlsRnti
776 )
777 #else
778 PUBLIC S16 cmPkSchMacRlsRntiReq(pst, rlsRnti)
779 Pst* pst;
780 RgInfRlsRnti* rlsRnti;
781 #endif
782 {
783    Buffer *mBuf = NULLP;
784    TRC2(cmPkSchMacRlsRntiReq)
785
786    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
787       RETVALUE(RFAILED);
788    }
789
790 #ifdef MS_MBUF_CORRUPTION 
791    MS_BUF_ADD_ALLOC_CALLER();
792 #endif 
793    if(SAddPstMsgMult((Data *)rlsRnti, sizeof(RgInfRlsRnti), mBuf) != ROK)
794    {
795       RGSCHINF_FREE_MSG(mBuf);
796       RETVALUE(RFAILED);
797    }
798
799    pst->event = (Event) EVTINFRLSRNTIREQ;
800    RETVALUE(SPstTsk(pst,mBuf));
801 }
802
803 /**
804 * @brief Request from RLC to MAC for forwarding SDUs on 
805  * dedicated channel for transmission.
806 *
807 * @details
808 *
809 *     Function : cmUnpkSchMacRlsRntiReq
810 *
811 *  @param[in]   Pst*  pst
812 *  @param[in]   SpId  spId
813 *  @param[in]   RguDDatReqInfo  *  datReq
814 *  @return   S16
815 *      -# ROK
816 **/
817 #ifdef ANSI
818 PUBLIC S16 cmUnpkSchMacRlsRntiReq
819 (
820 RlsRntiReq func,
821 Pst *pst,
822 Buffer *mBuf
823 )
824 #else
825 PUBLIC S16 cmUnpkSchMacRlsRntiReq(func, pst, mBuf)
826 RlsRntiReq func;
827 Pst *pst;
828 Buffer *mBuf;
829 #endif
830 {
831    RgInfRlsRnti rlsRnti;
832    
833    TRC2(cmUnpkSchMacRlsRntiReq)
834
835    if(SRemPreMsgMult((Data *)&rlsRnti, sizeof(RgInfRlsRnti), mBuf) != ROK)
836    {
837       RGSCHINF_FREE_MSG(mBuf);
838       RETVALUE(RFAILED);
839    }
840
841    RGSCHINF_FREE_MSG(mBuf);
842    RETVALUE((*func)(pst, &rlsRnti));
843 }
844
845 /**
846 * @brief Request from RLC to MAC for forwarding SDUs on 
847  * dedicated channel for transmission.
848 *
849 * @details
850 *
851 *     Function : cmPkSchMacCellRegReq
852 *
853 *  @param[in]   Pst*  pst
854 *  @param[in]   SpId  spId
855 *  @param[in]   RguDDatReqInfo  *  datReq
856 *  @return   S16
857 *      -# ROK
858 **/
859 #ifdef ANSI
860 PUBLIC S16 cmPkSchMacCellRegReq
861 (
862 Pst* pst,
863 RgInfCellReg* regReq
864 )
865 #else
866 PUBLIC S16 cmPkSchMacCellRegReq(pst, regReq)
867 Pst* pst;
868 RgInfCellReg* regReq;
869 #endif
870 {
871    Buffer *mBuf = NULLP;
872    TRC2(cmPkSchMacCellRegReq)
873
874    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
875       RETVALUE(RFAILED);
876    }
877
878 #ifdef MS_MBUF_CORRUPTION 
879    MS_BUF_ADD_ALLOC_CALLER();
880 #endif 
881    if(SAddPstMsgMult((Data *)regReq, sizeof(RgInfCellReg), mBuf) != ROK)
882    {
883       RGSCHINF_FREE_MSG(mBuf);
884       RETVALUE(RFAILED);
885    }
886
887    pst->event = (Event) EVTINFCELLREGREQ;
888    RETVALUE(SPstTsk(pst,mBuf));
889 }
890
891 /**
892 * @brief Request from RLC to MAC for forwarding SDUs on 
893  * dedicated channel for transmission.
894 *
895 * @details
896 *
897 *     Function : cmUnpkSchMacCellRegReq
898 *
899 *  @param[in]   Pst*  pst
900 *  @param[in]   SpId  spId
901 *  @param[in]   RguDDatReqInfo  *  datReq
902 *  @return   S16
903 *      -# ROK
904 **/
905 #ifdef ANSI
906 PUBLIC S16 cmUnpkSchMacCellRegReq
907 (
908 CellRegReq func,
909 Pst *pst,
910 Buffer *mBuf
911 )
912 #else
913 PUBLIC S16 cmUnpkSchMacCellRegReq(func, pst, mBuf)
914 CellRegReq func;
915 Pst *pst;
916 Buffer *mBuf;
917 #endif
918 {
919    RgInfCellReg regReq;
920    
921    TRC2(cmUnpkSchMacCellRegReq)
922
923    if(SRemPreMsgMult((Data *)&regReq, sizeof(RgInfCellReg), mBuf) != ROK)
924    {
925       RGSCHINF_FREE_MSG(mBuf);
926       RETVALUE(RFAILED);
927    }
928
929    RGSCHINF_FREE_MSG(mBuf);
930    RETVALUE((*func)(pst, &regReq));
931 }
932
933 /**
934 * @brief Primitive from SCH to MAC to register GBR LCG per UE
935 *
936 * @details
937 *
938 *     Function : cmPkSchMacLcgRegReq
939 *
940 *  @param[in]   Pst*                 pst
941 *  @param[in]   RgInfLcgRegReq       *lcgRegReq
942 *  @return   S16
943 *      -# ROK
944 **/
945 #ifdef ANSI
946 PUBLIC S16 cmPkSchMacLcgRegReq
947 (
948 Pst*                 pst,
949 RgInfLcgRegReq       *lcgRegReq
950 )
951 #else
952 PUBLIC S16 cmPkSchMacLcgRegReq(pst, lcgRegReq)
953 Pst*                 pst;
954 RgInfLcgRegReq       *lcgRegReq;
955 #endif
956 {
957    Buffer *mBuf = NULLP;
958
959    TRC2(cmPkSchMacLcgRegReq)
960
961    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
962       RETVALUE(RFAILED);
963    }
964
965    if(SAddPstMsgMult((Data *)lcgRegReq, sizeof(RgInfLcgRegReq), mBuf) != ROK)
966    {
967       RGSCHINF_FREE_MSG(mBuf);
968       RETVALUE(RFAILED);
969    }
970
971    pst->event = (Event) EVTINFLCGREG;
972    RETVALUE(SPstTsk(pst,mBuf));
973 } /* end of cmPkSchMacLcgRegReq */
974
975 /**
976 * @brief Primitive from SCH to MAC to register GBR LCG
977 *
978 * @details
979 *
980 *     Function : cmUnpkSchMacLcgRegReq
981 *
982 *  @param[in]    LcgReg               func
983 *  @param[in]    Pst*                 pst
984 *  @param[in]    Buffer               *mBuf
985 *  @return   S16
986 *      -# ROK
987 **/
988 #ifdef ANSI
989 PUBLIC S16 cmUnpkSchMacLcgRegReq
990 (
991 LcgReg         func,
992 Pst            *pst,
993 Buffer         *mBuf
994 )
995 #else
996 PUBLIC S16 cmUnpkSchMacLcgRegReq(func, pst, mBuf)
997 LcgReg         func;
998 Pst            *pst;
999 Buffer         *mBuf;
1000 #endif
1001 {
1002    RgInfLcgRegReq       *lcgRegReq;
1003    
1004    TRC2(cmUnpkSchMacLcgRegReq)
1005
1006    if(cmUnpkPtr((PTR *)&lcgRegReq, mBuf) != ROK)
1007    {
1008       RGSCHINF_FREE_MSG(mBuf);
1009       RETVALUE(RFAILED);
1010    }
1011
1012    RGSCHINF_FREE_MSG(mBuf);
1013    RETVALUE((*func)(pst, lcgRegReq));
1014 } /* end of cmUnpkSchMacLcgRegReq */
1015
1016 #ifdef LTEMAC_SPS
1017
1018 /**
1019 * @brief Primitive from SCH to MAC to register the set of SPS LCs per UE
1020 *
1021 * @details
1022 *
1023 *     Function : cmPkSchMacSpsLcRegReq
1024 *
1025 *  @param[in]   Pst*                 pst
1026 *  @param[in]   RgInfSpsLcInfo       *lcInfo
1027 *  @return   S16
1028 *      -# ROK
1029 **/
1030 #ifdef ANSI
1031 PUBLIC S16 cmPkSchMacSpsLcRegReq
1032 (
1033 Pst*                 pst,
1034 RgInfSpsLcInfo       *lcInfo
1035 )
1036 #else
1037 PUBLIC S16 cmPkSchMacSpsLcRegReq(pst, lcInfo)
1038 Pst*                 pst;
1039 RgInfSpsLcInfo       *lcInfo;
1040 #endif
1041 {
1042    Buffer *mBuf = NULLP;
1043
1044    TRC2(cmPkSchMacSpsLcRegReq)
1045
1046    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1047       RETVALUE(RFAILED);
1048    }
1049
1050    if(cmPkPtr((PTR)lcInfo, mBuf) != ROK)
1051    {
1052       RGSCHINF_FREE_MSG(mBuf);
1053       RETVALUE(RFAILED);
1054    }
1055
1056    pst->event = (Event) EVTINFSPSLCREG;
1057    RETVALUE(SPstTsk(pst,mBuf));
1058 } /* end of cmPkSchMacSpsLcRegReq */
1059
1060 /**
1061 * @brief Primitive from SCH to MAC to reset SPS Params for the UE
1062 *
1063 * @details
1064 *
1065 *     Function : cmPkSchMacUlSpsResetReq
1066 *
1067 *  @param[in]   Pst*                 pst
1068 *  @param[in]   RgInfUlSpsReset       *ulSpsResetInfo
1069 *  @return   S16
1070 *      -# ROK
1071 **/
1072 #ifdef ANSI
1073 PUBLIC S16 cmPkSchMacUlSpsResetReq
1074 (
1075 Pst*                 pst,
1076 RgInfUlSpsReset      *ulSpsResetInfo
1077 )
1078 #else
1079 PUBLIC S16 cmPkSchMacUlSpsResetReq(pst, ulSpsResetInfo)
1080 Pst*                 pst;
1081 RgInfUlSpsReset       *ulSpsResetInfo;
1082 #endif
1083 {
1084    Buffer *mBuf = NULLP;
1085
1086    TRC2(cmPkSchMacUlSpsResetReq)
1087
1088    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1089       RETVALUE(RFAILED);
1090    }
1091
1092    if(cmPkPtr((PTR)ulSpsResetInfo, mBuf) != ROK)
1093    {
1094       RGSCHINF_FREE_MSG(mBuf);
1095       RETVALUE(RFAILED);
1096    }
1097
1098    pst->event = (Event) EVTINFSPSRESET;
1099    RETVALUE(SPstTsk(pst,mBuf));
1100 } /* end of cmPkSchMacUlSpsResetReq */
1101
1102 /**
1103 * @brief Primitive from SCH to MAC to register the set of SPS LCs per UE
1104 *
1105 * @details
1106 *
1107 *     Function : cmUnpkSchMacSpsLcRegReq
1108 *
1109 *  @param[in]    SpsLcReg             func
1110 *  @param[in]    Pst*                 pst
1111 *  @param[in]    Buffer               *mBuf
1112 *  @return   S16
1113 *      -# ROK
1114 **/
1115 #ifdef ANSI
1116 PUBLIC S16 cmUnpkSchMacSpsLcRegReq
1117 (
1118 SpsLcReg       func,
1119 Pst            *pst,
1120 Buffer         *mBuf
1121 )
1122 #else
1123 PUBLIC S16 cmUnpkSchMacSpsLcRegReq(func, pst, mBuf)
1124 SpsLcReg       func;
1125 Pst            *pst;
1126 Buffer         *mBuf;
1127 #endif
1128 {
1129    RgInfSpsLcInfo       *lcInfo;
1130    
1131    TRC2(cmUnpkSchMacSpsLcRegReq)
1132
1133    if(cmUnpkPtr((PTR *)&lcInfo, mBuf) != ROK)
1134    {
1135       RGSCHINF_FREE_MSG(mBuf);
1136       RETVALUE(RFAILED);
1137    }
1138
1139    RGSCHINF_FREE_MSG(mBuf);
1140    RETVALUE((*func)(pst, lcInfo));
1141 } /* end of cmUnpkSchMacSpsLcRegReq */
1142
1143
1144
1145 /**
1146 * @brief Primitive from SCH to MAC to reset UL SPS params
1147 *
1148 * @details
1149 *
1150 *     Function : cmUnpkSchMacUlSpsResetReq
1151 *
1152 *  @param[in]    UlSpsReset             func
1153 *  @param[in]    Pst*                 pst
1154 *  @param[in]    Buffer               *mBuf
1155 *  @return   S16
1156 *      -# ROK
1157 **/
1158 #ifdef ANSI
1159 PUBLIC S16 cmUnpkSchMacUlSpsResetReq
1160 (
1161 UlSpsReset       func,
1162 Pst            *pst,
1163 Buffer         *mBuf
1164 )
1165 #else
1166 PUBLIC S16 cmUnpkSchMacUlSpsResetReq(func, pst, mBuf)
1167 UlSpsReset       func;
1168 Pst            *pst;
1169 Buffer         *mBuf;
1170 #endif
1171 {
1172    RgInfUlSpsReset       *ulSpsResetInfo;
1173    
1174    TRC2(cmUnpkSchMacUlSpsResetReq)
1175
1176    if(cmUnpkPtr((PTR *)&ulSpsResetInfo, mBuf) != ROK)
1177    {
1178       RGSCHINF_FREE_MSG(mBuf);
1179       RETVALUE(RFAILED);
1180    }
1181
1182    RGSCHINF_FREE_MSG(mBuf);
1183    RETVALUE((*func)(pst, ulSpsResetInfo));
1184 } /* end of cmUnpkSchMacUlSpsResetReq */
1185
1186
1187
1188 /**
1189 * @brief Primitive from SCH to MAC to deregister the set of SPS LCs per UE
1190 *
1191 * @details
1192 *
1193 *     Function : cmPkSchMacSpsLcDeregReq
1194 *
1195 *  @param[in]   Pst*                 pst
1196 *  @param[in]   CmLteCellId          cellId,
1197 *  @param[in]   CmLteRnti            crnti
1198 *  @return   S16
1199 *      -# ROK
1200 **/
1201 #ifdef ANSI
1202 PUBLIC S16 cmPkSchMacSpsLcDeregReq
1203 (
1204 Pst*                 pst,
1205 CmLteCellId          cellId,
1206 CmLteRnti            crnti
1207 )
1208 #else
1209 PUBLIC S16 cmPkSchMacSpsLcDeregReq(pst, cellId, crnti)
1210 Pst*                 pst;
1211 CmLteCellId          cellId;
1212 CmLteRnti            crnti;
1213 #endif
1214 {
1215    Buffer *mBuf = NULLP;
1216
1217    TRC2(cmPkSchMacSpsLcDeregReq)
1218
1219    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1220       RETVALUE(RFAILED);
1221    }
1222
1223    CMCHKPK(cmPkLteCellId, cellId, mBuf);
1224    CMCHKPK(cmPkLteRnti, crnti, mBuf);
1225
1226    pst->event = (Event) EVTINFSPSLCDEREG;
1227    RETVALUE(SPstTsk(pst,mBuf));
1228 } /* end of cmPkSchMacSpsLcDeregReq */
1229
1230 /**
1231 * @brief Primitive from SCH to MAC to deregister the set of SPS LCs per UE
1232 *
1233 * @details
1234 *
1235 *     Function : cmUnpkSchMacSpsLcDeregReq
1236 *
1237 *  @param[in]    SpsLcDereg           func
1238 *  @param[in]    Pst*                 pst
1239 *  @param[in]    Buffer               *mBuf
1240 *  @return   S16
1241 *      -# ROK
1242 **/
1243 #ifdef ANSI
1244 PUBLIC S16 cmUnpkSchMacSpsLcDeregReq
1245 (
1246 SpsLcDereg     func,
1247 Pst            *pst,
1248 Buffer         *mBuf
1249 )
1250 #else
1251 PUBLIC S16 cmUnpkSchMacSpsLcDeregReq(func, pst, mBuf)
1252 SpsLcDereg     func;
1253 Pst            *pst;
1254 Buffer         *mBuf;
1255 #endif
1256 {
1257    CmLteCellId  cellId;
1258    CmLteRnti    crnti;
1259    
1260    TRC2(cmUnpkSchMacSpsLcDeregReq)
1261
1262    CMCHKUNPK(cmUnpkLteRnti, &crnti, mBuf);
1263    CMCHKUNPK(cmUnpkLteCellId, &cellId, mBuf);
1264
1265    RGSCHINF_FREE_MSG(mBuf);
1266    RETVALUE((*func)(pst, cellId, crnti));
1267 } /* end of cmUnpkSchMacSpsLcDeregReq */
1268
1269 #endif /* LTEMAC_SPS */
1270 #ifdef LTE_L2_MEAS
1271
1272 /**
1273 * @brief Primitive from SCH to MAC for L2 Measurement
1274 *
1275 * @details
1276 *
1277 *     Function : cmPkSchMacL2MeasReq
1278 *
1279 *  @param[in]   Pst*                 pst
1280 *  @param[in]   RgInfSpsLcInfo       *lcInfo
1281 *  @return   S16
1282 *      -# ROK
1283 **/
1284 #ifdef ANSI
1285 PUBLIC S16 cmPkSchMacL2MeasReq
1286 (
1287 Pst*                 pst,
1288 RgInfL2MeasReq      *measInfo
1289 )
1290 #else
1291 PUBLIC S16 cmPkSchMacL2MeasReq(pst, measInfo)
1292 Pst*                 pst;
1293 RgInfL2MeasReq      *measInfo;
1294 #endif
1295 {
1296    Buffer *mBuf = NULLP;
1297
1298    TRC2(cmPkSchMacL2MeasReq)
1299
1300    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1301       RETVALUE(RFAILED);
1302    }
1303    if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasReq), mBuf) != ROK)
1304    {
1305       RGSCHINF_FREE_MSG(mBuf);
1306       RETVALUE(RFAILED);
1307    }
1308
1309    pst->event = (Event) EVTINFL2MEASREQ;
1310    RETVALUE(SPstTsk(pst,mBuf));
1311 } /* end of cmPkSchMacL2MeasReq */
1312
1313 /**
1314 * @brief Primitive from SCH to MAC for L2 Stop Measurement
1315 *
1316 * @details
1317 *
1318 *     Function : cmPkSchMacL2MeasStopReq
1319 *
1320 *  @param[in]   Pst*                 pst
1321 *  @param[in]   RgInfSpsLcInfo       *lcInfo
1322 *  @return   S16
1323 *      -# ROK
1324 **/
1325 #ifdef ANSI
1326 PUBLIC S16 cmPkSchMacL2MeasStopReq
1327 (
1328 Pst*                 pst,
1329 RgInfL2MeasStopReq *measInfo
1330 )
1331 #else
1332 PUBLIC S16 cmPkSchMacL2MeasStopReq(pst, measInfo)
1333 Pst*                 pst;
1334 RgInfL2MeasStopReq *measInfo;
1335 #endif
1336 {
1337    Buffer *mBuf = NULLP;
1338
1339    TRC2(cmPkSchMacL2MeasStopReq)
1340
1341    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1342        RETVALUE(RFAILED);
1343   }
1344    if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
1345    {
1346       SPutMsg(mBuf);
1347       RETVALUE(RFAILED);
1348    }
1349
1350    pst->event = (Event) EVTINFL2MEASSTOPREQ;
1351    RETVALUE(SPstTsk(pst,mBuf));
1352 } /* end of cmPkSchMacL2MeasStopReq */
1353 /**
1354 * @brief Primitive from SCH to MAC for L2 Measurement
1355 *         Send Request
1356 * @details
1357 *
1358 *     Function : cmPkSchMacL2MeasSendReq
1359 *
1360 *  @param[in]   Pst*                 pst
1361 *  @param[in]   RgInfSpsLcInfo       *lcInfo
1362 *  @return   S16
1363 *      -# ROK
1364 **/
1365 #ifdef ANSI
1366 PUBLIC S16 cmPkSchMacL2MeasSendReq
1367 (
1368 Pst*                 pst,
1369 RgInfL2MeasSndReq *measInfo
1370 )
1371 #else
1372 PUBLIC S16 cmPkSchMacL2MeasSendReq(pst, measInfo)
1373 Pst*                 pst;
1374 RgInfL2MeasSndReq *measInfo;
1375 #endif
1376 {
1377    Buffer *mBuf = NULLP;
1378
1379    TRC2(cmPkSchMacL2MeasSendReq)
1380  if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1381        RETVALUE(RFAILED);
1382   }
1383
1384    if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)
1385    {
1386       SPutMsg(mBuf);
1387       RETVALUE(RFAILED);
1388    }
1389
1390    pst->event = (Event) EVTINFL2MEASSENDREQ;
1391    RETVALUE(SPstTsk(pst,mBuf));
1392 } /* end of cmPkSchMacL2MeasSendReq */
1393
1394 /**
1395 * @brief Primitive from SCH to MAC for L2 Measurement request
1396 *
1397 * @details
1398 *
1399 *     Function : cmUnpkSchMacL2MeasReq
1400 *
1401 *  @param[in]    L2MeasReg            func
1402 *  @param[in]    Pst*                 pst
1403 *  @param[in]    Buffer               *mBuf
1404 *  @return   S16
1405 *      -# ROK
1406 **/
1407 #ifdef ANSI
1408 PUBLIC S16 cmUnpkSchMacL2MeasReq
1409 (
1410 L2MeasReq      func,
1411 Pst            *pst,
1412 Buffer         *mBuf
1413 )
1414 #else
1415 PUBLIC S16 cmUnpkSchMacL2MeasReq(func, pst, mBuf)
1416 L2MeasReq      func;
1417 Pst            *pst;
1418 Buffer         *mBuf;
1419 #endif
1420 {
1421    RgInfL2MeasReq      measInfo;
1422    
1423    TRC2(cmUnpkSchMacL2MeasReq)
1424
1425    if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasReq), mBuf) != ROK)
1426    {
1427       RGSCHINF_FREE_MSG(mBuf);
1428       RETVALUE(RFAILED);
1429    }
1430
1431    RGSCHINF_FREE_MSG(mBuf);
1432    RETVALUE((*func)(pst, &measInfo));
1433 } /* end of cmUnpkSchMacL2MeasReq */
1434
1435 /**
1436 * @brief Primitive from SCH to MAC for L2 Measurement Stop request
1437 *
1438 * @details
1439 *
1440 *     Function : cmUnpkSchMacL2MeasStopReq
1441 *
1442 *  @param[in]    L2MeasReg            func
1443 *  @param[in]    Pst*                 pst
1444 *  @param[in]    Buffer               *mBuf
1445 *  @return   S16
1446 *      -# ROK
1447 **/
1448 #ifdef ANSI
1449 PUBLIC S16 cmUnpkSchMacL2MeasStopReq
1450 (
1451 L2MeasStopReq func,
1452 Pst            *pst,
1453 Buffer         *mBuf
1454 )
1455 #else
1456 PUBLIC S16 cmUnpkSchMacL2MeasStopReq(func, pst, mBuf)
1457 L2MeasStopReq      func;
1458 Pst            *pst;
1459 Buffer         *mBuf;
1460 #endif
1461 {
1462    RgInfL2MeasStopReq measInfo;
1463
1464    TRC2(cmUnpkSchMacL2MeasStopReq)
1465    if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
1466    {
1467       SPutMsg(mBuf);
1468       RETVALUE(RFAILED);
1469    }
1470
1471    SPutMsg(mBuf);
1472    RETVALUE((*func)(pst, &measInfo));
1473 } /* end of cmUnpkSchMacL2MeasReq */
1474 /**
1475 * @brief Primitive from SCH to MAC for L2 Measurement request
1476 *
1477 * @details
1478 *
1479 *     Function : cmUnpkSchMacL2MeasReq
1480 *
1481 *  @param[in]    L2MeasReg            func
1482 *  @param[in]    Pst*                 pst
1483 *  @param[in]    Buffer               *mBuf
1484 *  @return   S16
1485 *      -# ROK
1486 **/
1487 #ifdef ANSI
1488 PUBLIC S16 cmUnpkSchMacL2MeasSendReq
1489 (
1490 L2MeasSendReq      func,
1491 Pst            *pst,
1492 Buffer         *mBuf
1493 )
1494 #else
1495 PUBLIC S16 cmUnpkSchMacL2MeasSendReq(func, pst, mBuf)
1496 L2MeasSendReq func;
1497 Pst            *pst;
1498 Buffer         *mBuf;
1499 #endif
1500 {
1501    RgInfL2MeasSndReq measInfo;
1502
1503    TRC2(cmUnpkSchMacL2MeasSendReq)
1504  if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)  
1505    {
1506       SPutMsg(mBuf);
1507       RETVALUE(RFAILED);
1508    }
1509
1510    SPutMsg(mBuf);
1511    RETVALUE((*func)(pst, &measInfo));
1512 } /* end of cmUnpkSchMacL2MeasSendReq*/
1513
1514 /**
1515 * @brief Primitive from MAC to SCH for L2 Measurement
1516 *
1517 * @details
1518 *
1519 *     Function : cmPkMacSchL2MeasCfm
1520 *
1521 *  @param[in]   Pst*                 pst
1522 *  @param[in]   RgInfL2MeasCfm       *measInfo
1523 *  @return   S16
1524 *      -# ROK
1525 **/
1526 #ifdef ANSI
1527 PUBLIC S16 cmPkMacSchL2MeasCfm
1528 (
1529 Pst*                 pst,
1530 RgInfL2MeasCfm       *measCfm
1531 )
1532 #else
1533 PUBLIC S16 cmPkMacSchL2MeasCfm(pst, measCfm)
1534 Pst*                 pst;
1535 RgInfL2MeasCfm       *measCfm;
1536 #endif
1537 {
1538    Buffer *mBuf = NULLP;
1539
1540    TRC2(cmPkMacSchL2MeasCfm)
1541
1542    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1543       RETVALUE(RFAILED);
1544    }
1545
1546    if(SAddPstMsgMult((Data *)measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
1547    {
1548       RGSCHINF_FREE_MSG(mBuf);
1549       RETVALUE(RFAILED);
1550    }
1551
1552    pst->event = (Event) EVTINFL2MEASCFM;
1553    RETVALUE(SPstTsk(pst,mBuf));
1554 } /* end of cmPkMacSchL2MeasCfm */
1555
1556
1557 /**
1558 * @brief Primitive from MAC to SCH for L2 Measurement
1559 *        stop cfm
1560 * @details
1561 *
1562 *     Function : cmPkMacSchL2MeasStopCfm
1563 *
1564 *  @param[in]   Pst*                 pst
1565 *  @param[in]   RgInfL2MeasCfm       *measInfo
1566 *  @return   S16
1567 *      -# ROK
1568 **/
1569 #ifdef ANSI
1570 PUBLIC S16 cmPkMacSchL2MeasStopCfm
1571 (
1572 Pst*                 pst,
1573 RgInfL2MeasCfm       *measCfm
1574 )
1575 #else
1576 PUBLIC S16 cmPkMacSchL2MeasStopCfm(pst, measCfm)
1577 Pst*                 pst;
1578 RgInfL2MeasCfm       *measCfm;
1579 #endif
1580 {
1581    Buffer *mBuf = NULLP;
1582
1583    TRC2(cmPkMacSchL2MeasStopCfm)
1584  if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1585       RETVALUE(RFAILED);
1586    }
1587
1588    if(SAddPstMsgMult((Data *)measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
1589    {
1590       SPutMsg(mBuf);
1591       RETVALUE(RFAILED);
1592    }
1593
1594    pst->event = (Event) EVTINFL2MEASSTOPCFM;
1595    RETVALUE(SPstTsk(pst,mBuf));
1596 }/*cmPkMacSchL2MeasStopCfm*/
1597 /**
1598 * @brief Primitive from MAC to SCH for L2 Measurement Cfm
1599 *
1600 * @details
1601 *
1602 *     Function : cmUnpkSchMacL2MeasReq
1603 *
1604 *  @param[in]    L2MeasCfm            func
1605 *  @param[in]    Pst*                 pst
1606 *  @param[in]    Buffer               *mBuf
1607 *  @return   S16
1608 *      -# ROK
1609 **/
1610 #ifdef ANSI
1611 PUBLIC S16 cmUnpkMacSchL2MeasCfm
1612 (
1613 L2MeasCfm      func,
1614 Pst            *pst,
1615 Buffer         *mBuf
1616 )
1617 #else
1618 PUBLIC S16 cmUnpkMacSchL2MeasCfm(func, pst, mBuf)
1619 L2MeasCfm      func;
1620 Pst            *pst;
1621 Buffer         *mBuf;
1622 #endif
1623 {
1624    RgInfL2MeasCfm      measCfm;
1625    
1626    TRC2(cmUnpkMacSchL2MeasCfm)
1627
1628    if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
1629    {
1630       RGSCHINF_FREE_MSG(mBuf);
1631       RETVALUE(RFAILED);
1632    }
1633
1634    RGSCHINF_FREE_MSG(mBuf);
1635    RETVALUE((*func)(pst, &measCfm));
1636 } /* end of cmUnpkMacSchL2MeasCfm */
1637
1638 /**
1639 * @brief Primitive from MAC to SCH for L2 Measurement Stop  Cfm
1640 *
1641 * @details
1642 *
1643 *     Function : cmUnpkMacSchL2MeasStopCfm
1644 *
1645 *  @param[in]    L2MeasCfm            func
1646 *  @param[in]    Pst*                 pst
1647 *  @param[in]    Buffer               *mBuf
1648 *  @return   S16
1649 *      -# ROK
1650 **/
1651 #ifdef ANSI
1652 PUBLIC S16 cmUnpkMacSchL2MeasStopCfm
1653 (
1654 L2MeasCfm      func,
1655 Pst            *pst,
1656 Buffer         *mBuf
1657 )
1658 #else
1659 PUBLIC S16 cmUnpkMacSchL2MeasStopCfm(func, pst, mBuf)
1660 L2MeasCfm      func;
1661 Pst            *pst;
1662 Buffer         *mBuf;
1663 #endif
1664 {
1665 RgInfL2MeasCfm      measCfm;
1666
1667    TRC2(cmUnpkMacSchL2MeasStopCfm)
1668
1669    if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
1670    {
1671       SPutMsg(mBuf);
1672       RETVALUE(RFAILED);
1673    }
1674
1675    SPutMsg(mBuf);
1676    RETVALUE((*func)(pst, &measCfm));
1677 } /* end of cmUnpkMacSchL2MeasStopCfm */
1678
1679 #endif/* LTE_L2_MEAS */
1680
1681 #endif
1682
1683
1684 /**********************************************************************
1685  
1686          End of file
1687 **********************************************************************/