03458f14036560eccaa8d5505e06176a6687f13d
[o-du/l2.git] / src / 5gnrrlc / rlc_layer_mgr.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:    NR RLC - Layer Manager file
22
23         Type:    C source file
24
25         Desc:    It contains the following common  functions for processing
26                  the all the external interfaces.
27                     -- RlcMiRlcConfigReq
28                     -- RlcMiRlcConfigCfm 
29                     -- RlcMiLkwCntrlReq
30                     -- RlcMiLkwCntrlCfm
31                     -- RlcMiLkwStaReq
32                     -- RlcMiLkwStaCfm
33                     -- RlcMiLkwStaInd
34                     -- RlcMiLkwStsReq
35                     -- RlcMiLkwStsCfm
36                     -- RlcMiLkwTrcInd 
37
38         File:     kw_lmm.c
39
40 ************************************************************************/
41 /** @file rlc_layer_mgr.c
42 @brief RLC Layer Manager Module
43 **/
44
45 \f
46 /* header (.h) include files */
47 #include "common_def.h"
48 #include "lkw.h"           /* LKW defines */
49 #include "ckw.h"           /* CKW defines */
50 #include "kwu.h"           /* KWU defines */
51 #include "rgu.h"           /* RGU defines */
52 #include "rlc_err.h"        /* Err defines */
53 #include "rlc_env.h"        /* RLC environment options */
54
55
56 /* extern (.x) include files */
57 #include "lkw.x"           /* LKW */
58 #include "ckw.x"           /* CKW */
59 #include "kwu.x"           /* KWU */
60 #include "rgu.x"           /* RGU */
61
62 #include "rlc_utils.h"            /* RLC defines */
63 #include "rlc_dl_ul_inf.h"
64 #include "rlc_dl.h"
65 #include "rlc_ul.h"
66
67 #define RLC_MODULE RLC_DBGMASK_LMM
68
69 RLCStats gRlcStats;
70 \f
71 /*********************************************************************
72  *             Forward Declaration of LKW Porting Functions
73  ********************************************************************/
74 RlcCb *rlcCb[MAX_RLC_INSTANCES];
75 S16 rlcActvTmr ARGS ((Ent ent, Inst inst));
76
77 static Void rlcLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,RlcMngmt *cfm,uint8_t type,
78                                  Header *hdr));
79 static S16 rlcLmmGenCfg ARGS ((RlcCb *gCb, RlcGenCfg *cfg));
80 static S16 rlcLmmCfgKwuSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
81 static S16 rlcLmmCfgUdxSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
82 static S16 rlcLmmCfgCkwSap ARGS ((RlcCb *gCb,RlcSapCfg   *cfg));
83 static S16 rlcLmmCfgRguSap ARGS ((RlcCb *gCb,RlcSapCfg   *cfg));
84 static S16 rlcLmmGenCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
85 static S16 rlcLmmUdxSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
86 static S16 rlcLmmLSapCntrl ARGS ((RlcCb *gCb,RlcMngmt *cntrl));
87 static S16 rlcLmmGetKwuSapSta ARGS ((RlcCb *gCb,RlcKwuSapSta *sta));
88 static S16 rlcLmmGetRguSapSta ARGS ((RlcCb *gCb,RlcRguSapSta *sta));
89 static S16 rlcLmmGetCkwCntSapSta ARGS ((RlcCb *gCb,RlcCkwCntSapSta *sta));
90 static S16 rlcLmmGetGenSts ARGS ((RlcCb *gCb,RlcGenSts *sts,Action action));
91 static S16 rlcLmmGetSapSts ARGS ((RlcCb *gCb,RlcMngmt *sts,Elmnt elmnt,Action 
92                                   action));
93
94 \f
95 /*********************************************************************
96  *             Primitives for RGU interface 
97  ********************************************************************/
98 /**
99  * @brief
100  *    Stores the general RLC configuration. 
101  * @details
102  *    It calculates the memory requirement of the Saps  
103  *    It also initializes the control blocks, the hash lists and registers
104  *    the timers. In case of error it rolls back and reports error in the 
105  *    confirm.If the general configuration is already done it is treated as 
106  *    reconfiguration, but right now reconfiguration is not supported.
107  * 
108  * @param[in]  gCb   RLC Instance Control Block
109  * @param[in]  cfm   RLC LM general config structure
110  * 
111  * @return  S16
112  *    LCM_REASON_NOT_APPL  (SUCCESS) 
113  *    LCM_REASON_MEM_NOAVAIL
114  *    LCM_REASON_REGTMR_FAIL
115  *    LCM_REASON_INVALID_PAR_VAL
116  *    LCM_REASON_HASHING_FAILED
117  */
118 static S16 rlcLmmGenCfg(RlcCb  *gCb,RlcGenCfg *cfg)
119 {
120    Size     rlcSapSize;
121    Size     rlcUdxSapSize;
122    S16      ret;
123    CmTqCp   *rlcTqCp;
124    Size     rguSapSize;
125
126    if(cfg->maxUe > RLC_MAX_UE) 
127    {
128 #if (ERRCLASS & ERRCLS_INT_PAR)
129       DU_LOG("\nERROR  --> RLC : Invalid maxUe : Max [%lu] Received [%lu]", 
130             RLC_MAX_UE, 
131             cfg->maxUe);
132 #endif /* ERRCLASS & ERRCLS_INT_PAR */
133       return (LCM_REASON_INVALID_PAR_VAL);
134    }
135
136    if(cfg->maxKwuSaps > RLC_MAX_KWUSAPS)
137    {
138 #if (ERRCLASS & ERRCLS_INT_PAR)
139       DU_LOG("\nERROR  --> RLC : Invalid maxKwuSaps : Max [%lu] Received [%lu]", 
140             RLC_MAX_KWUSAPS, 
141             cfg->maxKwuSaps);
142 #endif /* ERRCLASS & ERRCLS_INT_PAR */
143       return (LCM_REASON_INVALID_PAR_VAL);
144    }
145
146    if(cfg->maxUdxSaps > RLC_MAX_UDXSAPS)
147    {
148 #if (ERRCLASS & ERRCLS_INT_PAR)
149       DU_LOG("\nERROR  --> RLC : Invalid maxUduSaps : Max [%lu] Received [%lu]", 
150             RLC_MAX_UDXSAPS, 
151             cfg->maxUdxSaps);
152 #endif /* ERRCLASS & ERRCLS_INT_PAR */
153       return (LCM_REASON_INVALID_PAR_VAL);
154    }
155    
156    if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > RLC_MAX_RGUSAPS))
157    {
158       
159
160       return (LCM_REASON_INVALID_PAR_VAL);
161    }
162    if(gCb->init.cfgDone == TRUE)
163    {
164       /* reconfiguration not supported */
165       return (LCM_REASON_RECONFIG_FAIL);
166    }
167
168    gCb->genCfg = *cfg;
169
170    /* Timer Queue Control point initialization */
171    rlcTqCp         = &(gCb->rlcTqCp);
172    rlcTqCp->tmrLen = RLC_TMR_LEN;
173    rlcTqCp->nxtEnt = 0;
174
175    gCb->rlcThpt.inst = gCb->init.inst;
176    gCb->rlcThpt.ueTputInfo.ueThptTmr.tmrEvnt = TMR_NONE;
177    gCb->rlcThpt.ueTputInfo.numActvUe = 0;
178    memset(gCb->rlcThpt.ueTputInfo.thptPerUe, 0, MAX_NUM_UE * sizeof(RlcThptPerUe));
179
180    gCb->rlcThpt.snssaiTputInfo.snssaiThptTmr.tmrEvnt = TMR_NONE;
181    
182    if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
183    {
184       RLC_ALLOC(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
185       if (gCb->u.dlCb == NULLP)
186       {  
187          DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
188          return (LCM_REASON_MEM_NOAVAIL);
189       
190       }
191       /* allocate memory to the KWU sap's */
192       rlcSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
193                    (Size)sizeof(RlcKwuSapCb));
194
195       RLC_ALLOC(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
196
197 #if (ERRCLASS & ERRCLS_INT_PAR)
198       if(gCb->u.dlCb->rlcKwuDlSap == NULLP)
199       {
200          RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
201          DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
202          return (LCM_REASON_MEM_NOAVAIL);
203       }
204 #endif /* ERRCLASS & ERRCLS_INT_PAR */
205
206       gCb->u.dlCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
207
208       rlcUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
209                    (Size)sizeof(RlcUdxDlSapCb));
210
211       RLC_ALLOC(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
212 #if (ERRCLASS & ERRCLS_INT_PAR)
213       if(gCb->u.dlCb->udxDlSap == NULLP)
214       {
215          RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
216          RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
217          DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
218          return (LCM_REASON_MEM_NOAVAIL);
219       }
220 #endif /* ERRCLASS & ERRCLS_INT_PAR */
221
222       rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
223                    (Size)sizeof(RlcRguSapCb));
224       RLC_ALLOC(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
225 #if (ERRCLASS & ERRCLS_INT_PAR)
226       if(gCb->u.dlCb->rguDlSap == NULLP)
227       {
228          RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcSapSize);
229          RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
230          RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
231       
232          RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
233                    "rlcLmmGenCfg: SgetSBuf Failed for rguSap...!");
234          return (LCM_REASON_MEM_NOAVAIL);
235       }
236 #endif /* ERRCLASS & ERRCLS_INT_PAR */
237
238       
239       /* Initialize the Ue and Cell hash list */
240       ret = rlcDbmDlInit(gCb);
241       if (ret != ROK)
242       {
243          RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcSapSize);
244          RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
245          RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
246          RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
247          DU_LOG("\nERROR  --> RLC_DL : RLC DL Initialization failed");   
248          return (LCM_REASON_MEM_NOAVAIL);
249       }
250
251       /* Register the timer */
252       if(ODU_REG_TMR_MT(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
253               rlcActvTmr) != ROK)
254       {
255          RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
256          RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
257          RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
258          RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
259
260          return (LCM_REASON_REGTMR_FAIL);
261       }
262
263       /* initializations for background processing of freeing memory */
264       rlcUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
265       rlcUtlInitializeSelfPst(gCb);
266
267       if(ODU_GET_MSG_BUF(gCb->init.region, gCb->init.pool, &(gCb->u.dlCb->selfPstMBuf)) != ROK)
268       {
269          RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcSapSize);
270          RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
271          RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
272          RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
273
274          return (LCM_REASON_MEM_NOAVAIL);
275       
276       }
277 #ifdef LTE_L2_MEAS
278       rlcUtlL2MeasDlInit(gCb);
279 #endif
280    }
281    else if(gCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
282    {
283       RLC_ALLOC(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
284       if (gCb->u.ulCb == NULLP)
285       {     
286          DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
287          return (LCM_REASON_MEM_NOAVAIL);
288       
289       }
290       /* allocate memory to the KWU sap's */
291       rlcSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
292                    (Size)sizeof(RlcKwuSapCb));
293
294       RLC_ALLOC(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
295
296 #if (ERRCLASS & ERRCLS_INT_PAR)
297       if(gCb->u.ulCb->rlcKwuUlSap == NULLP)
298       {
299          RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
300          DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
301          return (LCM_REASON_MEM_NOAVAIL);
302       }
303 #endif /* ERRCLASS & ERRCLS_INT_PAR */
304
305       gCb->u.ulCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
306
307       /* allocate memory to the KWU sap's */
308       rlcUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
309                    (Size)sizeof(RlcUdxUlSapCb));
310
311       RLC_ALLOC(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
312
313 #if (ERRCLASS & ERRCLS_INT_PAR)
314       if(gCb->u.ulCb->rlcKwuUlSap == NULLP)
315       {
316          RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
317          RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
318          DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
319          return (LCM_REASON_MEM_NOAVAIL);
320       }
321 #endif /* ERRCLASS & ERRCLS_INT_PAR */
322
323       rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
324                    (Size)sizeof(RlcRguSapCb));
325       RLC_ALLOC(gCb,gCb->u.ulCb->rguUlSap, rguSapSize);
326 #if (ERRCLASS & ERRCLS_INT_PAR)
327       if(gCb->u.ulCb->rguUlSap == NULLP)
328       {
329          RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
330          RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
331          RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
332       
333          RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
334                    "rlcLmmGenCfg: SgetSBuf Failed for rguSap...!");
335          return (LCM_REASON_MEM_NOAVAIL);
336       }
337 #endif /* ERRCLASS & ERRCLS_INT_PAR */
338
339       /* Initialize the Ue and Cell hash list */
340       ret = rlcDbmUlInit(gCb);
341       if (ret != ROK)
342       {
343          RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
344          RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
345          RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
346          RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
347          DU_LOG("\nERROR  --> RLC_DL : RLC DL Initialization failed");   
348       }
349
350       /* Register the timer */
351       if(ODU_REG_TMR_MT(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
352               rlcActvTmr) != ROK)
353       {
354          RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
355          RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
356          RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, rlcSapSize);
357          RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
358
359          return (LCM_REASON_REGTMR_FAIL);
360       }
361
362 #ifdef LTE_L2_MEAS
363       rlcUtlL2MeasUlInit(gCb);
364 #endif
365    }
366    else
367    {
368 #if (ERRCLASS & ERRCLS_INT_PAR)
369       DU_LOG("\nERROR  --> RLC : Received Invalid RLC Mode");
370 #endif /* ERRCLASS & ERRCLS_INT_PAR */
371
372       return (LCM_REASON_INVALID_PAR_VAL);
373    }
374    /* Timer Initialization  */
375    gCb->rlcTqCp.tmrLen = RLC_TMR_LEN;
376
377    memset(gCb->rlcTq, NULLP, sizeof(CmTqType) * RLC_TMR_LEN);
378
379    RLC_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
380
381    gCb->init.lmPst.srcProcId = gCb->init.procId;
382    gCb->init.lmPst.srcEnt = gCb->init.ent;
383    gCb->init.lmPst.srcInst = gCb->init.inst;
384    gCb->init.lmPst.event = EVTNONE;
385
386    /* kw002.201 For multi core and multi region,no need to reinitiailize the 
387     * region again . This would be done with kwActvInit from SSI */
388 #if !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION)
389    gCb->init.region = cfg->lmPst.region;
390 #endif /* !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION) */
391    gCb->init.pool   = cfg->lmPst.pool;
392
393    gCb->init.cfgDone = TRUE;
394
395    /* TODO : make this generic for DL and UL after support for UL throughput calculation is added */
396    if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
397    {
398       /* Starting timer to print throughput */
399       if((rlcChkTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_UE_THROUGHPUT_TMR)) == FALSE)
400       {
401          DU_LOG("\nINFO   --> RLC_DL : Starting UE Throughput timer");
402          rlcStartTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_UE_THROUGHPUT_TMR);
403       }
404       /* Starting timer to print throughput */
405       if((rlcChkTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_SNSSAI_THROUGHPUT_TMR)) == FALSE)
406       {
407          DU_LOG("\nINFO   --> RLC_DL : Starting SNSSAI Throughput timer");
408          rlcStartTmr(gCb, (PTR)(&gCb->rlcThpt), EVENT_RLC_SNSSAI_THROUGHPUT_TMR);
409       }
410    }
411
412    
413    return (LCM_REASON_NOT_APPL);
414
415
416 /**
417  * @brief
418  *     Sends confirmation message to LM Called by RlcMiRlcConfigReq function
419  * 
420  * @param[in] gCb    RLC Instance Control Block
421  * @param[in] pst    Post structure
422  * @param[in] cfm    RLC LM structure 
423  * @param[in] type   Type of LM message
424  * @param[in] hdr    Message header
425  * 
426  * @return  S16
427  *     -# ROK
428  */
429 static Void rlcLmmSendCfm
430 (
431 RlcCb      *gCb,
432 Pst        *pst,                
433 RlcMngmt   *cfm,               
434 uint8_t    type,              
435 Header     *hdr              
436 )
437 {
438    Pst   rPst;   /* Reply post structure */
439
440    RLC_MEM_SET(&rPst, 0, sizeof(Pst));   
441  
442    /* reply post structure for confirmation */
443    if (gCb)
444    {
445       rPst.srcEnt = gCb->init.ent;
446       rPst.srcInst = gCb->init.inst;
447       cfm->hdr.entId.ent = gCb->init.ent;
448       cfm->hdr.entId.inst = gCb->init.inst;
449    }
450    else
451    {
452       rPst.srcEnt = pst->dstEnt;
453       rPst.srcInst = pst->dstInst;
454       cfm->hdr.entId.ent = pst->dstEnt;
455       cfm->hdr.entId.inst = pst->dstInst;
456    }
457    rPst.srcProcId = SFndProcId();
458    rPst.dstEnt = pst->srcEnt;
459    rPst.dstInst = pst->srcInst;
460    rPst.dstProcId = pst->srcProcId;
461    rPst.selector = hdr->response.selector;
462    rPst.prior = hdr->response.prior;
463    rPst.route = hdr->response.route;
464    rPst.region = hdr->response.mem.region;
465    rPst.pool= hdr->response.mem.pool;
466
467    /* Fill the reply header */
468    cfm->hdr.elmId.elmnt = hdr->elmId.elmnt;
469    cfm->hdr.transId = hdr->transId;
470
471    switch(type)
472    {
473       case TCFG:
474          RlcMiRlcConfigCfm(&rPst,cfm);
475          break;
476       case TCNTRL:
477          SGetDateTime(&(cfm->t.cntrl.dt));
478          RlcMiLkwCntrlCfm(&rPst,cfm);
479          break;
480       case TSTS:
481          SGetDateTime(&(cfm->t.sts.dt));
482          RlcMiLkwStsCfm(&rPst,0,cfm);
483          break;
484       case TSSTA:
485          SGetDateTime(&(cfm->t.ssta.dt));
486          RlcMiLkwStaCfm(&rPst,cfm);
487          break;
488       default:
489 #if (ERRCLASS & ERRCLS_INT_PAR)
490          DU_LOG("\nERROR  --> RLC : Received Invalid Message Type");
491          if(!gCb)
492          {
493             fflush(stdout);
494          }
495 #endif /* ERRCLASS & ERRCLS_INT_PAR */
496          break;
497    }
498
499    return; 
500
501
502
503 /**
504  * @brief
505  *    This function processes configuration requests received from the layer 
506  *    manager.
507  *
508  * @details
509  *    The configuration requests can be for general configuration, or 
510  *    configuration of RGU, KWU, and CKW SAPs. The type of the configuration 
511  *    request can be determined from the elmId field in the header of the layer
512  *    manager message.This function is called by the layer manager to configure
513  *    RLC. 
514  *
515  *    This function implements the following logic: 
516  *
517  *    - if genCfg is not done, send negative Cfm to the layer manager; 
518  *
519  *    - switch (cfg->hdr.elmId.elmnt)
520  *       - case STGEN 
521  *          - update the genCfg field in RlCb; 
522  *          - allocate the maximum static memory required by the RLC product; 
523  *          - register the timer service by calling SReqTmr; 
524  *          - set CfgDone for not configuring again; 
525  *       - case STKWUSAP 
526  *          - if all the parameters are valid, then allocate the KwuSap control 
527  *            block; 
528  *          - update the SAP control block with the information provided in the 
529  *          - configuration request; 
530  *          - send configuration confirm with the status, success; 
531  *       - case STCKWSAP 
532  *          - if all the parametes are valid, then allocate the CkwSap control 
533  *            block; 
534  *          - update the SAP control block with the information provided in the
535  *            configuration request; 
536  *          - send configuration confirm with the status, success; 
537  *       - case STRGUSAP 
538  *          - if all the parametes are valid, then allocate the rguSap control 
539  *            block; 
540  *          - update the SAP control block with the information provided in the
541  *            configuration request; 
542  *          - send configuration confirm with the status, success; 
543  *       - case STUDXSAP 
544  *          - if all the parametes are valid, then allocate the udxSap control 
545  *            block; 
546  *          - update the SAP control block with the information provided in the
547  *            configuration request; 
548  *          - send configuration confirm with the status, success; 
549  *    - end switch;
550  *     
551  * @param[in] pst   post structure 
552  * @param[in] cfg   LM management structure 
553  * 
554  * @return S16
555  *    -# Success : ROK
556  *    -# Failure : RFAILED
557  */
558
559 uint8_t RlcMiRlcConfigReq (Pst *pst,RlcMngmt *cfg)
560 {
561    Reason   reason;   /* failure reason */
562    RlcCb     *tRlcCb=NULLP;
563
564 #if (ERRCLASS & ERRCLS_INT_PAR)
565    /* Check if the instance is configured */
566    if (pst->dstInst >= MAX_RLC_INSTANCES)
567    {
568       cfg->cfm.status = LCM_PRIM_NOK;
569       cfg->cfm.reason = LCM_REASON_INVALID_INSTANCE;
570       rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);     
571       return (RFAILED);
572    }
573 #endif
574    
575    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
576
577    if (!tRlcCb)
578    {
579       cfg->cfm.status = LCM_PRIM_NOK;
580       cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
581       rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);     
582       return (RFAILED);
583    }
584    /* check configuration is done or not */
585    if ((tRlcCb->init.cfgDone != TRUE) && 
586        (cfg->hdr.elmId.elmnt != STGEN))
587    {
588       /*
589        * if general config is not over then use pst structure
590        * in primitive to communicate to stack manager
591        */
592
593       cfg->cfm.status = LCM_PRIM_NOK;
594       cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
595       rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);     
596       return (RFAILED);
597    }
598
599    DU_LOG("\nDEBUG  --> RLC : RlcMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
600
601    switch(cfg->hdr.elmId.elmnt)
602    {
603       case STGEN:
604       {
605          reason = rlcLmmGenCfg(tRlcCb,&cfg->t.cfg.s.gen);
606          break;
607       }
608       case STKWUSAP:
609       {
610          reason = rlcLmmCfgKwuSap(tRlcCb,&cfg->t.cfg.s.sap);
611          break;
612       }
613       case STCKWSAP:
614       {
615          reason = rlcLmmCfgCkwSap(tRlcCb,&cfg->t.cfg.s.sap);
616          break;
617       }
618       case STRGUSAP:
619       {
620          reason = rlcLmmCfgRguSap(tRlcCb,&cfg->t.cfg.s.sap);
621          break;
622       }
623       case STUDXSAP:
624       {
625          reason = rlcLmmCfgUdxSap(tRlcCb,&cfg->t.cfg.s.sap);
626          break;
627       }
628       default:
629       {
630          reason = LCM_REASON_INVALID_ELMNT;
631          break;
632       }   
633    }
634
635    if (reason == LCM_REASON_NOT_APPL)
636    {
637       cfg->cfm.status = LCM_PRIM_OK;
638       cfg->cfm.reason = LCM_REASON_NOT_APPL;
639       rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
640       return (ROK);
641    }
642    else
643    {
644       cfg->cfm.status = LCM_PRIM_NOK;
645       cfg->cfm.reason = reason;
646       rlcLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
647       return (RFAILED);
648    }
649
650
651 /**
652  * @brief 
653  *    The layer manager initiates and uses the management-control procedure to 
654  *    control RLC elements.The RLC control request primitive (RlcMiLkwCntrlReq) 
655  *    can be called more than once and at any time after the 
656  *    management-configuration procedure.The control request primitive 
657  *    is confirmed by a RlcMiLkwCntrlCfm primitive.
658  *
659  * @details
660  *    This function implements the following logic: 
661  *  
662  *    - if(cfgDone = FALSE) 
663  *       - send negative confirmation to the layer manager; 
664  *       - return; 
665  *    - else 
666  *    - switch(cntrl->hdr.elmId.elmnt) 
667  *       -  case STGEN 
668  *           - switch (action) 
669  *           - case AENA 
670  *                - switch(subAction) 
671  *                - case SAUSTA 
672  *                     - enable the unsolicited status flag; 
673  *                     - send the control Cfm with success; 
674  *                - case SADBG 
675  *                     - set the debug mask; 
676  *                     - send the control Cfm with success; 
677  *                - case SATRC 
678  *                     - enable the trace flag; 
679  *                     - send the control Cfm with success; 
680  *            - case ADISIMM 
681  *               - switch(subAction) 
682  *               - case SAUSTA 
683  *                    - disable the unsolicited status flag; 
684  *                    - send the control Cfm with success; 
685  *               - case SATRC 
686  *                    - disable the trace flag; 
687  *                    - send the control Cfm with success; 
688  *          - case ASHUTDOWN 
689  *     - case STRGUSAP 
690  *          - Call LSapCntrl
691  *     - case STUDXSAP 
692  *          - Call UdxSapCntrl
693  *     - default  
694  *    - end else  
695  * 
696  * @param[in] pst     post structure
697  * @param[in] cntrl   LM management structure
698  * 
699  * @return S16
700  *    -# ROK
701  *    -# RFAILED
702  */
703 uint8_t RlcMiLkwCntrlReq(Pst *pst, RlcMngmt *cntrl)
704 {
705    Reason   reason;   /* failure reason */
706    RlcCb     *tRlcCb=NULLP;
707
708 #if (ERRCLASS & ERRCLS_INT_PAR)
709    /* Check if the instance is configured */
710    if (pst->dstInst >= MAX_RLC_INSTANCES)
711    {
712       cntrl->cfm.status = LCM_PRIM_NOK;
713       cntrl->cfm.reason =  LCM_REASON_INVALID_INSTANCE;
714
715       rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
716       return (RFAILED);
717    }
718 #endif
719    
720    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
721
722    if(!tRlcCb)
723    {
724       cntrl->cfm.status = LCM_PRIM_NOK;
725       cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
726       rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
727       return (RFAILED);
728    }
729
730    if (!(tRlcCb->init.cfgDone))
731    {
732       cntrl->cfm.status = LCM_PRIM_NOK;
733       cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
734       rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
735       return (RFAILED);
736    }
737    DU_LOG("\nDEBUG  --> RLC : RlcMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
738
739    /* In normal cases, LCM_REASON_NOT_APPL is returned in cfm.
740     * In all error cases appropriate reason is returned
741     * by the functions below
742     */
743
744    switch (cntrl->hdr.elmId.elmnt)
745    {
746       case STGEN:
747       {
748          /* general control */
749          reason = rlcLmmGenCntrl(tRlcCb,cntrl);
750          break;
751       }
752       case STRGUSAP:
753       {
754          /* Lower SAP control */
755          reason = rlcLmmLSapCntrl(tRlcCb,cntrl);
756          break;
757       }
758       case STUDXSAP:
759       {
760          /* Udx Sap cntrl */
761          reason = rlcLmmUdxSapCntrl(tRlcCb,cntrl);
762          break;
763       }
764       default:
765       {
766          reason = LCM_REASON_INVALID_ELMNT;
767          break;
768       }
769    } /* end switch */
770    
771    if (reason == LCM_REASON_NOT_APPL)
772    {
773       cntrl->cfm.status = LCM_PRIM_OK;
774       cntrl->cfm.reason = LCM_REASON_NOT_APPL;
775    }
776    else
777    {
778       cntrl->cfm.status = LCM_PRIM_NOK;
779       cntrl->cfm.reason = reason;
780    }
781
782    rlcLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
783
784    return ROK;
785
786
787 /**
788  * @brief 
789  *    This function processes solicited status requests received from the layer
790  *    manager. The layer manager can request status information regarding the
791  *    system ID, RGUSAP,KWUSAP, or CKWSAP.
792  *
793  * @param[in] pst   post structure
794  * @param[in] sta   LM management structure
795  * @return S16
796  *    -# ROK (SUCCESS)
797  *    -# RFAILED
798  */
799 S16 RlcMiLkwStaReq(Pst *pst,RlcMngmt *sta)
800 {
801    RlcMngmt   rSta;     /* Status */
802    Reason    reason;   /* Failure reason */
803    RlcCb      *tRlcCb=NULLP;
804
805 #if (ERRCLASS & ERRCLS_INT_PAR)
806    /* Check if the instance is configured */
807    if (pst->dstInst >= MAX_RLC_INSTANCES)
808    {
809       sta->cfm.status = LCM_PRIM_NOK;
810       sta->cfm.reason = LCM_REASON_INVALID_INSTANCE;
811
812       rlcLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
813       return (RFAILED);
814    }
815 #endif
816    
817    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
818    if (!tRlcCb)
819    {
820       sta->cfm.status = LCM_PRIM_NOK;
821       sta->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
822
823       rlcLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
824       return (RFAILED);
825    }
826
827    DU_LOG("\nDEBUG  --> RLC : Status request for elmId(%d))", sta->hdr.elmId.elmnt);
828
829    reason = LCM_REASON_NOT_APPL;
830
831    RLC_MEM_SET(&rSta, 0, sizeof(RlcMngmt));
832    switch (sta->hdr.elmId.elmnt)
833    {
834       case STSID:
835       {
836          reason = LCM_REASON_NOT_APPL;
837          rlcGetSId(&rSta.t.ssta.s.sysId);
838          break;
839       }
840       case STKWUSAP:
841       {
842          RLC_MEM_CPY (&rSta.t.ssta.s.rlckwuSap, 
843                      &sta->t.ssta.s.rlckwuSap, 
844                      sizeof (RlcKwuSapSta));
845
846          reason = rlcLmmGetKwuSapSta (tRlcCb,&rSta.t.ssta.s.rlckwuSap);
847          break;
848       }
849       case STRGUSAP:
850       {
851          RLC_MEM_CPY (&rSta.t.ssta.s.rguSap, 
852                      &sta->t.ssta.s.rguSap,
853                      sizeof (RlcRguSapSta));
854
855          reason = rlcLmmGetRguSapSta (tRlcCb,&rSta.t.ssta.s.rguSap);
856          break;
857       }
858       case STCKWSAP:
859       {
860          RLC_MEM_CPY (&rSta.t.ssta.s.ckwSap, 
861                      &sta->t.ssta.s.ckwSap,
862                      sizeof (RlcCkwCntSapSta));
863
864          reason = rlcLmmGetCkwCntSapSta (tRlcCb,&rSta.t.ssta.s.ckwSap);
865          break;
866       }
867       default:
868       {
869          reason = LCM_REASON_INVALID_ELMNT;
870          break;
871       }
872    } /* end of switch */
873
874    if (reason == LCM_REASON_NOT_APPL)
875    {
876       rSta.cfm.status = LCM_PRIM_OK;
877       rSta.cfm.reason = LCM_REASON_NOT_APPL;
878    }
879    else
880    {
881       rSta.cfm.status = LCM_PRIM_NOK;
882       rSta.cfm.reason = reason;
883    }
884    rlcLmmSendCfm(tRlcCb,pst, &rSta, TSSTA, &sta->hdr);
885
886    return ROK;
887
888
889 /**
890  * @brief 
891  *    This function processes statistics requests received from the layer
892  *    manager.
893  *
894  * @details  
895  *    After collecting the statistics, ir calls the statistics confirm function
896  *    to send the statistics to the layer manager.
897  *
898  *    - switch(sts->hdr.elmId.elmnt) 
899  *    - case STGEN 
900  *       - get the general statistics from the KW control block; 
901  *       - if (action = RESET) 
902  *          - reset the general statistic field in the RlCb; 
903  *          - call RlcMiLkwStsCfm to send statistics back to layer manager; 
904  *    - case STCKWSAP 
905  *    - case STKWUSAP 
906  *    - case STRGUSAP 
907  *        - get the SAP specific statistics from KW control block; 
908  *        - if (action = RESET) 
909  *       - reset the general statistic field in the RlCb; 
910  *       - call RlcMiLkwStsCfm to send statistics to the layer manager; 
911  *  -end switch;
912  *
913  * @param[in] pst      post structure
914  * @param[in] action   action 
915  * @param[in] sts      LM management structure
916  * 
917  * @return S16
918  *    -# ROK
919  *    -# RFAILED
920  */
921 S16 RlcMiLkwStsReq (Pst *pst, Action action,RlcMngmt *sts)
922 {
923    RlcMngmt   rSts;     /* Statistics */
924    Reason    reason;   /* Reason for failure */
925    RlcCb     *tRlcCb=NULLP;
926
927 #if (ERRCLASS & ERRCLS_INT_PAR)
928    /* Check if the instance is configured */
929    if (pst->dstInst >= MAX_RLC_INSTANCES)
930    {
931       rSts.cfm.status = LCM_PRIM_NOK;
932       rSts.cfm.reason = LCM_REASON_INVALID_INSTANCE;
933
934       rlcLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
935       return (RFAILED);
936    }
937 #endif
938    
939    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
940    if (!tRlcCb)
941    {
942       rSts.cfm.status = LCM_PRIM_NOK;
943       rSts.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
944
945       rlcLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
946       return (RFAILED);
947    }
948
949    DU_LOG("\nDEBUG  --> RLC : RlcMiLkwStsReq(elmId(%d),action(%d))", 
950                        action, 
951                        sts->hdr.elmId.elmnt);
952
953    RLC_MEM_SET(&rSts, 0, sizeof(RlcMngmt));
954
955    switch (sts->hdr.elmId.elmnt)
956    {
957       case STGEN:
958       {
959          reason = rlcLmmGetGenSts(tRlcCb,&rSts.t.sts.s.gen, action);
960          break;
961       }
962       case STKWUSAP:
963       case STCKWSAP:
964       {
965          if( sts->hdr.elmId.elmnt == STKWUSAP)
966          {
967             /* kw005.201, modified the element of rlckwuSap from suId to spId */
968             rSts.t.sts.s.rlckwuSap.spId = sts->t.sts.s.rlckwuSap.spId;
969          }
970          reason = rlcLmmGetSapSts(tRlcCb,&rSts, sts->hdr.elmId.elmnt, action);
971          break;
972       }
973       default:
974       {
975          reason = LCM_REASON_INVALID_ELMNT;
976          break;
977       }
978    } /* end switch */
979
980    if (reason == LCM_REASON_NOT_APPL)
981    {
982       rSts.cfm.status = LCM_PRIM_OK;
983       rSts.cfm.reason = LCM_REASON_NOT_APPL;
984    }
985    else
986    {
987       rSts.cfm.status = LCM_PRIM_NOK;
988       rSts.cfm.reason = reason;
989    }
990    rlcLmmSendCfm(tRlcCb,pst, &rSts, TSTS, &sts->hdr);
991
992    return ROK;
993
994
995 /* kw005.201 added support for L2 Measurement */
996 #ifdef LTE_L2_MEAS
997 /**
998 @brief 
999 This function processes L2 Measurement requests received from the layer manager.
1000 The L2 Measurement is start for a time period and after the timer expiry, the 
1001 measurement confirm is sent.
1002
1003 -  Accept only one set of measurements.
1004 -  Allocate and initialise RlcL2MeasEvtCb.
1005 -  Validate if the measurement is already in progress.
1006    -  Loop through the existing measEvtCb with matching measType
1007       -  Check if measurement is running for any qci present in the measReq
1008       -  If present, move the qCi to list of invalid qCIs.
1009 -  Set RlcL2MeasEvtCb.measOn to TRUE for QCIs to be measured.
1010 -  For the number of measurements requested.
1011    -  For all Ues with RBs matching qCI.
1012       -  Add RbCb to the RB linked list.
1013       -  Set rlcRbCb.measOn to measurement type.
1014       -  If Meas type is DL_DELAY
1015          -  Update COUNT to startCount.
1016 -  Start l2Timer
1017
1018  *  @param[in] pst      post structure
1019  *  @param[in] action   action 
1020  *  @param[in] cfg      LM management structure
1021  *  @return S16
1022  *      -# Success : ROK
1023  *      -# Failure : RFAILED
1024 */
1025 S16 RlcMiLkwL2MeasReq(Pst *pst, RlcL2MeasReqEvt *measReqEvt)
1026 {
1027    S16            ret = ROK;
1028    uint16_t       cntr;
1029    uint8_t        measType;
1030    RlcL2MeasCfmEvt measCfmEvt;
1031
1032    RlcCb     *tRlcCb;
1033
1034    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
1035
1036    /* Initialize measCfmEvt */
1037    RLC_MEM_ZERO(&measCfmEvt, sizeof(RlcL2MeasCfmEvt));
1038    /* validate the received measReqEvt */
1039    /*LTE_L2_MEAS_PHASE2*/
1040    if(measReqEvt->measPeriod != 0)
1041    {
1042       /* L2 MEAS AGHOSH */
1043       if((measReqEvt->measReq.measType & LKW_L2MEAS_DL_IP)|| 
1044             (measReqEvt->measReq.measType & LKW_L2MEAS_UL_IP))
1045       {
1046          ret = rlcUtlValidateIpThL2Meas(measReqEvt, &measCfmEvt);
1047       }
1048
1049       if(ret != ROK)
1050       {
1051 #if (ERRCLASS & ERRCLS_ADD_RES)
1052 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1053          rlcUtlSndUlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
1054          RLC_FREE(tRlcCb, measReqEvt, sizeof(RlcL2MeasReqEvt))
1055          return RFAILED;
1056       }
1057    }
1058
1059    measType = measReqEvt->measReq.measType;
1060
1061    if((measType != LKW_L2MEAS_DL_IP) &&
1062       (measType !=  LKW_L2MEAS_ACT_UE) &&
1063       (measType !=  LKW_L2MEAS_DL_DISC) &&
1064       (measType != LKW_L2MEAS_DL_DELAY) && 
1065       (measType != LKW_L2MEAS_UU_LOSS) &&
1066       (measType !=  LKW_L2MEAS_UL_IP))/* || (qci > LKW_MAX_QCI)*/
1067    {
1068       measCfmEvt.transId = measReqEvt->transId;
1069       measCfmEvt.measType = measType;
1070       measCfmEvt.status.status = LCM_PRIM_NOK;
1071       measCfmEvt.status.reason = LKW_CAUSE_INVALID_MEASTYPE;
1072       rlcUtlSndDlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
1073       RLC_FREE(tRlcCb, measReqEvt, sizeof(RlcL2MeasReqEvt))
1074       return ROK;
1075    }
1076
1077    /* for UL IP throughput meas enable for all QCIs */
1078    if(measType & LKW_L2MEAS_UL_IP)
1079    {
1080       for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1081       {
1082          tRlcCb->u.ulCb->rlcL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
1083       }
1084    }
1085   
1086    if(measType & 
1087       (LKW_L2MEAS_DL_IP | LKW_L2MEAS_DL_DISC | 
1088       LKW_L2MEAS_DL_DELAY | LKW_L2MEAS_UU_LOSS))
1089    {
1090       RlcL2MeasReqEvt *measEvt;
1091       Pst      *udxPst;
1092
1093       udxPst = &(RLC_GET_UDX_SAP(tRlcCb)->pst);
1094       
1095       RLC_ALLOC_SHRABL_BUF(udxPst->region, 
1096                           udxPst->pool,
1097                           measEvt, 
1098                           sizeof(RlcL2MeasReqEvt));
1099
1100 #if (ERRCLASS & ERRCLS_ADD_RES) /* KW_FIX */ 
1101       if(measEvt == NULLP)
1102       {
1103          DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
1104          return RFAILED;
1105       }   
1106 #endif      
1107       memcpy(measEvt, measReqEvt, sizeof(RlcL2MeasReqEvt));
1108       /*Redirect the request to DL task */
1109       /* NOTE:As of today, there are no cases where the Req will fail at DL
1110          as long as it reached the DL, so we don't wait for a confirmation from
1111          DL to send the confirmation to LM*/
1112       /* The interface for sending a confirmation back does not exist today;
1113          it needs to be created when the need arises */
1114       rlcUlUdxL2MeasReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measEvt);
1115    }
1116
1117    /* We need to copy the transId for sending back confirms later */
1118    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1119    {
1120       RlcL2MeasEvtCb* measEvtCb = &(tRlcCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]);
1121       if(measEvtCb->measCb.measType & measType)
1122       {
1123          measEvtCb->transId= measReqEvt->transId;
1124       }
1125    }
1126    /*RLC_FREE(tRlcCb, measReqEvt, sizeof(RlcL2MeasReqEvt));*/
1127
1128    return (ret);
1129 } /* RlcMiLkwL2MeasReq */
1130
1131 /**
1132 @brief 
1133 This function processes L2 Measurement stop request received from the layer manager.
1134 After receving this request, RLC stops L2 Measurement
1135  *  @param[in] pst      post structure
1136  *  @param[in] measType meas Type 
1137  *  @return S16
1138  *      -# Success : ROK
1139  *      -# Failure : RFAILED
1140 */
1141
1142 S16 RlcMiLkwL2MeasStopReq(Pst *pst,uint8_t measType)
1143 {
1144    S16 ret = ROK;
1145    RlcL2MeasEvtCb *measEvtCb = NULLP;
1146
1147    uint16_t            cntr;
1148    uint8_t             status = ROK;
1149    RlcCb     *tRlcCb;
1150
1151    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
1152
1153    /* reset the counter values for the measurement that is stopped */
1154    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1155    {
1156       measEvtCb = &(tRlcCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]);
1157       if(measEvtCb->measCb.measType & measType)
1158       {
1159          rlcUtlResetUlL2MeasInRlcRb(tRlcCb, &measEvtCb->measCb, measType);
1160
1161       }
1162    }   
1163
1164    /* for UL IP throughput meas disable for all QCIs */
1165    if(measType & LKW_L2MEAS_UL_IP)
1166    {
1167       for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1168       {
1169          tRlcCb->u.ulCb->rlcL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
1170       }
1171    }
1172    
1173    if((measType & LKW_L2MEAS_DL_IP) || (measType & LKW_L2MEAS_DL_DISC)
1174        || (measType & LKW_L2MEAS_DL_DELAY))
1175    {
1176       /*Redirect the request to DL task */
1177       rlcUlUdxL2MeasStopReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measType);
1178       /*return ROK;*/
1179    }
1180    /*memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
1181
1182    status = LCM_PRIM_OK; 
1183    RlcMiLkwL2MeasStopCfm(&tRlcCb->genCfg.lmPst, measType,status); 
1184    
1185    return (ret);
1186 }
1187 /**
1188 @brief 
1189 This function processes L2 Measurement Send request received from the layer manager.
1190 After receving this request, RLC sends L2 Measurement
1191  *  @param[in] pst      post structure
1192  *  @param[in] measType meas Type 
1193  *  @return S16
1194  *      -# Success : ROK
1195  *      -# Failure : RFAILED
1196 */
1197
1198 S16 RlcMiLkwL2MeasSendReq(Pst *pst,uint8_t measType)
1199 {
1200    /*S16 ret = ROK;*/
1201    RlcL2MeasEvtCb *measEvtCb = NULLP;
1202    uint16_t            cntr;
1203    RlcCb     *tRlcCb;
1204
1205    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
1206    
1207    /* In case of addition of any new measType here ,appropriate handling 
1208     * has to be done in RLC DL (rlcUtlSndDlL2MeasCfm)*/
1209    if(measType & 
1210       (LKW_L2MEAS_DL_DISC | LKW_L2MEAS_DL_DELAY 
1211        | LKW_L2MEAS_UU_LOSS| LKW_L2MEAS_DL_IP))
1212    {
1213       /*Redirect the request to DL task */
1214       rlcUlUdxL2MeasSendReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),measType);
1215       /* L2 MEAS AGHOSH */
1216       /*return ROK;*/
1217    }
1218
1219    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1220    {
1221       measEvtCb = &(tRlcCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]);
1222       /* L2 MEAS AGHOSH */
1223       if(measEvtCb->measCb.measType & measType)
1224       {
1225          rlcUtlHdlL2TmrExp(tRlcCb, measEvtCb);
1226       }
1227    }
1228
1229    return ROK;
1230 }
1231 #endif /* LTE_L2_MEAS */
1232
1233 /**
1234  * @brief
1235  *    This function configures the RLC data sap
1236  *
1237  * @param[in]  gCb   RLC Instance Control Block
1238  * @param[in]  cfg   RLC LM Sap configuration structure
1239  *
1240  * @return  S16
1241  *    -# LCM_REASON_NOT_APPL  (SUCCESS)
1242  *    -# LCM_REASON_INVALID_SAP 
1243  *    -# LCM_REASON_MEM_NOAVAIL 
1244  *    -# LCM_REASON_RECONFIG_FAIL 
1245  */
1246 static S16 rlcLmmCfgKwuSap(RlcCb *gCb,RlcSapCfg *cfg)
1247 {
1248    RlcKwuSapCb   *rlcKwuSapCb;
1249
1250 #if (ERRCLASS & ERRCLS_INT_PAR)
1251    /* Validate the protocol parameters */
1252    if((cfg->sapId >= (S16)gCb->genCfg.maxKwuSaps) || (cfg->sapId < 0))
1253    {
1254       return (LCM_REASON_INVALID_PAR_VAL);
1255    }
1256 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1257
1258    rlcKwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1259               (RlcKwuSapCb*)(gCb->u.dlCb->rlcKwuDlSap + cfg->sapId):
1260               (RlcKwuSapCb*)(gCb->u.ulCb->rlcKwuUlSap + cfg->sapId);
1261
1262 #if (ERRCLASS & ERRCLS_INT_PAR)
1263    /* Check for reconfiguration */
1264    if (rlcKwuSapCb->state != RLC_SAP_NOT_CFG)
1265    {
1266       DU_LOG("\nERROR  --> RLC : RLC Mode [%d] : Invalid rlckwuSap State [%d]",
1267             gCb->genCfg.rlcMode, rlcKwuSapCb->state);
1268       /* reconfiguration not allowed */
1269       return (LCM_REASON_RECONFIG_FAIL);
1270    }
1271 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1272
1273    /* Fill the parameters */
1274    RLC_FILL_SAP_HELPER(rlcKwuSapCb, cfg, gCb);
1275
1276    return (LCM_REASON_NOT_APPL);
1277
1278
1279 /**
1280  * @brief
1281  *    This function configures the RLC control sap
1282  *
1283  * @param[in]  gCb   RLC Instance Control Block
1284  * @param[in]  cfg   RLC LM Sap configuration structure
1285  * 
1286  * @return  S16
1287  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1288  *    -# LCM_REASON_INVALID_SAP
1289  *    -# LCM_REASON_INVALID_SAP 
1290  *    -# LCM_REASON_RECONFIG_FAIL 
1291  */
1292 static S16 rlcLmmCfgCkwSap(RlcCb  *gCb,RlcSapCfg *cfg)
1293 {
1294    RlcCkwSapCb  *ckwSap;
1295    
1296 #if (ERRCLASS & ERRCLS_INT_PAR)
1297    /* Validate config parameters */
1298    if ((cfg->sapId >= RLC_MAX_CKWSAPS) || (cfg->sapId < 0) )
1299    {
1300       return (LCM_REASON_INVALID_PAR_VAL);
1301    }
1302
1303    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1304    {
1305       /* Get Sap control block */
1306       return (LCM_REASON_INVALID_PAR_VAL);
1307    }
1308 #endif
1309
1310    ckwSap = &(gCb->u.ulCb->ckwSap);
1311
1312 #if (ERRCLASS & ERRCLS_INT_PAR)
1313    /* Check for reconfiguration */
1314    if(ckwSap->state  != RLC_SAP_NOT_CFG)
1315    {
1316       DU_LOG("\nERROR  --> RLC : Invalid rlckwuSap State [%d]",ckwSap->state);
1317       return (LCM_REASON_RECONFIG_FAIL);
1318    }
1319 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1320    
1321    /* Fill the parameters */
1322    RLC_FILL_SAP_HELPER(ckwSap, cfg, gCb);
1323
1324    return (LCM_REASON_NOT_APPL);
1325
1326
1327 /**
1328  * @brief
1329  *    This function configures the UDX sap
1330  *
1331  * @param[in]  gCb   RLC Instance Control Block
1332  * @param[in]  cfg   RLC LM Sap configuration structure
1333  *
1334  * @return  S16
1335  *    -# LCM_REASON_NOT_APPL   (SUCCESS)
1336  *    -# LCM_REASON_INVALID_SAP
1337  *    -# LCM_REASON_INVALID_SAP
1338  *    -# LCM_REASON_RECONFIG_FAIL
1339  */
1340 static S16 rlcLmmCfgUdxSap(RlcCb *gCb,RlcSapCfg *cfg)
1341 {
1342    RlcUdxDlSapCb   *udxDlSap;
1343    RlcUdxUlSapCb   *udxUlSap;
1344
1345 #if (ERRCLASS & ERRCLS_INT_PAR)
1346    /* Validate the protocol parameters */
1347    if((cfg->sapId >= RLC_MAX_UDXSAPS) || (cfg->sapId < 0))
1348    {
1349       return (LCM_REASON_INVALID_PAR_VAL);
1350    }
1351 #endif
1352    /* Get Sap control block */
1353    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1354    {
1355       udxDlSap = (gCb->u.dlCb->udxDlSap + cfg->sapId);
1356 #if (ERRCLASS & ERRCLS_INT_PAR)
1357       /* Check for reconfiguration */
1358       if(udxDlSap->state != RLC_SAP_NOT_CFG)
1359       {
1360          DU_LOG("\nERROR  --> RLC : Invalid udxDlSap State [%d]",udxDlSap->state);
1361          return (LCM_REASON_RECONFIG_FAIL);
1362       }
1363 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1364
1365       /* Fill the parameters */
1366       RLC_FILL_SAP_HELPER(udxDlSap, cfg, gCb);
1367    }
1368    else
1369    {
1370       udxUlSap = (gCb->u.ulCb->udxUlSap + cfg->sapId);
1371
1372 #if (ERRCLASS & ERRCLS_INT_PAR)
1373    /* Check for reconfiguration */
1374       if(udxUlSap->state != RLC_SAP_NOT_CFG)
1375       {
1376          DU_LOG("\nERROR  --> RLC : Invalid udxUlSap State [%d]", udxUlSap->state);
1377          return (LCM_REASON_RECONFIG_FAIL);
1378       }
1379 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1380
1381       /* Fill the parameters */
1382       RLC_FILL_SAP_HELPER(udxUlSap, cfg, gCb);
1383
1384       udxUlSap->bndTmrInt = cfg->bndTmrIntvl;
1385       udxUlSap->retryCnt = 0;
1386       cmInitTimers(&(udxUlSap->bndTmr), 1);
1387    }
1388
1389    return (LCM_REASON_NOT_APPL);
1390
1391
1392 /**
1393  * @brief
1394  *    This function configures the RGU sap
1395  *
1396  * @param[in]  gCb   RLC Instance Control Block
1397  * @param[in]  cfg   RLC LM Sap configuration structure
1398  * @return  S16
1399  *    -# LCM_REASON_NOT_APPL    (SUCCESS)
1400  *    -# LCM_REASON_INVALID_SAP
1401  *    -# LCM_REASON_INVALID_SAP
1402  *    -# LCM_REASON_RECONFIG_FAIL
1403  */
1404 static S16 rlcLmmCfgRguSap(RlcCb *gCb,RlcSapCfg *cfg)
1405 {
1406    RlcRguSapCb   *rguSap;
1407
1408 #if (ERRCLASS & ERRCLS_INT_PAR)
1409    /* Validate the protocol parameters */
1410    if((cfg->sapId >= gCb->genCfg.maxRguSaps) || \
1411       (cfg->sapId < 0))
1412    {
1413       RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
1414                "rlcLmmCfgRguSap: Invalid RGU sapId\n");
1415       return (LCM_REASON_INVALID_PAR_VAL);
1416    }
1417 #endif
1418
1419    rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1420             &(gCb->u.dlCb->rguDlSap[cfg->sapId]): &(gCb->u.ulCb->rguUlSap[cfg->sapId]);
1421
1422 #if (ERRCLASS & ERRCLS_INT_PAR)
1423    /* Check for reconfiguration */
1424    if(rguSap->state != RLC_SAP_NOT_CFG)
1425    {
1426       DU_LOG("\nERROR  --> RLC : RLC Mode [%d]: Invalid rguSap State [%d]",
1427             gCb->genCfg.rlcMode, rguSap->state);
1428       return (LCM_REASON_RECONFIG_FAIL);
1429    }
1430 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1431
1432    /* Fill the parameters */
1433    RLC_FILL_SAP_HELPER(rguSap, cfg, gCb);
1434    rguSap->suId = cfg->sapId;
1435    rguSap->bndTmrInt = cfg->bndTmrIntvl;
1436    rguSap->retryCnt = 0;
1437    rguSap->state = RLC_SAP_CFG;
1438
1439    cmInitTimers(&(rguSap->bndTmr), 1);
1440
1441    return (LCM_REASON_NOT_APPL);
1442
1443
1444 /**
1445  * @brief
1446  *    Validates the RLC general control parameters 
1447  *
1448  * @param[in] cntrl   RLC LM structure 
1449  * 
1450  * @return  S16
1451  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1452  *    -# LCM_REASON_INVALID_SUBACTION
1453  *    -# LCM_REASON_INVALID_ACTION
1454  */
1455 static S16 rlcLmmValidateGenCntrl(RlcMngmt   *cntrl)
1456 {
1457    S16     reason;    /* reason for failure */
1458    uint8_t sAction;   /* subaction field */
1459
1460    reason = LCM_REASON_NOT_APPL;
1461    sAction = cntrl->t.cntrl.subAction;
1462
1463    switch (cntrl->t.cntrl.action)
1464    {
1465       case AENA:
1466       case ADISIMM:
1467          if ((sAction != SAUSTA) && 
1468              (sAction != SADBG) && 
1469              (sAction != SATRC))
1470          {
1471             reason = LCM_REASON_INVALID_SUBACTION;
1472          }
1473          break;
1474       case ASHUTDOWN:
1475          break;
1476       default:
1477          reason = LCM_REASON_INVALID_ACTION;
1478          break;
1479    }
1480    
1481    return (reason);
1482
1483
1484 /**
1485  * @brief
1486  *    it deregisters the timers and deregisters the rlckwuSap Control blocks 
1487  *
1488  * @param[in]  gCb   RLC Instance Control Block
1489  * 
1490  * @return  Void
1491  */
1492 static Void rlcLmmCleanGblRsrcs(RlcCb *gCb)
1493 {
1494    Size   rlcSapSize;
1495    Size   rlcUdxSapSize;
1496  
1497    if (gCb->init.cfgDone)
1498    {
1499       /* Deregister the timers */
1500 /*Pradeep: changing the SDeregTmrMt() to SDeregTmr*/
1501       (Void) SDeregTmrMt(gCb->init.ent, gCb->init.inst,
1502                         (S16)gCb->genCfg.timeRes, rlcActvTmr);
1503       /*(Void) SDeregTmr(gCb->init.ent, gCb->init.inst,
1504                         (S16)gCb->genCfg.timeRes, rlcActvTmr);*/
1505
1506       rlcSapSize = (Size)(gCb->genCfg.maxKwuSaps * sizeof(RlcKwuSapCb));
1507
1508       if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1509       {
1510          rlcUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(RlcUdxDlSapCb));
1511          if (gCb->u.dlCb)
1512          {
1513             gCb->u.dlCb->shutdownReceived = TRUE;
1514             rlcUtlFreeDlMemory(gCb); 
1515             if (gCb->u.dlCb->rlcKwuDlSap != NULLP)
1516             {
1517                RLC_FREE(gCb,gCb->u.dlCb->rlcKwuDlSap, rlcSapSize);
1518             }
1519             
1520             if(gCb->u.dlCb->udxDlSap != NULLP)
1521             {
1522                RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
1523             }
1524
1525             if(gCb->u.dlCb->rguDlSap != NULLP)
1526             {
1527                RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, gCb->genCfg.maxRguSaps);
1528                gCb->genCfg.maxRguSaps = 0;
1529             }
1530              if (gCb->u.dlCb->shutdownReceived) 
1531             {
1532                if (gCb->u.dlCb->selfPstMBuf != NULL)
1533                {
1534                   ODU_PUT_MSG_BUF(gCb->u.dlCb->selfPstMBuf);
1535                }
1536                RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
1537             }
1538          }
1539          
1540       }
1541       else
1542       {
1543          rlcUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(RlcUdxUlSapCb));
1544          if (gCb->u.ulCb)
1545          {
1546             if (gCb->u.ulCb->rlcKwuUlSap != NULLP)
1547             {
1548                RLC_FREE(gCb,gCb->u.ulCb->rlcKwuUlSap, rlcSapSize);
1549             }
1550             
1551             if(gCb->u.ulCb->udxUlSap != NULLP)
1552             {
1553                RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
1554             }
1555          
1556             if(gCb->u.ulCb->rguUlSap != NULLP)
1557             {
1558                RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, gCb->genCfg.maxRguSaps);
1559                gCb->genCfg.maxRguSaps = 0;
1560             }
1561          
1562             RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
1563          }
1564       }
1565
1566       gCb->init.cfgDone = FALSE;
1567       gCb->init.acnt = FALSE;
1568       gCb->init.trc = FALSE;
1569
1570       gCb->init.usta = FALSE;
1571    }
1572
1573    return;
1574 }
1575
1576 /**
1577  * @brief
1578  *    Delete all SAPs and Control Blocks
1579  *
1580  * @details
1581  *    Shutdown of RLC happens at modules level, tm, um and am modules will be
1582  *    shutdown using utility functin and dbm shutdown will clean up the SAPs,
1583  *    control blocks and lists. 
1584  *
1585  * @params[in] gCb   RLC instance control block   
1586  *
1587  * @return  S16
1588  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1589  *    -# LCM_REASON_HASHING_FAILED 
1590  */
1591 static S16 rlcLmmShutdown(RlcCb *gCb)
1592 {
1593    RlcRguSapCb   *rguSap;
1594    uint32_t          idx;
1595
1596    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1597    {
1598       for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1599       {
1600          rguSap = &(gCb->u.dlCb->rguDlSap[idx]);
1601          if ((rguSap->state == RLC_SAP_BND) || (rguSap->state == RLC_SAP_BINDING))
1602          {
1603             RlcLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1604          }
1605       }
1606    }
1607    else
1608    {
1609       for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1610       {
1611          rguSap = &(gCb->u.ulCb->rguUlSap[idx]); 
1612          if ((rguSap->state == RLC_SAP_BND) || (rguSap->state == RLC_SAP_BINDING))
1613          {
1614             RlcLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1615          }
1616       }
1617    }
1618    
1619    if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1620    {
1621       rlcDbmDlShutdown(gCb); 
1622    }
1623    else
1624    {
1625       rlcDbmUlShutdown(gCb);
1626    }
1627
1628    rlcDelTputSnssaiList(gCb);
1629    rlcLmmCleanGblRsrcs(gCb);
1630
1631    RLC_MEM_SET (&(gCb->genSts), 0, sizeof (RlcGenSts));
1632
1633    return (LCM_REASON_NOT_APPL);
1634
1635
1636 /**
1637  * @brief
1638  *    Function processes the general control request 
1639  *
1640  * @param[in] gCb     RLC instance control block
1641  * @param[in] cntrl   RLC LM structure
1642  *
1643  * @return  S16
1644  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1645  *    -# LCM_REASON_INVALID_SUBACTION
1646  *    -# LCM_REASON_INVALID_ACTION
1647  */
1648 static S16 rlcLmmGenCntrl(RlcCb *gCb,RlcMngmt *cntrl)
1649 {
1650    RlcTrcCntrl *trcCntrl; /* trace */
1651 #ifdef DEBUGP
1652    RlcDbgCntrl *dbgCntrl; /* debug */
1653 #endif /* DEBUGP */
1654    S16   reason;         /* reason for failure */
1655    
1656    /* Validate control parameters */
1657    reason = rlcLmmValidateGenCntrl (cntrl);
1658
1659    if (reason != LCM_REASON_NOT_APPL)
1660    {
1661       return (reason);
1662    }
1663
1664    switch(cntrl->t.cntrl.action)
1665    {
1666       case AENA:
1667       {
1668          switch(cntrl->t.cntrl.subAction)
1669          {
1670             case SAUSTA:
1671             {
1672                RLC_SET_USTA_FLAG(gCb, TRUE);
1673                break;
1674             }
1675             case SADBG:
1676             {
1677 #ifdef DEBUGP
1678                dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1679                RLC_GET_DBG_MASK(gCb) |= dbgCntrl->dbgMask;
1680 #endif /* DEBUGP */
1681                break;
1682             }
1683             case SATRC:
1684             {
1685                trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1686                gCb->init.trc = TRUE;
1687                gCb->trcLen = trcCntrl->trcLen;
1688                (gCb->trcMask) |= trcCntrl->trcMask;
1689                 break;
1690             }
1691          }
1692          break;
1693       }
1694       case ADISIMM:
1695       {
1696          switch(cntrl->t.cntrl.subAction)
1697          {
1698             case SAUSTA:
1699             {
1700                gCb->init.usta = FALSE;
1701             }
1702             break;
1703             case SADBG:
1704             {
1705 #ifdef DEBUGP
1706                dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1707                RLC_GET_DBG_MASK(gCb) &= ~(dbgCntrl->dbgMask);
1708 #endif /* DEBUGP */
1709             }
1710             break;
1711             case SATRC:
1712             {
1713                trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1714                gCb->init.trc = FALSE;
1715                gCb->trcMask &= ~(trcCntrl->trcMask);
1716             }
1717             break;
1718          }
1719          break;
1720       }
1721       case ASHUTDOWN:
1722       {
1723          reason = rlcLmmShutdown(gCb);
1724          break;
1725       }
1726    }
1727    return (reason);
1728
1729
1730 /**
1731  * @brief
1732  *    Bind/Unbind RLC UDX sap 
1733  *
1734  * @param[in]  gCb     RLC Instance Control Block
1735  * @param[in]  cntrl   RLC LM structure
1736  * 
1737  * @return  S16
1738  *    -# LCM_REASON_NOT_/PPL (SUCCESS)    
1739  *    -# LCM_REASON_INVALID_SAP 
1740  *    -# LCM_REASON_INVALID_STATE
1741  *    -# LCM_REASON_INVALID_ACTION 
1742  */
1743 static S16 rlcLmmUdxSapCntrl(RlcCb *gCb,RlcMngmt *cntrl)
1744 {
1745
1746 #if (ERRCLASS & ERRCLS_INT_PAR)
1747    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1748    {
1749       return (LCM_REASON_INVALID_SAP);
1750    }
1751    /* validate SuId */
1752    if((cntrl->t.cntrl.s.sapCntrl.suId < 0) || 
1753       (cntrl->t.cntrl.s.sapCntrl.suId >= RLC_MAX_UDXSAPS))
1754    {
1755       return (LCM_REASON_INVALID_SAP);
1756    }
1757 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1758
1759 #define UDX_SAP  gCb->u.ulCb->udxUlSap[cntrl->t.cntrl.s.sapCntrl.suId]
1760 #if (ERRCLASS & ERRCLS_INT_PAR)
1761    /* validate SAP */
1762    if(UDX_SAP.state == RLC_SAP_NOT_CFG)
1763    {
1764       DU_LOG("\nERROR  --> RLC : udxUlSap not configured yet");
1765       return (LCM_REASON_INVALID_STATE);
1766    }
1767 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1768
1769    switch(cntrl->t.cntrl.action)
1770    {
1771       case ABND:
1772       {
1773          if(UDX_SAP.state != RLC_SAP_BND)
1774          {
1775             /* start timer to wait for bind confirm */
1776             rlcStartTmr(gCb,(PTR)(&UDX_SAP), EVENT_RLC_WAIT_BNDCFM);
1777             UDX_SAP.state = RLC_SAP_BINDING;
1778             rlcUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
1779          }
1780          else
1781          {
1782             /* control request received for an already bound SAP */
1783             return (LCM_REASON_INVALID_STATE);
1784          }
1785       }
1786       break;
1787       case AUBND:
1788       {
1789          /* make the state of UDXSAP configured but not bound */
1790          UDX_SAP.state = RLC_SAP_CFG;
1791          rlcUlUdxUbndReq(&(UDX_SAP.pst), UDX_SAP.spId, 0);
1792       }
1793       break;
1794       default:
1795          return (LCM_REASON_INVALID_ACTION);
1796          break;
1797    } /* end of switch */
1798 #undef UDX_SAP
1799    return (LCM_REASON_NOT_APPL);
1800
1801
1802 /**
1803  * @brief
1804  *    Bind/Unbind RLC lower sap 
1805  *
1806  * @param[in]  gCb     RLC Instance Control Block
1807  * @param[in]  cntrl   RLC LM structure
1808  * @return  S16
1809  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
1810  *    -# LCM_REASON_INVALID_SAP 
1811  *    -# LCM_REASON_INVALID_STATE
1812  *    -# LCM_REASON_INVALID_ACTION 
1813  */
1814 static S16 rlcLmmLSapCntrl(RlcCb *gCb,RlcMngmt *cntrl)
1815 {
1816    RlcRguSapCb   *rguSap;   /* rgu sap pointer */
1817
1818 #if (ERRCLASS & ERRCLS_INT_PAR)
1819    /* validate SuId */
1820    if((cntrl->t.cntrl.s.sapCntrl.suId < 0) || 
1821       (cntrl->t.cntrl.s.sapCntrl.suId >= gCb->genCfg.maxRguSaps))
1822    {
1823       RLCLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
1824                "rlcLmmLSapCntrl: Invalid RGU suId\n");
1825       return (LCM_REASON_INVALID_SAP);
1826    }
1827 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1828    rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1829             &(gCb->u.dlCb->rguDlSap[cntrl->t.cntrl.s.sapCntrl.suId]): \
1830             &(gCb->u.ulCb->rguUlSap[cntrl->t.cntrl.s.sapCntrl.suId]);
1831
1832 #if (ERRCLASS & ERRCLS_INT_PAR)
1833    /* validate SAP */
1834    if(rguSap->state == RLC_SAP_NOT_CFG)
1835    {
1836       DU_LOG("\nERROR  --> RLC : RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
1837       return (LCM_REASON_INVALID_STATE);
1838    }
1839 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1840
1841    switch(cntrl->t.cntrl.action)
1842    {
1843       case ABND:
1844       {
1845          if(rguSap->state != RLC_SAP_BND)
1846          {
1847             /* start timer to wait for bind confirm */
1848             rlcStartTmr(gCb,(PTR)(rguSap), EVENT_RLC_WAIT_BNDCFM);
1849             rguSap->state = RLC_SAP_BINDING;
1850             rguSap->spId = cntrl->t.cntrl.s.sapCntrl.spId;
1851             rguSap->suId = cntrl->t.cntrl.s.sapCntrl.suId;
1852             RlcLiRguBndReq(&(rguSap->pst), rguSap->suId, rguSap->spId);
1853          }
1854          else
1855          {
1856             /* control request received for an already bound SAP */
1857             return (LCM_REASON_INVALID_STATE);
1858          }
1859       }
1860       break;
1861       case AUBND:
1862       {
1863          /* make the state of RGUSAP is configure but not bound */
1864          rguSap->state = RLC_SAP_CFG;
1865          RlcLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1866       }
1867       break;
1868       default:
1869          return (LCM_REASON_INVALID_ACTION);
1870          break;
1871    } /* end of switch */
1872
1873    return (LCM_REASON_NOT_APPL);
1874
1875
1876 /**
1877  * @brief
1878  *    Function gather the general KWU SAP status 
1879  *
1880  * @param[in] gCb   RLC Instance Control Block
1881  * @param[in] sta   LM KWU Sap Status structure 
1882  * 
1883  * @return  S16
1884  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
1885  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
1886  */
1887 static S16 rlcLmmGetKwuSapSta (RlcCb *gCb,RlcKwuSapSta *sta)
1888 {
1889    RlcKwuSapCb   *rlcKwSapCb;
1890    
1891 #if (ERRCLASS & ERRCLS_INT_PAR)
1892    /* Validate the protocol parameters */
1893    if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
1894        (sta->spId < 0))
1895    {
1896       return (LCM_REASON_INVALID_PAR_VAL);
1897    }
1898 #endif
1899
1900    /* Get Sap control block */
1901    rlcKwSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)? 
1902              (RlcKwuSapCb*)(gCb->u.dlCb->rlcKwuDlSap + sta->spId):
1903              (RlcKwuSapCb*)(gCb->u.ulCb->rlcKwuUlSap + sta->spId);
1904
1905    sta->state = rlcKwSapCb->state;
1906
1907    return (LCM_REASON_NOT_APPL);
1908
1909
1910 /**
1911  * @brief
1912  *    Function gather the general RGU SAP status
1913  *
1914  * @param[in]  gCb   RLC Instance Control Block
1915  * @param[in]  sta   LM RGU Sap Status structure
1916  * @return  S16
1917  *    -# LCM_REASON_NOT_APPL       (SUCCESS) 
1918  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE) 
1919  */
1920 static S16 rlcLmmGetRguSapSta(RlcCb *gCb,RlcRguSapSta *sta)
1921 {
1922
1923 #if (ERRCLASS & ERRCLS_INT_PAR)
1924    /* Validate the protocol parameters */
1925    if((sta->suId >= RLC_MAX_RGUSAPS) || (sta->suId < 0))
1926    {
1927       return (LCM_REASON_INVALID_PAR_VAL);
1928    }
1929 #endif
1930
1931    sta->state = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ? 
1932                  gCb->u.dlCb->rguDlSap[sta->suId].state : 
1933                  gCb->u.ulCb->rguUlSap[sta->suId].state ;
1934
1935    return (LCM_REASON_NOT_APPL);
1936
1937
1938 /**
1939  * @brief
1940  *    Function gather the general CKW SAP status
1941  *
1942  * @param[in]  gCb   RLC Instance Control Block
1943  * @param[in]  sta   LM CKW Sap Status structure
1944  * @return  S16
1945  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
1946  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
1947  */
1948 static S16 rlcLmmGetCkwCntSapSta(RlcCb *gCb,RlcCkwCntSapSta *sta)
1949 {
1950
1951 #if (ERRCLASS & ERRCLS_INT_PAR)
1952    /* Validate config parameters */
1953    if ((sta->spId >= RLC_MAX_CKWSAPS ) ||
1954        (sta->spId < 0 ) ||
1955        (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL))
1956    {
1957       return (LCM_REASON_INVALID_PAR_VAL);
1958    }
1959 #endif
1960    sta->state =  gCb->u.ulCb->ckwSap.state;
1961
1962    return (LCM_REASON_NOT_APPL);
1963
1964
1965
1966 /**
1967  * @brief
1968  *    Gather the general statistics 
1969  *
1970  * @param[in]  gCb      RLC Instance Control Block
1971  * @param[in]  sts      LM general statistics structure
1972  * @param[in]  action   action
1973  * @return  S16
1974  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
1975  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
1976  */
1977 static S16 rlcLmmGetGenSts(RlcCb *gCb,RlcGenSts *sts,Action action)
1978 {
1979
1980 #if (ERRCLASS & ERRCLS_INT_PAR)
1981    /* Validate protocol parameters */
1982    if ((action != LKW_ZEROSTS) && (action != LKW_NOZEROSTS))
1983    {
1984       return (LCM_REASON_INVALID_PAR_VAL);
1985    }
1986 #endif
1987
1988    *sts = gCb->genSts;
1989    
1990    if(action == LKW_ZEROSTS)
1991    {
1992       RLC_MEM_SET (&(gCb->genSts), 0, sizeof (RlcGenSts));
1993    }
1994
1995    return (LCM_REASON_NOT_APPL);
1996
1997
1998 /**
1999  * @brief
2000  *    Gather the SAP statistics
2001  *
2002  * @param[in]  gCb      RLC Instance Control Block
2003  * @param[in]  sts      LM general statistics structure
2004  * @param[in]  elmnt    element 
2005  * @param[in]  action   action 
2006  * 
2007  * @return  S16
2008  *    -# LCM_REASON_NOT_APPL (SUCCESS)
2009  *    -# LCM_REASON_INVALID_PAR_VAL (FAIL)
2010  */
2011 static S16 rlcLmmGetSapSts(RlcCb *gCb,RlcMngmt *sts,Elmnt elmnt, Action action)
2012 {
2013
2014    /* Validate protocol parameters */
2015    if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
2016    {
2017       return (LCM_REASON_INVALID_PAR_VAL);
2018    }
2019    switch(elmnt)
2020    {
2021       case STKWUSAP:
2022       {
2023          RlcKwuSapSts  *rlckwuSap; 
2024          RlcKwuSapCb   *rlcKwuSapCb;    
2025          rlckwuSap = &sts->t.sts.s.rlckwuSap;
2026
2027          /* Get Sap control block */
2028          /* kw005.201, modified the element of rlckwuSap from suId to spId */
2029          rlcKwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)? 
2030               (RlcKwuSapCb*)(gCb->u.dlCb->rlcKwuDlSap + rlckwuSap->spId):
2031               (RlcKwuSapCb*)(gCb->u.ulCb->rlcKwuUlSap + rlckwuSap->spId);
2032
2033
2034          *rlckwuSap = rlcKwuSapCb->sts;
2035
2036          if (action == LKW_ZEROSTS)
2037          {
2038             RLC_MEM_SET (&rlcKwuSapCb->sts, 0, sizeof (RlcKwuSapSts));
2039          }
2040          break;
2041       }
2042       /* kw005.201 removed RGUSAP statistics support */
2043       case STCKWSAP:
2044       {
2045          RlcCkwCntSts  *ckwSap;  
2046          ckwSap = &sts->t.sts.s.ckwSap;
2047          if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) 
2048          {
2049             return (LCM_REASON_INVALID_PAR_VAL);
2050          }
2051
2052          ckwSap->statMsgs = gCb->u.ulCb->ckwSap.sts.statMsgs;
2053
2054          if (action == LKW_ZEROSTS)
2055          {
2056             RLC_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (RlcCkwCntSts));
2057          }
2058          break;
2059       }
2060       default:
2061          return (LCM_REASON_INVALID_ELMNT);
2062    }
2063
2064    SGetDateTime(&sts->t.sts.dt);
2065
2066    return (LCM_REASON_NOT_APPL);
2067
2068
2069 /**
2070  * @brief
2071  *    This function sends Unsolicited Status Indication to the Layer Management
2072  *    Entity. 
2073  *
2074  * @param[in]  gCb        RLC Instance Control Block
2075  * @param[in]  category   Category 
2076  * @param[in]  event      event
2077  * @param[in]  cause      cause
2078  * @param[in]  UeId       ueId 
2079  * @param[in]  Qci        qci 
2080  * 
2081  * @return  Void
2082  */
2083 #ifdef LTE_L2_MEAS
2084 Void rlcLmmSendAlarm
2085 (
2086 RlcCb      *gCb,
2087 uint16_t    category,  
2088 uint16_t    event,    
2089 uint16_t    cause,   
2090 SuId        suId,   
2091 uint32_t    ueId,  
2092 uint8_t     qci   
2093 )
2094 #else /* LTE_L2_MEAS */
2095 Void rlcLmmSendAlarm
2096 (
2097 RlcCb       *gCb,
2098 uint16_t    category, 
2099 uint16_t    event,   
2100 uint16_t    cause,  
2101 SuId        suId,  
2102 uint32_t    ueId  
2103 )
2104 #endif /* LTE_L2_MEAS */
2105 {
2106    RlcMngmt   usta;   /* Rlc Management Structure */
2107
2108    if(gCb->init.usta == FALSE)
2109    {
2110       return;
2111    }
2112
2113    usta.hdr.elmId.elmnt = STGEN;
2114    usta.hdr.entId.ent = gCb->init.ent;
2115    usta.hdr.entId.inst = gCb->init.inst;
2116
2117    /* fill in the event and category */
2118    usta.t.usta.alarm.category = category;
2119    usta.t.usta.alarm.event = event;
2120    usta.t.usta.alarm.cause = cause;
2121
2122    /* set the suId and ueId */
2123    usta.t.usta.ueId = ueId;
2124    usta.t.usta.suId = suId;
2125 /* kw005.201 added support for L2 Measurement */
2126 #ifdef LTE_L2_MEAS
2127    if(event == LKW_EVT_MEAS_HALT)
2128    {
2129       usta.t.usta.qci = qci;
2130    }
2131 #endif /* LTE_L2_MEAS */
2132    /* update the date and time */
2133    (Void) SGetDateTime(&usta.t.usta.alarm.dt);
2134
2135    RlcMiLkwStaInd(&(gCb->init.lmPst), &usta);
2136
2137    return;
2138
2139
2140
2141 /**
2142  * @brief
2143  *    This function sends trace indication to LM 
2144  *
2145  * @param[in]  gCb     RLC Instance Control Block
2146  * @param[in]  event   event
2147  * @param[in]  mBuf    meessage buffer
2148  *
2149  * @return S16
2150  *    -# ROK 
2151  *    -# RFAILED 
2152  */
2153 S16 rlcLmmSendTrc(RlcCb *gCb,Event event,Buffer *mBuf)
2154 {
2155    RlcMngmt   trc;              /* RLC management control block */
2156    Buffer    *dstMbuf;   
2157    MsgLen    bufLen;
2158    Data      *tempBuf;
2159    MsgLen    tempCnt;
2160    Pst       pst;
2161
2162    DU_LOG("\nDEBUG  --> RLC : rlcLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
2163                      event,
2164                      gCb->trcLen);
2165
2166    memset(&trc, 0, sizeof(RlcMngmt));
2167
2168    pst = gCb->init.lmPst;
2169
2170    trc.t.trc.event = event;
2171    SGetDateTime(&trc.t.trc.dt);
2172    trc.cfm.status = LCM_PRIM_OK;
2173    trc.cfm.reason = LCM_REASON_NOT_APPL;
2174          
2175    if(mBuf != NULLP)
2176    {
2177      /* Check if the whole buffer is to be sent in Trace indication */
2178      if(gCb->trcLen == LKW_FULL_TRACE)
2179      {
2180         if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2181             != ROK)
2182         {
2183            /* rg005.201 removed SPutSBuf on error */
2184            DU_LOG("\nERROR  --> RLC : SCpyMsgMsg Failed");   
2185            return RFAILED;
2186         }
2187         /* Send Trace Indication to Layer manager */
2188         RlcMiLkwTrcInd(&pst, &trc, dstMbuf);
2189      }
2190      /* check if only a specified number of bytes are to be sent */
2191      else if(gCb->trcLen > 0)
2192      {
2193         /* Get the length of the recvd message buffer */
2194         if (SFndLenMsg(mBuf, &bufLen) != ROK)
2195         {
2196            DU_LOG("\nERROR  --> RLC : SFndLenMsg Failed");   
2197            return RFAILED;
2198         }
2199         /* Check if the recvd buffer size is less than request trace len */
2200         if(bufLen < gCb->trcLen)
2201         {
2202            /* Copy the whole of the recvd buffer in trace indication */
2203       
2204            if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2205               != ROK)
2206            {
2207               DU_LOG("\nERROR  --> RLC : SCpyMsgMsg Failed");   
2208               return RFAILED;
2209            }
2210          
2211            /* Send Trace Indication to Layer manager */
2212            RlcMiLkwTrcInd(&pst, &trc, dstMbuf);
2213         }
2214         else
2215         {
2216            /* if the recvd buffer size is greater than request trace len */
2217            /* Get a temporary buffer to store the msg */
2218            RLC_ALLOC(gCb,tempBuf, gCb->trcLen);
2219
2220 #if (ERRCLASS & ERRCLS_INT_PAR)
2221            if(tempBuf == NULLP)
2222            {
2223               (Void) SPutSMem(RLC_GET_MEM_REGION(gCb), RLC_GET_MEM_POOL(gCb));
2224       
2225                DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
2226                return (LCM_REASON_MEM_NOAVAIL);
2227            }
2228 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2229          
2230            /* Copy trcLen nos of bytes from the recvd message */
2231            if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)   
2232            {
2233               DU_LOG("\nERROR  --> RLC : SCpyMsgFix Failed");   
2234               return RFAILED;
2235            }
2236
2237            if (ODU_GET_MSG_BUF(pst.region, pst.pool, &dstMbuf) != ROK)
2238            {
2239               DU_LOG("\nERROR  --> RLC : Memory Allocation failed");   
2240               return RFAILED;
2241            }
2242            /* Copy the tempBuf data to dst mBuf */
2243            if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
2244            {
2245               DU_LOG("\nERROR  --> RLC : SCpyMsgFix Failed");   
2246               return RFAILED;
2247            }
2248   
2249            /* Free the memory allocated for tempBuf */
2250            RLC_FREE(gCb,tempBuf, gCb->trcLen);
2251            /* Send Trace Indication to Layer manager */
2252            RlcMiLkwTrcInd(&pst, &trc, dstMbuf);
2253         }
2254      }
2255    }
2256    else
2257    {
2258       RlcMiLkwTrcInd(&pst, &trc, mBuf);
2259    }
2260
2261    return ROK;
2262
2263
2264 \f  
2265 /*
2266  * @brief
2267  *    Activate Task - timer
2268  *
2269  * @details     
2270  *    Invoked by system services to activate a task with a timer tick.
2271  *
2272  * @param[in] ent    entity
2273  * @param[in] inst   instance
2274  *
2275  * @return S16
2276  *    -# ROK
2277  *    -# RFAILED
2278  *
2279  */
2280  
2281 S16 rlcActvTmr(Ent ent,Inst inst)
2282 {
2283    RlcCb   *gCb; 
2284
2285    if (inst >= MAX_RLC_INSTANCES)
2286    {
2287       return  (RFAILED);
2288    }
2289    gCb = RLC_GET_RLCCB(inst); 
2290    cmPrcTmr(&(gCb->rlcTqCp), gCb->rlcTq, (PFV) rlcTmrExpiry);
2291    return (ROK);
2292
2293 } /* end of rlcActvTmr */
2294
2295  
2296 /********************************************************************30**
2297
2298          End of file
2299 **********************************************************************/