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