Initial commit
[o-du/l2.git] / src / 5gnrmac / 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 static const char* RLOG_MODULE_NAME="MAC";
38 static int RLOG_MODULE_ID=4096;
39 static int RLOG_FILE_ID=167;
40
41 /* header include files (.h) */
42 #include "envopt.h"        /* environment options */
43 #include "envdep.h"        /* environment dependent */
44 #include "envind.h"        /* environment independent */
45 #include "gen.h"           /* general */
46 #include "ssi.h"           /* system services */
47 #include "cm_tkns.h"       /* Common Token Defines */
48 #include "cm_llist.h"      /* Common Link List Defines */
49 #include "cm_hash.h"       /* Common Hash List Defines */
50 #include "cm_mblk.h"       /* common memory link list library */
51 #include "cm_lte.h"        /* Common LTE Defines */
52 #include "rg_env.h"        /* MAC Environment Defines */
53 #include "rgr.h"           /* RGR Interface defines */
54 #include "tfu.h"           /* RGU Interface defines */
55 #include "lrg.h"           /* LRG Interface defines */
56 #include "rgm.h"           /* RGM Interface defines */
57 #include "rg_sch.h"        /* Scheduler defines */
58 #include "rg_sch_inf.h"        /* Scheduler defines */
59 #include "rg_sch_err.h"        /* MAC error defines */
60 #ifdef LTE_L2_MEAS
61 #include "rg_sch_cmn.h"    /* typedefs for Scheduler */
62 #endif
63 #include "rl_interface.h"
64 #include "rl_common.h"
65
66 /* header/extern include files (.x) */
67 #include "gen.x"           /* general */
68 #include "ssi.x"           /* system services */
69 #include "cm5.x"           /* system services */
70 #include "cm_tkns.x"       /* Common Token Definitions */
71 #include "cm_llist.x"      /* Common Link List Definitions */
72 #include "cm_lib.x"        /* Common Library Definitions */
73 #include "cm_hash.x"       /* Common Hash List Definitions */
74 #include "cm_mblk.x"       /* common memory link list library */
75 #include "cm_lte.x"        /* Common LTE Defines */
76 #include "rgr.x"           /* RGR Interface includes */
77 #include "rgm.x"           /* RGM Interface includes */
78 #include "tfu.x"           /* RGU Interface includes */
79 #include "lrg.x"           /* LRG Interface includes */
80 #include "rg_sch_inf.x"    /* Scheduler defines */
81 #include "rg_sch.x"        /* Scheduler includes */
82 #ifdef LTE_L2_MEAS
83 #include "rg_sch_cmn.x"    /* typedefs for Scheduler */
84 #endif 
85 #ifndef LTE_L2_MEAS
86 PUBLIC Void rgSCHCmnInit ARGS((Void));
87 #endif 
88 /* forward references */
89
90
91 PRIVATE U16 rgSCHLmmSapCfg ARGS((
92    Inst           inst,
93    RgCfg          *cfg,
94    U8             sapIdx,
95    Elmnt          sapType
96 ));
97
98 PRIVATE Void rgSCHLmmShutdown ARGS((
99    Inst inst
100 ));
101
102
103 PUBLIC void printSchCellInfo(void)
104 {
105    U8 idx=0;
106    U8 inst=0;
107    for (idx = 0; idx < rgSchCb[inst].numSaps; idx++)
108    {
109       /* Unbind all the TFU SAP */
110       /* Free the memory held by the cell associated
111        * with this SAP */
112       if (rgSchCb[inst].tfuSap[idx].cell != NULLP)
113       {
114          RLOG1(L_INFO,"CELL %d\n", idx);
115          RLOG1(L_INFO,"NUM UEs :%d\n",rgSchCb[inst].tfuSap[idx].cell->ueLst.nmbEnt);
116       }
117    }
118 }
119
120 \f
121 /**
122  * @brief Task Initiation callback function. 
123  *
124  * @details
125  *
126  *     Function : schActvInit
127  *     
128  *     This function is supplied as one of parameters during MAC's 
129  *     task registration. SSI will invoke this function once, after
130  *     it creates and attaches this TAPA Task to a system task.
131  *     
132  *  @param[in]  Ent Entity, the entity ID of this task.     
133  *  @param[in]  Inst Inst, the instance ID of this task.
134  *  @param[in]  Region Region, the region ID registered for memory 
135  *              usage of this task.
136  *  @param[in]  Reason Reason.
137  *  @return  S16
138  *      -# ROK
139  **/
140 #ifdef ANSI
141 PUBLIC S16 schActvInit
142 (
143 Ent    entity,            /* entity */
144 Inst   instId,             /* instance */
145 Region region,         /* region */
146 Reason reason          /* reason */
147 )
148 #else
149 PUBLIC S16 schActvInit(entity, instId, region, reason)
150 Ent    entity;            /* entity */
151 Inst   instId;             /* instance */
152 Region region;         /* region */
153 Reason reason;         /* reason */
154 #endif
155 {
156    Inst inst = (instId  - RGSCH_INST_START);
157
158    TRC2(schActvInit);
159
160    /* Initialize the MAC TskInit structure to zero */
161    cmMemset ((U8 *)&rgSchCb[inst], 0, sizeof(RgSchCb));
162
163    /* Initialize the MAC TskInit with received values */
164    rgSchCb[inst].rgSchInit.ent = entity;
165    rgSchCb[inst].rgSchInit.inst = inst;
166    rgSchCb[inst].rgSchInit.region = region;
167    rgSchCb[inst].rgSchInit.pool = 0;
168    rgSchCb[inst].rgSchInit.reason = reason;
169    rgSchCb[inst].rgSchInit.cfgDone = FALSE;
170    rgSchCb[inst].rgSchInit.acnt = FALSE;
171    rgSchCb[inst].rgSchInit.usta = FALSE;
172    rgSchCb[inst].rgSchInit.trc = FALSE;
173 #ifdef DEBUGP
174 #ifdef RG_DEBUG
175    /*  disabling debugs by default */
176    /* rgSchCb[inst].rgSchInit.dbgMask = 0xffffffff; */
177 #endif
178 #endif /* DEBUGP */
179    rgSchCb[inst].rgSchInit.procId = SFndProcId();
180
181    rgSchCb[inst].rgrSap = NULLP;
182    rgSchCb[inst].tfuSap = NULLP;
183    rgSchCb[inst].rgmSap = NULLP;
184    rgSCHCmnInit();
185
186    RETVALUE(ROK);
187 } /* schActvInit */
188 \f
189 \f
190 /**
191  * @brief SAP Configuration Handler. 
192  *
193  * @details
194  *
195  *     Function : rgSCHLmmSapCfg
196  *     
197  *     This function in called by RgMiLrgSchCfgReq(). It handles the
198  *     interface SAP configuration of the scheduler instance. It 
199  *     initializes the sapState to LRG_UNBND. Returns
200  *     reason for success/failure of this function.
201  *     
202  *  @param[in]  RgCfg *cfg, the Configuaration information 
203  *  @return  U16
204  *      -# LCM_REASON_GENCFG_NOT_DONE
205  *      -# LCM_REASON_INVALID_SAP
206  *      -# LCM_REASON_NOT_APPL
207  **/
208 #ifdef ANSI
209 PRIVATE U16 rgSCHLmmSapCfg
210 (
211 Inst  dInst,
212 RgCfg *cfg,            /* Configuaration information */
213 U8    sapIdx,          /* SAP index */
214 Elmnt sapType             /* SAP Type */
215 )
216 #else
217 PRIVATE U16 rgSCHLmmSapCfg(dInst, cfg, sapIdx, sapType)
218 Inst  dInst;
219 RgCfg *cfg;            /* Configuaration information */
220 U8    sapIdx;          /* SAP index */
221 Elmnt sapType;            /* SAP Type */
222 #endif
223 {
224    U16                  ret = LCM_REASON_NOT_APPL;
225    RgSchLowSapCfgInfo   *lowSapCfg = NULLP;
226    RgSchUpSapCfgInfo    *upSapCfg = NULLP;
227    Inst  inst = (dInst - RGSCH_INST_START);
228
229    TRC2(rgSCHLmmSapCfg)
230
231    /* Check if Gen Config has been done */
232
233    switch(sapType)
234    {   
235       case STRGRSAP:
236 #ifndef CL_MAC_LWLC
237          if ((cfg->s.schInstCfg.rgrSap[sapIdx].selector != RGR_SEL_TC) &&
238              (cfg->s.schInstCfg.rgrSap[sapIdx].selector != RGR_SEL_LC))
239          {
240             ret = LCM_REASON_INVALID_PAR_VAL;
241             RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCfg(): unsupported"
242                " Selector value for RGR.");
243             break;
244          }
245 #endif
246          if(rgSchCb[inst].rgrSap[sapIdx].sapSta.sapState == LRG_NOT_CFG)
247          { 
248             rgSchCb[inst].rgrSap[sapIdx].sapSta.sapState = LRG_UNBND;
249          }
250          upSapCfg = &rgSchCb[inst].rgrSap[sapIdx].sapCfg;
251
252          upSapCfg->sapPst.dstEnt = cfg->s.schInstCfg.rgrSap[sapIdx].ent;
253          upSapCfg->sapPst.dstInst = cfg->s.schInstCfg.rgrSap[sapIdx].inst;
254          upSapCfg->sapPst.dstProcId = cfg->s.schInstCfg.rgrSap[sapIdx].procId;
255          upSapCfg->sapPst.srcEnt = rgSchCb[inst].rgSchInit.ent;
256          upSapCfg->sapPst.srcInst = rgSchCb[inst].rgSchInit.inst +
257          RGSCH_INST_START;
258          upSapCfg->sapPst.srcProcId = rgSchCb[inst].rgSchInit.procId;
259          upSapCfg->sapPst.region = cfg->s.schInstCfg.rgrSap[sapIdx].mem.region;
260          upSapCfg->sapPst.pool = cfg->s.schInstCfg.rgrSap[sapIdx].mem.pool;
261          upSapCfg->sapPst.selector = cfg->s.schInstCfg.rgrSap[sapIdx].selector;
262          upSapCfg->sapPst.route = cfg->s.schInstCfg.rgrSap[sapIdx].route;
263          upSapCfg->sapPst.intfVer = 0; 
264          upSapCfg->sapPst.event = 0; 
265          upSapCfg->sapPst.prior = cfg->s.schInstCfg.rgrSap[sapIdx].prior;
266          upSapCfg->suId = cfg->s.schInstCfg.rgrSap[sapIdx].suId;
267          upSapCfg->spId = cfg->s.schInstCfg.rgrSap[sapIdx].spId;
268          break;
269       case STTFUSAP:
270 #ifndef CL_MAC_LWLC
271          if ((cfg->s.schInstCfg.tfuSap[sapIdx].selector != TFU_SEL_TC) &&
272              (cfg->s.schInstCfg.tfuSap[sapIdx].selector != TFU_SEL_LC))
273          {
274             ret = LCM_REASON_INVALID_PAR_VAL;
275             RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCfg(): unsupported"
276                      " Selector value for TFU.");
277             break;
278          }
279 #endif
280          if (rgSchCb[inst].tfuSap[sapIdx].sapSta.sapState == LRG_NOT_CFG) 
281          { 
282             rgSchCb[inst].tfuSap[sapIdx].sapSta.sapState = LRG_UNBND;
283          }
284          /* Initialize the  sap timer */
285          cmInitTimers(&(rgSchCb[inst].tfuSap[sapIdx].tmrBlk), 1);
286          lowSapCfg = &rgSchCb[inst].tfuSap[sapIdx].sapCfg;
287
288          lowSapCfg->sapPst.dstEnt = cfg->s.schInstCfg.tfuSap[sapIdx].ent;
289          lowSapCfg->sapPst.dstInst = cfg->s.schInstCfg.tfuSap[sapIdx].inst;
290          lowSapCfg->sapPst.dstProcId = cfg->s.schInstCfg.tfuSap[sapIdx].procId;
291          lowSapCfg->sapPst.srcEnt = rgSchCb[inst].rgSchInit.ent;
292          lowSapCfg->sapPst.srcInst = rgSchCb[inst].rgSchInit.inst +
293          RGSCH_INST_START;
294          lowSapCfg->sapPst.srcProcId = rgSchCb[inst].rgSchInit.procId;
295          lowSapCfg->sapPst.region = cfg->s.schInstCfg.tfuSap[sapIdx].mem.region;
296          lowSapCfg->sapPst.pool = cfg->s.schInstCfg.tfuSap[sapIdx].mem.pool;
297          lowSapCfg->sapPst.selector = cfg->s.schInstCfg.tfuSap[sapIdx].selector;
298          lowSapCfg->sapPst.route = cfg->s.schInstCfg.tfuSap[sapIdx].route;
299          lowSapCfg->sapPst.intfVer = 0; 
300           lowSapCfg->sapPst.event = 0; 
301          lowSapCfg->sapPst.prior = cfg->s.schInstCfg.tfuSap[sapIdx].prior;
302          lowSapCfg->suId = cfg->s.schInstCfg.tfuSap[sapIdx].suId;
303          lowSapCfg->spId = cfg->s.schInstCfg.tfuSap[sapIdx].spId;
304          cmMemcpy((U8 *)&lowSapCfg->bndTmr, 
305                   (U8 *)&cfg->s.schInstCfg.tfuSap[sapIdx].bndTmr,
306                   sizeof(TmrCfg));
307          break;
308       case STRGMSAP:
309 #ifndef RGM_LWLC
310          if ((cfg->s.schInstCfg.rgmSap[sapIdx].selector != RGM_SEL_LWLC) &&
311              (cfg->s.schInstCfg.rgmSap[sapIdx].selector != RGM_SEL_LC) &&
312              (cfg->s.schInstCfg.rgmSap[sapIdx].selector != RGM_SEL_TC))
313          {
314             ret = LCM_REASON_INVALID_PAR_VAL;
315             RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCfg(): unsupported"
316                      " Selector value for RGM.");
317             break;
318          }
319 #endif
320          if (rgSchCb[inst].rgmSap[sapIdx].sapSta.sapState == LRG_NOT_CFG) 
321          { 
322             rgSchCb[inst].rgmSap[sapIdx].sapSta.sapState = LRG_UNBND;
323          }
324          upSapCfg = &rgSchCb[inst].rgmSap[sapIdx].sapCfg;
325          upSapCfg->sapPst.dstEnt = cfg->s.schInstCfg.rgmSap[sapIdx].ent;
326          upSapCfg->sapPst.dstInst = cfg->s.schInstCfg.rgmSap[sapIdx].inst;
327          upSapCfg->sapPst.dstProcId = cfg->s.schInstCfg.rgmSap[sapIdx].procId;
328          upSapCfg->sapPst.srcEnt = rgSchCb[inst].rgSchInit.ent;
329          upSapCfg->sapPst.srcInst = rgSchCb[inst].rgSchInit.inst +
330          RGSCH_INST_START;
331          upSapCfg->sapPst.srcProcId = rgSchCb[inst].rgSchInit.procId;
332          upSapCfg->sapPst.region = cfg->s.schInstCfg.rgmSap[sapIdx].mem.region;
333          upSapCfg->sapPst.pool = cfg->s.schInstCfg.rgmSap[sapIdx].mem.pool;
334          upSapCfg->sapPst.selector = cfg->s.schInstCfg.rgmSap[sapIdx].selector;
335          upSapCfg->sapPst.route = cfg->s.schInstCfg.rgmSap[sapIdx].route;
336          upSapCfg->sapPst.intfVer = 0; 
337          upSapCfg->sapPst.event = 0; 
338          upSapCfg->sapPst.prior = cfg->s.schInstCfg.rgmSap[sapIdx].prior;
339          upSapCfg->suId = cfg->s.schInstCfg.rgmSap[sapIdx].suId;
340          upSapCfg->spId = cfg->s.schInstCfg.rgmSap[sapIdx].spId;
341
342          break;
343       default:
344          /* would never reach here */
345          break;
346    }
347    RETVALUE(ret);
348 }
349
350 \f
351 /**
352  * @brief Scheduler instance Configuration Handler. 
353  *
354  * @details
355  *
356  *     Function : rgSCHLmmInstCfg
357  *     
358  *     This function in called by RgMiLrgSchCfgReq(). It handles the
359  *     general and SAP configurations of the scheduler instance. It initializes
360  *     the hash lists of rgSchCb. Returns
361  *     reason for success/failure of this function.
362  *     
363  *  @param[in]  RgCfg *cfg, the Configuaration information 
364  *  @return  U16
365  *      -# LCM_REASON_NOT_APPL 
366  *      -# LCM_REASON_INVALID_MSGTYPE
367  *      -# LCM_REASON_MEM_NOAVAIL
368  **/
369 #ifdef ANSI
370 PUBLIC U16 rgSCHLmmInstCfg
371 (
372 RgCfg *cfg,            /* Configuaration information */
373 Inst  dInst
374 )
375 #else
376 PUBLIC U16 rgSCHLmmInstCfg(cfg,dInst)
377 RgCfg *cfg;            /* Configuaration information */
378 Inst  dInst;
379 #endif
380 {
381    U16    ret = LCM_REASON_NOT_APPL;
382    Inst   inst = (dInst - RGSCH_INST_START);
383    U8     idx;
384
385    TRC2(rgSCHLmmInstCfg)
386
387    /* Check if Instance Configuration is done already */
388    if (rgSchCb[inst].rgSchInit.cfgDone == TRUE)
389    {
390       RETVALUE(LCM_REASON_INVALID_MSGTYPE);
391    }
392    if ((cfg->s.schInstCfg.genCfg.lmPst.selector != LRG_SEL_TC) &&
393        (cfg->s.schInstCfg.genCfg.lmPst.selector != LRG_SEL_LC))
394    {
395       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmInstCfg(): unsupported "
396                  "Selector value for lmPst.");
397       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
398    }
399    /* Update the Pst structure for LM interface */
400    cmMemcpy((U8 *)&rgSchCb[inst].rgSchInit.lmPst,
401             (U8 *)&cfg->s.schInstCfg.genCfg.lmPst,
402              sizeof(Pst));
403    
404    rgSchCb[inst].rgSchInit.inst = inst;
405    rgSchCb[inst].rgSchInit.lmPst.srcProcId = rgSchCb[inst].rgSchInit.procId;
406    rgSchCb[inst].rgSchInit.lmPst.srcEnt = rgSchCb[inst].rgSchInit.ent;
407    rgSchCb[inst].rgSchInit.lmPst.srcInst = rgSchCb[inst].rgSchInit.inst +
408    RGSCH_INST_START;
409    rgSchCb[inst].rgSchInit.lmPst.event = EVTNONE;
410
411    rgSchCb[inst].rgSchInit.region = cfg->s.schInstCfg.genCfg.mem.region;
412    rgSchCb[inst].rgSchInit.pool = cfg->s.schInstCfg.genCfg.mem.pool;
413    rgSchCb[inst].genCfg.tmrRes = cfg->s.schInstCfg.genCfg.tmrRes;
414 #ifdef LTE_ADV
415    rgSchCb[inst].genCfg.forceCntrlSrbBoOnPCel =  cfg->s.schInstCfg.genCfg.forceCntrlSrbBoOnPCel;
416    rgSchCb[inst].genCfg.isSCellActDeactAlgoEnable =  cfg->s.schInstCfg.genCfg.isSCellActDeactAlgoEnable;
417 #endif
418    rgSchCb[inst].genCfg.startCellId    = cfg->s.schInstCfg.genCfg.startCellId;
419
420    /* allocate RGR saps */
421    if (SGetSBuf(rgSchCb[inst].rgSchInit.region,
422                 rgSchCb[inst].rgSchInit.pool,
423                 (Data **)&rgSchCb[inst].rgrSap,
424                 (sizeof(RgSchUpSapCb) * cfg->s.schInstCfg.numSaps)) != ROK)
425    {
426       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmInstCfg: SGetSBuf for "
427                    "RGR saps failed");
428       RETVALUE(RFAILED);
429    }
430    /* allocate RGM saps */
431    if (SGetSBuf(rgSchCb[inst].rgSchInit.region,
432                 rgSchCb[inst].rgSchInit.pool,
433                 (Data **)&rgSchCb[inst].rgmSap,
434                 (sizeof(RgSchUpSapCb) * cfg->s.schInstCfg.numSaps)) != ROK)
435    {
436       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmInstCfg: SGetSBuf for "
437                    "RGM saps failed");
438       RETVALUE(RFAILED);
439    }
440
441
442    /* allocate TFU saps */
443    if (SGetSBuf(rgSchCb[inst].rgSchInit.region,
444                 rgSchCb[inst].rgSchInit.pool,
445                 (Data **)&rgSchCb[inst].tfuSap,
446                 (sizeof(RgSchLowSapCb) * cfg->s.schInstCfg.numSaps)) != ROK)
447    {
448       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmInstCfg: SGetSBuf for TFU "
449                  "saps failed");
450       RETVALUE(RFAILED);
451    }
452
453    /* allocate for bndCfmResponses */
454    if (SGetSBuf(rgSchCb[inst].rgSchInit.region,
455                 rgSchCb[inst].rgSchInit.pool,
456                 (Data **)&rgSchCb[inst].genCfg.bndCfmResp,
457                 (sizeof(RgSchLmResponse) * cfg->s.schInstCfg.numSaps)) != ROK)
458    {
459       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmInstCfg: SGetSBuf for bind"
460            " confirm responses failed");
461       RETVALUE(RFAILED);
462    }
463
464 #ifdef LTE_ADV
465    rgSCHLaaInitEnbCb(&rgSchCb[inst]);
466 #endif
467
468    rgSchCb[inst].numSaps = cfg->s.schInstCfg.numSaps;
469    for (idx = 0; idx < cfg->s.schInstCfg.numSaps; idx++)
470    {
471       /* Initialize SAP State and configure SAP */
472       rgSchCb[inst].rgrSap[idx].sapSta.sapState = LRG_NOT_CFG;
473       rgSchCb[inst].rgrSap[idx].cell = NULLP;
474       rgSCHLmmSapCfg(dInst, cfg, idx, STRGRSAP);
475
476       rgSchCb[inst].rgmSap[idx].sapSta.sapState = LRG_NOT_CFG;
477       rgSchCb[inst].rgmSap[idx].cell = NULLP;
478       rgSCHLmmSapCfg(dInst, cfg, idx, STRGMSAP);
479
480       rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_NOT_CFG;
481       rgSchCb[inst].tfuSap[idx].cell = NULLP;
482       rgSCHLmmSapCfg(dInst, cfg, idx, STTFUSAP);
483       rgSchCb[inst].tfuSap[idx].numBndRetries = 0;
484    }
485    /* Initialzie the timer queue */   
486    cmMemset((U8 *)&rgSchCb[inst].tmrTq, 0, sizeof(CmTqType)*RGSCH_TQ_SIZE);
487    /* Initialize the timer control point */
488    cmMemset((U8 *)&rgSchCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
489    rgSchCb[inst].tmrTqCp.tmrLen = RGSCH_TQ_SIZE;
490
491    /* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */
492    /* Timer Registration request to SSI */
493    if (SRegTmrMt(rgSchCb[inst].rgSchInit.ent, dInst,
494       (S16)rgSchCb[inst].genCfg.tmrRes, schActvTmr) != ROK)
495    {
496       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHLmmInstCfg(): Failed to "
497              "register timer.");
498       RETVALUE(LCM_REASON_MEM_NOAVAIL);
499    }   
500                     
501    /* Set Config done in TskInit */
502    rgSchCb[inst].rgSchInit.cfgDone = TRUE;
503
504    RETVALUE(ret);
505 }
506
507 \f
508 /***********************************************************
509  *
510  *     Func : rgSCHLmmShutdown
511  *        
512  *
513  *     Desc : Handles the scheduler instance shutdown request. Calls 
514  *     rgSCHCfgFreeCellCb(RgSchCellCb*) to handle each cellCb deallocation.
515  *            
516  *
517  *     Ret  : Void
518  *
519  *     Notes: 
520  *
521  *     File : rg_sch_lmm.c 
522  *
523  **********************************************************/
524 #ifdef ANSI
525 PRIVATE Void rgSCHLmmShutdown
526 (
527 Inst inst
528 )
529 #else
530 PRIVATE Void rgSCHLmmShutdown(inst)
531 Inst inst;
532 #endif
533 {
534    Inst          dInst = inst + RGSCH_INST_START;
535    U8            idx;
536 #ifdef LTE_L2_MEAS
537    CmLList       *lnk = NULLP;
538    RgSchCb       *instCb =  &rgSchCb[inst];
539    RgSchCellCb   *cell = NULLP;
540    RgSchL2MeasCb *measCb;
541    U8            ulAllocIdx;
542    RgSchCmnUlCell *cellUl;
543    RgSchClcBoRpt  *bo = NULL;
544 #endif
545
546    TRC2(rgSCHLmmShutdown)
547
548 #ifdef LTE_L2_MEAS
549    for (idx = 0; idx < instCb->numSaps; idx++)
550    {
551      /* got the cell break the loop */
552      cell = instCb->rgrSap[idx].cell;
553      if(cell != NULLP)
554      {
555         /* Free the memory held up by  ulAllocInfo */
556         cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
557 #ifdef LTE_TDD
558         for(ulAllocIdx = 0; ulAllocIdx < RGSCH_SF_ALLOC_SIZE; ulAllocIdx++)
559 #else
560         for(ulAllocIdx = 0; ulAllocIdx < RGSCH_NUM_SUB_FRAMES; ulAllocIdx++)
561 #endif
562         {
563            if(cell->sfAllocArr[ulAllocIdx].ulUeInfo.ulAllocInfo != NULLP)
564            {
565              /* ccpu00117052 - MOD - Passing double pointer
566              for proper NULLP assignment*/
567              rgSCHUtlFreeSBuf(cell->instIdx, 
568                     (Data **)(&(cell->sfAllocArr[ulAllocIdx].ulUeInfo.\
569                                 ulAllocInfo)),
570                     cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc));
571            }
572         }
573         /* Free the memory allocated to measCb */
574         lnk = cell->l2mList.first;
575         while(lnk != NULLP)
576         {
577            measCb = (RgSchL2MeasCb *)lnk->node;
578            cmLListDelFrm(&cell->l2mList, lnk);
579            lnk = lnk->next;
580              /* ccpu00117052 - MOD - Passing double pointer
581              for proper NULLP assignment*/
582            rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,\
583                           sizeof(RgSchL2MeasCb));
584         }
585
586         /* Free mem if any present for boLst for common channels */
587         for(idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
588         {
589            lnk = (CmLList *)cell->cmnLcCb[idx].boLst.first;
590            while (lnk)
591            {
592               bo = (RgSchClcBoRpt *)(lnk->node);
593               lnk = lnk->next;
594               cmLListDelFrm(&cell->cmnLcCb[idx].boLst, &bo->boLstEnt);
595               rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
596            }
597         }
598      }
599    }
600 #endif
601
602 #ifdef LTE_ADV
603    rgSCHLaaDeInitEnbCb(&rgSchCb[inst]);
604 #endif
605    for (idx = 0; idx < rgSchCb[inst].numSaps; idx++)
606    {
607       /* Unbind all the TFU SAP */
608       if(rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_WAIT_BNDCFM)
609       {
610          rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg, LRG_UNBND);
611          if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
612          {
613             rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR, (PTR)&rgSchCb[inst].tfuSap[idx]); 
614          }
615          rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_UNBND;
616       }
617       if(rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_BND)
618       {
619          rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg, LRG_UNBND);
620          rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_UNBND;
621       }
622       /* Free the memory held by the cell associated with this SAP */
623       if (rgSchCb[inst].tfuSap[idx].cell != NULLP)
624          rgSCHCfgFreeCellCb(rgSchCb[inst].tfuSap[idx].cell);
625       rgSchCb[inst].tfuSap[idx].cell = NULLP;
626    }
627    /* Free the memory held by the scheduler instance */
628    /* Deallocate RGR saps */
629    SPutSBuf(rgSchCb[inst].rgSchInit.region,
630                 rgSchCb[inst].rgSchInit.pool,
631                 (Data *)rgSchCb[inst].rgrSap,
632                 (sizeof(RgSchUpSapCb) * rgSchCb[inst].numSaps));
633    rgSchCb[inst].rgrSap = NULLP;
634    /* Deallocate RGM saps */
635    SPutSBuf(rgSchCb[inst].rgSchInit.region,
636                 rgSchCb[inst].rgSchInit.pool,
637                 (Data *)rgSchCb[inst].rgmSap,
638                 (sizeof(RgSchUpSapCb) * rgSchCb[inst].numSaps));
639    rgSchCb[inst].rgmSap = NULLP;
640
641    /* Deallocate TFU saps */
642    SPutSBuf(rgSchCb[inst].rgSchInit.region,
643                 rgSchCb[inst].rgSchInit.pool,
644                 (Data *)rgSchCb[inst].tfuSap,
645                 (sizeof(RgSchLowSapCb) * rgSchCb[inst].numSaps));
646    rgSchCb[inst].tfuSap = NULLP;
647
648    /* Deallocate bndCfmResponses */
649    SPutSBuf(rgSchCb[inst].rgSchInit.region,
650                 rgSchCb[inst].rgSchInit.pool,
651                 (Data *)rgSchCb[inst].genCfg.bndCfmResp,
652                 (sizeof(RgSchLmResponse) * rgSchCb[inst].numSaps));
653    rgSchCb[inst].genCfg.bndCfmResp = NULLP;
654    /* De-register the Timer Service */
655    (Void) SDeregTmrMt(rgSchCb[inst].rgSchInit.ent, dInst,
656                      (S16)rgSchCb[inst].genCfg.tmrRes, schActvTmr); 
657
658    /* call back the task initialization function to intialize
659     * the global rgSchCb[inst] Struct */
660    schActvInit(rgSchCb[inst].rgSchInit.ent, dInst, rgSchCb[inst].rgSchInit.region, 
661               rgSchCb[inst].rgSchInit.reason);
662    
663    /* Set Config done in TskInit */
664    rgSchCb[inst].rgSchInit.cfgDone = FALSE;
665
666    RETVOID;
667 }
668
669 \f
670 /***********************************************************
671  *
672  *     Func : rgSCHLmmGenCntrl 
673  *        
674  *
675  *     Desc : Processes the LM control request for STGEN elmnt.
676  *            
677  *
678  *     Ret  : Void
679  *
680  *     Notes: 
681  *
682  *     File : rg_sch_lmm.c 
683  *
684  **********************************************************/
685 #ifdef ANSI
686 PUBLIC Void rgSCHLmmGenCntrl 
687 (
688 RgMngmt       *cntrl,
689 RgMngmt       *cfm,
690 Pst           *cfmPst
691 )
692 #else
693 PUBLIC Void rgSCHLmmGenCntrl(cntrl, cfm, cfmPst)
694 RgMngmt       *cntrl;
695 RgMngmt       *cfm;
696 Pst           *cfmPst;
697 #endif
698 {
699    Inst      inst = (cfmPst->srcInst - RGSCH_INST_START); /* Scheduler instance ID */
700    TRC2(rgSCHLmmGenCntrl)
701
702    cfm->cfm.status = LCM_PRIM_OK;
703    cfm->cfm.reason = LCM_REASON_NOT_APPL;
704    
705
706    switch(cntrl->t.cntrl.action)
707    {
708       case AENA:
709          /* Action is Enable */
710          switch(cntrl->t.cntrl.subAction)
711          {
712             case SAUSTA:   
713             /* Enable Unsolicited Status (alarms) */
714                rgSchCb[inst].rgSchInit.usta = TRUE;
715                /*Store the response and TransId for sending the Alarms */
716                cmMemcpy((U8 *)&rgSchCb[inst].genCfg.ustaResp.response, 
717                (U8 *)&cntrl->hdr.response, sizeof(Resp));
718                rgSchCb[inst].genCfg.ustaResp.transId = cntrl->hdr.transId;
719                break;
720             case SADBG:
721             /* Enable Debug Printing */
722 #ifdef DEBUGP
723                rgSchCb[inst].rgSchInit.dbgMask |= cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
724 #endif
725                break;
726 #ifdef PHY_ERROR_LOGING
727             case SAELMNT:
728                {
729                   rgSchUlAllocCntr.mcs = cntrl->t.cntrl.s.rgSchUlAllocCntrl.mcs;
730                   rgSchUlAllocCntr.numOfRb = cntrl->t.cntrl.s.rgSchUlAllocCntrl.numOfRb;
731                   rgSchUlAllocCntr.rbStart = cntrl->t.cntrl.s.rgSchUlAllocCntrl.rbStart;
732                   rgSchUlAllocCntr.testStart = cntrl->t.cntrl.s.rgSchUlAllocCntrl.testStart;
733                   rgSchUlAllocCntr.enaLog = cntrl->t.cntrl.s.rgSchUlAllocCntrl.enaLog;
734                   rgSchUlAllocCntr.logTime = cntrl->t.cntrl.s.rgSchUlAllocCntrl.logTime;
735                   rgSchUlAllocCntr.crcOk = 0;
736                   rgSchUlAllocCntr.crcErr = 0;
737                   rgSchUlAllocCntr.numUlPackets = 0;
738                   rgSchUlAllocCntr.numPrach = 0;
739                   rgSchUlAllocCntr.taZero = 0;
740 #ifdef MAC_SCH_STATS
741                   /* Reset
742                    * L2
743                    * statistics
744                    * */
745                   cmMemset((U8 *)&hqRetxStats, 0, sizeof(RgSchHqRetxStats));
746                   cmMemset((U8 *)&hqFailStats, 0, sizeof(RgSchNackAckStats));
747 #endif
748                   break;
749                }
750 #endif
751             default:
752                cfm->cfm.status = LCM_PRIM_NOK;
753                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
754                RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "rgSCHLmmGenCntrl(): "
755                   "invalid subaction=%d", cntrl->t.cntrl.subAction);
756                break;
757          }
758          break;
759       case ADISIMM:
760          /* Action is Diable immidiately */
761          switch(cntrl->t.cntrl.subAction)
762          {
763             case SAUSTA:
764             /* Disable Unsolicited Status (alarms) */
765                rgSchCb[inst].rgSchInit.usta = FALSE;
766                break;
767             case SADBG:
768             /* Disable Debug Printing */
769 #ifdef DEBUGP
770                rgSchCb[inst].rgSchInit.dbgMask &=\
771                           ~cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
772 #endif
773                break;
774
775             default:
776                cfm->cfm.status = LCM_PRIM_NOK;
777                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
778                RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "rgSCHLmmGenCntrl():"
779                  " invalid subaction=%d", cntrl->t.cntrl.subAction);
780                break;
781          }
782          break;
783       case ASHUTDOWN:
784          /* Free all the memory dynamically allocated by MAC */
785          rgSCHLmmShutdown(inst);
786          break;
787       default:
788          cfm->cfm.status = LCM_PRIM_NOK;
789          cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
790          RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "rgSCHLmmGenCntrl(): invalid"
791           " action=%d", cntrl->t.cntrl.action);
792          break;
793    }
794    RgMiLrgSchCntrlCfm(cfmPst, cfm);
795    RETVOID;
796 }
797
798 \f
799 /***********************************************************
800  *
801  *     Func : rgSCHLmmSapCntrl 
802  *        
803  *
804  *     Desc : Processes the LM control request for STxxxSAP elmnt.
805  *            
806  *
807  *     Ret  : Void
808  *
809  *     Notes: 
810  *
811  *     File : rg_sch_lmm.c 
812  *
813  **********************************************************/
814 #ifdef ANSI
815 PUBLIC Void rgSCHLmmSapCntrl 
816 (
817 RgMngmt       *cntrl,
818 RgMngmt       *cfm,
819 Pst           *cfmPst
820 )
821 #else
822 PUBLIC Void rgSCHLmmSapCntrl(cntrl, cfm, cfmPst)
823 RgMngmt       *cntrl;
824 RgMngmt       *cfm;
825 Pst           *cfmPst;
826 #endif
827 {
828    U8       idx;
829
830    /* TODO Pass InstId instead of using InstId from cfmPst */
831    Inst      inst = (cfmPst->srcInst - RGSCH_INST_START); /* Scheduler instance Id */
832    TRC2(rgSCHLmmSapCntrl)
833
834    /* Only TFU SAP can be controlled by LM */
835    switch(cntrl->hdr.elmId.elmnt)
836    {
837       case STTFUSAP:
838          idx = (U8)cntrl->t.cntrl.s.rgSapCntrl.suId;
839          if (idx > LRG_MAX_SAPS_PER_INST)
840          {
841             cfm->cfm.status = LCM_PRIM_NOK;
842             cfm->cfm.reason = LCM_REASON_INVALID_SAP;
843          }
844          switch(cntrl->t.cntrl.action)
845          {
846             case ABND:
847                /* Bind Enable Request */
848                if ((rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_NOT_CFG) ||
849                    (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_BND))
850                {
851                   cfm->cfm.status = LCM_PRIM_NOK;
852                   cfm->cfm.reason = LCM_REASON_INVALID_SAP;
853                }
854                else
855                {
856                   if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
857                   {
858                      rgSCHLmmStartTmr(inst, RGSCH_BNDREQ_TMR,
859                                   rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.val, 
860                                   (PTR)&rgSchCb[inst].tfuSap[idx]);
861                   }
862                   /* Change SAP state */
863                   rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_WAIT_BNDCFM;
864                   rgSchCb[inst].tfuSap[idx].numBndRetries++;
865                   /* Store the response and TransId for sending 
866                    * the Control confirm */
867                   cmMemcpy((U8 *)&rgSchCb[inst].genCfg.bndCfmResp[idx].response,
868                            (U8 *)&cntrl->hdr.response, sizeof(Resp));
869                   rgSchCb[inst].genCfg.bndCfmResp[idx].transId = 
870                                                 cntrl->hdr.transId;
871                   
872                   cfm->cfm.status = LCM_PRIM_OK_NDONE;
873                   cfm->cfm.reason = LCM_REASON_NOT_APPL;
874
875                   /* Sending Control Confirm before sending Bind
876                    * Request to TFU  */
877                   RgMiLrgSchCntrlCfm(cfmPst, cfm);
878                   
879                   rgSCHUtlTfuBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg.suId, 
880                                  rgSchCb[inst].tfuSap[idx].sapCfg.spId);
881                  RETVOID; 
882                }
883                break;
884             case AUBND:
885             /* Unbind request */
886
887                /* Check if the SAP is configured */
888                if( (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_NOT_CFG) ||
889                      (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_UNBND))
890                {
891                   cfm->cfm.status = LCM_PRIM_NOK;
892                   cfm->cfm.reason = LCM_REASON_INVALID_MSGTYPE;
893                }
894                else
895                {
896                   rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg,
897                                   TFU_UBNDREQ_MNGMT);
898                   if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
899                   {
900                      rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR, 
901                                        (PTR)&rgSchCb[inst].tfuSap[idx]);
902                   }
903                   /* Change SAP state */
904                   rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_UNBND;
905                   cfm->cfm.status = LCM_PRIM_OK;
906                   cfm->cfm.reason = LCM_REASON_NOT_APPL;
907                }
908                break;
909             case ADEL:
910                /* Delete SAP, does initialization of SAP */
911                if ((rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_WAIT_BNDCFM) ||
912                    (rgSchCb[inst].tfuSap[idx].sapSta.sapState == LRG_BND))
913                {
914                   rgSCHUtlTfuUBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg,
915                                   TFU_UBNDREQ_MNGMT);
916                   if (rgSchCb[inst].tfuSap[idx].sapCfg.bndTmr.enb == TRUE)
917                   {
918                      rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR,
919                                      (PTR)&rgSchCb[inst].tfuSap[idx]);
920                   }
921                }
922                cmMemset((U8 *)&rgSchCb[inst].tfuSap[idx], 0, sizeof(RgSchLowSapCb));
923                rgSchCb[inst].tfuSap[idx].sapSta.sapState = LRG_NOT_CFG;
924                cfm->cfm.status = LCM_PRIM_OK;
925                cfm->cfm.reason = LCM_REASON_NOT_APPL;
926                break;
927             default:
928                cfm->cfm.status = LCM_PRIM_NOK;
929                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
930                RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCntrl(): "
931                   "invalid action=%d", cntrl->t.cntrl.action);
932                break;
933          }
934          break;
935       case STRGRSAP:
936          idx = (U8)cntrl->t.cntrl.s.rgSapCntrl.spId;
937          if (idx > LRG_MAX_SAPS_PER_INST)
938          {
939             cfm->cfm.status = LCM_PRIM_NOK;
940             cfm->cfm.reason = LCM_REASON_INVALID_SAP;
941          }
942          switch(cntrl->t.cntrl.action)
943          {
944             case ADEL:
945                cmMemset((U8 *)&rgSchCb[inst].rgrSap[idx], 0, sizeof(RgSchUpSapCb));
946                rgSchCb[inst].rgrSap[idx].sapSta.sapState = LRG_NOT_CFG;
947                cfm->cfm.status = LCM_PRIM_OK;
948                cfm->cfm.reason = LCM_REASON_NOT_APPL;
949                break;
950             default:
951                cfm->cfm.status = LCM_PRIM_NOK;
952                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
953                RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCntrl(): "
954                      "invalid action=%d", cntrl->t.cntrl.action);
955                break;
956          }
957          break;
958       case STRGMSAP:
959          idx = (U8)cntrl->t.cntrl.s.rgSapCntrl.spId;
960          if (idx > LRG_MAX_SAPS_PER_INST)
961          {
962             cfm->cfm.status = LCM_PRIM_NOK;
963             cfm->cfm.reason = LCM_REASON_INVALID_SAP;
964          }
965          switch(cntrl->t.cntrl.action)
966          {
967             case ADEL:
968                cmMemset((U8 *)&rgSchCb[inst].rgmSap[idx], 0, sizeof(RgSchUpSapCb));
969                rgSchCb[inst].rgmSap[idx].sapSta.sapState = LRG_NOT_CFG;
970                cfm->cfm.status = LCM_PRIM_OK;
971                cfm->cfm.reason = LCM_REASON_NOT_APPL;
972                break;
973             default:
974                cfm->cfm.status = LCM_PRIM_NOK;
975                cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
976                RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "rgSCHLmmSapCntrl(): "
977                      "invalid action=%d", cntrl->t.cntrl.action);
978                break;
979          }
980          break;
981
982        default:
983          /* Would never come here. */
984          RETVOID;
985    }
986    RgMiLrgSchCntrlCfm(cfmPst, cfm);
987    RETVOID;
988 }
989
990 \f
991 /***********************************************************
992  *
993  *     Func : rgSCHLmmFillCfmPst 
994  *        
995  *
996  *     Desc : Fills the Confirmation Post Structure cfmPst using the reqPst 
997  *            and the cfm->hdr.response.
998  *            
999  *
1000  *     Ret  : Void
1001  *
1002  *     Notes: 
1003  *
1004  *     File : rg_sch_lmm.c 
1005  *
1006  **********************************************************/
1007 #ifdef ANSI
1008 PUBLIC Void rgSCHLmmFillCfmPst
1009 (
1010 Pst           *reqPst,
1011 Pst           *cfmPst,
1012 RgMngmt       *cfm
1013 )
1014 #else
1015 PUBLIC Void rgSCHLmmFillCfmPst(reqPst, cfmPst, cfm)
1016 Pst           *reqPst;
1017 Pst           *cfmPst;
1018 RgMngmt       *cfm;
1019 #endif
1020 {
1021    Inst inst;
1022
1023    TRC2(rgSCHLmmFillCfmPst)
1024
1025    inst = (reqPst->dstInst - RGSCH_INST_START);
1026
1027    cfmPst->srcEnt    = rgSchCb[inst].rgSchInit.ent;
1028    cfmPst->srcInst   = rgSchCb[inst].rgSchInit.inst + RGSCH_INST_START;
1029    cfmPst->srcProcId = rgSchCb[inst].rgSchInit.procId;
1030    cfmPst->dstEnt    = reqPst->srcEnt;
1031    cfmPst->dstInst   = reqPst->srcInst;
1032    cfmPst->dstProcId = reqPst->srcProcId;
1033
1034    cfmPst->selector  = cfm->hdr.response.selector;
1035    cfmPst->prior     = cfm->hdr.response.prior;
1036    cfmPst->route     = cfm->hdr.response.route;
1037    cfmPst->region    = cfm->hdr.response.mem.region;
1038    cfmPst->pool      = cfm->hdr.response.mem.pool;
1039
1040    RETVOID;
1041 }
1042
1043 \f
1044 /**
1045  * @brief Timer start handler. 
1046  *
1047  * @details
1048  *
1049  *     Function : rgSCHLmmStartTmr
1050  *     
1051  *     This function based on the input parameters starts the timer for 
1052  *     "tmrVal" duration. As of now scheduler instance uses the timer 
1053  *     functionality for BndReq only. Hence there is no conditional
1054  *     code based on "tmrEvnt".
1055  *     
1056  *  @param[in]  S16   tmrEvnt, the Timer Event    
1057  *  @param[in]  U32   tmrVal,  the Wait Time
1058  *  @param[in]  PTR   cb,  Entry for which Timer expired
1059  *  @return  S16
1060  *      -# ROK
1061  **/
1062 #ifdef ANSI
1063 PUBLIC S16 rgSCHLmmStartTmr
1064 (
1065 Inst               inst,
1066 S16                tmrEvnt,            /* Timer Event */
1067 U32                tmrVal,             /* Wait Time */
1068 PTR                cb                  /* Entry for which Timer Expired */
1069 )
1070 #else
1071 PUBLIC S16 rgSCHLmmStartTmr(inst, tmrEvnt, tmrVal, cb)
1072 Inst               inst;             /* scheduler instance ID */
1073 S16                tmrEvnt;            /* Timer Event */
1074 U32                tmrVal;             /* Wait Time */
1075 PTR                cb;                 /* Entry for which Timer Expired */
1076 #endif
1077 {
1078    CmTmrArg    arg;
1079 /*   Inst        dInst = inst + RGSCH_INST_START; */
1080
1081    TRC2(rgSCHLmmStartTmr)
1082
1083    UNUSED(tmrEvnt);
1084
1085    /* Initialize the arg structure */
1086    cmMemset((U8 *)&arg, 0, sizeof(CmTmrArg));
1087
1088    arg.tqCp = &rgSchCb[inst].tmrTqCp;
1089    arg.tq = rgSchCb[inst].tmrTq;
1090    arg.timers = &((RgSchLowSapCb *)cb)->tmrBlk;
1091    arg.cb = cb;
1092    arg.tNum = 0;
1093    arg.max = RGSCH_MAX_TIMER;
1094    arg.evnt = RGSCH_BNDREQ_TMR;
1095    arg.wait = tmrVal;      
1096    cmPlcCbTq(&arg);
1097
1098    RETVALUE(ROK);
1099 }
1100
1101 \f
1102 /**
1103  * @brief Timer stop handler. 
1104  *
1105  * @details
1106  *
1107  *     Function : rgSCHLmmStopTmr
1108  *     
1109  *     This function based on the input parameters stops the timer for 
1110  *     "tmrEvnt". As of now Scheduler instance uses the timer functionality for
1111  *     BndReq only. Hence there is no conditional code based on "tmrEvnt".
1112  *     Once the bind happens and this timer is stopped, the timer functionality
1113  *     is deregistered with SSI. As there is no further use of timer processing.
1114  *     
1115  *  @param[in]  S16   tmrEvnt, the Timer Event    
1116  *  @param[in]  PTR   cb,  Entry for which Timer expired
1117  *  @return  S16
1118  *      -# ROK
1119  *      -# RFAILED
1120  **/
1121 #ifdef ANSI
1122 PUBLIC S16 rgSCHLmmStopTmr
1123 (
1124 Inst               inst,             /* Scheduler instance */
1125 S16                tmrEvnt,            /* Timer Event */
1126 PTR                cb                  /* Entry for which Timer Expired */
1127 )
1128 #else
1129 PUBLIC S16 rgSCHLmmStopTmr(inst, tmrEvnt, cb)
1130 Inst               inst;             /* Scheduler instance */
1131 S16                tmrEvnt;            /* Timer Event */
1132 PTR                cb;                 /* Entry for which Timer Expired */
1133 #endif
1134 {
1135    CmTmrArg   arg;
1136    U8         i;
1137    S16        ret; 
1138
1139    TRC2(rgSCHLmmStopTmr)
1140
1141    ret = RFAILED;
1142
1143    for(i=0;i<RGSCH_MAX_TIMER;i++)
1144    {
1145       /* Search for the Timer Blocks */
1146       if(((RgSchLowSapCb *)cb)->tmrBlk.tmrEvnt == tmrEvnt)
1147       {
1148          /* Initialize the arg structure */
1149          cmMemset((U8 *)&arg, 0, sizeof(CmTmrArg));
1150
1151          arg.tqCp = &rgSchCb[inst].tmrTqCp;
1152          arg.tq = rgSchCb[inst].tmrTq;
1153          arg.timers = &(((RgSchLowSapCb *)cb)->tmrBlk);
1154          arg.cb = cb;
1155          arg.max = RGSCH_MAX_TIMER;
1156          arg.evnt = tmrEvnt;
1157
1158          arg.tNum = i;   
1159          cmRmvCbTq(&arg);
1160          ret = ROK;
1161          break;
1162       }
1163
1164    }
1165
1166
1167    RETVALUE(ret);
1168 }
1169
1170 \f
1171 /**
1172  * @brief Timer Expiry handler. 
1173  *
1174  * @details
1175  *
1176  *     Function : rgSCHLmmTmrExpiry
1177  *     
1178  *     This is a callback function used as an input parameter to cmPrcTmr()
1179  *     to check expiry of any timer. In this function, we are only concerned
1180  *     about tmrEvnt=Bind timer.
1181  *     
1182  *  @param[in]  PTR   cb,  Entry for which Timer expired
1183  *  @param[in]  S16   tmrEvnt, the Timer Event    
1184  *  @return  S16
1185  *      -# ROK
1186  **/
1187 #ifdef ANSI
1188 PUBLIC S16 rgSCHLmmTmrExpiry
1189 (
1190 PTR cb,               /* Pointer to timer control block */
1191 S16 tmrEvnt           /* Timer Event */
1192 )
1193 #else
1194 PUBLIC S16 rgSCHLmmTmrExpiry(cb,tmrEvnt)
1195 PTR cb;               /* Pointer to timer control block */
1196 S16 tmrEvnt;          /* Timer Event */
1197 #endif
1198 {
1199    S16           ret = ROK;
1200    RgSchLowSapCb *tfuSap = (RgSchLowSapCb *)cb;
1201 #ifdef DEBUGP
1202    Inst          inst = tfuSap->cell->instIdx;
1203 #endif
1204    TRC2(rgSCHLmmTmrExpiry)
1205
1206    
1207    switch(tmrEvnt)
1208    {
1209       case RGSCH_BNDREQ_TMR:
1210          tfuSap->numBndRetries++;
1211          if(tfuSap->numBndRetries > RGSCH_MAX_BNDRETRY)
1212          {
1213             rgSCHLmmStaInd((U8)(tfuSap->sapCfg.sapPst.srcInst - RGSCH_INST_START),
1214                            (U16)LCM_CATEGORY_INTERFACE, (U16)LCM_EVENT_BND_FAIL,
1215                            (U16)LCM_CAUSE_TMR_EXPIRED, (RgUstaDgn *)NULLP);
1216          }
1217          else
1218          {
1219             /* Restart the bind timer */
1220             if (tfuSap->sapCfg.bndTmr.enb == TRUE)
1221             {
1222                ret = rgSCHLmmStartTmr((U8)(tfuSap->sapCfg.sapPst.srcInst - RGSCH_INST_START),
1223                                   RGSCH_BNDREQ_TMR, 
1224                                  (U32)tfuSap->sapCfg.bndTmr.val, cb);
1225             }
1226
1227             /* Send bind request */
1228             rgSCHUtlTfuBndReq((U8)(tfuSap->sapCfg.sapPst.srcInst - RGSCH_INST_START), 
1229             tfuSap->sapCfg.suId, tfuSap->sapCfg.spId);
1230          }
1231          break;
1232       default:
1233          RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "rgSCHLmmTmrExpiry(): Invalid"
1234                  " tmrEvnt=%d", tmrEvnt);
1235          ret = RFAILED;
1236          break;
1237    }
1238    RETVALUE(ret);
1239 }
1240
1241 \f
1242 /**
1243  * @brief Layer Manager Control Confirm generation handler
1244  *        for Bind Confirm reception at TFU interface.
1245  *        RgLiTfuBndCfm() forwards the confirmation to this 
1246  *        function. All SAP state related handling is restricted
1247  *        to LMM modules, hence the cfm forwarding.
1248  *
1249  * @details
1250  *
1251  *     Function : rgSCHLmmBndCfm 
1252  *     
1253  *     This API is used by the LIM module of MAC to forward
1254  *     the Bind Confirm it receives over the TFU interface.
1255  *     
1256  *  @param[in]   Pst *pst, Post Structure
1257  *  @param[in]   SuId suId, Service user ID
1258  *  @param[in]   U8 status, Status
1259  *  @return  S16
1260  *      -# ROK
1261  **/
1262 #ifdef ANSI
1263 PUBLIC S16 rgSCHLmmBndCfm
1264 (
1265 Pst *pst,               /* Post Structure */
1266 SuId suId,              /* Service user ID */
1267 U8 status               /* Status */
1268 )
1269 #else
1270 PUBLIC S16 rgSCHLmmBndCfm(pst,suId,status)
1271 Pst *pst;               /* Post Structure */
1272 SuId suId;              /* Service user Id */
1273 U8 status;              /* Status */
1274 #endif
1275 {
1276    S16       ret = ROK;
1277    RgMngmt   cntrlCfm;
1278    Pst       cfmPst;
1279    Inst      inst = (pst->dstInst - RGSCH_INST_START); /* scheduler instance */
1280
1281    TRC2(rgSCHLmmBndCfm)
1282
1283
1284    /* check the SAP State */
1285    switch(rgSchCb[inst].tfuSap[suId].sapSta.sapState)
1286    {
1287       case LRG_WAIT_BNDCFM:
1288          break;
1289       case LRG_BND:
1290          /* SAP is already bound */
1291          RETVALUE(ROK);
1292       default:
1293          RETVALUE(RFAILED);
1294    }
1295
1296    cfmPst = rgSchCb[inst].rgSchInit.lmPst;
1297    cfmPst.selector = rgSchCb[inst].genCfg.bndCfmResp[suId].response.selector;
1298    cfmPst.prior = rgSchCb[inst].genCfg.bndCfmResp[suId].response.prior;
1299    cfmPst.route = rgSchCb[inst].genCfg.bndCfmResp[suId].response.route;
1300    cfmPst.region = rgSchCb[inst].genCfg.bndCfmResp[suId].response.mem.region;
1301    cfmPst.pool = rgSchCb[inst].genCfg.bndCfmResp[suId].response.mem.pool;
1302    
1303    cmMemset((U8 *)&cntrlCfm, 0, sizeof(RgMngmt));
1304
1305    switch(status)
1306    {
1307       case CM_BND_OK: /* status is OK */
1308          /* Change SAP state to Bound */
1309          rgSchCb[inst].tfuSap[suId].sapSta.sapState = LRG_BND;
1310          if (rgSchCb[inst].tfuSap[suId].sapCfg.bndTmr.enb == TRUE)
1311          {
1312             ret = rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR, (PTR)&rgSchCb[inst].tfuSap[suId]);
1313          }
1314          /* Send Control Confirm with status as OK to Layer Manager */
1315          cntrlCfm.cfm.status = LCM_PRIM_OK;
1316          cntrlCfm.cfm.reason = LCM_REASON_NOT_APPL;
1317         /* Sending Status Indication to Layer Manager */
1318          rgSCHLmmStaInd((U8)(rgSchCb[inst].tfuSap->sapCfg.sapPst.srcInst - RGSCH_INST_START),
1319                LCM_CATEGORY_INTERFACE, LCM_EVENT_BND_OK,
1320                LCM_CAUSE_LYR_SPECIFIC, (RgUstaDgn *)NULLP);
1321          break;
1322
1323       default:
1324          /* Change SAP state to UnBound */
1325          rgSchCb[inst].tfuSap[suId].sapSta.sapState = LRG_UNBND;
1326          if (rgSchCb[inst].tfuSap[suId].sapCfg.bndTmr.enb == TRUE)
1327          {
1328             ret = rgSCHLmmStopTmr(inst, RGSCH_BNDREQ_TMR, (PTR)&rgSchCb[inst].tfuSap[suId]);
1329          }
1330          /* Send Control Confirm with status as NOK to Layer Manager */
1331          cntrlCfm.cfm.status = LCM_PRIM_NOK;
1332          cntrlCfm.cfm.reason = LCM_REASON_NEG_CFM;
1333          break;
1334    }
1335    rgSchCb[inst].tfuSap[suId].numBndRetries = 0;
1336    cntrlCfm.hdr.elmId.elmnt = STTFUSAP;
1337    cntrlCfm.hdr.transId = rgSchCb[inst].genCfg.bndCfmResp[suId].transId;
1338
1339    ret = RgMiLrgSchCntrlCfm(&cfmPst, &cntrlCfm);
1340
1341    RETVALUE(ret);
1342 }
1343
1344 /**
1345  * @brief Layer Manager Unsolicited Status Indication generation. 
1346  *
1347  * @details
1348  *
1349  *     Function : rgSCHLmmStaInd 
1350  *     
1351  *     This API is used by the other modules of MAC to send a unsolicited
1352  *     status indication to the Layer Manager.
1353  *     
1354  *  @param[in]  U16 category, the Alarm category
1355  *  @param[in]  U16 event, the Alarm event
1356  *  @param[in]  U16 cause, the cause of the Alarm
1357  *  @param[in]  RgUstaDgn *dgn, Alarm Diagonostics
1358  *  @return  S16
1359  *      -# ROK
1360  **/
1361 #ifdef ANSI
1362 PUBLIC S16 rgSCHLmmStaInd
1363 (
1364 Inst inst,
1365 U16  category,
1366 U16  event,
1367 U16  cause,
1368 RgUstaDgn *dgn
1369 )
1370 #else
1371 PUBLIC S16 rgSCHLmmStaInd(inst, category, event, cause, dgn) 
1372 Inst inst;
1373 U16 category;
1374 U16 event;
1375 U16 cause;
1376 RgUstaDgn *dgn;
1377 #endif
1378 {
1379    RgMngmt    usta;
1380
1381    TRC2(rgSCHLmmStaInd)
1382
1383    if(rgSchCb[inst].rgSchInit.usta == FALSE)
1384    {
1385       RETVALUE(ROK);
1386    }
1387
1388    cmMemset((U8 *)&usta, 0, sizeof(RgMngmt));
1389
1390    SGetDateTime(&usta.t.usta.cmAlarm.dt);
1391    usta.t.usta.cmAlarm.category = category;
1392    usta.t.usta.cmAlarm.event = event;
1393    usta.t.usta.cmAlarm.cause = cause;
1394    if (dgn != NULLP)
1395    {
1396       cmMemcpy((U8 *)&usta.t.usta.dgn, (U8 *)dgn, sizeof(RgUstaDgn));
1397    }
1398
1399    rgSchCb[inst].rgSchInit.lmPst.selector = 
1400                        rgSchCb[inst].genCfg.ustaResp.response.selector;
1401    rgSchCb[inst].rgSchInit.lmPst.prior = 
1402                        rgSchCb[inst].genCfg.ustaResp.response.prior;
1403    rgSchCb[inst].rgSchInit.lmPst.route = 
1404                        rgSchCb[inst].genCfg.ustaResp.response.route;
1405    rgSchCb[inst].rgSchInit.lmPst.region = 
1406                        rgSchCb[inst].genCfg.ustaResp.response.mem.region;
1407    rgSchCb[inst].rgSchInit.lmPst.pool = 
1408                        rgSchCb[inst].genCfg.ustaResp.response.mem.pool;
1409    usta.hdr.transId = rgSchCb[inst].genCfg.ustaResp.transId;
1410
1411    RETVALUE(RgMiLrgSchStaInd(&rgSchCb[inst].rgSchInit.lmPst, &usta));
1412 }
1413
1414 \f
1415 /**
1416  * @brief Scheduler instance timer call back function registered with SSI. 
1417  *
1418  * @details
1419  *
1420  *     Function :  schActvTmr
1421  *     
1422  *     This function is invoked by SSI for every timer activation
1423  *     period expiry. Note that SS_MT_TMR flag needs to be enabled for this
1424  *     as isntId is needed.As part of SRegTmr call for scheduler instance 
1425  *     SS_MT_TMR flag needs to be enabled and schActvTmr needs to be given as 
1426  *     callback function
1427  *     
1428  *  @return  S16
1429  *      -# ROK
1430  **/
1431 #ifdef ANSI
1432 PUBLIC S16 schActvTmr
1433 (
1434 Ent ent,
1435 Inst inst
1436 )
1437 #else
1438 PUBLIC S16 schActvTmr(ent, inst)
1439 Ent ent;
1440 Inst inst;
1441 #endif
1442 {
1443    Inst schInst = (inst  - RGSCH_INST_START);
1444    TRC2(schActvTmr)
1445
1446    /* Check if any timer in the scheduler instance has expired */ 
1447    cmPrcTmr(&rgSchCb[schInst].tmrTqCp,
1448             rgSchCb[schInst].tmrTq, (PFV) rgSCHLmmTmrExpiry);
1449  
1450    RETVALUE(ROK);
1451  
1452 } /* end of schActvTmr */
1453
1454 \f
1455 /**********************************************************************
1456  
1457          End of file
1458 **********************************************************************/