src/5gnrmac/rg_lmm.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 Layer Manager Interface Module
  26
  27      File:     rg_lmm.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_lmm.c
  32 @brief This file contains the Layer Management interface module implementation.
  33        The functions for the configuration, control, status and statistics
  34        request primitives are defined here.
  35 */
  36
  37 /* header include files (.h) */
  38 #include "common_def.h"
  39 #include "rg_env.h"        /* MAC Environment Defines */
  40 #include "crg.h"           /* CRG Interface defines */
  41 #include "rgu.h"           /* RGU Interface defines */
  42 #include "tfu.h"           /* RGU Interface defines */
  43 #include "rg_sch_inf.h"    /* RGR Interface defines */
  44 #include "lrg.h"           /* LRG Interface defines */
  45 #include "rgr.h"           /* LRG Interface defines */
  46 #include "rg.h"            /* MAC defines */
  47 #include "rg_err.h"        /* MAC error defines */
  48 #include "mac_utils.h"
  49
  50 /* header/extern include files (.x) */
  51 #include "crg.x"           /* CRG Interface includes */
  52 #include "rgu.x"           /* RGU Interface includes */
  53 #include "tfu.x"           /* RGU Interface includes */
  54 #include "rg_sch_inf.x"    /* SCH Interface includes */
  55 #include "rg_prg.x"    /* PRG Interface includes */
  56 #include "lrg.x"           /* LRG Interface includes */
  57 #include "rgr.x"           /* LRG Interface includes */
  58 #include "du_app_mac_inf.h"
  59 #include "rg.x"            /* MAC includes */
  60 #ifdef SS_DIAG
  61 #include "ss_diag.h"        /* Common log file */
  62 #endif
  63 #include "ss_rbuf.h"
  64 #include "ss_rbuf.x"
  65 #include "mac_sch_interface.h"
  66 #include "lwr_mac_upr_inf.h"
  67 #include "mac.h"
  68 #include "lwr_mac_fsm.h"
  69 #include "lwr_mac_phy.h"
  70
  71 #ifdef __cplusplus
  72 extern "C" {
  73 #endif /* __cplusplus */
  74 Void rgGetSId ARGS((SystemId *s));
  75 #ifdef __cplusplus
  76 }
  77 #endif /* __cplusplus */
  78
  79 /* Public variable declaration */
  80 MacCb  macCb;
  81
  82 /* forward references */
  83 static uint16_t rgLMMGenCfg ARGS((
  84    Inst           inst,
  85    RgCfg          *cfg
  86 ));
  87
  88 static uint16_t rgLMMSapCfg ARGS((
  89    Inst           inst,
  90    RgCfg          *cfg,
  91    Elmnt          sapType
  92 ));
  93
  94 static Void rgLMMShutdown ARGS((
  95    Inst           inst
  96 ));
  97
  98 static Void rgLMMFillCfmPst ARGS((
  99    Pst           *reqPst,
 100    Pst           *cfmPst,
 101    RgMngmt       *cfm
 102 ));
 103
 104 static Void rgLMMGenCntrl ARGS((
 105 RgMngmt       *cntrl,
 106 RgMngmt       *cfm,
 107 Pst           *cfmPst
 108 ));
 109
 110 static Void rgLMMSapCntrl ARGS((
 111 RgMngmt       *cntrl,
 112 RgMngmt       *cfm,
 113 Pst           *cfmPst
 114 ));
 115
 116 \f
 117 /**
 118  * @brief Task Initiation callback function.
 119  *
 120  * @details
 121  *
 122  *     Function : rgActvInit
 123  *
 124  *     This function is supplied as one of parameters during MAC's
 125  *     task registration. SSI will invoke this function once, after
 126  *     it creates and attaches this TAPA Task to a system task.
 127  *
 128  *  @param[in]  Ent entity, the entity ID of this task.
 129  *  @param[in]  Inst inst, the instance ID of this task.
 130  *  @param[in]  Region region, the region ID registered for memory
 131  *              usage of this task.
 132  *  @param[in]  Reason reason.
 133  *  @return  S16
 134  *      -# ROK
 135  **/
 136 S16 rgActvInit
 137 (
 138 Ent entity,            /* entity */
 139 Inst inst,             /* instance */
 140 Region region,         /* region */
 141 Reason reason          /* reason */
 142 )
 143 {
 144    Inst macInst ;
 145
 146    RG_IS_INST_VALID(inst);
 147
 148    macInst = inst - RG_INST_START;
 149    /* Initialize the MAC TskInit structure to zero */
 150    memset (&rgCb[macInst], 0, sizeof(RgCb));
 151
 152    /* Initialize the MAC TskInit with received values */
 153    rgCb[macInst].rgInit.ent = entity;
 154    rgCb[macInst].rgInit.inst = inst;
 155    rgCb[macInst].rgInit.region = region;
 156    rgCb[macInst].rgInit.pool = 0;
 157    rgCb[macInst].rgInit.reason = reason;
 158    rgCb[macInst].rgInit.cfgDone = FALSE;
 159    rgCb[macInst].rgInit.acnt = FALSE;
 160    rgCb[macInst].rgInit.usta = FALSE;
 161    rgCb[macInst].rgInit.trc = FALSE;
 162    rgCb[macInst].trcLen = 0;
 163 #ifdef DEBUGP
 164 #ifdef RG_DEBUG
 165    /* disabling debugs by default */
 166    rgCb[macInst].rgInit.dbgMask = 0xffffffff;
 167 #endif
 168 #endif /* DEBUGP */
 169 #ifdef SS_DIAG
 170    rgCb[macInst].rgInit.logMask = 0x0;
 171 #endif
 172    rgCb[macInst].rgInit.procId = SFndProcId();
 173    rgCb[macInst].tfuSap.numBndRetries = 0;
 174
 175    /* Initialize Sap state */
 176    rgCb[macInst].tfuSap.sapSta.sapState = LRG_NOT_CFG;
 177    rgCb[macInst].crgSap.sapSta.sapState = LRG_NOT_CFG;
 178    rgCb[macInst].rguSap = NULLP;
 179    rgCb[macInst].crgSap.sapSta.sapState = LRG_NOT_CFG;
 180
 181    rgCb[macInst].inactiveCell = NULLP;
 182    rgCb[macInst].cell         = NULLP;
 183 #ifdef SS_RBUF
 184    SAttachSRngBuf(SS_RNG_BUF_ULMAC_TO_ULRLC, SS_RBUF_ENT_ULMAC,SS_RNG_TX);
 185    SAttachSRngBuf(SS_RNG_BUF_ULMAC_TO_ULRLC, SS_RBUF_ENT_ULRLC,SS_RNG_RX);
 186 #endif
 187
 188    /* Initialize Scheduler as well */
 189    schActvInit(ENTMAC, SCH_INST_START, DFLT_REGION, PWR_UP);
 190
 191    /* Initialize lower mac */
 192    lwrMacLayerInit(region, 0);
 193
 194    return ROK;
 195
 196 } /* rgActvInit */
 197 \f
 198 /**
 199  * @brief Layer Manager Configuration request handler.
 200  *
 201  * @details
 202  *
 203  *     Function : RgMiLrgCfgReq
 204  *
 205  *     This function handles the configuration
 206  *     request received from the Layer Manager.
 207  *     -# Based on the cfg->hdr.elmId.elmnt value it invokes one of the
 208  *        functions rgHdlGenCfg() or rgHdlSapCfg().
 209  *     -# Invokes RgMiLrgCfgCfm() to send back the confirmation to the LM.
 210  *
 211  *  @param[in]  Pst *pst, the post structure
 212  *  @param[in]  RgMngmt *cfg, the configuration parameter's structure
 213  *  @return  S16
 214  *      -# ROK
 215  **/
 216 S16 RgMiLrgCfgReq
 217 (
 218 Pst      *pst,    /* post structure  */
 219 RgMngmt  *cfg     /* config structure  */
 220 )
 221 {
 222    uint16_t  ret = LCM_PRIM_OK;
 223    uint16_t  reason = LCM_REASON_NOT_APPL;
 224    RgMngmt   cfm;
 225    Pst       cfmPst;
 226    Inst      inst;
 227
 228
 229
 230    DU_LOG("\nINFO  -->  MAC : Received CfgReq for MAC layer, Entity = %d, Instance = %d", pst->srcEnt, pst->srcInst);
 231
 232    RG_IS_INST_VALID(pst->dstInst);
 233    inst = pst->dstInst - RG_INST_START;
 234
 235    /* Fill the post structure for sending the confirmation */
 236    rgLMMFillCfmPst(pst, &cfmPst, cfg);
 237
 238    memset(&cfm, 0, sizeof(RgMngmt));
 239
 240 #ifdef LMINT3
 241    cfm.hdr.transId = cfg->hdr.transId;
 242 #endif
 243
 244
 245    cfm.hdr.elmId.elmnt = cfg->hdr.elmId.elmnt;
 246    switch(cfg->hdr.elmId.elmnt)
 247    {
 248       case STGEN:
 249 #ifdef INTEL_WLS_MEM
 250          /* Start WLS message receiver thread */
 251          LwrMacStartWlsRcvr();
 252 #endif
 253          reason = rgLMMGenCfg(inst,&cfg->t.cfg);
 254          break;
 255       case STRGUSAP:
 256       case STCRGSAP:
 257       case STTFUSAP:
 258          reason = rgLMMSapCfg(inst,&cfg->t.cfg, cfg->hdr.elmId.elmnt);
 259          break;
 260       default:
 261          ret = LCM_PRIM_NOK;
 262          reason = LCM_REASON_INVALID_ELMNT;
 263          DU_LOG("\nERROR  -->  MAC : Invalid Elmnt=%d",
 264                cfg->hdr.elmId.elmnt);
 265          break;
 266    }
 267
 268    if (reason != LCM_REASON_NOT_APPL)
 269    {
 270       ret = LCM_PRIM_NOK;
 271    }
 272
 273    cfm.cfm.status = ret;
 274    cfm.cfm.reason = reason;
 275
 276    RgMiLrgCfgCfm(&cfmPst, &cfm);
 277
 278    return ROK;
 279 }/*-- RgMiLrgCfgReq --*/
 280
 281 \f
 282 /**
 283  * @brief Layer Manager Statistics request handler.
 284  *
 285  * @details
 286  *
 287  *     Function : RgMiLrgStsReq
 288  *
 289  *     This function handles the statistics
 290  *     request received from the Layer Manager.
 291  *      -# Based on sts->hdr.elmId.elmnt, it retrieves either general or SAP
 292  *      statistics from the rgCb global control block.
 293  *      -# If action=ARST, it will reset the statistics parameters in rgCb to 0.
 294  *      -# Invokes the RgMiLrgStsCfm to send back the confirmation to LM.
 295  *
 296  *  @param[in]  Pst *pst, the post structure
 297  *  @param[in]  RgMngmt *sts, the statistics parameter's structure
 298  *  @return  S16
 299  *      -# ROK
 300  **/
 301 S16 RgMiLrgStsReq
 302 (
 303 Pst      *pst,    /* post structure  */
 304 RgMngmt  *sts     /* statistics structure  */
 305 )
 306 {
 307    Pst       cfmPst;
 308    RgMngmt   cfm;
 309    Inst      inst;
 310
 311    RG_IS_INST_VALID(pst->dstInst);
 312    inst = pst->dstInst - RG_INST_START;
 313    /* Fill the post structure for sending the confirmation */
 314    rgLMMFillCfmPst(pst, &cfmPst, sts);
 315
 316    memset(&cfm, 0, sizeof(RgMngmt));
 317
 318 #ifdef LMINT3
 319    cfm.hdr.transId = sts->hdr.transId;
 320 #endif
 321    SGetDateTime(&cfm.t.sts.dt);
 322    cfm.cfm.status = LCM_PRIM_OK;
 323    cfm.cfm.reason = LCM_REASON_NOT_APPL;
 324    cfm.hdr.elmId.elmnt = sts->hdr.elmId.elmnt;
 325    cfm.t.sts.action = sts->t.sts.action;
 326
 327    /* Check if General Config Done */
 328    if(rgCb[inst].rgInit.cfgDone != TRUE)
 329    {
 330       cfm.cfm.status = LCM_PRIM_NOK;
 331       cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 332       RgMiLrgStsCfm(&cfmPst,&cfm);
 333       DU_LOG("\nERROR  -->  MAC : Gen Cfg not done");
 334       return ROK;
 335    }
 336
 337    switch(sts->hdr.elmId.elmnt)
 338    {
 339       case STGEN:
 340          {
 341             memcpy(&(cfm.t.sts.s.genSts), &rgCb[inst].genSts,
 342                   sizeof(RgGenSts));
 343             /* check if action is read and reset */
 344             if(sts->t.sts.action == ARST)
 345             {
 346                rgCb[inst].genSts.numHarqFail = 0;
 347             }
 348             /* L2 statistics */
 349 #ifdef MAC_SCH_STATS
 350             {
 351                RgGenSts *genSts = &(cfm.t.sts.s.genSts);
 352                uint8_t       cqi = 0;
 353                for(cqi=0; cqi <= 14; cqi++)
 354                {
 355                   /* Filling DL ACK/NACK stats */
 356                   genSts->nackAckStats.dlCqiStat[cqi].mcs = \
 357                      hqFailStats.dlCqiStat[cqi].mcs;
 358                   genSts->nackAckStats.dlCqiStat[cqi].numOfNacks = \
 359                      hqFailStats.dlCqiStat[cqi].numOfNacks;
 360                   genSts->nackAckStats.dlCqiStat[cqi].numOfAcks =
 361                      hqFailStats.dlCqiStat[cqi].numOfAcks;
 362
 363                   /* Filling UL ACK/NACK stats */
 364                   genSts->nackAckStats.ulCqiStat[cqi].mcs = \
 365                      hqFailStats.ulCqiStat[cqi].mcs;
 366                   genSts->nackAckStats.ulCqiStat[cqi].numOfNacks = \
 367                      hqFailStats.ulCqiStat[cqi].numOfNacks;
 368                   genSts->nackAckStats.ulCqiStat[cqi].numOfAcks = \
 369                      hqFailStats.ulCqiStat[cqi].numOfAcks;
 370
 371                   /* Filling DL HQ Retx stats */
 372                   genSts->hqRetxStats.dlCqiStat[cqi].mcs = \
 373                      hqRetxStats.dlCqiStat[cqi].mcs;
 374                   genSts->hqRetxStats.dlCqiStat[cqi].numOfHQ_1 = \
 375                      hqRetxStats.dlCqiStat[cqi].numOfHQ_1;
 376                   genSts->hqRetxStats.dlCqiStat[cqi].numOfHQ_2 = \
 377                      hqRetxStats.dlCqiStat[cqi].numOfHQ_2;
 378                   genSts->hqRetxStats.dlCqiStat[cqi].numOfHQ_3 = \
 379                      hqRetxStats.dlCqiStat[cqi].numOfHQ_3;
 380                   genSts->hqRetxStats.dlCqiStat[cqi].numOfHQ_4 = \
 381                      hqRetxStats.dlCqiStat[cqi].numOfHQ_4;
 382                   genSts->hqRetxStats.dlCqiStat[cqi].totalTx = \
 383                      hqRetxStats.dlCqiStat[cqi].totalTx;
 384
 385                   /* Filling UL HQ Retx stats */
 386                   genSts->hqRetxStats.ulCqiStat[cqi].mcs = \
 387                      hqRetxStats.ulCqiStat[cqi].mcs;
 388                   genSts->hqRetxStats.ulCqiStat[cqi].numOfHQ_1 = \
 389                      hqRetxStats.ulCqiStat[cqi].numOfHQ_1;
 390                   genSts->hqRetxStats.ulCqiStat[cqi].numOfHQ_2 = \
 391                      hqRetxStats.ulCqiStat[cqi].numOfHQ_2;
 392                   genSts->hqRetxStats.ulCqiStat[cqi].numOfHQ_3 = \
 393                      hqRetxStats.ulCqiStat[cqi].numOfHQ_3;
 394                   genSts->hqRetxStats.ulCqiStat[cqi].numOfHQ_4 = \
 395                      hqRetxStats.ulCqiStat[cqi].numOfHQ_4;
 396                   genSts->hqRetxStats.ulCqiStat[cqi].totalTx = \
 397                      hqRetxStats.ulCqiStat[cqi].totalTx;
 398                }
 399                /* Reset statistics */
 400                if(sts->t.sts.action == ZEROSTS)
 401                {
 402                   memset(&hqRetxStats, 0, \
 403                         sizeof(RgSchHqRetxStats));
 404                   memset(&hqFailStats, 0, \
 405                         sizeof(RgSchNackAckStats));
 406                }
 407             }
 408 #endif /* MAC_SCH_STATS*/
 409          }
 410          break;
 411       case STRGUSAP:
 412          memcpy(&(cfm.t.sts.s.rguSts), &rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts,
 413                   sizeof(RgSapSts));
 414
 415          /* check if action is read and reset */
 416          if(sts->t.sts.action == ARST)
 417             memset(&rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts, 0, sizeof(RgSapSts));
 418
 419          break;
 420       case STCRGSAP:
 421          memcpy(&(cfm.t.sts.s.crgSts), &rgCb[inst].crgSap.sapSts,
 422                   sizeof(RgSapSts));
 423
 424          /* check if action is read and reset */
 425          if(sts->t.sts.action == ARST)
 426             memset(&rgCb[inst].crgSap.sapSts, 0, sizeof(RgSapSts));
 427
 428          break;
 429       case STTFUSAP:
 430          memcpy(&(cfm.t.sts.s.tfuSts), &rgCb[inst].tfuSap.sapSts,
 431                   sizeof(RgSapSts));
 432
 433          /* check if action is read and reset */
 434          if(sts->t.sts.action == ARST)
 435             memset(&rgCb[inst].tfuSap.sapSts, 0, sizeof(RgSapSts));
 436
 437          break;
 438       default:
 439          cfm.cfm.status = LCM_PRIM_NOK;
 440          cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
 441          DU_LOG("\nERROR  -->  MAC : Invalid Elmnt = %d",sts->hdr.elmId.elmnt);
 442          break;
 443    }
 444    RgMiLrgStsCfm(&cfmPst,&cfm);
 445    return ROK;
 446 }/*-- RgMiLrgStsReq --*/
 447
 448 \f
 449 /**
 450  * @brief Layer Manager Status request handler.
 451  *
 452  * @details
 453  *
 454  *     Function : RgMiLrgStaReq
 455  *
 456  *     This function handles the solicited status
 457  *     request received from the Layer Manager.
 458  *      -# Based on sta->hdr.elmId.elmnt, it retrieves the status of a
 459  *      particular SAP from the rgCb global control block.
 460  *      -# Invokes the RgMiLrgStaCfm to send back the confirmation to LM.
 461  *
 462  *  @param[in]  Pst *pst, the post structure
 463  *  @param[in]  RgMngmt *sta, the status parameter's structure
 464  *  @return  S16
 465  *      -# ROK
 466  **/
 467 S16 RgMiLrgStaReq
 468 (
 469 Pst      *pst,    /* post structure  */
 470 RgMngmt  *sta     /* status structure  */
 471 )
 472 {
 473    Pst       cfmPst;
 474    RgMngmt   cfm;
 475    Inst      inst ;
 476
 477
 478    RG_IS_INST_VALID(pst->dstInst);
 479    inst = pst->dstInst - RG_INST_START;
 480
 481
 482    /* Fill the post structure for sending the confirmation */
 483    rgLMMFillCfmPst(pst, &cfmPst, sta);
 484
 485    if (sta->t.ssta.s.sysId.ptNmb != NULLP)
 486    {
 487       MAC_FREE(sta->t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
 488    }
 489
 490    memset(&cfm, 0, sizeof(RgMngmt));
 491    cfm.hdr.elmId.elmnt = sta->hdr.elmId.elmnt;
 492
 493 #ifdef LMINT3
 494    cfm.hdr.transId = sta->hdr.transId;
 495 #endif
 496    /* Check if General Config Done */
 497    if(rgCb[inst].rgInit.cfgDone != TRUE)
 498    {
 499       SGetDateTime(&cfm.t.ssta.dt);
 500       MAC_ALLOC(cfm.t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
 501            if(cfm.t.ssta.s.sysId.ptNmb == NULLP)
 502       {
 503          DU_LOG("\nERROR  -->  MAC : Memory Unavailable for Confirmation");
 504          return ROK;
 505       }
 506       memset((cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
 507       rgGetSId(&cfm.t.ssta.s.sysId);
 508       cfm.cfm.status = LCM_PRIM_NOK;
 509       cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 510       cfm.hdr.elmId.elmnt = sta->hdr.elmId.elmnt;
 511       RgMiLrgStaCfm(&cfmPst, &cfm);
 512       DU_LOG("\nERROR  -->  MAC : Gen Cfg not done");
 513       return ROK;
 514    }
 515
 516    switch(sta->hdr.elmId.elmnt)
 517    {
 518       case STGEN:
 519          SGetDateTime(&cfm.t.ssta.dt);
 520          MAC_ALLOC(cfm.t.ssta.s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
 521          if(cfm.t.ssta.s.sysId.ptNmb  == NULLP)
 522          {
 523             DU_LOG("\nERROR  -->  MAC : Memory Unavailable for Confirmation");
 524             return ROK;
 525          }
 526          memset((cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
 527          rgGetSId(&cfm.t.ssta.s.sysId);
 528          cfm.cfm.status = LCM_PRIM_OK;
 529          cfm.cfm.reason = LCM_REASON_NOT_APPL;
 530          RgMiLrgStaCfm(&cfmPst, &cfm);
 531          break;
 532       case STRGUSAP:
 533          cfm.cfm.status = LCM_PRIM_OK;
 534          cfm.cfm.reason = LCM_REASON_NOT_APPL;
 535          SGetDateTime(&cfm.t.ssta.dt);
 536          memcpy(&(cfm.t.ssta.s.rguSapSta),
 537                                 &rgCb[inst].rguSap[sta->t.ssta.sapInst].sapSta,
 538             sizeof(RgSapSta));
 539          RgMiLrgStaCfm(&cfmPst, &cfm);
 540          break;
 541       case STCRGSAP:
 542          cfm.cfm.status = LCM_PRIM_OK;
 543          cfm.cfm.reason = LCM_REASON_NOT_APPL;
 544          SGetDateTime(&cfm.t.ssta.dt);
 545          memcpy(&(cfm.t.ssta.s.crgSapSta), &rgCb[inst].crgSap.sapSta,
 546          sizeof(RgSapSta));
 547          RgMiLrgStaCfm(&cfmPst, &cfm);
 548          break;
 549       case STTFUSAP:
 550          cfm.cfm.status = LCM_PRIM_OK;
 551          cfm.cfm.reason = LCM_REASON_NOT_APPL;
 552          SGetDateTime(&cfm.t.ssta.dt);
 553          memcpy(&(cfm.t.ssta.s.tfuSapSta), &rgCb[inst].tfuSap.sapSta,
 554          sizeof(RgSapSta));
 555          RgMiLrgStaCfm(&cfmPst, &cfm);
 556          break;
 557       default:
 558          cfm.cfm.status = LCM_PRIM_NOK;
 559          cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
 560          RgMiLrgStaCfm(&cfmPst, &cfm);
 561          DU_LOG("\nERROR  -->  MAC : Invalid elmnt=%d",sta->hdr.elmId.elmnt);
 562          break;
 563    }
 564    return ROK;
 565 }/*-- RgMiLrgStaReq --*/
 566
 567 \f
 568 /**
 569  * @brief Layer Manager Control request handler.
 570  *
 571  * @details
 572  *
 573  *     Function : RgMiLrgCntrlReq
 574  *
 575  *     This function handles the control
 576  *     request received from the Layer Manager.
 577  *      -# Based on cntrl->hdr.elmId.elmnt, cntrl->t.cntrl.action
 578  *      and cntrl->t.cntrl.subAction, it performs the appropriate control action
 579  *      of SAP (enable/disable), Debug (enable/disable), Trace (enable/disable)
 580  *      and layer shutdown.
 581  *      -# Invokes the RgMiLrgCntrlCfm to send back the confirmation to LM.
 582  *
 583  *  @param[in]  Pst *pst, the post structure
 584  *  @param[in]  RgMngmt *cntrl, the control parameter's structure
 585  *  @return  S16
 586  *      -# ROK
 587  **/
 588 S16 RgMiLrgCntrlReq
 589 (
 590 Pst      *pst,    /* post structure  */
 591 RgMngmt  *cntrl   /* control structure  */
 592 )
 593 {
 594    S16       ret = ROK;            /* return value */
 595    Pst       cfmPst;
 596    RgMngmt   cfm;
 597    Inst      inst;
 598    /* Fill the post structure for sending the confirmation */
 599
 600    RG_IS_INST_VALID(pst->dstInst);
 601    inst = pst->dstInst - RG_INST_START;
 602
 603    rgLMMFillCfmPst(pst, &cfmPst, cntrl);
 604
 605    memset(&cfm, 0, sizeof(RgMngmt));
 606 #ifdef LMINT3
 607    cfm.hdr.transId = cntrl->hdr.transId;
 608 #endif
 609    cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt;
 610    cfm.t.cntrl.action = cntrl->t.cntrl.action;
 611    cfm.t.cntrl.subAction = cntrl->t.cntrl.subAction;
 612
 613    /* Check if General Config Done*/
 614    if(rgCb[inst].rgInit.cfgDone != TRUE)
 615    {
 616       cfm.cfm.status = LCM_PRIM_NOK;
 617       cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 618       cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt;
 619       RgMiLrgCntrlCfm(&cfmPst, &cfm);
 620       DU_LOG("\nERROR  -->  MAC : Gen Cfg not done");
 621       return ROK;
 622    }
 623
 624    /* General Config done, process the Control request */
 625    switch(cntrl->hdr.elmId.elmnt)
 626    {
 627       case STGEN:
 628          rgLMMGenCntrl(cntrl, &cfm, &cfmPst);
 629          break;
 630       case STTFUSAP:
 631       case STRGUSAP:
 632       case STCRGSAP:
 633          rgLMMSapCntrl(cntrl, &cfm, &cfmPst);
 634          break;
 635       default:
 636          cfm.cfm.status = LCM_PRIM_NOK;
 637          cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
 638          RgMiLrgCntrlCfm(&cfmPst, &cfm);
 639          DU_LOG("\nERROR  -->  MAC : invalid elmnt=%d",cntrl->hdr.elmId.elmnt);
 640          break;
 641    }
 642    return (ret);
 643 }/*-- RgMiLrgCntrlReq --*/
 644
 645 \f
 646 /**
 647  * @brief SAP Configuration Handler.
 648  *
 649  * @details
 650  *
 651  *     Function : rgLMMSapCfg
 652  *
 653  *     This function in called by RgMiLrgCfgReq(). It handles the
 654  *     interface SAP configuration of the LTE MAC layer. It
 655  *     initializes the sapState to LRG_UNBND. Returns
 656  *     reason for success/failure of this function.
 657  *
 658  *  @param[in]  Inst        inst
 659  *  @param[in]  RgCfg *cfg, the Configuaration information
 660  *  @return  uint16_t
 661  *      -# LCM_REASON_GENCFG_NOT_DONE
 662  *      -# LCM_REASON_INVALID_SAP
 663  *      -# LCM_REASON_NOT_APPL
 664  **/
 665 static uint16_t rgLMMSapCfg
 666 (
 667 Inst  inst,
 668 RgCfg *cfg,            /* Configuaration information */
 669 Elmnt sapType             /* Sap Type */
 670 )
 671 {
 672    uint16_t          ret = LCM_REASON_NOT_APPL;
 673    RgLowSapCfgInfo   *lowSapCfg = NULLP;
 674    RgUpSapCfgInfo    *upSapCfg = NULLP;
 675    RgUpSapCb         *upSapCb  = NULLP;
 676
 677
 678       /* Check if Gen Config has been done */
 679    if(rgCb[inst].rgInit.cfgDone != TRUE)
 680          return (LCM_REASON_GENCFG_NOT_DONE);
 681
 682    switch(sapType)
 683    {
 684       case STRGUSAP:
 685          if ((cfg->s.rguSap.spId > LRG_MAX_RGU_SAPS) &&
 686                (cfg->s.rguSap.selector != ODU_SELECTOR_TC) &&
 687                (cfg->s.rguSap.selector != ODU_SELECTOR_LC))
 688          {
 689             ret = LCM_REASON_INVALID_PAR_VAL;
 690             DU_LOG("\nERROR  -->  MAC : unsupported Selector value for RGU");
 691             break;
 692          }
 693          upSapCb = &(rgCb[inst].rguSap[cfg->s.rguSap.spId]);
 694          if(upSapCb->sapSta.sapState == LRG_NOT_CFG)
 695          {
 696             upSapCb->sapSta.sapState = LRG_UNBND;
 697          }
 698          upSapCfg = &(upSapCb->sapCfg);
 699          upSapCfg->sapPst.dstEnt = cfg->s.rguSap.ent;
 700          upSapCfg->sapPst.dstInst = cfg->s.rguSap.inst;
 701          upSapCfg->sapPst.dstProcId = cfg->s.rguSap.procId;
 702          upSapCfg->sapPst.srcEnt = rgCb[inst].rgInit.ent;
 703          upSapCfg->sapPst.srcInst = rgCb[inst].rgInit.inst;
 704          upSapCfg->sapPst.srcProcId = rgCb[inst].rgInit.procId;
 705          upSapCfg->sapPst.region = cfg->s.rguSap.mem.region;
 706          upSapCfg->sapPst.pool = cfg->s.rguSap.mem.pool;
 707          upSapCfg->sapPst.selector = cfg->s.rguSap.selector;
 708          upSapCfg->sapPst.route = cfg->s.rguSap.route;
 709          upSapCfg->sapPst.intfVer = 0;
 710          upSapCfg->sapPst.prior = cfg->s.rguSap.prior;
 711          upSapCfg->suId = cfg->s.rguSap.suId;
 712          upSapCfg->spId = cfg->s.rguSap.spId;
 713          /*T2K uses 2 saps, T3K uses 1 sap. change the rgRguDlSap to 1 only if
 714           * there is cfg request with sap is 1*/
 715          break;
 716       case STCRGSAP:
 717          if ((cfg->s.crgSap.selector != ODU_SELECTOR_TC) &&
 718                (cfg->s.crgSap.selector != ODU_SELECTOR_LC))
 719          {
 720             ret = LCM_REASON_INVALID_PAR_VAL;
 721             DU_LOG("\nERROR  -->  MAC : unsupported Selector value for CRG");
 722             break;
 723          }
 724          if(rgCb[inst].crgSap.sapSta.sapState == LRG_NOT_CFG)
 725          {
 726             rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
 727          }
 728          upSapCfg = &rgCb[inst].crgSap.sapCfg;
 729
 730          upSapCfg->sapPst.dstEnt = cfg->s.crgSap.ent;
 731          upSapCfg->sapPst.dstInst = cfg->s.crgSap.inst;
 732          upSapCfg->sapPst.dstProcId = cfg->s.crgSap.procId;
 733          upSapCfg->sapPst.srcEnt = rgCb[inst].rgInit.ent;
 734          upSapCfg->sapPst.srcInst = rgCb[inst].rgInit.inst;
 735          upSapCfg->sapPst.srcProcId = rgCb[inst].rgInit.procId;
 736          upSapCfg->sapPst.region = cfg->s.crgSap.mem.region;
 737          upSapCfg->sapPst.pool = cfg->s.crgSap.mem.pool;
 738          upSapCfg->sapPst.selector = cfg->s.crgSap.selector;
 739          upSapCfg->sapPst.route = cfg->s.crgSap.route;
 740          upSapCfg->sapPst.intfVer = 0;
 741          upSapCfg->sapPst.prior = cfg->s.crgSap.prior;
 742          upSapCfg->suId = cfg->s.crgSap.suId;
 743          upSapCfg->spId = cfg->s.crgSap.spId;
 744          break;
 745       case STTFUSAP:
 746 #ifndef CL_MAC_LWLC
 747          if ((cfg->s.tfuSap.selector != ODU_SELECTOR_TC) &&
 748                (cfg->s.tfuSap.selector != ODU_SELECTOR_LC))
 749          {
 750             ret = LCM_REASON_INVALID_PAR_VAL;
 751             DU_LOG("\nERROR  -->  MAC : unsupported Selector value for TFU");
 752             break;
 753          }
 754 #endif
 755          if (rgCb[inst].tfuSap.sapSta.sapState == LRG_NOT_CFG)
 756          {
 757             rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
 758          }
 759          lowSapCfg = &rgCb[inst].tfuSap.sapCfg;
 760
 761          lowSapCfg->sapPst.dstEnt = cfg->s.tfuSap.ent;
 762          lowSapCfg->sapPst.dstInst = cfg->s.tfuSap.inst;
 763          lowSapCfg->sapPst.dstProcId = rgCb[inst].rgInit.procId;
 764          lowSapCfg->sapPst.srcEnt = rgCb[inst].rgInit.ent;
 765          lowSapCfg->sapPst.srcInst = rgCb[inst].rgInit.inst;
 766          lowSapCfg->sapPst.srcProcId = rgCb[inst].rgInit.procId;
 767          lowSapCfg->sapPst.region = cfg->s.tfuSap.mem.region;
 768          lowSapCfg->sapPst.pool = cfg->s.tfuSap.mem.pool;
 769          lowSapCfg->sapPst.selector = cfg->s.tfuSap.selector;
 770          lowSapCfg->sapPst.route = cfg->s.tfuSap.route;
 771          lowSapCfg->sapPst.intfVer = 0;
 772          lowSapCfg->sapPst.prior = cfg->s.tfuSap.prior;
 773          lowSapCfg->suId = cfg->s.tfuSap.suId;
 774          lowSapCfg->spId = cfg->s.tfuSap.spId;
 775          memcpy(&lowSapCfg->bndTmr, &cfg->s.tfuSap.bndTmr,
 776                    sizeof(TmrCfg));
 777          break;
 778       default:
 779          /* would never reach here */
 780          break;
 781    }
 782    return (ret);
 783 }
 784
 785 \f
 786 /**
 787  * @brief General Configuration Handler.
 788  *
 789  * @details
 790  *
 791  *     Function : rgLMMGenCfg
 792  *
 793  *     This function in called by RgMiLrgCfgReq(). It handles the
 794  *     general configuration of the LTE MAC layer. It initializes
 795  *     the hash lists of RgCb. Returns
 796  *     reason for success/failure of this function.
 797  *
 798  *  @param[in]  Inst        inst
 799  *  @param[in]  RgCfg *cfg, the Configuaration information
 800  *  @return  uint16_t
 801  *      -# LCM_REASON_NOT_APPL
 802  *      -# LCM_REASON_INVALID_MSGTYPE
 803  *      -# LCM_REASON_MEM_NOAVAIL
 804  **/
 805 static uint16_t rgLMMGenCfg
 806 (
 807 Inst inst,
 808 RgCfg *cfg            /* Configuaration information */
 809 )
 810 {
 811    uint16_t    ret = LCM_REASON_NOT_APPL;
 812
 813
 814    /* Check if General Configuration is done already */
 815    if (rgCb[inst].rgInit.cfgDone == TRUE)
 816    {
 817       return (LCM_REASON_INVALID_MSGTYPE);
 818    }
 819    if ((cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_TC) &&
 820          (cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_LC))
 821    {
 822       DU_LOG("\nERROR  -->  MAC : unsupported Selector value for RGU");
 823       return (LCM_REASON_INVALID_PAR_VAL);
 824    }
 825    /* Update the Pst structure for LM interface */
 826    memcpy(&rgCb[inst].rgInit.lmPst, &cfg->s.genCfg.lmPst,
 827              sizeof(Pst));
 828
 829    rgCb[inst].rgInit.lmPst.srcProcId = rgCb[inst].rgInit.procId;
 830    rgCb[inst].rgInit.lmPst.srcEnt = rgCb[inst].rgInit.ent;
 831    rgCb[inst].rgInit.lmPst.srcInst = rgCb[inst].rgInit.inst;
 832    rgCb[inst].rgInit.lmPst.event = EVTNONE;
 833
 834    rgCb[inst].rgInit.region = cfg->s.genCfg.mem.region;
 835    rgCb[inst].rgInit.pool = cfg->s.genCfg.mem.pool;
 836    rgCb[inst].genCfg.tmrRes = cfg->s.genCfg.tmrRes;
 837
 838    macCb.tmrRes = cfg->s.genCfg.tmrRes;
 839    macCb.macInst = rgCb[inst].rgInit.inst;
 840    macCb.procId = rgCb[inst].rgInit.procId;
 841
 842    /* Initialize SAP States */
 843    rgCb[inst].crgSap.sapSta.sapState = LRG_NOT_CFG;
 844
 845    if(cfg->s.genCfg.numRguSaps == 0)
 846    {
 847       DU_LOG("\nERROR  -->  MAC : rgGenCfg(): Invalid numRguSap.\n");
 848       return RFAILED;
 849    }
 850
 851    /* allocate RGR saps */
 852    MAC_ALLOC(rgCb[inst].rguSap, sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps);
 853    if(rgCb[inst].rguSap == NULLP)
 854    {
 855       DU_LOG("\nERROR  -->  MAC : rgGenCfg(): Failed to allocate mem for RGU SAP's.\n");
 856       return RFAILED;
 857    }
 858    rgCb[inst].numRguSaps = cfg->s.genCfg.numRguSaps;
 859
 860    for (int idx = 0; idx < rgCb[inst].numRguSaps; idx++)
 861    {
 862       rgCb[inst].rguSap[idx].sapSta.sapState = LRG_NOT_CFG;
 863       memset(&rgCb[inst].rguSap[idx], 0, sizeof(RgUpSapCb));
 864    }
 865    rgCb[inst].tfuSap.sapSta.sapState = LRG_NOT_CFG;
 866    /* Initialize the timer blocks */
 867    cmInitTimers(macCb.tmrBlk, MAX_NUM_TIMER);
 868    /* Initialzie the timer queue */
 869    memset(&macCb.tmrTq, 0, sizeof(CmTqType) * MAC_TQ_SIZE);
 870    /* Initialize the timer control point */
 871    memset(&macCb.tmrTqCp, 0, sizeof(CmTqCp));
 872    macCb.tmrTqCp.tmrLen = MAC_TQ_SIZE;
 873
 874    /* Timer Registration request to SSI */
 875    if(ODU_REG_TMR_MT(ENTMAC, macCb.macInst, macCb.tmrRes, macActvTmr) != ROK)
 876    {
 877
 878       DU_LOG("\nERROR  -->  MAC : Failed to register timer");
 879
 880       MAC_FREE(rgCb[inst].rguSap,
 881             (sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps));
 882
 883       return (LCM_REASON_MEM_NOAVAIL);
 884    }
 885
 886    /* Set Config done in TskInit */
 887    rgCb[inst].rgInit.cfgDone = TRUE;
 888
 889    return (ret);
 890 }
 891
 892 \f
 893 /***********************************************************
 894  *
 895  *     Func : rgLMMShutdown
 896  *
 897  *
 898  *     Desc : Handles the MAC layer shutdown request. Calls
 899  *     rgCFGFreeCellCb(RgCellCb*) to handle each cellCb deallocation.
 900  *
 901  *
 902  *     Ret  : Void
 903  *
 904  *     Notes:
 905  *
 906  *     File : rg_lmm.c
 907  *
 908  **********************************************************/
 909 static Void rgLMMShutdown(Inst inst)
 910 {
 911    RgCellCb   *cell = rgCb[inst].cell;
 912    uint8_t    idx;
 913
 914
 915     /* Unbind the TFU Sap */
 916    if(rgCb[inst].tfuSap.sapSta.sapState == LRG_WAIT_BNDCFM)
 917    {
 918       //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, LRG_UNBND);
 919       if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
 920       {
 921          rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
 922       }
 923       rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
 924    }
 925    if(rgCb[inst].tfuSap.sapSta.sapState == LRG_BND)
 926    {
 927       //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, LRG_UNBND);
 928       rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
 929    }
 930
 931
 932    if(cell != NULLP)
 933    {
 934       for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
 935       {
 936          rgTOMRlsSf(inst,&cell->subFrms[idx]);
 937       }
 938
 939       rgCFGFreeCellCb(cell);
 940    }
 941
 942    /* Deleting the RGU SAPs */
 943     MAC_FREE(rgCb[inst].rguSap,
 944          (sizeof(RgUpSapCb) * rgCb[inst].numRguSaps));
 945
 946    rgCb[inst].inactiveCell = NULLP;
 947    rgCb[inst].cell         = NULLP;
 948
 949    /* De-register the Timer Service */
 950    (Void) SDeregTmrMt(rgCb[inst].rgInit.ent, rgCb[inst].rgInit.inst,
 951          (S16)rgCb[inst].genCfg.tmrRes, macActvTmr);
 952
 953    /* call back the task initialization function to intialize
 954     * the global RgCb Struct */
 955    rgActvInit(rgCb[inst].rgInit.ent, rgCb[inst].rgInit.inst, rgCb[inst].rgInit.region,
 956          rgCb[inst].rgInit.reason);
 957
 958    return;
 959 }
 960
 961 \f
 962 /***********************************************************
 963  *
 964  *     Func : rgLMMGenCntrl
 965  *
 966  *
 967  *     Desc : Processes the LM control request for STGEN elmnt.
 968  *
 969  *
 970  *     Ret  : Void
 971  *
 972  *     Notes:
 973  *
 974  *     File : rg_lmm.c
 975  *
 976  **********************************************************/
 977 static Void rgLMMGenCntrl
 978 (
 979 RgMngmt       *cntrl,
 980 RgMngmt       *cfm,
 981 Pst           *cfmPst
 982 )
 983 {
 984    Inst      inst = (cfmPst->srcInst - RG_INST_START);
 985
 986    cfm->cfm.status = LCM_PRIM_OK;
 987    cfm->cfm.reason = LCM_REASON_NOT_APPL;
 988
 989
 990    switch(cntrl->t.cntrl.action)
 991    {
 992       case AENA:
 993          /* Action is Enable */
 994          switch(cntrl->t.cntrl.subAction)
 995          {
 996             case SATRC:
 997             /* Enable Traces */
 998                rgCb[inst].rgInit.trc = TRUE;
 999                rgCb[inst].trcLen = cntrl->t.cntrl.s.trcLen;
1000                /*Store the response and TransId for sending the Traces */
1001                memcpy(&rgCb[inst].genCfg.trcResp.response,
1002                &cntrl->hdr.response, sizeof(Resp));
1003                rgCb[inst].genCfg.trcResp.transId = cntrl->hdr.transId;
1004
1005                break;
1006             case SAUSTA:
1007             /* Enable Unsolicited Status (alarms) */
1008                rgCb[inst].rgInit.usta = TRUE;
1009                /*Store the response and TransId for sending the Alarms */
1010                memcpy(&rgCb[inst].genCfg.ustaResp.response,
1011                &cntrl->hdr.response, sizeof(Resp));
1012                rgCb[inst].genCfg.ustaResp.transId = cntrl->hdr.transId;
1013                break;
1014             case SADBG:
1015             /* Enable Debug Printing */
1016 #ifdef DEBUGP
1017                rgCb[inst].rgInit.dbgMask |= cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
1018 #endif
1019                break;
1020 #ifdef SS_DIAG
1021             case SALOG:
1022                rgCb[inst].rgInit.logMask = cntrl->t.cntrl.s.logMask;
1023                break;
1024 #endif
1025
1026             default:
1027                cfm->cfm.status = LCM_PRIM_NOK;
1028                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
1029                DU_LOG("\nERROR  -->  MAC : invalid subaction=%d",cntrl->t.cntrl.subAction);
1030                break;
1031          }
1032          break;
1033       case ADISIMM:
1034          /* Action is Diable immidiately */
1035          switch(cntrl->t.cntrl.subAction)
1036          {
1037             case SATRC:
1038                /* Disable Traces */
1039                rgCb[inst].rgInit.trc = FALSE;
1040                break;
1041             case SAUSTA:
1042                /* Disable Unsolicited Status (alarms) */
1043                rgCb[inst].rgInit.usta = FALSE;
1044                break;
1045             case SADBG:
1046                /* Disable Debug Printing */
1047 #ifdef DEBUGP
1048                rgCb[inst].rgInit.dbgMask &=~cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
1049 #endif
1050                break;
1051 #ifdef SS_DIAG
1052             case SALOG:
1053                rgCb[inst].rgInit.logMask = cntrl->t.cntrl.s.logMask;
1054                break;
1055 #endif
1056
1057             default:
1058                cfm->cfm.status = LCM_PRIM_NOK;
1059                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
1060                DU_LOG("\nERROR  -->  MAC : invalid subaction=%d",cntrl->t.cntrl.subAction);
1061                break;
1062          }
1063          break;
1064       case ASHUTDOWN:
1065          /* Free all the memory dynamically allocated by MAC */
1066          rgLMMShutdown(inst);
1067          break;
1068       default:
1069          cfm->cfm.status = LCM_PRIM_NOK;
1070          cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
1071          DU_LOG("\nERROR  -->  MAC : invalid action=%d",cntrl->t.cntrl.action);
1072          break;
1073    }
1074    RgMiLrgCntrlCfm(cfmPst, cfm);
1075    return;
1076 }
1077
1078 \f
1079 /***********************************************************
1080  *
1081  *     Func : rgLMMSapCntrl
1082  *
1083  *
1084  *     Desc : Processes the LM control request for STxxxSAP elmnt.
1085  *
1086  *
1087  *     Ret  : Void
1088  *
1089  *     Notes:
1090  *
1091  *     File : rg_lmm.c
1092  *
1093  **********************************************************/
1094 static Void rgLMMSapCntrl
1095 (
1096 RgMngmt       *cntrl,
1097 RgMngmt       *cfm,
1098 Pst           *cfmPst
1099 )
1100 {
1101    Inst      inst = cfmPst->srcInst - RG_INST_START;
1102
1103    /* Only TFU Sap can be controlled by LM */
1104    switch(cntrl->hdr.elmId.elmnt)
1105    {
1106       case STTFUSAP:
1107          switch(cntrl->t.cntrl.action)
1108          {
1109             case ABND:
1110             /* Bind Enable Request */
1111                if ((rgCb[inst].tfuSap.sapSta.sapState == LRG_NOT_CFG) ||
1112                    (rgCb[inst].tfuSap.sapSta.sapState == LRG_BND))
1113                {
1114                   cfm->cfm.status = LCM_PRIM_NOK;
1115                   cfm->cfm.reason = LCM_REASON_INVALID_SAP;
1116                }
1117                else
1118                {
1119                   if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
1120                   {
1121                      rgLMMStartTmr(inst,RG_BNDREQ_TMR, rgCb[inst].tfuSap.sapCfg.bndTmr.val,
1122                      (PTR)&rgCb[inst].tfuSap);
1123                   }
1124                   /* Change SAP state */
1125                   rgCb[inst].tfuSap.sapSta.sapState = LRG_WAIT_BNDCFM;
1126                   rgCb[inst].tfuSap.numBndRetries++;
1127                   /* Store the response and TransId for sending
1128                    * the Control confirm */
1129                   memcpy(&rgCb[inst].genCfg.bndCfmResp.response,
1130                            &cntrl->hdr.response, sizeof(Resp));
1131                   rgCb[inst].genCfg.bndCfmResp.transId = cntrl->hdr.transId;
1132
1133                   /* Sending Status Indication to Layer Manager */
1134                   cfm->cfm.status = LCM_PRIM_OK_NDONE;
1135                   cfm->cfm.reason = LCM_REASON_NOT_APPL;
1136                   RgMiLrgCntrlCfm(cfmPst, cfm);
1137
1138                   //rgLIMTfuBndReq(inst,rgCb[inst].tfuSap.sapCfg.suId,
1139                                       //rgCb[inst].tfuSap.sapCfg.spId);
1140                   RETVOID;
1141                }
1142                break;
1143             case AUBND:
1144             /* Unbind request */
1145
1146                /* Check if the SAP is configured */
1147                if( (rgCb[inst].tfuSap.sapSta.sapState == LRG_NOT_CFG) ||
1148                      (rgCb[inst].tfuSap.sapSta.sapState == LRG_UNBND))
1149                {
1150                   cfm->cfm.status = LCM_PRIM_NOK;
1151                   cfm->cfm.reason = LCM_REASON_INVALID_MSGTYPE;
1152                }
1153                else
1154                {
1155                   //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, TFU_UBNDREQ_MNGMT);
1156                   if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
1157                   {
1158                      rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
1159                   }
1160                   /* Change SAP state */
1161                   rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
1162                   cfm->cfm.status = LCM_PRIM_OK;
1163                   cfm->cfm.reason = LCM_REASON_NOT_APPL;
1164                }
1165                break;
1166             case ADEL:
1167                /* Delete SAP, does initialization of SAP */
1168                if ((rgCb[inst].tfuSap.sapSta.sapState == LRG_WAIT_BNDCFM) ||
1169                    (rgCb[inst].tfuSap.sapSta.sapState == LRG_BND))
1170                {
1171                   //rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, TFU_UBNDREQ_MNGMT);
1172                   if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
1173                   {
1174                      rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
1175                   }
1176                }
1177                memset(&rgCb[inst].tfuSap, 0, sizeof(RgLowSapCb));
1178                rgCb[inst].tfuSap.sapSta.sapState = LRG_NOT_CFG;
1179                cfm->cfm.status = LCM_PRIM_OK;
1180                cfm->cfm.reason = LCM_REASON_NOT_APPL;
1181                break;
1182             default:
1183                cfm->cfm.status = LCM_PRIM_NOK;
1184                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
1185                DU_LOG("\nERROR  -->  MAC : rgLMMSapCntrl(): invalid action=%d",
1186                cntrl->t.cntrl.action);
1187                break;
1188          }
1189          break;
1190       case STRGUSAP:
1191          switch(cntrl->t.cntrl.action)
1192          {
1193             case ADEL:
1194                memset(&rgCb[inst].rguSap[cntrl->t.cntrl.instId], 0, sizeof(RgUpSapCb));
1195                rgCb[inst].rguSap[cntrl->t.cntrl.instId].sapSta.sapState = LRG_NOT_CFG;
1196                cfm->cfm.status = LCM_PRIM_OK;
1197                cfm->cfm.reason = LCM_REASON_NOT_APPL;
1198                break;
1199             default:
1200                cfm->cfm.status = LCM_PRIM_NOK;
1201                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
1202                DU_LOG("\nERROR  -->  MAC : rgLMMSapCntrl(): invalid action=%d",
1203                cntrl->t.cntrl.action);
1204                break;
1205          }
1206          break;
1207       case STCRGSAP:
1208          switch(cntrl->t.cntrl.action)
1209          {
1210             case ADEL:
1211                memset(&rgCb[inst].crgSap, 0, sizeof(RgUpSapCb));
1212                rgCb[inst].crgSap.sapSta.sapState = LRG_NOT_CFG;
1213                cfm->cfm.status = LCM_PRIM_OK;
1214                cfm->cfm.reason = LCM_REASON_NOT_APPL;
1215                break;
1216             default:
1217                cfm->cfm.status = LCM_PRIM_NOK;
1218                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
1219                DU_LOG("\nERROR  -->  MAC : invalid action=%d",cntrl->t.cntrl.action);
1220
1221                break;
1222          }
1223          break;
1224       default:
1225          /* Would never here. */
1226          RETVOID;
1227    }
1228    RgMiLrgCntrlCfm(cfmPst, cfm);
1229    return;
1230 }
1231
1232 \f
1233 /***********************************************************
1234  *
1235  *     Func : rgLMMFillCfmPst
1236  *
1237  *
1238  *     Desc : Fills the Confirmation Post Structure cfmPst using the reqPst
1239  *            and the cfm->hdr.response.
1240  *
1241  *
1242  *     Ret  : Void
1243  *
1244  *     Notes:
1245  *
1246  *     File : rg_lmm.c
1247  *
1248  **********************************************************/
1249 static Void rgLMMFillCfmPst
1250 (
1251 Pst           *reqPst,
1252 Pst           *cfmPst,
1253 RgMngmt       *cfm
1254 )
1255 {
1256    Inst inst;
1257    inst = (reqPst->dstInst - RG_INST_START);
1258
1259    cfmPst->srcEnt    = rgCb[inst].rgInit.ent;
1260    cfmPst->srcInst   = rgCb[inst].rgInit.inst;
1261    cfmPst->srcProcId = rgCb[inst].rgInit.procId;
1262    cfmPst->dstEnt    = reqPst->srcEnt;
1263    cfmPst->dstInst   = reqPst->srcInst;
1264    cfmPst->dstProcId = reqPst->srcProcId;
1265
1266    cfmPst->selector  = cfm->hdr.response.selector;
1267    cfmPst->prior     = cfm->hdr.response.prior;
1268    cfmPst->route     = cfm->hdr.response.route;
1269    cfmPst->region    = cfm->hdr.response.mem.region;
1270    cfmPst->pool      = cfm->hdr.response.mem.pool;
1271
1272    return;
1273 }
1274
1275 \f
1276 /**
1277  * @brief Timer start handler.
1278  *
1279  * @details
1280  *
1281  *     Function : rgLMMStartTmr
1282  *
1283  *     This function based on the input parameters starts the timer for
1284  *     "tmrVal" duration. As of now MAC uses the timer functionality for
1285  *     BndReq only. Hence there is no conditional code based on "tmrEvnt".
1286  *
1287  *  @param[in]  Inst        inst
1288  *  @param[in]  S16   tmrEvnt, the Timer Event
1289  *  @param[in]  uint32_t   tmrVal,  the Wait Time
1290  *  @param[in]  PTR   cb,  Entry for which Timer expired
1291  *  @return  S16
1292  *      -# ROK
1293  **/
1294 S16 rgLMMStartTmr
1295 (
1296 Inst               inst,
1297 S16                tmrEvnt,            /* Timer Event */
1298 uint32_t           tmrVal,             /* Wait Time */
1299 PTR                cb                  /* Entry for which Timer Expired */
1300 )
1301 {
1302    CmTmrArg    arg;
1303
1304
1305       UNUSED(tmrEvnt);
1306
1307    /* Initialize the arg structure */
1308    memset(&arg, 0, sizeof(CmTmrArg));
1309
1310    arg.tqCp = &rgCb[inst].tmrTqCp;
1311    arg.tq = rgCb[inst].tmrTq;
1312    arg.timers = rgCb[inst].tmrBlk;
1313    arg.cb = cb;
1314    arg.tNum = 0;
1315    arg.max = RG_MAX_TIMER;
1316    arg.evnt = RG_BNDREQ_TMR;
1317    arg.wait = tmrVal;
1318    cmPlcCbTq(&arg);
1319
1320    return ROK;
1321 }
1322
1323 \f
1324 /**
1325  * @brief Timer stop handler.
1326  *
1327  * @details
1328  *
1329  *     Function : rgLMMStopTmr
1330  *
1331  *     This function based on the input parameters stops the timer for
1332  *     "tmrEvnt". As of now MAC uses the timer functionality for
1333  *     BndReq only. Hence there is no conditional code based on "tmrEvnt".
1334  *     Once the bind happens and this timer is stopped, the timer functionality
1335  *     is deregistered with SSI. As there is no further use of timer processing.
1336  *
1337  *  @param[in]  Inst        inst
1338  *  @param[in]  S16   tmrEvnt, the Timer Event
1339  *  @param[in]  PTR   cb,  Entry for which Timer expired
1340  *  @return  S16
1341  *      -# ROK
1342  *      -# RFAILED
1343  **/
1344 S16 rgLMMStopTmr
1345 (
1346 Inst               inst,             /* Scheduler instance */
1347 S16                tmrEvnt,            /* Timer Event */
1348 PTR                cb                  /* Entry for which Timer Expired */
1349 )
1350 {
1351    CmTmrArg   arg;
1352    uint8_t      i;
1353    S16        ret;
1354
1355
1356    ret = RFAILED;
1357
1358    for(i=0;i<RG_MAX_TIMER;i++)
1359    {
1360       /* Search for the Timer Blocks */
1361       if(rgCb[inst].tmrBlk[i].tmrEvnt == tmrEvnt)
1362       {
1363          /* Initialize the arg structure */
1364          memset(&arg, 0, sizeof(CmTmrArg));
1365
1366          arg.tqCp = &rgCb[inst].tmrTqCp;
1367          arg.tq = rgCb[inst].tmrTq;
1368          arg.timers = rgCb[inst].tmrBlk;
1369          arg.cb = cb;
1370          arg.max = RG_MAX_TIMER;
1371          arg.evnt = NOTUSED;
1372          arg.wait = NOTUSED;
1373
1374          arg.tNum = i;
1375          cmRmvCbTq(&arg);
1376          ret = ROK;
1377          break;
1378       }
1379
1380    }
1381
1382
1383    return (ret);
1384 }
1385
1386 \f
1387 /**
1388  * @brief Timer Expiry handler.
1389  *
1390  * @details
1391  *
1392  *     Function : rgLMMTmrExpiry
1393  *
1394  *     This is a callback function used as an input parameter to cmPrcTmr()
1395  *     to check expiry of any timer. In this function, the only concern is
1396  *     about tmrEvnt=Bind timer.
1397  *
1398  *  @param[in]  PTR   cb,  Entry for which Timer expired
1399  *  @param[in]  S16   tmrEvnt, the Timer Event
1400  *  @return  S16
1401  *      -# ROK
1402  **/
1403 S16 rgLMMTmrExpiry
1404 (
1405 PTR cb,               /* Pointer to timer control block */
1406 S16 tmrEvnt           /* Timer Event */
1407 )
1408 {
1409    S16        ret = ROK;
1410    RgLowSapCb *tfuSap = (RgLowSapCb *)cb;
1411    Inst          inst = tfuSap->sapCfg.sapPst.srcInst - RG_INST_START;
1412
1413    switch(tmrEvnt)
1414    {
1415       case RG_BNDREQ_TMR:
1416          tfuSap->numBndRetries++;
1417          if(tfuSap->numBndRetries > RG_MAX_BNDRETRY)
1418          {
1419             rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE, LCM_EVENT_BND_FAIL,
1420                         LCM_CAUSE_TMR_EXPIRED, NULLP);
1421          }
1422          else
1423          {
1424             /* Restart the bind timer */
1425             if (tfuSap->sapCfg.bndTmr.enb == TRUE)
1426             {
1427                ret = rgLMMStartTmr(inst,RG_BNDREQ_TMR, tfuSap->sapCfg.bndTmr.val,
1428                cb);
1429             }
1430
1431             /* Send bind request */
1432             //rgLIMTfuBndReq(inst,rgCb[inst].tfuSap.sapCfg.suId,
1433                                 //rgCb[inst].tfuSap.sapCfg.spId);
1434          }
1435          break;
1436       default:
1437          DU_LOG("\nERROR  -->  MAC : Invalid tmrEvnt=%d",tmrEvnt);
1438          ret = RFAILED;
1439          break;
1440    }
1441    return (ret);
1442 }
1443
1444
1445 \f
1446 /**
1447  * @brief Layer Manager Unsolicited Status Indication generation.
1448  *
1449  * @details
1450  *
1451  *     Function : rgLMMStaInd
1452  *
1453  *     This API is used by the other modules of MAC to send a unsolicited
1454  *     status indication to the Layer Manager.
1455  *
1456  *  @param[in]  Inst        inst
1457  *  @param[in]  uint16_t category, the Alarm category
1458  *  @param[in]  uint16_t event, the Alarm event
1459  *  @param[in]  uint16_t cause, the cause of the Alarm
1460  *  @param[in]  RgUstaDgn *dgn, Alarm Diagonostics
1461  *  @return  S16
1462  *      -# ROK
1463  **/
1464 S16 rgLMMStaInd
1465 (
1466 Inst inst,
1467 uint16_t category,
1468 uint16_t event,
1469 uint16_t cause,
1470 RgUstaDgn *dgn
1471 )
1472 {
1473    RgMngmt    usta;
1474    if(rgCb[inst].rgInit.usta == FALSE)
1475    {
1476       return ROK;
1477    }
1478
1479    memset(&usta, 0, sizeof(RgMngmt));
1480
1481    SGetDateTime(&usta.t.usta.cmAlarm.dt);
1482    usta.t.usta.cmAlarm.category = category;
1483    usta.t.usta.cmAlarm.event = event;
1484    usta.t.usta.cmAlarm.cause = cause;
1485    if (dgn != NULLP)
1486    {
1487       memcpy(&usta.t.usta.dgn, dgn, sizeof(RgUstaDgn));
1488    }
1489
1490    rgCb[inst].rgInit.lmPst.selector = rgCb[inst].genCfg.ustaResp.response.selector;
1491    rgCb[inst].rgInit.lmPst.prior = rgCb[inst].genCfg.ustaResp.response.prior;
1492    rgCb[inst].rgInit.lmPst.route = rgCb[inst].genCfg.ustaResp.response.route;
1493    rgCb[inst].rgInit.lmPst.region = rgCb[inst].genCfg.ustaResp.response.mem.region;
1494    rgCb[inst].rgInit.lmPst.pool = rgCb[inst].genCfg.ustaResp.response.mem.pool;
1495    usta.hdr.transId = rgCb[inst].genCfg.ustaResp.transId;
1496
1497    return (RgMiLrgStaInd(&rgCb[inst].rgInit.lmPst, &usta));
1498 }
1499
1500 \f
1501 /**
1502  * @brief Layer Manager Trace Indication generation.
1503  *
1504  * @details
1505  *
1506  *     Function : rgLMMTrcInd
1507  *
1508  *     This API is used by the other modules of MAC to send a
1509  *     Trace indication to the Layer Manager.
1510  *
1511  *  @param[in]  Inst        inst
1512  *  @param[in]   Buffer *srcMbuf, the Message Buffer .
1513  *  @param[in]   uint8_t event, the trace event.
1514  *  @return Void
1515  **/
1516 Void rgLMMTrcInd
1517 (
1518 Inst   inst,
1519 Buffer *srcMbuf,    /* Message Buffer */
1520 uint8_t event            /* event */
1521 )
1522 {
1523    Buffer   *dstMbuf = NULLP;
1524    MsgLen   bufLen  = 0;
1525    Data     *tempBuf;
1526    MsgLen   tempCnt;
1527    RgMngmt  trc;
1528    Pst      pst;
1529
1530
1531
1532    if ((rgCb[inst].trcLen == LRG_NO_TRACE) || (srcMbuf == NULLP))
1533    {
1534       DU_LOG("\nERROR  -->  MAC : Trace Disabled.");
1535       return;
1536    }
1537
1538    memset(&trc, 0, sizeof(RgMngmt));
1539
1540    pst = rgCb[inst].rgInit.lmPst;
1541    pst.selector = rgCb[inst].genCfg.trcResp.response.selector;
1542    pst.prior = rgCb[inst].genCfg.trcResp.response.prior;
1543    pst.route = rgCb[inst].genCfg.trcResp.response.route;
1544    pst.region = rgCb[inst].genCfg.trcResp.response.mem.region;
1545    pst.pool = rgCb[inst].genCfg.trcResp.response.mem.pool;
1546
1547    trc.hdr.transId = rgCb[inst].genCfg.trcResp.transId;
1548
1549    SGetDateTime(&trc.t.trc.dt);
1550
1551    /* Check if the whole buffer is to be sent in Trace indication */
1552    if(rgCb[inst].trcLen == LRG_FULL_TRACE)
1553    {
1554       if (SCpyMsgMsg(srcMbuf, pst.region, pst.pool, &dstMbuf)
1555             != ROK)
1556       {
1557          DU_LOG("\nERROR  -->  MAC : SCpyMsgMsg Failed.");
1558          return;
1559       }
1560       trc.cfm.status = LCM_PRIM_OK;
1561       trc.cfm.reason = LCM_REASON_NOT_APPL;
1562       trc.t.trc.evnt = event;
1563
1564       /* Send Trace Indication to Layer manager */
1565       RgMiLrgTrcInd(&pst, &trc, dstMbuf);
1566    }
1567    /* check if only a specified number of bytes are to be sent */
1568    else if(rgCb[inst].trcLen > 0)
1569    {
1570       /* Get the length of the recvd message buffer */
1571       if (SFndLenMsg(srcMbuf, &bufLen) != ROK)
1572       {
1573          DU_LOG("\nERROR  -->  MAC : SFndLenMsg Failed.");
1574          return;
1575       }
1576       /* Check if the recvd buffer size is less than request trace len */
1577       if(bufLen < rgCb[inst].trcLen)
1578       {
1579          /* Copy the whole of the recvd buffer in trace indication */
1580
1581          if (SCpyMsgMsg(srcMbuf, pst.region, pst.pool, &dstMbuf)
1582                != ROK)
1583          {
1584             DU_LOG("\nERROR  -->  MAC : SCpyMsgMsg Failed.");
1585             return;
1586          }
1587
1588          trc.cfm.status = LCM_PRIM_OK;
1589          trc.cfm.reason = LCM_REASON_NOT_APPL;
1590          trc.t.trc.evnt = event;
1591
1592          /* Send Trace Indication to Layer manager */
1593          RgMiLrgTrcInd(&pst, &trc, dstMbuf);
1594       }
1595       /* if the recvd buffer size is greater than request trace len */
1596       if(bufLen >= rgCb[inst].trcLen)
1597       {
1598          /* Get a temporary buffer to store the msg */
1599          if (rgAllocSBuf(inst,&tempBuf, rgCb[inst].trcLen) != ROK)
1600          {
1601             DU_LOG("\nERROR  -->  MAC : rgAllocSBuf Failed.");
1602             return;
1603          }
1604
1605          /* Copy trcLen nos of bytes from the recvd message */
1606          if (SCpyMsgFix(srcMbuf,0,rgCb[inst].trcLen,tempBuf,&tempCnt) != ROK)
1607          {
1608             DU_LOG("\nERROR  -->  MAC : SCpyMsgFix Failed.");
1609             return;
1610          }
1611
1612          if (ODU_GET_MSG_BUF(pst.region, pst.pool, &dstMbuf) != ROK)
1613          {
1614             DU_LOG("\nERROR  -->  MAC : dstMbuf Allocation Failed");
1615             return;
1616          }
1617          /* Copy the tempBuf data to dst mBuf */
1618          if (SCpyFixMsg(tempBuf,dstMbuf,0,rgCb[inst].trcLen,&tempCnt) != ROK)
1619          {
1620             DU_LOG("\nERROR  -->  MAC : SCpyFixMsg Failed.");
1621             return;
1622          }
1623
1624          /*ccpu00117052 - MOD - Passing double pointer for proper NULLP
1625            assignment */
1626          /* Free the memory allocated for tempBuf */
1627          rgFreeSBuf(inst,&tempBuf, rgCb[inst].trcLen);
1628
1629          trc.cfm.status = LCM_PRIM_OK;
1630          trc.cfm.reason = LCM_REASON_NOT_APPL;
1631          trc.t.trc.evnt = event;
1632
1633          /* Send Trace Indication to Layer manager */
1634          RgMiLrgTrcInd(&pst, &trc, dstMbuf);
1635       }
1636    }
1637    return;
1638 }
1639
1640 \f
1641 /**
1642  * @brief Layer Manager Control Confirm generation handler
1643  *        for Bind Confirm reception at TFU interface.
1644  *        RgLiTfuBndCfm() forwards the confirmation to this
1645  *        function. All SAP state related handling is restricted
1646  *        to LMM modules, hence the cfm forwarding.
1647  *
1648  * @details
1649  *
1650  *     Function : rgLMMBndCfm
1651  *
1652  *     This API is used by the LIM module of MAC to forward
1653  *     the Bind Confirm it receives over the TFU interface.
1654  *
1655  *  @param[in]   Pst *pst, Post Structure
1656  *  @param[in]   SuId suId, Service user ID
1657  *  @param[in]   uint8_t status, Status
1658  *  @return  S16
1659  *      -# ROK
1660  **/
1661 S16 rgLMMBndCfm
1662 (
1663 Pst *pst,               /* Post Structure */
1664 SuId suId,              /* Service user ID */
1665 uint8_t status               /* Status */
1666 )
1667 {
1668    Inst      inst = pst->dstInst - RG_INST_START;
1669    S16       ret = ROK;
1670    RgMngmt   cntrlCfm;
1671    Pst       cfmPst;
1672
1673
1674    UNUSED(pst);
1675
1676    /* Check if the suId is valid */
1677    if(rgCb[inst].tfuSap.sapCfg.suId != suId)
1678    {
1679       DU_LOG("\nERROR  -->  MAC : Invalid SuId");
1680       return RFAILED;
1681    }
1682
1683    /* check the Sap State */
1684    switch(rgCb[inst].tfuSap.sapSta.sapState)
1685    {
1686       case LRG_WAIT_BNDCFM:
1687          break;
1688       case LRG_BND:
1689          /* SAP is already bound */
1690          return ROK;
1691       default:
1692          return RFAILED;
1693    }
1694
1695    cfmPst = rgCb[inst].rgInit.lmPst;
1696    cfmPst.selector = rgCb[inst].genCfg.bndCfmResp.response.selector;
1697    cfmPst.prior = rgCb[inst].genCfg.bndCfmResp.response.prior;
1698    cfmPst.route = rgCb[inst].genCfg.bndCfmResp.response.route;
1699    cfmPst.region = rgCb[inst].genCfg.bndCfmResp.response.mem.region;
1700    cfmPst.pool = rgCb[inst].genCfg.bndCfmResp.response.mem.pool;
1701
1702    memset(&cntrlCfm, 0, sizeof(RgMngmt));
1703
1704    switch(status)
1705    {
1706       case CM_BND_OK: /* status is OK */
1707          /* Change SAP state to Bound */
1708          rgCb[inst].tfuSap.sapSta.sapState = LRG_BND;
1709          if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
1710          {
1711             ret = rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
1712          }
1713          /* Send Control Confirm with status as OK to Layer Manager */
1714          cntrlCfm.cfm.status = LCM_PRIM_OK;
1715          cntrlCfm.cfm.reason = LCM_REASON_NOT_APPL;
1716          break;
1717
1718       default:
1719          /* Change SAP state to UnBound */
1720          rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
1721          if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
1722          {
1723             ret = rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
1724          }
1725          /* Send Control Confirm with status as NOK to Layer Manager */
1726          cntrlCfm.cfm.status = LCM_PRIM_NOK;
1727          cntrlCfm.cfm.reason = LCM_REASON_NEG_CFM;
1728          break;
1729    }
1730    rgCb[inst].tfuSap.numBndRetries = 0;
1731    cntrlCfm.hdr.elmId.elmnt = STTFUSAP;
1732    cntrlCfm.hdr.transId = rgCb[inst].genCfg.bndCfmResp.transId;
1733
1734    ret = RgMiLrgCntrlCfm(&cfmPst, &cntrlCfm);
1735
1736    return (ret);
1737 }
1738
1739 /**********************************************************************
1740
1741   End of file
1742  **********************************************************************/