2da5c5880b5da20914c0f3541a48bbce86031f81
[o-du/l2.git] / src / 5gnrrlc / rlc_cfg_ul.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**
20
21         Name:    NR RLC - Configuration Manager file
22
23         Type:    C source file
24
25         Desc:    It contains the following configuraiton primtives
26                  for different actions
27                     -- rlcCfgValdtEntCfg
28                     -- rlcCfgFillRbCb
29                     -- rlcCfgRbInit
30
31         File:     rlc_cfg_ul.c
32
33 *********************************************************************21*/
34 /** @file rlc_cfg_ul.c
35 @brief RLC Uplink Configuration Module
36 **/
37
38 \f
39 /* header (.h) include files */
40 #include "common_def.h"
41 #include "lkw.h"           /* LKW defines */
42 #include "ckw.h"           /* CKW defines */
43 #include "kwu.h"           /* KWU defines */
44 #include "rgu.h"           /* RGU defines */
45 #include "rlc_err.h"        /* RLC error options */
46 #include "rlc_env.h"        /* RLC environment options */
47
48 /* extern (.x) include files */
49 #include "lkw.x"           /* LKW */
50 #include "ckw.x"           /* CKW */
51 #include "kwu.x"           /* KWU */
52 #include "rgu.x"           /* RGU */
53
54 #include "rlc_utils.h"            /* RLC defines */
55 #include "rlc_ul.h"
56 #ifdef TENB_STATS
57 #ifdef L2_L3_SPLIT
58 #include "l2_tenb_stats.x"    /* Total EnodeB Stats declarations */
59 #endif
60 #endif
61 S16 rlcValidateRbCfgParams (RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
62                                   RlcEntCfgInfo *cfgToValidate, CmStatus *status);
63 #define RLC_MODULE RLC_DBGMASK_CFG
64 #ifdef LTE_L2_MEAS
65 /**
66  *
67  * @brief Handle modification of UE ID for L2 Meas data structs
68  *       
69  *
70  *  @param[in] ueId     ue ID
71  *
72  *  @return  S16
73  *      -# ROK 
74  *      -# RFAILED 
75  *
76 */
77 static S16 rlcHdlMeasUlUeIdChg(RlcCb *gCb, uint8_t cellId,uint8_t oldUeId, uint8_t newUeId)
78 {
79    RlcL2MeasCb    *measCb    = NULLP;
80    uint16_t       cntr;
81    uint16_t       ueIdx = 0;     
82
83    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
84    {
85       measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
86
87       if( measCb->measType & LKW_L2MEAS_UL_IP)
88       {
89
90          for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++)
91          {
92             if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == oldUeId)
93             {
94                measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = newUeId;
95                break;
96             }
97          }
98       }
99    }
100    return ROK;
101 }
102
103 /**
104  *
105  * @brief Handler to delete an UE's L2 Meas ctxt
106  *       
107 *
108  *  @param[in] ueId     ue ID
109  *
110  *  @return  S16
111  *      -# ROK 
112  *      -# RFAILED 
113  *
114 */
115 static S16 rlcDelFrmUlL2Meas(RlcCb *gCb, uint8_t cellId,uint8_t ueId)
116 {
117    RlcL2MeasCb    *measCb    = NULLP;
118    uint16_t       cntr;
119    uint16_t       ueIdx = 0;     
120
121    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
122    {
123       measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
124
125
126       if( measCb->measType & LKW_L2MEAS_UL_IP)
127       {
128
129          for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++)
130          {
131             if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == ueId)
132             {
133                measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = FALSE;
134                if (measCb->val.ipThMeas.numUes-1 == ueIdx)
135                {
136                   measCb->val.ipThMeas.numUes--;
137                }
138                break;
139             }
140          }
141
142
143
144       {
145          uint32_t myIdx =0;
146          S16                  ret;           /* Return value */
147             RlcUlUeCb             *ueCb = NULL;  
148
149             for (myIdx = 0; myIdx < measCb->val.ipThMeas.numUes; myIdx++)
150             {
151                ueCb = NULL;
152                ret = rlcDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb);
153             }
154          }
155
156       }
157    }
158
159    return ROK;
160 }
161
162
163 static S16 rlcAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *rlcRbCb,uint8_t cellId,uint8_t ueId)
164 {
165    RlcL2MeasCb    *measCb    = NULLP;
166    uint16_t       cntr;
167    uint16_t       cntr1;
168    uint16_t       ueIdx = 0;
169    uint16_t       qciIdx = 0;
170    uint16_t       *numQci;
171    #ifndef XEON_SPECIFIC_CHANGES
172    uint8_t        freeIdx = gCb->genCfg.maxUe;
173    #else
174    uint16_t       freeIdx = LKW_MAX_UE;
175    #endif 
176
177    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
178    {
179       measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
180
181       freeIdx = gCb->genCfg.maxUe;
182
183       if(measCb->measType & LKW_L2MEAS_ACT_UE )
184       {
185          for(cntr1 =0;cntr1<measCb->val.nonIpThMeas.numQci;cntr1++)
186          {
187             if(measCb->val.nonIpThMeas.qci[cntr1] != rlcRbCb->qci)
188             {
189                measCb->val.nonIpThMeas.qci[cntr1]  = rlcRbCb->qci;
190                gCb->u.ulCb->rlcL2Cb.measOn[rlcRbCb->qci] |=measCb->measType;
191                break;
192             }
193          }
194       }
195
196       if(((rlcRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE))
197       {
198 #ifdef LTE_L2_MEAS_RLC
199          if (measCb->measType & LKW_L2MEAS_ACT_UE)
200          {
201             if((rlcRbCb->mode == RLC_MODE_UM) &&
202                   (rlcRbCb->dir & RLC_DIR_DL ))
203             {
204                if (rlcRbCb->m.um.umDl.sduQ.count)
205                {
206                   if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
207                   {
208                      rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
209                      gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
210                   }
211                }
212             }
213             else if (rlcRbCb->mode == RLC_MODE_AM)
214             {
215                if ((rlcRbCb->m.am.amDl.cntrlBo) ||
216                      (rlcRbCb->m.am.amDl.retxBo)  ||
217                      (rlcRbCb->m.am.amDl.bo))
218                {
219                   if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
220                   {
221                      rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
222                      gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
223                   }
224                }
225             }
226          }
227 #endif
228       }
229       if((measCb->measType & LKW_L2MEAS_UL_IP))
230       {
231
232          for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++)
233          {
234             if ((freeIdx == gCb->genCfg.maxUe) && 
235                   (measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid == FALSE))
236             {
237                freeIdx = ueIdx;
238                continue;
239             }
240             if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == ueId)
241             {
242                break;
243             }
244          }
245
246          if (ueIdx ==  measCb->val.ipThMeas.numUes)
247          {
248             if (gCb->genCfg.maxUe == measCb->val.ipThMeas.numUes)
249             {
250                return RFAILED;  
251             }
252             if (gCb->genCfg.maxUe == freeIdx)
253             {               
254                measCb->val.ipThMeas.numUes++;
255             }
256             else
257             {
258                ueIdx = freeIdx;
259             }
260             measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE;
261             memset(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(RlcL2Cntr) *LKW_MAX_QCI));
262             measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci = 0;
263          }
264          measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = ueId;
265          measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId = cellId;
266          numQci = &(measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci);
267
268          for (qciIdx =0; qciIdx <  *numQci; qciIdx++)
269          {
270             if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == rlcRbCb->qci)
271             {
272                break;
273             }
274          }
275
276          if (qciIdx == *numQci)
277          {
278             measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = rlcRbCb->qci;
279             (*numQci)++;
280          }
281 \f
282          rlcUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[rlcRbCb->qci],
283                &rlcRbCb->rbL2Cb, measCb->measType);
284       }
285       rlcRbCb->rbL2Cb.measOn |= measCb->measType;      
286    }
287    return (ROK);
288 }/*rlcAddToDlL2Meas*/ 
289 #endif /*LTE_L2_MEAS*/
290 \f
291 /** 
292  * @brief
293  *     This primitive fills the RbCb 
294  *
295  * @param [in]    gCb      -  RLC Instance Control Block
296  * @param [out]   rbCb     -  RB Control Block
297  * @param [out]   ueCb     -  UE Control Block
298  * @param [in]    entCfg   -  RLC Entity configuration
299  *
300  * @return  S16
301  *    -#ROK
302  *    -#RFAILED
303  */
304 static S16 rlcCfgFillUlRbCb(RlcCb *gCb,RlcUlRbCb *rbCb,RlcUlUeCb *ueCb,RlcEntCfgInfo *entCfg)
305 {
306
307    DU_LOG("\nDEBUG  -->  RLC_UL : rlcCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
308                 rbCb->rlcId.cellId, 
309                 entCfg->rbId, 
310                 entCfg->rbType);
311
312    /* Initialize according to entMode */
313    switch (entCfg->entMode)
314    {
315       case RLC_MODE_TM:
316       {
317          rbCb->lch.lChId  = entCfg->lCh[0].lChId;
318          rbCb->lch.lChType = entCfg->lCh[0].type;
319          rbCb->dir = entCfg->dir;
320          break;
321       }
322       case RLC_MODE_UM:
323       {
324          rbCb->lch.lChId  = entCfg->lCh[0].lChId;
325          rbCb->lch.lChType = entCfg->lCh[0].type;
326          rbCb->dir = entCfg->dir;
327
328          rbCb->m.umUl.snLen = entCfg->m.umInfo.ul.snLen;
329
330          /* the bitmask for SN = 10 is 0x3ff and for SN = 5 is 0x1f */
331          rbCb->m.umUl.modBitMask = (rbCb->m.umUl.umWinSz << 1) - 1; 
332
333          rbCb->m.umUl.reAsmblTmrInt = 
334             entCfg->m.umInfo.ul.reAsmblTmr;
335          cmInitTimers(&(rbCb->m.umUl.reAsmblTmr), 1);
336          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
337          break;
338       }
339       case RLC_MODE_AM:
340       {
341          /* Down Link Information 
342           * indx = 1 as Up Link   */
343          rbCb->lch.lChId  = entCfg->lCh[1].lChId;
344          rbCb->lch.lChType = entCfg->lCh[1].type;
345          rbCb->dir = RLC_DIR_BOTH;
346
347          rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr;
348          rbCb->m.amUl.reAsmblTmrInt = entCfg->m.amInfo.ul.reAsmblTmr;
349
350          rbCb->m.amUl.snLen = entCfg->m.amInfo.ul.snLen; /* 5GNR */
351          
352          if(RLC_AM_CFG_12BIT_SN_LEN == rbCb->m.amUl.snLen)
353          {
354             rbCb->m.amUl.snModMask = (1 << RLC_SN_LEN_12BITS) - 1; /* 5GNR */
355          }
356          else 
357          {
358             rbCb->m.amUl.snModMask = (1 << RLC_SN_LEN_18BITS) - 1; /* 5GNR */
359          }
360
361          cmInitTimers(&(rbCb->m.amUl.reAsmblTmr), 1);
362          cmInitTimers(&(rbCb->m.amUl.staProhTmr), 1);
363
364          rbCb->m.amUl.vrMr = rbCb->m.amUl.rxNext + (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen));
365
366          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
367
368          break;
369       }
370       default:
371       {
372          DU_LOG("\nERROR  -->  RLC_UL : INVALID RB Mode cellId(%d), rbId(%d)",
373                 rbCb->rlcId.cellId, 
374                 entCfg->rbId); 
375          return RFAILED;
376       }
377    }
378    
379    if(entCfg->snssai)
380    {
381       if(!rbCb->snssai)
382       {
383          RLC_ALLOC(gCb, rbCb->snssai, sizeof(Snssai));
384          if(rbCb->snssai == NULLP)
385          {
386             DU_LOG("\nERROR  -->  RLC_UL : rlcCfgFillUlRbCb(): Failed to allocate memory for snssai ");
387             return RFAILED;
388          }
389       }
390       memcpy(rbCb->snssai, entCfg->snssai, sizeof(Snssai));
391    }
392    rbCb->mode = entCfg->entMode;
393    
394    return ROK;
395
396
397 \f
398 /** 
399  * @brief This primitive Initializes the RB Cb
400  *
401  * @param [in]    gCb      -  RLC Instance Control Block
402  * @param [out]   rbCb     -  RB Control Block
403  * @param [in]    ptr      -  Void pointer
404  * @param [in]    entCfg   -  Entity Configuration
405  *
406  * @return  S16
407  *    -#ROK
408  *    -#RFAILED
409  */
410 static S16 rlcCfgUpdateUlRb(RlcCb *gCb,RlcUlRbCb *rbCb,void *ptr,RlcEntCfgInfo *entCfg)
411 {
412    
413    switch (rbCb->mode)
414    {
415       case RLC_MODE_TM:
416       {
417          RlcUlCellCb *cellCb = (RlcUlCellCb *)ptr;
418          rbCb->dir = entCfg->dir;
419          rbCb->lch.lChId = entCfg->lCh[0].lChId;
420          rbCb->lch.lChType = entCfg->lCh[0].type;
421          cellCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
422          break;
423       }
424       case RLC_MODE_UM:
425       {
426          RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
427          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
428          rlcCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg);
429          break;
430       }
431       case RLC_MODE_AM:
432       {
433          RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
434
435          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
436          ueCb->lCh[entCfg->lCh[1].lChId - 1].ulRbCb = rbCb;
437          /* Up Link */
438          rbCb->lch.lChId = entCfg->lCh[1].lChId;
439          rbCb->lch.lChType = entCfg->lCh[1].type;
440          rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr;
441          rbCb->m.amUl.reAsmblTmrInt = entCfg->m.amInfo.ul.reAsmblTmr;
442          break;
443       }
444    }
445    
446    if(entCfg->snssai)
447    {
448       if(!rbCb->snssai)
449       {
450          RLC_ALLOC(gCb, rbCb->snssai, sizeof(Snssai));
451          if(rbCb->snssai == NULLP)
452          {
453             DU_LOG("\nERROR  -->  RLC_UL : rlcCfgUpdateUlRb(): Failed to allocate memory for snssai ");
454             return RFAILED;
455          }
456       }
457       memcpy(rbCb->snssai,entCfg->snssai,sizeof(Snssai));
458    }
459    
460    return (CKW_CFG_REAS_NONE);
461
462
463 \f
464 /** 
465  * @brief 
466  *    This primitive validates uplink Add RB Configuration and reserve memory
467  *    for RB creation.
468  *  
469  * @param [in]  gCb      -  RLC Instance Control Block
470  * @param [in]  ueId     -  UE Identifier
471  * @param [in]  cellId   -  CELL Identifier
472  * @param [in]  cfgToValidate   -  Entity Configuration needs to be validated. 
473  * @param [out] status  -  status of configuration
474  *
475  * @return  S16
476  *    -# ROK
477  *    -# RFAILED
478  */
479 S16 rlcValidateRbCfgParams(RlcCb *gCb,CmLteRnti ueId,CmLteCellId cellId,RlcEntCfgInfo *cfgToValidate,CmStatus *status)
480 {
481    if (cellId == 0)
482    {
483       status->reason = CKW_CFG_REAS_CELL_UNKWN;
484       return  (RFAILED);
485    }
486    if ((cfgToValidate->rguSapId >= gCb->genCfg.maxRguSaps) || (cfgToValidate->rguSapId < 0))
487    {
488       RLCDBGP_ERROR(gCb, "rlcValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
489             ueId, cellId, cfgToValidate->rguSapId);
490       status->reason = CKW_CFG_REAS_INVALID_RGUSAP;
491       return RFAILED; 
492    }  
493   
494    if((CKW_CFG_ADD == cfgToValidate->cfgType) ||
495       (CKW_CFG_MODIFY == cfgToValidate->cfgType))
496    {
497       /* Validate LChId for UM and AM modes */
498       if ((cfgToValidate->lCh[0].lChId <= 0) ||
499            ((cfgToValidate->entMode == RLC_MODE_AM) &&
500              (cfgToValidate->lCh[1].lChId <= 0)))
501       {
502          status->reason = CKW_CFG_REAS_INVALID_LCHID;
503          return RFAILED; 
504       }  
505       if((cfgToValidate->entMode == RLC_MODE_UM) &&
506          (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_6BIT_SN_LEN) &&
507          (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_12BIT_SN_LEN))
508       {   
509          DU_LOG("\nERROR  -->  RLC_UL : UM Mode RB[%d],Invalid SN Len[%d]",
510                cfgToValidate->rbId,
511                cfgToValidate->m.umInfo.ul.snLen);
512          status->reason = CKW_CFG_REAS_INVALID_SNLEN;
513          return RFAILED; 
514       }
515       /* Process Adding new RB */
516       if (ueId == 0)
517       {
518          if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
519          {
520             status->reason = CKW_CFG_REAS_RB_UNKWN;
521             return RFAILED;
522          }
523
524          if ((cfgToValidate->lCh[0].type != CM_LTE_LCH_CCCH) &&
525                (cfgToValidate->entMode != RLC_MODE_TM))
526          {
527             status->reason= (cfgToValidate->entMode != RLC_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
528                CKW_CFG_REAS_LCHTYPE_MIS;
529             return RFAILED;
530          }
531       }
532       else
533       {
534          if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
535          {
536             status->reason = CKW_CFG_REAS_RB_UNKWN;
537             return RFAILED;
538          }
539
540          if(cfgToValidate->entMode == RLC_MODE_TM)
541          {
542             status->reason = CKW_CFG_REAS_LCHTYPE_MIS;
543             return RFAILED;
544          }
545          if (!(((cfgToValidate->lCh[0].type == CM_LTE_LCH_DCCH) && 
546                (cfgToValidate->entMode != RLC_MODE_UM))|| 
547                (cfgToValidate->lCh[0].type == CM_LTE_LCH_DTCH)) )
548          {
549             status->reason = CKW_CFG_REAS_RB_MODE_MIS;
550             return RFAILED;
551          }
552       }
553    }
554    else /* cfgType is CKW_CFG_DELETE */
555    {
556       if (ueId == 0)
557       {
558          if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
559          {
560             status->reason = CKW_CFG_REAS_RB_UNKWN;
561             return RFAILED;
562          }
563
564       }
565       else
566       {
567          if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
568          {
569             status->reason = CKW_CFG_REAS_RB_UNKWN;
570             return RFAILED;
571          }
572       }
573    }
574    return ROK;
575 }
576
577 \f
578 /** 
579  * @brief 
580  *    This primitive validates uplink Add RB Configuration and reserve memory
581  *    for RB creation.
582  *  
583  * @param [in]  gCb      -  RLC Instance Control Block
584  * @param [in]  cfgToValidate   -  Entity Configuration needs to be validated. 
585  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
586  * @param [out] cfgTmpData    -  Configuration Temporary Data 
587  *
588  * @return  S16
589  *    -# ROK
590  *    -# RFAILED
591  */
592 S16 rlcCfgValidateUlRb
593 (
594 RlcCb             *gCb,
595 RlcEntCfgInfo    *cfgToValidate,
596 RlcUlEntTmpData   *cfgEntData,
597 RlcUlCfgTmpData   *cfgTmpData 
598 )
599 {
600
601    DU_LOG("\nDEBUG  -->  RLC_UL : cellId(%d), cfgType(%d)",
602                 cfgTmpData->cellId,
603                 cfgToValidate->cfgType);
604
605    if(ROK != rlcValidateRbCfgParams(gCb, 
606                                    cfgTmpData->ueId, 
607                                    cfgTmpData->cellId, 
608                                    cfgToValidate, 
609                                    &cfgEntData->entUlCfgCfm.status))
610    {
611       return RFAILED;
612    }
613    
614    cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_NONE;
615    switch(cfgToValidate->cfgType)
616    {
617       case CKW_CFG_ADD:
618       {
619          if (cfgTmpData->ueId == 0)
620          {
621             /* Cell Cb is added if it not present , it is not roll backed if the
622              * configuration fails */
623             rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
624             if(!cfgTmpData->cellCb)
625             {
626                /* cell cb does not exist we need to create a new one */
627                RLC_ALLOC(gCb,cfgTmpData->cellCb, sizeof(RlcUlCellCb));
628                if(!cfgTmpData->cellCb)
629                {
630                   DU_LOG("\nERROR  -->  RLC_UL : Memory allocation failure CELLID:%d",
631                         cfgTmpData->cellId);
632                   cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL;
633                   return RFAILED;
634                }
635                rlcDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
636             }
637             else
638             {
639                if (( cfgTmpData->cellCb->rbCb[cfgToValidate->rbId] != NULLP))
640                {
641                   cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_PRSNT;
642                   return RFAILED;
643                }
644             }
645
646             RLC_ALLOC(gCb,cfgEntData->rbCb, sizeof (RlcUlRbCb));
647             if (!cfgEntData->rbCb)
648             {
649                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
650                return RFAILED;
651             }
652          }
653          else
654          {
655             /* Ue Cb is added if it not present , it is not roll backed if the
656              * configuration fails */
657             rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
658             if(!cfgTmpData->ueCb)
659             {
660                RLC_ALLOC(gCb,cfgTmpData->ueCb, sizeof(RlcUlUeCb));
661                if(!cfgTmpData->ueCb)
662                {
663                   DU_LOG("\nERROR  -->  RLC_UL : Memory allocation failure CELLID:%d",
664                         cfgTmpData->cellId);
665                   cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL;
666                   return RFAILED;
667                }
668                rlcDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
669                cfgTmpData->ueCb->ueDeleteInfo.ueDelTmr.tmrEvnt = TMR_NONE;
670             }
671             else
672             {
673                RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId, 
674                      cfgToValidate->rbType,
675                      cfgTmpData->ueCb,
676                      cfgEntData->rbCb);
677                if(cfgEntData->rbCb != NULLP)
678                {
679                   cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_PRSNT;
680                   return RFAILED;
681                }
682             }
683             RLC_ALLOC(gCb,cfgEntData->rbCb, sizeof (RlcUlRbCb));
684             if (!cfgEntData->rbCb)
685             {
686                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
687                return RFAILED;
688             }
689          }
690          /*Allocating the memory for receive buffer */
691          if(RLC_MODE_UM == cfgToValidate->entMode)
692          {
693             uint16_t hashIndex;
694         
695             /* Spec 38.322 Section 7.2 
696              * UM_Window_Size = 32 when a 6 bit SN is configured, 
697              * UM_Window_Size = 2048 when a 12 bit SN is configured.
698              */
699             cfgEntData->rbCb->m.umUl.umWinSz = RLC_POWER(2, 
700                   ((cfgToValidate->m.umInfo.ul.snLen *6)-1));
701             RLC_ALLOC(gCb, cfgEntData->rbCb->m.umUl.recBufLst,
702               (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
703             for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++ )
704             {
705                cmLListInit(&(cfgEntData->rbCb->m.umUl.recBufLst[hashIndex]));
706             }
707          }
708          else if(RLC_MODE_AM == cfgToValidate->entMode)
709          {
710 #ifndef LTE_TDD 
711              uint32_t hashIndex;
712               RLC_ALLOC(gCb,
713                     cfgEntData->rbCb->m.amUl.recBufLst,
714                     (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
715               for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++)
716               {
717                   cmLListInit(&(cfgEntData->rbCb->m.amUl.recBufLst[hashIndex]));
718               }
719 #endif
720          }
721          break;
722       }
723       case CKW_CFG_MODIFY: 
724       case CKW_CFG_DELETE:
725       {
726          if (cfgTmpData->ueId == 0)
727          {
728             /* Try to get the CellCb if it already exists */
729             rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
730             if(!cfgTmpData->cellCb)
731             {
732                DU_LOG("\nERROR  -->  RLC_UL : CellCb not found UEID:%d",
733                       cfgTmpData->ueId);
734                /*how can a modify request come for a cell which does not exist*/
735                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
736                return RFAILED;
737             }
738
739             cfgEntData->rbCb = cfgTmpData->cellCb->rbCb[cfgToValidate->rbId];
740             if (!cfgEntData->rbCb)
741             {
742                /* something is wrong the rbId for this cell does not exist */
743                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
744                return RFAILED;
745             }
746             return ROK;
747          }
748          else
749          {
750             rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
751             if(!cfgTmpData->ueCb)
752             {   
753                DU_LOG("\nERROR  -->  RLC_UL : UeId [%d]: UeCb not found",
754                      cfgTmpData->ueId);
755                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
756                return RFAILED;
757             }
758
759             /* Get rbCb */
760             RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId, 
761                                       cfgToValidate->rbType, 
762                                       cfgTmpData->ueCb, 
763                                       cfgEntData->rbCb);
764             if ( cfgEntData->rbCb == NULLP)
765             {
766                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
767                return RFAILED;
768             }
769             return ROK;
770          }
771          break;
772       }
773    }
774
775    if(cfgToValidate->cfgType == CKW_CFG_MODIFY)
776    {
777       if(cfgToValidate->entMode != cfgEntData->rbCb->mode)
778       {
779          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_MODE_MIS;
780          return RFAILED;
781       }
782
783       if(cfgToValidate->m.umInfo.ul.snLen != cfgEntData->rbCb->m.umUl.snLen)
784       {
785          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_SNLEN_MIS;
786          return RFAILED;
787       }
788    }
789    return ROK;
790 }
791
792 \f
793 /** 
794  * @brief 
795  *    This primitive roll back the RB Configuration
796  *  
797  * @param [in]  gCb      -  RLC Instance Control Block
798  * @param [in]  ueId     -  UE Identifier
799  * @param [in]  cfg   -     Configuration entity. 
800  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
801  *
802  * @return  S16
803  *    -# ROK
804  *    -# RFAILED
805  */
806 S16 rlcCfgRollBackUlRb
807 (
808 RlcCb             *gCb,
809 CmLteRnti        ueId,
810 RlcEntCfgInfo    *cfg,
811 RlcUlEntTmpData   *cfgEntData
812 )
813 {
814
815    if(CKW_CFG_ADD == cfg->cfgType)
816    {
817       if(RLC_MODE_UM == cfg->entMode)
818       {
819          RLC_FREE(gCb, cfgEntData->rbCb->m.umUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
820       }
821       else if(RLC_MODE_AM == cfg->entMode)
822       {
823 #ifndef LTE_TDD 
824       RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
825 #endif
826       }
827       RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
828    }
829
830    return ROK;
831 }
832
833 \f
834 /** 
835  * @brief 
836  *    This primitive apply RB Configuration. 
837  *  
838  * @param [in] gCb      -  RLC Instance Control Block
839  * @param [in] cfgToAply  -   Configuration to be applied 
840  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
841  * @param [out] cfgTmpData    -  Configuration Temporary Data 
842  *
843  * @return  S16
844  *    -# ROK
845  *    -# RFAILED
846  */
847 Void rlcCfgApplyUlRb
848 (
849 RlcCb             *gCb,
850 RlcEntCfgInfo    *cfgToAply,
851 RlcUlEntTmpData   *cfgEntData,
852 RlcUlCfgTmpData   *cfgTmpData
853 )
854 {
855   
856    switch(cfgToAply->cfgType)
857    {
858       case CKW_CFG_ADD:
859       {
860          /* copy the RB Cb into UeCb */
861          cfgEntData->rbCb->rlcId.rbId = cfgToAply->rbId;
862          if (cfgTmpData->ueId == 0)
863          {
864             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = cfgEntData->rbCb;
865             cfgTmpData->cellCb->lCh[cfgToAply->lCh[0].lChId -1].ulRbCb = cfgEntData->rbCb;
866          }
867          else
868          {
869             if(cfgToAply->rbType == CM_LTE_SRB)
870             {
871                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = cfgEntData->rbCb;
872             }
873             else
874             {
875                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = cfgEntData->rbCb;
876             }
877          }
878
879          RLC_LMM_RB_STS_INC(gCb);
880
881          cfgEntData->rbCb->rlcId.cellId = cfgTmpData->cellId;
882          cfgEntData->rbCb->rlcId.ueId   = cfgTmpData->ueId;
883          cfgEntData->rbCb->rlcId.rbType = cfgToAply->rbType;
884          cfgEntData->rbCb->inst         = gCb->init.inst;
885
886          /* Fill RB CB */
887          rlcCfgFillUlRbCb(gCb,
888                          cfgEntData->rbCb, 
889                          cfgTmpData->ueCb,
890                          cfgToAply);
891
892 #ifdef LTE_L2_MEAS
893          cfgEntData->rbCb->qci = cfgToAply->qci;
894          cfgEntData->rbCb->ueCb =  cfgTmpData->ueCb;
895          if (cfgToAply->lCh[1].type == CM_LTE_LCH_DTCH)
896          {
897             /* ccpu00129778 */
898             rlcAddToUlL2Meas(gCb, cfgEntData->rbCb,
899                   cfgTmpData->cellId,cfgTmpData->ueId); 
900          }
901 #endif /* LTE_L2_MEAS */
902          break;
903       }
904       case CKW_CFG_MODIFY:
905       {
906          if(cfgTmpData->ueId == 0)
907          {
908             rlcCfgUpdateUlRb(gCb,
909                             cfgEntData->rbCb, 
910                             (void *)cfgTmpData->cellCb, 
911                             cfgToAply);
912          }
913          else
914          {
915             rlcCfgUpdateUlRb(gCb,
916                             cfgEntData->rbCb, 
917                             (void*)cfgTmpData->ueCb, 
918                             cfgToAply);
919          }
920          break;
921       }
922       case CKW_CFG_DELETE:
923       {
924          if (cfgTmpData->ueId == 0)
925          {
926             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = NULLP;
927             cfgTmpData->cellCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb = 
928                                                                         NULLP;
929          }
930          else
931          {
932             cfgTmpData->ueCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb = 
933                                                                        NULLP;
934
935             /* Free the Buffers of RbCb */
936             if( RLC_MODE_UM == cfgEntData->rbCb->mode )
937             {
938                rlcUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
939             }
940             else if(RLC_MODE_AM == cfgEntData->rbCb->mode)
941             {
942                rlcAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
943             }
944
945             /* Assign NULLP to rbCb in rbCbLst */
946             if ( cfgToAply->rbType == CM_LTE_SRB )
947             {
948                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = NULLP;
949             }
950             else
951             {
952                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = NULLP;
953             }
954          }
955          /* Delete RbCb  */
956          RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
957
958          RLC_LMM_RB_STS_DEC(gCb);
959          break;
960       }
961    }
962    return;
963 }
964
965 \f
966 /** 
967  * @brief 
968  *    This primitive validates uplink Delete UE request 
969  *    for RB creation.
970  *  
971  * @param [in]  gCb      -  RLC Instance Control Block
972  * @param [in]  cfgToValidate   -  Entity Configuration to be validated.
973  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
974  * @param [out] cfgTmpData    -  Configuration Temporary Data 
975  *
976  * @return  S16
977  *    -# ROK
978  *    -# RFAILED
979  */
980 S16 rlcCfgValidateDelUlUe
981 (
982 RlcCb             *gCb,
983 RlcEntCfgInfo    *cfgToValidate,
984 RlcUlEntTmpData   *cfgEntData,
985 RlcUlCfgTmpData   *cfgTmpData
986 )
987 {
988
989     DU_LOG("\nDEBUG  -->  RLC_UL : cellId(%d), cfgType(%d)",
990               cfgTmpData->cellId,cfgToValidate->cfgType);
991    
992    /* Check for ueId is present or not */
993    if ( cfgTmpData->ueId == 0 )
994    {
995       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;
996       DU_LOG("\nERROR  -->  RLC_UL : UeId is 0 for CELLID;%d",
997             cfgTmpData->cellId);
998       return RFAILED;
999    }
1000
1001    /* Fetch Ue Cb */
1002    if(ROK != rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
1003    {
1004       DU_LOG("\nERROR  -->  RLC_UL : UeId [%d]: UeCb not found",
1005             cfgTmpData->ueId);
1006       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;
1007       return RFAILED;
1008    }
1009    return ROK;
1010 }
1011
1012 \f
1013 /** 
1014  * @brief 
1015  *    This primitive apply Uplink Delete Ue request 
1016  *  
1017  * @param [in] gCb      -  RLC Instance Control Block
1018  * @param [in] cfgTmpData    -  Configuration Temporary Data 
1019  *
1020  * @return  S16
1021  *    -# ROK
1022  */
1023 Void rlcCfgApplyDelUlUe
1024 (
1025 RlcCb             *gCb,
1026 RlcUlCfgTmpData   *cfgTmpData
1027 )
1028 {
1029    
1030 #ifdef LTE_L2_MEAS
1031    rlcDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
1032 #endif
1033    rlcDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
1034    return;
1035 }
1036   
1037 \f
1038 /** 
1039  * @brief 
1040  *    This primitive validates uplink Delete UE request 
1041  *    for RB creation.
1042  *  
1043  * @param [in] gCb      -  RLC Instance Control Block
1044  * @param [in] ueId     -  UE Identifier
1045  * @param [in] cfgToValidate   -  Entity Configuration to be done.
1046  * @param [in] cfgEntData    -  Configuration Temporary Data Entity
1047  * @param [in] cfgTmpData    -  Configuration Temporary Data 
1048  *
1049  * @return  S16
1050  *    -# ROK
1051  *    -# RFAILED
1052  */
1053 S16 rlcCfgValidateDelUlCell
1054 (
1055 RlcCb             *gCb,
1056 CmLteCellId      cellId,
1057 RlcEntCfgInfo    *cfgToValidate,
1058 RlcUlEntTmpData   *cfgEntData,
1059 RlcUlCfgTmpData   *cfgTmpData
1060 )
1061 {
1062
1063    DU_LOG("\nDEBUG  -->  RLC_UL : cfgType(%d)",
1064               cfgToValidate->cfgType);
1065    
1066    cfgTmpData->cellCb = NULLP;
1067
1068    /* Check for cellId is present or not */
1069    if ( cellId == 0 )
1070    {
1071       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;
1072       DU_LOG("\nERROR  -->  RLC_UL : CellId is 0");
1073       return RFAILED;
1074    }
1075
1076    /* Fetch Cell Cb */
1077    rlcDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
1078    if (!cfgTmpData->cellCb)
1079    {
1080       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;
1081       DU_LOG("\nERROR  -->  RLC_UL : CellCb not found");
1082       return RFAILED;
1083    }
1084    return ROK;
1085 }
1086
1087 \f
1088 /** 
1089  * @brief 
1090  *    This primitive apply Uplink Delete Ue request 
1091  *  
1092  * @param [in] gCb      -  RLC Instance Control Block
1093  * @param [in] cfgEntData  - Temporary Data maintained for a transaction 
1094  *
1095  * @return  S16
1096  *    -# ROK
1097  */
1098 Void rlcCfgApplyDelUlCell(RlcCb *gCb,RlcUlCfgTmpData *cfgInfo)
1099 {
1100    
1101    rlcDbmDelUlCellCb(gCb,cfgInfo->cellCb);
1102    return;
1103 }
1104 \f
1105 /** 
1106  * @brief 
1107  *    This primitive validates reestablishment of RB.
1108  *  
1109  * @param [in]   gCb      -  RLC Instance Control Block
1110  * @param [in]   ueId     -  UE Identifier
1111  * @param [in]   cellId   -  CELL Identifier
1112  * @param [in]   cfgToValidate   -  Entity Configuration to be done.
1113  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
1114  *
1115  * @return  S16
1116  *    -# ROK
1117  *    -# RFAILED
1118  */
1119 S16 rlcCfgValidateReEstRb
1120 (
1121 RlcCb             *gCb,
1122 CmLteRnti        ueId,
1123 CmLteCellId      cellId,
1124 RlcEntCfgInfo    *cfgToValidate,
1125 RlcUlEntTmpData   *cfgEntData
1126 )
1127 {
1128    CmLteRlcId   rlcId;   /* RLC Identifier */
1129
1130     DU_LOG("\nDEBUG  -->  RLC_UL : cellId(%d) RBID:%d",
1131          cellId,
1132          cfgToValidate->rbId); 
1133
1134    /* Get rlcId */
1135    rlcId.ueId = ueId;
1136    rlcId.cellId = cellId;
1137    rlcId.rbId = cfgToValidate->rbId;
1138    rlcId.rbType = cfgToValidate->rbType;
1139
1140    rlcDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
1141    if (cfgEntData->rbCb == NULLP)
1142    {
1143       DU_LOG("\nERROR  -->  RLC_UL : CellId [%u]: rbId [%d] not found",
1144              cellId,
1145              cfgToValidate->rbId);
1146       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_UNKWN;
1147       return RFAILED;
1148    }
1149
1150    return ROK;
1151 }
1152
1153
1154 \f
1155 /** 
1156  * @brief 
1157  *    This primitive apply reestablishment of RB.
1158  *  
1159  * @param [in] gCb        -  RLC Instance Control Block
1160  * @param [in] ueId       -  UE Identifier
1161  * @param [in] cellId     -  CELL Identifier
1162  * @param [in] sndReEstInd  -  ReEstablish Indication Flag 
1163  * @param [in] cfgEntData -  Configuration Temporary Data Entity 
1164  *
1165  * @return  S16
1166  *    -# ROK
1167  */
1168 Void rlcCfgApplyReEstUlRb
1169 (
1170 RlcCb           *gCb,
1171 CmLteRnti       ueId,
1172 CmLteCellId     cellId,
1173 Bool            sndReEstInd,
1174 RlcUlEntTmpData *cfgEntData
1175 )
1176 {
1177    CmLteRlcId   rlcId;   /* RLC Identifier */
1178    
1179    rlcId.ueId = ueId;
1180    rlcId.cellId = cellId;
1181    rlcId.rbId = cfgEntData->entUlCfgCfm.rbId;
1182    rlcId.rbType = cfgEntData->entUlCfgCfm.rbType;
1183    cfgEntData->rbCb->rlcId.ueId = ueId;
1184    switch (cfgEntData->rbCb->mode)
1185    {
1186       case RLC_MODE_TM:
1187          {
1188             rlcTmmUlReEstablish(gCb,cfgEntData->rbCb);
1189             break;
1190          }
1191
1192       case RLC_MODE_UM:
1193          {
1194             rlcUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
1195             break;
1196          }
1197
1198       case RLC_MODE_AM:
1199          {
1200             rlcAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
1201             break;
1202          }
1203    }
1204    return;
1205 }
1206 \f
1207 /** 
1208  * @brief 
1209  *    This primitive validates reestablishment of RB.
1210  *  
1211  * @param [in] gCb        -  RLC Instance Control Block
1212  * @param [in] ueInfo     -  UE Identifier
1213  * @param [in] newUeInfo  -  CELL Identifier
1214  * @param [in] cfgTmpData -  Configuration Temporary Data 
1215  *
1216  * @return  S16
1217  *    -# ROK
1218  *    -# RFAILED
1219  */
1220 S16 rlcCfgValidateUeIdChng
1221 (
1222 RlcCb            *gCb,
1223 CkwUeInfo        *ueInfo,
1224 CkwUeInfo        *newUeInfo,
1225 RlcUlCfgTmpData  *cfgTmpData
1226 )
1227 {
1228    RlcUlUeCb   *ueCb;
1229
1230 #define CFM_STATUS  cfgTmpData->cfgEntData[0].entUlCfgCfm.status
1231    if ( (ueInfo->ueId == newUeInfo->ueId) && 
1232         (ueInfo->cellId == newUeInfo->cellId))
1233    {
1234       CFM_STATUS.reason = CKW_CFG_REAS_SAME_UEID;
1235       CFM_STATUS.status = CKW_CFG_CFM_NOK; 
1236       return RFAILED;
1237    } 
1238    
1239    if(ROK == rlcDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
1240    {
1241       DU_LOG("\nERROR  -->  RLC_UL : NewUeId[%d]:ueCb already exists",
1242              newUeInfo->ueId);
1243       CFM_STATUS.reason = CKW_CFG_REAS_UE_EXISTS;
1244       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1245       return RFAILED;
1246    }
1247   
1248    if(ROK != rlcDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId, 
1249                               &cfgTmpData->ueCb))
1250    {
1251       DU_LOG("\nERROR  -->  RLC_UL : UeId [%d]: UeCb not found",
1252             ueInfo->ueId);
1253       CFM_STATUS.reason = CKW_CFG_REAS_UE_UNKWN;
1254       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1255       return RFAILED;
1256    }
1257 #undef CFM_STATUS
1258    return ROK;
1259 }
1260
1261
1262 \f
1263 /** 
1264  * @brief 
1265  *    This primitive apply reestablishment of RB.
1266  *  
1267  * @param [in] gCb        -  RLC Instance Control Block
1268  * @param [in] ueInfo     -  UE Identifier
1269  * @param [in] newUeInfo  -  CELL Identifier
1270  * @param [in] cfgTmpData -  Configuration Temporary Data 
1271  *
1272  * @return  S16
1273  *    -# ROK
1274  */
1275 Void rlcCfgApplyUlUeIdChng
1276 (
1277 RlcCb            *gCb,
1278 CkwUeInfo        *ueInfo,
1279 CkwUeInfo        *newUeInfo,
1280 RlcUlCfgTmpData  *cfgTmpData
1281 )
1282 {
1283    
1284 #ifdef LTE_L2_MEAS
1285    rlcHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
1286 #endif   
1287    cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) cfgTmpData->ueCb);
1288    /* update the hash key with new values */ 
1289    cfgTmpData->ueCb->ueId = newUeInfo->ueId;
1290    cfgTmpData->ueCb->cellId =newUeInfo->cellId;
1291    if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp),
1292                               (PTR)cfgTmpData->ueCb, 
1293                               (uint8_t *)&(cfgTmpData->ueCb->ueId),
1294                               (uint16_t) sizeof(CmLteRnti)))
1295
1296    {
1297        DU_LOG("\nERROR  -->  RLC_UL : UeId[%u] HashList Insertion Failed",
1298             newUeInfo->ueId);
1299    }
1300
1301    return;
1302 }
1303 /********************************************************************30**
1304
1305          End of file
1306 **********************************************************************/