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 /************************************************************************
25 Desc: C source code for L2 Measurement fucntions
29 **********************************************************************/
31 /** @file rg_sch_l2m.c
32 @brief This file implements the L2 Measurement feature code.
35 /* header include files -- defines (.h) */
36 #include "common_def.h"
43 #include "rg_sch_cmn.h"
44 #include "rg_sch_inf.h" /* typedefs for Scheduler */
45 #include "rg_sch_err.h"
46 #include "rl_interface.h"
47 #include "rl_common.h"
49 /* header/extern include files (.x) */
50 #include "tfu.x" /* TFU types */
51 #include "lrg.x" /* layer management typedefs for MAC */
52 #include "rgr.x" /* layer management typedefs for MAC */
53 #include "rgm.x" /* layer management typedefs for MAC */
54 #include "rg_sch_inf.x" /* typedefs for Scheduler */
55 #include "rg_sch.x" /* typedefs for Scheduler */
56 #include "rg_sch_cmn.x" /* typedefs for Scheduler */
61 static const char* RLOG_MODULE_NAME="MAC";
62 static int RLOG_MODULE_ID=4096;
63 static int RLOG_FILE_ID=166;
65 static S16 rgSchL2mInsertMeasCb ARGS((
67 RgSchL2MeasCb *measCb,
68 LrgSchMeasReqInfo *measInfo ));
70 static RgSchL2MeasCb * rgSchL2mAllocMeasCb ARGS((
72 LrgSchMeasReqInfo *measInfo,
75 /* Function definitions */
77 /** @brief This function fills the L2 measurement confirm structure
81 * Function: rgSchFillL2MeasCfm
83 * @param [in] RgSchCellCb *cell
84 * @param [in] RgSchL2MeasCb *measCb
85 * @param [out] LrgSchMeasCfmInfo *measCfm
86 * @param [in] measTime
90 S16 rgSchFillL2MeasCfm
93 RgSchL2MeasCb *measCb,
94 LrgSchMeasCfmInfo *cfm,
98 S16 rgSchFillL2MeasCfm(cell, measCb, cfm, measTime)
100 RgSchL2MeasCb *measCb;
101 LrgSchMeasCfmInfo *cfm;
106 LrgSchMeasReqInfo *measInfo;
110 measInfo = &measCb->measReq;
112 cfm->hdr.transId = measInfo->hdr.transId;
113 cfm->measType = measInfo->measType;
114 cfm->cellId = measInfo->cellId;
115 cfm->cfm.status = LCM_PRIM_OK;
116 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_DL) &&
119 cfm->avgPrbDl.prbPerc = ((cell->avgPrbDl.prbCount * 100) /
121 /* Resetting the prbCount to 0, fix for ccpu00125002 */
122 cell->avgPrbDl.prbCount = 0;
124 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL) &&
127 cfm->avgPrbUl.prbPerc = ((cell->avgPrbUl.prbCount * 100) /
129 /* Resetting the prbCount to 0, fix for ccpu00125002 */
130 cell->avgPrbUl.prbCount = 0;
132 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL) &&
135 cfm->avgPrbQciDlCfm.numQci = measCb->measReq.avgPrbQciDl.numQci;
136 for(idx = 0; idx < measCb->measReq.avgPrbQciDl.numQci; idx++)
138 qciVal = measCb->measReq.avgPrbQciDl.qci[idx];
139 cfm->avgPrbQciDlCfm.prbPercQci[idx].prbPercQci =
140 ((cell->qciArray[qciVal].dlPrbCount * 100) /
142 cfm->avgPrbQciDlCfm.prbPercQci[idx].qciValue = qciVal;
143 cell->qciArray[qciVal].dlPrbCount = 0;
146 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL) &&
149 cfm->avgPrbQciUlCfm.numQci = measCb->measReq.avgPrbQciUl.numQci;
150 for(idx = 0; idx < measCb->measReq.avgPrbQciUl.numQci; idx++)
152 cfm->avgPrbQciUlCfm.prbPercQci[idx].qciValue =
153 measCb->avgPrbQciUl.prbUsage[idx].qciValue;
155 if(measCb->avgPrbQciUl.prbUsage[idx].prbUsage > measCb->ulTotalBw)
157 measCb->avgPrbQciUl.prbUsage[idx].prbUsage = measCb->ulTotalBw;
160 cfm->avgPrbQciUlCfm.prbPercQci[idx].prbPercQci =
161 ((measCb->avgPrbQciUl.prbUsage[idx].prbUsage * 100) /
165 if(measCb->measReq.measType & LRG_L2MEAS_RA_PREAMBLE)
167 cfm->raPrmbsCfm.dedPreambles = cell->raPrmbs.dedPream;
168 cfm->raPrmbsCfm.randSelPreLowRange = cell->raPrmbs.preamGrpA;
169 cfm->raPrmbsCfm.randSelPreHighRange = cell->raPrmbs.preamGrpB;
170 cell->raPrmbs.dedPream = 0;
171 cell->raPrmbs.preamGrpA = 0;
172 cell->raPrmbs.preamGrpB = 0;
174 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
176 cfm->numUeQciDlCfm.numQci = measInfo->nmbActvUeQciDl.numQci;
177 sampOc = (measTime / measInfo->nmbActvUeQciDl.sampPrd);
181 if (measCb->measReq.nmbActvUeQciDl.numQci)
183 for(idx = 0; idx < measCb->measReq.nmbActvUeQciDl.numQci; idx++)
185 qciVal = measCb->measReq.nmbActvUeQciDl.qci[idx];
187 cell->qciArray[qciVal].dlTotal_UeCount +=
188 cell->qciArray[qciVal].dlUeCount;
189 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci =
190 cell->qciArray[qciVal].dlTotal_UeCount / sampOc;
191 cfm->numUeQciDlCfm.numActvUeQci[idx].qciValue = qciVal;
193 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
194 "L2_MEAS:CFM DL QCI %u TOTAL Count %lu Active UE %d ",
195 qciVal,cell->qciArray[qciVal].dlTotal_UeCount,
196 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci);
198 cell->qciArray[qciVal].dlTotal_UeCount = 0;
204 for(qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
207 cell->qciArray[qciVal].dlTotal_UeCount +=
208 cell->qciArray[qciVal].dlUeCount;
209 if (cell->qciArray[qciVal].dlTotal_UeCount)
211 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci =
212 cell->qciArray[qciVal].dlTotal_UeCount / sampOc;
213 cfm->numUeQciDlCfm.numActvUeQci[idx].qciValue = qciVal;
215 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
216 "L2_MEAS:CFM DL QCI %u TOTAL Count %lu Active UE %d ",
217 qciVal,cell->qciArray[qciVal].dlTotal_UeCount,
218 cfm->numUeQciDlCfm.numActvUeQci[idx].numActvUeQci);
220 cell->qciArray[qciVal].dlTotal_UeCount = 0;
224 cfm->numUeQciDlCfm.numQci = idx;
228 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
230 cfm->numUeQciUlCfm.numQci = measInfo->nmbActvUeQciUl.numQci;
231 sampOc = (measTime / measInfo->nmbActvUeQciUl.sampPrd);
236 if (measCb->measReq.nmbActvUeQciUl.numQci)
238 for(idx = 0; idx < measCb->measReq.nmbActvUeQciUl.numQci; idx++)
240 cell->qciArray[qciVal].ulTotal_UeCount +=
241 cell->qciArray[qciVal].ulUeCount;
242 qciVal = measCb->measReq.nmbActvUeQciUl.qci[idx];
243 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci =
244 cell->qciArray[qciVal].ulTotal_UeCount/ sampOc;
245 cfm->numUeQciUlCfm.numActvUeQci[idx].qciValue = qciVal;
247 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
248 "L2_MEAS:CFM UL QCI %d TOTAL Count %lu Active UE %d ",
249 qciVal,cell->qciArray[qciVal].ulTotal_UeCount,
250 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci);
252 cell->qciArray[qciVal].ulTotal_UeCount = 0;
258 for(qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
260 cell->qciArray[qciVal].ulTotal_UeCount +=
261 cell->qciArray[qciVal].ulUeCount;
262 if (cell->qciArray[qciVal].ulTotal_UeCount)
264 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci =
265 cell->qciArray[qciVal].ulTotal_UeCount/ sampOc;
266 cfm->numUeQciUlCfm.numActvUeQci[idx].qciValue = qciVal;
268 RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
269 "L2_MEAS:CFM UL QCI %d TOTAL Count %lu Active UE %d ",
270 qciVal,cell->qciArray[qciVal].ulTotal_UeCount,
271 cfm->numUeQciUlCfm.numActvUeQci[idx].numActvUeQci);
273 cell->qciArray[qciVal].ulTotal_UeCount = 0;
277 cfm->numUeQciUlCfm.numQci = idx;
281 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
283 cfm->tbTransDlTotalCnt = cell->dlUlTbCnt.tbTransDlTotalCnt;
284 cell->dlUlTbCnt.tbTransDlTotalCnt = 0;
286 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
288 cfm->tbTransDlFaulty = cell->dlUlTbCnt.tbTransDlFaulty;
289 cell->dlUlTbCnt.tbTransDlFaulty = 0;
291 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
293 cfm->tbTransUlTotalCnt = cell->dlUlTbCnt.tbTransUlTotalCnt;
294 cell->dlUlTbCnt.tbTransUlTotalCnt = 0;
296 if(measCb->measReq.measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
298 cfm->tbTransUlFaulty = cell->dlUlTbCnt.tbTransUlFaulty;
299 cell->dlUlTbCnt.tbTransUlFaulty = 0;
302 measCb->dlTotalBw = 0;
303 measCb->ulTotalBw = 0;
306 } /* rgSchFillL2MeasCfm */
308 /** @brief This function sends the L2 measurement confirm to LM
313 * Function: rgSchL2mSndCfm
315 * @param [in] Pst *pst
316 * @param [in] RgSchL2MeasCb *measCb
317 * @param [in] Bool isErr
324 RgSchL2MeasCb *measCb,
325 LrgSchMeasReqInfo *measInfo,
329 S16 rgSchL2mSndCfm(pst, measCb, measInfo, isErr)
331 RgSchL2MeasCb *measCb;
332 LrgSchMeasReqInfo *measInfo;
336 LrgSchMeasCfmInfo cfm;
338 memset(&cfm, 0, sizeof(LrgSchMeasCfmInfo));
339 cfm.hdr.transId = measInfo->hdr.transId;
340 cfm.measType = measInfo->measType;
341 cfm.cellId = measInfo->cellId;
342 cfm.cfm.status = LCM_PRIM_OK;
345 cfm.cfm.status = LCM_PRIM_NOK;
346 cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
347 RgMiLrgSchL2MeasCfm(pst, &cfm);
351 } /* rgSchL2mSndCfm */
353 /** @brief This function fills the LM confirmation pst structure
357 * Function: rgSchL2mFillCfmPst
359 * @param [in] Pst *pst
360 * @param [out] Pst *cfmPst
361 * @param [in] LrgSchMeasReqInfo *measInfo
365 Void rgSchL2mFillCfmPst
369 LrgSchMeasReqInfo *measInfo
372 Void rgSchL2mFillCfmPst(pst, cfmPst, measInfo)
375 LrgSchMeasReqInfo *measInfo;
379 cfmPst->srcEnt = pst->dstEnt;
380 cfmPst->srcInst = pst->dstInst;
381 cfmPst->srcProcId = pst->dstProcId;
382 cfmPst->dstEnt = pst->srcEnt;
383 cfmPst->dstInst = pst->srcInst;
384 cfmPst->dstProcId = pst->srcProcId;
386 cfmPst->selector = measInfo->hdr.response.selector;
387 cfmPst->prior = measInfo->hdr.response.prior;
388 cfmPst->route = measInfo->hdr.response.route;
389 cfmPst->region = measInfo->hdr.response.mem.region;
390 cfmPst->pool = measInfo->hdr.response.mem.pool;
393 } /* rgSchL2mFillCfmPst */
395 /** @brief This function inserts the MeasCb in to data base
399 * Function: rgSchL2mInsertMeasCb
401 * @param [in] RgSchCellCb *cell
402 * @param [in] RgSchL2MeasCb *measCb
403 * @param [in] LrgSchMeasReqInfo *measInfo
409 static S16 rgSchL2mInsertMeasCb
412 RgSchL2MeasCb *measCb,
413 LrgSchMeasReqInfo *measInfo
416 static S16 rgSchL2mInsertMeasCb(cell, measCb, measInfo)
418 RgSchL2MeasCb *measCb;
419 LrgSchMeasReqInfo *measInfo;
423 RgSchL2MeasCb *oldMeasCb;
427 * 1. Check if l2mList has any entries.
429 * 1. Take the first entrie's time period and find the diff with
431 * 2. If the diff is > measInfo->timePeriod then insert before this
433 * 3. Else take the next entry in list
434 * 4. If reached without adding to list . Append at the end of list.
435 * 3. If no entries in l2mList add at the first.
437 lnk = cell->l2mList.first;
438 node = &measCb->measLnk;
439 node->node = (PTR)measCb;
442 oldMeasCb = (RgSchL2MeasCb *)lnk->node;
443 diffTime = (oldMeasCb->measReq.timePrd -
444 (RGSCH_CALC_SF_DIFF(cell->crntTime, oldMeasCb->startTime)));
445 if (diffTime > measInfo->timePrd)
447 cell->l2mList.crnt = lnk;
448 cmLListInsCrnt(&(cell->l2mList), node);
456 cmLListAdd2Tail(&(cell->l2mList), node);
458 } /* rgSchL2mInsertMeasCb */
460 /** @brief This function calculates the Down link prb count
465 * Function: rgSchL2CalDlPrbCount
467 * @param [in] RgSchCellCb *cell
470 static Void rgSchL2CalDlPrbCount
475 static Void rgSchL2CalDlPrbCount(cell)
480 RgSchDlSf *sf = NULLP;
485 frm = cell->crntTime;
486 RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
487 sf = rgSCHUtlSubFrmGet(cell, frm);
489 idx = (cell->crntTime.slot + RG_SCH_CMN_DL_DELTA) %
490 RGSCH_NUM_SUB_FRAMES;
491 if(RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, idx))
493 cell->avgPrbDl.prbCount += sf->bwAssigned;
494 dlPrbCnt += sf->bwAssigned;
497 cell->avgPrbDl.prbCount += sf->bwAssigned;
502 /** @brief This function calculates the up link prb count
507 * Function: rgSchL2CalUlPrbCount
509 * @param [in] RgSchCellCb *cell
512 static Void rgSchL2CalUlPrbCount
517 static Void rgSchL2CalUlPrbCount(cell)
521 RgSchUlSf *sf = NULLP;
522 RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
528 idx = cellUl->schdIdx;
529 if(idx < cellUl->numUlSubfrms)
531 sf = &cellUl->ulSfArr[idx];
532 cell->avgPrbUl.prbCount += sf->totPrb;
535 sf = &cellUl->ulSfArr[cellUl->schdIdx];
536 cell->avgPrbUl.prbCount += sf->totPrb;
540 /** @brief This function allocates memory from the heap
544 * Function: rgSchL2mAllocMeasCb
546 * @param [in] RgSchCellCb *cell
547 * @param [in] RgSchL2MeasCb *measInfo
548 * @param [out] RgSchErrInfo *err
549 * @return RgSchL2MeasCb *
552 static RgSchL2MeasCb * rgSchL2mAllocMeasCb
555 LrgSchMeasReqInfo *measInfo,
559 static RgSchL2MeasCb * rgSchL2mAllocMeasCb(cell, measInfo, err)
561 LrgSchMeasReqInfo *measInfo;
565 RgSchL2MeasCb *measCb = NULLP;
566 Inst inst = cell->instIdx;
569 if((rgSCHUtlAllocSBuf(inst, (Data **)&measCb,
570 sizeof(RgSchL2MeasCb))) == RFAILED)
572 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSchL2mAllocMeasCb():"
573 "Allocation of RgSchL2MeasCb failed");
576 memcpy(&measCb->measReq, measInfo, sizeof(LrgSchMeasReqInfo));
577 RGSCHCPYTIMEINFO(cell->crntTime, measCb->startTime);
579 measCb->dlTotalBw = 0;
580 measCb->ulTotalBw = 0;
583 } /* rgSchL2mAllocMeasCb */
586 * @brief Layer Manager Measurement request handler.
590 * Function : rgSchL2mMeasReq
592 * This function handles measurement request received at scheduler instance
593 * from the Layer Manager.
594 * -# Measurement request will be stored in the list in ascending order of
597 * @param[in] Pst *pst, the post structure
598 * @param[in] LrgSchMeasReqInfo *measInfo, the measurement request structure
599 * @param[out] RgSchErrInfo *err, error information
608 LrgSchMeasReqInfo *measInfo,
612 S16 rgSchL2mMeasReq(cell, measInfo, err)
614 LrgSchMeasReqInfo *measInfo;
618 RgSchL2MeasCb *measCb;
624 if ((measCb = rgSchL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
626 RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ,
627 RGSCHERR_SCH_ALLOC_FAILED);
628 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSchL2mMeasReq():"
629 "Allocation of RgSchL2MeasCb failed");
632 /*memcpy(&measCb->measReq, measInfo,\
633 sizeof(LrgSchMeasReqInfo));*/
634 rgSchL2mInsertMeasCb(cell, measCb, measInfo);
636 if (measInfo->timePrd == 0)
638 cell->sndL2Meas = FALSE;
639 if (measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
641 for (idx = 0; idx < measInfo->avgPrbQciDl.numQci; idx++)
643 qciVal = measInfo->avgPrbQciDl.qci[idx];
644 cell->qciArray[qciVal].qci = qciVal;
647 if (measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
649 for (idx = 0; idx < measInfo->nmbActvUeQciDl.numQci; idx++)
651 qciVal = measInfo->nmbActvUeQciDl.qci[idx];
652 cell->qciArray[qciVal].qci = qciVal;
655 if (measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
657 for (idx = 0; idx < measInfo->nmbActvUeQciUl.numQci; idx++)
659 qciVal = measInfo->nmbActvUeQciUl.qci[idx];
660 cell->qciArray[qciVal].qci = qciVal;
664 /* Here post the message to MAC */
665 if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
667 RgInfL2MeasReq measReq;
669 memset(&measReq, 0, sizeof(RgInfL2MeasReq));
670 measReq.transId = measInfo->hdr.transId;
671 measReq.measType = measInfo->measType;
672 measReq.timePrd = measInfo->timePrd;
673 measReq.cellId = measInfo->cellId;
674 measReq.t.prbReq.numQci = measInfo->avgPrbQciUl.numQci;
675 for (idx = 0; idx < measInfo->avgPrbQciUl.numQci; idx++)
677 measReq.t.prbReq.qci[idx] = measInfo->avgPrbQciUl.qci[idx];
679 /* Send measReq to MAC */
680 rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
681 RgSchMacL2Meas(&pst, &measReq);
684 } /* rgSchL2mMeasReq */
687 * @brief This function calculates the measurement for differnt measurement type
688 * and send the end result to the layer manager
692 * Function : rgSCHL2Meas
694 * @param[in] RgSchCellCb *cell
706 S16 rgschL2Meas(cell,isCalrCrcInd)
711 CmLList *node = NULLP;
712 RgSchL2MeasCb *measCb = NULLP;
714 LrgSchMeasCfmInfo measCfm;
720 Bool isDlDataAllowed;
726 node = cell->l2mList.first;
727 memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
730 measCb = (RgSchL2MeasCb *)node->node;
732 if(cell->crntTime.sfn == 1023 && cell->crntTime.slot == 9)
734 /*calculates diff between crnt time and start time*/
735 meas = RGSCH_CALC_SFN_SF_DIFF(cell->crntTime,
736 measCb->sfnCycle, measCb->startTime);
741 /*calculates diff between crnt time and start time*/
742 meas = RGSCH_CALC_SFN_SF_DIFF(cell->crntTime,
743 measCb->sfnCycle, measCb->startTime);
746 if (cell->sndL2Meas || meas == measCb->measReq.timePrd)
749 rem = meas % RGSCH_NUM_SUB_FRAMES;
750 /* Get the total number of DL and UL subframes within the reporting period*/
751 numDlSf = (meas / RGSCH_NUM_SUB_FRAMES) * rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
752 numUlSf = (meas / RGSCH_NUM_SUB_FRAMES) * rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
754 sfIdx = (measCb->startTime.slot + 1) % RGSCH_NUM_SUB_FRAMES;
758 isDlDataAllowed = RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, sfIdx);
763 else if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][sfIdx] ==
764 RG_SCH_TDD_UL_SUBFRAME)
768 sfIdx = (sfIdx + 1) % RGSCH_NUM_SUB_FRAMES;
772 measCb->dlTotalBw = numDlSf * cell->bwCfg.dlTotalBw;
773 measCb->ulTotalBw = numUlSf * cell->bwCfg.ulTotalBw;
776 measCb->dlTotalBw = meas * cell->bwCfg.dlTotalBw;
777 measCb->ulTotalBw = meas * cell->bwCfg.ulTotalBw;
779 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL))
783 rgSchFillL2MeasCfm(cell, measCb, &measCfm, meas);
792 rgSchFillL2MeasCfm(cell, measCb, &measCfm, meas);
794 RgMiLrgSchL2MeasCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst),
796 memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
798 /* Delete this measCb from the list */
799 if(measCb->measReq.timePrd > 0)
801 cmLListDelFrm(&cell->l2mList, &measCb->measLnk);
802 rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,
803 sizeof(RgSchL2MeasCb));
805 else/*do not delete measCb, will use for next measurement*/
807 measCb->startTime = cell->crntTime;
808 measCb->sfnCycle = 0;
809 measCb->cfmRcvd = FALSE;
810 memset(&measCb->avgPrbQciUl, 0, sizeof(LrgAvgPrbQCICfm));
811 cell->sndL2Meas = FALSE;
813 /* ccpu00117052 - MOD - Passing double pointer
814 for proper NULLP assignment*/
818 /* Just update the AVERAGE UL PRB counter here and return
819 * if the caller is CRCIndication() and the UL scheduling happens
821 #ifdef RG_ULSCHED_AT_CRC
824 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL)
826 rgSchL2CalUlPrbCount(cell);
831 /* UL PRB counter gets updated as a part of CRC indication
832 * if the UL scheduling happens there */
833 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_UL))
835 rgSchL2CalUlPrbCount(cell);
838 if((measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_DL))
840 rgSchL2CalDlPrbCount(cell);
842 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
844 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, measCb->startTime);
846 if((sfDiff % measCb->measReq.nmbActvUeQciDl.sampPrd) == 0)
848 if (measCb->measReq.nmbActvUeQciDl.numQci)
850 for (idx = 0; idx < measCb->measReq.nmbActvUeQciDl.numQci;
853 qciVal = measCb->measReq.nmbActvUeQciDl.qci[idx];
854 cell->qciArray[qciVal].dlTotal_UeCount +=
855 cell->qciArray[qciVal].dlUeCount;
860 for (qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
862 cell->qciArray[qciVal].dlTotal_UeCount +=
863 cell->qciArray[qciVal].dlUeCount;
868 if(measCb->measReq.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
870 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime , measCb->startTime);
871 if((sfDiff % measCb->measReq.nmbActvUeQciUl.sampPrd) == 0)
873 if (measCb->measReq.nmbActvUeQciUl.numQci)
875 for (idx = 0; idx < measCb->measReq.nmbActvUeQciUl.numQci;
878 qciVal = measCb->measReq.nmbActvUeQciUl.qci[idx];
879 cell->qciArray[qciVal].ulTotal_UeCount +=
880 cell->qciArray[qciVal].ulUeCount;
885 for (qciVal = 1; qciVal < LRG_MAX_QCI_PER_REQ; qciVal++)
887 cell->qciArray[qciVal].ulTotal_UeCount +=
888 cell->qciArray[qciVal].ulUeCount;
897 #endif /* LTE_L2_MEAS */
898 /**********************************************************************
901 **********************************************************************/