1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
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 #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
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 *******************************************************************************/
19 /********************************************************************20**
21 Name: LTE - RLC - Layer Manager file
25 Desc: It contains the following common functions for processing
26 the all the external interfaces.
40 *********************************************************************21*/
41 static const char* RLOG_MODULE_NAME="LMM";
42 static int RLOG_MODULE_ID=2048;
43 static int RLOG_FILE_ID=197;
45 @brief RLC Layer Manager Module
49 /* header (.h) include files */
50 #include "common_def.h"
51 #include "lkw.h" /* LKW defines */
52 #include "ckw.h" /* CKW defines */
53 #include "kwu.h" /* KWU defines */
54 #include "rgu.h" /* RGU defines */
55 #include "kw_err.h" /* Err defines */
56 #include "kw_env.h" /* RLC environment options */
58 #include "kw.h" /* RLC defines */
63 /* extern (.x) include files */
64 #include "lkw.x" /* LKW */
65 #include "ckw.x" /* CKW */
66 #include "kwu.x" /* KWU */
67 #include "rgu.x" /* RGU */
74 #define KW_MODULE KW_DBGMASK_LMM
78 /*********************************************************************
79 * Forward Declaration of LKW Porting Functions
80 ********************************************************************/
81 PUBLIC KwCb *kwCb[KW_MAX_RLC_INSTANCES];
82 EXTERN S16 kwActvTmr ARGS ((Ent ent, Inst inst));
84 PRIVATE Void kwLmmSendCfm ARGS ((KwCb *gCb,Pst *pst,KwMngmt *cfm,U8 type,
86 PRIVATE S16 kwLmmGenCfg ARGS ((KwCb *gCb, KwGenCfg *cfg));
87 PRIVATE S16 kwLmmCfgKwuSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
88 PRIVATE S16 kwLmmCfgUdxSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
89 PRIVATE S16 kwLmmCfgCkwSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
90 PRIVATE S16 kwLmmCfgRguSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
91 PRIVATE S16 kwLmmGenCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
92 PRIVATE S16 kwLmmUdxSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
93 PRIVATE S16 kwLmmLSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
94 PRIVATE S16 kwLmmGetKwuSapSta ARGS ((KwCb *gCb,KwKwuSapSta *sta));
95 PRIVATE S16 kwLmmGetRguSapSta ARGS ((KwCb *gCb,KwRguSapSta *sta));
96 PRIVATE S16 kwLmmGetCkwCntSapSta ARGS ((KwCb *gCb,KwCkwCntSapSta *sta));
97 PRIVATE S16 kwLmmGetGenSts ARGS ((KwCb *gCb,KwGenSts *sts,Action action));
98 PRIVATE S16 kwLmmGetSapSts ARGS ((KwCb *gCb,KwMngmt *sts,Elmnt elmnt,Action
102 /*********************************************************************
103 * Primitives for RGU interface
104 ********************************************************************/
107 * Stores the general RLC configuration.
109 * It calculates the memory requirement of the Saps
110 * It also initializes the control blocks, the hash lists and registers
111 * the timers. In case of error it rolls back and reports error in the
112 * confirm.If the general configuration is already done it is treated as
113 * reconfiguration, but right now reconfiguration is not supported.
115 * @param[in] gCb RLC Instance Control Block
116 * @param[in] cfm RLC LM general config structure
119 * LCM_REASON_NOT_APPL (SUCCESS)
120 * LCM_REASON_MEM_NOAVAIL
121 * LCM_REASON_REGTMR_FAIL
122 * LCM_REASON_INVALID_PAR_VAL
123 * LCM_REASON_HASHING_FAILED
126 PRIVATE S16 kwLmmGenCfg
132 PRIVATE S16 kwLmmGenCfg(gCB,cfg)
145 if(cfg->maxUe > KW_MAX_UE)
147 #if (ERRCLASS & ERRCLS_INT_PAR)
148 RLOG2(L_ERROR, "Invalid maxUe : Max [%lu] Received [%lu]",
151 #endif /* ERRCLASS & ERRCLS_INT_PAR */
152 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
155 if(cfg->maxKwuSaps > KW_MAX_KWUSAPS)
157 #if (ERRCLASS & ERRCLS_INT_PAR)
158 RLOG2(L_ERROR, "Invalid maxKwuSaps : Max [%lu] Received [%lu]",
161 #endif /* ERRCLASS & ERRCLS_INT_PAR */
162 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
165 if(cfg->maxUdxSaps > KW_MAX_UDXSAPS)
167 #if (ERRCLASS & ERRCLS_INT_PAR)
168 RLOG2(L_ERROR, "Invalid maxUduSaps : Max [%lu] Received [%lu]",
171 #endif /* ERRCLASS & ERRCLS_INT_PAR */
172 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
175 if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > KW_MAX_RGUSAPS))
179 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
181 if(gCb->init.cfgDone == TRUE)
183 /* reconfiguration not supported */
184 RETVALUE(LCM_REASON_RECONFIG_FAIL);
189 /* Timer Queue Control point initialization */
190 kwTqCp = &(gCb->kwTqCp);
191 kwTqCp->tmrLen = KW_TMR_LEN;
194 if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
196 KW_ALLOC(gCb,gCb->u.dlCb, sizeof (KwDlCb));
197 if (gCb->u.dlCb == NULLP)
199 RLOG0(L_FATAL,"Memory Allocation failed");
200 RETVALUE(LCM_REASON_MEM_NOAVAIL);
203 /* allocate memory to the KWU sap's */
204 kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
205 (Size)sizeof(KwKwuSapCb));
207 KW_ALLOC(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
209 #if (ERRCLASS & ERRCLS_INT_PAR)
210 if(gCb->u.dlCb->kwuDlSap == NULLP)
212 KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
213 RLOG0(L_FATAL,"Memory Allocation failed");
214 RETVALUE(LCM_REASON_MEM_NOAVAIL);
216 #endif /* ERRCLASS & ERRCLS_INT_PAR */
218 gCb->u.dlCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
220 kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
221 (Size)sizeof(KwUdxDlSapCb));
223 KW_ALLOC(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
224 #if (ERRCLASS & ERRCLS_INT_PAR)
225 if(gCb->u.dlCb->udxDlSap == NULLP)
227 KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
228 KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
229 RLOG0(L_FATAL,"Memory Allocation failed");
230 RETVALUE(LCM_REASON_MEM_NOAVAIL);
232 #endif /* ERRCLASS & ERRCLS_INT_PAR */
234 rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
235 (Size)sizeof(KwRguSapCb));
236 KW_ALLOC(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
237 #if (ERRCLASS & ERRCLS_INT_PAR)
238 if(gCb->u.dlCb->rguDlSap == NULLP)
240 KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
241 KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
242 KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
244 KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
245 "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
246 RETVALUE(LCM_REASON_MEM_NOAVAIL);
248 #endif /* ERRCLASS & ERRCLS_INT_PAR */
251 /* Initialize the Ue and Cell hash list */
252 ret = kwDbmDlInit(gCb);
255 KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
256 KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
257 KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
258 KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
259 RLOG0(L_FATAL,"RLC DL Initialization failed");
260 RETVALUE(LCM_REASON_MEM_NOAVAIL);
263 /* Register the timer */
264 /*Pradeep: changing the SRegTmrMt() to SRegTmr()*/
265 if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
268 KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
269 KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
270 KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
271 KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
273 RETVALUE(LCM_REASON_REGTMR_FAIL);
276 /* initializations for background processing of freeing memory */
277 kwUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
278 kwUtlInitializeSelfPst(gCb);
280 if(SGetMsg(gCb->init.region,
282 &(gCb->u.dlCb->selfPstMBuf)) != ROK)
284 KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
285 KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
286 KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
287 KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
289 RETVALUE(LCM_REASON_MEM_NOAVAIL);
293 kwUtlL2MeasDlInit(gCb);
296 else if(gCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
298 KW_ALLOC(gCb,gCb->u.ulCb, sizeof (KwUlCb));
299 if (gCb->u.ulCb == NULLP)
301 RLOG0(L_FATAL,"Memory Allocation failed");
302 RETVALUE(LCM_REASON_MEM_NOAVAIL);
305 /* allocate memory to the KWU sap's */
306 kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
307 (Size)sizeof(KwKwuSapCb));
309 KW_ALLOC(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
311 #if (ERRCLASS & ERRCLS_INT_PAR)
312 if(gCb->u.ulCb->kwuUlSap == NULLP)
314 KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
315 RLOG0(L_FATAL,"Memory Allocation failed");
316 RETVALUE(LCM_REASON_MEM_NOAVAIL);
318 #endif /* ERRCLASS & ERRCLS_INT_PAR */
320 gCb->u.ulCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
322 /* allocate memory to the KWU sap's */
323 kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
324 (Size)sizeof(KwUdxUlSapCb));
326 KW_ALLOC(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
328 #if (ERRCLASS & ERRCLS_INT_PAR)
329 if(gCb->u.ulCb->kwuUlSap == NULLP)
331 KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
332 KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
333 RLOG0(L_FATAL,"Memory Allocation failed");
334 RETVALUE(LCM_REASON_MEM_NOAVAIL);
336 #endif /* ERRCLASS & ERRCLS_INT_PAR */
338 rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
339 (Size)sizeof(KwRguSapCb));
340 KW_ALLOC(gCb,gCb->u.ulCb->rguUlSap, rguSapSize);
341 #if (ERRCLASS & ERRCLS_INT_PAR)
342 if(gCb->u.ulCb->rguUlSap == NULLP)
344 KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
345 KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
346 KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
348 KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
349 "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
350 RETVALUE(LCM_REASON_MEM_NOAVAIL);
352 #endif /* ERRCLASS & ERRCLS_INT_PAR */
354 /* Initialize the Ue and Cell hash list */
355 ret = kwDbmUlInit(gCb);
358 KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
359 KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
360 KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
361 KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
362 RLOG0(L_FATAL,"RLC DL Initialization failed");
365 /* Register the timer */
367 if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
370 KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
371 KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
372 KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
373 KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
375 RETVALUE(LCM_REASON_REGTMR_FAIL);
379 kwUtlL2MeasUlInit(gCb);
384 #if (ERRCLASS & ERRCLS_INT_PAR)
385 RLOG0(L_ERROR, "Received Invalid RLC Mode");
386 #endif /* ERRCLASS & ERRCLS_INT_PAR */
388 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
390 /* Timer Initialization */
391 gCb->kwTqCp.tmrLen = KW_TMR_LEN;
393 cmMemset((U8*)gCb->kwTq, NULLP, sizeof(CmTqType) * KW_TMR_LEN);
395 KW_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
397 gCb->init.lmPst.srcProcId = gCb->init.procId;
398 gCb->init.lmPst.srcEnt = gCb->init.ent;
399 gCb->init.lmPst.srcInst = gCb->init.inst;
400 gCb->init.lmPst.event = EVTNONE;
402 /* kw002.201 For multi core and multi region,no need to reinitiailize the
403 * region again . This would be done with kwActvInit from SSI */
404 #if !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION)
405 gCb->init.region = cfg->lmPst.region;
406 #endif /* !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION) */
407 gCb->init.pool = cfg->lmPst.pool;
409 gCb->init.cfgDone = TRUE;
411 RETVALUE(LCM_REASON_NOT_APPL);
416 * Sends confirmation message to LM Called by KwMiLkwCfgReq function
418 * @param[in] gCb RLC Instance Control Block
419 * @param[in] pst Post structure
420 * @param[in] cfm RLC LM structure
421 * @param[in] type Type of LM message
422 * @param[in] hdr Message header
428 PRIVATE Void kwLmmSendCfm
437 PRIVATE Void kwLmmSendCfm(gCb,pst, cfm, type, hdr)
445 Pst rPst; /* Reply post structure */
449 KW_MEM_SET(&rPst, 0, sizeof(Pst));
451 /* reply post structure for confirmation */
454 rPst.srcEnt = gCb->init.ent;
455 rPst.srcInst = gCb->init.inst;
456 cfm->hdr.entId.ent = gCb->init.ent;
457 cfm->hdr.entId.inst = gCb->init.inst;
461 rPst.srcEnt = pst->dstEnt;
462 rPst.srcInst = pst->dstInst;
463 cfm->hdr.entId.ent = pst->dstEnt;
464 cfm->hdr.entId.inst = pst->dstInst;
466 rPst.srcProcId = SFndProcId();
467 rPst.dstEnt = pst->srcEnt;
468 rPst.dstInst = pst->srcInst;
469 rPst.dstProcId = pst->srcProcId;
470 rPst.selector = hdr->response.selector;
471 rPst.prior = hdr->response.prior;
472 rPst.route = hdr->response.route;
473 rPst.region = hdr->response.mem.region;
474 rPst.pool= hdr->response.mem.pool;
476 /* Fill the reply header */
477 cfm->hdr.elmId.elmnt = hdr->elmId.elmnt;
478 cfm->hdr.transId = hdr->transId;
483 KwMiLkwCfgCfm(&rPst,cfm);
486 SGetDateTime(&(cfm->t.cntrl.dt));
487 KwMiLkwCntrlCfm(&rPst,cfm);
490 SGetDateTime(&(cfm->t.sts.dt));
491 KwMiLkwStsCfm(&rPst,0,cfm);
494 SGetDateTime(&(cfm->t.ssta.dt));
495 KwMiLkwStaCfm(&rPst,cfm);
498 #if (ERRCLASS & ERRCLS_INT_PAR)
499 RLOG0(L_ERROR, "Received Invalid Message Type");
504 #endif /* ERRCLASS & ERRCLS_INT_PAR */
514 * This function processes configuration requests received from the layer
518 * The configuration requests can be for general configuration, or
519 * configuration of RGU, KWU, and CKW SAPs. The type of the configuration
520 * request can be determined from the elmId field in the header of the layer
521 * manager message.This function is called by the layer manager to configure
524 * This function implements the following logic:
526 * - if genCfg is not done, send negative Cfm to the layer manager;
528 * - switch (cfg->hdr.elmId.elmnt)
530 * - update the genCfg field in RlCb;
531 * - allocate the maximum static memory required by the RLC product;
532 * - register the timer service by calling SReqTmr;
533 * - set CfgDone for not configuring again;
535 * - if all the parameters are valid, then allocate the KwuSap control
537 * - update the SAP control block with the information provided in the
538 * - configuration request;
539 * - send configuration confirm with the status, success;
541 * - if all the parametes are valid, then allocate the CkwSap control
543 * - update the SAP control block with the information provided in the
544 * configuration request;
545 * - send configuration confirm with the status, success;
547 * - if all the parametes are valid, then allocate the rguSap control
549 * - update the SAP control block with the information provided in the
550 * configuration request;
551 * - send configuration confirm with the status, success;
553 * - if all the parametes are valid, then allocate the udxSap control
555 * - update the SAP control block with the information provided in the
556 * configuration request;
557 * - send configuration confirm with the status, success;
560 * @param[in] pst post structure
561 * @param[in] cfg LM management structure
565 * -# Failure : RFAILED
569 PUBLIC S16 KwMiLkwCfgReq
575 PUBLIC S16 KwMiLkwCfgReq (pst, cfg)
580 Reason reason; /* failure reason */
585 #if (ERRCLASS & ERRCLS_INT_PAR)
586 /* Check if the instance is configured */
587 if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
589 cfg->cfm.status = LCM_PRIM_NOK;
590 cfg->cfm.reason = LCM_REASON_INVALID_INSTANCE;
591 kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
596 tKwCb = KW_GET_KWCB(pst->dstInst);
600 cfg->cfm.status = LCM_PRIM_NOK;
601 cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
602 kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
605 /* check configuration is done or not */
606 if ((tKwCb->init.cfgDone != TRUE) &&
607 (cfg->hdr.elmId.elmnt != STGEN))
610 * if general config is not over then use pst structure
611 * in primitive to communicate to stack manager
614 cfg->cfm.status = LCM_PRIM_NOK;
615 cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
616 kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
620 RLOG1(L_DEBUG, "KwMiLkwCfgReq elmId(%d)", cfg->hdr.elmId.elmnt);
622 switch(cfg->hdr.elmId.elmnt)
626 reason = kwLmmGenCfg(tKwCb,&cfg->t.cfg.s.gen);
631 reason = kwLmmCfgKwuSap(tKwCb,&cfg->t.cfg.s.sap);
636 reason = kwLmmCfgCkwSap(tKwCb,&cfg->t.cfg.s.sap);
641 reason = kwLmmCfgRguSap(tKwCb,&cfg->t.cfg.s.sap);
646 reason = kwLmmCfgUdxSap(tKwCb,&cfg->t.cfg.s.sap);
651 reason = LCM_REASON_INVALID_ELMNT;
656 if (reason == LCM_REASON_NOT_APPL)
658 cfg->cfm.status = LCM_PRIM_OK;
659 cfg->cfm.reason = LCM_REASON_NOT_APPL;
660 kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
665 cfg->cfm.status = LCM_PRIM_NOK;
666 cfg->cfm.reason = reason;
667 kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
674 * The layer manager initiates and uses the management-control procedure to
675 * control RLC elements.The RLC control request primitive (KwMiLkwCntrlReq)
676 * can be called more than once and at any time after the
677 * management-configuration procedure.The control request primitive
678 * is confirmed by a KwMiLkwCntrlCfm primitive.
681 * This function implements the following logic:
683 * - if(cfgDone = FALSE)
684 * - send negative confirmation to the layer manager;
687 * - switch(cntrl->hdr.elmId.elmnt)
691 * - switch(subAction)
693 * - enable the unsolicited status flag;
694 * - send the control Cfm with success;
696 * - set the debug mask;
697 * - send the control Cfm with success;
699 * - enable the trace flag;
700 * - send the control Cfm with success;
702 * - switch(subAction)
704 * - disable the unsolicited status flag;
705 * - send the control Cfm with success;
707 * - disable the trace flag;
708 * - send the control Cfm with success;
717 * @param[in] pst post structure
718 * @param[in] cntrl LM management structure
725 PUBLIC S16 KwMiLkwCntrlReq
731 PUBLIC S16 KwMiLkwCntrlReq(pst, cntrl)
736 Reason reason; /* failure reason */
739 TRC3(KwMiLkwCntrlReq)
741 #if (ERRCLASS & ERRCLS_INT_PAR)
742 /* Check if the instance is configured */
743 if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
745 cntrl->cfm.status = LCM_PRIM_NOK;
746 cntrl->cfm.reason = LCM_REASON_INVALID_INSTANCE;
748 kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
753 tKwCb = KW_GET_KWCB(pst->dstInst);
757 cntrl->cfm.status = LCM_PRIM_NOK;
758 cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
759 kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
763 if (!(tKwCb->init.cfgDone))
765 cntrl->cfm.status = LCM_PRIM_NOK;
766 cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
767 kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
770 RLOG1(L_DEBUG, "KwMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
772 /* In normal cases, LCM_REASON_NOT_APPL is returned in cfm.
773 * In all error cases appropriate reason is returned
774 * by the functions below
777 switch (cntrl->hdr.elmId.elmnt)
781 /* general control */
782 reason = kwLmmGenCntrl(tKwCb,cntrl);
787 /* Lower SAP control */
788 reason = kwLmmLSapCntrl(tKwCb,cntrl);
794 reason = kwLmmUdxSapCntrl(tKwCb,cntrl);
799 reason = LCM_REASON_INVALID_ELMNT;
804 if (reason == LCM_REASON_NOT_APPL)
806 cntrl->cfm.status = LCM_PRIM_OK;
807 cntrl->cfm.reason = LCM_REASON_NOT_APPL;
811 cntrl->cfm.status = LCM_PRIM_NOK;
812 cntrl->cfm.reason = reason;
815 kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
822 * This function processes solicited status requests received from the layer
823 * manager. The layer manager can request status information regarding the
824 * system ID, RGUSAP,KWUSAP, or CKWSAP.
826 * @param[in] pst post structure
827 * @param[in] sta LM management structure
833 PUBLIC S16 KwMiLkwStaReq
839 PUBLIC S16 KwMiLkwStaReq(pst, sta)
844 KwMngmt rSta; /* Status */
845 Reason reason; /* Failure reason */
850 #if (ERRCLASS & ERRCLS_INT_PAR)
851 /* Check if the instance is configured */
852 if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
854 sta->cfm.status = LCM_PRIM_NOK;
855 sta->cfm.reason = LCM_REASON_INVALID_INSTANCE;
857 kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
862 tKwCb = KW_GET_KWCB(pst->dstInst);
865 sta->cfm.status = LCM_PRIM_NOK;
866 sta->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
868 kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
872 RLOG1(L_DEBUG, "Status request for elmId(%d))", sta->hdr.elmId.elmnt);
874 reason = LCM_REASON_NOT_APPL;
876 KW_MEM_SET(&rSta, 0, sizeof(KwMngmt));
877 switch (sta->hdr.elmId.elmnt)
881 reason = LCM_REASON_NOT_APPL;
882 kwGetSId(&rSta.t.ssta.s.sysId);
887 KW_MEM_CPY (&rSta.t.ssta.s.kwuSap,
888 &sta->t.ssta.s.kwuSap,
889 sizeof (KwKwuSapSta));
891 reason = kwLmmGetKwuSapSta (tKwCb,&rSta.t.ssta.s.kwuSap);
896 KW_MEM_CPY (&rSta.t.ssta.s.rguSap,
897 &sta->t.ssta.s.rguSap,
898 sizeof (KwRguSapSta));
900 reason = kwLmmGetRguSapSta (tKwCb,&rSta.t.ssta.s.rguSap);
905 KW_MEM_CPY (&rSta.t.ssta.s.ckwSap,
906 &sta->t.ssta.s.ckwSap,
907 sizeof (KwCkwCntSapSta));
909 reason = kwLmmGetCkwCntSapSta (tKwCb,&rSta.t.ssta.s.ckwSap);
914 reason = LCM_REASON_INVALID_ELMNT;
917 } /* end of switch */
919 if (reason == LCM_REASON_NOT_APPL)
921 rSta.cfm.status = LCM_PRIM_OK;
922 rSta.cfm.reason = LCM_REASON_NOT_APPL;
926 rSta.cfm.status = LCM_PRIM_NOK;
927 rSta.cfm.reason = reason;
929 kwLmmSendCfm(tKwCb,pst, &rSta, TSSTA, &sta->hdr);
936 * This function processes statistics requests received from the layer
940 * After collecting the statistics, ir calls the statistics confirm function
941 * to send the statistics to the layer manager.
943 * - switch(sts->hdr.elmId.elmnt)
945 * - get the general statistics from the KW control block;
946 * - if (action = RESET)
947 * - reset the general statistic field in the RlCb;
948 * - call KwMiLkwStsCfm to send statistics back to layer manager;
952 * - get the SAP specific statistics from KW control block;
953 * - if (action = RESET)
954 * - reset the general statistic field in the RlCb;
955 * - call KwMiLkwStsCfm to send statistics to the layer manager;
958 * @param[in] pst post structure
959 * @param[in] action action
960 * @param[in] sts LM management structure
967 PUBLIC S16 KwMiLkwStsReq
974 PUBLIC S16 KwMiLkwStsReq (pst, action, sts)
980 KwMngmt rSts; /* Statistics */
981 Reason reason; /* Reason for failure */
986 #if (ERRCLASS & ERRCLS_INT_PAR)
987 /* Check if the instance is configured */
988 if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
990 rSts.cfm.status = LCM_PRIM_NOK;
991 rSts.cfm.reason = LCM_REASON_INVALID_INSTANCE;
993 kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
998 tKwCb = KW_GET_KWCB(pst->dstInst);
1001 rSts.cfm.status = LCM_PRIM_NOK;
1002 rSts.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
1004 kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
1008 RLOG2(L_DEBUG, "KwMiLkwStsReq(elmId(%d),action(%d))",
1010 sts->hdr.elmId.elmnt);
1012 KW_MEM_SET(&rSts, 0, sizeof(KwMngmt));
1014 switch (sts->hdr.elmId.elmnt)
1018 reason = kwLmmGetGenSts(tKwCb,&rSts.t.sts.s.gen, action);
1024 if( sts->hdr.elmId.elmnt == STKWUSAP)
1026 /* kw005.201, modified the element of kwuSap from suId to spId */
1027 rSts.t.sts.s.kwuSap.spId = sts->t.sts.s.kwuSap.spId;
1029 reason = kwLmmGetSapSts(tKwCb,&rSts, sts->hdr.elmId.elmnt, action);
1034 reason = LCM_REASON_INVALID_ELMNT;
1039 if (reason == LCM_REASON_NOT_APPL)
1041 rSts.cfm.status = LCM_PRIM_OK;
1042 rSts.cfm.reason = LCM_REASON_NOT_APPL;
1046 rSts.cfm.status = LCM_PRIM_NOK;
1047 rSts.cfm.reason = reason;
1049 kwLmmSendCfm(tKwCb,pst, &rSts, TSTS, &sts->hdr);
1054 /* kw005.201 added support for L2 Measurement */
1058 This function processes L2 Measurement requests received from the layer manager.
1059 The L2 Measurement is start for a time period and after the timer expiry, the
1060 measurement confirm is sent.
1062 - Accept only one set of measurements.
1063 - Allocate and initialise KwL2MeasEvtCb.
1064 - Validate if the measurement is already in progress.
1065 - Loop through the existing measEvtCb with matching measType
1066 - Check if measurement is running for any qci present in the measReq
1067 - If present, move the qCi to list of invalid qCIs.
1068 - Set KwL2MeasEvtCb.measOn to TRUE for QCIs to be measured.
1069 - For the number of measurements requested.
1070 - For all Ues with RBs matching qCI.
1071 - Add RbCb to the RB linked list.
1072 - Set kwRbCb.measOn to measurement type.
1073 - If Meas type is DL_DELAY
1074 - Update COUNT to startCount.
1077 * @param[in] pst post structure
1078 * @param[in] action action
1079 * @param[in] cfg LM management structure
1082 * -# Failure : RFAILED
1085 PUBLIC S16 KwMiLkwL2MeasReq
1088 KwL2MeasReqEvt *measReqEvt
1091 PUBLIC S16 KwMiLkwL2MeasReq (pst, measReqEvt)
1093 KwL2MeasReqEvt *measReqEvt;
1099 KwL2MeasCfmEvt measCfmEvt;
1103 TRC3(KwMiLkwL2MeasReq);
1105 tKwCb = KW_GET_KWCB(pst->dstInst);
1107 /* Initialize measCfmEvt */
1108 KW_MEM_ZERO(&measCfmEvt, sizeof(KwL2MeasCfmEvt));
1109 /* validate the received measReqEvt */
1110 /*LTE_L2_MEAS_PHASE2*/
1111 if(measReqEvt->measPeriod != 0)
1113 /* L2 MEAS AGHOSH */
1114 if((measReqEvt->measReq.measType & LKW_L2MEAS_DL_IP)||
1115 (measReqEvt->measReq.measType & LKW_L2MEAS_UL_IP))
1117 ret = kwUtlValidateIpThL2Meas(measReqEvt, &measCfmEvt);
1122 #if (ERRCLASS & ERRCLS_ADD_RES)
1123 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1124 kwUtlSndUlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
1125 KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
1130 measType = measReqEvt->measReq.measType;
1132 if((measType != LKW_L2MEAS_DL_IP) &&
1133 (measType != LKW_L2MEAS_ACT_UE) &&
1134 (measType != LKW_L2MEAS_DL_DISC) &&
1135 (measType != LKW_L2MEAS_DL_DELAY) &&
1136 (measType != LKW_L2MEAS_UU_LOSS) &&
1137 (measType != LKW_L2MEAS_UL_IP))/* || (qci > LKW_MAX_QCI)*/
1139 measCfmEvt.transId = measReqEvt->transId;
1140 measCfmEvt.measType = measType;
1141 measCfmEvt.status.status = LCM_PRIM_NOK;
1142 measCfmEvt.status.reason = LKW_CAUSE_INVALID_MEASTYPE;
1143 kwUtlSndDlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
1144 KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
1148 /* for UL IP throughput meas enable for all QCIs */
1149 if(measType & LKW_L2MEAS_UL_IP)
1151 for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1153 tKwCb->u.ulCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
1158 (LKW_L2MEAS_DL_IP | LKW_L2MEAS_DL_DISC |
1159 LKW_L2MEAS_DL_DELAY | LKW_L2MEAS_UU_LOSS))
1161 KwL2MeasReqEvt *measEvt;
1164 udxPst = &(KW_GET_UDX_SAP(tKwCb)->pst);
1166 KW_ALLOC_SHRABL_BUF(udxPst->region,
1169 sizeof(KwL2MeasReqEvt));
1171 #if (ERRCLASS & ERRCLS_ADD_RES) /* KW_FIX */
1172 if(measEvt == NULLP)
1174 RLOG0(L_FATAL,"Memory Allocation failed");
1178 cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(KwL2MeasReqEvt));
1179 /*Redirect the request to DL task */
1180 /* NOTE:As of today, there are no cases where the Req will fail at DL
1181 as long as it reached the DL, so we don't wait for a confirmation from
1182 DL to send the confirmation to LM*/
1183 /* The interface for sending a confirmation back does not exist today;
1184 it needs to be created when the need arises */
1185 KwUlUdxL2MeasReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measEvt);
1188 /* We need to copy the transId for sending back confirms later */
1189 for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1191 KwL2MeasEvtCb* measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1192 if(measEvtCb->measCb.measType & measType)
1194 measEvtCb->transId= measReqEvt->transId;
1197 /*KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt));*/
1200 } /* KwMiLkwL2MeasReq */
1204 This function processes L2 Measurement stop request received from the layer manager.
1205 After receving this request, RLC stops L2 Measurement
1206 * @param[in] pst post structure
1207 * @param[in] measType meas Type
1210 * -# Failure : RFAILED
1214 PUBLIC S16 KwMiLkwL2MeasStopReq
1220 PUBLIC S16 KwMiLkwL2MeasStopReq (pst, measType)
1226 KwL2MeasEvtCb *measEvtCb = NULLP;
1232 TRC3(KwMiLkwL2MeasStopReq);
1234 tKwCb = KW_GET_KWCB(pst->dstInst);
1236 /* reset the counter values for the measurement that is stopped */
1237 for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1239 measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1240 if(measEvtCb->measCb.measType & measType)
1242 kwUtlResetUlL2MeasInKwRb(tKwCb, &measEvtCb->measCb, measType);
1247 /* for UL IP throughput meas disable for all QCIs */
1248 if(measType & LKW_L2MEAS_UL_IP)
1250 for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1252 tKwCb->u.ulCb->kwL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
1256 if((measType & LKW_L2MEAS_DL_IP) || (measType & LKW_L2MEAS_DL_DISC)
1257 || (measType & LKW_L2MEAS_DL_DELAY))
1259 /*Redirect the request to DL task */
1260 KwUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
1263 /*cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
1265 status = LCM_PRIM_OK;
1266 KwMiLkwL2MeasStopCfm(&tKwCb->genCfg.lmPst, measType,status);
1272 This function processes L2 Measurement Send request received from the layer manager.
1273 After receving this request, RLC sends L2 Measurement
1274 * @param[in] pst post structure
1275 * @param[in] measType meas Type
1278 * -# Failure : RFAILED
1282 PUBLIC S16 KwMiLkwL2MeasSendReq
1288 PUBLIC S16 KwMiLkwL2MeasSendReq (pst, measType)
1294 KwL2MeasEvtCb *measEvtCb = NULLP;
1297 TRC3(KwMiLkwL2MeasSendReq);
1299 tKwCb = KW_GET_KWCB(pst->dstInst);
1301 /* In case of addition of any new measType here ,appropriate handling
1302 * has to be done in RLC DL (kwUtlSndDlL2MeasCfm)*/
1304 (LKW_L2MEAS_DL_DISC | LKW_L2MEAS_DL_DELAY
1305 | LKW_L2MEAS_UU_LOSS| LKW_L2MEAS_DL_IP))
1307 /*Redirect the request to DL task */
1308 KwUlUdxL2MeasSendReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
1309 /* L2 MEAS AGHOSH */
1313 for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1315 measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1316 /* L2 MEAS AGHOSH */
1317 if(measEvtCb->measCb.measType & measType)
1319 kwUtlHdlL2TmrExp(tKwCb, measEvtCb);
1325 #endif /* LTE_L2_MEAS */
1329 * This function configures the RLC data sap
1331 * @param[in] gCb RLC Instance Control Block
1332 * @param[in] cfg RLC LM Sap configuration structure
1335 * -# LCM_REASON_NOT_APPL (SUCCESS)
1336 * -# LCM_REASON_INVALID_SAP
1337 * -# LCM_REASON_MEM_NOAVAIL
1338 * -# LCM_REASON_RECONFIG_FAIL
1341 PRIVATE S16 kwLmmCfgKwuSap
1347 PRIVATE S16 kwLmmCfgKwuSap(gCb,cfg)
1352 KwKwuSapCb *kwuSapCb;
1353 TRC2(kwLmmCfgKwuSap)
1355 #if (ERRCLASS & ERRCLS_INT_PAR)
1356 /* Validate the protocol parameters */
1357 if((cfg->sapId >= (S16)gCb->genCfg.maxKwuSaps) || (cfg->sapId < 0))
1359 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1361 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1363 kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1364 (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + cfg->sapId):
1365 (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + cfg->sapId);
1367 #if (ERRCLASS & ERRCLS_INT_PAR)
1368 /* Check for reconfiguration */
1369 if (kwuSapCb->state != KW_SAP_NOT_CFG)
1371 RLOG2(L_ERROR,"RLC Mode [%d] : Invalid kwuSap State [%d]",
1372 gCb->genCfg.rlcMode, kwuSapCb->state);
1373 /* reconfiguration not allowed */
1374 RETVALUE(LCM_REASON_RECONFIG_FAIL);
1376 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1378 /* Fill the parameters */
1379 KW_FILL_SAP_HELPER(kwuSapCb, cfg, gCb);
1381 RETVALUE(LCM_REASON_NOT_APPL);
1386 * This function configures the RLC control sap
1388 * @param[in] gCb RLC Instance Control Block
1389 * @param[in] cfg RLC LM Sap configuration structure
1392 * -# LCM_REASON_NOT_APPL (SUCCESS)
1393 * -# LCM_REASON_INVALID_SAP
1394 * -# LCM_REASON_INVALID_SAP
1395 * -# LCM_REASON_RECONFIG_FAIL
1398 PRIVATE S16 kwLmmCfgCkwSap
1404 PRIVATE S16 kwLmmCfgCkwSap(gCb,cfg)
1411 TRC2(kwLmmCfgCkwSap)
1413 #if (ERRCLASS & ERRCLS_INT_PAR)
1414 /* Validate config parameters */
1415 if ((cfg->sapId >= KW_MAX_CKWSAPS) || (cfg->sapId < 0) )
1417 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1420 if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1422 /* Get Sap control block */
1423 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1427 ckwSap = &(gCb->u.ulCb->ckwSap);
1429 #if (ERRCLASS & ERRCLS_INT_PAR)
1430 /* Check for reconfiguration */
1431 if(ckwSap->state != KW_SAP_NOT_CFG)
1433 RLOG1(L_ERROR,"Invalid kwuSap State [%d]",ckwSap->state);
1434 RETVALUE(LCM_REASON_RECONFIG_FAIL);
1436 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1438 /* Fill the parameters */
1439 KW_FILL_SAP_HELPER(ckwSap, cfg, gCb);
1441 RETVALUE(LCM_REASON_NOT_APPL);
1446 * This function configures the UDX sap
1448 * @param[in] gCb RLC Instance Control Block
1449 * @param[in] cfg RLC LM Sap configuration structure
1452 * -# LCM_REASON_NOT_APPL (SUCCESS)
1453 * -# LCM_REASON_INVALID_SAP
1454 * -# LCM_REASON_INVALID_SAP
1455 * -# LCM_REASON_RECONFIG_FAIL
1458 PRIVATE S16 kwLmmCfgUdxSap
1464 PRIVATE S16 kwLmmCfgUdxSap(gCb,cfg)
1469 KwUdxDlSapCb *udxDlSap;
1470 KwUdxUlSapCb *udxUlSap;
1472 TRC2(kwLmmCfgUdxSap);
1474 #if (ERRCLASS & ERRCLS_INT_PAR)
1475 /* Validate the protocol parameters */
1476 if((cfg->sapId >= KW_MAX_UDXSAPS) || (cfg->sapId < 0))
1478 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1481 /* Get Sap control block */
1482 if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1484 udxDlSap = (gCb->u.dlCb->udxDlSap + cfg->sapId);
1485 #if (ERRCLASS & ERRCLS_INT_PAR)
1486 /* Check for reconfiguration */
1487 if(udxDlSap->state != KW_SAP_NOT_CFG)
1489 RLOG1(L_ERROR,"Invalid udxDlSap State [%d]",udxDlSap->state);
1490 RETVALUE(LCM_REASON_RECONFIG_FAIL);
1492 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1494 /* Fill the parameters */
1495 KW_FILL_SAP_HELPER(udxDlSap, cfg, gCb);
1499 udxUlSap = (gCb->u.ulCb->udxUlSap + cfg->sapId);
1501 #if (ERRCLASS & ERRCLS_INT_PAR)
1502 /* Check for reconfiguration */
1503 if(udxUlSap->state != KW_SAP_NOT_CFG)
1505 RLOG1(L_ERROR,"Invalid udxUlSap State [%d]", udxUlSap->state);
1506 RETVALUE(LCM_REASON_RECONFIG_FAIL);
1508 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1510 /* Fill the parameters */
1511 KW_FILL_SAP_HELPER(udxUlSap, cfg, gCb);
1513 udxUlSap->bndTmrInt = cfg->bndTmrIntvl;
1514 udxUlSap->retryCnt = 0;
1515 cmInitTimers(&(udxUlSap->bndTmr), 1);
1518 RETVALUE(LCM_REASON_NOT_APPL);
1523 * This function configures the RGU sap
1525 * @param[in] gCb RLC Instance Control Block
1526 * @param[in] cfg RLC LM Sap configuration structure
1528 * -# LCM_REASON_NOT_APPL (SUCCESS)
1529 * -# LCM_REASON_INVALID_SAP
1530 * -# LCM_REASON_INVALID_SAP
1531 * -# LCM_REASON_RECONFIG_FAIL
1534 PRIVATE S16 kwLmmCfgRguSap
1540 PRIVATE S16 kwLmmCfgRguSap(gCb,cfg)
1547 TRC2(kwLmmCfgRguSap);
1549 #if (ERRCLASS & ERRCLS_INT_PAR)
1550 /* Validate the protocol parameters */
1551 if((cfg->sapId >= gCb->genCfg.maxRguSaps) || \
1554 KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
1555 "kwLmmCfgRguSap: Invalid RGU sapId\n");
1556 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1560 rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1561 &(gCb->u.dlCb->rguDlSap[cfg->sapId]): &(gCb->u.ulCb->rguUlSap[cfg->sapId]);
1563 #if (ERRCLASS & ERRCLS_INT_PAR)
1564 /* Check for reconfiguration */
1565 if(rguSap->state != KW_SAP_NOT_CFG)
1567 RLOG2(L_ERROR,"RLC Mode [%d]: Invalid rguSap State [%d]",
1568 gCb->genCfg.rlcMode, rguSap->state);
1569 RETVALUE(LCM_REASON_RECONFIG_FAIL);
1571 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1573 /* Fill the parameters */
1574 KW_FILL_SAP_HELPER(rguSap, cfg, gCb);
1575 rguSap->suId = cfg->sapId;
1576 rguSap->bndTmrInt = cfg->bndTmrIntvl;
1577 rguSap->retryCnt = 0;
1578 rguSap->state = KW_SAP_CFG;
1580 cmInitTimers(&(rguSap->bndTmr), 1);
1582 RETVALUE(LCM_REASON_NOT_APPL);
1587 * Validates the RLC general control parameters
1589 * @param[in] cntrl RLC LM structure
1592 * -# LCM_REASON_NOT_APPL (SUCCESS)
1593 * -# LCM_REASON_INVALID_SUBACTION
1594 * -# LCM_REASON_INVALID_ACTION
1597 PRIVATE S16 kwLmmValidateGenCntrl
1602 PRIVATE S16 kwLmmValidateGenCntrl(cntrl)
1606 S16 reason; /* reason for failure */
1607 U8 sAction; /* subaction field */
1609 TRC2(kwLmmValidateGenCntrl);
1611 reason = LCM_REASON_NOT_APPL;
1612 sAction = cntrl->t.cntrl.subAction;
1614 switch (cntrl->t.cntrl.action)
1618 if ((sAction != SAUSTA) &&
1619 (sAction != SADBG) &&
1622 reason = LCM_REASON_INVALID_SUBACTION;
1628 reason = LCM_REASON_INVALID_ACTION;
1637 * it deregisters the timers and deregisters the kwuSap Control blocks
1639 * @param[in] gCb RLC Instance Control Block
1644 PRIVATE Void kwLmmCleanGblRsrcs
1649 PRIVATE Void kwLmmCleanGblRsrcs(gCb)
1656 TRC2(kwLmmCleanGblRsrcs)
1658 if (gCb->init.cfgDone)
1660 /* Deregister the timers */
1661 /*Pradeep: changing the SDeregTmrMt() to SDeregTmr*/
1662 (Void) SDeregTmrMt(gCb->init.ent, gCb->init.inst,
1663 (S16)gCb->genCfg.timeRes, kwActvTmr);
1664 /*(Void) SDeregTmr(gCb->init.ent, gCb->init.inst,
1665 (S16)gCb->genCfg.timeRes, kwActvTmr);*/
1667 kwSapSize = (Size)(gCb->genCfg.maxKwuSaps * sizeof(KwKwuSapCb));
1669 if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1671 kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxDlSapCb));
1674 gCb->u.dlCb->shutdownReceived = TRUE;
1675 kwUtlFreeDlMemory(gCb);
1676 if (gCb->u.dlCb->kwuDlSap != NULLP)
1678 KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
1681 if(gCb->u.dlCb->udxDlSap != NULLP)
1683 KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
1686 if(gCb->u.dlCb->rguDlSap != NULLP)
1688 KW_FREE(gCb,gCb->u.dlCb->rguDlSap, gCb->genCfg.maxRguSaps);
1689 gCb->genCfg.maxRguSaps = 0;
1691 if (gCb->u.dlCb->shutdownReceived)
1693 if (gCb->u.dlCb->selfPstMBuf != NULL)
1695 SPutMsg(gCb->u.dlCb->selfPstMBuf);
1697 KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
1704 kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxUlSapCb));
1707 if (gCb->u.ulCb->kwuUlSap != NULLP)
1709 KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
1712 if(gCb->u.ulCb->udxUlSap != NULLP)
1714 KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
1717 if(gCb->u.ulCb->rguUlSap != NULLP)
1719 KW_FREE(gCb,gCb->u.ulCb->rguUlSap, gCb->genCfg.maxRguSaps);
1720 gCb->genCfg.maxRguSaps = 0;
1723 KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
1727 gCb->init.cfgDone = FALSE;
1728 gCb->init.acnt = FALSE;
1729 gCb->init.trc = FALSE;
1731 gCb->init.usta = FALSE;
1739 * Delete all SAPs and Control Blocks
1742 * Shutdown of RLC happens at modules level, tm, um and am modules will be
1743 * shutdown using utility functin and dbm shutdown will clean up the SAPs,
1744 * control blocks and lists.
1746 * @params[in] gCb RLC instance control block
1749 * -# LCM_REASON_NOT_APPL (SUCCESS)
1750 * -# LCM_REASON_HASHING_FAILED
1753 PRIVATE S16 kwLmmShutdown
1758 PRIVATE S16 kwLmmShutdown(gCb)
1767 if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1769 for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1771 rguSap = &(gCb->u.dlCb->rguDlSap[idx]);
1772 if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
1774 KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1780 for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1782 rguSap = &(gCb->u.ulCb->rguUlSap[idx]);
1783 if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
1785 KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1790 if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1792 kwDbmDlShutdown(gCb);
1796 kwDbmUlShutdown(gCb);
1799 kwLmmCleanGblRsrcs(gCb);
1801 KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
1803 RETVALUE(LCM_REASON_NOT_APPL);
1808 * Function processes the general control request
1810 * @param[in] gCb RLC instance control block
1811 * @param[in] cntrl RLC LM structure
1814 * -# LCM_REASON_NOT_APPL (SUCCESS)
1815 * -# LCM_REASON_INVALID_SUBACTION
1816 * -# LCM_REASON_INVALID_ACTION
1819 PRIVATE S16 kwLmmGenCntrl
1825 PRIVATE S16 kwLmmGenCntrl(gCb,cntrl)
1830 KwTrcCntrl *trcCntrl; /* trace */
1832 KwDbgCntrl *dbgCntrl; /* debug */
1834 S16 reason; /* reason for failure */
1836 TRC2(kwLmmGenCntrl);
1838 /* Validate control parameters */
1839 reason = kwLmmValidateGenCntrl (cntrl);
1841 if (reason != LCM_REASON_NOT_APPL)
1846 switch(cntrl->t.cntrl.action)
1850 switch(cntrl->t.cntrl.subAction)
1854 KW_SET_USTA_FLAG(gCb, TRUE);
1860 dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1861 KW_GET_DBG_MASK(gCb) |= dbgCntrl->dbgMask;
1867 trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1868 gCb->init.trc = TRUE;
1869 gCb->trcLen = trcCntrl->trcLen;
1870 (gCb->trcMask) |= trcCntrl->trcMask;
1878 switch(cntrl->t.cntrl.subAction)
1882 gCb->init.usta = FALSE;
1888 dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1889 KW_GET_DBG_MASK(gCb) &= ~(dbgCntrl->dbgMask);
1895 trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1896 gCb->init.trc = FALSE;
1897 gCb->trcMask &= ~(trcCntrl->trcMask);
1905 reason = kwLmmShutdown(gCb);
1914 * Bind/Unbind RLC UDX sap
1916 * @param[in] gCb RLC Instance Control Block
1917 * @param[in] cntrl RLC LM structure
1920 * -# LCM_REASON_NOT_/PPL (SUCCESS)
1921 * -# LCM_REASON_INVALID_SAP
1922 * -# LCM_REASON_INVALID_STATE
1923 * -# LCM_REASON_INVALID_ACTION
1926 PRIVATE S16 kwLmmUdxSapCntrl
1932 PRIVATE S16 kwLmmUdxSapCntrl(gCb,cntrl)
1937 TRC2(kwLmmUdxSapCntrl)
1939 #if (ERRCLASS & ERRCLS_INT_PAR)
1940 if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1942 RETVALUE(LCM_REASON_INVALID_SAP);
1945 if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
1946 (cntrl->t.cntrl.s.sapCntrl.suId >= KW_MAX_UDXSAPS))
1948 RETVALUE(LCM_REASON_INVALID_SAP);
1950 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1952 #define UDX_SAP gCb->u.ulCb->udxUlSap[cntrl->t.cntrl.s.sapCntrl.suId]
1953 #if (ERRCLASS & ERRCLS_INT_PAR)
1955 if(UDX_SAP.state == KW_SAP_NOT_CFG)
1957 RLOG0(L_ERROR,"udxUlSap not configured yet");
1958 RETVALUE(LCM_REASON_INVALID_STATE);
1960 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1962 switch(cntrl->t.cntrl.action)
1966 if(UDX_SAP.state != KW_SAP_BND)
1968 /* start timer to wait for bind confirm */
1969 kwStartTmr(gCb,(PTR)(&UDX_SAP), KW_EVT_WAIT_BNDCFM);
1970 UDX_SAP.state = KW_SAP_BINDING;
1971 KwUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
1975 /* control request received for an already bound SAP */
1976 RETVALUE(LCM_REASON_INVALID_STATE);
1982 /* make the state of UDXSAP configured but not bound */
1983 UDX_SAP.state = KW_SAP_CFG;
1984 KwUlUdxUbndReq(&(UDX_SAP.pst), UDX_SAP.spId, 0);
1988 RETVALUE(LCM_REASON_INVALID_ACTION);
1990 } /* end of switch */
1992 RETVALUE(LCM_REASON_NOT_APPL);
1997 * Bind/Unbind RLC lower sap
1999 * @param[in] gCb RLC Instance Control Block
2000 * @param[in] cntrl RLC LM structure
2002 * -# LCM_REASON_NOT_APPL (SUCCESS)
2003 * -# LCM_REASON_INVALID_SAP
2004 * -# LCM_REASON_INVALID_STATE
2005 * -# LCM_REASON_INVALID_ACTION
2008 PRIVATE S16 kwLmmLSapCntrl
2014 PRIVATE S16 kwLmmLSapCntrl(gCb,cntrl)
2019 KwRguSapCb *rguSap; /* rgu sap pointer */
2021 TRC2(kwLmmLSapCntrl)
2023 #if (ERRCLASS & ERRCLS_INT_PAR)
2025 if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
2026 (cntrl->t.cntrl.s.sapCntrl.suId >= gCb->genCfg.maxRguSaps))
2028 KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
2029 "kwLmmLSapCntrl: Invalid RGU suId\n");
2030 RETVALUE(LCM_REASON_INVALID_SAP);
2032 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2033 rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
2034 &(gCb->u.dlCb->rguDlSap[cntrl->t.cntrl.s.sapCntrl.suId]): \
2035 &(gCb->u.ulCb->rguUlSap[cntrl->t.cntrl.s.sapCntrl.suId]);
2037 #if (ERRCLASS & ERRCLS_INT_PAR)
2039 if(rguSap->state == KW_SAP_NOT_CFG)
2041 RLOG1(L_ERROR,"RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
2042 RETVALUE(LCM_REASON_INVALID_STATE);
2044 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2046 switch(cntrl->t.cntrl.action)
2050 if(rguSap->state != KW_SAP_BND)
2052 /* start timer to wait for bind confirm */
2053 kwStartTmr(gCb,(PTR)(rguSap), KW_EVT_WAIT_BNDCFM);
2054 rguSap->state = KW_SAP_BINDING;
2055 rguSap->spId = cntrl->t.cntrl.s.sapCntrl.spId;
2056 rguSap->suId = cntrl->t.cntrl.s.sapCntrl.suId;
2057 KwLiRguBndReq(&(rguSap->pst), rguSap->suId, rguSap->spId);
2061 /* control request received for an already bound SAP */
2062 RETVALUE(LCM_REASON_INVALID_STATE);
2068 /* make the state of RGUSAP is configure but not bound */
2069 rguSap->state = KW_SAP_CFG;
2070 KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
2074 RETVALUE(LCM_REASON_INVALID_ACTION);
2076 } /* end of switch */
2078 RETVALUE(LCM_REASON_NOT_APPL);
2083 * Function gather the general KWU SAP status
2085 * @param[in] gCb RLC Instance Control Block
2086 * @param[in] sta LM KWU Sap Status structure
2089 * -# LCM_REASON_NOT_APPL (SUCCESS)
2090 * -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2093 PRIVATE S16 kwLmmGetKwuSapSta
2099 PRIVATE S16 kwLmmGetKwuSapSta(gCb,sta)
2104 KwKwuSapCb *kwSapCb;
2106 TRC2(kwLmmGetKwuSapSta);
2108 #if (ERRCLASS & ERRCLS_INT_PAR)
2109 /* Validate the protocol parameters */
2110 if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
2113 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2117 /* Get Sap control block */
2118 kwSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
2119 (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + sta->spId):
2120 (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + sta->spId);
2122 sta->state = kwSapCb->state;
2124 RETVALUE(LCM_REASON_NOT_APPL);
2129 * Function gather the general RGU SAP status
2131 * @param[in] gCb RLC Instance Control Block
2132 * @param[in] sta LM RGU Sap Status structure
2134 * -# LCM_REASON_NOT_APPL (SUCCESS)
2135 * -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2138 PRIVATE S16 kwLmmGetRguSapSta
2144 PRIVATE S16 kwLmmGetRguSapSta(gCb,sta)
2149 TRC2(kwLmmGetRguSapSta);
2151 #if (ERRCLASS & ERRCLS_INT_PAR)
2152 /* Validate the protocol parameters */
2153 if((sta->suId >= KW_MAX_RGUSAPS) || (sta->suId < 0))
2155 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2159 sta->state = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
2160 gCb->u.dlCb->rguDlSap[sta->suId].state :
2161 gCb->u.ulCb->rguUlSap[sta->suId].state ;
2163 RETVALUE(LCM_REASON_NOT_APPL);
2168 * Function gather the general CKW SAP status
2170 * @param[in] gCb RLC Instance Control Block
2171 * @param[in] sta LM CKW Sap Status structure
2173 * -# LCM_REASON_NOT_APPL (SUCCESS)
2174 * -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2177 PRIVATE S16 kwLmmGetCkwCntSapSta
2183 PRIVATE S16 kwLmmGetCkwCntSapSta(gCb,sta)
2185 KwCkwCntSapSta *sta;
2188 TRC2(kwLmmGetCkwCntSapSta);
2190 #if (ERRCLASS & ERRCLS_INT_PAR)
2191 /* Validate config parameters */
2192 if ((sta->spId >= KW_MAX_CKWSAPS ) ||
2194 (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL))
2196 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2199 sta->state = gCb->u.ulCb->ckwSap.state;
2201 RETVALUE(LCM_REASON_NOT_APPL);
2207 * Gather the general statistics
2209 * @param[in] gCb RLC Instance Control Block
2210 * @param[in] sts LM general statistics structure
2211 * @param[in] action action
2213 * -# LCM_REASON_NOT_APPL (SUCCESS)
2214 * -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2217 PRIVATE S16 kwLmmGetGenSts
2224 PRIVATE S16 kwLmmGetGenSts(gCb,sts, action)
2230 TRC2(kwLmmGetGenSts);
2232 #if (ERRCLASS & ERRCLS_INT_PAR)
2233 /* Validate protocol parameters */
2234 if ((action != LKW_ZEROSTS) && (action != LKW_NOZEROSTS))
2236 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2242 if(action == LKW_ZEROSTS)
2244 KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
2247 RETVALUE(LCM_REASON_NOT_APPL);
2252 * Gather the SAP statistics
2254 * @param[in] gCb RLC Instance Control Block
2255 * @param[in] sts LM general statistics structure
2256 * @param[in] elmnt element
2257 * @param[in] action action
2260 * -# LCM_REASON_NOT_APPL (SUCCESS)
2261 * -# LCM_REASON_INVALID_PAR_VAL (FAIL)
2264 PRIVATE S16 kwLmmGetSapSts
2272 PRIVATE S16 kwLmmGetSapSts(sts, elmnt, action)
2279 TRC2(kwLmmGetSapSts);
2281 /* Validate protocol parameters */
2282 if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
2284 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2290 KwKwuSapSts *kwuSap;
2291 KwKwuSapCb *kwuSapCb;
2292 kwuSap = &sts->t.sts.s.kwuSap;
2294 /* Get Sap control block */
2295 /* kw005.201, modified the element of kwuSap from suId to spId */
2296 kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
2297 (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + kwuSap->spId):
2298 (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + kwuSap->spId);
2301 *kwuSap = kwuSapCb->sts;
2303 if (action == LKW_ZEROSTS)
2305 KW_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
2309 /* kw005.201 removed RGUSAP statistics support */
2312 KwCkwCntSts *ckwSap;
2313 ckwSap = &sts->t.sts.s.ckwSap;
2314 if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
2316 RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2319 ckwSap->statMsgs = gCb->u.ulCb->ckwSap.sts.statMsgs;
2321 if (action == LKW_ZEROSTS)
2323 KW_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (KwCkwCntSts));
2328 RETVALUE(LCM_REASON_INVALID_ELMNT);
2331 SGetDateTime(&sts->t.sts.dt);
2333 RETVALUE(LCM_REASON_NOT_APPL);
2338 * This function sends Unsolicited Status Indication to the Layer Management
2341 * @param[in] gCb RLC Instance Control Block
2342 * @param[in] category Category
2343 * @param[in] event event
2344 * @param[in] cause cause
2345 * @param[in] UeId ueId
2346 * @param[in] Qci qci
2352 PUBLIC Void kwLmmSendAlarm
2363 PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId, qci)
2372 #else /* LTE_L2_MEAS */
2374 PUBLIC Void kwLmmSendAlarm
2384 PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId)
2392 #endif /* LTE_L2_MEAS */
2394 KwMngmt usta; /* Rlc Management Structure */
2396 TRC2(kwLmmSendAlarm);
2398 if(gCb->init.usta == FALSE)
2403 usta.hdr.elmId.elmnt = STGEN;
2404 usta.hdr.entId.ent = gCb->init.ent;
2405 usta.hdr.entId.inst = gCb->init.inst;
2407 /* fill in the event and category */
2408 usta.t.usta.alarm.category = category;
2409 usta.t.usta.alarm.event = event;
2410 usta.t.usta.alarm.cause = cause;
2412 /* set the suId and ueId */
2413 usta.t.usta.ueId = ueId;
2414 usta.t.usta.suId = suId;
2415 /* kw005.201 added support for L2 Measurement */
2417 if(event == LKW_EVT_MEAS_HALT)
2419 usta.t.usta.qci = qci;
2421 #endif /* LTE_L2_MEAS */
2422 /* update the date and time */
2423 (Void) SGetDateTime(&usta.t.usta.alarm.dt);
2425 KwMiLkwStaInd(&(gCb->init.lmPst), &usta);
2433 * This function sends trace indication to LM
2435 * @param[in] gCb RLC Instance Control Block
2436 * @param[in] event event
2437 * @param[in] mBuf meessage buffer
2444 PUBLIC S16 kwLmmSendTrc
2451 PUBLIC S16 kwLmmSendTrc(gCb,event, mBuf)
2457 KwMngmt trc; /* RLC management control block */
2466 RLOG2(L_DEBUG, "kwLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
2470 cmMemset((U8 *)&trc, 0, sizeof(KwMngmt));
2472 pst = gCb->init.lmPst;
2474 trc.t.trc.event = event;
2475 SGetDateTime(&trc.t.trc.dt);
2476 trc.cfm.status = LCM_PRIM_OK;
2477 trc.cfm.reason = LCM_REASON_NOT_APPL;
2481 /* Check if the whole buffer is to be sent in Trace indication */
2482 if(gCb->trcLen == LKW_FULL_TRACE)
2484 if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2487 /* rg005.201 removed SPutSBuf on error */
2488 RLOG0(L_ERROR,"SCpyMsgMsg Failed");
2491 /* Send Trace Indication to Layer manager */
2492 KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2494 /* check if only a specified number of bytes are to be sent */
2495 else if(gCb->trcLen > 0)
2497 /* Get the length of the recvd message buffer */
2498 if (SFndLenMsg(mBuf, &bufLen) != ROK)
2500 RLOG0(L_ERROR,"SFndLenMsg Failed");
2503 /* Check if the recvd buffer size is less than request trace len */
2504 if(bufLen < gCb->trcLen)
2506 /* Copy the whole of the recvd buffer in trace indication */
2508 if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2511 RLOG0(L_ERROR,"SCpyMsgMsg Failed");
2515 /* Send Trace Indication to Layer manager */
2516 KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2520 /* if the recvd buffer size is greater than request trace len */
2521 /* Get a temporary buffer to store the msg */
2522 KW_ALLOC(gCb,tempBuf, gCb->trcLen);
2524 #if (ERRCLASS & ERRCLS_INT_PAR)
2525 if(tempBuf == NULLP)
2527 (Void) SPutSMem(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb));
2529 RLOG0(L_FATAL,"Memory Allocation failed");
2530 RETVALUE(LCM_REASON_MEM_NOAVAIL);
2532 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2534 /* Copy trcLen nos of bytes from the recvd message */
2535 if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)
2537 RLOG0(L_ERROR,"SCpyMsgFix Failed");
2541 if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
2543 RLOG0(L_FATAL,"Memory Allocation failed");
2546 /* Copy the tempBuf data to dst mBuf */
2547 if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
2549 RLOG0(L_ERROR,"SCpyMsgFix Failed");
2553 /* Free the memory allocated for tempBuf */
2554 KW_FREE(gCb,tempBuf, gCb->trcLen);
2555 /* Send Trace Indication to Layer manager */
2556 KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2562 KwMiLkwTrcInd(&pst, &trc, mBuf);
2571 * Activate Task - timer
2574 * Invoked by system services to activate a task with a timer tick.
2576 * @param[in] ent entity
2577 * @param[in] inst instance
2586 PUBLIC S16 kwActvTmr
2592 PUBLIC S16 kwActvTmr(ent,inst)
2600 if (inst >= KW_MAX_RLC_INSTANCES)
2604 gCb = KW_GET_KWCB(inst);
2605 cmPrcTmr(&(gCb->kwTqCp), gCb->kwTq, (PFV) kwTmrExpiry);
2608 } /* end of kwActvTmr */
2611 /********************************************************************30**
2614 **********************************************************************/