rg_sch_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_sch_lmm.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_sch_lmm.c
  32 @brief This file contains the Layer Management interface module implementation for scheduler.
  33        The functions for the configuration, control, status and statistics
  34        request primitives are defined here.
  35 */
  36
  37
  38 /* header include files (.h) */
  39 #include "common_def.h"
  40 #include "rg_env.h"        /* MAC Environment Defines */
  41 #include "rgr.h"           /* RGR Interface defines */
  42 #include "tfu.h"           /* RGU Interface defines */
  43 #include "lrg.h"           /* LRG Interface defines */
  44 #include "rgm.h"           /* RGM Interface defines */
  45 #include "rg_sch.h"        /* Scheduler defines */
  46 #include "rg_sch_inf.h"        /* Scheduler defines */
  47 #include "rg_sch_err.h"        /* MAC error defines */
  48 #ifdef LTE_L2_MEAS
  49 #include "rg_sch_cmn.h"    /* typedefs for Scheduler */
  50 #endif
  51 #include "sch_utils.h"
  52 /* header/extern include files (.x) */
  53 #include "rgr.x"           /* RGR Interface includes */
  54 #include "rgm.x"           /* RGM Interface includes */
  55 #include "tfu.x"           /* RGU Interface includes */
  56 #include "lrg.x"           /* LRG Interface includes */
  57 #include "rg_sch_inf.x"    /* Scheduler defines */
  58 #include "rg_sch.x"        /* Scheduler includes */
  59 #ifdef LTE_L2_MEAS
  60 #include "rg_sch_cmn.x"    /* typedefs for Scheduler */
  61 #endif
  62 #ifndef LTE_L2_MEAS
  63 Void rgSCHCmnInit ARGS((Void));
  64 #endif
  65 /* forward references */
  66 extern int schActvInit(Ent entity, Inst instId, Region region, Reason reason);
  67 #ifdef UNUSE_FUN
  68 static uint16_t rgSCHLmmSapCfg ARGS((
  69    Inst           inst,
  70    RgCfg          *cfg,
  71    uint8_t             sapIdx,
  72    Elmnt          sapType
  73 ));
  74 #endif
  75 static Void rgSCHLmmShutdown ARGS((
  76    Inst inst
  77 ));
  78
  79
  80 void printSchCellInfo(void)
  81 {
  82    uint8_t idx=0;
  83    uint8_t inst=0;
  84    for (idx = 0; idx < rgSchCb[inst].numSaps; idx++)
  85    {
  86       /* Unbind all the TFU SAP */
  87       /* Free the memory held by the cell associated
  88        * with this SAP */
  89       if (rgSchCb[inst].tfuSap[idx].cell != NULLP)
  90       {
  91          DU_LOG("\nINFO  -->  SCH : CELL %d\n", idx);
  92          DU_LOG("\nINFO  -->  SCH : NUM UEs :%d\n",rgSchCb[inst].tfuSap[idx].cell->ueLst.nmbEnt);
  93       }
  94    }
  95 }
  96
  97 /**
  98  * @brief SAP Configuration Handler.
  99  *
 100  * @details
 101  *
 102  *     Function : rgSCHLmmSapCfg
 103  *
 104  *     This function in called by SchProcGenCfgReq(). It handles the
 105  *     interface SAP configuration of the scheduler instance. It
 106  *     initializes the sapState to LRG_UNBND. Returns
 107  *     reason for success/failure of this function.
 108  *
 109  *  @param[in]  RgCfg *cfg, the Configuaration information
 110  *  @return  uint16_t
 111  *      -# LCM_REASON_GENCFG_NOT_DONE
 112  *      -# LCM_REASON_INVALID_SAP
 113  *      -# LCM_REASON_NOT_APPL
 114  **/
 115 #ifdef UNUSE_FUN
 116 static uint16_t rgSCHLmmSapCfg
 117 (
 118 Inst  dInst,
 119 RgCfg *cfg,            /* Configuaration information */
 120 uint8_t sapIdx,          /* SAP index */
 121 Elmnt sapType             /* SAP Type */
 122 )
 123 {
 124    uint16_t                  ret = LCM_REASON_NOT_APPL;
 125    RgSchLowSapCfgInfo   *lowSapCfg = NULLP;
 126    RgSchUpSapCfgInfo    *upSapCfg = NULLP;
 127    Inst  inst = (dInst - SCH_INST_START);
 128
 129    /* Check if Gen Config has been done */
 130
 131    switch(sapType)
 132    {
 133       case STRGRSAP:
 134 #ifndef CL_MAC_LWLC
 135          if ((cfg->s.schInstCfg.rgrSap[sapIdx].selector != ODU_SELECTOR_TC) &&
 136              (cfg->s.schInstCfg.rgrSap[sapIdx].selector != ODU_SELECTOR_LC))
 137          {
 138             ret = LCM_REASON_INVALID_PAR_VAL;
 139             DU_LOG("\nERROR  -->  SCH : rgSCHLmmSapCfg(): unsupported"
 140                " Selector value for RGR.");
 141             break;
 142          }
 143 #endif
 144          if(rgSchCb[inst].rgrSap[sapIdx].sapSta.sapState == LRG_NOT_CFG)
 145          {
 146             rgSchCb[inst].rgrSap[sapIdx].sapSta.sapState = LRG_UNBND;
 147          }
 148          upSapCfg = &rgSchCb[inst].rgrSap[sapIdx].sapCfg;
 149
 150          upSapCfg->sapPst.dstEnt = cfg->s.schInstCfg.rgrSap[sapIdx].ent;
 151          upSapCfg->sapPst.dstInst = cfg->s.schInstCfg.rgrSap[sapIdx].inst;
 152          upSapCfg->sapPst.dstProcId = cfg->s.schInstCfg.rgrSap[sapIdx].procId;
 153          upSapCfg->sapPst.srcEnt = rgSchCb[inst].rgSchInit.ent;
 154          upSapCfg->sapPst.srcInst = rgSchCb[inst].rgSchInit.inst +
 155          SCH_INST_START;
 156          upSapCfg->sapPst.srcProcId = rgSchCb[inst].rgSchInit.procId;
 157          upSapCfg->sapPst.region = cfg->s.schInstCfg.rgrSap[sapIdx].mem.region;
 158          upSapCfg->sapPst.pool = cfg->s.schInstCfg.rgrSap[sapIdx].mem.pool;
 159          upSapCfg->sapPst.selector = cfg->s.schInstCfg.rgrSap[sapIdx].selector;
 160          upSapCfg->sapPst.route = cfg->s.schInstCfg.rgrSap[sapIdx].route;
 161          upSapCfg->sapPst.intfVer = 0;
 162          upSapCfg->sapPst.event = 0;
 163          upSapCfg->sapPst.prior = cfg->s.schInstCfg.rgrSap[sapIdx].prior;
 164          upSapCfg->suId = cfg->s.schInstCfg.rgrSap[sapIdx].suId;
 165          upSapCfg->spId = cfg->s.schInstCfg.rgrSap[sapIdx].spId;
 166          break;
 167       case STTFUSAP:
 168 #ifndef CL_MAC_LWLC
 169          if ((cfg->s.schInstCfg.tfuSap[sapIdx].selector != ODU_SELECTOR_TC) &&
 170              (cfg->s.schInstCfg.tfuSap[sapIdx].selector != ODU_SELECTOR_LC))
 171          {
 172             ret = LCM_REASON_INVALID_PAR_VAL;
 173             DU_LOG("\nERROR  -->  SCH : rgSCHLmmSapCfg(): unsupported"
 174                      " Selector value for TFU.");
 175             break;
 176          }
 177 #endif
 178          if (rgSchCb[inst].tfuSap[sapIdx].sapSta.sapState == LRG_NOT_CFG)
 179          {
 180             rgSchCb[inst].tfuSap[sapIdx].sapSta.sapState = LRG_UNBND;
 181          }
 182          /* Initialize the  sap timer */
 183          cmInitTimers(&(rgSchCb[inst].tfuSap[sapIdx].tmrBlk), 1);
 184          lowSapCfg = &rgSchCb[inst].tfuSap[sapIdx].sapCfg;
 185
 186          lowSapCfg->sapPst.dstEnt = cfg->s.schInstCfg.tfuSap[sapIdx].ent;
 187          lowSapCfg->sapPst.dstInst = cfg->s.schInstCfg.tfuSap[sapIdx].inst;
 188          lowSapCfg->sapPst.dstProcId = cfg->s.schInstCfg.tfuSap[sapIdx].procId;
 189          lowSapCfg->sapPst.srcEnt = rgSchCb[inst].rgSchInit.ent;
 190          lowSapCfg->sapPst.srcInst = rgSchCb[inst].rgSchInit.inst +
 191          SCH_INST_START;
 192          lowSapCfg->sapPst.srcProcId = rgSchCb[inst].rgSchInit.procId;
 193          lowSapCfg->sapPst.region = cfg->s.schInstCfg.tfuSap[sapIdx].mem.region;
 194          lowSapCfg->sapPst.pool = cfg->s.schInstCfg.tfuSap[sapIdx].mem.pool;
 195          lowSapCfg->sapPst.selector = cfg->s.schInstCfg.tfuSap[sapIdx].selector;
 196          lowSapCfg->sapPst.route = cfg->s.schInstCfg.tfuSap[sapIdx].route;
 197          lowSapCfg->sapPst.intfVer = 0;
 198           lowSapCfg->sapPst.event = 0;
 199          lowSapCfg->sapPst.prior = cfg->s.schInstCfg.tfuSap[sapIdx].prior;
 200          lowSapCfg->suId = cfg->s.schInstCfg.tfuSap[sapIdx].suId;
 201          lowSapCfg->spId = cfg->s.schInstCfg.tfuSap[sapIdx].spId;
 202          memcpy(&lowSapCfg->bndTmr,
 203                   &cfg->s.schInstCfg.tfuSap[sapIdx].bndTmr,
 204                   sizeof(TmrCfg));
 205          break;
 206       case STRGMSAP:
 207 #ifndef RGM_LWLC
 208          if ((cfg->s.schInstCfg.rgmSap[sapIdx].selector != RGM_SEL_LWLC) &&
 209              (cfg->s.schInstCfg.rgmSap[sapIdx].selector != RGM_SEL_LC) &&
 210              (cfg->s.schInstCfg.rgmSap[sapIdx].selector != RGM_SEL_TC))
 211          {
 212             ret = LCM_REASON_INVALID_PAR_VAL;
 213             DU_LOG("\nERROR  -->  SCH : rgSCHLmmSapCfg(): unsupported"
 214                      " Selector value for RGM.");
 215             break;
 216          }
 217 #endif
 218          if (rgSchCb[inst].rgmSap[sapIdx].sapSta.sapState == LRG_NOT_CFG)
 219          {
 220             rgSchCb[inst].rgmSap[sapIdx].sapSta.sapState = LRG_UNBND;
 221          }
 222          upSapCfg = &rgSchCb[inst].rgmSap[sapIdx].sapCfg;
 223          upSapCfg->sapPst.dstEnt = cfg->s.schInstCfg.rgmSap[sapIdx].ent;
 224          upSapCfg->sapPst.dstInst = cfg->s.schInstCfg.rgmSap[sapIdx].inst;
 225          upSapCfg->sapPst.dstProcId = cfg->s.schInstCfg.rgmSap[sapIdx].procId;
 226          upSapCfg->sapPst.srcEnt = rgSchCb[inst].rgSchInit.ent;
 227          upSapCfg->sapPst.srcInst = rgSchCb[inst].rgSchInit.inst +
 228          SCH_INST_START;
 229          upSapCfg->sapPst.srcProcId = rgSchCb[inst].rgSchInit.procId;
 230          upSapCfg->sapPst.region = cfg->s.schInstCfg.rgmSap[sapIdx].mem.region;
 231          upSapCfg->sapPst.pool = cfg->s.schInstCfg.rgmSap[sapIdx].mem.pool;
 232          upSapCfg->sapPst.selector = cfg->s.schInstCfg.rgmSap[sapIdx].selector;
 233          upSapCfg->sapPst.route = cfg->s.schInstCfg.rgmSap[sapIdx].route;
 234          upSapCfg->sapPst.intfVer = 0;
 235          upSapCfg->sapPst.event = 0;
 236          upSapCfg->sapPst.prior = cfg->s.schInstCfg.rgmSap[sapIdx].prior;
 237          upSapCfg->suId = cfg->s.schInstCfg.rgmSap[sapIdx].suId;
 238          upSapCfg->spId = cfg->s.schInstCfg.rgmSap[sapIdx].spId;
 239
 240          break;
 241       default:
 242          /* would never reach here */
 243          break;
 244    }
 245    return (ret);
 246 }
 247 #endif
 248 \f
 249 /***********************************************************
 250  *
 251  *     Func : rgSCHLmmShutdown
 252  *
 253  *
 254  *     Desc : Handles the scheduler instance shutdown request. Calls
 255  *     rgSCHCfgFreeCellCb(RgSchCellCb*) to handle each cellCb deallocation.
 256  *
 257  *
 258  *     Ret  : Void
 259  *
 260  *     Notes:
 261  *
 262  *     File : rg_sch_lmm.c
 263  *
 264  **********************************************************/
 265 static Void rgSCHLmmShutdown(Inst inst)
 266 {
 267    Inst          dInst = inst + SCH_INST_START;
 268    uint8_t       idx;
 269 #ifdef LTE_L2_MEAS
 270    CmLList       *lnk = NULLP;
 271    RgSchCb       *instCb =  &rgSchCb[inst];
 272    RgSchCellCb   *cell = NULLP;
 273    RgSchL2MeasCb *measCb;
 274    uint8_t       ulAllocIdx;
 275    RgSchCmnUlCell *cellUl;
 276    RgSchClcBoRpt  *bo = NULL;
 277 #endif
 278
 279 #ifdef LTE_L2_MEAS
 280    for (idx = 0; idx < instCb->numSaps; idx++)
 281    {
 282      /* got the cell break the loop */
 283      cell = instCb->rgrSap[idx].cell;
 284      if(cell != NULLP)
 285      {
 286         /* Free the memory held up by  ulAllocInfo */
 287         cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
 288 #ifdef LTE_TDD
 289         for(ulAllocIdx = 0; ulAllocIdx < RGSCH_SF_ALLOC_SIZE; ulAllocIdx++)
 290 #else
 291         for(ulAllocIdx = 0; ulAllocIdx < RGSCH_NUM_SUB_FRAMES; ulAllocIdx++)
 292 #endif
 293         {
 294            if(cell->sfAllocArr[ulAllocIdx].ulUeInfo.ulAllocInfo != NULLP)
 295            {
 296              /* ccpu00117052 - MOD - Passing double pointer
 297              for proper NULLP assignment*/
 298              rgSCHUtlFreeSBuf(cell->instIdx,
 299                     (Data **)(&(cell->sfAllocArr[ulAllocIdx].ulUeInfo.\
 300                                 ulAllocInfo)),
 301                     cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc));
 302            }
 303         }
 304         /* Free the memory allocated to measCb */
 305         lnk = cell->l2mList.first;
 306         while(lnk != NULLP)
 307         {
 308            measCb = (RgSchL2MeasCb *)lnk->node;
 309            cmLListDelFrm(&cell->l2mList, lnk);
 310            lnk = lnk->next;
 311              /* ccpu00117052 - MOD - Passing double pointer
 312              for proper NULLP assignment*/
 313            rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,\
 314                           sizeof(RgSchL2MeasCb));
 315         }
 316
 317         /* Free mem if any present for boLst for common channels */
 318         for(idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
 319         {
 320            lnk = (CmLList *)cell->cmnLcCb[idx].boLst.first;
 321            while (lnk)
 322            {
 323               bo = (RgSchClcBoRpt *)(lnk->node);
 324               lnk = lnk->next;
 325               cmLListDelFrm(&cell->cmnLcCb[idx].boLst, &bo->boLstEnt);
 326               rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
 327            }
 328         }
 329      }
 330    }
 331 #endif
 332
 333 #ifdef LTE_ADV
 334    rgSCHLaaDeInitEnbCb(&rgSchCb[inst]);
 335 #endif
 336    for (idx = 0; idx < rgSchCb[inst].numSaps; idx++)
 337    {
 338       /* Unbind all the TFU SAP */
 339       if(rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_WAIT_BNDCFM)
 340       {
 341          //rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg, LRG_UNBND);
 342          if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
 343          {
 344             rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR, (PTR)&rgSchCb[inst].tfuSap[idx]);
 345          }
 346          rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_UNBND;
 347       }
 348       if(rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_BND)
 349       {
 350          //rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg, LRG_UNBND);
 351          rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_UNBND;
 352       }
 353       /* Free the memory held by the cell associated with this SAP */
 354       if (rgSchCb[inst].tfuSap[idx].cell != NULLP)
 355          rgSCHCfgFreeCellCb(rgSchCb[inst].tfuSap[idx].cell);
 356       rgSchCb[inst].tfuSap[idx].cell = NULLP;
 357    }
 358    /* Free the memory held by the scheduler instance */
 359    /* Deallocate RGR saps */
 360    SCH_FREE(rgSchCb[inst].rgrSap,
 361                 (sizeof(RgSchUpSapCb) * rgSchCb[inst].numSaps));
 362    rgSchCb[inst].rgrSap = NULLP;
 363    /* Deallocate RGM saps */
 364    SCH_FREE(rgSchCb[inst].rgmSap,
 365                 (sizeof(RgSchUpSapCb) * rgSchCb[inst].numSaps));
 366    rgSchCb[inst].rgmSap = NULLP;
 367
 368    /* Deallocate TFU saps */
 369    SCH_FREE(rgSchCb[inst].tfuSap,
 370                 (sizeof(RgSchLowSapCb) * rgSchCb[inst].numSaps));
 371    rgSchCb[inst].tfuSap = NULLP;
 372
 373    /* Deallocate bndCfmResponses */
 374    SCH_FREE(rgSchCb[inst].genCfg.bndCfmResp,
 375                 (sizeof(RgSchLmResponse) * rgSchCb[inst].numSaps));
 376    rgSchCb[inst].genCfg.bndCfmResp = NULLP;
 377    /* De-register the Timer Service */
 378    (Void) SDeregTmrMt(rgSchCb[inst].rgSchInit.ent, dInst,
 379                      (S16)rgSchCb[inst].genCfg.tmrRes, schActvTmr);
 380
 381    /* call back the task initialization function to intialize
 382     * the global rgSchCb[inst] Struct */
 383    schActvInit(rgSchCb[inst].rgSchInit.ent, dInst, rgSchCb[inst].rgSchInit.region,
 384               rgSchCb[inst].rgSchInit.reason);
 385
 386    /* Set Config done in TskInit */
 387    rgSchCb[inst].rgSchInit.cfgDone = FALSE;
 388
 389    return;
 390 }
 391
 392 \f
 393 /***********************************************************
 394  *
 395  *     Func : rgSCHLmmGenCntrl
 396  *
 397  *
 398  *     Desc : Processes the LM control request for STGEN elmnt.
 399  *
 400  *
 401  *     Ret  : Void
 402  *
 403  *     Notes:
 404  *
 405  *     File : rg_sch_lmm.c
 406  *
 407  **********************************************************/
 408 Void rgSCHLmmGenCntrl(RgMngmt *cntrl,RgMngmt *cfm,Pst  *cfmPst)
 409 {
 410    Inst      inst = (cfmPst->srcInst - SCH_INST_START); /* Scheduler instance ID */
 411
 412    cfm->cfm.status = LCM_PRIM_OK;
 413    cfm->cfm.reason = LCM_REASON_NOT_APPL;
 414
 415
 416    switch(cntrl->t.cntrl.action)
 417    {
 418       case AENA:
 419          /* Action is Enable */
 420          switch(cntrl->t.cntrl.subAction)
 421          {
 422             case SAUSTA:
 423             /* Enable Unsolicited Status (alarms) */
 424                rgSchCb[inst].rgSchInit.usta = TRUE;
 425                /*Store the response and TransId for sending the Alarms */
 426                memcpy(&rgSchCb[inst].genCfg.ustaResp.response,
 427                &cntrl->hdr.response, sizeof(Resp));
 428                rgSchCb[inst].genCfg.ustaResp.transId = cntrl->hdr.transId;
 429                break;
 430             case SADBG:
 431             /* Enable Debug Printing */
 432 #ifdef DEBUGP
 433                rgSchCb[inst].rgSchInit.dbgMask |= cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
 434 #endif
 435                break;
 436 #ifdef PHY_ERROR_LOGING
 437             case SAELMNT:
 438                {
 439                   rgSchUlAllocCntr.mcs = cntrl->t.cntrl.s.rgSchUlAllocCntrl.mcs;
 440                   rgSchUlAllocCntr.numOfRb = cntrl->t.cntrl.s.rgSchUlAllocCntrl.numOfRb;
 441                   rgSchUlAllocCntr.rbStart = cntrl->t.cntrl.s.rgSchUlAllocCntrl.rbStart;
 442                   rgSchUlAllocCntr.testStart = cntrl->t.cntrl.s.rgSchUlAllocCntrl.testStart;
 443                   rgSchUlAllocCntr.enaLog = cntrl->t.cntrl.s.rgSchUlAllocCntrl.enaLog;
 444                   rgSchUlAllocCntr.logTime = cntrl->t.cntrl.s.rgSchUlAllocCntrl.logTime;
 445                   rgSchUlAllocCntr.crcOk = 0;
 446                   rgSchUlAllocCntr.crcErr = 0;
 447                   rgSchUlAllocCntr.numUlPackets = 0;
 448                   rgSchUlAllocCntr.numPrach = 0;
 449                   rgSchUlAllocCntr.taZero = 0;
 450 #ifdef MAC_SCH_STATS
 451                   /* Reset
 452                    * L2
 453                    * statistics
 454                    * */
 455                   memset(&hqRetxStats, 0, sizeof(RgSchHqRetxStats));
 456                   memset(&hqFailStats, 0, sizeof(RgSchNackAckStats));
 457 #endif
 458                   break;
 459                }
 460 #endif
 461             default:
 462                cfm->cfm.status = LCM_PRIM_NOK;
 463                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
 464                DU_LOG("\nERROR  -->  SCH : rgSCHLmmGenCntrl(): "
 465                   "invalid subaction=%d", cntrl->t.cntrl.subAction);
 466                break;
 467          }
 468          break;
 469       case ADISIMM:
 470          /* Action is Diable immidiately */
 471          switch(cntrl->t.cntrl.subAction)
 472          {
 473             case SAUSTA:
 474             /* Disable Unsolicited Status (alarms) */
 475                rgSchCb[inst].rgSchInit.usta = FALSE;
 476                break;
 477             case SADBG:
 478             /* Disable Debug Printing */
 479 #ifdef DEBUGP
 480                rgSchCb[inst].rgSchInit.dbgMask &=\
 481                           ~cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
 482 #endif
 483                break;
 484
 485             default:
 486                cfm->cfm.status = LCM_PRIM_NOK;
 487                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
 488                DU_LOG("\nERROR  -->  SCH : rgSCHLmmGenCntrl():"
 489                  " invalid subaction=%d", cntrl->t.cntrl.subAction);
 490                break;
 491          }
 492          break;
 493       case ASHUTDOWN:
 494          /* Free all the memory dynamically allocated by MAC */
 495          rgSCHLmmShutdown(inst);
 496          break;
 497       default:
 498          cfm->cfm.status = LCM_PRIM_NOK;
 499          cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
 500          DU_LOG("\nERROR  -->  SCH : rgSCHLmmGenCntrl(): invalid"
 501           " action=%d", cntrl->t.cntrl.action);
 502          break;
 503    }
 504    RgMiLrgSchCntrlCfm(cfmPst, cfm);
 505    return;
 506 }
 507
 508 \f
 509 /***********************************************************
 510  *
 511  *     Func : rgSCHLmmSapCntrl
 512  *
 513  *
 514  *     Desc : Processes the LM control request for STxxxSAP elmnt.
 515  *
 516  *
 517  *     Ret  : Void
 518  *
 519  *     Notes:
 520  *
 521  *     File : rg_sch_lmm.c
 522  *
 523  **********************************************************/
 524 Void rgSCHLmmSapCntrl
 525 (
 526 RgMngmt       *cntrl,
 527 RgMngmt       *cfm,
 528 Pst           *cfmPst
 529 )
 530 {
 531    uint8_t       idx;
 532
 533    /* TODO Pass InstId instead of using InstId from cfmPst */
 534    Inst      inst = (cfmPst->srcInst - SCH_INST_START); /* Scheduler instance Id */
 535
 536    /* Only TFU SAP can be controlled by LM */
 537    switch(cntrl->hdr.elmId.elmnt)
 538    {
 539       case STTFUSAP:
 540          idx = (uint8_t)cntrl->t.cntrl.s.rgSapCntrl.suId;
 541          if (idx > LRG_MAX_SAPS_PER_INST)
 542          {
 543             cfm->cfm.status = LCM_PRIM_NOK;
 544             cfm->cfm.reason = LCM_REASON_INVALID_SAP;
 545          }
 546          switch(cntrl->t.cntrl.action)
 547          {
 548             case ABND:
 549                /* Bind Enable Request */
 550                if ((rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_NOT_CFG) ||
 551                    (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_BND))
 552                {
 553                   cfm->cfm.status = LCM_PRIM_NOK;
 554                   cfm->cfm.reason = LCM_REASON_INVALID_SAP;
 555                }
 556                else
 557                {
 558                   if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
 559                   {
 560                      rgSCHLmmStartTmr(inst, RGSCH_BNDREQ_TMR,
 561                                   rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.val,
 562                                   (PTR)&rgSchCb[inst].tfuSap[idx]);
 563                   }
 564                   /* Change SAP state */
 565                   rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_WAIT_BNDCFM;
 566                   rgSchCb[inst].tfuSap[idx].numBndRetries++;
 567                   /* Store the response and TransId for sending
 568                    * the Control confirm */
 569                   memcpy(&rgSchCb[inst].genCfg.bndCfmResp[idx].response,
 570                            &cntrl->hdr.response, sizeof(Resp));
 571                   rgSchCb[inst].genCfg.bndCfmResp[idx].transId =
 572                                                 cntrl->hdr.transId;
 573
 574                   cfm->cfm.status = LCM_PRIM_OK_NDONE;
 575                   cfm->cfm.reason = LCM_REASON_NOT_APPL;
 576
 577                   /* Sending Control Confirm before sending Bind
 578                    * Request to TFU  */
 579                   RgMiLrgSchCntrlCfm(cfmPst, cfm);
 580
 581                   //rgSCHUtlTfuBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg.suId,
 582                     //             rgSchCb[inst].tfuSap[idx].sapCfg.spId);
 583                  return;
 584                }
 585                break;
 586             case AUBND:
 587             /* Unbind request */
 588
 589                /* Check if the SAP is configured */
 590                if( (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_NOT_CFG) ||
 591                      (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_UNBND))
 592                {
 593                   cfm->cfm.status = LCM_PRIM_NOK;
 594                   cfm->cfm.reason = LCM_REASON_INVALID_MSGTYPE;
 595                }
 596                else
 597                {
 598                   //rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg,
 599                     //              TFU_UBNDREQ_MNGMT);
 600                   if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
 601                   {
 602                      rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR,
 603                                        (PTR)&rgSchCb[inst].tfuSap[idx]);
 604                   }
 605                   /* Change SAP state */
 606                   rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_UNBND;
 607                   cfm->cfm.status = LCM_PRIM_OK;
 608                   cfm->cfm.reason = LCM_REASON_NOT_APPL;
 609                }
 610                break;
 611             case ADEL:
 612                /* Delete SAP, does initialization of SAP */
 613                if ((rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_WAIT_BNDCFM) ||
 614                    (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_BND))
 615                {
 616                   //rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg,
 617                     //              TFU_UBNDREQ_MNGMT);
 618                   if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
 619                   {
 620                      rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR,
 621                                      (PTR)&rgSchCb[inst].tfuSap[idx]);
 622                   }
 623                }
 624                memset(&rgSchCb[inst].tfuSap[idx], 0, sizeof(RgSchLowSapCb));
 625                rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_NOT_CFG;
 626                cfm->cfm.status = LCM_PRIM_OK;
 627                cfm->cfm.reason = LCM_REASON_NOT_APPL;
 628                break;
 629             default:
 630                cfm->cfm.status = LCM_PRIM_NOK;
 631                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
 632                DU_LOG("\nERROR  -->  SCH : rgSCHLmmSapCntrl(): "
 633                   "invalid action=%d", cntrl->t.cntrl.action);
 634                break;
 635          }
 636          break;
 637       case STRGRSAP:
 638          idx = (uint8_t)cntrl->t.cntrl.s.rgSapCntrl.spId;
 639          if (idx > LRG_MAX_SAPS_PER_INST)
 640          {
 641             cfm->cfm.status = LCM_PRIM_NOK;
 642             cfm->cfm.reason = LCM_REASON_INVALID_SAP;
 643          }
 644          switch(cntrl->t.cntrl.action)
 645          {
 646             case ADEL:
 647                memset(&rgSchCb[inst].rgrSap[idx], 0, sizeof(RgSchUpSapCb));
 648                rgSchCb[inst].rgrSap[idx].sapSta.sapState = LRG_NOT_CFG;
 649                cfm->cfm.status = LCM_PRIM_OK;
 650                cfm->cfm.reason = LCM_REASON_NOT_APPL;
 651                break;
 652             default:
 653                cfm->cfm.status = LCM_PRIM_NOK;
 654                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
 655                DU_LOG("\nERROR  -->  SCH : rgSCHLmmSapCntrl(): "
 656                      "invalid action=%d", cntrl->t.cntrl.action);
 657                break;
 658          }
 659          break;
 660       case STRGMSAP:
 661          idx = (uint8_t)cntrl->t.cntrl.s.rgSapCntrl.spId;
 662          if (idx > LRG_MAX_SAPS_PER_INST)
 663          {
 664             cfm->cfm.status = LCM_PRIM_NOK;
 665             cfm->cfm.reason = LCM_REASON_INVALID_SAP;
 666          }
 667          switch(cntrl->t.cntrl.action)
 668          {
 669             case ADEL:
 670                memset(&rgSchCb[inst].rgmSap[idx], 0, sizeof(RgSchUpSapCb));
 671                rgSchCb[inst].rgmSap[idx].sapSta.sapState = LRG_NOT_CFG;
 672                cfm->cfm.status = LCM_PRIM_OK;
 673                cfm->cfm.reason = LCM_REASON_NOT_APPL;
 674                break;
 675             default:
 676                cfm->cfm.status = LCM_PRIM_NOK;
 677                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
 678                DU_LOG("\nERROR  -->  SCH : rgSCHLmmSapCntrl(): "
 679                      "invalid action=%d", cntrl->t.cntrl.action);
 680                break;
 681          }
 682          break;
 683
 684        default:
 685          /* Would never come here. */
 686          return;
 687    }
 688    RgMiLrgSchCntrlCfm(cfmPst, cfm);
 689    return;
 690 }
 691
 692 \f
 693 /***********************************************************
 694  *
 695  *     Func : SchFillCfmPst
 696  *
 697  *
 698  *     Desc : Fills the Confirmation Post Structure cfmPst using the reqPst
 699  *            and the cfm->hdr.response.
 700  *
 701  *
 702  *     Ret  : Void
 703  *
 704  *     Notes:
 705  *
 706  *     File : rg_sch_lmm.c
 707  *
 708  **********************************************************/
 709 Void SchFillCfmPst
 710 (
 711 Pst           *reqPst,
 712 Pst           *cfmPst,
 713 RgMngmt       *cfm
 714 )
 715 {
 716    Inst inst;
 717
 718    inst = (reqPst->dstInst - SCH_INST_START);
 719
 720    cfmPst->srcEnt    = ENTMAC;
 721    cfmPst->srcInst   = (Inst) 1;
 722    cfmPst->srcProcId = rgSchCb[inst].rgSchInit.procId;
 723    cfmPst->dstEnt    = ENTMAC;
 724    cfmPst->dstInst   = (Inst) 0;
 725    cfmPst->dstProcId = reqPst->srcProcId;
 726
 727    cfmPst->selector  = cfm->hdr.response.selector;
 728    cfmPst->region    = cfm->hdr.response.mem.region;
 729    cfmPst->pool      = cfm->hdr.response.mem.pool;
 730
 731    return;
 732 }
 733
 734 \f
 735 /**
 736  * @brief Timer start handler.
 737  *
 738  * @details
 739  *
 740  *     Function : rgSCHLmmStartTmr
 741  *
 742  *     This function based on the input parameters starts the timer for
 743  *     "tmrVal" duration. As of now scheduler instance uses the timer
 744  *     functionality for BndReq only. Hence there is no conditional
 745  *     code based on "tmrEvnt".
 746  *
 747  *  @param[in]  S16   tmrEvnt, the Timer Event
 748  *  @param[in]  uint32_t   tmrVal,  the Wait Time
 749  *  @param[in]  PTR   cb,  Entry for which Timer expired
 750  *  @return  S16
 751  *      -# ROK
 752  **/
 753 S16 rgSCHLmmStartTmr
 754 (
 755 Inst       inst,
 756 S16        tmrEvnt,            /* Timer Event */
 757 uint32_t   tmrVal,             /* Wait Time */
 758 PTR        cb                  /* Entry for which Timer Expired */
 759 )
 760 {
 761    CmTmrArg    arg;
 762 /*   Inst        dInst = inst + SCH_INST_START; */
 763
 764    UNUSED(tmrEvnt);
 765
 766    /* Initialize the arg structure */
 767    memset(&arg, 0, sizeof(CmTmrArg));
 768
 769    arg.tqCp = &rgSchCb[inst].tmrTqCp;
 770    arg.tq = rgSchCb[inst].tmrTq;
 771    arg.timers = &((RgSchLowSapCb *)cb)->tmrBlk;
 772    arg.cb = cb;
 773    arg.tNum = 0;
 774    arg.max = RGSCH_MAX_TIMER;
 775    arg.evnt = RGSCH_BNDREQ_TMR;
 776    arg.wait = tmrVal;
 777    cmPlcCbTq(&arg);
 778
 779    return ROK;
 780 }
 781
 782 \f
 783 /**
 784  * @brief Timer stop handler.
 785  *
 786  * @details
 787  *
 788  *     Function : rgSCHLmmStopTmr
 789  *
 790  *     This function based on the input parameters stops the timer for
 791  *     "tmrEvnt". As of now Scheduler instance uses the timer functionality for
 792  *     BndReq only. Hence there is no conditional code based on "tmrEvnt".
 793  *     Once the bind happens and this timer is stopped, the timer functionality
 794  *     is deregistered with SSI. As there is no further use of timer processing.
 795  *
 796  *  @param[in]  S16   tmrEvnt, the Timer Event
 797  *  @param[in]  PTR   cb,  Entry for which Timer expired
 798  *  @return  S16
 799  *      -# ROK
 800  *      -# RFAILED
 801  **/
 802 S16 rgSCHLmmStopTmr
 803 (
 804 Inst inst,             /* Scheduler instance */
 805 S16  tmrEvnt,            /* Timer Event */
 806 PTR  cb                  /* Entry for which Timer Expired */
 807 )
 808 {
 809    CmTmrArg   arg;
 810    uint8_t    i;
 811    S16        ret;
 812
 813    ret = RFAILED;
 814
 815    for(i=0;i<RGSCH_MAX_TIMER;i++)
 816    {
 817       /* Search for the Timer Blocks */
 818       if(((RgSchLowSapCb *)cb)->tmrBlk.tmrEvnt == tmrEvnt)
 819       {
 820          /* Initialize the arg structure */
 821          memset(&arg, 0, sizeof(CmTmrArg));
 822
 823          arg.tqCp = &rgSchCb[inst].tmrTqCp;
 824          arg.tq = rgSchCb[inst].tmrTq;
 825          arg.timers = &(((RgSchLowSapCb *)cb)->tmrBlk);
 826          arg.cb = cb;
 827          arg.max = RGSCH_MAX_TIMER;
 828          arg.evnt = tmrEvnt;
 829
 830          arg.tNum = i;
 831          cmRmvCbTq(&arg);
 832          ret = ROK;
 833          break;
 834       }
 835
 836    }
 837
 838
 839    return (ret);
 840 }
 841
 842 \f
 843 /**
 844  * @brief Timer Expiry handler.
 845  *
 846  * @details
 847  *
 848  *     Function : rgSCHLmmTmrExpiry
 849  *
 850  *     This is a callback function used as an input parameter to cmPrcTmr()
 851  *     to check expiry of any timer. In this function, we are only concerned
 852  *     about tmrEvnt=Bind timer.
 853  *
 854  *  @param[in]  PTR   cb,  Entry for which Timer expired
 855  *  @param[in]  S16   tmrEvnt, the Timer Event
 856  *  @return  S16
 857  *      -# ROK
 858  **/
 859 S16 rgSCHLmmTmrExpiry
 860 (
 861 PTR cb,               /* Pointer to timer control block */
 862 S16 tmrEvnt           /* Timer Event */
 863 )
 864 {
 865    S16           ret = ROK;
 866    RgSchLowSapCb *tfuSap = (RgSchLowSapCb *)cb;
 867
 868
 869    switch(tmrEvnt)
 870    {
 871       case RGSCH_BNDREQ_TMR:
 872          tfuSap->numBndRetries++;
 873          if(tfuSap->numBndRetries > RGSCH_MAX_BNDRETRY)
 874          {
 875             rgSCHLmmStaInd((uint8_t)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
 876                            (uint16_t)LCM_CATEGORY_INTERFACE, (uint16_t)LCM_EVENT_BND_FAIL,
 877                            (uint16_t)LCM_CAUSE_TMR_EXPIRED, (RgUstaDgn *)NULLP);
 878          }
 879          else
 880          {
 881             /* Restart the bind timer */
 882             if (tfuSap->sapCfg.bndTmr.enb == TRUE)
 883             {
 884                ret = rgSCHLmmStartTmr((uint8_t)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
 885                                   RGSCH_BNDREQ_TMR,
 886                                  (uint32_t)tfuSap->sapCfg.bndTmr.val, cb);
 887             }
 888
 889             /* Send bind request */
 890             //rgSCHUtlTfuBndReq((uint8_t)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
 891             //tfuSap->sapCfg.suId, tfuSap->sapCfg.spId);
 892          }
 893          break;
 894       default:
 895          DU_LOG("\nERROR  -->  SCH : rgSCHLmmTmrExpiry(): Invalid"
 896                  " tmrEvnt=%d", tmrEvnt);
 897          ret = RFAILED;
 898          break;
 899    }
 900    return (ret);
 901 }
 902
 903 \f
 904 /**
 905  * @brief Layer Manager Control Confirm generation handler
 906  *        for Bind Confirm reception at TFU interface.
 907  *        RgLiTfuBndCfm() forwards the confirmation to this
 908  *        function. All SAP state related handling is restricted
 909  *        to LMM modules, hence the cfm forwarding.
 910  *
 911  * @details
 912  *
 913  *     Function : rgSCHLmmBndCfm
 914  *
 915  *     This API is used by the LIM module of MAC to forward
 916  *     the Bind Confirm it receives over the TFU interface.
 917  *
 918  *  @param[in]   Pst *pst, Post Structure
 919  *  @param[in]   SuId suId, Service user ID
 920  *  @param[in]   uint8_t status, Status
 921  *  @return  S16
 922  *      -# ROK
 923  **/
 924 S16 rgSCHLmmBndCfm
 925 (
 926 Pst *pst,               /* Post Structure */
 927 SuId suId,              /* Service user ID */
 928 uint8_t status               /* Status */
 929 )
 930 {
 931    S16       ret = ROK;
 932    RgMngmt   cntrlCfm;
 933    Pst       cfmPst;
 934    Inst      inst = (pst->dstInst - SCH_INST_START); /* scheduler instance */
 935
 936
 937    /* check the SAP State */
 938    switch(rgSchCb[inst].tfuSap[suId].sapSta.sapState)
 939    {
 940       case LRG_WAIT_BNDCFM:
 941          break;
 942       case LRG_BND:
 943          /* SAP is already bound */
 944          return ROK;
 945       default:
 946          return RFAILED;
 947    }
 948
 949    cfmPst = rgSchCb[inst].rgSchInit.lmPst;
 950    cfmPst.selector = rgSchCb[inst].genCfg.bndCfmResp[suId].response.selector;
 951    cfmPst.prior = rgSchCb[inst].genCfg.bndCfmResp[suId].response.prior;
 952    cfmPst.route = rgSchCb[inst].genCfg.bndCfmResp[suId].response.route;
 953    cfmPst.region = rgSchCb[inst].genCfg.bndCfmResp[suId].response.mem.region;
 954    cfmPst.pool = rgSchCb[inst].genCfg.bndCfmResp[suId].response.mem.pool;
 955
 956    memset(&cntrlCfm, 0, sizeof(RgMngmt));
 957
 958    switch(status)
 959    {
 960       case CM_BND_OK: /* status is OK */
 961          /* Change SAP state to Bound */
 962          rgSchCb[inst].tfuSap[suId].sapSta.sapState = LRG_BND;
 963          if (rgSchCb[inst].tfuSap[suId].sapCfg.bndTmr.enb == TRUE)
 964          {
 965             ret = rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR, (PTR)&rgSchCb[inst].tfuSap[suId]);
 966          }
 967          /* Send Control Confirm with status as OK to Layer Manager */
 968          cntrlCfm.cfm.status = LCM_PRIM_OK;
 969          cntrlCfm.cfm.reason = LCM_REASON_NOT_APPL;
 970         /* Sending Status Indication to Layer Manager */
 971          rgSCHLmmStaInd((uint8_t)(rgSchCb[inst].tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
 972                LCM_CATEGORY_INTERFACE, LCM_EVENT_BND_OK,
 973                LCM_CAUSE_LYR_SPECIFIC, (RgUstaDgn *)NULLP);
 974          break;
 975
 976       default:
 977          /* Change SAP state to UnBound */
 978          rgSchCb[inst].tfuSap[suId].sapSta.sapState = LRG_UNBND;
 979          if (rgSchCb[inst].tfuSap[suId].sapCfg.bndTmr.enb == TRUE)
 980          {
 981             ret = rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR, (PTR)&rgSchCb[inst].tfuSap[suId]);
 982          }
 983          /* Send Control Confirm with status as NOK to Layer Manager */
 984          cntrlCfm.cfm.status = LCM_PRIM_NOK;
 985          cntrlCfm.cfm.reason = LCM_REASON_NEG_CFM;
 986          break;
 987    }
 988    rgSchCb[inst].tfuSap[suId].numBndRetries = 0;
 989    cntrlCfm.hdr.elmId.elmnt = STTFUSAP;
 990    cntrlCfm.hdr.transId = rgSchCb[inst].genCfg.bndCfmResp[suId].transId;
 991
 992    ret = RgMiLrgSchCntrlCfm(&cfmPst, &cntrlCfm);
 993
 994    return (ret);
 995 }
 996
 997 /**
 998  * @brief Layer Manager Unsolicited Status Indication generation.
 999  *
1000  * @details
1001  *
1002  *     Function : rgSCHLmmStaInd
1003  *
1004  *     This API is used by the other modules of MAC to send a unsolicited
1005  *     status indication to the Layer Manager.
1006  *
1007  *  @param[in]  uint16_t category, the Alarm category
1008  *  @param[in]  uint16_t event, the Alarm event
1009  *  @param[in]  uint16_t cause, the cause of the Alarm
1010  *  @param[in]  RgUstaDgn *dgn, Alarm Diagonostics
1011  *  @return  S16
1012  *      -# ROK
1013  **/
1014 S16 rgSCHLmmStaInd
1015 (
1016 Inst inst,
1017 uint16_t  category,
1018 uint16_t  event,
1019 uint16_t  cause,
1020 RgUstaDgn *dgn
1021 )
1022 {
1023    RgMngmt    usta;
1024
1025    if(rgSchCb[inst].rgSchInit.usta == FALSE)
1026    {
1027       return ROK;
1028    }
1029    memset(&usta, 0, sizeof(RgMngmt));
1030
1031    SGetDateTime(&usta.t.usta.cmAlarm.dt);
1032    usta.t.usta.cmAlarm.category = category;
1033    usta.t.usta.cmAlarm.event = event;
1034    usta.t.usta.cmAlarm.cause = cause;
1035    if (dgn != NULLP)
1036    {
1037       memcpy(&usta.t.usta.dgn, dgn, sizeof(RgUstaDgn));
1038    }
1039
1040    rgSchCb[inst].rgSchInit.lmPst.selector =
1041                        rgSchCb[inst].genCfg.ustaResp.response.selector;
1042    rgSchCb[inst].rgSchInit.lmPst.prior =
1043                        rgSchCb[inst].genCfg.ustaResp.response.prior;
1044    rgSchCb[inst].rgSchInit.lmPst.route =
1045                        rgSchCb[inst].genCfg.ustaResp.response.route;
1046    rgSchCb[inst].rgSchInit.lmPst.region =
1047                        rgSchCb[inst].genCfg.ustaResp.response.mem.region;
1048    rgSchCb[inst].rgSchInit.lmPst.pool =
1049                        rgSchCb[inst].genCfg.ustaResp.response.mem.pool;
1050    usta.hdr.transId = rgSchCb[inst].genCfg.ustaResp.transId;
1051
1052    return (RgMiLrgSchStaInd(&rgSchCb[inst].rgSchInit.lmPst, &usta));
1053 }
1054
1055 \f
1056 /**********************************************************************
1057
1058          End of file
1059 **********************************************************************/