RAR_message
[o-du/l2.git] / src / 5gnrmac / rg_com.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 functions
26   
27      File:     rg_com.c 
28   
29 **********************************************************************/
30
31 /** @file rg_com.c
32 @brief This module does processing related to handling of upper interface APIs 
33 invoked by RRC towards MAC.
34 */
35
36 static const char* RLOG_MODULE_NAME="MAC";
37 static int RLOG_FILE_ID=181;
38 static int RLOG_MODULE_ID=4096;
39 /* header include files -- defines (.h) */
40 #include "envopt.h"        /* environment options */
41 #include "envdep.h"        /* environment dependent */
42 #include "envind.h"        /* environment independent */
43 #include "gen.h"           /* general layer */
44 #include "ssi.h"           /* system service interface */
45 #include "cm_hash.h"       /* common hash list */
46 #include "cm_mblk.h"       /* common memory link list library */
47 #include "cm_llist.h"      /* common linked list library */
48 #include "cm_err.h"        /* common error */
49 #include "cm_lte.h"        /* common LTE */
50 #include "lrg.h"
51 #include "crg.h"
52 #include "rgu.h"
53 #include "tfu.h"
54 #include "rg_sch_inf.h"
55 #include "rg_prg.h"       /* PRG interface includes*/
56 #include "rg_env.h"
57 #include "rg.h"
58 #include "rg_err.h"
59
60 /* header/extern include files (.x) */
61 #include "gen.x"           /* general layer */
62 #include "ssi.x"           /* system service interface */
63 #include "cm5.x"           /* common timers */
64 #include "cm_lib.x"        /* common library */
65 #include "cm_hash.x"       /* common hash list */
66 #include "cm_mblk.x"       /* common memory link list library */
67 #include "cm_llist.x"      /* common linked list library */
68 #include "cm_tkns.x"       /* common tokens */
69 #include "cm_lte.x"        /* common LTE */
70 #include "lrg.x"
71 #include "crg.x"
72 #include "rgu.x"
73 #include "tfu.x"
74 #include "rg_sch_inf.x"
75 #include "rg_prg.x"       /* PRG interface typedefs*/
76 #include "du_app_mac_inf.h"
77 #include "rg.x"
78 #ifdef LTE_ADV
79 #include "rg_pom_scell.x"
80 #endif
81 /* local defines */
82 PRIVATE S16 rgCOMHndlCfgReq ARGS((Inst inst,CrgCfg  *cfg, RgErrInfo *errInfo,Bool *isCfmRqrd,CrgCfgTransId transId));
83 PRIVATE S16 rgCOMHndlRecfgReq ARGS((Inst inst,CrgRecfg *recfg, RgErrInfo *errInfo, \
84          CrgCfgTransId transId,Bool *isCfmRqrd));
85 PRIVATE S16 rgCOMHndlDelReq ARGS((Inst inst,CrgDel *del, RgErrInfo *errInfo, Bool *isCfmRqrd, CrgCfgTransId transId));
86 PRIVATE S16 rgCOMHndlResetReq ARGS((Inst inst,CrgRst *reset,RgErrInfo *errInfo));
87 /* local typedefs */
88  
89 /* local externs */
90  
91 /* forward references */
92
93 /**
94  * @brief Handler to handle config request from RRC to MAC.
95  *
96  * @details
97  *
98  *     Function: rgCOMCfgReq
99  *     
100  *     This API handles processing for config request from RRC to MAC. 
101  *     
102  *     Processing Steps:
103  *      - If configuration, process configuration request. Call rgCOMHndlCfgReq.
104  *      - else If re-configuration, process re-configuration request. 
105  *        Call rgCOMHndlRecfgReq.
106  *      - else If reset, process reset request. Call rgCOMHndlResetReq.
107  *      - else If delete, process delete request. Call rgCOMHndlDelReq.
108  *      - If successful, send confirmation to RRC. Call rgUIMCrgCfgCfm.
109  *      - If failed, FAIL.
110  *
111  *  @param[in]  Inst        inst
112  *  @param[in]  CrgCfgTransId transId
113  *  @param[in]  CrgCfgReqInfo *crgCfgReq
114  *  @return  S16
115  *      -# ROK 
116  *      -# RFAILED 
117  **/
118 #ifdef ANSI
119 PUBLIC S16 rgCOMCfgReq
120 (
121 Inst          inst,
122 CrgCfgTransId transId,
123 CrgCfgReqInfo *crgCfgReq
124 )
125 #else
126 PUBLIC S16 rgCOMCfgReq(inst,transId, crgCfgReq)
127 Inst          inst;
128 CrgCfgTransId transId;
129 CrgCfgReqInfo *crgCfgReq;
130 #endif
131 {
132    S16             ret;
133    U8              cfmStatus = CRG_CFG_CFM_OK;
134    RgErrInfo       errInfo;
135    Bool            isCfmRqrd = TRUE;
136
137    TRC2(rgCOMCfgReq);
138
139    /* Process Config/Reconfig/Delete request from RRC */
140    switch (crgCfgReq->action)
141    {
142       case CRG_CONFIG:
143          {
144             ret = rgCOMHndlCfgReq(inst,&crgCfgReq->u.cfgInfo, &errInfo,&isCfmRqrd, transId);
145             break;
146          }
147       case CRG_RECONFIG:
148          {
149             ret = rgCOMHndlRecfgReq(inst,&crgCfgReq->u.recfgInfo, &errInfo, transId, &isCfmRqrd);
150             break;
151          }
152          /* Start: LTEMAC_2.1_DEV_CFG */
153       case CRG_RESET:
154          {
155             ret = rgCOMHndlResetReq(inst,&crgCfgReq->u.rstInfo, &errInfo);
156             break;
157          }
158          /* End: LTEMAC_2.1_DEV_CFG */
159       case CRG_DELETE:
160          {
161             ret = rgCOMHndlDelReq(inst,&crgCfgReq->u.delInfo, &errInfo, &isCfmRqrd, transId);
162             break;
163          }
164       default:
165          {
166             RLOG1(L_ERROR, "Invalid configuration action %d",
167                      crgCfgReq->action);
168
169             ret = RFAILED;
170          }
171    }
172
173    if (ret != ROK)
174    {
175       cfmStatus = CRG_CFG_CFM_NOK;
176    }
177
178    /* When UeSCellCfg is present then confirmation will be sent later once
179       confirm from all SMAC are recved at PMAC. PMAC will send a consolidated
180       confirm to RRC.Handling the failure of PMAC for Ue Scell add*/
181 #ifdef LTE_ADV
182 if(TRUE == isCfmRqrd)
183    {
184 #endif
185       /* Send back confirmation status to RRC */
186       rgUIMCrgCfgCfm(inst,transId, cfmStatus); 
187 #ifdef LTE_ADV
188    }
189 #endif
190    RGDBGINFO(inst,(rgPBuf(inst), "CRG Configuration request processed\n"));
191    RETVALUE(ret);
192 }  /* rgCOMCfgReq */
193 /**
194  * @brief Handler for processing Cell/Ue/Logical channel configuration request
195  * recieved from RRC.
196  *
197  * @details
198  *
199  *     Function: rgCOMHndlCfgReq
200  *     
201  *     This API handles processing of configuration request from RRC to MAC. 
202  *     
203  *     Processing Steps:
204  *        - Validate configuration request parameters at CFG module. 
205  *          Call rgCFGVldtCrgCellCfg, rgCFGVldtCrgUeCfg, rgCFGVldtCrgLcCfg 
206  *          for Cell, UE and Logical channel configuration respectively.
207  *        - If validated successfully, Call rgCFGCrgCellCfg, rgCFGCrgUeCfg, 
208  *          rgCFGCrgLcCfg for Cell, UE and Logical channel configuration 
209  *          respectively, else FAIL.
210  *
211  *  @param[in]  Inst        inst
212  *  @param[in]  CrgCfg    *cfg
213  *  @param[out] RgErrInfo *errInfo
214  *  @return  S16
215  *      -# ROK 
216  *      -# RFAILED 
217  **/
218 #ifdef ANSI
219 PRIVATE S16 rgCOMHndlCfgReq
220 (
221 Inst             inst,
222 CrgCfg           *cfg,
223 RgErrInfo        *errInfo,
224 Bool             *isCfmRqrd,
225 CrgCfgTransId    transId
226 )
227 #else
228 PRIVATE S16 rgCOMHndlCfgReq(inst,cfg, errInfo,isCfmRqrd,transId)
229 Inst            inst;
230 CrgCfg          *cfg;
231 RgErrInfo       *errInfo;
232 Bool            *isCfmRqrd;
233 CrgCfgTransId   transId;
234 #endif
235 {
236    S16       ret;
237    RgCellCb  *cell = NULLP;
238    RgUeCb    *ue   = NULLP;
239
240    TRC2(rgCOMHndlCfgReq);
241
242    errInfo->errType = RGERR_COM_CFG_REQ;
243
244    /* Validate and process the configuration request */ 
245    switch (cfg->cfgType)
246    {
247       case CRG_CELL_CFG:
248       {
249          ret = rgCFGVldtCrgCellCfg(inst,&cfg->u.cellCfg,errInfo);
250          if (ret != ROK)
251          {
252               RLOG_ARG0(L_ERROR,DBG_CELLID,cfg->u.cellCfg.cellId, "Cell configuration validation FAILED\n");
253               RETVALUE(RFAILED);
254          }
255          ret = rgCFGCrgCellCfg(inst,&cfg->u.cellCfg, errInfo);
256          break;
257       }
258       case CRG_UE_CFG:
259       {
260          {
261             ret = rgCFGVldtCrgUeCfg(inst,&cfg->u.ueCfg, &cell, errInfo);
262             if (ret != ROK)
263             {
264                RLOG_ARG0(L_ERROR,DBG_CRNTI,cfg->u.ueCfg.crnti, "Ue configuration validation FAILED\n");
265                RETVALUE(RFAILED);
266             }
267             ret = rgCFGCrgUeCfg(inst,cell, &cfg->u.ueCfg, errInfo);
268          }
269          break;
270       }
271       case CRG_LCH_CFG:
272       {
273
274          ret = rgCFGVldtCrgLcCfg(inst,&cfg->u.lchCfg, &cell, &ue,errInfo);
275          if (ret != ROK)
276          {
277             
278             RLOG_ARG1(L_ERROR,DBG_CELLID,cfg->u.cellCfg.cellId,
279                          "LC configuration validation FAILED: LC %d\n", cfg->u.lchCfg.lcId);
280             RETVALUE(RFAILED);
281          }
282          ret = rgCFGCrgLcCfg(inst,cell, ue, &cfg->u.lchCfg, errInfo,isCfmRqrd,transId);
283          break;
284       }
285       default:
286       {
287          RLOG1(L_ERROR, "Should never come here: cfgType %d",cfg->cfgType);
288          RETVALUE(RFAILED);
289       }
290    }
291
292    RETVALUE(ret);
293 }  /* rgCOMHndlCfgReq */
294
295
296 /**
297  * @brief Handler for processing Cell/Ue/Logical channel re-configuration request
298  * recieved from RRC.
299  *
300  * @details
301  *
302  *     Function: rgCOMHndlRecfgReq
303  *     
304  *     This API handles processing of reconfiguration request from RRC to MAC. 
305  *     
306  *     Processing Steps:
307  *      - Validate reconfiguration request parameters at CFG module. Call 
308  *        rgCFGVldtCrgCellRecfg, rgCFGVldtCrgUeRecfg, rgCFGVldtCrgLchRecfg for 
309  *        Cell, UE and logical channel reconfiguration respectively.
310  *      - If validated, Call rgCFGCrgCellRecfg, rgCFGCrgUeRecfg, 
311  *        rgCFGCrgLchRecfg for Cell, UE and Logical channel re-configuration 
312  *        respectively else FAIL.
313  *
314  *  @param[in]  Inst        inst
315  *  @param[in]  CrgRecfg   *recfg
316  *  @param[out] RgErrInfo  *errInfo
317  *  @return  S16
318  *      -# ROK 
319  *      -# RFAILED 
320  **/
321 #ifdef ANSI
322 PRIVATE S16 rgCOMHndlRecfgReq
323 (
324 Inst             inst,
325 CrgRecfg         *recfg,
326 RgErrInfo        *errInfo,
327 CrgCfgTransId    transId,
328 Bool             *isCfmRqrd
329 )
330 #else
331 PRIVATE S16 rgCOMHndlRecfgReq(inst,recfg, errInfo, transId, isCfmRqrd)
332 Inst            inst;
333 CrgRecfg        *recfg;
334 RgErrInfo       *errInfo;
335 CrgCfgTransId   transId;
336 Bool            *isCfmRqrd;
337 #endif
338 {
339    S16       ret;
340    RgCellCb  *cell = rgCb[inst].cell;
341    RgUeCb    *ue   = NULLP;
342    RgUlLcCb  *ulLc = NULLP;
343
344    TRC2(rgCOMHndlRecfgReq);
345
346    errInfo->errType = RGERR_COM_RECFG_REQ;
347    
348    /* Validate and process the re-configuration request */ 
349    switch (recfg->recfgType)
350    {
351       case CRG_CELL_CFG:
352       {
353          ret = rgCFGVldtCrgCellRecfg(inst,&recfg->u.cellRecfg, &cell, errInfo);
354             if (ret != ROK) 
355             {
356                RLOG_ARG0(L_ERROR,DBG_CELLID,recfg->u.cellRecfg.cellId,
357                          "Cell Recfg Validation FAILED");
358                RETVALUE(RFAILED);
359             }
360          ret = rgCFGCrgCellRecfg(inst,cell, &recfg->u.cellRecfg, errInfo);
361          break;
362       }
363       case CRG_UE_CFG:
364       {
365          /*ccpu00126865 - Added as a part of RRC Reestablishment issue with MAC
366           * having a possibility of sending NOK */
367          if (recfg->u.ueRecfg.oldCrnti != recfg->u.ueRecfg.newCrnti)
368          {
369             errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
370             ret = ROK;
371          }    
372          else
373          {
374 #ifdef LTE_ADV
375          /* Check for isSCellCfgPres */
376          if(TRUE == recfg->u.ueRecfg.crgSCellCfg.isSCellCfgPres)
377          {
378             ret = rgFillAndAddSCellCfg(inst, cell, &recfg->u.ueRecfg, transId, isCfmRqrd);
379             if (ret != ROK)
380             {
381                RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue SCell configuration FAILED for inst [%d]\n",
382                         recfg->u.ueRecfg.oldCrnti, inst));
383                RETVALUE(RFAILED);
384             }
385
386          }
387          else
388          {
389 #endif /* LTE_ADV */
390             ret = rgCFGVldtCrgUeRecfg(inst,&recfg->u.ueRecfg, &cell, &ue, errInfo);
391             if ( ret != ROK)
392             {
393                RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.ueRecfg.cellId,
394                       "Ue Re-configuration validation FAILED OLD CRNTI:%d",
395                       recfg->u.ueRecfg.oldCrnti);
396                RETVALUE(RFAILED);
397             }
398             ret = rgCFGCrgUeRecfg(inst,cell, ue, &recfg->u.ueRecfg, errInfo);
399          }
400 #ifdef LTE_ADV
401          }
402 #endif
403          break;
404       }
405       case CRG_LCH_CFG:
406       {
407          ret = rgCFGVldtCrgLcRecfg(inst,&recfg->u.lchRecfg, &cell, &ue, 
408                &ulLc, errInfo);
409          if (ret != ROK)
410          {
411             RLOG_ARG2(L_ERROR,DBG_CELLID,recfg->u.lchRecfg.cellId,
412                       "LC Re-configuration validation FAILED LCID:%d CRNTI:%d",
413                       recfg->u.lchRecfg.lcId,recfg->u.lchRecfg.crnti);
414             RETVALUE(RFAILED);
415          }
416
417 #ifdef LTE_ADV
418          /*ERAB- multicell fix*/
419          cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
420                sizeof(CrgCfgTransId));
421 #endif
422          ret = rgCFGCrgLcRecfg(inst,cell, ue, ulLc,
423                &recfg->u.lchRecfg, errInfo,isCfmRqrd);
424
425          break;
426       }
427       default:
428       {
429          RLOG1(L_ERROR, "Should never come here: recfgType %d",
430                   recfg->recfgType);
431          RETVALUE(RFAILED);
432       }
433    }
434
435    RETVALUE(ret);
436 }  /* rgCOMHndlRecfgReq */
437
438 /*Start: LTEMAC_2.1_DEV_CFG */
439 /**
440  * @brief Handler for processing UE Reset request recieved from RRC.
441  *
442  * @details
443  *
444  *     Function: rgCOMHndlResetReq
445  *     
446  *     This API handles processing of Reset request from RRC to MAC. 
447  *     
448  *     Processing Steps:
449  *      - Validate reset request parameters at CFG module. Call 
450  *        rgCFGVldtCrgUeReset for UE reset.
451  *      - If validated, Call rgCFGCrgUeReset for UE reset, else FAIL.
452  *
453  *  @param[in]  Inst        inst
454  *  @param[in]  CrgRst     *reset
455  *  @param[out] RgErrInfo  *errInfo
456  *  @return  S16
457  *      -# ROK 
458  *      -# RFAILED 
459  **/
460 #ifdef ANSI
461 PRIVATE S16 rgCOMHndlResetReq
462 (
463 Inst       inst,
464 CrgRst     *reset,
465 RgErrInfo  *errInfo
466 )
467 #else
468 PRIVATE S16 rgCOMHndlResetReq(inst,reset, errInfo)
469 Inst       inst;
470 CrgRst     *reset;
471 RgErrInfo  *errInfo;
472 #endif
473 {
474    TRC2(rgCOMHndlResetReq);
475
476    /* Fix : ccpu00126865: ignore CRG reset. Let SCH trigger it. */
477    
478    errInfo->errCause = RGERR_NONE;
479    RGDBGINFO(inst,(rgPBuf(inst), "CRG UE Reset processed \n"));
480    RETVALUE(ROK);
481 }  /* rgCOMHndlResetReq */
482 /*End: LTEMAC_2.1_DEV_CFG */
483
484 /**
485  * @brief Handler for processing Cell/UE/Logical channel delete request
486  * recieved from RRC.
487  *
488  * @details
489  *
490  *     Function: rgCOMHndlDelReq
491  *     
492  *     This API handles processing of delete request from RRC to MAC. 
493  *     
494  *     Processing Steps:
495  *        - Fetch corresponding control block and pass it to CFG module.
496  *        - If control block does not exist, FAIL.
497  *
498  *  @param[in]  Inst        inst
499  *  @param[in]  CrgDel    *del
500  *  @param[out] RgErrInfo *errInfo
501     @param[out] Bool      *isCfmRqrd
502  *  @return  S16
503  *      -# ROK 
504  *      -# RFAILED 
505  **/
506 #ifdef ANSI
507 PRIVATE S16 rgCOMHndlDelReq
508 (
509 Inst        inst,
510 CrgDel      *del,
511 RgErrInfo   *errInfo,
512 Bool        *isCfmRqrd,
513 CrgCfgTransId transId
514 )
515 #else
516 PRIVATE S16 rgCOMHndlDelReq(inst,del, errInfo,isCfmRqrd,transId)
517 Inst        inst;
518 CrgDel      *del;
519 RgErrInfo   *errInfo;
520 Bool        *isCfmRqrd;
521 CrgCfgTransId transId;
522 #endif
523 {
524
525    S16            ret;
526    VOLATILE U32   startTime=0;
527
528    TRC2(rgCOMHndlDelReq);
529    
530    errInfo->errType = RGERR_COM_DEL_REQ;
531    
532    /* Process the delete request */ 
533    switch (del->delType)
534    {
535       case CRG_CELL_CFG:
536       {
537          ret = rgCFGCrgCellDel(inst,del, errInfo);
538          break;
539       }
540       case CRG_UE_CFG:
541       {
542          /*starting Task*/ 
543          SStartTask(&startTime,PID_MAC_UE_DEL);
544
545
546          ret = rgCFGCrgUeDel(inst,del, errInfo);
547          RGDBGINFONEW(inst,(rgPBuf(inst),"[%d] Delete UE Done \n", del->u.ueDel.crnti));
548
549          /*stoping Task*/ 
550          SStopTask(startTime,PID_MAC_UE_DEL);
551
552          break;
553       }
554       case CRG_LCH_CFG:
555       {
556          ret = rgCFGCrgLcDel(inst,del, errInfo,isCfmRqrd, transId);
557          break;
558       }
559       default:
560       {
561          RLOG1(L_ERROR, "Should never come here: delType %d",
562                   del->delType);
563          RETVALUE(RFAILED);
564       }
565    }
566
567    RETVALUE(ret);
568 }  /* rgCOMHndlDelReq */
569
570 #ifdef LTE_ADV
571 /**
572  * @brief Handler for the SCell configuration request from RRC to MAC.
573  *
574  * @details
575  *
576  *     Function : RgPrgPMacSMacUeSCellCfgReq
577  *
578  *     Processing Steps:
579  *      - Allocate and create UE control block.
580  *      - Update UE control block with the values recieved in the
581  *        configuration.
582  *      - If successful, add the control block to hash list of UEs for the cell
583  *        else Rollback and FAIL.
584  *
585  *  @param[in]  Pst          *pst
586  *  @param[in]  RgPrgUeSCellCfgInfo *ueSCellCb
587  *  @return  S16
588  *      -# ROK
589  *      -# RFAILED
590  **/
591 #ifdef ANSI
592 PUBLIC S16 RgPrgPMacSMacUeSCellCfgReq
593 (
594 Pst         *pst,    
595 RgPrgUeSCellCfgInfo *ueSCellCb
596 )
597 #else
598 PUBLIC S16 RgPrgPMacSMacUeSCellCfgReq(pst, ueSCellCb)
599 Pst         *pst;    
600 RgPrgUeSCellCfgInfo *ueSCellCb;
601 #endif
602 {
603    RgPrgCfgCfmInfo  cfgCfm;
604    Inst             inst = pst->dstInst;
605    RgCellCb         *cell = rgCb[inst].cell;
606    S16              ret;
607    Pst              cfmPst;    
608
609    TRC2(RgPrgPMacSMacUeSCellCfgReq);
610    
611    RGDBGPRM(inst,(rgPBuf(inst),
612             "APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d\n",
613             ueSCellCb->cellId, ueSCellCb->ueId));
614
615    cfgCfm.ueId = ueSCellCb->ueId;
616    cfgCfm.sCellId = ueSCellCb->cellId;
617    cfgCfm.status = PRG_CFG_CFM_OK;
618    cfgCfm.event = EVTPRGUESCELLCFGCFM;
619    rgGetPstToInst(&cfmPst, inst, pst->srcInst);
620
621   ret = rgUtlVltdAddSCellCfg(ueSCellCb, cell, inst);
622   if(ret != ROK)
623   {
624      RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Crg Ue SCell failed:\
625               cellId %d\n", ueSCellCb->ueId, ueSCellCb->cellId));
626      /* Set status as Not OK*/
627      cfgCfm.status = PRG_CFG_CFM_NOK;
628   }
629   else
630   {
631      ret = rgCfgAddUeSCellCfg(inst, ueSCellCb, cell);
632      if(ret != ROK)
633      {
634         RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Crg Ue SCell failed:\
635                  cellId %d\n", ueSCellCb->ueId, ueSCellCb->cellId));
636         /* Set status as Not OK*/
637         cfgCfm.status = PRG_CFG_CFM_NOK;
638      }
639   }
640   
641   RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]Crg Ue SCell Config done:\
642            cellId %d\n", ueSCellCb->ueId, ueSCellCb->cellId));
643
644   /* Send positive confirmation to primary cell*/
645   RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
646   RETVALUE(ROK);
647 }  /* RgPrgPMacSMacUeSCellCfgReq */
648
649 /**
650  * @brief Hander for config confim from sec MAC to Pri mac for Add Scell Cfg.
651  *
652  * @details
653  *
654  *     Function : RgPrgSMacPMacCfgCfm
655  *
656  *     Processing Steps:
657  *      - Allocate and create UE control block.
658  *      - If cfm event is lch recfg then send the confirmation to RRC for
659  *        that event.
660  *      - If cfm event is Scell addition then send the confirmation to RRC for
661  *        the same.
662  *         - Update UE control block with the values received in the
663  *           configuration.
664  *         - If successful, add the control block to hash list of UEs for the cell
665  *           else Rollback and FAIL.
666  *
667  *  @param[in]  Inst        dstMacInst
668  *  @param[in]  RgUrSCellCb  *ueSCellCb
669  *  @return  S16
670  *      -# ROK
671  *      -# RFAILED
672  **/
673 #ifdef ANSI
674 PUBLIC S16 RgPrgSMacPMacCfgCfm
675 (
676 Pst             *pst,    
677 RgPrgCfgCfmInfo *cfgCfm
678 )
679 #else
680 PUBLIC S16 RgPrgSMacPMacCfgCfm(pst, cfgCfm)
681 Pst             *pst;    
682 RgPrgCfgCfmInfo *cfgCfm;
683 #endif
684 {
685    Inst      inst = pst->dstInst;
686    RgCellCb *cell;
687    RgUeCb   *ue;
688    TRC2(RgPrgSMacPMacCfgCfm);
689
690
691    RG_IS_INST_VALID(inst);
692
693    RGDBGPRM(pst->dstInst,(rgPBuf(pst->dstInst),
694             "Config Confirm Rcvd from Inst %d ueId %d cellId %d\n",
695             pst->srcInst, cfgCfm->ueId, cfgCfm->cellId));
696
697    cell = rgCb[inst].cell;
698
699    if ((ue = rgDBMGetUeCb(cell, cfgCfm->ueId)) == NULLP)
700    {
701       RGDBGERRNEW(inst,(rgPBuf(inst), 
702                "[%d]Ue does not exist\n", cfgCfm->ueId));
703       RETVALUE(RFAILED);
704    }
705    switch(cfgCfm->event)
706    {
707       /* cfgCount increment for all cases */
708       case EVTPRGUESCELLLCHMODCFM:
709       case EVTPRGUESCELLLCHDELCFM:
710       case EVTPRGUESCELLLCHADDCFM:
711          {
712             ue->cfgCfmInfo.cfgCfgCount++;
713             ue->cfgCfmInfo.mask |= cfgCfm->status;
714             if(ue->cfgCfmInfo.numSCells == ue->cfgCfmInfo.cfgCfgCount)
715             {
716                ue->cfgCfmInfo.cfgCfgCount = 0;
717                /* Send back confirmation status to RRC */
718                rgUIMCrgCfgCfm(inst, ue->cfgCfmInfo.transId, ue->cfgCfmInfo.mask);
719                ue->cfgCfmInfo.mask = 0;
720                RGDBGINFO(inst,(rgPBuf(inst), "CRG Configuration request processed\n"));
721             }
722          }
723          break;
724       case EVTPRGUESCELLCFGCFM:
725          {
726             /*Commit Added SCell info to UeCb as we confirmation received */
727             if(PRG_CFG_CFM_OK == cfgCfm->status)
728             {
729                ue->sCelInfo[pst->srcInst].isSCellAdded = TRUE;
730                ue->sCelInfo[pst->srcInst].macInst = pst->srcInst;
731                ue->sCelInfo[pst->srcInst].sCellId = cfgCfm->sCellId;
732             }
733
734             ue->cfgCfmInfo.cfgCfgCount++;
735             ue->cfgCfmInfo.mask |= cfgCfm->status;
736             if(ue->cfgCfmInfo.numSCells == ue->cfgCfmInfo.cfgCfgCount)
737             {
738                ue->cfgCfmInfo.cfgCfgCount = 0;
739                /* Send back confirmation status to RRC */
740                rgUIMCrgCfgCfm(inst, ue->cfgCfmInfo.transId, ue->cfgCfmInfo.mask);
741                ue->cfgCfmInfo.mask = 0;
742                RGDBGINFO(inst,(rgPBuf(inst), "CRG Configuration request processed\n"));
743             }
744          }
745          break;
746       default:
747          {
748             RGDBGERRNEW(inst,(rgPBuf(inst), "Invalid configuration confirm event %d\n",
749                      cfgCfm->event));
750
751             RETVALUE(RFAILED);
752          }
753
754    }
755    RETVALUE(ROK);
756 }  /* RgPrgSMacPMacCfgCfm */
757
758 /**
759  * @brief Function for handling UE release for SCELL
760  * triggered from Primary Cell
761  *
762  * @details
763  *
764  *     Function : RgPrgPMacSMacUeSCellDelReq
765  *     
766  *        - This Function should be invoked by PCell of UE
767  *        - Remove the UE context from SCELL corresponding to rnti.
768  *           
769  *  @param[in] Pst                 *pst
770  *  @param[in] RgPrgUeSCellDelInfo *ueSCellDelInfo
771  *  @return  ROK is SUCCESS 
772  **/
773 #ifdef ANSI
774 PUBLIC S16 RgPrgPMacSMacUeSCellDelReq
775 (
776 Pst                 *pst,
777 RgPrgUeSCellDelInfo *ueSCellDelInfo
778 )
779 #else
780 PUBLIC S16 RgPrgPMacSMacUeSCellDelReq(pst, ueSCellDelInfo)
781 Pst                 *pst;
782 RgPrgUeSCellDelInfo *ueSCellDelInfo;
783 #endif
784 {
785    Inst        inst     = pst->dstInst - RG_INST_START;
786    RgCellCb    *sCell   = rgCb[inst].cell;
787    RgUeCb      *sCellUe = NULLP;
788
789    TRC2(RgPrgPMacSMacUeSCellDelReq)
790
791    /* Checking for cell Cb because in case of shutdownReq it is possible that
792     * cell is already deleted for this cell*/
793    if(sCell == NULLP)
794    {
795       RETVALUE(ROK);
796    }
797    /* Retrive the UeCb from sec cell*/
798    if ((sCellUe = rgDBMGetUeCb(sCell, ueSCellDelInfo->ueId)) == NULLP)
799    {
800       RGDBGERRNEW(inst, (rgPBuf(inst), "[%d]UE:does not exist in sCell(%d)\n",
801                ueSCellDelInfo->ueId, sCell->cellId));
802       RETVALUE(RFAILED);
803    }
804    
805    /*PMAC_Reest: ueId and newRnti is different that means its a UeId change
806     *request from PMAC to SMAC during PCell reestablishment
807     */
808   if(ueSCellDelInfo->ueId != ueSCellDelInfo->newRnti)
809   {
810      /* Retrive the UeCb from sec cell*/
811      if ((rgDBMGetUeCb(sCell, ueSCellDelInfo->newRnti)) != NULLP)
812      {
813         RGDBGERRNEW(inst, (rgPBuf(inst), "[%d]UE:UE context already exist in\
814                  sCell(%d)",ueSCellDelInfo->newRnti, sCell->cellId));
815         RETVALUE(RFAILED);
816      }
817
818      rgDBMDelUeCb(sCell, sCellUe);
819
820      sCellUe->ueId = ueSCellDelInfo->newRnti;
821
822      /* Reset harq procs*/
823      rgDHMUeReset(sCell, &sCellUe->dl.hqEnt);
824
825      rgDBMInsUeCb(sCell, sCellUe);
826   }
827   else
828   {
829      rgDBMDelUeCb(sCell, sCellUe);
830      rgCFGFreeUeCb(sCell, sCellUe);
831   }
832
833    RETVALUE(ROK);
834 } /* RgPrgPMacSMacUeSCellDelReq */
835 #endif /*LTE_ADV */
836 /**********************************************************************
837  
838          End of file
839 **********************************************************************/