057557c6f4261db7f39b6712b4e901e124649095
[o-du/l2.git] / src / 5gnrmac / mac_msg_router.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 SSI Interface Implementation
26   
27      File:     mac_msg_router.c
28   
29 **********************************************************************/
30
31 /** @file mac_msg_router.c
32 @brief This file contains the implementation of callback functions 
33 registered with SSI during the LTE MAC Task initialization.
34 */
35 /* header include files -- defines (.h) */
36 #include "common_def.h"
37 #include "rgu.h"           /* RGU defines */
38 #include "tfu.h"           /* RGU defines */
39 #include "lrg.h"           /* layer management defines for LTE-MAC */
40 #include "rgr.h"           /* layer management defines for LTE-MAC */
41 #include "crg.h"           /* CRG interface includes */
42 #include "rg_sch_inf.h"    /* SCH interface includes */
43 #include "rg_prg.h"        /* PRG interface includes */
44 #include "rg_env.h"        /* customisable defines and macros for LTE-MAC */
45 #include "rg.h"            /* defines and macros for MAC */
46 #include "rgr.h"            /* defines and macros for SCH */
47
48
49 /* header/extern include files (.x) */
50 #include "rgu.x"           /* RGU types */
51 #include "tfu.x"           /* RGU types */
52 #include "lrg.x"           /* layer management typedefs for MAC */
53 #include "rgr.x"           /* layer management typedefs for MAC */
54 #include "crg.x"           /* CRG interface typedes */
55 #include "rg_sch_inf.x"    /* SCH interface typedefs */
56 #include "rg_prg.x"        /*PRG interface includes*/
57 #include "du_app_mac_inf.h"
58 #include "rg.x"            /* typedefs for MAC */
59 #include "rlc_mac_inf.h"
60 #include "lwr_mac_upr_inf.h"
61
62 /**
63  * @brief Task Activation callback function Entity SM. 
64  *
65  * @details
66  *
67  *     Function : rgHdlSMEvents
68  *     
69  *     Process Messages received from Entity SM
70  *     
71  *  @param[in]  Pst     *pst, Post structure of the primitive.     
72  *  @param[in]  Buffer *mBuf, Packed primitive parameters in the buffer.
73  *  @param[in]  Reason reason.
74  *  @return  void
75  **/
76 static inline void rgHdlSMEvents
77 (
78 Pst     *pst,                       /* post structure       */
79 Buffer  *mBuf                       /* message buffer       */
80 )
81 {
82    switch(pst->event)
83    {
84 #ifdef LCRGMILRG
85       case EVTLRGCFGREQ:
86          /* Process a config. request */
87          cmUnpkLrgCfgReq(RgMiLrgCfgReq, pst, mBuf);
88          break;
89       case EVTMACSCHGENCFGREQ:
90          /* Process a config. request */
91          cmUnpkLrgSchCfgReq(MacSchGenCfgReq, pst, mBuf);
92          break;
93       case EVTLRGCNTRLREQ:
94          /* Process a control request */
95          cmUnpkLrgCntrlReq(RgMiLrgCntrlReq, pst, mBuf);
96          break;
97       case EVTLRGSSTAREQ:
98          /* Process a status request  */
99          cmUnpkLrgStaReq(RgMiLrgStaReq, pst, mBuf);
100          break;
101       case EVTLRGSTSREQ:
102          /* Process a statistics request */
103          cmUnpkLrgStsReq(RgMiLrgStsReq, pst, mBuf);
104          break;
105 #endif /* LCRGMILRG */
106       case EVENT_MAC_CELL_CONFIG_REQ:
107          {
108             /* Process MAC cell config */
109             unpackDuMacCellCfg(MacProcCellCfgReq, pst, mBuf);
110             break;
111          }
112       case EVENT_MAC_CELL_START:
113          {
114             /* Process MAC cell start request */
115             unpackMacCellStart(MacProcCellStart, pst, mBuf);
116             break;
117          }
118       case EVENT_MAC_CELL_STOP:
119          {
120             /* Process MAC cell stop request */
121             unpackMacCellStop(MacProcCellStop, pst, mBuf);
122             break;
123          }
124       case EVENT_MAC_DL_CCCH_IND:
125          {
126             /* Process DL CCCH Ind */
127             unpackMacDlCcchInd(MacProcDlCcchInd, pst, mBuf);
128             break;
129          }
130       case EVENT_MAC_UE_CREATE_REQ:
131          {
132             /* Process Ue Create Request */
133             unpackMacUeCreateReq(MacProcUeCreateReq, pst, mBuf);
134             break;
135          }
136       case EVENT_MAC_UE_RECONFIG_REQ:
137          {
138             /* Process Ue Reconfig Request */
139             unpackMacUeReconfigReq(MacProcUeReconfigReq, pst, mBuf);
140             break;
141          }
142       case EVENT_MAC_UE_DELETE_REQ:
143          {
144             /* Process UE Delete Request */  
145             unpackMacUeDeleteReq(MacProcUeDeleteReq, pst, mBuf);
146             break;
147          }
148       case EVENT_MAC_CELL_DELETE_REQ:
149          {
150             /* Process Cell Delete Request */
151             unpackMacCellDeleteReq(MacProcCellDeleteReq, pst, mBuf);
152             break;
153          }
154       case EVENT_MAC_SLICE_CFG_REQ:
155          {
156             /* Process Slice Configuration Request */
157             unpackMacSliceCfgReq(MacProcSliceCfgReq, pst, mBuf);
158             break;
159          }
160       case EVENT_MAC_SLICE_RECFG_REQ:
161          {
162             /* Process Slice Reconfiguration Request */
163             unpackMacSliceCfgReq(MacProcSliceReCfgReq, pst, mBuf);
164             break;
165          }
166       case EVENT_MAC_RACH_RESOURCE_REQ:
167          {
168             /* Process Rach Resource Request */
169             unpackMacRachRsrcReq(MacProcRachRsrcReq, pst, mBuf);
170             break;
171          }
172
173       default:
174          RG_FREE_MSG(mBuf);
175          break;
176    }
177 }
178
179
180 /**
181  * @brief Task Activation callback function Entity NH. 
182  *
183  * @details
184  *
185  *     Function : rgHdlNHEvents
186  *     
187  *     Process Messages received from Entity NH
188  *     
189  *  @param[in]  Pst     *pst, Post structure of the primitive.     
190  *  @param[in]  Buffer *mBuf, Packed primitive parameters in the buffer.
191  *  @param[in]  Reason reason.
192  *  @return  void
193  **/
194 static inline void rgHdlNHEvents
195 (
196 Pst     *pst,                       /* post structure       */
197 Buffer  *mBuf                       /* message buffer       */
198 )
199 {
200    switch(pst->event)
201    {
202 #ifdef LCRGUICRG
203       case EVTCRGBNDREQ:
204          cmUnpkCrgBndReq(RgUiCrgBndReq, pst, mBuf);
205          break;
206       case EVTCRGUBNDREQ:
207          cmUnpkCrgUbndReq(RgUiCrgUbndReq, pst, mBuf);
208          break;
209       case EVTCRGCFGREQ:
210          cmUnpkCrgCfgReq(RgUiCrgCfgReq, pst, mBuf);
211          break;
212 #endif            
213       default:
214          RG_FREE_MSG(mBuf);
215          break;
216    }
217 }
218
219 /**
220  * @brief Task Activation callback function Entity KW. 
221  *
222  * @details
223  *
224  *     Function : rgHdlKWEvents
225  *     
226  *     Process Messages received from Entity KW
227  *     
228  *  @param[in]  Pst     *pst, Post structure of the primitive.     
229  *  @param[in]  Buffer *mBuf, Packed primitive parameters in the buffer.
230  *  @param[in]  Reason reason.
231  *  @return  void
232  **/
233 static inline void rgHdlKWEvents
234 (
235 Pst     *pst,                       /* post structure       */
236 Buffer  *mBuf                       /* message buffer       */
237 )
238 {
239    switch(pst->event)
240    {
241 #ifdef LCRGUIRGU
242       case EVTRGUBNDREQ:
243          cmUnpkRguBndReq(RgUiRguBndReq, pst, mBuf);
244          break;
245       case EVTRGUUBNDREQ:
246          cmUnpkRguUbndReq(RgUiRguUbndReq, pst, mBuf);
247          break;
248       case EVENT_DL_DATA_TO_MAC:
249          unpackRlcDlData(MacProcRlcDlData, pst, mBuf);
250          break;
251       case EVENT_BO_STATUS_TO_MAC:
252          unpackRlcBoStatus(MacProcRlcBoStatus, pst, mBuf);
253          break;
254 #ifdef LTE_L2_MEAS
255
256       case EVTRGUL2MULTHRPMEASREQ:
257          cmUnpkRguL2MUlThrpMeasReq(RgUiRguL2MUlThrpMeasReq, pst,mBuf);
258          break;
259
260 #endif
261 #endif            
262       default:
263          RG_FREE_MSG(mBuf);
264          break;
265    }
266 }
267
268 /**
269  * @brief Task Activation callback function Entity TF. 
270  *
271  * @details
272  *
273  *     Function : rgHdlTFEvents
274  *     
275  *     Process Messages received from Entity TF
276  *     
277  *  @param[in]  Pst     *pst, Post structure of the primitive.     
278  *  @param[in]  Buffer *mBuf, Packed primitive parameters in the buffer.
279  *  @param[in]  Reason reason.
280  *  @return  void
281  **/
282 static inline void rgHdlTFEvents
283 (
284 Pst     *pst,                       /* post structure       */
285 Buffer  *mBuf                       /* message buffer       */
286 )
287 {
288    switch(pst->event)
289    {
290       case EVENT_SLOT_IND_TO_MAC:
291          unpackSlotInd(fapiMacSlotInd, pst, mBuf);
292          break;
293       case EVENT_STOP_IND_TO_MAC:
294          unpackStopInd(fapiMacStopInd, pst, mBuf);
295          break;
296       case EVENT_RACH_IND_TO_MAC:
297          unpackRachInd(fapiMacRachInd, pst, mBuf);
298          break;
299       case EVENT_CRC_IND_TO_MAC:
300          unpackCrcInd(fapiMacCrcInd, pst, mBuf);
301          break;
302       case EVENT_RX_DATA_IND_TO_MAC:
303          unpackRxDataInd(fapiMacRxDataInd, pst, mBuf);
304          break;
305       case EVENT_UCI_IND_TO_MAC:
306          unpackUciInd(FapiMacUciInd, pst, mBuf);
307          break;
308       default:
309          RG_FREE_MSG(mBuf);
310          break;
311    }
312 }
313
314
315 /**
316  * @brief Task Activation callback function Entity RG SCH. 
317  *
318  * @details
319  *
320  *     Function : rgHdlRGEvents
321  *     
322  *     Process Messages received from Entity RG SCH
323  *     
324  *  @param[in]  Pst     *pst, Post structure of the primitive.     
325  *  @param[in]  Buffer *mBuf, Packed primitive parameters in the buffer.
326  *  @param[in]  Reason reason.
327  *  @return  void
328  **/
329 static inline void rgHdlRGEvents
330 (
331 Pst     *pst,                       /* post structure       */
332 Buffer  *mBuf                       /* message buffer       */
333 )
334 {
335    switch(pst->event)
336    {
337 #ifdef LCRG
338       case EVTINFCELLREGREQ:
339          cmUnpkSchMacCellRegReq(RgSchMacCellRegReq, pst, mBuf);
340          break;
341       case EVTINFSFALLOCREQ:
342          cmUnpkSchMacSfAllocReq(RgSchMacSfAllocReq, pst, mBuf);
343          break;
344       case EVTINFRLSHQREQ:
345          cmUnpkSchMacRlsHqReq(RgSchMacRlsHqReq, pst, mBuf);
346          break;
347       case EVTINFHQENTRESET:
348          cmUnpkSchMacRstHqEntReq(RgSchMacRstHqEntReq, pst, mBuf);
349          break;
350       case EVTINFRLSRNTIREQ:
351          cmUnpkSchMacRlsRntiReq(RgSchMacRlsRntiReq, pst, mBuf);
352          break;
353 #ifdef LTEMAC_SPS
354       case EVTINFSPSLCREG:
355          cmUnpkSchMacSpsLcRegReq(RgSchMacSpsLcRegReq, pst, mBuf);
356          break;
357       case EVTINFSPSLCDEREG:
358          cmUnpkSchMacSpsLcDeregReq(RgSchMacSpsLcDeregReq, pst, mBuf);
359          break;
360       case EVTINFSPSRESET:
361          cmUnpkSchMacUlSpsResetReq(RgSchMacUlSpsResetReq, pst, mBuf);
362          break;
363 #endif /* LTEMAC_SPS */
364 #ifdef LTE_L2_MEAS
365       case EVTINFL2MEASREQ:
366          cmUnpkSchMacL2MeasReq(RgSchMacL2MeasReq, pst, mBuf);
367          break;
368       case EVTINFL2MEASSENDREQ :
369          cmUnpkSchMacL2MeasSendReq(RgSchMacL2MeasSendReq, pst , mBuf);
370          break;
371       case EVTINFL2MEASSTOPREQ:
372          cmUnpkSchMacL2MeasStopReq(RgSchMacL2MeasStopReq, pst , mBuf);
373          break;
374 #endif/* LTE_L2_MEAS */
375       case EVTINFLCGREG:
376          cmUnpkSchMacLcgRegReq(RgSchMacLcgRegReq, pst, mBuf);
377          break;
378 #endif            
379 #if defined(LTE_ADV) && defined(LCPRG)
380       case EVTPRGUESCELLCFGREQ:
381       {
382          cmUnpkPrgPMacSMacUeSCellCfgReq(RgPrgPMacSMacUeSCellCfgReq, pst, mBuf);
383       }
384       break;
385       case EVTPRGUESCELLCFGCFM:
386       case EVTPRGUESCELLLCHMODCFM:
387       case EVTPRGUESCELLLCHDELCFMDEL:
388       case EVTPRGUESCELLLCHADDCFM:
389       {
390          cmUnpkPrgSMacPMacCfgCfm(RgPrgSMacPMacCfgCfm, pst, mBuf);
391       }
392       break;
393       case EVTPRGUESCELLDELREQ:
394       {
395          cmUnpkPrgPMacSMacUeSCellDelReq(RgPrgPMacSMacUeSCellDelReq, pst, mBuf);
396       }
397       break;
398       case EVTPRGUESCELLLCHMODREQ:
399       {
400          cmUnpkPrgPMacSMacUeSCellLchModReq(RgPrgPMacSMacUeSCellLchModReq, pst,
401                                            mBuf);
402       }
403       break;
404       case EVTPRGUESCELLLCHDELREQ:
405       {
406          cmUnpkPrgPMacSMacUeSCellLchDelReq(RgPrgPMacSMacUeSCellLchDelReq, pst,
407                                            mBuf);
408       }
409       break;
410       case EVTPRGUESCELLLCHADDREQ:
411       {
412          cmUnpkPrgPMacSMacUeSCellLchAddReq(RgPrgPMacSMacUeSCellLchAddReq, pst,
413                                            mBuf);
414       }
415       break;
416
417 #endif
418       default:
419       {
420          RG_FREE_MSG(mBuf);
421          break;
422       }
423
424    }
425 }
426
427 /**
428 * @brief Function prints src, dest, msg infor about all the msgs that received.
429 *
430 * @details
431 *
432 *     Function : callFlowRgActvTsk 
433 *
434 *     Function prints src, dest, msg infor about all the msgs that received
435 *
436 *  @param[in]  Pst     *pst, Post structure of the primitive.
437 *
438 *  @return  void
439 **/
440
441 void callFlowRgActvTsk(Pst *pst)
442 {
443    char sourceTask[50];
444    char destTask[50]="ENTMAC";
445    char message[100];
446
447    switch(pst->srcEnt)
448    {
449       case ENTDUAPP:
450          {
451             strcpy(sourceTask,"ENTDUAPP");
452             switch(pst->event)
453             {
454 #ifdef LCRGMILRG
455                case EVTLRGCFGREQ:
456                   strcpy(message,"EVTLRGCFGREQ");
457                   break;
458                case EVTMACSCHGENCFGREQ:
459                   strcpy(message,"EVTMACSCHGENCFGREQ");
460                   break;
461                case EVTLRGCNTRLREQ:
462                   strcpy(message,"EVTLRGCNTRLREQ");
463                   break;
464                case EVTLRGSSTAREQ:
465                   strcpy(message,"EVTLRGSSTAREQ");
466                   break;
467                case EVTLRGSTSREQ:
468                   strcpy(message,"EVTLRGSTSREQ");
469                   break;
470 #endif /* LCRGMILRG */
471                case EVENT_MAC_CELL_CONFIG_REQ:
472                   strcpy(message,"EVENT_MAC_CELL_CONFIG_REQ");
473                   break;
474                case EVENT_MAC_CELL_START:
475                   strcpy(message,"EVENT_MAC_CELL_START");
476                   break;
477                case EVENT_MAC_CELL_STOP:
478                   strcpy(message,"EVENT_MAC_CELL_STOP");
479                   break;
480                case EVENT_MAC_DL_CCCH_IND:
481                   strcpy(message,"EVENT_MAC_DL_CCCH_IND");
482                   break;
483                case EVENT_MAC_UE_CREATE_REQ:
484                   strcpy(message,"EVENT_MAC_UE_CREATE_REQ");
485                   break;
486                case EVENT_MAC_UE_RECONFIG_REQ:
487                   strcpy(message,"EVENT_MAC_UE_RECONFIG_REQ");
488                   break;
489                case EVENT_MAC_UE_DELETE_REQ:
490                   strcpy(message,"EVENT_MAC_UE_DELETE_REQ");
491                   break;
492                case EVENT_MAC_CELL_DELETE_REQ:
493                   strcpy(message,"EVENT_MAC_CELL_DELETE_REQ");
494                   break;
495                case EVENT_MAC_SLICE_CFG_REQ:
496                   strcpy(message,"EVENT_MAC_SLICE_CFG_REQ");
497                   break;
498                case EVENT_MAC_SLICE_RECFG_REQ:
499                   strcpy(message,"EVENT_MAC_SLICE_RECFG_REQ");
500                   break;
501                default:
502                   strcpy(message,"Invalid Event");
503                   break;
504             }
505             break;
506          }
507       case ENTRLC:
508          { 
509             strcpy(sourceTask,"ENTRLC");
510             switch(pst->event)
511             {
512 #ifdef LCRGUIRGU
513                case EVTRGUBNDREQ:
514                   strcpy(message,"EVTRGUBNDREQ");
515                   break;
516                case EVTRGUUBNDREQ:
517                   strcpy(message,"EVTRGUUBNDREQ");
518                   break;
519                case EVENT_DL_DATA_TO_MAC:
520                   strcpy(message,"EVENT_DL_DATA_TO_MAC");
521                   break;
522                case EVENT_BO_STATUS_TO_MAC:
523                   strcpy(message,"EVENT_BO_STATUS_TO_MAC");
524                   break;
525 #endif
526                default:
527                   strcpy(message,"Invalid Event");
528                   break;
529             }
530
531             break;
532          }
533       case ENTLWRMAC:
534          {
535             strcpy(sourceTask,"ENTLWRMAC");
536             switch(pst->event)
537             {
538                case EVENT_SLOT_IND_TO_MAC:
539                   strcpy(message,"EVENT_SLOT_IND_TO_MAC");
540                   break;
541                case EVENT_STOP_IND_TO_MAC:
542                   strcpy(message,"EVENT_STOP_IND_TO_MAC");
543                   break;
544                case EVENT_RACH_IND_TO_MAC:
545                   strcpy(message,"EVENT_RACH_IND_TO_MAC");
546                   break;
547                case EVENT_CRC_IND_TO_MAC:
548                   strcpy(message,"EVENT_CRC_IND_TO_MAC");
549                   break;
550                case EVENT_RX_DATA_IND_TO_MAC:
551                   strcpy(message,"EVENT_RX_DATA_IND_TO_MAC");
552                   break;
553                case EVENT_UCI_IND_TO_MAC:
554                   strcpy(message,"EVENT_UCI_IND_TO_MAC");
555                   break;
556                default:
557                   strcpy(message,"Invalid Event");
558                   break;
559             }
560
561             break;
562          }
563       case ENTMAC: /* When scheduler instance sends msg to MAC */
564          {
565             strcpy(sourceTask,"ENTMAC");
566             switch(pst->event)
567             {
568 #ifdef LCRG
569                case EVTINFCELLREGREQ:
570                   strcpy(message,"EVTINFCELLREGREQ");
571                   break;
572                case EVTINFSFALLOCREQ:
573                   strcpy(message,"EVTINFSFALLOCREQ");
574                   break;
575                case EVTINFRLSHQREQ:
576                   strcpy(message,"EVTINFRLSHQREQ");
577                   break;
578                case EVTINFHQENTRESET:
579                   strcpy(message,"EVTINFHQENTRESET");
580                   break;
581                case EVTINFRLSRNTIREQ:
582                   strcpy(message,"EVTINFRLSRNTIREQ");
583                   break;
584 #ifdef LTEMAC_SPS
585                case EVTINFSPSLCREG:
586                   strcpy(message,"EVTINFSPSLCREG");
587                   break;
588                case EVTINFSPSLCDEREG:
589                   strcpy(message,"EVTINFSPSLCDEREG");
590                   break;
591                case EVTINFSPSRESET:
592                   strcpy(message,"EVTINFSPSRESET");
593                   break;
594 #endif /* LTEMAC_SPS */
595                case EVTINFLCGREG:
596                   strcpy(message,"EVTINFLCGREG");
597                   break;
598 #endif            
599 #if defined(LTE_ADV) && defined(LCPRG)
600                case EVTPRGUESCELLCFGREQ:
601                   strcpy(message,"EVTPRGUESCELLCFGREQ");
602                   break;
603                case EVTPRGUESCELLCFGCFM:
604                   strcpy(message,"EVTPRGUESCELLCFGCFM");
605                   break;
606                case EVTPRGUESCELLLCHMODCFM:
607                   strcpy(message,"EVTPRGUESCELLLCHMODCFM");
608                   break;
609                case EVTPRGUESCELLLCHDELCFMDEL:
610                   strcpy(message,"EVTPRGUESCELLLCHDELCFMDEL");
611                   break;
612                case EVTPRGUESCELLLCHADDCFM:
613                   strcpy(message,"EVTPRGUESCELLLCHADDCFM");
614                   break;
615                case EVTPRGUESCELLDELREQ:
616                   strcpy(message,"EVTPRGUESCELLDELREQ");
617                   break;
618                case EVTPRGUESCELLLCHMODREQ:
619                   strcpy(message,"EVTPRGUESCELLLCHMODREQ");
620                   break;
621                case EVTPRGUESCELLLCHDELREQ:
622                   strcpy(message,"EVTPRGUESCELLLCHDELREQ");
623                   break;
624                case EVTPRGUESCELLLCHADDREQ:
625                   strcpy(message,"EVTPRGUESCELLLCHADDREQ");
626                   break;
627
628 #endif
629                default:
630                   strcpy(message,"Invalid Event");
631                   break;
632             }
633             break;
634          }
635
636       default:
637          {
638             strcpy(sourceTask,"Invalid Source Entity Id");
639             break;
640          }
641    }
642    DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
643 }
644
645 \f
646 /**********************************************************************
647 \f
648 /**
649  * @brief Task Activation callback function. 
650  *
651  * @details
652  *
653  *     Function : rgActvTsk
654  *     
655  *     Primitives invoked by MAC's users/providers through
656  *     a loosely coupled interface arrive here by means of 
657  *     SSI's message handling. This API is registered with
658  *     SSI during the Task Registration of MAC.
659  *     
660  *  @param[in]  Pst     *pst, Post structure of the primitive.     
661  *  @param[in]  Buffer *mBuf, Packed primitive parameters in the buffer.
662  *  @param[in]  Reason reason.
663  *  @return  S16
664  *      -# ROK
665  **/
666 S16 rgActvTsk
667 (
668 Pst     *pst,                       /* post structure       */
669 Buffer  *mBuf                       /* message buffer       */
670 )
671 {
672
673 #ifdef CALL_FLOW_DEBUG_LOG
674    callFlowRgActvTsk(pst);
675 #endif
676
677    switch(pst->srcEnt)
678    {
679       /* The originator of this message is the stack manager,
680        * unpack and go to the respective primitive processing function */
681       case ENTDUAPP:
682           rgHdlSMEvents(pst, mBuf);
683            break;
684       case ENTNH:
685           rgHdlNHEvents(pst, mBuf);
686           break;
687       case ENTRLC:
688           rgHdlKWEvents(pst, mBuf);
689           break;
690       case ENTLWRMAC:
691           rgHdlTFEvents(pst, mBuf);
692           break;
693       case ENTMAC: /* When scheduler instance sends msg to MAC */
694           rgHdlRGEvents(pst, mBuf);
695           break;
696        default:
697           RG_FREE_MSG(mBuf);
698           break;
699    }
700    ODU_EXIT_TASK();
701    return ROK;
702 }/* end of rgActvTsk */
703
704 \f
705 /**********************************************************************
706  
707          End of file
708 **********************************************************************/