Addressed comments in lower Mac
[o-du/l2.git] / src / 5gnrmac / rg_l2m.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may not use this file except in compliance with the License.           #
7 #   You may obtain a copy of the License at                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
11 #   Unless required by applicable law or agreed to in writing, software        #
12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
14 #   See the License for the specific language governing permissions and        #
15 #   limitations under the License.                                             #
16 ################################################################################
17 *******************************************************************************/
18
19 /************************************************************************
20  
21      Name:     LTE-MAC layer
22   
23      Type:     C source file
24   
25      Desc:     C source code for  L2 Measurements in MAC
26   
27      File:     rg_l2m.c
28   
29 **********************************************************************/
30
31 /** @file rg_l2m.c
32 @brief This file implements the schedulers main access to MAC layer code.
33 */
34
35 /* header include files -- defines (.h) */
36 #include "envopt.h"        /* environment options */
37 #include "envdep.h"        /* environment dependent */
38 #include "envind.h"        /* environment independent */
39 #include "gen.h"           /* general layer */
40 #include "ssi.h"           /* system service interface */
41 #include "cm_hash.h"       /* common hash list */
42 #include "cm_llist.h"      /* common linked list library */
43 #include "cm_err.h"        /* common error */
44 #include "cm_lte.h"        /* common LTE */
45 #include "lrg.h"
46 #include "crg.h"        
47 #include "rgr.h"
48 #include "rgu.h"           
49 #include "tfu.h"
50 #include "rg_env.h"
51 #include "rg_err.h"
52 #include "rg_sch_inf.h"
53 #include "rg.h"
54
55 /* header/extern include files (.x) */
56 #include "gen.x"           /* general layer typedefs */
57 #include "ssi.x"           /* system services typedefs */
58 #include "cm5.x"           /* common timers */
59 #include "cm_hash.x"       /* common hash list */
60 #include "cm_lib.x"        /* common library */
61 #include "cm_llist.x"      /* common linked list */
62 #include "cm_mblk.x"       /* memory management */
63 #include "cm_tkns.x"       /* common tokens */
64 #include "cm_lte.x"       /* common tokens */
65 #include "rgu.x"           /* RGU types */
66 #include "tfu.x"           /* TFU types */
67 #include "lrg.x"           /* layer management typedefs for MAC */
68 #include "rgr.x"           /* layer management typedefs for MAC */
69 #include "crg.x"           /* layer management typedefs for MAC */
70 #include "rg_sch_inf.x"    /* typedefs for Scheduler */
71 #include "rg_prg.x"        /* typedefs for PRG interface */
72 #include "du_app_mac_inf.h"
73 #include "rg.x"            /* MAC types */
74
75 #ifdef LTE_L2_MEAS
76 static const char* RLOG_MODULE_NAME="MAC";
77 static int RLOG_FILE_ID=183;
78 static int RLOG_MODULE_ID=4096;
79 #endif 
80
81 /* local defines */
82 #ifdef LTE_L2_MEAS
83 PRIVATE S16 rgL2mInsertMeasCb ARGS((
84          RgCellCb       *cell,
85          RgL2MeasCb     *measCb,
86          RgInfL2MeasReq *measInfo ));
87
88 PRIVATE RgL2MeasCb * rgL2mAllocMeasCb ARGS((
89          RgCellCb       *cell,
90          RgInfL2MeasReq *measInfo,
91          RgErrInfo      *err));
92
93 /* Function definitions */
94
95 /** @brief This function creates the measCb
96  *
97  * @details
98  *
99  *     Function: rgL2mCreateMeasCb
100  *         Processing steps:
101  *         - Check the measType
102  *         - Create measCb for every qci
103  *
104  * @param  [in] RgCellCb       *cell
105  * @param  [in] RgInfL2MeasReq *measInfo
106  * @param  [in] U8             measType
107  * @param  [out] RgErrInfo      *err
108  * @return  S16
109  *      -# ROK 
110  *      -# RFAILED 
111  *
112  */
113 #ifdef ANSI
114 PUBLIC S16 rgL2mCreateMeasCb 
115 (
116 RgCellCb       *cell,
117 RgInfL2MeasReq *measInfo, 
118 U8              measType,
119 RgErrInfo      *err
120 )
121 #else
122 PUBLIC S16 rgL2mCreateMeasCb(cell, measInfo, measType, err)
123 RgCellCb       *cell;
124 RgInfL2MeasReq *measInfo; 
125 U8              measType;
126 RgErrInfo      *err;
127 #endif    
128 {
129   // Inst    inst = cell->macInst - RG_INST_START;
130    U32     idx;
131    RgL2MeasCb       *measCb = NULLP;
132    U8            qciVal = 0;
133
134    UNUSED(measType);
135    UNUSED(err);
136
137    TRC3(rgL2mCreateMeasCb)
138
139       if ((measCb = rgL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
140       {
141          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Allocation of RgL2MeasCb failed");
142          RETVALUE(RFAILED);
143       }
144    //Memcpy is already done in rgL2mAllocMeasCb
145    /*cmMemcpy((U8 *)&measCb->measReq, (CONSTANT U8 *)measInfo,\
146      sizeof(RgInfL2MeasReq));*/
147    rgL2mInsertMeasCb(cell, measCb, measInfo);
148    measCb->measReq.timePrd = measInfo->timePrd;
149
150    if(measInfo->timePrd == 0)
151    {
152       cell->sndL2Meas = FALSE;
153    }
154
155    for(idx = 0; idx < measInfo->t.prbReq.numQci; idx++)
156    {
157       if(measInfo->timePrd == 0)
158       {
159          qciVal = measInfo->t.prbReq.qci[idx];
160          cell->qciArray[qciVal].qci = qciVal;
161       }
162       cell->qciArray[measInfo->t.prbReq.qci[idx]].mask = TRUE;
163    }
164    RETVALUE(ROK);
165 } /* rgL2mCreateMeasCb */
166
167
168 /**
169  * @brief Layer Manager Measurement request handler. 
170  *
171  * @details
172  *
173  *     Function : rgL2mMeasReq
174  *     
175  *     This function handles  measurement request received at MAC
176  *     from the Scheduler.
177  *     -# Measurement request will be stored in the list in descending order of
178  *     there time period.
179  *     
180  *  @param[in]  Pst *pst, the post structure     
181  *  @param[in]  RgInfL2MeasReq *measInfo, the measurement request structure
182  *  @param[out] RgErrInfo   *err, error information
183  *  @return  S16
184  *      -# ROK
185  **/
186 #ifdef ANSI
187 PUBLIC S16 rgL2mMeasReq 
188 (
189 RgCellCb       *cell,
190 RgInfL2MeasReq *measInfo,
191 RgErrInfo      *err
192 )
193 #else
194 PUBLIC S16 rgL2mMeasReq(cell, measInfo, err)
195 RgCellCb       *cell;
196 RgInfL2MeasReq *measInfo; 
197 RgErrInfo      *err;
198 #endif    
199 {
200    S16  ret=RFAILED;
201
202    TRC3(rgL2mMeasReq)
203    /* Creaet MeasCb Insert in cell->l2mList and return*/
204    if ( (ret = rgL2mCreateMeasCb(cell, measInfo,
205                LRG_L2MEAS_AVG_PRB_PER_QCI_UL, err)) != ROK)
206    {
207       /* Clear Downlink MeasCb created Above If exists*/
208       RETVALUE(ret);
209    }
210    RETVALUE(ROK);
211 } /* rgL2mMeasReq */
212 /** @brief This function sends the measurement confirm
213  *  from mac to scheduler
214  *
215  * @details
216  *
217  *     Function: rgSndL2MeasCfm
218  *
219  * @param  [in] RgCellCb          *cell
220  * @param  [in] RgInfL2MeasCfm    *measCfm
221  */
222 #ifdef ANSI
223 PRIVATE Void rgSndL2MeasCfm
224 (
225 RgCellCb          *cell, 
226 RgInfL2MeasCfm    *measCfm
227 )
228 #else
229 PRIVATE Void rgSndL2MeasCfm (cell, measCfm)
230 RgCellCb          *cell; 
231 RgInfL2MeasCfm    *measCfm;   
232 #endif
233 {
234    Pst             pst;
235    Inst            macInst = cell->macInst - RG_INST_START;
236    TRC3(rgSndL2MeasCfm)
237
238       cmMemset((U8 *)&pst, 0, sizeof(Pst));
239    rgGetPstToInst(&pst,macInst, cell->schInstMap.schInst);
240    RgMacSchL2Meas(&pst, measCfm);
241
242    RETVOID;
243 }/* rgSndL2MeasCfm */
244
245 /** @brief This function sends the measurement stop confirm
246  *  from mac to scheduler
247  *
248  * @details
249  *
250  *     Function: rgSndL2MeasStopCfm
251  *
252  * @param  [in] RgCellCb          *cell
253  * @param  [in] RgInfL2MeasCfm    *measCfm
254  */
255 #ifdef ANSI
256 PRIVATE Void rgSndL2MeasStopCfm
257 (
258 RgCellCb          *cell,
259 RgInfL2MeasCfm    *measCfm
260 )
261 #else
262 PRIVATE Void rgSndL2MeasStopCfm (cell, measCfm)
263 RgCellCb          *cell;
264 RgInfL2MeasCfm    *measCfm;
265 #endif
266 {
267    Pst             pst;
268    Inst            macInst = cell->macInst - RG_INST_START;
269
270    TRC3(rgSndL2MeasStopCfm)
271       cmMemset((U8 *)&pst, 0, sizeof(Pst));
272    rgGetPstToInst(&pst,macInst, cell->schInstMap.schInst);
273    RgMacSchL2MeasStop(&pst, measCfm);
274
275    RETVOID;
276 }/* rgSndL2MeasStopCfm */
277
278 /**
279  * @brief  L2 Measurement request handler.This function shall be called by
280  *  scheduler to calculate average PRB usage Per Qci in Uplink
281  *
282  * @details
283  *
284  *     Function : RgSchMacL2MeasReq
285  *     
286  *  @param[in]  Pst *pst, the post structure     
287  *  @param[in]  RgInfL2MeasReq *measInfo, L2 Measurement req structure
288  *  @return  S16
289  *      -# ROK
290  *      -# RFAILED
291  **/
292 #ifdef ANSI
293 PUBLIC S16 RgSchMacL2MeasReq
294 (
295 Pst               *pst,          /* post structure  */
296 RgInfL2MeasReq    *measInfo      /* Meas Req Info */
297 )
298 #else
299 PUBLIC S16 RgSchMacL2MeasReq(pst, measInfo)
300 Pst               *pst;          /* post structure  */
301 RgInfL2MeasReq    *measInfo;      /* Meas Req Info */
302 #endif    
303 {
304    Inst            inst;
305    RgCellCb        *cellCb = NULLP;
306    RgErrInfo       err;
307    S16             ret = ROK;
308    RgInfL2MeasCfm   measCfm;
309
310    TRC3(RgSchMacL2MeasReq)
311
312
313    RG_IS_INST_VALID(pst->dstInst);
314    inst   = pst->dstInst - RG_INST_START;
315    cellCb = rgCb[inst].cell;
316    /* Get the  cell using cellId */
317    if ((cellCb == NULLP) ||
318        (cellCb->cellId != measInfo->cellId))
319    {
320       RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,"unable to get the cellCb");
321       RETVALUE(RFAILED);
322    }
323    /* Call L2M Function to store Meas req */
324    ret = rgL2mMeasReq(cellCb, measInfo, &err);
325    if (ret != ROK)
326    {
327       cmMemset((U8 *)&measCfm, 0, sizeof(RgInfL2MeasCfm));
328       measCfm.transId     = measInfo->transId;
329       measCfm.cellId      = measInfo->cellId;
330       measCfm.measType    = measInfo->measType;
331       measCfm.cfm.reason   = LCM_REASON_INVALID_PAR_VAL;
332       measCfm.cfm.status  = LCM_PRIM_NOK;
333       rgSndL2MeasCfm(cellCb, &measCfm);
334       RLOG_ARG2(L_ERROR,DBG_CELLID,measInfo->cellId,
335                "Meas req Failed  errType(%d) errCause(%d)",
336                err.errType, err.errCause);
337       RETVALUE(RFAILED);
338    }
339    RETVALUE(ret);
340 } /* -- RgSchMacL2MeasReq-- */
341
342 /**
343  * @brief  L2 Measurement request handler.This function shall be called by
344  *         sch to to stop l2 measurement in MAC,
345  *
346  * @details
347  *
348  *     Function : RgSchMacL2MeasStopReq
349  *     
350  *  @param[in]  Pst *pst, the post structure     
351  *  @param[in]  RgInfL2MeasReq *measInfo, L2 Measurement req structure
352  *  @return  S16
353  *      -# ROK
354  *      -# RFAILED
355  **/
356 #ifdef ANSI
357 PUBLIC S16 RgSchMacL2MeasStopReq
358 (
359 Pst               *pst,          /* post structure  */
360 RgInfL2MeasStopReq *measInfo      /* Meas Req Info */
361 )
362 #else
363 PUBLIC S16 RgSchMacL2MeasStopReq(pst, measInfo)
364 Pst               *pst;          /* post structure  */
365 RgInfL2MeasStopReq *measInfo;      /* Meas Req Info */
366 #endif
367 {
368    S16             ret = ROK;   
369    CmLList         *node   = NULLP;
370    RgL2MeasCb      *measCb = NULLP;
371    U8               idx;
372    U8               qciVal;
373    Inst             inst;
374    RgCellCb        *cellCb = NULLP;
375
376    RgInfL2MeasCfm  measCfm;
377
378    TRC3(RgSchMacL2MeasStopReq)
379
380
381    RG_IS_INST_VALID(pst->dstInst);
382    inst   = pst->dstInst - RG_INST_START;
383    cellCb = rgCb[inst].cell;
384       /* Get the  cell using cellId */
385    if ((cellCb == NULLP) ||
386        (cellCb->cellId != measInfo->cellId))
387    {
388       
389       RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
390             "Unable to get the cellCb");
391       RETVALUE(RFAILED);
392    }
393    node = cellCb->l2mList.first; 
394    while(node != NULLP)
395    {
396       measCb = (RgL2MeasCb *)(node)->node;
397       node = (node)->next;
398       /*L2 Meas off for qci in cell */
399       for(idx = 0; idx < measCb->measReq.t.prbReq.numQci; idx++)
400       {
401          qciVal = measCb->measReq.t.prbReq.qci[idx];
402          cellCb->qciArray[qciVal].mask = FALSE;
403       }
404       cmLListDelFrm(&cellCb->l2mList, &measCb->measLnk);
405       rgFreeSBuf(inst,(Data**)&measCb, sizeof(RgL2MeasCb));
406    }
407    cmMemset((U8 *)&measCfm, 0, sizeof(RgInfL2MeasCfm));
408    measCfm.transId     = measInfo->transId;
409    measCfm.cellId      = measInfo->cellId;
410    measCfm.measType    = measInfo->measType;
411    measCfm.cfm.status  = LCM_PRIM_OK;
412    rgSndL2MeasStopCfm(cellCb, &measCfm);
413    RETVALUE(ret);
414 } /* -- RgSchMacL2MeasStopReq-- */
415
416 /**
417  * @brief  L2 Measurement request handler.This function shall be called by
418  *  scheduler for  sending L2 meas 
419  *
420  * @details
421  *
422  *     Function : RgSchMacL2MeasSendReq
423  *     
424  *  @param[in]  Pst *pst, the post structure     
425  *  @param[in]  RgInfL2MeasReq *measInfo, L2 Measurement req structure
426  *  @return  S16
427  *      -# ROK
428  *      -# RFAILED
429  **/
430 #ifdef ANSI
431 PUBLIC S16 RgSchMacL2MeasSendReq
432 (
433 Pst               *pst,          /* post structure  */
434 RgInfL2MeasSndReq *measInfo      /* Meas Req Info */
435 )
436 #else
437 PUBLIC S16 RgSchMacL2MeasSendReq(pst, measInfo)
438 Pst               *pst;          /* post structure  */
439 RgInfL2MeasSndReq *measInfo;      /* Meas Req Info */
440 #endif
441 {
442    Inst            inst;
443    RgCellCb       *cellCb = NULLP;
444    S16             ret    = ROK;
445
446    TRC3(RgSchMacL2MeasSendReq)
447
448
449    RG_IS_INST_VALID(pst->dstInst);
450    inst   = pst->dstInst - RG_INST_START;
451    cellCb = rgCb[inst].cell;
452       /* Get the  cell using cellId */
453    if ((cellCb == NULLP) ||
454        (cellCb->cellId != measInfo->cellId))
455    {
456       
457       RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
458             "Unable to get the cellCb");
459       RETVALUE(RFAILED);
460    }
461    /*set sndL2Meas as applicatoin sent l2 meas info request*/
462    cellCb->sndL2Meas = TRUE;
463
464    RETVALUE(ret);
465 }/*RgSchMacL2MeasSendReq*/ 
466
467 /** @brief This function inserts the MeasCb in to data base
468  *
469  * @details
470  *
471  *     Function: rgL2mInsertMeasCb
472  *
473  * @param  [in] RgCellCb       *cell
474  * @param  [in] RgL2MeasCb     *measCb
475  * @param  [in] RgInfMeasReq   *measInfo
476  * @return  S16
477  *      -# ROK 
478  *      -# RFAILED 
479  */
480 #ifdef ANSI
481 PRIVATE S16 rgL2mInsertMeasCb
482 (
483 RgCellCb       *cell,
484 RgL2MeasCb     *measCb,
485 RgInfL2MeasReq *measInfo
486 )
487 #else
488 PRIVATE S16 rgL2mInsertMeasCb(cell, measCb, measInfo)
489 RgCellCb       *cell;
490 RgL2MeasCb     *measCb;
491 RgInfL2MeasReq *measInfo;
492 #endif
493 {
494    CmLList   *lnk, *node;
495    RgL2MeasCb  *oldMeasCb;
496    U16         diffTime;
497
498    TRC3(rgL2mInsertMeasCb)
499
500       /* 
501        * 1. Check if l2mList has any entries.
502        * 2. If yes 
503        *       1. Take the first entrie's time period and find the diff with
504        *       cell->crntTime.
505        *       2. If the diff is > measInfo->timePeriod then insert before this
506        *       entry.
507        *       3. Else take the next entry in list
508        *       4. If reached without adding to list . Append at the end of list.
509        * 3. If no entries in l2mList add at the first.
510        */
511       lnk = cell->l2mList.first;
512
513    node = &measCb->measLnk;
514    node->node = (PTR)measCb;
515    while(lnk != NULLP )
516    {
517       oldMeasCb = (RgL2MeasCb *)lnk->node;
518       diffTime = (oldMeasCb->measReq.timePrd - 
519             (RG_CALC_SF_DIFF(cell->crntTime, oldMeasCb->startTime)));
520       if (diffTime > measInfo->timePrd)
521       {
522          cell->l2mList.crnt = lnk;
523          cmLListInsCrnt(&(cell->l2mList), node);
524          RETVALUE(ROK);
525       }
526       else
527       {
528          lnk = lnk->next;
529       }
530    }  /* End of While */
531
532    cmLListAdd2Tail(&(cell->l2mList), node);
533    RETVALUE(ROK);
534 } /* rgL2mInsertMeasCb */
535
536 /** @brief This function allocates memory from the heap
537  *
538  * @details
539  *
540  *     Function: rgL2mAllocMeasCb
541  *
542  * @param  [in] RgCellCb       *cell
543  * @param  [in] RgInfL2MeasReq *measInfo
544  * @param  [out] RgErrInfo      *err
545  * @return  RgSchL2MeasCb *
546  */
547 #ifdef ANSI
548 PRIVATE RgL2MeasCb * rgL2mAllocMeasCb
549 (
550 RgCellCb       *cell,
551 RgInfL2MeasReq *measInfo,
552 RgErrInfo      *err
553 )
554 #else
555 PRIVATE RgL2MeasCb * rgL2mAllocMeasCb(cell, measInfo, err)
556 RgCellCb       *cell;
557 RgInfL2MeasReq *measInfo;
558 RgErrInfo      *err;
559 #endif
560 {
561    RgL2MeasCb       *measCb = NULLP;
562    Inst             inst = cell->macInst - RG_INST_START;
563
564    TRC3(rgL2mAllocMeasCb)
565
566       if((rgAllocSBuf(inst,(Data **)&(measCb),
567                   sizeof(RgL2MeasCb))) == RFAILED)
568       {
569          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
570                    "Allocation of RgL2MeasCb failed");
571          err->errType  = RGERR_L2M_MEASREQ;
572          err->errCause = RGERR_RAM_MEM_EXHAUST;
573          RETVALUE(NULLP);
574       }
575    cmMemcpy((U8 *)&measCb->measReq, (U8 *)measInfo, sizeof(RgInfL2MeasReq));
576    RGCPYTIMEINFO(cell->crntTime, measCb->startTime);
577
578    RETVALUE(measCb);
579 } /* rgL2mAllocMeasCb */
580
581
582 /**
583  * @brief This function calculates the measurement for measType 
584  * LRG_L2MEAS_AVG_PRB_PER_QCI_UL and send the end result to the 
585  * MAC Scheduler.
586  *
587  * @details
588  *
589  *  Function : rgL2Meas
590  *     
591  *  @param[in] RgCellCb  *cell
592  *  @return  S16
593  *      -# ROK
594  *      -# RFAILED
595  **/
596 #ifdef ANSI
597 PUBLIC S16 rgL2Meas
598 (
599 RgCellCb  *cell
600 )
601 #else
602 PUBLIC S16 rgL2Meas(cell)
603 RgCellCb  *cell;
604 #endif
605 {
606    CmLList         *node   = NULLP;
607    RgL2MeasCb      *measCb = NULLP;
608    RgInfL2MeasCfm  measCfm;
609    U8              idx = 0;
610    U8              qciVal = 0;
611    U32             measPrd; /*LTE_L2_MEAS_PHASE2*/
612    CmLteTimingInfo  crntTime;
613    Inst           inst = cell->macInst - RG_INST_START;
614    
615    TRC3(rgL2Meas)
616
617    node = cell->l2mList.first;
618
619    while(node != NULLP)
620    {
621       measCb = (RgL2MeasCb *)node->node;
622       node = node->next;
623       crntTime = cell->crntTime;
624
625       if(cell->crntTime.sfn == 0 && (cell->crntTime.slot % RG_NUM_SUB_FRAMES) == 0)
626       {
627          measCb->sfnCycle++;
628       }
629
630       measPrd = RG_CALC_SFN_SF_DIFF(cell->crntTime, 
631                         measCb->sfnCycle, measCb->startTime);
632       
633       /*LTE_L2_MEAS_PHASE2*/
634       if (cell->sndL2Meas || measPrd == measCb->measReq.timePrd)
635       {
636          cmMemset((U8 *)&measCfm, 0, sizeof(RgInfL2MeasCfm));
637          for(idx = 0; idx < measCb->measReq.t.prbReq.numQci; idx++)
638          {
639             qciVal = measCb->measReq.t.prbReq.qci[idx];
640             measCfm.u.prbCfm.prbUsage[idx].qciValue = qciVal;
641
642             measCfm.transId  = measCb->measReq.transId;
643             measCfm.measType = measCb->measReq.measType;
644             measCfm.cellId    = measCb->measReq.cellId;
645
646             measCfm.u.prbCfm.prbUsage[idx].prbUsage = 
647                cell->qciArray[qciVal].prbCount;
648
649             cell->qciArray[qciVal].prbCount = 0;
650             measCfm.u.prbCfm.numQci++;
651             if(measCb->measReq.timePrd > 0)
652             {
653                cell->qciArray[qciVal].mask = FALSE;
654             }
655          }
656          rgSndL2MeasCfm(cell, &measCfm);
657
658          if(measCb->measReq.timePrd > 0) 
659          {
660             cmLListDelFrm(&cell->l2mList, &measCb->measLnk);
661             rgFreeSBuf(inst,(Data**)&measCb, sizeof(RgL2MeasCb));
662          }
663          else /*if meas period is 0 then do not delette meascb , just reset l2 cntrs value to 0*/
664          { 
665             measCb->startTime = crntTime;
666             measCb->measReq.timePrd = 0;
667             cell->sndL2Meas = FALSE;
668          }
669          continue;
670       } 
671    }
672    RETVALUE(ROK);
673 } /* rgL2MEas */
674
675 #endif /* LTE_L2_MEAS */
676 /**********************************************************************
677  
678          End of file
679 **********************************************************************/