cu link failure fix
[o-du/l2.git] / src / 5gnrrlc / kw_lmm.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may not use this file except in compliance with the License.           #
7 #   You may obtain a copy of the License at                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
11 #   Unless required by applicable law or agreed to in writing, software        #
12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
14 #   See the License for the specific language governing permissions and        #
15 #   limitations under the License.                                             #
16 ################################################################################
17 *******************************************************************************/
18
19 /********************************************************************20**
20
21         Name:    LTE - 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                     -- KwMiLkwCfgReq
28                     -- KwMiLkwCfgCfm 
29                     -- KwMiLkwCntrlReq
30                     -- KwMiLkwCntrlCfm
31                     -- KwMiLkwStaReq
32                     -- KwMiLkwStaCfm
33                     -- KwMiLkwStaInd
34                     -- KwMiLkwStsReq
35                     -- KwMiLkwStsCfm
36                     -- KwMiLkwTrcInd 
37
38         File:     kw_lmm.c
39
40 *********************************************************************21*/
41 static const char* RLOG_MODULE_NAME="LMM";
42 static int RLOG_MODULE_ID=2048;
43 static int RLOG_FILE_ID=197;
44 /** @file kw_lmm.c
45 @brief RLC Layer Manager Module
46 **/
47
48 \f
49 /* header (.h) include files */
50 #include "envopt.h"        /* environment options */
51 #include "envdep.h"        /* environment dependent */
52 #include "envind.h"        /* environment independent */
53
54 #include "gen.h"           /* general */
55 #include "ssi.h"           /* system services */
56 #include "cm5.h"           /* common timer defines */
57 #include "cm_tkns.h"       /* common tokens defines */
58 #include "cm_mblk.h"       /* common memory allocation library defines */
59 #include "cm_llist.h"      /* common link list  defines  */
60 #include "cm_hash.h"       /* common hash list  defines */
61 #include "cm_lte.h"        /* common LTE defines */
62 #include "lkw.h"           /* LKW defines */
63 #include "ckw.h"           /* CKW defines */
64 #include "kwu.h"           /* KWU defines */
65 #include "rgu.h"           /* RGU defines */
66 #include "kw_err.h"        /* Err defines */
67 #include "kw_env.h"        /* RLC environment options */
68
69 #include "kw.h"            /* RLC defines */
70 #include "kw_dl.h"
71 #include "kw_ul.h"
72 #include "kw_udx.h"
73
74 /* extern (.x) include files */
75 #include "gen.x"           /* general */
76 #include "ssi.x"           /* system services */
77
78 #include "cm5.x"           /* common timer library */
79 #include "cm_tkns.x"       /* common tokens */
80 #include "cm_mblk.x"       /* common memory allocation */
81 #include "cm_llist.x"      /* common link list */
82 #include "cm_hash.x"       /* common hash list */
83 #include "cm_lte.x"        /* common LTE includes */
84 #include "cm_lib.x"        /* common memory allocation library */
85 #include "lkw.x"           /* LKW */
86 #include "ckw.x"           /* CKW */
87 #include "kwu.x"           /* KWU */
88 #include "rgu.x"           /* RGU */
89
90 #include "kw.x"
91 #include "kw_udx.x"
92 #include "kw_dl.x"
93 #include "kw_ul.x"
94
95 #define KW_MODULE KW_DBGMASK_LMM
96
97 RLCStats gRlcStats;
98 \f
99 /*********************************************************************
100  *             Forward Declaration of LKW Porting Functions
101  ********************************************************************/
102 PUBLIC KwCb *kwCb[KW_MAX_RLC_INSTANCES];
103 EXTERN S16 kwActvTmr ARGS ((Ent ent, Inst inst));
104
105 PRIVATE Void kwLmmSendCfm ARGS ((KwCb *gCb,Pst *pst,KwMngmt *cfm,U8 type,
106                                  Header *hdr));
107 PRIVATE S16 kwLmmGenCfg ARGS ((KwCb *gCb, KwGenCfg *cfg));
108 PRIVATE S16 kwLmmCfgKwuSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
109 PRIVATE S16 kwLmmCfgUdxSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
110 PRIVATE S16 kwLmmCfgCkwSap ARGS ((KwCb *gCb,KwSapCfg   *cfg));
111 PRIVATE S16 kwLmmCfgRguSap ARGS ((KwCb *gCb,KwSapCfg   *cfg));
112 PRIVATE S16 kwLmmGenCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
113 PRIVATE S16 kwLmmUdxSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
114 PRIVATE S16 kwLmmLSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
115 PRIVATE S16 kwLmmGetKwuSapSta ARGS ((KwCb *gCb,KwKwuSapSta *sta));
116 PRIVATE S16 kwLmmGetRguSapSta ARGS ((KwCb *gCb,KwRguSapSta *sta));
117 PRIVATE S16 kwLmmGetCkwCntSapSta ARGS ((KwCb *gCb,KwCkwCntSapSta *sta));
118 PRIVATE S16 kwLmmGetGenSts ARGS ((KwCb *gCb,KwGenSts *sts,Action action));
119 PRIVATE S16 kwLmmGetSapSts ARGS ((KwCb *gCb,KwMngmt *sts,Elmnt elmnt,Action 
120                                   action));
121
122 \f
123 /*********************************************************************
124  *             Primitives for RGU interface 
125  ********************************************************************/
126 /**
127  * @brief
128  *    Stores the general RLC configuration. 
129  * @details
130  *    It calculates the memory requirement of the Saps  
131  *    It also initializes the control blocks, the hash lists and registers
132  *    the timers. In case of error it rolls back and reports error in the 
133  *    confirm.If the general configuration is already done it is treated as 
134  *    reconfiguration, but right now reconfiguration is not supported.
135  * 
136  * @param[in]  gCb   RLC Instance Control Block
137  * @param[in]  cfm   RLC LM general config structure
138  * 
139  * @return  S16
140  *    LCM_REASON_NOT_APPL  (SUCCESS) 
141  *    LCM_REASON_MEM_NOAVAIL
142  *    LCM_REASON_REGTMR_FAIL
143  *    LCM_REASON_INVALID_PAR_VAL
144  *    LCM_REASON_HASHING_FAILED
145  */
146 #ifdef ANSI
147 PRIVATE S16 kwLmmGenCfg
148 (
149 KwCb       *gCb,
150 KwGenCfg   *cfg
151 )
152 #else
153 PRIVATE S16 kwLmmGenCfg(gCB,cfg)
154 KwCb       *gCb;
155 KwGenCfg   *cfg;
156 #endif
157 {
158    Size     kwSapSize;
159    Size     kwUdxSapSize;
160    S16      ret;
161    CmTqCp   *kwTqCp;
162    Size     rguSapSize;
163
164    TRC2(kwLmmGenCfg)
165
166    if(cfg->maxUe > KW_MAX_UE) 
167    {
168 #if (ERRCLASS & ERRCLS_INT_PAR)
169       RLOG2(L_ERROR, "Invalid maxUe : Max [%lu] Received [%lu]", 
170             KW_MAX_UE, 
171             cfg->maxUe);
172 #endif /* ERRCLASS & ERRCLS_INT_PAR */
173       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
174    }
175
176    if(cfg->maxKwuSaps > KW_MAX_KWUSAPS)
177    {
178 #if (ERRCLASS & ERRCLS_INT_PAR)
179       RLOG2(L_ERROR, "Invalid maxKwuSaps : Max [%lu] Received [%lu]", 
180             KW_MAX_KWUSAPS, 
181             cfg->maxKwuSaps);
182 #endif /* ERRCLASS & ERRCLS_INT_PAR */
183       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
184    }
185
186    if(cfg->maxUdxSaps > KW_MAX_UDXSAPS)
187    {
188 #if (ERRCLASS & ERRCLS_INT_PAR)
189       RLOG2(L_ERROR, "Invalid maxUduSaps : Max [%lu] Received [%lu]", 
190             KW_MAX_UDXSAPS, 
191             cfg->maxUdxSaps);
192 #endif /* ERRCLASS & ERRCLS_INT_PAR */
193       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
194    }
195    
196    if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > KW_MAX_RGUSAPS))
197    {
198       
199
200       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
201    }
202    if(gCb->init.cfgDone == TRUE)
203    {
204       /* reconfiguration not supported */
205       RETVALUE(LCM_REASON_RECONFIG_FAIL);
206    }
207
208    gCb->genCfg = *cfg;
209
210    /* Timer Queue Control point initialization */
211    kwTqCp         = &(gCb->kwTqCp);
212    kwTqCp->tmrLen = KW_TMR_LEN;
213    kwTqCp->nxtEnt = 0;
214
215    if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
216    {
217       KW_ALLOC(gCb,gCb->u.dlCb, sizeof (KwDlCb));
218       if (gCb->u.dlCb == NULLP)
219       {  
220          RLOG0(L_FATAL,"Memory Allocation failed");   
221          RETVALUE(LCM_REASON_MEM_NOAVAIL);
222       
223       }
224       /* allocate memory to the KWU sap's */
225       kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
226                    (Size)sizeof(KwKwuSapCb));
227
228       KW_ALLOC(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
229
230 #if (ERRCLASS & ERRCLS_INT_PAR)
231       if(gCb->u.dlCb->kwuDlSap == NULLP)
232       {
233          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
234          RLOG0(L_FATAL,"Memory Allocation failed");   
235          RETVALUE(LCM_REASON_MEM_NOAVAIL);
236       }
237 #endif /* ERRCLASS & ERRCLS_INT_PAR */
238
239       gCb->u.dlCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
240
241       kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
242                    (Size)sizeof(KwUdxDlSapCb));
243
244       KW_ALLOC(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
245 #if (ERRCLASS & ERRCLS_INT_PAR)
246       if(gCb->u.dlCb->udxDlSap == NULLP)
247       {
248          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
249          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
250          RLOG0(L_FATAL,"Memory Allocation failed");   
251          RETVALUE(LCM_REASON_MEM_NOAVAIL);
252       }
253 #endif /* ERRCLASS & ERRCLS_INT_PAR */
254
255       rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
256                    (Size)sizeof(KwRguSapCb));
257       KW_ALLOC(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
258 #if (ERRCLASS & ERRCLS_INT_PAR)
259       if(gCb->u.dlCb->rguDlSap == NULLP)
260       {
261          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
262          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
263          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
264       
265          KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
266                    "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
267          RETVALUE(LCM_REASON_MEM_NOAVAIL);
268       }
269 #endif /* ERRCLASS & ERRCLS_INT_PAR */
270
271       
272       /* Initialize the Ue and Cell hash list */
273       ret = kwDbmDlInit(gCb);
274       if (ret != ROK)
275       {
276          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
277          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
278          KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
279          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
280          RLOG0(L_FATAL,"RLC DL Initialization failed");   
281          RETVALUE(LCM_REASON_MEM_NOAVAIL);
282       }
283       /* Register the timer */
284 /*Pradeep: changing the SRegTmrMt() to SRegTmr()*/
285       if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
286               kwActvTmr) != ROK)
287       {
288          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
289          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
290          KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
291          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
292
293          RETVALUE(LCM_REASON_REGTMR_FAIL);
294       }
295
296       /* initializations for background processing of freeing memory */
297       kwUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
298       kwUtlInitializeSelfPst(gCb);
299
300       if(SGetMsg(gCb->init.region, 
301                  gCb->init.pool,
302                  &(gCb->u.dlCb->selfPstMBuf)) != ROK)
303       {
304          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
305          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
306          KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
307          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
308
309          RETVALUE(LCM_REASON_MEM_NOAVAIL);
310       
311       }
312 #ifdef LTE_L2_MEAS
313       kwUtlL2MeasDlInit(gCb);
314 #endif
315    }
316    else if(gCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
317    {
318       KW_ALLOC(gCb,gCb->u.ulCb, sizeof (KwUlCb));
319       if (gCb->u.ulCb == NULLP)
320       {     
321          RLOG0(L_FATAL,"Memory Allocation failed");   
322          RETVALUE(LCM_REASON_MEM_NOAVAIL);
323       
324       }
325       /* allocate memory to the KWU sap's */
326       kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
327                    (Size)sizeof(KwKwuSapCb));
328
329       KW_ALLOC(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
330
331 #if (ERRCLASS & ERRCLS_INT_PAR)
332       if(gCb->u.ulCb->kwuUlSap == NULLP)
333       {
334          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
335          RLOG0(L_FATAL,"Memory Allocation failed");   
336          RETVALUE(LCM_REASON_MEM_NOAVAIL);
337       }
338 #endif /* ERRCLASS & ERRCLS_INT_PAR */
339
340       gCb->u.ulCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
341
342       /* allocate memory to the KWU sap's */
343       kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
344                    (Size)sizeof(KwUdxUlSapCb));
345
346       KW_ALLOC(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
347
348 #if (ERRCLASS & ERRCLS_INT_PAR)
349       if(gCb->u.ulCb->kwuUlSap == NULLP)
350       {
351          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
352          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
353          RLOG0(L_FATAL,"Memory Allocation failed");   
354          RETVALUE(LCM_REASON_MEM_NOAVAIL);
355       }
356 #endif /* ERRCLASS & ERRCLS_INT_PAR */
357
358       rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
359                    (Size)sizeof(KwRguSapCb));
360       KW_ALLOC(gCb,gCb->u.ulCb->rguUlSap, rguSapSize);
361 #if (ERRCLASS & ERRCLS_INT_PAR)
362       if(gCb->u.ulCb->rguUlSap == NULLP)
363       {
364          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
365          KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
366          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
367       
368          KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
369                    "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
370          RETVALUE(LCM_REASON_MEM_NOAVAIL);
371       }
372 #endif /* ERRCLASS & ERRCLS_INT_PAR */
373
374       /* Initialize the Ue and Cell hash list */
375       ret = kwDbmUlInit(gCb);
376       if (ret != ROK)
377       {
378          KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
379          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
380          KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
381          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
382          RLOG0(L_FATAL,"RLC DL Initialization failed");   
383       }
384
385       /* Register the timer */
386
387       if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
388               kwActvTmr) != ROK)
389       {
390          KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
391          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
392          KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
393          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
394
395          RETVALUE(LCM_REASON_REGTMR_FAIL);
396       }
397 #ifdef LTE_L2_MEAS
398       kwUtlL2MeasUlInit(gCb);
399 #endif
400    }
401    else
402    {
403 #if (ERRCLASS & ERRCLS_INT_PAR)
404       RLOG0(L_ERROR, "Received Invalid RLC Mode");
405 #endif /* ERRCLASS & ERRCLS_INT_PAR */
406
407       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
408    }
409    /* Timer Initialization  */
410    gCb->kwTqCp.tmrLen = KW_TMR_LEN;
411
412    cmMemset((U8*)gCb->kwTq, NULLP, sizeof(CmTqType) * KW_TMR_LEN);
413
414    KW_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
415
416    gCb->init.lmPst.srcProcId = gCb->init.procId;
417    gCb->init.lmPst.srcEnt = gCb->init.ent;
418    gCb->init.lmPst.srcInst = gCb->init.inst;
419    gCb->init.lmPst.event = EVTNONE;
420
421    /* kw002.201 For multi core and multi region,no need to reinitiailize the 
422     * region again . This would be done with kwActvInit from SSI */
423 #if !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION)
424    gCb->init.region = cfg->lmPst.region;
425 #endif /* !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION) */
426    gCb->init.pool   = cfg->lmPst.pool;
427
428    gCb->init.cfgDone = TRUE;
429
430    RETVALUE(LCM_REASON_NOT_APPL);
431
432
433 /**
434  * @brief
435  *     Sends confirmation message to LM Called by KwMiLkwCfgReq function
436  * 
437  * @param[in] gCb    RLC Instance Control Block
438  * @param[in] pst    Post structure
439  * @param[in] cfm    RLC LM structure 
440  * @param[in] type   Type of LM message
441  * @param[in] hdr    Message header
442  * 
443  * @return  S16
444  *     -# ROK
445  */
446 #ifdef ANSI
447 PRIVATE Void kwLmmSendCfm
448 (
449 KwCb      *gCb,
450 Pst       *pst,                
451 KwMngmt   *cfm,               
452 U8        type,              
453 Header    *hdr              
454 )
455 #else
456 PRIVATE Void kwLmmSendCfm(gCb,pst, cfm, type, hdr)
457 KwCb      gCb;
458 Pst       *pst;            
459 KwMngmt   *cfm;           
460 U8        type;          
461 Header    *hdr;         
462 #endif
463 {
464    Pst   rPst;   /* Reply post structure */
465
466    TRC2(kwLmmSendCfm);
467
468    KW_MEM_SET(&rPst, 0, sizeof(Pst));   
469  
470    /* reply post structure for confirmation */
471    if (gCb)
472    {
473       rPst.srcEnt = gCb->init.ent;
474       rPst.srcInst = gCb->init.inst;
475       cfm->hdr.entId.ent = gCb->init.ent;
476       cfm->hdr.entId.inst = gCb->init.inst;
477    }
478    else
479    {
480       rPst.srcEnt = pst->dstEnt;
481       rPst.srcInst = pst->dstInst;
482       cfm->hdr.entId.ent = pst->dstEnt;
483       cfm->hdr.entId.inst = pst->dstInst;
484    }
485    rPst.srcProcId = SFndProcId();
486    rPst.dstEnt = pst->srcEnt;
487    rPst.dstInst = pst->srcInst;
488    rPst.dstProcId = pst->srcProcId;
489    rPst.selector = hdr->response.selector;
490    rPst.prior = hdr->response.prior;
491    rPst.route = hdr->response.route;
492    rPst.region = hdr->response.mem.region;
493    rPst.pool= hdr->response.mem.pool;
494
495    /* Fill the reply header */
496    cfm->hdr.elmId.elmnt = hdr->elmId.elmnt;
497    cfm->hdr.transId = hdr->transId;
498
499    switch(type)
500    {
501       case TCFG:
502          KwMiLkwCfgCfm(&rPst,cfm);
503          break;
504       case TCNTRL:
505          SGetDateTime(&(cfm->t.cntrl.dt));
506          KwMiLkwCntrlCfm(&rPst,cfm);
507          break;
508       case TSTS:
509          SGetDateTime(&(cfm->t.sts.dt));
510          KwMiLkwStsCfm(&rPst,0,cfm);
511          break;
512       case TSSTA:
513          SGetDateTime(&(cfm->t.ssta.dt));
514          KwMiLkwStaCfm(&rPst,cfm);
515          break;
516       default:
517 #if (ERRCLASS & ERRCLS_INT_PAR)
518          RLOG0(L_ERROR, "Received Invalid Message Type");
519          if(!gCb)
520          {
521             fflush(stdout);
522          }
523 #endif /* ERRCLASS & ERRCLS_INT_PAR */
524          break;
525    }
526
527    RETVOID; 
528
529
530
531 /**
532  * @brief
533  *    This function processes configuration requests received from the layer 
534  *    manager.
535  *
536  * @details
537  *    The configuration requests can be for general configuration, or 
538  *    configuration of RGU, KWU, and CKW SAPs. The type of the configuration 
539  *    request can be determined from the elmId field in the header of the layer
540  *    manager message.This function is called by the layer manager to configure
541  *    RLC. 
542  *
543  *    This function implements the following logic: 
544  *
545  *    - if genCfg is not done, send negative Cfm to the layer manager; 
546  *
547  *    - switch (cfg->hdr.elmId.elmnt)
548  *       - case STGEN 
549  *          - update the genCfg field in RlCb; 
550  *          - allocate the maximum static memory required by the RLC product; 
551  *          - register the timer service by calling SReqTmr; 
552  *          - set CfgDone for not configuring again; 
553  *       - case STKWUSAP 
554  *          - if all the parameters are valid, then allocate the KwuSap control 
555  *            block; 
556  *          - update the SAP control block with the information provided in the 
557  *          - configuration request; 
558  *          - send configuration confirm with the status, success; 
559  *       - case STCKWSAP 
560  *          - if all the parametes are valid, then allocate the CkwSap control 
561  *            block; 
562  *          - update the SAP control block with the information provided in the
563  *            configuration request; 
564  *          - send configuration confirm with the status, success; 
565  *       - case STRGUSAP 
566  *          - if all the parametes are valid, then allocate the rguSap control 
567  *            block; 
568  *          - update the SAP control block with the information provided in the
569  *            configuration request; 
570  *          - send configuration confirm with the status, success; 
571  *       - case STUDXSAP 
572  *          - if all the parametes are valid, then allocate the udxSap control 
573  *            block; 
574  *          - update the SAP control block with the information provided in the
575  *            configuration request; 
576  *          - send configuration confirm with the status, success; 
577  *    - end switch;
578  *     
579  * @param[in] pst   post structure 
580  * @param[in] cfg   LM management structure 
581  * 
582  * @return S16
583  *    -# Success : ROK
584  *    -# Failure : RFAILED
585  */
586
587 #ifdef ANSI
588 PUBLIC S16 KwMiLkwCfgReq 
589 (
590 Pst       *pst, 
591 KwMngmt   *cfg
592 )
593 #else
594 PUBLIC S16 KwMiLkwCfgReq (pst, cfg)
595 Pst       *pst;
596 KwMngmt   *cfg;
597 #endif
598 {
599    Reason   reason;   /* failure reason */
600    KwCb     *tKwCb=NULLP;
601
602    TRC3(KwMiLkwCfgReq);
603
604 #if (ERRCLASS & ERRCLS_INT_PAR)
605    /* Check if the instance is configured */
606    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
607    {
608       cfg->cfm.status = LCM_PRIM_NOK;
609       cfg->cfm.reason = LCM_REASON_INVALID_INSTANCE;
610       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);     
611       RETVALUE(RFAILED);
612    }
613 #endif
614    
615    tKwCb =  KW_GET_KWCB(pst->dstInst);
616
617    if (!tKwCb)
618    {
619       cfg->cfm.status = LCM_PRIM_NOK;
620       cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
621       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);     
622       RETVALUE(RFAILED);
623    }
624    /* check configuration is done or not */
625    if ((tKwCb->init.cfgDone != TRUE) && 
626        (cfg->hdr.elmId.elmnt != STGEN))
627    {
628       /*
629        * if general config is not over then use pst structure
630        * in primitive to communicate to stack manager
631        */
632
633       cfg->cfm.status = LCM_PRIM_NOK;
634       cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
635       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);     
636       RETVALUE(RFAILED);
637    }
638
639    RLOG1(L_DEBUG, "KwMiLkwCfgReq elmId(%d)", cfg->hdr.elmId.elmnt);
640
641    switch(cfg->hdr.elmId.elmnt)
642    {
643       case STGEN:
644       {
645          reason = kwLmmGenCfg(tKwCb,&cfg->t.cfg.s.gen);
646          break;
647       }
648       case STKWUSAP:
649       {
650          reason = kwLmmCfgKwuSap(tKwCb,&cfg->t.cfg.s.sap);
651          break;
652       }
653       case STCKWSAP:
654       {
655          reason = kwLmmCfgCkwSap(tKwCb,&cfg->t.cfg.s.sap);
656          break;
657       }
658       case STRGUSAP:
659       {
660          reason = kwLmmCfgRguSap(tKwCb,&cfg->t.cfg.s.sap);
661          break;
662       }
663       case STUDXSAP:
664       {
665          reason = kwLmmCfgUdxSap(tKwCb,&cfg->t.cfg.s.sap);
666          break;
667       }
668       default:
669       {
670          reason = LCM_REASON_INVALID_ELMNT;
671          break;
672       }   
673    }
674
675    if (reason == LCM_REASON_NOT_APPL)
676    {
677       cfg->cfm.status = LCM_PRIM_OK;
678       cfg->cfm.reason = LCM_REASON_NOT_APPL;
679       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
680       RETVALUE(ROK);
681    }
682    else
683    {
684       cfg->cfm.status = LCM_PRIM_NOK;
685       cfg->cfm.reason = reason;
686       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
687       RETVALUE(RFAILED);
688    }
689
690
691 /**
692  * @brief 
693  *    The layer manager initiates and uses the management-control procedure to 
694  *    control RLC elements.The RLC control request primitive (KwMiLkwCntrlReq) 
695  *    can be called more than once and at any time after the 
696  *    management-configuration procedure.The control request primitive 
697  *    is confirmed by a KwMiLkwCntrlCfm primitive.
698  *
699  * @details
700  *    This function implements the following logic: 
701  *  
702  *    - if(cfgDone = FALSE) 
703  *       - send negative confirmation to the layer manager; 
704  *       - return; 
705  *    - else 
706  *    - switch(cntrl->hdr.elmId.elmnt) 
707  *       -  case STGEN 
708  *           - switch (action) 
709  *           - case AENA 
710  *                - switch(subAction) 
711  *                - case SAUSTA 
712  *                     - enable the unsolicited status flag; 
713  *                     - send the control Cfm with success; 
714  *                - case SADBG 
715  *                     - set the debug mask; 
716  *                     - send the control Cfm with success; 
717  *                - case SATRC 
718  *                     - enable the trace flag; 
719  *                     - send the control Cfm with success; 
720  *            - case ADISIMM 
721  *               - switch(subAction) 
722  *               - case SAUSTA 
723  *                    - disable the unsolicited status flag; 
724  *                    - send the control Cfm with success; 
725  *               - case SATRC 
726  *                    - disable the trace flag; 
727  *                    - send the control Cfm with success; 
728  *          - case ASHUTDOWN 
729  *     - case STRGUSAP 
730  *          - Call LSapCntrl
731  *     - case STUDXSAP 
732  *          - Call UdxSapCntrl
733  *     - default  
734  *    - end else  
735  * 
736  * @param[in] pst     post structure
737  * @param[in] cntrl   LM management structure
738  * 
739  * @return S16
740  *    -# ROK
741  *    -# RFAILED
742  */
743 #ifdef ANSI
744 PUBLIC S16 KwMiLkwCntrlReq
745 (
746 Pst       *pst, 
747 KwMngmt   *cntrl
748 )
749 #else
750 PUBLIC S16 KwMiLkwCntrlReq(pst, cntrl)
751 Pst       *pst;
752 KwMngmt   *cntrl;
753 #endif
754 {
755    Reason   reason;   /* failure reason */
756    KwCb     *tKwCb=NULLP;
757
758    TRC3(KwMiLkwCntrlReq)
759
760 #if (ERRCLASS & ERRCLS_INT_PAR)
761    /* Check if the instance is configured */
762    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
763    {
764       cntrl->cfm.status = LCM_PRIM_NOK;
765       cntrl->cfm.reason =  LCM_REASON_INVALID_INSTANCE;
766
767       kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
768       RETVALUE(RFAILED);
769    }
770 #endif
771    
772    tKwCb =  KW_GET_KWCB(pst->dstInst);
773
774    if(!tKwCb)
775    {
776       cntrl->cfm.status = LCM_PRIM_NOK;
777       cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
778       kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
779       RETVALUE(RFAILED);
780    }
781
782    if (!(tKwCb->init.cfgDone))
783    {
784       cntrl->cfm.status = LCM_PRIM_NOK;
785       cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
786       kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
787       RETVALUE(RFAILED);
788    }
789    RLOG1(L_DEBUG, "KwMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
790
791    /* In normal cases, LCM_REASON_NOT_APPL is returned in cfm.
792     * In all error cases appropriate reason is returned
793     * by the functions below
794     */
795
796    switch (cntrl->hdr.elmId.elmnt)
797    {
798       case STGEN:
799       {
800          /* general control */
801          reason = kwLmmGenCntrl(tKwCb,cntrl);
802          break;
803       }
804       case STRGUSAP:
805       {
806          /* Lower SAP control */
807          reason = kwLmmLSapCntrl(tKwCb,cntrl);
808          break;
809       }
810       case STUDXSAP:
811       {
812          /* Udx Sap cntrl */
813          reason = kwLmmUdxSapCntrl(tKwCb,cntrl);
814          break;
815       }
816       default:
817       {
818          reason = LCM_REASON_INVALID_ELMNT;
819          break;
820       }
821    } /* end switch */
822    
823    if (reason == LCM_REASON_NOT_APPL)
824    {
825       cntrl->cfm.status = LCM_PRIM_OK;
826       cntrl->cfm.reason = LCM_REASON_NOT_APPL;
827    }
828    else
829    {
830       cntrl->cfm.status = LCM_PRIM_NOK;
831       cntrl->cfm.reason = reason;
832    }
833
834    kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
835
836    RETVALUE(ROK);
837
838
839 /**
840  * @brief 
841  *    This function processes solicited status requests received from the layer
842  *    manager. The layer manager can request status information regarding the
843  *    system ID, RGUSAP,KWUSAP, or CKWSAP.
844  *
845  * @param[in] pst   post structure
846  * @param[in] sta   LM management structure
847  * @return S16
848  *    -# ROK (SUCCESS)
849  *    -# RFAILED
850  */
851 #ifdef ANSI
852 PUBLIC S16 KwMiLkwStaReq
853 (
854 Pst       *pst, 
855 KwMngmt   *sta
856 )
857 #else
858 PUBLIC S16 KwMiLkwStaReq(pst, sta)
859 Pst       *pst;
860 KwMngmt   *sta;
861 #endif
862 {
863    KwMngmt   rSta;     /* Status */
864    Reason    reason;   /* Failure reason */
865    KwCb      *tKwCb=NULLP;
866
867    TRC3(KwMiLkwStaReq);
868
869 #if (ERRCLASS & ERRCLS_INT_PAR)
870    /* Check if the instance is configured */
871    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
872    {
873       sta->cfm.status = LCM_PRIM_NOK;
874       sta->cfm.reason = LCM_REASON_INVALID_INSTANCE;
875
876       kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
877       RETVALUE(RFAILED);
878    }
879 #endif
880    
881    tKwCb =  KW_GET_KWCB(pst->dstInst);
882    if (!tKwCb)
883    {
884       sta->cfm.status = LCM_PRIM_NOK;
885       sta->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
886
887       kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
888       RETVALUE(RFAILED);
889    }
890
891    RLOG1(L_DEBUG, "Status request for elmId(%d))", sta->hdr.elmId.elmnt);
892
893    reason = LCM_REASON_NOT_APPL;
894
895    KW_MEM_SET(&rSta, 0, sizeof(KwMngmt));
896    switch (sta->hdr.elmId.elmnt)
897    {
898       case STSID:
899       {
900          reason = LCM_REASON_NOT_APPL;
901          kwGetSId(&rSta.t.ssta.s.sysId);
902          break;
903       }
904       case STKWUSAP:
905       {
906          KW_MEM_CPY (&rSta.t.ssta.s.kwuSap, 
907                      &sta->t.ssta.s.kwuSap, 
908                      sizeof (KwKwuSapSta));
909
910          reason = kwLmmGetKwuSapSta (tKwCb,&rSta.t.ssta.s.kwuSap);
911          break;
912       }
913       case STRGUSAP:
914       {
915          KW_MEM_CPY (&rSta.t.ssta.s.rguSap, 
916                      &sta->t.ssta.s.rguSap,
917                      sizeof (KwRguSapSta));
918
919          reason = kwLmmGetRguSapSta (tKwCb,&rSta.t.ssta.s.rguSap);
920          break;
921       }
922       case STCKWSAP:
923       {
924          KW_MEM_CPY (&rSta.t.ssta.s.ckwSap, 
925                      &sta->t.ssta.s.ckwSap,
926                      sizeof (KwCkwCntSapSta));
927
928          reason = kwLmmGetCkwCntSapSta (tKwCb,&rSta.t.ssta.s.ckwSap);
929          break;
930       }
931       default:
932       {
933          reason = LCM_REASON_INVALID_ELMNT;
934          break;
935       }
936    } /* end of switch */
937
938    if (reason == LCM_REASON_NOT_APPL)
939    {
940       rSta.cfm.status = LCM_PRIM_OK;
941       rSta.cfm.reason = LCM_REASON_NOT_APPL;
942    }
943    else
944    {
945       rSta.cfm.status = LCM_PRIM_NOK;
946       rSta.cfm.reason = reason;
947    }
948    kwLmmSendCfm(tKwCb,pst, &rSta, TSSTA, &sta->hdr);
949
950    RETVALUE(ROK);
951
952
953 /**
954  * @brief 
955  *    This function processes statistics requests received from the layer
956  *    manager.
957  *
958  * @details  
959  *    After collecting the statistics, ir calls the statistics confirm function
960  *    to send the statistics to the layer manager.
961  *
962  *    - switch(sts->hdr.elmId.elmnt) 
963  *    - case STGEN 
964  *       - get the general statistics from the KW control block; 
965  *       - if (action = RESET) 
966  *          - reset the general statistic field in the RlCb; 
967  *          - call KwMiLkwStsCfm to send statistics back to layer manager; 
968  *    - case STCKWSAP 
969  *    - case STKWUSAP 
970  *    - case STRGUSAP 
971  *        - get the SAP specific statistics from KW control block; 
972  *        - if (action = RESET) 
973  *       - reset the general statistic field in the RlCb; 
974  *       - call KwMiLkwStsCfm to send statistics to the layer manager; 
975  *  -end switch;
976  *
977  * @param[in] pst      post structure
978  * @param[in] action   action 
979  * @param[in] sts      LM management structure
980  * 
981  * @return S16
982  *    -# ROK
983  *    -# RFAILED
984  */
985 #ifdef ANSI
986 PUBLIC S16 KwMiLkwStsReq 
987 (
988 Pst      *pst, 
989 Action    action, 
990 KwMngmt   *sts
991 )
992 #else
993 PUBLIC S16 KwMiLkwStsReq (pst, action, sts)
994 Pst       *pst;
995 Action    action;
996 KwMngmt   *sts;
997 #endif
998 {
999    KwMngmt   rSts;     /* Statistics */
1000    Reason    reason;   /* Reason for failure */
1001    KwCb     *tKwCb=NULLP;
1002
1003    TRC3(KwMiLkwStsReq);
1004
1005 #if (ERRCLASS & ERRCLS_INT_PAR)
1006    /* Check if the instance is configured */
1007    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
1008    {
1009       rSts.cfm.status = LCM_PRIM_NOK;
1010       rSts.cfm.reason = LCM_REASON_INVALID_INSTANCE;
1011
1012       kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
1013       RETVALUE(RFAILED);
1014    }
1015 #endif
1016    
1017    tKwCb =  KW_GET_KWCB(pst->dstInst);
1018    if (!tKwCb)
1019    {
1020       rSts.cfm.status = LCM_PRIM_NOK;
1021       rSts.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
1022
1023       kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
1024       RETVALUE(RFAILED);
1025    }
1026
1027    RLOG2(L_DEBUG, "KwMiLkwStsReq(elmId(%d),action(%d))", 
1028                        action, 
1029                        sts->hdr.elmId.elmnt);
1030
1031    KW_MEM_SET(&rSts, 0, sizeof(KwMngmt));
1032
1033    switch (sts->hdr.elmId.elmnt)
1034    {
1035       case STGEN:
1036       {
1037          reason = kwLmmGetGenSts(tKwCb,&rSts.t.sts.s.gen, action);
1038          break;
1039       }
1040       case STKWUSAP:
1041       case STCKWSAP:
1042       {
1043          if( sts->hdr.elmId.elmnt == STKWUSAP)
1044          {
1045             /* kw005.201, modified the element of kwuSap from suId to spId */
1046             rSts.t.sts.s.kwuSap.spId = sts->t.sts.s.kwuSap.spId;
1047          }
1048          reason = kwLmmGetSapSts(tKwCb,&rSts, sts->hdr.elmId.elmnt, action);
1049          break;
1050       }
1051       default:
1052       {
1053          reason = LCM_REASON_INVALID_ELMNT;
1054          break;
1055       }
1056    } /* end switch */
1057
1058    if (reason == LCM_REASON_NOT_APPL)
1059    {
1060       rSts.cfm.status = LCM_PRIM_OK;
1061       rSts.cfm.reason = LCM_REASON_NOT_APPL;
1062    }
1063    else
1064    {
1065       rSts.cfm.status = LCM_PRIM_NOK;
1066       rSts.cfm.reason = reason;
1067    }
1068    kwLmmSendCfm(tKwCb,pst, &rSts, TSTS, &sts->hdr);
1069
1070    RETVALUE(ROK);
1071
1072
1073 /* kw005.201 added support for L2 Measurement */
1074 #ifdef LTE_L2_MEAS
1075 /**
1076 @brief 
1077 This function processes L2 Measurement requests received from the layer manager.
1078 The L2 Measurement is start for a time period and after the timer expiry, the 
1079 measurement confirm is sent.
1080
1081 -  Accept only one set of measurements.
1082 -  Allocate and initialise KwL2MeasEvtCb.
1083 -  Validate if the measurement is already in progress.
1084    -  Loop through the existing measEvtCb with matching measType
1085       -  Check if measurement is running for any qci present in the measReq
1086       -  If present, move the qCi to list of invalid qCIs.
1087 -  Set KwL2MeasEvtCb.measOn to TRUE for QCIs to be measured.
1088 -  For the number of measurements requested.
1089    -  For all Ues with RBs matching qCI.
1090       -  Add RbCb to the RB linked list.
1091       -  Set kwRbCb.measOn to measurement type.
1092       -  If Meas type is DL_DELAY
1093          -  Update COUNT to startCount.
1094 -  Start l2Timer
1095
1096  *  @param[in] pst      post structure
1097  *  @param[in] action   action 
1098  *  @param[in] cfg      LM management structure
1099  *  @return S16
1100  *      -# Success : ROK
1101  *      -# Failure : RFAILED
1102 */
1103 #ifdef ANSI
1104 PUBLIC S16 KwMiLkwL2MeasReq 
1105 (
1106 Pst            *pst, 
1107 KwL2MeasReqEvt *measReqEvt 
1108 )
1109 #else
1110 PUBLIC S16 KwMiLkwL2MeasReq (pst, measReqEvt)
1111 Pst            *pst; 
1112 KwL2MeasReqEvt *measReqEvt;
1113 #endif
1114 {
1115    S16            ret = ROK;
1116    U16            cntr;
1117    U8             measType;
1118    KwL2MeasCfmEvt measCfmEvt;
1119
1120    KwCb     *tKwCb;
1121
1122    TRC3(KwMiLkwL2MeasReq);
1123
1124    tKwCb =  KW_GET_KWCB(pst->dstInst);
1125
1126    /* Initialize measCfmEvt */
1127    KW_MEM_ZERO(&measCfmEvt, sizeof(KwL2MeasCfmEvt));
1128    /* validate the received measReqEvt */
1129    /*LTE_L2_MEAS_PHASE2*/
1130    if(measReqEvt->measPeriod != 0)
1131    {
1132       /* L2 MEAS AGHOSH */
1133       if((measReqEvt->measReq.measType & LKW_L2MEAS_DL_IP)|| 
1134             (measReqEvt->measReq.measType & LKW_L2MEAS_UL_IP))
1135       {
1136          ret = kwUtlValidateIpThL2Meas(measReqEvt, &measCfmEvt);
1137       }
1138
1139       if(ret != ROK)
1140       {
1141 #if (ERRCLASS & ERRCLS_ADD_RES)
1142 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1143          kwUtlSndUlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
1144          KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
1145          RETVALUE(RFAILED);
1146       }
1147    }
1148
1149    measType = measReqEvt->measReq.measType;
1150
1151    if((measType != LKW_L2MEAS_DL_IP) &&
1152       (measType !=  LKW_L2MEAS_ACT_UE) &&
1153       (measType !=  LKW_L2MEAS_DL_DISC) &&
1154       (measType != LKW_L2MEAS_DL_DELAY) && 
1155       (measType != LKW_L2MEAS_UU_LOSS) &&
1156       (measType !=  LKW_L2MEAS_UL_IP))/* || (qci > LKW_MAX_QCI)*/
1157    {
1158       measCfmEvt.transId = measReqEvt->transId;
1159       measCfmEvt.measType = measType;
1160       measCfmEvt.status.status = LCM_PRIM_NOK;
1161       measCfmEvt.status.reason = LKW_CAUSE_INVALID_MEASTYPE;
1162       kwUtlSndDlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
1163       KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
1164       RETVALUE(ROK);
1165    }
1166
1167    /* for UL IP throughput meas enable for all QCIs */
1168    if(measType & LKW_L2MEAS_UL_IP)
1169    {
1170       for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1171       {
1172          tKwCb->u.ulCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
1173       }
1174    }
1175   
1176    if(measType & 
1177       (LKW_L2MEAS_DL_IP | LKW_L2MEAS_DL_DISC | 
1178       LKW_L2MEAS_DL_DELAY | LKW_L2MEAS_UU_LOSS))
1179    {
1180       KwL2MeasReqEvt *measEvt;
1181       Pst      *udxPst;
1182
1183       udxPst = &(KW_GET_UDX_SAP(tKwCb)->pst);
1184       
1185       KW_ALLOC_SHRABL_BUF(udxPst->region, 
1186                           udxPst->pool,
1187                           measEvt, 
1188                           sizeof(KwL2MeasReqEvt));
1189
1190 #if (ERRCLASS & ERRCLS_ADD_RES) /* KW_FIX */ 
1191       if(measEvt == NULLP)
1192       {
1193          RLOG0(L_FATAL,"Memory Allocation failed");   
1194          RETVALUE(RFAILED);
1195       }   
1196 #endif      
1197       cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(KwL2MeasReqEvt));
1198       /*Redirect the request to DL task */
1199       /* NOTE:As of today, there are no cases where the Req will fail at DL
1200          as long as it reached the DL, so we don't wait for a confirmation from
1201          DL to send the confirmation to LM*/
1202       /* The interface for sending a confirmation back does not exist today;
1203          it needs to be created when the need arises */
1204       KwUlUdxL2MeasReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measEvt);
1205    }
1206
1207    /* We need to copy the transId for sending back confirms later */
1208    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1209    {
1210       KwL2MeasEvtCb* measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1211       if(measEvtCb->measCb.measType & measType)
1212       {
1213          measEvtCb->transId= measReqEvt->transId;
1214       }
1215    }
1216    /*KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt));*/
1217
1218    RETVALUE(ret);
1219 } /* KwMiLkwL2MeasReq */
1220
1221 /**
1222 @brief 
1223 This function processes L2 Measurement stop request received from the layer manager.
1224 After receving this request, RLC stops L2 Measurement
1225  *  @param[in] pst      post structure
1226  *  @param[in] measType meas Type 
1227  *  @return S16
1228  *      -# Success : ROK
1229  *      -# Failure : RFAILED
1230 */
1231
1232 #ifdef ANSI
1233 PUBLIC S16 KwMiLkwL2MeasStopReq
1234 (
1235 Pst            *pst,
1236 U8             measType
1237 )
1238 #else
1239 PUBLIC S16 KwMiLkwL2MeasStopReq (pst, measType)
1240 Pst            *pst;
1241 U8             measType;
1242 #endif
1243 {
1244    S16 ret = ROK;
1245    KwL2MeasEvtCb *measEvtCb = NULLP;
1246
1247    U16            cntr;
1248    U8             status = ROK;
1249    KwCb     *tKwCb;
1250
1251    TRC3(KwMiLkwL2MeasStopReq);
1252
1253    tKwCb =  KW_GET_KWCB(pst->dstInst);
1254
1255    /* reset the counter values for the measurement that is stopped */
1256    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1257    {
1258       measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1259       if(measEvtCb->measCb.measType & measType)
1260       {
1261          kwUtlResetUlL2MeasInKwRb(tKwCb, &measEvtCb->measCb, measType);
1262
1263       }
1264    }   
1265
1266    /* for UL IP throughput meas disable for all QCIs */
1267    if(measType & LKW_L2MEAS_UL_IP)
1268    {
1269       for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1270       {
1271          tKwCb->u.ulCb->kwL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
1272       }
1273    }
1274    
1275    if((measType & LKW_L2MEAS_DL_IP) || (measType & LKW_L2MEAS_DL_DISC)
1276        || (measType & LKW_L2MEAS_DL_DELAY))
1277    {
1278       /*Redirect the request to DL task */
1279       KwUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
1280       /*RETVALUE(ROK);*/
1281    }
1282    /*cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
1283
1284    status = LCM_PRIM_OK; 
1285    KwMiLkwL2MeasStopCfm(&tKwCb->genCfg.lmPst, measType,status); 
1286    
1287    RETVALUE(ret);
1288 }
1289 /**
1290 @brief 
1291 This function processes L2 Measurement Send request received from the layer manager.
1292 After receving this request, RLC sends L2 Measurement
1293  *  @param[in] pst      post structure
1294  *  @param[in] measType meas Type 
1295  *  @return S16
1296  *      -# Success : ROK
1297  *      -# Failure : RFAILED
1298 */
1299
1300 #ifdef ANSI
1301 PUBLIC S16 KwMiLkwL2MeasSendReq
1302 (
1303 Pst            *pst,
1304 U8             measType
1305 )
1306 #else
1307 PUBLIC S16 KwMiLkwL2MeasSendReq (pst, measType)
1308 Pst            *pst;
1309 U8             measType;
1310 #endif
1311 {
1312    /*S16 ret = ROK;*/
1313    KwL2MeasEvtCb *measEvtCb = NULLP;
1314    U16            cntr;
1315    KwCb     *tKwCb;
1316    TRC3(KwMiLkwL2MeasSendReq);
1317
1318    tKwCb =  KW_GET_KWCB(pst->dstInst);
1319    
1320    /* In case of addition of any new measType here ,appropriate handling 
1321     * has to be done in RLC DL (kwUtlSndDlL2MeasCfm)*/
1322    if(measType & 
1323       (LKW_L2MEAS_DL_DISC | LKW_L2MEAS_DL_DELAY 
1324        | LKW_L2MEAS_UU_LOSS| LKW_L2MEAS_DL_IP))
1325    {
1326       /*Redirect the request to DL task */
1327       KwUlUdxL2MeasSendReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
1328       /* L2 MEAS AGHOSH */
1329       /*RETVALUE(ROK);*/
1330    }
1331
1332    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1333    {
1334       measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1335       /* L2 MEAS AGHOSH */
1336       if(measEvtCb->measCb.measType & measType)
1337       {
1338          kwUtlHdlL2TmrExp(tKwCb, measEvtCb);
1339       }
1340    }
1341
1342    RETVALUE(ROK);
1343 }
1344 #endif /* LTE_L2_MEAS */
1345
1346 /**
1347  * @brief
1348  *    This function configures the RLC data sap
1349  *
1350  * @param[in]  gCb   RLC Instance Control Block
1351  * @param[in]  cfg   RLC LM Sap configuration structure
1352  *
1353  * @return  S16
1354  *    -# LCM_REASON_NOT_APPL  (SUCCESS)
1355  *    -# LCM_REASON_INVALID_SAP 
1356  *    -# LCM_REASON_MEM_NOAVAIL 
1357  *    -# LCM_REASON_RECONFIG_FAIL 
1358  */
1359 #ifdef ANSI
1360 PRIVATE S16 kwLmmCfgKwuSap
1361 (
1362 KwCb       *gCb,
1363 KwSapCfg   *cfg                
1364 )
1365 #else
1366 PRIVATE S16 kwLmmCfgKwuSap(gCb,cfg)
1367 KwCb       *gCb;
1368 KwSapCfg   *cfg;               
1369 #endif
1370 {
1371    KwKwuSapCb   *kwuSapCb;
1372    TRC2(kwLmmCfgKwuSap)
1373
1374 #if (ERRCLASS & ERRCLS_INT_PAR)
1375    /* Validate the protocol parameters */
1376    if((cfg->sapId >= (S16)gCb->genCfg.maxKwuSaps) || (cfg->sapId < 0))
1377    {
1378       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1379    }
1380 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1381
1382    kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1383               (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + cfg->sapId):
1384               (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + cfg->sapId);
1385
1386 #if (ERRCLASS & ERRCLS_INT_PAR)
1387    /* Check for reconfiguration */
1388    if (kwuSapCb->state != KW_SAP_NOT_CFG)
1389    {
1390       RLOG2(L_ERROR,"RLC Mode [%d] : Invalid kwuSap State [%d]",
1391             gCb->genCfg.rlcMode, kwuSapCb->state);
1392       /* reconfiguration not allowed */
1393       RETVALUE(LCM_REASON_RECONFIG_FAIL);
1394    }
1395 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1396
1397    /* Fill the parameters */
1398    KW_FILL_SAP_HELPER(kwuSapCb, cfg, gCb);
1399
1400    RETVALUE(LCM_REASON_NOT_APPL);
1401
1402
1403 /**
1404  * @brief
1405  *    This function configures the RLC control sap
1406  *
1407  * @param[in]  gCb   RLC Instance Control Block
1408  * @param[in]  cfg   RLC LM Sap configuration structure
1409  * 
1410  * @return  S16
1411  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1412  *    -# LCM_REASON_INVALID_SAP
1413  *    -# LCM_REASON_INVALID_SAP 
1414  *    -# LCM_REASON_RECONFIG_FAIL 
1415  */
1416 #ifdef ANSI
1417 PRIVATE S16 kwLmmCfgCkwSap 
1418 (
1419 KwCb       *gCb,
1420 KwSapCfg   *cfg             
1421 )
1422 #else
1423 PRIVATE S16 kwLmmCfgCkwSap(gCb,cfg)
1424 KwCb       *gCb;
1425 KwSapCfg   *cfg;             
1426 #endif
1427 {
1428    KwCkwSapCb  *ckwSap;
1429    
1430    TRC2(kwLmmCfgCkwSap)
1431
1432 #if (ERRCLASS & ERRCLS_INT_PAR)
1433    /* Validate config parameters */
1434    if ((cfg->sapId >= KW_MAX_CKWSAPS) || (cfg->sapId < 0) )
1435    {
1436       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1437    }
1438
1439    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1440    {
1441       /* Get Sap control block */
1442       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1443    }
1444 #endif
1445
1446    ckwSap = &(gCb->u.ulCb->ckwSap);
1447
1448 #if (ERRCLASS & ERRCLS_INT_PAR)
1449    /* Check for reconfiguration */
1450    if(ckwSap->state  != KW_SAP_NOT_CFG)
1451    {
1452       RLOG1(L_ERROR,"Invalid kwuSap State [%d]",ckwSap->state);
1453       RETVALUE(LCM_REASON_RECONFIG_FAIL);
1454    }
1455 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1456    
1457    /* Fill the parameters */
1458    KW_FILL_SAP_HELPER(ckwSap, cfg, gCb);
1459
1460    RETVALUE(LCM_REASON_NOT_APPL);
1461
1462
1463 /**
1464  * @brief
1465  *    This function configures the UDX sap
1466  *
1467  * @param[in]  gCb   RLC Instance Control Block
1468  * @param[in]  cfg   RLC LM Sap configuration structure
1469  *
1470  * @return  S16
1471  *    -# LCM_REASON_NOT_APPL   (SUCCESS)
1472  *    -# LCM_REASON_INVALID_SAP
1473  *    -# LCM_REASON_INVALID_SAP
1474  *    -# LCM_REASON_RECONFIG_FAIL
1475  */
1476 #ifdef ANSI
1477 PRIVATE S16 kwLmmCfgUdxSap 
1478 (
1479 KwCb       *gCb,
1480 KwSapCfg   *cfg         
1481 )
1482 #else
1483 PRIVATE S16 kwLmmCfgUdxSap(gCb,cfg)
1484 KwCb       *gCb;
1485 KwSapCfg   *cfg;       
1486 #endif
1487 {
1488    KwUdxDlSapCb   *udxDlSap;
1489    KwUdxUlSapCb   *udxUlSap;
1490
1491    TRC2(kwLmmCfgUdxSap);
1492    
1493 #if (ERRCLASS & ERRCLS_INT_PAR)
1494    /* Validate the protocol parameters */
1495    if((cfg->sapId >= KW_MAX_UDXSAPS) || (cfg->sapId < 0))
1496    {
1497       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1498    }
1499 #endif
1500    /* Get Sap control block */
1501    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1502    {
1503       udxDlSap = (gCb->u.dlCb->udxDlSap + cfg->sapId);
1504 #if (ERRCLASS & ERRCLS_INT_PAR)
1505       /* Check for reconfiguration */
1506       if(udxDlSap->state != KW_SAP_NOT_CFG)
1507       {
1508          RLOG1(L_ERROR,"Invalid udxDlSap State [%d]",udxDlSap->state);
1509          RETVALUE(LCM_REASON_RECONFIG_FAIL);
1510       }
1511 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1512
1513       /* Fill the parameters */
1514       KW_FILL_SAP_HELPER(udxDlSap, cfg, gCb);
1515    }
1516    else
1517    {
1518       udxUlSap = (gCb->u.ulCb->udxUlSap + cfg->sapId);
1519
1520 #if (ERRCLASS & ERRCLS_INT_PAR)
1521    /* Check for reconfiguration */
1522       if(udxUlSap->state != KW_SAP_NOT_CFG)
1523       {
1524          RLOG1(L_ERROR,"Invalid udxUlSap State [%d]", udxUlSap->state);
1525          RETVALUE(LCM_REASON_RECONFIG_FAIL);
1526       }
1527 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1528
1529       /* Fill the parameters */
1530       KW_FILL_SAP_HELPER(udxUlSap, cfg, gCb);
1531
1532       udxUlSap->bndTmrInt = cfg->bndTmrIntvl;
1533       udxUlSap->retryCnt = 0;
1534       cmInitTimers(&(udxUlSap->bndTmr), 1);
1535    }
1536
1537    RETVALUE(LCM_REASON_NOT_APPL);
1538
1539
1540 /**
1541  * @brief
1542  *    This function configures the RGU sap
1543  *
1544  * @param[in]  gCb   RLC Instance Control Block
1545  * @param[in]  cfg   RLC LM Sap configuration structure
1546  * @return  S16
1547  *    -# LCM_REASON_NOT_APPL    (SUCCESS)
1548  *    -# LCM_REASON_INVALID_SAP
1549  *    -# LCM_REASON_INVALID_SAP
1550  *    -# LCM_REASON_RECONFIG_FAIL
1551  */
1552 #ifdef ANSI
1553 PRIVATE S16 kwLmmCfgRguSap 
1554 (
1555 KwCb       *gCb,
1556 KwSapCfg   *cfg               
1557 )
1558 #else
1559 PRIVATE S16 kwLmmCfgRguSap(gCb,cfg)
1560 KwCb       *gCb;
1561 KwSapCfg   *cfg;             
1562 #endif
1563 {
1564    KwRguSapCb   *rguSap;
1565
1566    TRC2(kwLmmCfgRguSap);
1567    
1568 #if (ERRCLASS & ERRCLS_INT_PAR)
1569    /* Validate the protocol parameters */
1570    if((cfg->sapId >= gCb->genCfg.maxRguSaps) || \
1571       (cfg->sapId < 0))
1572    {
1573       KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
1574                "kwLmmCfgRguSap: Invalid RGU sapId\n");
1575       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1576    }
1577 #endif
1578
1579    rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1580             &(gCb->u.dlCb->rguDlSap[cfg->sapId]): &(gCb->u.ulCb->rguUlSap[cfg->sapId]);
1581
1582 #if (ERRCLASS & ERRCLS_INT_PAR)
1583    /* Check for reconfiguration */
1584    if(rguSap->state != KW_SAP_NOT_CFG)
1585    {
1586       RLOG2(L_ERROR,"RLC Mode [%d]: Invalid rguSap State [%d]",
1587             gCb->genCfg.rlcMode, rguSap->state);
1588       RETVALUE(LCM_REASON_RECONFIG_FAIL);
1589    }
1590 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1591
1592    /* Fill the parameters */
1593    KW_FILL_SAP_HELPER(rguSap, cfg, gCb);
1594    rguSap->suId = cfg->sapId;
1595    rguSap->bndTmrInt = cfg->bndTmrIntvl;
1596    rguSap->retryCnt = 0;
1597    rguSap->state = KW_SAP_CFG;
1598
1599    cmInitTimers(&(rguSap->bndTmr), 1);
1600
1601    RETVALUE(LCM_REASON_NOT_APPL);
1602
1603
1604 /**
1605  * @brief
1606  *    Validates the RLC general control parameters 
1607  *
1608  * @param[in] cntrl   RLC LM structure 
1609  * 
1610  * @return  S16
1611  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1612  *    -# LCM_REASON_INVALID_SUBACTION
1613  *    -# LCM_REASON_INVALID_ACTION
1614  */
1615 #ifdef ANSI
1616 PRIVATE S16 kwLmmValidateGenCntrl
1617 (
1618 KwMngmt   *cntrl                 
1619 )
1620 #else
1621 PRIVATE S16 kwLmmValidateGenCntrl(cntrl)
1622 KwMngmt   *cntrl;                
1623 #endif
1624 {
1625    S16   reason;    /* reason for failure */
1626    U8    sAction;   /* subaction field */
1627
1628    TRC2(kwLmmValidateGenCntrl);
1629
1630    reason = LCM_REASON_NOT_APPL;
1631    sAction = cntrl->t.cntrl.subAction;
1632
1633    switch (cntrl->t.cntrl.action)
1634    {
1635       case AENA:
1636       case ADISIMM:
1637          if ((sAction != SAUSTA) && 
1638              (sAction != SADBG) && 
1639              (sAction != SATRC))
1640          {
1641             reason = LCM_REASON_INVALID_SUBACTION;
1642          }
1643          break;
1644       case ASHUTDOWN:
1645          break;
1646       default:
1647          reason = LCM_REASON_INVALID_ACTION;
1648          break;
1649    }
1650    
1651    RETVALUE(reason);
1652
1653
1654 /**
1655  * @brief
1656  *    it deregisters the timers and deregisters the kwuSap Control blocks 
1657  *
1658  * @param[in]  gCb   RLC Instance Control Block
1659  * 
1660  * @return  Void
1661  */
1662 #ifdef ANSI
1663 PRIVATE Void kwLmmCleanGblRsrcs
1664 (
1665 KwCb   *gCb
1666 )
1667 #else
1668 PRIVATE Void kwLmmCleanGblRsrcs(gCb)
1669 KwCb   *gCb;
1670 #endif
1671 {
1672    Size   kwSapSize;
1673    Size   kwUdxSapSize;
1674  
1675    TRC2(kwLmmCleanGblRsrcs)   
1676  
1677    if (gCb->init.cfgDone)
1678    {
1679       /* Deregister the timers */
1680 /*Pradeep: changing the SDeregTmrMt() to SDeregTmr*/
1681       (Void) SDeregTmrMt(gCb->init.ent, gCb->init.inst,
1682                         (S16)gCb->genCfg.timeRes, kwActvTmr);
1683       /*(Void) SDeregTmr(gCb->init.ent, gCb->init.inst,
1684                         (S16)gCb->genCfg.timeRes, kwActvTmr);*/
1685
1686       kwSapSize = (Size)(gCb->genCfg.maxKwuSaps * sizeof(KwKwuSapCb));
1687
1688       if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1689       {
1690          kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxDlSapCb));
1691          if (gCb->u.dlCb)
1692          {
1693             gCb->u.dlCb->shutdownReceived = TRUE;
1694             kwUtlFreeDlMemory(gCb); 
1695             if (gCb->u.dlCb->kwuDlSap != NULLP)
1696             {
1697                KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
1698             }
1699             
1700             if(gCb->u.dlCb->udxDlSap != NULLP)
1701             {
1702                KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
1703             }
1704
1705             if(gCb->u.dlCb->rguDlSap != NULLP)
1706             {
1707                KW_FREE(gCb,gCb->u.dlCb->rguDlSap, gCb->genCfg.maxRguSaps);
1708                gCb->genCfg.maxRguSaps = 0;
1709             }
1710              if (gCb->u.dlCb->shutdownReceived) 
1711             {
1712                if (gCb->u.dlCb->selfPstMBuf != NULL)
1713                {
1714                   SPutMsg(gCb->u.dlCb->selfPstMBuf);
1715                }
1716                KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
1717             }
1718          }
1719          
1720       }
1721       else
1722       {
1723          kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxUlSapCb));
1724          if (gCb->u.ulCb)
1725          {
1726             if (gCb->u.ulCb->kwuUlSap != NULLP)
1727             {
1728                KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
1729             }
1730             
1731             if(gCb->u.ulCb->udxUlSap != NULLP)
1732             {
1733                KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
1734             }
1735          
1736             if(gCb->u.ulCb->rguUlSap != NULLP)
1737             {
1738                KW_FREE(gCb,gCb->u.ulCb->rguUlSap, gCb->genCfg.maxRguSaps);
1739                gCb->genCfg.maxRguSaps = 0;
1740             }
1741          
1742             KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
1743          }
1744       }
1745
1746       gCb->init.cfgDone = FALSE;
1747       gCb->init.acnt = FALSE;
1748       gCb->init.trc = FALSE;
1749
1750       gCb->init.usta = FALSE;
1751    }
1752
1753    RETVOID;
1754 }
1755
1756 /**
1757  * @brief
1758  *    Delete all SAPs and Control Blocks
1759  *
1760  * @details
1761  *    Shutdown of RLC happens at modules level, tm, um and am modules will be
1762  *    shutdown using utility functin and dbm shutdown will clean up the SAPs,
1763  *    control blocks and lists. 
1764  *
1765  * @params[in] gCb   RLC instance control block   
1766  *
1767  * @return  S16
1768  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1769  *    -# LCM_REASON_HASHING_FAILED 
1770  */
1771 #ifdef ANSI
1772 PRIVATE S16 kwLmmShutdown
1773 (
1774 KwCb   *gCb
1775 )
1776 #else
1777 PRIVATE S16 kwLmmShutdown(gCb)
1778 KwCb   *gCb;
1779 #endif
1780 {
1781    KwRguSapCb   *rguSap;
1782    U32          idx;
1783
1784    TRC2(kwLmmShutdown)
1785
1786    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1787    {
1788       for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1789       {
1790          rguSap = &(gCb->u.dlCb->rguDlSap[idx]);
1791          if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
1792          {
1793             KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1794          }
1795       }
1796    }
1797    else
1798    {
1799       for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1800       {
1801          rguSap = &(gCb->u.ulCb->rguUlSap[idx]); 
1802          if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
1803          {
1804             KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1805          }
1806       }
1807    }
1808    
1809    if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1810    {
1811       kwDbmDlShutdown(gCb); 
1812    }
1813    else
1814    {
1815       kwDbmUlShutdown(gCb);
1816    }
1817
1818    kwLmmCleanGblRsrcs(gCb);
1819
1820    KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
1821
1822    RETVALUE(LCM_REASON_NOT_APPL);
1823
1824
1825 /**
1826  * @brief
1827  *    Function processes the general control request 
1828  *
1829  * @param[in] gCb     RLC instance control block
1830  * @param[in] cntrl   RLC LM structure
1831  *
1832  * @return  S16
1833  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1834  *    -# LCM_REASON_INVALID_SUBACTION
1835  *    -# LCM_REASON_INVALID_ACTION
1836  */
1837 #ifdef ANSI
1838 PRIVATE S16 kwLmmGenCntrl
1839 (
1840 KwCb *gCb,
1841 KwMngmt *cntrl       
1842 )
1843 #else
1844 PRIVATE S16 kwLmmGenCntrl(gCb,cntrl)
1845 KwCb    *gCb;
1846 KwMngmt *cntrl;     
1847 #endif
1848 {
1849    KwTrcCntrl *trcCntrl; /* trace */
1850 #ifdef DEBUGP
1851    KwDbgCntrl *dbgCntrl; /* debug */
1852 #endif /* DEBUGP */
1853    S16   reason;         /* reason for failure */
1854    
1855    TRC2(kwLmmGenCntrl);
1856
1857    /* Validate control parameters */
1858    reason = kwLmmValidateGenCntrl (cntrl);
1859
1860    if (reason != LCM_REASON_NOT_APPL)
1861    {
1862       RETVALUE(reason);
1863    }
1864
1865    switch(cntrl->t.cntrl.action)
1866    {
1867       case AENA:
1868       {
1869          switch(cntrl->t.cntrl.subAction)
1870          {
1871             case SAUSTA:
1872             {
1873                KW_SET_USTA_FLAG(gCb, TRUE);
1874                break;
1875             }
1876             case SADBG:
1877             {
1878 #ifdef DEBUGP
1879                dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1880                KW_GET_DBG_MASK(gCb) |= dbgCntrl->dbgMask;
1881 #endif /* DEBUGP */
1882                break;
1883             }
1884             case SATRC:
1885             {
1886                trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1887                gCb->init.trc = TRUE;
1888                gCb->trcLen = trcCntrl->trcLen;
1889                (gCb->trcMask) |= trcCntrl->trcMask;
1890                 break;
1891             }
1892          }
1893          break;
1894       }
1895       case ADISIMM:
1896       {
1897          switch(cntrl->t.cntrl.subAction)
1898          {
1899             case SAUSTA:
1900             {
1901                gCb->init.usta = FALSE;
1902             }
1903             break;
1904             case SADBG:
1905             {
1906 #ifdef DEBUGP
1907                dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1908                KW_GET_DBG_MASK(gCb) &= ~(dbgCntrl->dbgMask);
1909 #endif /* DEBUGP */
1910             }
1911             break;
1912             case SATRC:
1913             {
1914                trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1915                gCb->init.trc = FALSE;
1916                gCb->trcMask &= ~(trcCntrl->trcMask);
1917             }
1918             break;
1919          }
1920          break;
1921       }
1922       case ASHUTDOWN:
1923       {
1924          reason = kwLmmShutdown(gCb);
1925          break;
1926       }
1927    }
1928    RETVALUE(reason);
1929
1930
1931 /**
1932  * @brief
1933  *    Bind/Unbind RLC UDX sap 
1934  *
1935  * @param[in]  gCb     RLC Instance Control Block
1936  * @param[in]  cntrl   RLC LM structure
1937  * 
1938  * @return  S16
1939  *    -# LCM_REASON_NOT_/PPL (SUCCESS)    
1940  *    -# LCM_REASON_INVALID_SAP 
1941  *    -# LCM_REASON_INVALID_STATE
1942  *    -# LCM_REASON_INVALID_ACTION 
1943  */
1944 #ifdef ANSI
1945 PRIVATE S16 kwLmmUdxSapCntrl
1946 (
1947 KwCb      *gCb,
1948 KwMngmt   *cntrl               
1949 )
1950 #else
1951 PRIVATE S16 kwLmmUdxSapCntrl(gCb,cntrl)
1952 KwCb      *gCb;
1953 KwMngmt   *cntrl;               
1954 #endif
1955 {
1956    TRC2(kwLmmUdxSapCntrl)
1957
1958 #if (ERRCLASS & ERRCLS_INT_PAR)
1959    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1960    {
1961       RETVALUE(LCM_REASON_INVALID_SAP);
1962    }
1963    /* validate SuId */
1964    if((cntrl->t.cntrl.s.sapCntrl.suId < 0) || 
1965       (cntrl->t.cntrl.s.sapCntrl.suId >= KW_MAX_UDXSAPS))
1966    {
1967       RETVALUE(LCM_REASON_INVALID_SAP);
1968    }
1969 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1970
1971 #define UDX_SAP  gCb->u.ulCb->udxUlSap[cntrl->t.cntrl.s.sapCntrl.suId]
1972 #if (ERRCLASS & ERRCLS_INT_PAR)
1973    /* validate SAP */
1974    if(UDX_SAP.state == KW_SAP_NOT_CFG)
1975    {
1976       RLOG0(L_ERROR,"udxUlSap not configured yet");
1977       RETVALUE(LCM_REASON_INVALID_STATE);
1978    }
1979 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1980
1981    switch(cntrl->t.cntrl.action)
1982    {
1983       case ABND:
1984       {
1985          if(UDX_SAP.state != KW_SAP_BND)
1986          {
1987             /* start timer to wait for bind confirm */
1988             kwStartTmr(gCb,(PTR)(&UDX_SAP), KW_EVT_WAIT_BNDCFM);
1989             UDX_SAP.state = KW_SAP_BINDING;
1990             KwUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
1991          }
1992          else
1993          {
1994             /* control request received for an already bound SAP */
1995             RETVALUE(LCM_REASON_INVALID_STATE);
1996          }
1997       }
1998       break;
1999       case AUBND:
2000       {
2001          /* make the state of UDXSAP configured but not bound */
2002          UDX_SAP.state = KW_SAP_CFG;
2003          KwUlUdxUbndReq(&(UDX_SAP.pst), UDX_SAP.spId, 0);
2004       }
2005       break;
2006       default:
2007          RETVALUE(LCM_REASON_INVALID_ACTION);
2008          break;
2009    } /* end of switch */
2010 #undef UDX_SAP
2011    RETVALUE(LCM_REASON_NOT_APPL);
2012
2013
2014 /**
2015  * @brief
2016  *    Bind/Unbind RLC lower sap 
2017  *
2018  * @param[in]  gCb     RLC Instance Control Block
2019  * @param[in]  cntrl   RLC LM structure
2020  * @return  S16
2021  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2022  *    -# LCM_REASON_INVALID_SAP 
2023  *    -# LCM_REASON_INVALID_STATE
2024  *    -# LCM_REASON_INVALID_ACTION 
2025  */
2026 #ifdef ANSI
2027 PRIVATE S16 kwLmmLSapCntrl
2028 (
2029 KwCb      *gCb,
2030 KwMngmt   *cntrl 
2031 )
2032 #else
2033 PRIVATE S16 kwLmmLSapCntrl(gCb,cntrl)
2034 KwCb      *gCb;
2035 KwMngmt   *cntrl; 
2036 #endif
2037 {
2038    KwRguSapCb   *rguSap;   /* rgu sap pointer */
2039
2040    TRC2(kwLmmLSapCntrl)
2041
2042 #if (ERRCLASS & ERRCLS_INT_PAR)
2043    /* validate SuId */
2044    if((cntrl->t.cntrl.s.sapCntrl.suId < 0) || 
2045       (cntrl->t.cntrl.s.sapCntrl.suId >= gCb->genCfg.maxRguSaps))
2046    {
2047       KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
2048                "kwLmmLSapCntrl: Invalid RGU suId\n");
2049       RETVALUE(LCM_REASON_INVALID_SAP);
2050    }
2051 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2052    rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
2053             &(gCb->u.dlCb->rguDlSap[cntrl->t.cntrl.s.sapCntrl.suId]): \
2054             &(gCb->u.ulCb->rguUlSap[cntrl->t.cntrl.s.sapCntrl.suId]);
2055
2056 #if (ERRCLASS & ERRCLS_INT_PAR)
2057    /* validate SAP */
2058    if(rguSap->state == KW_SAP_NOT_CFG)
2059    {
2060       RLOG1(L_ERROR,"RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
2061       RETVALUE(LCM_REASON_INVALID_STATE);
2062    }
2063 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2064
2065    switch(cntrl->t.cntrl.action)
2066    {
2067       case ABND:
2068       {
2069          if(rguSap->state != KW_SAP_BND)
2070          {
2071             /* start timer to wait for bind confirm */
2072             kwStartTmr(gCb,(PTR)(rguSap), KW_EVT_WAIT_BNDCFM);
2073             rguSap->state = KW_SAP_BINDING;
2074             rguSap->spId = cntrl->t.cntrl.s.sapCntrl.spId;
2075             rguSap->suId = cntrl->t.cntrl.s.sapCntrl.suId;
2076             KwLiRguBndReq(&(rguSap->pst), rguSap->suId, rguSap->spId);
2077          }
2078          else
2079          {
2080             /* control request received for an already bound SAP */
2081             RETVALUE(LCM_REASON_INVALID_STATE);
2082          }
2083       }
2084       break;
2085       case AUBND:
2086       {
2087          /* make the state of RGUSAP is configure but not bound */
2088          rguSap->state = KW_SAP_CFG;
2089          KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
2090       }
2091       break;
2092       default:
2093          RETVALUE(LCM_REASON_INVALID_ACTION);
2094          break;
2095    } /* end of switch */
2096
2097    RETVALUE(LCM_REASON_NOT_APPL);
2098
2099
2100 /**
2101  * @brief
2102  *    Function gather the general KWU SAP status 
2103  *
2104  * @param[in] gCb   RLC Instance Control Block
2105  * @param[in] sta   LM KWU Sap Status structure 
2106  * 
2107  * @return  S16
2108  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2109  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2110  */
2111 #ifdef ANSI
2112 PRIVATE S16 kwLmmGetKwuSapSta 
2113 (
2114 KwCb          *gCb,
2115 KwKwuSapSta   *sta         
2116 )
2117 #else
2118 PRIVATE S16 kwLmmGetKwuSapSta(gCb,sta)
2119 KwCb          *gCb;
2120 KwKwuSapSta   *sta;         
2121 #endif
2122 {
2123    KwKwuSapCb   *kwSapCb;
2124    
2125    TRC2(kwLmmGetKwuSapSta);
2126
2127 #if (ERRCLASS & ERRCLS_INT_PAR)
2128    /* Validate the protocol parameters */
2129    if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
2130        (sta->spId < 0))
2131    {
2132       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2133    }
2134 #endif
2135
2136    /* Get Sap control block */
2137    kwSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)? 
2138              (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + sta->spId):
2139              (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + sta->spId);
2140
2141    sta->state = kwSapCb->state;
2142
2143    RETVALUE(LCM_REASON_NOT_APPL);
2144
2145
2146 /**
2147  * @brief
2148  *    Function gather the general RGU SAP status
2149  *
2150  * @param[in]  gCb   RLC Instance Control Block
2151  * @param[in]  sta   LM RGU Sap Status structure
2152  * @return  S16
2153  *    -# LCM_REASON_NOT_APPL       (SUCCESS) 
2154  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE) 
2155  */
2156 #ifdef ANSI
2157 PRIVATE S16 kwLmmGetRguSapSta 
2158 (
2159 KwCb          *gCb,
2160 KwRguSapSta   *sta         
2161 )
2162 #else
2163 PRIVATE S16 kwLmmGetRguSapSta(gCb,sta)
2164 KwCb          *gCb;
2165 KwRguSapSta   *sta;       
2166 #endif
2167 {
2168    TRC2(kwLmmGetRguSapSta);
2169
2170 #if (ERRCLASS & ERRCLS_INT_PAR)
2171    /* Validate the protocol parameters */
2172    if((sta->suId >= KW_MAX_RGUSAPS) || (sta->suId < 0))
2173    {
2174       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2175    }
2176 #endif
2177
2178    sta->state = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ? 
2179                  gCb->u.dlCb->rguDlSap[sta->suId].state : 
2180                  gCb->u.ulCb->rguUlSap[sta->suId].state ;
2181
2182    RETVALUE(LCM_REASON_NOT_APPL);
2183
2184
2185 /**
2186  * @brief
2187  *    Function gather the general CKW SAP status
2188  *
2189  * @param[in]  gCb   RLC Instance Control Block
2190  * @param[in]  sta   LM CKW Sap Status structure
2191  * @return  S16
2192  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2193  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2194  */
2195 #ifdef ANSI
2196 PRIVATE S16 kwLmmGetCkwCntSapSta
2197 (
2198 KwCb             *gCb,
2199 KwCkwCntSapSta   *sta     
2200 )
2201 #else
2202 PRIVATE S16 kwLmmGetCkwCntSapSta(gCb,sta)
2203 kwCb             *gCb,
2204 KwCkwCntSapSta   *sta;   
2205 #endif
2206 {
2207    TRC2(kwLmmGetCkwCntSapSta);
2208
2209 #if (ERRCLASS & ERRCLS_INT_PAR)
2210    /* Validate config parameters */
2211    if ((sta->spId >= KW_MAX_CKWSAPS ) ||
2212        (sta->spId < 0 ) ||
2213        (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL))
2214    {
2215       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2216    }
2217 #endif
2218    sta->state =  gCb->u.ulCb->ckwSap.state;
2219
2220    RETVALUE(LCM_REASON_NOT_APPL);
2221
2222
2223
2224 /**
2225  * @brief
2226  *    Gather the general statistics 
2227  *
2228  * @param[in]  gCb      RLC Instance Control Block
2229  * @param[in]  sts      LM general statistics structure
2230  * @param[in]  action   action
2231  * @return  S16
2232  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2233  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2234  */
2235 #ifdef ANSI
2236 PRIVATE S16 kwLmmGetGenSts
2237 (
2238 KwCb       *gCb,
2239 KwGenSts   *sts,       
2240 Action     action         
2241 )
2242 #else
2243 PRIVATE S16 kwLmmGetGenSts(gCb,sts, action)
2244 KwCb       *gCb;
2245 KwGenSts   *sts;          
2246 Action     action;         
2247 #endif
2248 {
2249    TRC2(kwLmmGetGenSts);
2250
2251 #if (ERRCLASS & ERRCLS_INT_PAR)
2252    /* Validate protocol parameters */
2253    if ((action != LKW_ZEROSTS) && (action != LKW_NOZEROSTS))
2254    {
2255       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2256    }
2257 #endif
2258
2259    *sts = gCb->genSts;
2260    
2261    if(action == LKW_ZEROSTS)
2262    {
2263       KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
2264    }
2265
2266    RETVALUE(LCM_REASON_NOT_APPL);
2267
2268
2269 /**
2270  * @brief
2271  *    Gather the SAP statistics
2272  *
2273  * @param[in]  gCb      RLC Instance Control Block
2274  * @param[in]  sts      LM general statistics structure
2275  * @param[in]  elmnt    element 
2276  * @param[in]  action   action 
2277  * 
2278  * @return  S16
2279  *    -# LCM_REASON_NOT_APPL (SUCCESS)
2280  *    -# LCM_REASON_INVALID_PAR_VAL (FAIL)
2281  */
2282 #ifdef ANSI
2283 PRIVATE S16 kwLmmGetSapSts
2284 (
2285 KwCb      *gCb,
2286 KwMngmt   *sts,               
2287 Elmnt     elmnt,               
2288 Action    action             
2289 )
2290 #else
2291 PRIVATE S16 kwLmmGetSapSts(sts, elmnt, action)
2292 KwCb      *gCb;
2293 KwMngmt   *sts;            
2294 Elmnt     elmnt;            
2295 Action    action;         
2296 #endif
2297 {
2298    TRC2(kwLmmGetSapSts);
2299
2300    /* Validate protocol parameters */
2301    if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
2302    {
2303       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2304    }
2305    switch(elmnt)
2306    {
2307       case STKWUSAP:
2308       {
2309          KwKwuSapSts  *kwuSap; 
2310          KwKwuSapCb   *kwuSapCb;    
2311          kwuSap = &sts->t.sts.s.kwuSap;
2312
2313          /* Get Sap control block */
2314          /* kw005.201, modified the element of kwuSap from suId to spId */
2315          kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)? 
2316               (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + kwuSap->spId):
2317               (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + kwuSap->spId);
2318
2319
2320          *kwuSap = kwuSapCb->sts;
2321
2322          if (action == LKW_ZEROSTS)
2323          {
2324             KW_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
2325          }
2326          break;
2327       }
2328       /* kw005.201 removed RGUSAP statistics support */
2329       case STCKWSAP:
2330       {
2331          KwCkwCntSts  *ckwSap;  
2332          ckwSap = &sts->t.sts.s.ckwSap;
2333          if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) 
2334          {
2335             RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2336          }
2337
2338          ckwSap->statMsgs = gCb->u.ulCb->ckwSap.sts.statMsgs;
2339
2340          if (action == LKW_ZEROSTS)
2341          {
2342             KW_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (KwCkwCntSts));
2343          }
2344          break;
2345       }
2346       default:
2347          RETVALUE(LCM_REASON_INVALID_ELMNT);
2348    }
2349
2350    SGetDateTime(&sts->t.sts.dt);
2351
2352    RETVALUE(LCM_REASON_NOT_APPL);
2353
2354
2355 /**
2356  * @brief
2357  *    This function sends Unsolicited Status Indication to the Layer Management
2358  *    Entity. 
2359  *
2360  * @param[in]  gCb        RLC Instance Control Block
2361  * @param[in]  category   Category 
2362  * @param[in]  event      event
2363  * @param[in]  cause      cause
2364  * @param[in]  UeId       ueId 
2365  * @param[in]  Qci        qci 
2366  * 
2367  * @return  Void
2368  */
2369 #ifdef LTE_L2_MEAS
2370 #ifdef ANSI
2371 PUBLIC Void kwLmmSendAlarm
2372 (
2373 KwCb   *gCb,
2374 U16    category,  
2375 U16    event,    
2376 U16    cause,   
2377 SuId   suId,   
2378 U32    ueId,  
2379 U8     qci   
2380 )
2381 #else
2382 PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId, qci)
2383 KwCb   *gCb;
2384 U16    category; 
2385 U16    event;   
2386 U16    cause;  
2387 SuId   suId;  
2388 U32    ueId; 
2389 U8     qci;    
2390 #endif
2391 #else /* LTE_L2_MEAS */
2392 #ifdef ANSI
2393 PUBLIC Void kwLmmSendAlarm
2394 (
2395 KwCb   *gCb,
2396 U16    category, 
2397 U16    event,   
2398 U16    cause,  
2399 SuId   suId,  
2400 U32    ueId  
2401 )
2402 #else
2403 PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId)
2404 KwCb   *gCb;
2405 U16    category; 
2406 U16    event;   
2407 U16    cause;  
2408 SuId   suId;  
2409 U32    ueId; 
2410 #endif
2411 #endif /* LTE_L2_MEAS */
2412 {
2413    KwMngmt   usta;   /* Rlc Management Structure */
2414
2415    TRC2(kwLmmSendAlarm);
2416
2417    if(gCb->init.usta == FALSE)
2418    {
2419       RETVOID;
2420    }
2421
2422    usta.hdr.elmId.elmnt = STGEN;
2423    usta.hdr.entId.ent = gCb->init.ent;
2424    usta.hdr.entId.inst = gCb->init.inst;
2425
2426    /* fill in the event and category */
2427    usta.t.usta.alarm.category = category;
2428    usta.t.usta.alarm.event = event;
2429    usta.t.usta.alarm.cause = cause;
2430
2431    /* set the suId and ueId */
2432    usta.t.usta.ueId = ueId;
2433    usta.t.usta.suId = suId;
2434 /* kw005.201 added support for L2 Measurement */
2435 #ifdef LTE_L2_MEAS
2436    if(event == LKW_EVT_MEAS_HALT)
2437    {
2438       usta.t.usta.qci = qci;
2439    }
2440 #endif /* LTE_L2_MEAS */
2441    /* update the date and time */
2442    (Void) SGetDateTime(&usta.t.usta.alarm.dt);
2443
2444    KwMiLkwStaInd(&(gCb->init.lmPst), &usta);
2445
2446    RETVOID;
2447
2448
2449
2450 /**
2451  * @brief
2452  *    This function sends trace indication to LM 
2453  *
2454  * @param[in]  gCb     RLC Instance Control Block
2455  * @param[in]  event   event
2456  * @param[in]  mBuf    meessage buffer
2457  *
2458  * @return S16
2459  *    -# ROK 
2460  *    -# RFAILED 
2461  */
2462 #ifdef ANSI
2463 PUBLIC S16 kwLmmSendTrc
2464 (
2465 KwCb     *gCb,
2466 Event    event,     
2467 Buffer   *mBuf     
2468 )
2469 #else
2470 PUBLIC S16 kwLmmSendTrc(gCb,event, mBuf)
2471 KwCb     *gCb;
2472 Event    event;   
2473 Buffer   *mBuf;  
2474 #endif
2475 {
2476    KwMngmt   trc;              /* RLC management control block */
2477    Buffer    *dstMbuf;   
2478    MsgLen    bufLen;
2479    Data      *tempBuf;
2480    MsgLen    tempCnt;
2481    Pst       pst;
2482
2483    TRC2(kwLmmSendTrc)
2484
2485    RLOG2(L_DEBUG, "kwLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
2486                      event,
2487                      gCb->trcLen);
2488
2489    cmMemset((U8 *)&trc, 0, sizeof(KwMngmt));
2490
2491    pst = gCb->init.lmPst;
2492
2493    trc.t.trc.event = event;
2494    SGetDateTime(&trc.t.trc.dt);
2495    trc.cfm.status = LCM_PRIM_OK;
2496    trc.cfm.reason = LCM_REASON_NOT_APPL;
2497          
2498    if(mBuf != NULLP)
2499    {
2500      /* Check if the whole buffer is to be sent in Trace indication */
2501      if(gCb->trcLen == LKW_FULL_TRACE)
2502      {
2503         if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2504             != ROK)
2505         {
2506            /* rg005.201 removed SPutSBuf on error */
2507            RLOG0(L_ERROR,"SCpyMsgMsg Failed");   
2508            RETVALUE(RFAILED);
2509         }
2510         /* Send Trace Indication to Layer manager */
2511         KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2512      }
2513      /* check if only a specified number of bytes are to be sent */
2514      else if(gCb->trcLen > 0)
2515      {
2516         /* Get the length of the recvd message buffer */
2517         if (SFndLenMsg(mBuf, &bufLen) != ROK)
2518         {
2519            RLOG0(L_ERROR,"SFndLenMsg Failed");   
2520            RETVALUE(RFAILED);
2521         }
2522         /* Check if the recvd buffer size is less than request trace len */
2523         if(bufLen < gCb->trcLen)
2524         {
2525            /* Copy the whole of the recvd buffer in trace indication */
2526       
2527            if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2528               != ROK)
2529            {
2530               RLOG0(L_ERROR,"SCpyMsgMsg Failed");   
2531               RETVALUE(RFAILED);
2532            }
2533          
2534            /* Send Trace Indication to Layer manager */
2535            KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2536         }
2537         else
2538         {
2539            /* if the recvd buffer size is greater than request trace len */
2540            /* Get a temporary buffer to store the msg */
2541            KW_ALLOC(gCb,tempBuf, gCb->trcLen);
2542
2543 #if (ERRCLASS & ERRCLS_INT_PAR)
2544            if(tempBuf == NULLP)
2545            {
2546               (Void) SPutSMem(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb));
2547       
2548                RLOG0(L_FATAL,"Memory Allocation failed");   
2549                RETVALUE(LCM_REASON_MEM_NOAVAIL);
2550            }
2551 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2552          
2553            /* Copy trcLen nos of bytes from the recvd message */
2554            if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)   
2555            {
2556               RLOG0(L_ERROR,"SCpyMsgFix Failed");   
2557               RETVALUE(RFAILED);
2558            }
2559
2560            if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
2561            {
2562               RLOG0(L_FATAL,"Memory Allocation failed");   
2563               RETVALUE(RFAILED);
2564            }
2565            /* Copy the tempBuf data to dst mBuf */
2566            if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
2567            {
2568               RLOG0(L_ERROR,"SCpyMsgFix Failed");   
2569               RETVALUE(RFAILED);
2570            }
2571   
2572            /* Free the memory allocated for tempBuf */
2573            KW_FREE(gCb,tempBuf, gCb->trcLen);
2574            /* Send Trace Indication to Layer manager */
2575            KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2576         }
2577      }
2578    }
2579    else
2580    {
2581       KwMiLkwTrcInd(&pst, &trc, mBuf);
2582    }
2583
2584    RETVALUE(ROK);
2585
2586
2587 \f  
2588 /*
2589  * @brief
2590  *    Activate Task - timer
2591  *
2592  * @details     
2593  *    Invoked by system services to activate a task with a timer tick.
2594  *
2595  * @param[in] ent    entity
2596  * @param[in] inst   instance
2597  *
2598  * @return S16
2599  *    -# ROK
2600  *    -# RFAILED
2601  *
2602  */
2603  
2604 #ifdef ANSI
2605 PUBLIC S16 kwActvTmr
2606 (
2607 Ent    ent,
2608 Inst   inst
2609 )
2610 #else
2611 PUBLIC S16 kwActvTmr(ent,inst)
2612 Ent    ent;
2613 Inst   inst;
2614 #endif
2615 {
2616    KwCb   *gCb; 
2617    TRC2(kwActvTmr)
2618
2619    if (inst >= KW_MAX_RLC_INSTANCES)
2620    {
2621       RETVALUE (RFAILED);
2622    }
2623    gCb = KW_GET_KWCB(inst); 
2624    cmPrcTmr(&(gCb->kwTqCp), gCb->kwTq, (PFV) kwTmrExpiry);
2625    RETVALUE(ROK);
2626
2627 } /* end of kwActvTmr */
2628
2629  
2630 /********************************************************************30**
2631
2632          End of file
2633 **********************************************************************/