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 **********************************************************************/