Deleted the rlog folder
[o-du/l2.git] / src / 5gnrsch / rg_sch_gom.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 Entry point fucntions
26   
27      File:     rg_sch_gom.c 
28   
29 **********************************************************************/
30
31 /** @file rg_sch_gom.c 
32 @brief This module does processing related to handling of upper interface APIs 
33 invoked by RRM towards MAC.
34 */
35
36
37 /* header include files -- defines (.h) */
38 #include "common_def.h"
39 #include "lrg.h"
40 #include "rgr.h"
41 #include "tfu.h"
42 #include "rg_env.h"
43 #include "rg_sch_inf.h"
44 #include "rg_sch.h"
45 #include "rg_sch_err.h"
46
47 /* header/extern include files (.x) */
48 #include "lrg.x"
49 #include "rgr.x"
50 #include "tfu.x"
51 #include "rg_sch_inf.x"
52 #include "rg_sch.x"
53
54 /* local defines */
55 static S16 rgSCHGomHndlCfgReq ARGS((RgSchCb *instCb, SpId spId,
56          RgrCfg  *cfg, RgSchErrInfo *errInfo));
57 static S16 rgSCHGomHndlRecfgReq ARGS((RgSchCb *instCb, SpId spId,
58          RgrRecfg  *recfg, RgSchErrInfo *errInfo));
59 static S16 rgSCHGomHndlResetReq ARGS((RgSchCb *instCb,SpId spId,RgrRst *reset,
60          RgSchErrInfo  *errInfo));
61 static S16 rgSCHGomGetCellIdFrmCfgReq ARGS((RgrCfgReqInfo *rgrCfgReq,
62          CmLteCellId *cellId));
63 static S16 rgSCHGomCfgReq ARGS((Region reg, Pool pool, RgSchCb *instCb,
64          RgrCfgTransId transId, RgrCfgReqInfo *cfgReqInfo));
65 static S16 rgSCHGomEnqCfgReq ARGS((Region reg, Pool pool, RgSchCellCb *cell,
66          RgrCfgTransId transId, RgrCfgReqInfo *rgrCfgReq));
67 static S16 rgSCHGomHndlDelReq ARGS((RgSchCb  *instCb,SpId spId, 
68          RgrDel  *del,RgSchErrInfo  *errInfo));
69 #ifdef LTE_ADV
70 static S16 rgSCHGomHndlSCellActDeactReq ARGS((RgSchCb *instCb, SpId spId,
71          RgrSCellActDeactEvnt  *sCellActDeactEvnt, RgSchErrInfo *errInfo, uint8_t action));
72 #endif /* LTE_ADV */
73 #ifdef EMTC_ENABLE
74 S16 rgSchEmtcGetSiWinPerd ARGS((
75 RgSchCellCb   *cell,
76 uint16_t  *siWinSize,
77 uint16_t  *minPeriod 
78 ));
79 extern S16 rgSCHEmtcUtlCalMcsAndNPrb
80 (
81  RgSchCellCb         *cell,
82  uint8_t                  cfgType,
83  MsgLen              msgLen,
84  uint8_t                  siId
85  );
86
87 S32 rgSCHEmtcUtlGetAllwdCchTbSzForSI ARGS(
88 (
89 uint32_t bo
90 ));
91
92 Void rgSCHEmtcWarningSiCfg ARGS(
93 (
94 RgSchCellCb             *cell,
95 RgrWarningSiCfgReqInfo  *warningSiCfgReqInfo,
96 uint16_t                     idx
97 ));
98 #endif
99
100
101 /* local typedefs */
102  
103 /* local externs */
104  
105 /* forward references */
106
107 \f
108
109 /**
110  * @brief Handler for config request from RRM to Schedular.
111  *
112  * @details
113  *
114  *     Function: rgSCHGomHndlCfg
115  *     
116  *     This API is called from schedulers UIM and it handles config request
117  *     from RRM to Scheduler.
118  *     
119  *     Processing Steps:
120  *      - If the request is for the inactive cell, 
121  *       - Handle request.Call rgSCHGomCfgReq.
122  *      - Else,
123  *       - Enqueue the request. Call rgSCHGomEnqCfgReq.
124  *         
125  *  @param[in]  Pst           *pst
126  *  @param[in]  RgSchCb       *instCb
127  *  @param[in]  RgrCfgTransId transId
128  *  @param[in]  RgrCfgReqInfo *cfgReqInfo
129  *  @return  S16
130  *      -# ROK 
131  *      -# RFAILED 
132  **/
133 S16 rgSCHGomHndlCfg(Pst *pst,RgSchCb  *instCb,RgrCfgTransId transId,RgrCfgReqInfo *cfgReqInfo)
134 {
135    S16           ret;
136    SpId          spId = 0;
137    CmLteCellId   cellId;
138    RgSchCellCb   *cell = NULLP;    
139    uint8_t       cfmStatus = RGR_CFG_CFM_NOK;
140
141    /* Apply the configuration for Cell Configuration or Delete */
142    if (cfgReqInfo->action != RGR_RECONFIG)
143    {
144       ret = rgSCHGomCfgReq (pst->region, pst->pool, instCb, 
145             transId, cfgReqInfo);
146       return (ret);
147    }
148
149    /* Fetch the cell Id for the recieved request */
150    if((rgSCHGomGetCellIdFrmCfgReq(cfgReqInfo, &cellId)) != ROK)
151    {
152       DU_LOG("\nERROR  -->  SCH : Action.Config Type Error");
153
154       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
155             (Size)sizeof(*cfgReqInfo));
156       cfgReqInfo = NULLP;
157       schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus); 
158       return RFAILED;
159    }
160    /* Extract the cell and Enquee Config Request */
161    if(NULLP != instCb->rgrSap[spId].cell)
162    {
163       if(cellId != instCb->rgrSap[spId].cell->cellId) 
164       {
165          DU_LOG("\nERROR  -->  SCH : Cell with Id %d already exists "
166            "on sap %d", instCb->rgrSap[spId].cell->cellId, spId);  
167
168          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
169                (Size)sizeof(*cfgReqInfo));
170          cfgReqInfo = NULLP;
171          schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus); 
172          return RFAILED;
173       }
174       cell = instCb->rgrSap[spId].cell;
175
176       /* Enqueue the configuration */
177       ret = rgSCHGomEnqCfgReq(pst->region, pst->pool, cell, transId, cfgReqInfo);
178       if (ret != ROK)
179       {
180          DU_LOG("\nERROR  -->  SCH : rgSCHGomHndlCfg: Enqueuing CfgReq "
181               "Failed ");
182
183          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
184                (Size)sizeof(*cfgReqInfo));
185          cfgReqInfo = NULLP;
186          schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus); 
187          return RFAILED;
188       }
189
190       return ROK;
191    }
192    SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, 
193          (Size)sizeof(*cfgReqInfo));
194    cfgReqInfo = NULLP;
195    schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus); 
196    return RFAILED;
197
198 }/* rgSCHGomHndlCfg */
199
200
201 /**
202  * @brief Handler to handle config request from RRM to Scheduler.
203  *
204  * @details
205  *
206  *     Function: rgSCHGomCfgReq
207  *     
208  *     This API handles processing for config request from RRM to Scheduler.
209  *     
210  *     Processing Steps: 
211  *      - If Configuration request, call rgSCHGomHndlCfgReq.
212  *      - Else if Reconfiguration request, call rgSCHGomHndlRecfgReq.
213  *      - If successful, send configuration confirm to RRM.
214  *        Call schSendCfgCfm else FAIL.
215  *
216  *  @param[in]  Region        reg
217  *  @param[in]  Pool          pool
218  *  @param[in]  RgSchCb       *instCb
219  *  @param[in]  RgrCfgTransId transId
220  *  @param[in]  RgrCfgReqInfo *cfgReqInfo
221  *  @return  S16
222  *      -# ROK 
223  *      -# RFAILED 
224  **/
225 static S16 rgSCHGomCfgReq(Region  reg,Pool  pool,RgSchCb *instCb,RgrCfgTransId transId,RgrCfgReqInfo *cfgReqInfo)
226 {
227    SpId            spId = 0;
228    uint8_t         cfmStatus = RGR_CFG_CFM_OK;
229    S16             ret;
230    RgSchErrInfo    errInfo;
231 #ifdef EMTC_ENABLE
232 printf("\nDEBUG  -->  SCH: AT MAC rgSCHGomCfgReq \n");
233 #endif
234
235    /* Process Config/Reconfig/Delete request from RRM */
236    switch (cfgReqInfo->action)
237    {
238       case SCH_CONFIG:
239          {
240             ret = rgSCHGomHndlCfgReq(instCb, spId, 
241                              &cfgReqInfo->u.cfgInfo, &errInfo);
242             break;
243          }
244       case RGR_RECONFIG:
245          {
246             ret = rgSCHGomHndlRecfgReq(instCb, spId, 
247                              &cfgReqInfo->u.recfgInfo, &errInfo);
248             break;
249          }
250       case RGR_RESET:
251          {
252             ret = rgSCHGomHndlResetReq(instCb, spId, 
253                              &cfgReqInfo->u.rstInfo, &errInfo);
254             break;
255          }
256       case RGR_DELETE:
257          {
258             ret = rgSCHGomHndlDelReq(instCb, spId,
259                              &cfgReqInfo->u.delInfo, &errInfo);
260             break;
261          } 
262 #ifdef LTE_ADV
263       case RGR_SCELL_ACT:
264       case RGR_SCELL_DEACT: 
265       case RGR_SCELL_READY: 
266          {
267             ret = rgSCHGomHndlSCellActDeactReq(instCb, spId,
268                              &cfgReqInfo->u.sCellActDeactEvnt, &errInfo, cfgReqInfo->action);
269             break;
270          }
271 #endif /* LTE_ADV */
272       default:
273          {
274             DU_LOG("\nERROR  -->  SCH : Invalid configuration "
275                "action %d", cfgReqInfo->action);
276             ret = RFAILED;
277          }
278    } /* End of switch */
279
280    if (ret != ROK)
281    {
282       cfmStatus = RGR_CFG_CFM_NOK;
283    }
284
285    SPutSBuf(reg, pool, (Data *)cfgReqInfo, 
286          (Size)sizeof(*cfgReqInfo));
287    cfgReqInfo = NULLP;
288 #ifdef EMTC_ENABLE
289 printf("\nDEBUG  -->  SCH: AT MAC sending RGR cfg cfm \n");
290 #endif
291
292    /* Send back confirmation status to RRM */   
293    schSendCfgCfm(reg, pool, transId, cfmStatus); 
294 #ifdef EMTC_ENABLE
295 printf("\nDEBUG  -->  SCH: AT MAC RGR cfg cfm sent\n");
296 #endif
297
298    return (ret);
299 }  /* rgSCHGomCfgReq */
300
301
302 /**
303  * @brief Handler to enqueuing config request from RRM to Scheduler.
304  *
305  * @details
306  *
307  *     Function: rgSCHGomEnqCfgReq
308  *     
309  *     This API enqueues config request from RRM to MAC. 
310  *     
311  *     Processing Steps:
312  *      - Allocate the configuration request element.
313  *      - Copy the contents of the recieved configuration to config request
314  *        element and free the recieved configuration pointer.
315  *      - If the configuration is without activation time,
316  *         - Enqueue the request in crntRgrCfgLst of the cell at the end of 
317  *           the list.
318  *      - Else
319  *         - Enqueue the request in pndngRgrCfgLst of the cell.
320  *         
321  *  @param[in]  Region        reg,
322  *  @param[in]  Pool          pool
323  *  @param[in]  RgSchCellCb   *cell
324  *  @param[in]  RgrCfgTransId transId
325  *  @param[in]  RgrCfgReqInfo *rgrCfgReq
326  *  @return  S16
327  *      -# ROK 
328  *      -# RFAILED 
329  **/
330 static S16 rgSCHGomEnqCfgReq(Region reg,Pool pool,RgSchCellCb *cell,RgrCfgTransId transId,RgrCfgReqInfo *rgrCfgReq)
331 {
332    S16                ret;
333    uint32_t           sfDiff;
334    RgSchCfgElem       *rgrCfgElem  = NULLP;
335    CmLteTimingInfo    actvTime; 
336    Inst               inst = cell->instIdx;
337
338    /* Allocate memory for config Element */
339    ret = rgSCHUtlAllocSBuf(inst, (Data **)&rgrCfgElem, sizeof(RgSchCfgElem));
340    if ((ret != ROK) || ((uint8_t *)rgrCfgElem == NULLP))
341    {
342       return RFAILED;
343    }
344
345    /* Initialize the configuration element */
346    memcpy(rgrCfgElem->rgrCfg.transId.trans,transId.trans,
347          sizeof(transId.trans));
348    rgrCfgElem->rgrCfg.reg = reg;
349    rgrCfgElem->rgrCfg.pool = pool;
350    rgrCfgElem->rgrCfg.rgrCfgReq = rgrCfgReq;
351    rgrCfgElem->cfgReqLstEnt.prev = NULLP;
352    rgrCfgElem->cfgReqLstEnt.next = NULLP;
353    rgrCfgElem->cfgReqLstEnt.node = (PTR )rgrCfgElem;
354
355    /* Add configuration element to current/pending cfgLst */
356    if (((rgrCfgReq->action == RGR_RECONFIG) &&
357             (rgrCfgReq->u.recfgInfo.recfgType == RGR_CELL_CFG) &&
358             (rgrCfgReq->u.recfgInfo.u.cellRecfg.recfgActvTime.pres == TRUE)))
359
360    {
361       actvTime = 
362          rgrCfgReq->u.recfgInfo.u.cellRecfg.recfgActvTime.actvTime;
363
364       /* Check if the activation time is valid */
365       if (actvTime.sfn >= RGSCH_MAX_SFN 
366             || actvTime.slot >= RGSCH_NUM_SUB_FRAMES_5G)
367       {
368          DU_LOG("\nERROR  -->  SCH : Invalid activation time for RGR "
369            "config request: activation sfn %d activation slot %d current "
370            "sfn %d current slot %d", actvTime.sfn, actvTime.slot, 
371            cell->crntTime.sfn, cell->crntTime.slot);
372          /* ccpu00117052 - MOD - Passing double pointer
373          for proper NULLP assignment*/
374          rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
375          return RFAILED;
376       }
377
378       sfDiff = RGSCH_CALC_SF_DIFF(actvTime, cell->crntTime);
379
380       if (sfDiff > (RGR_ACTV_WIN_SIZE * RGSCH_NUM_SUB_FRAMES_5G))
381       {
382          DU_LOG("\nERROR  -->  SCH : Invalid activation time for RGR"
383               " config request: activation sfn %d activation slot %d "
384               "current sfn %d current slot %d", actvTime.sfn,
385               actvTime.slot, cell->crntTime.sfn, cell->crntTime.slot);
386          /* ccpu00117052 - MOD - Passing double pointer
387          for proper NULLP assignment*/
388          rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
389          return RFAILED;
390       }
391
392       if (sfDiff)
393       {
394          /* Add to pending cfgReqLst */
395          rgrCfgElem->actvTime = actvTime; 
396          rgSCHDbmInsPndngRgrCfgElem(cell, rgrCfgElem);
397          /* Cfm to be sent only after applying request */
398          return ROK;
399       }
400    }
401
402    /* Add to current cfgReq list */
403    rgSCHDbmInsCrntRgrCfgElem(cell, rgrCfgElem);
404    /* Cfm to be sent only after applying request */
405    return ROK;
406 }  /* rgSCHGomEnqCfgReq */
407
408
409 /**
410  * @brief Handler for TTI processing for configurations recieved from RRM.
411  *
412  * @details
413  *
414  *     Function: rgSCHGomTtiHndlr
415  *     
416  *     This API does TTI processing for configurations recieved from RRM.
417  *     
418  *     Processing Steps:
419  *      - It dequeues config request from the current configuration list.
420  *        For each config request in the list: 
421  *        - Processes the request. Call rgSCHGomCfgReq.
422  *      - It dequeues config request for the current tti from the pending 
423  *        configuration list. For each config request in the list:
424  *        - Processes the request. Call rgSCHGomCfgReq.
425  *
426  *  @param[in]  RgSchCellCb *cell
427  *  @return  S16
428  *      -# ROK 
429  *      -# RFAILED 
430  **/
431 S16 rgSCHGomTtiHndlr(RgSchCellCb *cell,SpId  spId)
432 {
433    RgSchCfgElem       *cfgElem;
434    Inst               inst= cell->instIdx;
435
436    /* Dequeue from current config list */
437    while ((cfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
438    {
439       rgSCHDbmDelCrntRgrCfgElem(cell, cfgElem);
440       rgSCHGomCfgReq(cfgElem->rgrCfg.reg,cfgElem->rgrCfg.pool,
441             &rgSchCb[inst], cfgElem->rgrCfg.transId, 
442             cfgElem->rgrCfg.rgrCfgReq);
443       /* ccpu00117052 - MOD - Passing double pointer
444       for proper NULLP assignment*/
445       rgSCHUtlFreeSBuf(inst, (Data **)&cfgElem, sizeof(*cfgElem));
446    }
447
448    /* Handle config requests from pending config list */
449    while((cfgElem = rgSCHDbmGetPndngRgrCfgElemByKey(cell, cell->crntTime)) != NULLP)
450    {
451       rgSCHDbmDelPndngRgrCfgElem(cell, cfgElem);
452       rgSCHGomCfgReq(cfgElem->rgrCfg.reg, cfgElem->rgrCfg.pool, 
453             &rgSchCb[inst], cfgElem->rgrCfg.transId, 
454             cfgElem->rgrCfg.rgrCfgReq);
455       /* ccpu00117052 - MOD - Passing double pointer
456       for proper NULLP assignment*/
457       rgSCHUtlFreeSBuf(inst, (Data **)&cfgElem, sizeof(*cfgElem));
458    } 
459
460    return ROK;
461 }
462
463
464 /**
465  * @brief Handler to handle configuration request from RRM to MAC.
466  *
467  * @details
468  *
469  *     Function: rgSCHGomHndlCfgReq
470  *     
471  *     This API handles processing for configuration request from RRM to MAC.
472  *     
473  *     - Processing Steps: 
474  *        - Validate configuration request parameters at CFG module. 
475  *          Call rgSCHCfgVldtRgrCellCfg for cell configuration.
476  *        - If validated successfully, send configuration request to CFG.
477  *          Call rgSCHCfgRgrCellCfg else FAIL.
478  *          
479  *  @param[in]  RgSchCb      *instCb
480  *  @param[in]  SpId         spId
481  *  @param[in]  RgrCfg       *cfg
482  *  @param[out] RgSchErrInfo *errInfo
483  *  @return  S16
484  *      -# ROK 
485  *      -# RFAILED 
486  **/
487 static S16 rgSCHGomHndlCfgReq(RgSchCb *instCb,SpId spId,RgrCfg *cfg,RgSchErrInfo *errInfo)
488 {
489    S16          ret;
490    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
491    Inst         inst = (instCb->rgSchInit.inst );
492    RgSchUeCb    *ue;
493
494    errInfo->errType = RGSCHERR_GOM_CFG_REQ;
495    
496    /* Validate and process the configuration request */ 
497    switch (cfg->cfgType)
498    {
499       case RGR_CELL_CFG:
500       {
501          ret = rgSCHCfgVldtRgrCellCfg(inst, &cfg->u.cellCfg, cell, errInfo);
502             if (ret != ROK)
503             {
504                DU_LOG("\nERROR  -->  SCH : Rgr Cell configuration "
505                   "validation FAILED: Cell %d", cfg->u.cellCfg.cellId);
506                return RFAILED;
507             }
508          ret = rgSCHCfgRgrCellCfg(instCb, spId, &cfg->u.cellCfg, errInfo);
509          break;
510       }
511       case RGR_UE_CFG:
512       case RGR_SCELL_UE_CFG:
513       {
514          ret = rgSCHCfgVldtRgrUeCfg(inst, &cfg->u.ueCfg, &cell, errInfo);
515          if (ret != ROK)
516          {
517             DU_LOG("\nERROR  -->  SCH : Ue configuration validation"
518                " FAILED: CRNTI:%d", cfg->u.ueCfg.crnti);
519             return RFAILED;
520          }
521          ret = rgSCHCfgRgrUeCfg(cell, &cfg->u.ueCfg, errInfo);
522          break;
523       }
524       case RGR_LCH_CFG:
525       {
526          ret = rgSCHCfgVldtRgrLcCfg(inst, &cfg->u.lchCfg, &cell, &ue, errInfo);
527          if (ret != ROK)
528          {
529             DU_LOG("\nERROR  -->  SCH : LC configuration validation "
530               "FAILED: LCID:%d", cfg->u.lchCfg.lcId);
531             return RFAILED;
532          }
533          ret = rgSCHCfgRgrLchCfg(cell, ue, &cfg->u.lchCfg, errInfo); 
534          break;
535       }
536       case RGR_LCG_CFG:
537       {
538          ret = rgSCHCfgVldtRgrLcgCfg(inst, &cfg->u.lcgCfg, &cell, &ue, errInfo);
539          if (ret != ROK)
540          {
541             DU_LOG("\nERROR  -->  SCH : LCG configuration validation "
542               "FAILED: LCGID:%d", cfg->u.lcgCfg.ulInfo.lcgId);
543             return RFAILED;
544          }
545          ret = rgSCHCfgRgrLcgCfg(cell, ue, &cfg->u.lcgCfg, errInfo); 
546          break;
547       }
548       case MAC_GNB_CFG:
549       {
550          ret = rgSCHCfgVldtRgrSchedEnbCfg(inst, &cfg->u.schedEnbCfg, errInfo);
551          if (ret != ROK)
552          {
553             DU_LOG("\nERROR  -->  SCH : SCH ENB configuration validation FAILED: \n");
554             return RFAILED;
555          }
556          ret = rgSCHCfgRgrSchedEnbCfg(inst, spId, &cfg->u.schedEnbCfg, errInfo); 
557          break;
558       }
559       default:
560       {
561 #if(ERRCLASS & ERRCLS_INT_PAR)
562             DU_LOG("\nERROR  -->  SCH : Should never come here: "
563                 "cfgType %d", cfg->cfgType);
564 #endif
565             return RFAILED;
566       }
567    }
568    
569    return (ret);
570 }  /* rgSCHGomHndlCfgReq */
571
572 #ifdef LTE_ADV
573 /**
574  * @brief Handler to handle re-configuration request from RRM to MAC.
575  *
576  * @details
577  *
578  *     Function: rgSCHGomHndlSCellActDeactReq
579  *     
580  *     This API handles processing for SCell Activation Request from RRM to SCH.
581  *     
582  *     - Processing Steps: 
583  *        - Validate sCell Actication request parameters at CFG module. 
584  *        - If validated successfully, send configuration request to CFG.
585  *        - call activation function for each SCells configured
586  *
587  *  @param[in]  RgSchCb      *instCb
588  *  @param[in]  SpId         spId
589  *  @param[in]  RgrSCellActDeactEvnt  *sCellActDeactEvnt
590  *  @param[in]  uint8_t action
591  *  @param[out] RgSchErrInfo *errInfo
592  *  @return  S16
593  *      -# ROK 
594  *      -# RFAILED 
595  **/
596 static S16 rgSCHGomHndlSCellActDeactReq(RgSchCb  *instCb,SpId  spId,RgrSCellActDeactEvnt  *sCellActDeactEvnt,RgSchErrInf *errInfo,uint8_t action)
597 {
598    RgSchUeCb    *ue = NULLP;
599    uint16_t     idx = 0;
600    uint16_t     sCellIdx = 0;
601    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
602    Inst         inst = (instCb->rgSchInit.inst);
603
604    DU_LOG(("\nDEBUG  -->  SCH : Processing RGR SCell Actication request:"
605                   "%d\n", sCellActDeactEvnt->crnti));
606
607    errInfo->errType = RGSCHERR_GOM_SCELL_REQ;
608
609    /* Fetch the Ue */
610    if ((ue = rgSCHDbmGetUeCb(cell, sCellActDeactEvnt->crnti)) == NULLP)
611    {
612       DU_LOG(("\nERROR  -->  SCH : [%d]UE: does not exist\n", 
613             sCellActDeactEvnt->crnti));
614       return RFAILED;
615    }
616    
617    for(idx = 0; idx < sCellActDeactEvnt->numOfSCells; idx++)
618    {
619       sCellIdx = sCellActDeactEvnt->sCellActDeactInfo[idx].sCellIdx;
620
621       if (ROK != (rgSCHSCellTrigActDeact(cell, ue, sCellIdx, action)))
622       {
623             DU_LOG("\nERROR  -->  SCH : SCell Actication failed"
624                      "for UE [%d] with SCellIdx [%d]\n", 
625                      sCellActDeactEvnt->crnti, idx);
626             return RFAILED;
627
628       }
629
630    DU_LOG("\nINFO  -->  SCH : RGR Reconfiguration processed\n");
631    return ROK;
632 }  /* rgSCHGomHndlSCellActDeactReq */
633
634 #endif /* LTE_ADV */
635 /**
636  * @brief Handler to handle re-configuration request from RRM to MAC.
637  *
638  * @details
639  *
640  *     Function: rgSCHGomHndlRecfgReq
641  *     
642  *     This API handles processing for re-configuration request from RRM to MAC.
643  *     
644  *     - Processing Steps: 
645  *        - Validate re-configuration request parameters at CFG module. 
646  *          Call rgSCHCfgVldtRgrCellRecfg for cell re-configuration.
647  *        - If validated successfully, send configuration request to CFG.
648  *          Call rgSCHCfgRgrCellRecfg else FAIL.
649  *
650  *  @param[in]  RgSchCb      *instCb
651  *  @param[in]  SpId         spId
652  *  @param[in]  RgrRecfg     *recfg
653  *  @param[out] RgSchErrInfo *errInfo
654  *  @return  S16
655  *      -# ROK 
656  *      -# RFAILED 
657  **/
658 static S16 rgSCHGomHndlRecfgReq(RgSchCb  *instCb,SpId  spId,RgrRecfg *recfg,RgSchErrInfo  *errInfo)
659 {
660    RgSchUeCb    *ue = NULLP;
661    RgSchDlLcCb  *dlLc = NULLP; /* PURIFY_FIX:UMR */
662    S16          ret; 
663    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
664    Inst         inst = (instCb->rgSchInit.inst );
665
666    errInfo->errType = RGSCHERR_GOM_RECFG_REQ;
667    
668    /* Validate and process the re-configuration request */
669    switch (recfg->recfgType)
670    {
671       case RGR_CELL_CFG:
672       {
673          ret = rgSCHCfgVldtRgrCellRecfg(inst, &recfg->u.cellRecfg, &cell,
674                errInfo);
675          if (ret != ROK) 
676          {
677             DU_LOG("\nERROR  -->  SCH : Rgr Cell Recfg Validation "
678                      "FAILED");
679             return RFAILED;
680          }
681          ret = rgSCHCfgRgrCellRecfg(cell, &recfg->u.cellRecfg, errInfo);
682          break;
683       }
684       case RGR_UE_CFG:
685       case RGR_SCELL_UE_CFG:
686       {
687          ret = rgSCHCfgVldtRgrUeRecfg(inst, &recfg->u.ueRecfg, &cell, &ue, errInfo);
688          if ( ret != ROK)
689          {
690             DU_LOG("\nERROR  -->  SCH : Ue Recfg Validation FAILED"
691                       "OLD CRNTI:%d",recfg->u.ueRecfg.oldCrnti);
692             return RFAILED;
693          }
694          ret = rgSCHCfgRgrUeRecfg(cell, ue, &recfg->u.ueRecfg, errInfo);
695          break;
696       }
697       case RGR_LCH_CFG:
698       {
699          ret = rgSCHCfgVldtRgrLchRecfg(inst, &recfg->u.lchRecfg, &cell, &ue, 
700                &dlLc, errInfo);
701          if (ret != ROK)
702          {
703             DU_LOG("\nERROR  -->  SCH : Lc Recfg Validation FAILED"
704                       "LCID:%d",recfg->u.lchRecfg.lcId);
705             return RFAILED;
706          }
707          ret = rgSCHCfgRgrLchRecfg(cell, ue, dlLc, &recfg->u.lchRecfg, errInfo);
708          break;
709       }
710       case RGR_LCG_CFG:
711       {
712          ret = rgSCHCfgVldtRgrLcgRecfg(inst, &recfg->u.lcgRecfg, cell, &ue,
713                errInfo);
714          if (ret != ROK)
715          {
716             DU_LOG("\nERROR  -->  SCH : Lcg Recfg Validation FAILED"
717                       "LCGID:%d",recfg->u.lcgRecfg.ulRecfg.lcgId);
718             return RFAILED;
719          }
720          ret = rgSCHCfgRgrLcgRecfg(cell, ue, &recfg->u.lcgRecfg, errInfo);
721          break;
722       }
723       default:
724       {
725 #if(ERRCLASS & ERRCLS_INT_PAR)
726          DU_LOG("\nERROR  -->  SCH : Should never come here: recfgType %d", recfg->recfgType);
727 #endif
728          return RFAILED;
729       }
730    }
731
732    return (ret);
733 }  /* rgSCHGomHndlRecfgReq */
734
735 /**
736  * @brief Handler to handle UE reset request from RRM to Scheduler.
737  *
738  * @details
739  *
740  *     Function: rgSCHGomHndlResetReq
741  *     
742  *     This API handles processing for UE reset request from RRM to Scheduler.
743  *     
744  *     - Processing Steps: 
745  *        - Validate UE reset request parameters at CFG module. 
746  *          Call rgSCHCfgVldtRgrUeReset for UE reset.
747  *        - If validated successfully, send UE reset request to CFG.
748  *          Call rgSCHCfgRgrUeReset else FAIL.
749  *
750  *  @param[in]  RgrRst   *rstInfo
751  *  @param[out] RgSchErrInfo *errInfo
752  *  @return  S16
753  *      -# ROK 
754  *      -# RFAILED 
755  **/
756 static S16 rgSCHGomHndlResetReq(RgSchCb  *instCb,SpId spId,RgrRst *reset,RgSchErrInfo  *errInfo)
757 {
758    S16          ret; 
759    RgSchCellCb  *cell= instCb->rgrSap[spId].cell;
760    Inst         inst = (instCb->rgSchInit.inst );
761    RgSchUeCb    *ue = NULLP;
762
763    errInfo->errType = RGSCHERR_GOM_RESET_REQ;
764    
765    /* Validate and process the UE reset request */
766    ret = rgSCHCfgVldtRgrUeReset(inst, reset, cell, &ue, errInfo);
767    if (ret != ROK) 
768    {
769       DU_LOG("\nERROR  -->  SCH : Rgr UE Reset Validation FAILED"
770                "CRNTI:%d",reset->crnti);
771       return RFAILED;
772    }
773    
774    ret = rgSCHCfgRgrUeReset(cell, ue, reset, errInfo);
775    if (ret != ROK) 
776    {
777       DU_LOG("\nERROR  -->  SCH : Rgr UE Reset FAILED"
778                "CRNTI:%d",reset->crnti);
779       return RFAILED;
780    }
781
782    return (ret);
783 }  /* rgSCHGomHndlResetReq */
784
785
786 /**
787  * @brief Handler for processing Cell/Ue/Logical channel delete request
788  * recieved from RRM.
789  *
790  * @details
791  *
792  *     Function: rgSCHGomHndlDelReq
793  *     
794  *     This API handles processing of delete request from RRM to MAC. 
795  *     
796  *     Processing Steps:
797  *        - Fetch corresponding control block and pass it to CFG module.
798  *        - If control block does not exist, FAIL.
799  *
800  *  @param[in]  RgSchCb      *instCb
801  *  @param[in]  SpId         spId
802  *  @param[in]  RgrDel       *del
803  *  @param[out] RgSchErrInfo *errInfo
804  *  @return  S16
805  *      -# ROK 
806  *      -# RFAILED 
807  **/
808 static S16 rgSCHGomHndlDelReq(RgSchCb *instCb,SpId spId,RgrDel *del,RgSchErrInfo  *errInfo)
809 {
810
811    S16       ret;
812    volatile uint32_t     startTime=0;
813
814    errInfo->errType = RGSCHERR_GOM_DEL_REQ;
815
816    if(instCb->rgrSap[spId].cell == NULLP)
817    {
818       DU_LOG("\nERROR  -->  SCH : Cell doesnt exist");
819       return RFAILED; 
820    }
821    
822    /* Process the delete request */ 
823    switch (del->delType)
824    {
825       case RGR_CELL_CFG:
826       {
827          ret = rgSCHCfgRgrCellDel(instCb->rgrSap[spId].cell, del, errInfo);
828          if(ret == ROK)
829          {
830             /* TODO::Needs to be revisited after tti flow CaDev Start */
831             uint8_t idx = (uint8_t)((instCb->rgrSap[spId].cell->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
832             instCb->cells[idx] = NULLP;
833             /* CaDev End */
834             instCb->rgrSap[spId].cell = NULLP;
835             instCb->tfuSap[spId].cell = NULLP;
836          }
837          break;
838       }
839       case RGR_UE_CFG:
840       case RGR_SCELL_UE_CFG:
841       {
842
843          /*starting Task*/
844          SStartTask(&startTime, PID_SCH_UE_DEL);
845
846          ret = rgSCHCfgRgrUeDel(instCb->rgrSap[spId].cell, del, errInfo);
847
848          /*stoping Task*/
849          SStopTask(startTime, PID_SCH_UE_DEL);
850
851          break;
852       }
853       case RGR_LCH_CFG:
854       {
855          ret = rgSCHCfgRgrLcDel(instCb->rgrSap[spId].cell, del, errInfo);
856          break;
857       }
858       case RGR_LCG_CFG:
859       {
860          ret = rgSCHCfgRgrLcgDel(instCb->rgrSap[spId].cell, del, errInfo);
861          break;
862       }
863       default:
864       {
865 #if(ERRCLASS & ERRCLS_INT_PAR)
866          DU_LOG("\nERROR  -->  SCH : Should never come here: delType %d", del->delType);
867 #endif
868          return RFAILED;
869       }
870    }
871
872    return (ret);
873 }  /* rgSCHGomHndlDelReq */
874
875
876
877
878 /***********************************************************
879  *
880  *     Func : rgSCHGomGetCellIdFrmCfgReq
881  *        
882  *
883  *     Desc : 
884  *     - Processing Steps: 
885  *        - Retrieves the cell Id for a config request.
886  *
887  *  @param[in]  RgrCfgReqInfo *rgrCfgReq
888  *  @param[out] CmLteCellId   *cellId
889  *     Ret  : ROK on fetching cellId
890  *            RFAILED on failure
891  *
892  *     Notes: 
893  *
894  *     File : rg_sch_gom.c 
895  *
896  **********************************************************/
897 static S16 rgSCHGomGetCellIdFrmCfgReq(RgrCfgReqInfo *rgrCfgReq,CmLteCellId   *cellId)
898 {
899
900    /* Extract CellId depending on the action and Config Type in the Request 
901     * As of now this function is called for only re configuration so removed
902     * othe CASES below if needed we can add them*/
903    switch (rgrCfgReq->action)
904    {
905       case RGR_RECONFIG:
906          {
907             if (rgrCfgReq->u.recfgInfo.recfgType ==RGR_CELL_CFG)
908             {
909                *cellId = rgrCfgReq->u.recfgInfo.u.cellRecfg.cellId;
910             }
911             else if ((rgrCfgReq->u.recfgInfo.recfgType ==  RGR_SCELL_UE_CFG) || 
912                   (rgrCfgReq->u.recfgInfo.recfgType == RGR_UE_CFG))
913             {
914                *cellId = rgrCfgReq->u.recfgInfo.u.ueRecfg.cellId;
915             }
916             else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCH_CFG)
917             {
918                *cellId = rgrCfgReq->u.recfgInfo.u.lchRecfg.cellId;
919             }
920             else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCG_CFG) 
921             {
922                *cellId = rgrCfgReq->u.recfgInfo.u.lcgRecfg.cellId;
923             }
924             else
925             {
926                return RFAILED;
927             }
928             break;
929          }
930       default:
931       {
932          return RFAILED;
933       }
934    }  /* End of Switch */
935
936    return ROK;
937 }  /* rgSCHGomGetCellIdFrmCfgReq */
938
939 #ifdef RGR_SI_SCH
940 /**
941  * @brief Handler to handle SI configuration request from RRM to MAC.
942  *
943  * @details
944  *
945  *     Function: rgSCHGomHndlSiCfg
946  *     
947  *     This API handles processing for SI configuration request from RRM to MAC.
948  *     
949  *     - Processing Steps: 
950  *        - Validate SI configuration request parameters at CFG module. 
951  *          Call rgSCHCfgVldtSiCfg for SI configuration.
952  *        - If validated successfully, send configuration request to CFG.
953  *          Call rgSCHCfgRgrCellCfg else FAIL.
954  *          
955  *  @param[in]  Region        reg
956  *  @param[in]  Pool          pool
957  *  @param[in]  RgSchCb       *instCb
958  *  @param[in]  SpId          spId
959  *  @param[in]  RgrCfgTransId transId
960  *  @param[in]  RgrSiCfgReqInfo *cfgReqInfo
961  *  @return  S16
962  *      -# ROK 
963  *      -# RFAILED 
964  **/
965 S16 rgSCHGomHndlSiCfg(Region reg,Pool pool,RgSchCb *instCb,SpId spId,RgrCfgTransId transId,RgrSiCfgReqInfo *cfgReqInfo)
966 {
967    S16          ret;
968    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
969    Inst         inst = (instCb->rgSchInit.inst );
970    RgSchErrInfo errInfo;
971    uint8_t      cfmStatus = RGR_CFG_CFM_NOK;
972    MsgLen       msgLen = 0, pduLen;
973    S32          tbSz   = 0;
974    uint8_t      nPrb   = 0; 
975    uint8_t      mcs    = 0;
976
977
978    /* check if cell does not exists */
979    if (((uint8_t *)cell == NULLP) || (cell->cellId != cfgReqInfo->cellId))
980    {
981       DU_LOG("\nERROR  -->  SCH : Cell Control block does not exist");
982       RGSCH_FREE_MSG(cfgReqInfo->pdu);
983       SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
984       cfgReqInfo = NULLP;
985       rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus); 
986       return RFAILED;
987    }
988
989    /*Validate the received SI configuration */
990    ret = rgSCHCfgVldtRgrSiCfg(inst, cfgReqInfo, cell, &errInfo);
991    if (ret != ROK)
992    {
993       DU_LOG("\nERROR  -->  SCH : Rgr SI configuration "
994                "validation FAILED");
995       RGSCH_FREE_MSG(cfgReqInfo->pdu);
996       SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
997       cfgReqInfo = NULLP;
998       rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus); 
999       return RFAILED;
1000    }
1001    /*ccpu00140789: Stopping SI scheduling*/
1002    if(RGR_SI_STOP == cfgReqInfo->cfgType)
1003    {
1004       if((cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si != NULLP)&&
1005                       (cell->siCb.siArray[cfgReqInfo->siId-1].si != NULLP))
1006       {
1007          cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
1008          RGSCH_FREE_MSG(cell->siCb.siArray[cfgReqInfo->siId-1].si);
1009          cell->siCb.siArray[cfgReqInfo->siId-1].si = NULLP;
1010          if(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si != NULLP)
1011          {
1012             RGSCH_FREE_MSG(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si);
1013             cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
1014          }
1015          SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1016          cfgReqInfo = NULLP;   
1017          cfmStatus = RGR_CFG_CFM_OK;
1018          rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1019          return ROK; 
1020        }
1021        else
1022        {
1023           SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1024           cfgReqInfo = NULLP;
1025           rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1026           return RFAILED; 
1027        }
1028    }
1029
1030    /* Check if the pdu sent from application
1031     * matches a transport block size. if not,
1032     * add padding bytes. This is usually done
1033     * by RRC but since we are bypassing RRC,
1034     * MAC is taking over that responsibility
1035     */
1036    if ( RGR_SI_CFG_TYPE_MIB != cfgReqInfo->cfgType )
1037    {
1038       SFndLenMsg(cfgReqInfo->pdu, &msgLen);
1039
1040       /* check if the application pdu matches a tb size */
1041       tbSz = rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs);
1042
1043       if ( tbSz != (msgLen*8) )
1044       {
1045          MsgLen  nmPadBytes = 0;
1046          Data*   padding    = NULLP;
1047
1048          /* need to add padding bytes */
1049          nmPadBytes = (tbSz - (msgLen*8))/8;
1050
1051          if ( SGetSBuf(reg,pool,&padding,nmPadBytes) != ROK)
1052          {
1053             DU_LOG("\nERROR  -->  SCH : Rgr SI configuration "
1054                      "SGetSBuf failed for padding failed");
1055             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
1056             cfgReqInfo = NULLP;
1057             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, 
1058                                                            cfmStatus); 
1059             return RFAILED;
1060          }
1061
1062          memset(padding,0,nmPadBytes);
1063
1064 #ifdef MS_MBUF_CORRUPTION 
1065    MS_BUF_ADD_ALLOC_CALLER();
1066 #endif 
1067          if ( SAddPstMsgMult((Data*)padding,nmPadBytes,cfgReqInfo->pdu) != ROK)
1068          {
1069             DU_LOG("\nERROR  -->  SCH : Rgr SI configuration "
1070                      "Failed to add padding bytes");
1071             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
1072             cfgReqInfo = NULLP;
1073             SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1074             padding = NULLP;
1075             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, 
1076                                                             cfmStatus); 
1077             return RFAILED;
1078          }
1079          SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1080          padding = NULLP;
1081       }/* if (tbSz != ...*/
1082    }/* if (RGR_SI_CFG_TYPE_SI...*/
1083
1084    /*Set the received pdu at the appropriate place */
1085    switch(cfgReqInfo->cfgType)
1086    {
1087       case RGR_SI_CFG_TYPE_MIB:   /* SI CFG Type MIB */
1088          RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.mib, 
1089                cell->siCb.newSiInfo.mib, 
1090                cfgReqInfo->pdu, cell->siCb.siBitMask, 
1091                RGSCH_SI_MIB_UPD);
1092          break;
1093
1094       case RGR_SI_CFG_TYPE_SIB1_PWS:
1095          {
1096             SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1097             ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1098             if (ret != ROK)
1099             {
1100                DU_LOG("\nERROR  -->  SCH : Failed to get MCS and NPRB" 
1101                      "value");
1102                RGSCH_FREE_MSG(cfgReqInfo->pdu);
1103                SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
1104                cfgReqInfo = NULLP;
1105                rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, 
1106                      cfmStatus); 
1107                return RFAILED;
1108             }
1109
1110             RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1, 
1111                   cell->siCb.newSiInfo.sib1Info.sib1, 
1112                   cfgReqInfo->pdu, cell->siCb.siBitMask, 
1113                   RGSCH_SI_SIB1_PWS_UPD);
1114          }
1115          break;
1116
1117       case RGR_SI_CFG_TYPE_SIB1:
1118          SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1119          ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1120          if (ret != ROK)
1121          {
1122             DU_LOG("\nERROR  -->  SCH : Failed to get MCS and NPRB" 
1123                      "value");
1124             RGSCH_FREE_MSG(cfgReqInfo->pdu);
1125             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
1126             cfgReqInfo = NULLP;
1127             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, 
1128                                                                  cfmStatus); 
1129             return RFAILED;
1130          }
1131          RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1, 
1132                cell->siCb.newSiInfo.sib1Info.sib1, 
1133                cfgReqInfo->pdu, cell->siCb.siBitMask, 
1134                RGSCH_SI_SIB1_UPD);
1135          break;
1136
1137       case RGR_SI_CFG_TYPE_SI:    /* SI CFG TYPE SI */
1138          SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1139          ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen, 
1140                                                      cfgReqInfo->siId);
1141          if (ret != ROK)
1142          {
1143             DU_LOG("\nERROR  -->  SCH : Failed to get MCS and NPRB" 
1144                      "value");
1145             RGSCH_FREE_MSG(cfgReqInfo->pdu);
1146             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
1147             cfgReqInfo = NULLP;
1148             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, 
1149                                                                  cfmStatus); 
1150             return RFAILED;
1151          }
1152          /* Si recfg, where numSi changes */
1153          if (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) 
1154          {
1155             Buffer **newSiPdu = &cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si;
1156             if(*newSiPdu != NULLP)
1157             {
1158                RGSCH_FREE_MSG(*newSiPdu);
1159             }
1160             *newSiPdu = (Buffer *)cfgReqInfo->pdu;
1161             cell->siCb.siBitMask |= RGSCH_SI_SI_UPD;
1162          }
1163          else /* Initial Si cfg  or si recfg where numSi did not change */
1164          {
1165             uint8_t bitMask;
1166             /* Initial Si cfg */
1167             if (cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si == NULLP)
1168             {
1169                cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
1170                cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1171                bitMask = RGSCH_SI_DFLT;
1172             }
1173             else
1174             {
1175                bitMask = RGSCH_SI_SI_UPD;
1176             }
1177
1178             RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si, 
1179                 cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si, 
1180                 cfgReqInfo->pdu, 
1181                 cell->siCb.siBitMask, bitMask);
1182          }
1183          break;
1184
1185       case RGR_SI_CFG_TYPE_SIB8_CDMA:    /* SI CFG TYPE SIB 8 CDMA */
1186          SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1187          ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen, 
1188                                                      cfgReqInfo->siId);
1189          if (ret != ROK)
1190          {
1191             DU_LOG("\nERROR  -->  SCH : Failed to get MCS and NPRB" 
1192                      "value");
1193             RGSCH_FREE_MSG(cfgReqInfo->pdu);
1194             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
1195             cfgReqInfo = NULLP;
1196             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, 
1197                                                                  cfmStatus); 
1198             return RFAILED;
1199          }
1200          /* No need to wait for Modification period boundary */
1201          cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
1202          RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si,
1203                cfgReqInfo->pdu);
1204          cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1205          break;
1206       default:
1207          DU_LOG("\nERROR  -->  SCH : Invalid cfgType "
1208                   "parameter value");
1209          RGSCH_FREE_MSG(cfgReqInfo->pdu);
1210          SPutSBuf(reg, pool, (Data *)cfgReqInfo, 
1211                (Size)sizeof(*cfgReqInfo)); 
1212          cfgReqInfo = NULLP;
1213          rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, 
1214                cfmStatus); 
1215          return RFAILED;
1216    }
1217
1218    SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo)); 
1219    cfgReqInfo = NULLP;
1220    cfmStatus = RGR_CFG_CFM_OK;
1221    rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus); 
1222
1223
1224    return ROK;
1225 }  /* rgSCHGomHndlSiCfg */
1226
1227
1228 /**
1229  * @brief Handler to handle Warning SI configuration request from RRM to MAC.
1230  *
1231  * @details
1232  *
1233  *     Function: rgSCHGomHndlWarningSiCfg
1234  *     
1235  *     This API handles processing for Warning SI configuration request from 
1236  *     RRM to MAC.
1237  *     
1238  *          
1239  *  @param[in]  Region        reg
1240  *  @param[in]  Pool          pool
1241  *  @param[in]  RgSchCb       *instCb
1242  *  @param[in]  SpId          spId
1243  *  @param[in]  RgrWarningSiCfgReqInfo  *warningSiCfgReqInfo
1244  *  @return  S16
1245  *      -# ROK 
1246  *      -# RFAILED 
1247  **/
1248 S16 rgSCHGomHndlWarningSiCfg
1249 (
1250 Region        reg,
1251 Pool          pool,
1252 RgSchCb       *instCb,
1253 SpId          spId,
1254 RgrCfgTransId transId,
1255 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
1256 )
1257 {
1258    RgSchCellCb       *cell = instCb->rgrSap[spId].cell;
1259    uint8_t           cfmStatus = RGR_CFG_CFM_NOK;
1260    uint16_t          idx;
1261    uint8_t           siId = warningSiCfgReqInfo->siId; 
1262    uint8_t           j, mcs=0, nPrb=0;
1263    RgSchWarningSiSeg *warningSiMsg;
1264    RgSchWarningSiPdu *pduNode;
1265    CmLList           *node;
1266    MsgLen            msgLen = 0;
1267    Bool              freeNodeFound = FALSE;
1268    uint16_t          siWinSize = 0;
1269    uint16_t          minPeriod = 0;
1270 #ifdef EMTC_ENABLE
1271    uint8_t           isEmtc = warningSiCfgReqInfo->emtcEnable;
1272 #endif
1273
1274 #ifdef EMTC_ENABLE
1275    if(TRUE == isEmtc)
1276    {
1277       rgSchEmtcGetSiWinPerd(cell, &siWinSize, &minPeriod);
1278    }
1279    else
1280 #endif
1281    {
1282       siWinSize = cell->siCfg.siWinSize;
1283       minPeriod = cell->siCfg.minPeriodicity;
1284    }
1285    /* check if cell does not exists */
1286    if (((uint8_t *)cell == NULLP) || 
1287          (cell->cellId != warningSiCfgReqInfo->cellId) ||
1288          (warningSiCfgReqInfo->siId > 
1289           ((minPeriod * 10)/siWinSize)))
1290    {
1291       DU_LOG("\nERROR  -->  SCH : Warning SI Cfg Failed for siId = %d"
1292                 "warning cellID:%d",warningSiCfgReqInfo->siId,warningSiCfgReqInfo->cellId);
1293       rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
1294       SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo, 
1295             sizeof(RgrWarningSiCfgReqInfo)); 
1296       warningSiCfgReqInfo = NULLP;
1297       rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId, 
1298             cfmStatus); 
1299       return RFAILED;
1300    }
1301
1302    /* Search for free index in WarningSi */
1303    for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1304    {
1305       if((cell->siCb.warningSi[idx].siId == 0 ||
1306                cell->siCb.warningSi[idx].siId == warningSiCfgReqInfo->siId))
1307       {
1308          warningSiMsg = (RgSchWarningSiSeg *)&cell->siCb.warningSi[idx].warningSiMsg; 
1309
1310          /* Search for free SI node */
1311          /* ccpu00136659: CMAS ETWS design changes */
1312          if (warningSiMsg->segLstCp.first == NULLP) /* Free SI Node */
1313          {
1314             warningSiMsg->transId = transId;
1315             pduNode = (RgSchWarningSiPdu *)&cell->siCb.warningSi[idx].
1316                warningSiMsg.pduNode;
1317             CM_LLIST_FIRST_NODE(&warningSiCfgReqInfo->siPduLst, node);
1318             j = 0;
1319
1320             /* Get the PDUs one by one from the received pduLst of warning 
1321              * message and calculate the MCS and nPrb of each pdu once.
1322              * Store the pdu in warningSiMsg pduLst, which will be scheduled 
1323              * later while sending warning message as part of SIB11/SIB12 
1324              */   
1325             while((node != NULLP) && (j < RGR_MAX_WARNING_SI_SEG))
1326
1327             {
1328                pduNode[j].pdu = (Buffer *)node->node;
1329                if(pduNode[j].pdu != NULLP)
1330                {
1331                   SFndLenMsg(pduNode[j].pdu, &msgLen);
1332                   /*Get the nPrb and mcs parametr values */
1333 #ifdef EMTC_ENABLE
1334                   if (rgSCHEmtcUtlGetAllwdCchTbSzForSI(msgLen*8) != (msgLen*8))
1335 #else
1336                   if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
1337 #endif
1338
1339                   {
1340                      DU_LOG("\nERROR  -->  SCH : rgSCHGomHndlWarningSiCfg():msgLen does not match\
1341                            any valid TB Size.");
1342                      DU_LOG("\nERROR  -->  SCH : Warning SI Cfg Failed" 
1343                            "for siId = %d", warningSiCfgReqInfo->siId);
1344                      rgSCHUtlFreeWarningSiSeg(reg, pool, 
1345                            &warningSiCfgReqInfo->siPduLst);
1346                      SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo, 
1347                            sizeof(RgrWarningSiCfgReqInfo)); 
1348                      warningSiCfgReqInfo = NULLP;
1349                      rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId,
1350                            siId, transId,cfmStatus); 
1351                      return RFAILED;
1352
1353                   }
1354                }
1355                pduNode[j].mcs = mcs;
1356                pduNode[j].nPrb = nPrb;
1357                pduNode[j].msgLen = msgLen;
1358                /* ccpu00136659: CMAS ETWS design changes */
1359                cmLListAdd2Tail(&warningSiMsg->segLstCp, &pduNode[j].lnk);
1360                pduNode[j].lnk.node = (PTR)&pduNode[j];
1361                j++;
1362                node = node->next;
1363             }
1364
1365             /* ccpu00132385-  nodes in received SI config linked list should 
1366              * be freed after processing the config.*/
1367             while(warningSiCfgReqInfo->siPduLst.first != NULLP)
1368             {
1369                node = warningSiCfgReqInfo->siPduLst.first;
1370                cmLListDelFrm(&(warningSiCfgReqInfo->siPduLst), node);
1371                SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
1372                node = NULLP;
1373             } 
1374
1375             cell->siCb.warningSi[idx].siId = warningSiCfgReqInfo->siId;
1376             cell->siCb.warningSi[idx].idx = idx;
1377 #ifdef EMTC_ENABLE
1378             if(TRUE == isEmtc)
1379             {
1380                rgSCHEmtcWarningSiCfg(cell,warningSiCfgReqInfo,idx);
1381             }
1382             else
1383 #endif
1384             {
1385                cell->siCb.siArray[warningSiCfgReqInfo->siId-1].si = 
1386                   &cell->siCb.warningSi[idx];
1387                cell->siCb.siArray[warningSiCfgReqInfo->siId-1].isWarningSi =
1388                   TRUE;
1389             }
1390             freeNodeFound = TRUE;
1391             break;
1392          }
1393       }
1394    }
1395
1396    if (freeNodeFound == FALSE)
1397    {
1398       DU_LOG("\nDEBUG  -->  SCH : No SI Index is free");
1399       rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
1400       SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo, 
1401             sizeof(RgrWarningSiCfgReqInfo)); 
1402       warningSiCfgReqInfo = NULLP;
1403       rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId, 
1404             cfmStatus); 
1405       return RFAILED;
1406    }
1407
1408    SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo, 
1409          sizeof(RgrWarningSiCfgReqInfo)); 
1410    warningSiCfgReqInfo = NULLP;
1411    return ROK;
1412 }
1413
1414 \f
1415 /**
1416  * @brief Handler to handle SI Stop request from RRM to MAC.
1417  *
1418  * @details
1419  *
1420  *     Function: rgSCHGomHndlWarningSiStopReq
1421  *     
1422  *     This API handles processing for SI stop request from RRM to MAC.
1423  *     
1424  *  @param[in]  Region        reg
1425  *  @param[in]  Pool          pool
1426  *  @param[in]  RgSchCb       *instCb
1427  *  @param[in]  SpId          siId
1428  *  @return  void
1429  **/
1430 Void rgSCHGomHndlWarningSiStopReq(Region reg,Pool pool,RgSchCb *instCb,uint8_t siId,RgrCfgTransId transId,SpId spId)
1431 {
1432    RgSchCellCb        *cell = instCb->rgrSap[spId].cell;
1433    uint16_t           idx;
1434    CmLList            *node;
1435    RgSchWarningSiPdu  *warningSiPdu;
1436    Buffer             *pdu;
1437
1438    for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1439    {
1440       if(cell->siCb.warningSi[idx].siId == siId)
1441       {
1442          if ((cmMemcmp ((uint8_t *)&cell->siCb.warningSi[idx].warningSiMsg.transId, 
1443                      (uint8_t *)&transId, sizeof(RgrCfgTransId))) == 0)
1444          {
1445             /* ccpu00136659: CMAS ETWS design changes */
1446             CM_LLIST_FIRST_NODE(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
1447             while(node != NULLP)
1448             {
1449                /* On receiving the warning stop message, remove one by one
1450                 * each PDU from the warning SI list
1451                 */  
1452                /* ccpu00136659: CMAS ETWS design changes */
1453                node = (CmLList *)&cell->siCb.warningSi[idx].warningSiMsg.segLstCp.first;
1454                warningSiPdu = (RgSchWarningSiPdu *)node->node;
1455                pdu = warningSiPdu->pdu;
1456                cmLListDelFrm(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
1457                RGSCH_FREE_MSG(pdu);
1458                node = node->next;
1459             }
1460          }
1461       }
1462    }
1463    return;
1464 }
1465
1466 #endif/*RGR_SI_SCH */
1467 \f
1468 /* LTE_ADV_FLAG_REMOVED_START */
1469
1470 /**
1471  * @brief This function sets the Phigh range for CC users corresponding to the CC Pool
1472  * @details
1473  *
1474  *     Function: rgSchUpdtRNTPInfo
1475  *
1476  *     Invoked by: rgSCHGomHndlLoadInf
1477  *
1478  *  @param[in]  RgSchCellCb*     cell
1479  *  @param[in]  RgSubFrm*     subFrm
1480  *  @param[in]  RgrLoadInfReqInfo   *loadInfReq
1481  *  @return  S16
1482  *
1483  **/
1484 S16 rgSchUpdtRNTPInfo(RgSchCellCb *cell,RgSchDlSf *sf,RgrLoadInfReqInfo *loadInfReq)
1485 {
1486    /*  Initialise the variables */
1487    RgSchSFRPoolInfo *sfrCCPool;
1488    CmLListCp   *l;
1489    CmLList     *n;
1490    S16 ret = RFAILED;
1491
1492    l = &sf->sfrTotalPoolInfo.ccPool;
1493
1494    /*Get the first node from the CC Pool*/
1495    n = cmLListFirst(l);
1496    while(n)
1497    {
1498       sfrCCPool = (RgSchSFRPoolInfo*)n->node;
1499       if (sfrCCPool->poolendRB == loadInfReq->rgrCcPHighEndRb)
1500       {
1501          sfrCCPool->pwrHiCCRange.endRb   = loadInfReq->rgrCcPHighEndRb;
1502          sfrCCPool->pwrHiCCRange.startRb = loadInfReq->rgrCcPHighStartRb;
1503          return ROK;
1504       }
1505       else
1506       {
1507          n = cmLListNext(l);
1508       }
1509    }
1510    return (ret);
1511 }
1512 /**
1513  * @brief Handler to handle LOAD INF request from RRM to MAC.
1514  *
1515  * @details
1516  *
1517  *     Function: rgSCHGomHndlLoadInf
1518  *
1519  *     This API handles processing for LOAD INF request from RRM to MAC.
1520  *
1521  *     - Processing Steps:
1522  *        - Validate LOAD INF request parameters at CFG module.
1523  *          Call rgSCHCfgVldtRgrLoadInf for SI configuration.
1524  *        - If validated successfully, send configuration request.
1525  *
1526  *  @param[in]  Region            reg
1527  *  @param[in]  Pool              pool
1528  *  @param[in]  RgSchCb           *instCb
1529  *  @param[in]  SpId              spId
1530  *  @param[in]  RgrCfgTransId     transId
1531  *  @param[in]  RgrLoadInfReqInfo *loadInfReq
1532  *  @return  S16
1533  *      -# ROK
1534  *      -# RFAILED
1535  **/
1536 S16 rgSCHGomHndlLoadInf(Region reg,Pool pool,RgSchCb *instCb,SpId spId,RgrCfgTransId transId,RgrLoadInfReqInfo *loadInfReq)
1537 {
1538    S16          ret;
1539    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
1540    Inst         inst  = (instCb->rgSchInit.inst );
1541    RgSchErrInfo errInfo;
1542    uint16_t i;
1543
1544    /* check if cell does not exists */
1545    if (((uint8_t *)cell == NULLP) || (cell->cellId != loadInfReq->cellId))
1546    {
1547       DU_LOG("\nERROR  -->  SCH : Cell Control block does not exist"
1548              "for load cellId:%d",loadInfReq->cellId);
1549       SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1550       return RFAILED;
1551    }
1552
1553    if (cell->lteAdvCb.dsfrCfg.status == RGR_DISABLE)
1554    {
1555       DU_LOG("\nERROR  -->  SCH : rgSCHGomHndlLoadInf(): DSFR Feature not enabled");
1556       SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1557       return RFAILED;
1558    }
1559    /* Validate the received LOAD INF Configuration */
1560    ret = rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, &errInfo);
1561    if (ret != ROK)
1562    {
1563       DU_LOG("\nERROR  -->  SCH : Rgr LOAD INF Configuration "
1564                "validation FAILED");
1565       SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1566       return RFAILED;
1567    }
1568    /* Update the RNTP info rcvd in the respective cell centre pool so that Phigh can be
1569       sent for the UEs scheduled in that particular RB range*/
1570    for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
1571    {
1572       if((rgSchUpdtRNTPInfo(cell, cell->subFrms[i], loadInfReq) != ROK))
1573       {
1574          return RFAILED;
1575       }
1576    }
1577
1578    SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1579
1580
1581    return ROK;
1582 }  /* rgSCHGomHndlLoadInf */
1583 /* LTE_ADV_FLAG_REMOVED_END */
1584 \f
1585 /**********************************************************************
1586  
1587          End of file
1588 **********************************************************************/