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 Entry point fucntions
29 **********************************************************************/
31 static const char* RLOG_MODULE_NAME="MAC";
32 static int RLOG_FILE_ID=237;
33 static int RLOG_MODULE_ID=4096;
35 @brief This module does processing related to handling of lower interface APIs
36 invoked by PHY towards MAC
38 /* header include files -- defines (.h) */
39 #include "envopt.h" /* environment options */
40 #include "envdep.h" /* environment dependent */
41 #include "envind.h" /* environment independent */
42 #include "gen.h" /* general layer */
43 #include "ssi.h" /* system services */
44 #include "cm5.h" /* common timers defines */
45 #include "cm_hash.h" /* common hash list defines */
46 #include "cm_llist.h" /* common linked list defines */
47 #include "cm_mblk.h" /* memory management */
48 #include "cm_tkns.h" /* common tokens */
49 #include "cm_lte.h" /* common tokens */
50 #include "rgu.h" /* RGU defines */
51 #include "tfu.h" /* RGU defines */
52 #include "lrg.h" /* layer management defines for LTE-MAC */
53 #include "crg.h" /* layer management defines for LTE-MAC */
54 #include "rg_sch_inf.h" /* layer management defines for LTE-MAC */
55 #include "rg.h" /* defines and macros for MAC */
56 #include "rg_env.h" /* defines and macros for MAC */
57 #include "rg_err.h" /* defines and macros for MAC */
60 /* header/extern include files (.x) */
61 #include "gen.x" /* general layer typedefs */
62 #include "ssi.x" /* system services typedefs */
63 #include "cm5.x" /* common timers */
64 #include "cm_hash.x" /* common hash list */
65 #include "cm_lib.x" /* common library */
66 #include "cm_llist.x" /* common linked list */
67 #include "cm_mblk.x" /* memory management */
68 #include "cm_tkns.x" /* common tokens */
69 #include "cm_lte.x" /* common tokens */
70 #include "rgu.x" /* RGU types */
71 #include "tfu.x" /* RGU types */
72 #include "lrg.x" /* layer management typedefs for MAC */
73 #include "crg.x" /* CRG interface typedefs */
74 #include "rg_sch_inf.x" /* SCH interface typedefs */
75 #include "rg_prg.x" /* PRG interface typedefs */
76 #include "rgm.x" /* layer management typedefs for MAC */
77 #include "rgm.h" /* layer management typedefs for MAC */
78 #include "rg.x" /* typedefs for MAC */
80 #ifdef MAC_RLC_UL_RBUF
85 /* ADD Changes for Downlink UE Timing Optimization */
86 #ifndef LTEMAC_DLUE_TMGOPTMZ
87 PRIVATE S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf, RgCellCb *cellCb,
90 PUBLIC S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
93 PRIVATE S16 rgTOMProcCrntiCEInDatInd ARGS((
102 PRIVATE S16 rgTOMProcCCCHSduInDatInd ARGS((
111 PUBLIC S16 rgHndlFlowCntrl
117 EXTERN S16 RgUiRguFlowCntrlInd(Pst* pst, SuId suId, RguFlowCntrlInd *flowCntrlInd);
119 EXTERN S16 rgEmtcHndl(RgCellCb *cell,RgInfSfAlloc *sfInfo);
120 EXTERN S16 rgTOMEmtcUtlFillDatReqPdus(TfuDatReqInfo *datInfo, RgDlSf *dlSf, RgCellCb *cell, RgErrInfo *err);
121 EXTERN Void rgTOMEmtcRlsSf(RgDlSf *dlSf);
124 PRIVATE Void rgTOML2MCompileActiveLCs ARGS
131 PRIVATE S16 rgTOMUtlL2MStoreBufSz ARGS
137 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo ARGS
141 RgRguDedDatInd *dDatInd
145 /* The below table takes lower values of BSR Range for a BSR value
146 This is to ensure that outstanding can be decrease to zero upon reception of
147 TB, which is not guaranteed if higher Range values are used */
148 /* Note: taking value 10 for BSR index 1 */
149 #ifndef MAC_5GTF_UPDATE
150 PRIVATE U32 rgLwrBsrTbl[64] = {
151 0, 10, 10, 12, 14, 17, 19, 22, 26,
152 31, 36, 42, 49, 57, 67, 78, 91,
153 107, 125, 146, 171, 200, 234, 274, 321,
154 376, 440, 515, 603, 706, 826, 967, 1132,
155 1326, 1552, 1817, 2127, 2490, 2915, 3413, 3995,
156 4677, 5476, 6411, 7505, 8787, 10287, 12043, 14099,
157 16507, 19325, 22624, 26487, 31009, 36304, 42502, 49759,
158 58255, 68201, 79846, 93479, 109439, 128125, 150000
162 PRIVATE U32 rgLwrBsrTbl[64] = {
163 0,10,13,16,19,23,29,35,43,53,65,80,98,120,147,181,223,274,337,414,
164 509,625,769,945,1162,1429,1757,2161,2657,3267,4017,4940,6074,7469,
165 9185,11294,13888,17077,20999,25822,31752,39045,48012,59039,72598,
166 89272,109774,134986,165989,204111,250990,308634,379519,466683,
167 573866,705666,867737,1067031,1312097,1613447,1984009,2439678,
175 #define RG_TOM_INF_ALLOC(_pdu, _size, _dataPtr, _ret) {\
176 _ret = cmGetMem((Ptr)&_pdu->memCp, _size, (Ptr *)&_dataPtr); \
179 /* global variables */
180 PUBLIC U32 rgUlrate_tfu;
182 EXTERN U32 grgUlrate_tfu;
185 /** @brief This function fills the PDSCH data of a downlink subframe
189 * Function: rgTOMUtlFillDatReqPdus
192 * - Fill BCCH on DLSCH data using datInfo
193 * - Fill PCCH on DLSCH data using datInfo
194 * - Fill Dedicated data on DLSCH data using datInfo
195 * - Fill RA RSP data using datInfo
197 * @param [out] TfuDatReqInfo *datInfo
198 * @param [in] RgDlSf *dlSf
199 * @param [in] RgCellCb *cellCb
200 * @param [out] RgErrInfo *err
206 PRIVATE S16 rgTOMUtlFillDatReqPdus
208 TfuDatReqInfo *datInfo,
214 PRIVATE S16 rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)
215 TfuDatReqInfo *datInfo;
222 TfuDatReqPduInfo *datReq=NULLP;
223 /* Moving node declaration to limited scope for optimization */
226 Inst inst = cellCb->macInst - RG_INST_START;
228 TRC2(rgTOMUtlFillDatReqPdus)
230 /* first lets send the BCCH data down to PHY */
231 if (dlSf->bcch.tb != NULLP)
233 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
234 &(datInfo->memCp))) != ROK)
236 err->errCause = RGERR_TOM_MEM_EXHAUST;
237 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion ");
240 #ifdef TFU_ALLOC_EVENT_NO_INIT
244 datReq->tbInfo[0].lchInfo[0].mBuf[0]=NULLP;
247 datReq->rnti = RG_SI_RNTI;
248 datReq->dciInfo = dlSf->bcch.pdcch.dci;
249 /* Note: SCpyMsgMsg is not done since free of unsent buffer
250 * has been taken care through cell delete by invoking rgTomRlsSf
252 datReq->nmbOfTBs = 1;
254 datReq->mBuf[0] = dlSf->bcch.tb;
256 SFndLenMsg((Buffer *)dlSf->bcch.tb, &(datReq->tbInfo[0].tbSize));
257 datReq->tbInfo[0].tbPres = TRUE;
258 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->bcch.tb;
259 datReq->tbInfo[0].numLch = 1;
260 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
262 #ifdef TFU_ALLOC_EVENT_NO_INIT
263 datReq->tbInfo[1].tbPres = FALSE;
264 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
267 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
268 datReq->lnk.node = (PTR)datReq;
270 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
271 datReq->txPwrOffset = dlSf->bcch.txPwrOffset;
273 /* Setting the pointer to NULL post transmission */
274 dlSf->bcch.tb = NULLP;
277 if (dlSf->pcch.tb != NULLP)
279 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
280 &(datInfo->memCp))) != ROK)
282 err->errCause = RGERR_TOM_MEM_EXHAUST;
283 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",datReq->rnti);
286 #ifdef TFU_ALLOC_EVENT_NO_INIT
291 datReq->rnti = RG_P_RNTI;
292 datReq->dciInfo = dlSf->pcch.pdcch.dci;
293 datReq->nmbOfTBs = 1;
295 datReq->mBuf[0] = dlSf->pcch.tb;
297 SFndLenMsg((Buffer *)dlSf->pcch.tb, &datReq->tbInfo[0].tbSize);
298 datReq->tbInfo[0].tbPres = TRUE;
299 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->pcch.tb;
300 #ifdef TFU_ALLOC_EVENT_NO_INIT
301 datReq->tbInfo[1].tbPres = FALSE;
302 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
304 datReq->tbInfo[0].numLch = 1;
305 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
307 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
308 datReq->lnk.node = (PTR)datReq;
310 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
311 datReq->txPwrOffset = dlSf->pcch.txPwrOffset;
313 dlSf->pcch.tb = NULLP;
316 for(idx=0; idx < dlSf->numRaRsp; idx++)
318 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
319 &(datInfo->memCp))) != ROK)
321 err->errCause = RGERR_TOM_MEM_EXHAUST;
322 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",
326 #ifdef TFU_ALLOC_EVENT_NO_INIT
331 datReq->rnti = dlSf->raRsp[idx].pdcch.rnti;
332 datReq->dciInfo = dlSf->raRsp[idx].pdcch.dci;
333 datReq->nmbOfTBs = 1;
335 datReq->mBuf[0] = dlSf->raRsp[idx].rar;
337 SFndLenMsg((Buffer *)dlSf->raRsp[idx].rar, &datReq->tbInfo[0].tbSize);
338 datReq->tbInfo[0].tbPres = TRUE;
339 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->raRsp[idx].rar;
340 #ifdef TFU_ALLOC_EVENT_NO_INIT
341 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
342 datReq->tbInfo[1].tbPres = FALSE;
344 datReq->tbInfo[0].numLch = 1;
345 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
346 // prc_trace_format_string(0x40,3,"UE Id=(%d) tbSz=(%d)",datReq->rnti, datReq->tbInfo[0].tbSize);
348 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
349 datReq->lnk.node = (PTR)datReq;
351 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
352 datReq->txPwrOffset = dlSf->raRsp[idx].txPwrOffset;
354 dlSf->raRsp[idx].rar = NULLP;
357 /* Fill Dedicated UE data */
358 if (dlSf->tbs.count != 0)
361 while (dlSf->tbs.first)
363 node = dlSf->tbs.first;
364 hqCb = (RgDlHqProcCb*)node->node;
365 if ((ret = rgDHMSndDatReq (cellCb, dlSf, datInfo, hqCb, err)) != ROK)
367 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
368 "DHM unable to fill DATA request");
369 err->errType = RGERR_TOM_TTIIND;
376 } /* end of rgTOMUtlFillDatReqPdus*/
378 /** @brief This function does all the processing related to a single downlink
383 * Function: rgTOMUtlProcDlSf
386 * - collate control data for all UEs and send to PHY
387 * - collate data buffers for all UEs and send to PHY
389 * @param [in] RgDlSf *dlSf
390 * @param [in] RgCellCb *cellCb
391 * @param [out] RgErrInfo *err
394 /* ADD Changes for Downlink UE Timing Optimization */
395 #ifndef LTEMAC_DLUE_TMGOPTMZ
397 PRIVATE S16 rgTOMUtlProcDlSf
404 PRIVATE S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
411 PUBLIC S16 rgTOMUtlProcDlSf
418 PUBLIC S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
426 TfuDatReqInfo *datInfo;
427 Inst inst = cellCb->macInst - RG_INST_START;
429 TRC2(rgTOMUtlProcDlSf);
431 /* Fill Data Request Info from scheduler to PHY */
432 if ((ret = rgAllocEventMem(inst,(Ptr *)&datInfo,
433 sizeof(TfuDatReqInfo))) != ROK)
435 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to Allocate TfuDatReqInfo");
440 cmLListInit(&datInfo->pdus);
442 RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DELTA);
444 RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DLDATA_DLDELTA);
446 datInfo->cellId = cellCb->cellId;
447 if((0 == (datInfo->timingInfo.sfn % 30)) && (0 == datInfo->timingInfo.subframe))
449 //printf("5GTF_CHECK rgTOMUtlProcDlSf dat (%d : %d)\n", datInfo->timingInfo.sfn, datInfo->timingInfo.subframe);
451 #ifdef TFU_ALLOC_EVENT_NO_INIT
452 datInfo->bchDat.pres = 0;
456 if (dlSf->bch.tb != NULLP)
458 datInfo->bchDat.pres = PRSNT_NODEF;
459 datInfo->bchDat.val = dlSf->bch.tb;
460 dlSf->bch.tb = NULLP;
463 /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
464 if ((ret = rgTOMEmtcUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
466 RG_FREE_MEM(datInfo);
470 /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
471 if ((ret = rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
473 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data for cell");
474 RG_FREE_MEM(datInfo);
477 if((datInfo->pdus.count) || (datInfo->bchDat.pres == TRUE))
479 /* sending the data to Phy */
480 if (rgLIMTfuDatReq(inst,datInfo) != ROK)
482 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data info for cell");
487 /* Nothing to send: free the allocated datInfo */
488 RG_FREE_MEM(datInfo);
497 * @brief Handler for processing TTI indication recieved from
502 * Function: rgTOMTtiInd
504 * Handler for processing TTI indication recieved from PHY
507 * Invoked by: RgLiTfuTtiInd
510 * - Get cell and update the cell's current time with the timing value given
512 * - Invoke the cmPrcTmr to process the timing queue.
513 * - Append the PHICH information to the downlink subframe that needs to go
514 * out to PHY in this subframe.
515 * - Invoke DHM to release the downlink subframe that occured earlier
516 * rgDHMRlsDlsfHqProc.
517 * - Invoke the TTI handler of scheduler.
518 * - Invoke the TTI handler of RAM module.
519 * - Get the downlink subframe that has to go out to PHY in this subframe
521 * - Invoke rgTOMUtlProcTA to perform and timing advance processing.
522 * - Invoke rgTOMUtlProcDlSf to do further processing on the downlink
524 * - Get the downlink subframe that would occur after RG_DL_DELTA and
525 * invoke rgTOMUtlProcDlSfStaInd to send status indications to the higher
527 * - Invoke GOM's TTI handler rgGOMTtiHndlr
528 * - Invoke COM's TTI handler rgCOMTtiHndlr
530 * @param[in] Inst inst
531 * @param[in] TfuTtiIndInfo *ttiInd
536 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
537 pthread_t gMacTId = 0;
540 PUBLIC S16 rgTOMTtiInd
543 TfuTtiIndInfo *ttiInfo
546 PUBLIC S16 rgTOMTtiInd(inst, ttiInfo)
548 TfuTtiIndInfo *ttiInfo;
554 /* ADD Changes for Downlink UE Timing Optimization */
555 #ifdef LTEMAC_DLUE_TMGOPTMZ
557 CmLteTimingInfo prevTmInfo;
559 TfuTtiCellInfo *ttiInd = &ttiInfo->cells[0];
563 #ifdef MAC_FREE_RING_BUF
564 gMacTId = pthread_self();
566 cellCb = rgCb[inst].cell;
567 if ((cellCb == NULLP)
568 ||(cellCb->cellId != ttiInd->cellId))
571 RLOG_ARG0(L_ERROR,DBG_CELLID,ttiInd->cellId,
572 "Unable to get the cellCb for cell");
573 err.errType = RGERR_TOM_TTIIND;
574 err.errCause = RGERR_TOM_INV_CELL_ID;
577 RGCPYTIMEINFO(ttiInd->timingInfo, cellCb->crntTime);
578 if((0 == (ttiInd->timingInfo.sfn % 30)) && (0 == ttiInd->timingInfo.sfn))
580 //printf("5GTF_CHECK rgTOMTtiInd (%d : %d)\n", ttiInd->timingInfo.sfn, ttiInd->timingInfo.subframe);
582 rgMacGT = (ttiInd->timingInfo.sfn * RG_NUM_SUB_FRAMES_5G) + ttiInd->timingInfo.subframe;
585 /*Included to track the number of 10240 cycles completed */
587 if((cellCb->crntTime.sfn == 0) && (cellCb->crntTime.subframe==0))
589 cellCb->ttiCycle += 1;
594 /*Check if we have transmitted the previous DL SF, it could be the
595 case that we haven't received all the DATA from RLC as yet
596 and thus we would not have transmitted previous DL SF yet.*/
597 /* ADD Changes for Downlink UE Timing Optimization */
598 #ifdef LTEMAC_DLUE_TMGOPTMZ
599 RGSUBFRMCRNTTIME(ttiInd->timingInfo, prevTmInfo, 1);
600 prevDlSf = &cellCb->subFrms[(prevTmInfo.subframe % RG_NUM_SUB_FRAMES)];
601 if(FALSE == prevDlSf->txDone)
603 if (ROK != rgTOMUtlProcDlSf (prevDlSf, cellCb, &err))
605 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to process "
606 "previous downlink subframe for cell");
607 err.errType = RGERR_TOM_TTIIND;
610 /* Mark this frame as sent */
611 prevDlSf->txDone = TRUE;
613 if(prevDlSf->remDatReqCnt)
615 /*We have not received 1 or more data requests from RLC, this is
616 error scenario. MAC & SCH need to discard the allocations for
617 which data request hasn't been received as yet. And MAC
618 needs to inform SCH about the list of UEs for which
619 allocation need to be discarded. */
620 prevDlSf->remDatReqCnt = 0;
624 dlSf = &cellCb->subFrms[(ttiInd->timingInfo.subframe % RG_NUM_SUB_FRAMES)];
626 if((dlSf->txDone == TRUE) ||
627 (!RG_TIMEINFO_SAME(ttiInd->timingInfo,dlSf->schdTime)))
630 #ifndef LTEMAC_DLUE_TMGOPTMZ
631 TfuDatReqInfo *datInfo;
632 CmLteTimingInfo timingInfo;
633 #ifdef TFU_DL_DELTA_CHANGE
634 RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DLDATA_DLDELTA);
636 RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DELTA);
638 /* Fill Data Request from MAC for BCH */
639 if ((timingInfo.sfn % 4 == 0) && (timingInfo.subframe == 0))
641 if (ROK != rgAllocEventMem(inst,(Ptr *)&datInfo,
642 sizeof(TfuDatReqInfo)))
644 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
645 "rgTOMUtlProcDlSf() Unable to Allocate TfuDatReqInfo for cell");
650 cmLListInit(&datInfo->pdus);
651 datInfo->cellId = cellCb->cellId;
652 datInfo->bchDat.pres = NOTPRSNT;
653 datInfo->timingInfo = timingInfo;
656 /* sending the dummy data req to Phy */
657 if (rgLIMTfuDatReq(inst,datInfo) != ROK)
659 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
660 "rgTOMUtlProcDlSf() Unable to send data info for cell");
666 /* Freeing as the part of CL Non RT Indication */
667 /* TDOD : Generalize for all SOCs */
668 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
669 rgDHMFreeTbBufs(inst);
674 /*Return if there is still some data to be received
675 from RLC for this DL SF. */
676 /* ADD Changes for Downlink UE Timing Optimization */
677 #ifdef LTEMAC_DLUE_TMGOPTMZ
678 if(0 != dlSf->remDatReqCnt)
680 /* Freeing as the part of CL Non RT Indication */
681 /* TODO : Generalize for all SOCs and remove this flag */
682 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
683 rgDHMFreeTbBufs(inst);
689 #ifdef XEON_SPECIFIC_CHANGES
690 CM_MEAS_TIME((ttiInd->timingInfo.subframe % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_DL_BR_PRC);
693 if (ROK != rgTOMUtlProcDlSf (dlSf, cellCb, &err))
695 RLOG_ARG0(L_ERROR,DBG_CELLID,ttiInd->cellId,
696 "Unable to process downlink subframe for cell");
697 err.errType = RGERR_TOM_TTIIND;
699 #ifdef XEON_SPECIFIC_CHANGES
700 CM_MEAS_TIME((ttiInd->timingInfo.subframe % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_DL_AFTER_PRC);
703 /* Mark this frame as sent */
706 /* Freeing as the part of CL Non RT Indication */
707 /* TODO : Generalize for all SOCs and remove this flag */
708 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
709 rgDHMFreeTbBufs(inst);
714 /** @brief This function allocates the RgMacPdu that will be populated by DEMUX
715 * with the SubHeaders list and the values of the Control elements.
719 * Function: rgTOMUtlAllocPduEvnt
722 * @param[in] Inst inst
723 * @param [out] RgMacPdu **pdu
730 PRIVATE S16 rgTOMUtlAllocPduEvnt
736 PRIVATE S16 rgTOMUtlAllocPduEvnt (inst,pdu)
743 RgUstaDgn dgn; /* Alarm diagnostics structure */
744 VOLATILE U32 startTime=0;
746 TRC2(rgTOMUtlAllocPduEvnt);
748 evntMem.region = rgCb[inst].rgInit.region;
749 evntMem.pool = rgCb[inst].rgInit.pool;
752 SStartTask(&startTime, PID_TOMUTL_CMALLCEVT);
754 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
755 MS_BUF_ADD_ALLOC_CALLER();
758 if (cmAllocEvnt (sizeof (RgMacPdu), RG_BLKSZ, &evntMem, (Ptr*)pdu) != ROK)
760 rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
761 rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
762 LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
763 RLOG0(L_ERROR,"Allocation of DUX event failed");
768 SStopTask(startTime, PID_TOMUTL_CMALLCEVT);
773 /** @brief This function frees up the RgMacPdu structure that has been
774 * populated by demux.
778 * Function: rgTOMUtlFreePduEvnt
779 * - Function frees up the RgMacPdu structure, in case of error it shall
780 * free up the buffer's present in the different sdu.
783 * @param [in] Inst inst
784 * @param [in] RgMacPdu *pdu
785 * @param [in] Bool *error
789 PRIVATE Void rgTOMUtlFreePduEvnt
795 PRIVATE Void rgTOMUtlFreePduEvnt (pdu, error)
804 TRC2(rgTOMUtlFreePduEvnt);
805 /* Steps of freeing up the PDU.
806 * 1. loop through the subHdrLst and free up all the buffers.
807 * 2. free up the whole event
809 if ((error == TRUE) && (pdu->sduLst.count > 0))
811 node = pdu->sduLst.first;
814 sdu = (RgMacSdu*)node->node;
815 RG_FREE_MSG(sdu->mBuf);
821 } /* end of rgTOMUtlFreePduEvnt */
823 /** @brief This function allocates the RgMacPdu that will be populated by DEMUX
824 * with the SubHeaders list and the values of the Control elements.
828 * Function: rgTOMInfAllocPduEvnt
831 * @param [in] Inst inst
832 * @param [out] RgMacPdu **pdu
839 PRIVATE S16 rgTOMInfAllocPduEvnt
842 RgInfSfDatInd **sfInfo
845 PRIVATE S16 rgTOMInfAllocPduEvnt (inst,sfInfo)
847 RgInfSfDatInd **sfInfo;
852 RgUstaDgn dgn; /* Alarm diagnostics structure */
853 VOLATILE U32 startTime=0;
855 TRC2(rgTOMInfAllocPduEvnt);
857 evntMem.region = rgCb[inst].rgInit.region;
858 evntMem.pool = rgCb[inst].rgInit.pool;
861 SStartTask(&startTime, PID_TOMINF_CMALLCEVT);
863 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
864 MS_BUF_ADD_ALLOC_CALLER();
866 if (cmAllocEvnt (sizeof (RgInfSfDatInd), RG_BLKSZ, &evntMem, (Ptr*)sfInfo) != ROK)
868 rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
869 rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
870 LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
871 RLOG0(L_ERROR,"Allocation failed");
876 SStopTask(startTime, PID_TOMINF_CMALLCEVT);
881 /** @brief This function frees up the RgMacPdu structure that has been
882 * populated by demux.
886 * Function: rgTOMInfFreePduEvnt
887 * - Function frees up the RgMacPdu structure, in case of error it shall
888 * free up the buffer's present in the different sdu.
891 * @param [in] RgMacPdu *pdu
892 * @param [in] Bool *error
896 PRIVATE Void rgTOMInfFreePduEvnt
898 RgInfSfDatInd *sfInfo
901 PRIVATE Void rgTOMInfFreePduEvnt (sfInfo)
902 RgInfSfDatInd *sfInfo;
905 TRC2(rgTOMInfFreePduEvnt);
909 } /* end of rgTOMUtlFreePduEvnt */
913 /** @brief This function performs the preparation of information needed to set
914 * L2M Scheduled UL Throughput Information for a particular UE.
918 * Function: rgTomUtlPrepareL2MUlThrpInfo
919 * This function performs the preparation of information needed to set
920 * L2M Scheduled UL Throughput Information for a particular UE.
924 * @param [in] RgCellCb *cellCb
925 * @param [in] RgUeCb *ueCb
926 * @param [out] RgRguDedDatInd *dDatInd
930 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo
934 RgRguDedDatInd *dDatInd
937 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo(cellCb,ueCb,dDatInd)
940 RgRguDedDatInd *dDatInd;
946 TRC2(rgTomUtlPrepareL2MUlThrpInfo);
948 dDatInd->burstInd = RGU_L2M_UL_BURST_END;
949 for(loop=0;loop<dDatInd->numLch;loop++)
951 lcId=dDatInd->lchData[loop].lcId;
954 lcgId = ueCb->ul.lcCb[lcId - 1].lcgId;
955 if(ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs > 0)
957 dDatInd->burstInd = RGU_L2M_UL_BURST_START;
968 /** @brief This function is called by rgTOMDatInd. This function invokes the
969 * scheduler with the information of the received Data and any Control Elements
970 * if present. Also it generates Data indications towards the higher layers.
977 * - Retrieves the RaCb with the rnti provided, if it doesnt exist
979 * - If UE exists then update the Schduler with any MAC CEs if present.
980 * - Invoke RAM module to do Msg3 related processing rgRAMProcMsg3
981 * - Loop through the SDU subheaders and invoke either a common data
982 * indication (rgUIMSndCmnDatInd) or dedicated data indication
983 * (rgUIMSndDedDatInd) towards the higher layers.
985 * @param [in] RgCellCb *cellCb
986 * @param [in] RgUeCb *ueCb
987 * @param [in] CmLteRnti rnti
988 * @param [in] RgMacPdu *pdu
989 * @param [out] U32 *lcgBytes
1000 PRIVATE S16 rgTOMUtlProcMsg
1006 Bool *spsToBeActvtd,
1012 PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,spsToBeActvtd,sduSize, subframe, lcgBytes)
1017 Bool *spsToBeActvtd;
1022 #else /* LTEMAC_SPS */
1024 PRIVATE S16 rgTOMUtlProcMsg
1033 PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, subframe, lcgBytes)
1042 Inst inst = cellCb->macInst - RG_INST_START;
1044 RgRguCmnDatInd *cDatInd;
1045 RgRguDedDatInd *dDatInd;
1052 RgInfSpsRelInfo relInfo;
1059 U16 totalBytesRcvd = 0;
1060 U16 sduLen[RGU_MAX_LC] = {0};
1061 U8 qciVal[RGU_MAX_LC] = {0};
1068 /* Moved outside of LTE_L2_MEAS
1069 * scope as this pointer will now be used to
1070 * check for valid Logical Channel ID
1087 TRC2(rgTOMUtlProcMsg)
1093 if(pdu->sduLst.first)
1095 sdu = (RgMacSdu*)(pdu->sduLst.first->node);
1097 if ((sdu->lcId == RG_CCCH_LCID))
1099 /* code for common channel dat indications */
1100 if ((ret = rgAllocShrablSBuf (inst,(Data**)&cDatInd, sizeof(RgRguCmnDatInd))) != ROK)
1104 cDatInd->cellId = cellCb->cellId;
1105 cDatInd->rnti = ueCb->ueId;
1106 /* rg001.101: Corrected lcId value for common data indication */
1107 cDatInd->lcId = cellCb->ulCcchId;
1108 cDatInd->pdu = sdu->mBuf;
1109 SFndLenMsg (sdu->mBuf, &ccchSz);
1110 /* Fix : syed Contention resolution ID copy should consider only
1111 * 6 bytes of information from sdu->mBuf. Incase of CCCH sdu for reest
1112 * message/psuedo reest message, ccchSz can go beyond 6 and can corrupt
1113 * other fields of ueCb. */
1114 if (ccchSz >= RG_CRES_LEN)
1116 SCpyMsgFix (sdu->mBuf, (MsgLen)0, RG_CRES_LEN, ueCb->contResId.resId,
1119 #ifdef XEON_SPECIFIC_CHANGES
1120 CM_LOG_DEBUG(CM_LOG_ID_MAC, "CCCH SDU of size(%d) received for UE(%d) CRES[0x%x 0x%x 0x%x 0x%x 0x%x 0x%x] Time[%d %d]\n", ((S16)ccchSz), ueCb->ueId,ueCb->contResId.resId[0], ueCb->contResId.resId[1], ueCb->contResId.resId[2], ueCb->contResId.resId[3], ueCb->contResId.resId[4], ueCb->contResId.resId[5], cellCb->crntTime.sfn, cellCb->crntTime.subframe);
1123 rgUIMSndCmnDatInd(inst,cellCb->rguUlSap,cDatInd);
1125 } /* end of common channel processing */
1127 if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
1133 elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
1138 dDatInd = (RgRguDedDatInd *)elem;
1139 cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
1141 dDatInd->cellId = cellCb->cellId;
1142 dDatInd->rnti = ueCb->ueId;
1143 dDatInd->numLch = 0;
1146 ulSf = &cellCb->ulSf[(subframe % RG_NUM_SUB_FRAMES)];
1147 if(ulSf->ueUlAllocInfo != NULLP)
1149 for(idx1 = 0; idx1 < ulSf->numUe; idx1++)
1151 if(ulSf->ueUlAllocInfo[idx1].rnti == ueCb->ueId)
1153 numPrb = ulSf->ueUlAllocInfo[idx1].numPrb;
1159 node = pdu->sduLst.first;
1162 sdu = (RgMacSdu*)node->node;
1164 ulLcCb = rgDBMGetUlDedLcCb (ueCb, sdu->lcId);
1168 RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,"Unconfigured LCID:%d CRNTI:%d"
1169 ,sdu->lcId,ueCb->ueId);
1170 /* ccpu00128443: Fix for memory leak */
1171 /* Fix : syed Neccessary to set sdu->mBuf = NULLP */
1172 RG_FREE_MSG(sdu->mBuf);
1176 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
1178 extern S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId,
1179 CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
1181 if(ROK == kwProcDlStatusPdu(&(cellCb->rguDlSap->sapCfg.sapPst),
1182 cellCb->rguDlSap->sapCfg.suId,
1183 cellCb->cellId,ueCb->ueId,sdu->lcId,sdu->mBuf))
1185 RG_FREE_MSG(sdu->mBuf);
1192 /* ccpu00116477- Fixed the rgUIMSndDedDatInd condition when we receive 11 sdus in the
1193 * list we are losing 11th sdu and sending the first 10 sdus again which
1194 * is causing the duplicate packets and eNB crashing due to access
1195 * of the freed memory */
1196 if (dDatInd->numLch >= RGU_MAX_LC)
1198 if ((ret = rgUIMSndDedDatInd(inst,ueCb->rguUlSap,dDatInd)) != ROK)
1200 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
1201 "Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
1205 if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
1210 elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
1215 dDatInd = (RgRguDedDatInd *)elem;
1216 cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
1218 dDatInd->cellId = cellCb->cellId;
1219 dDatInd->rnti = ueCb->ueId;
1220 dDatInd->numLch = 0;
1222 dDatInd->lchData[dDatInd->numLch].lcId = sdu->lcId;
1223 dDatInd->lchData[dDatInd->numLch].pdu.mBuf[dDatInd->lchData[dDatInd->numLch].pdu.numPdu] = sdu->mBuf;
1224 dDatInd->lchData[dDatInd->numLch].pdu.numPdu++;
1225 lcgId = ulLcCb->lcgId;
1226 SFndLenMsg(sdu->mBuf, &bufSz);
1230 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs -= bufSz;
1233 //if ((lcgBytes != NULLP) && (ueCb->ul.lcgArr[lcgId].isGbr == TRUE))
1234 if (lcgBytes != NULLP)
1236 lcgBytes[lcgId] += bufSz;
1241 /* Check if data has come on SPS LC */
1242 /* KWORK_FIX: Modified the index from lcId to lcId-1 for handling lcId 10 properly */
1243 if (ueCb->ul.spsLcId[sdu->lcId-1] == TRUE)
1245 ueCb->ul.spsDatRcvd++;
1250 /* Data rcvd on CRNTI*/
1251 /* Retrieve the LCG ID of the LCID*/
1252 /* SPS LCG has data whose size > SID Size */
1253 /* Activate SPS if data recvd on SPS LCID and size > SID Packet Size */
1254 if((ueCb->ul.spsLcId[sdu->lcId-1] == TRUE) &&
1255 (sdu->len > RG_SPS_SID_PACKET_SIZE))
1257 *spsToBeActvtd = TRUE;
1258 *sduSize = sdu->len;
1265 if(cellCb->qciArray[ulLcCb->qci].mask == TRUE)
1267 sduLen[ulLcCb->qci] = sdu->len;
1268 totalBytesRcvd += sdu->len;
1269 qciVal[ulLcCb->qci] = ulLcCb->qci;
1273 } /* end of while for SubHeaders */
1275 for(idx2 = 0; idx2 < RGU_MAX_LC; idx2++)
1277 if((cellCb->qciArray[qciVal[idx2]].mask == TRUE) &&
1280 cellCb->qciArray[qciVal[idx2]].prbCount +=
1281 ((numPrb * sduLen[idx2]) / totalBytesRcvd);
1285 if(totalBytesRcvd > 0 && qciVal[idx2] > 0)
1287 RG_UPD_GBR_PRB(cellCb, qciVal[idx2], ((numPrb * sduLen[idx2])/totalBytesRcvd));
1292 /*Added for explicit release - start*/
1295 if(isSpsRnti && dDatInd && dDatInd->numLch)
1297 if(ueCb->ul.spsDatRcvd != 0)
1299 ueCb->ul.explRelCntr = 0;
1300 ueCb->ul.spsDatRcvd = 0;
1304 ueCb->ul.explRelCntr++;
1305 if (ueCb->ul.explRelCntr == ueCb->ul.explRelCnt)
1307 ueCb->ul.explRelCntr = 0;
1308 /* Indicate scheduler for explicit release */
1309 cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
1310 rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
1311 relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1312 relInfo.cRnti = ueCb->ueId;
1313 relInfo.isExplRel = TRUE;
1314 /* Release indicator is called now through the matrix in the function below */
1315 RgMacSchSpsRel( &schPst1, &relInfo );
1316 ueCb->ul.implRelCntr = 0;
1323 if(ueCb->ul.spsDatRcvd != 0)
1325 //ueCb->ul.implRelCntr = 0;
1326 ueCb->ul.explRelCntr = 0;
1327 ueCb->ul.spsDatRcvd = 0;
1331 /*Added for explicit release - end */
1333 if((dDatInd) && (dDatInd->numLch))
1336 rgTomUtlPrepareL2MUlThrpInfo(cellCb, ueCb,dDatInd);
1338 RG_CALC_TTI_CNT(cellCb, dDatInd->ttiCnt);
1340 if ((ret = rgUIMSndDedDatInd(inst,ueCb->rguUlSap,dDatInd)) != ROK)
1342 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
1343 "Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
1348 else if((dDatInd) && (0 == dDatInd->numLch))
1350 /* Free the memory allocated for dDatInd if we
1351 * have no valid LCH PDU to send to RLC.*/
1352 rgFreeSharableSBuf(inst,(Data **)&dDatInd,sizeof(RgRguDedDatInd));
1358 /** @brief This function frees up the RgMacPdu structure that has been
1359 * populated by demux.
1363 * Function: rgTOMUtlInsSchInfo
1364 * - Function frees up the RgMacPdu structure, in case of error it shall
1365 * free up the buffer's present in the different sdu.
1368 * @param [in] RgMacPdu *pdu
1369 * @param [in] Bool *error
1374 PRIVATE S16 rgTOMUtlInsSchInfo
1377 RgInfSfDatInd *sfInfo,
1378 RgInfCeInfo *ceInfo,
1385 PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti,spsToBeActvtd,sduSize, lcgBytes)
1387 RgInfSfDatInd *sfInfo;
1388 RgInfCeInfo *ceInfo;
1397 PRIVATE S16 rgTOMUtlInsSchInfo
1400 RgInfSfDatInd *sfInfo,
1401 RgInfCeInfo *ceInfo,
1406 PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti, lcgBytes)
1408 RgInfSfDatInd *sfInfo;
1409 RgInfCeInfo *ceInfo;
1416 RgInfUeDatInd *ueInfo;
1420 TRC2(rgTOMUtlInsSchInfo);
1422 RG_TOM_INF_ALLOC(sfInfo, sizeof(RgInfUeDatInd), ueInfo, ret);
1429 ueInfo->rnti = rnti;
1431 ueInfo->ceInfo = *ceInfo;
1432 ueInfo->ueLstEnt.node = (PTR)ueInfo;
1433 for (lcgId = 1, idx = 0; lcgId < RGINF_MAX_LCG_PER_UE; lcgId++)
1435 if (lcgBytes[lcgId] != 0)
1437 /* Only GBR bytes */
1438 ueInfo->lcgInfo[idx].lcgId = lcgId;
1439 ueInfo->lcgInfo[idx++].bytesRcvd = lcgBytes[lcgId];
1440 lcgBytes[lcgId] = 0;
1443 cmLListAdd2Tail(&sfInfo->ueLst, &ueInfo->ueLstEnt);
1445 } /* end of rgTOMUtlInsSchInfo */
1449 * @brief Handler for processing data indication recieved from PHY for UEs.
1453 * Function: rgTOMDatInd
1455 * Handler for processing data indication recieved from PHY for UEs.
1457 * Invoked by: RgLiTfuDatInd of LIM
1460 * For each DataInfo recieved
1461 * - Validate the information received and retrieve cellCb
1462 * Validate cellId, rnti
1463 * - Call De-Mux module to decode the data rgDUXDemuxData
1464 * - If received a CRNTI control element
1465 * - Check if a CCCH SDU is present, if it is return failure
1466 * - Check for the existence of UE, if its isnt present return failure.
1467 * - Delegate the remaining processing to rgTOMUtlProcMsg3 which
1468 * primarily informs the scheduler about the data received and
1469 * generates Data indications towards the higher layer.
1470 * - If only CCCH SDU is present
1471 * - Invoke rgTOMUtlProcMsg3 for further processing.
1472 * - If its a non-Msg3 PDU i.e. received outside of a RA procedure
1473 * - Retrieve the UeCB
1474 * - Validate that the received PDU contains only configured Logical
1476 * - Invoke rgTOMUtlProcDatPdu for further processing. It informs the
1477 * scheduler with the information of the received Data and generates
1478 * DatIndications towards the higher layers.
1480 * @param [in] Inst inst
1481 * @param[in] TfuDatIndInfo *datInd
1487 PUBLIC S16 rgTOMDatInd
1490 TfuDatIndInfo *datInd
1493 PUBLIC S16 rgTOMDatInd(inst,datInd)
1495 TfuDatIndInfo *datInd;
1501 RgUeCb *prevUeCb = NULLP;
1504 RgInfSfDatInd *sfInfo;
1508 TfuDatInfo *datInfo;
1512 Bool isSpsRnti=FALSE;
1514 RgInfSpsRelInfo relInfo;
1515 Bool spsToBeActvtd = FALSE;
1518 U32 lcgBytes[RGINF_MAX_LCG_PER_UE];
1522 #ifdef STUB_TTI_HANDLING_5GTF
1523 node = datInd->datIndLst.first;
1524 for (;node; node=node->next)
1526 datInfo = (TfuDatInfo*)node->node;
1529 SFndLenMsg(datInfo->mBuf, &len);
1530 rgUlrate_tfu += len;
1531 if (rgUlrate_tfu > 100000)
1533 printf("Sowmya:rgTOMDatInd datInfo->mBuf len =%d rgUlrate_tfu=%d",len,rgUlrate_tfu);
1541 cmMemset((U8 *)&lcgBytes, 0, sizeof(lcgBytes));
1543 tfuSap = &(rgCb[inst].tfuSap);
1545 cellCb = rgCb[inst].cell;
1546 if((cellCb == NULLP) ||
1547 (cellCb->cellId != datInd->cellId))
1550 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to get the cellCb for cell");
1553 /* Avoiding memset as all the fields are getting initialized further */
1555 if (rgTOMInfAllocPduEvnt (inst,&sfInfo) != ROK)
1557 err.errType = RGERR_TOM_DATIND;
1558 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
1559 node = datInd->datIndLst.first;
1562 cmLListInit(&sfInfo->ueLst);
1563 sfInfo->cellId = datInd->cellId;
1564 sfInfo->timingInfo = datInd->timingInfo;
1565 subframe = datInd->timingInfo.subframe;
1567 node = datInd->datIndLst.first;
1568 for (;node; node=node->next)
1570 datInfo = (TfuDatInfo*)node->node;
1572 //extern U32 ulrate_tfu;
1574 SFndLenMsg(datInfo->mBuf, &len);
1575 #ifdef STUB_TTI_HANDLING_5GTF
1576 // printf("Sowmya:rgTOMDatInd datInfo->mBuf len =%d",len);
1578 rgUlrate_tfu += len;
1580 grgUlrate_tfu += len;
1583 #ifdef STUB_TTI_HANDLING_5GTF
1584 rgLIMUtlFreeDatIndEvnt(datInd,TRUE);
1586 /* We shall call De-Mux to process the received buffer. We shall try and find
1587 * out the RaCb based on the following -
1588 * 1. If the incoming PDU contained a CCCH SDU i.e. this is message 3.
1589 * 2. If the incoming PDU contained a CRNTI control element, i.e. we should
1590 * have a ueCb also for this
1592 /* Lets allocate the event that needs to be passed to DUX */
1593 if (rgTOMUtlAllocPduEvnt (inst,&pdu) != ROK)
1595 err.errType = RGERR_TOM_DATIND;
1596 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
1597 rgTOMInfFreePduEvnt (sfInfo);
1601 if ((ret = rgDUXDemuxData (inst,pdu, &ceInfo,
1602 &datInfo->mBuf, &err)) != ROK)
1605 /* Fix: sriky memory corruption precautions */
1606 rgTOMUtlFreePduEvnt (pdu, TRUE);
1607 err.errType = RGERR_TOM_DATIND;
1608 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"DUX processing failed");
1609 tfuSap->sapSts.numPduDrop++;
1612 /* It could be that a non-msg3 pdu contains a CRNTI Control element. We
1613 * should check for CRNTI CE and if it exists the UECb must exist, also an
1614 * if the CRNTI in the CE and the one with which the message came in are
1615 * different we shall look for an raCb as well.
1618 if (ceInfo.bitMask & RG_CCCH_SDU_PRSNT)
1620 ret = rgTOMProcCCCHSduInDatInd(pdu, prevUeCb, \
1621 cellCb, datInfo, &ceInfo, subframe);
1624 rgTOMUtlFreePduEvnt (pdu, TRUE);
1625 err.errType = RGERR_TOM_DATIND;
1626 tfuSap->sapSts.numPduDrop++;
1629 } /* end of Msg3 processing */
1631 else if (ceInfo.bitMask & RG_CRNTI_CE_PRSNT)
1633 ret = rgTOMProcCrntiCEInDatInd(pdu, prevUeCb, \
1634 cellCb, datInfo, &ceInfo, subframe);
1637 rgTOMUtlFreePduEvnt (pdu, TRUE);
1638 err.errType = RGERR_TOM_DATIND;
1639 tfuSap->sapSts.numPduDrop++;
1643 } /* end of CRNTI based message */
1646 ueCb = rgDBMGetUeCb (cellCb, datInfo->rnti);
1650 /* Try getting the UE using SPS-RNTI. */
1651 ueCb = rgDBMGetSpsUeCb (cellCb, datInfo->rnti);
1655 /* Increment implrelCntr for an empty transmission */
1656 if (pdu->sduLst.count == 0)
1658 ueCb->ul.implRelCntr++;
1659 if (ueCb->ul.implRelCntr == ueCb->ul.implRelCnt)
1661 /* Indicate scheduler for implicit release */
1662 cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
1663 rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
1665 ueCb->ul.implRelCntr = 0;
1666 ueCb->ul.explRelCntr = 0;
1667 relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1668 relInfo.cRnti = ueCb->ueId;
1669 relInfo.isExplRel = FALSE;
1670 RgMacSchSpsRel(&schPst1, &relInfo);
1675 /* Reset the implrelCntr */
1676 ueCb->ul.implRelCntr = 0;
1682 /* Perform failure if ueCb is still NULLP */
1683 rgTOMUtlFreePduEvnt (pdu, TRUE);
1684 err.errType = RGERR_TOM_DATIND;
1685 RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,"RNTI:%d Unable to get the UE CB",
1687 tfuSap->sapSts.numPduDrop++;
1692 rgTOMUtlL2MStoreBufSz(ueCb, &ceInfo);
1693 rgTOML2MCompileActiveLCs (cellCb, ueCb, pdu, &ceInfo);
1696 if ((ret = rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,&spsToBeActvtd,&sduSize, subframe, (U32 *)&lcgBytes)) != ROK)
1698 if ((ret = rgTOMUtlProcMsg (cellCb, ueCb, pdu, subframe, (U32 *)&lcgBytes)) != ROK)
1699 #endif /* LTEMAC_SPS */
1701 rgTOMUtlFreePduEvnt (pdu, TRUE);
1702 err.errType = RGERR_TOM_DATIND;
1703 RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,
1704 "Unable to handle Data Indication CRNTI:%d",ueCb->ueId);
1705 tfuSap->sapSts.numPduDrop++;
1712 if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti,spsToBeActvtd,sduSize, (U32 *)&lcgBytes) != ROK)
1714 if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti, (U32 *)&lcgBytes) != ROK)
1718 rgTOMInfFreePduEvnt (sfInfo);
1719 rgTOMUtlFreePduEvnt (pdu, FALSE);
1722 /* free up the PDU memory */
1723 rgTOMUtlFreePduEvnt (pdu, FALSE);
1725 /* Free the allocated memory for ueUlAllocInfo here */
1727 if(cellCb->ulSf[(subframe % RG_NUM_SUB_FRAMES)].ueUlAllocInfo != NULLP)
1729 /*ccpu00117052 - MOD - Passing double for proper NULLP
1731 rgFreeSBuf(inst,(Data **)&(cellCb->ulSf[(subframe % RG_NUM_SUB_FRAMES)].ueUlAllocInfo),
1732 ((cellCb->ulSf[(subframe % RG_NUM_SUB_FRAMES)].numUe) * sizeof(RgUeUlAlloc)));
1736 /* Update PRB used for all GBR QCIs to scheduler */
1737 cmMemcpy((U8*) &sfInfo->qcisUlPrbCnt[0],
1738 (U8*) &cellCb->qcisUlPrbCnt[0],
1739 (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1740 /* clear the cellCb ul prb value */
1741 cmMemset((U8*)&cellCb->qcisUlPrbCnt[0], 0,
1742 (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1746 rgGetPstToInst(&schPst, inst,cellCb->schInstMap.schInst);
1747 sfInfo->cellSapId = cellCb->schInstMap.cellSapId;
1748 RgMacSchSfRecp(&schPst, sfInfo);
1753 * @brief Function handles allocation for common channels i.e. BCCH-BCH,
1754 * BCCH-DLSCH, PCCH-DLSCH.
1758 * Function : rgHndlCmnChnl
1760 * This function is invoked from RgSchMacSfAllocReq. This function handles
1761 * allocations made for common channels like BCCH and PCCH.
1764 * 1. If BCCH on BCH has been scheduled, send StatusIndication on RGU.
1765 * 2. If PCCH is scheduled, send StatusIndication on RGU.
1766 * 3. If BCCH on DLSCH has been scheduled and sndStatInd is TRUE, send
1767 * StatusIndication on RGU, else copy the bcch buffer onto the downlink
1771 * @param[in] RgCellCb *cell,
1772 * @param[in] CmLteTimingInfo timingInfo,
1773 * @param[in] RgInfCmnLcInfo *cmnLcInfo,
1774 * @param[in/out] RgErrInfo *err,
1780 PRIVATE S16 rgHndlCmnChnl
1783 CmLteTimingInfo timingInfo,
1784 RgInfCmnLcInfo *cmnLcInfo,
1788 PRIVATE S16 rgHndlCmnChnl(cell, timingInfo, cmnLcInfo, err)
1790 CmLteTimingInfo timingInfo;
1791 RgInfCmnLcInfo *cmnLcInfo;
1795 #if (ERRCLASS & ERRCLS_DEBUG)
1799 RgBcchDlschLcCb *bcch;
1800 #if (ERRCLASS & ERRCLS_DEBUG)
1803 #endif/*RGR_SI_SCH*/
1804 RguCStaIndInfo *staInd;
1806 Inst inst = cell->macInst - RG_INST_START;
1810 dlSf = &cell->subFrms[(timingInfo.subframe % RG_NUM_SUB_FRAMES)];
1812 if(cmnLcInfo->bitMask & RGINF_BCH_INFO)
1815 #if (ERRCLASS & ERRCLS_DEBUG)
1816 if(NULLP == (bch = rgDBMGetBcchOnBch(cell)))
1820 if(cmnLcInfo->bchInfo.lcId != bch->lcId)
1826 if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1828 err->errCause = RGERR_TOM_MEM_EXHAUST;
1831 staInd->cellId = cell->cellId;
1832 staInd->rnti = RG_INVALID_RNTI;
1833 staInd->lcId = cmnLcInfo->bchInfo.lcId;
1834 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.subframe);
1835 /* ADD Changes for Downlink UE Timing Optimization */
1836 #ifdef LTEMAC_DLUE_TMGOPTMZ
1837 dlSf->remDatReqCnt++;
1839 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1844 /*Store the received BCH Data in the scheduled subframe*/
1845 dlSf->bch.tb = cmnLcInfo->bchInfo.pdu;
1846 #endif/*RGR_SI_SCH*/
1849 if(cmnLcInfo->bitMask & RGINF_PCCH_INFO)
1851 #if (ERRCLASS & ERRCLS_DEBUG)
1852 if(NULLP == (pcch = rgDBMGetPcch(cell)))
1856 if(cmnLcInfo->pcchInfo.lcId != pcch->lcId)
1862 dlSf->pcch.pdcch.rnti =
1863 cmnLcInfo->pcchInfo.rnti;
1864 dlSf->pcch.pdcch.dci =
1865 cmnLcInfo->pcchInfo.dciInfo;
1867 /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */
1868 dlSf->pcch.txPwrOffset = cmnLcInfo->pcchInfo.txPwrOffset;
1870 if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1872 err->errCause = RGERR_TOM_MEM_EXHAUST;
1875 staInd->cellId = cell->cellId;
1876 staInd->rnti = RG_INVALID_RNTI;
1877 staInd->lcId = cmnLcInfo->pcchInfo.lcId;
1878 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.subframe);
1879 /* ADD Changes for Downlink UE Timing Optimization */
1880 #ifdef LTEMAC_DLUE_TMGOPTMZ
1881 dlSf->remDatReqCnt++;
1883 /* for consolidated CmnStaInd calling below function from function
1884 * rgHndlSchedUe once CmnStaInd prepared for all UEs
1886 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1892 if(cmnLcInfo->bitMask & RGINF_BCCH_INFO)
1894 dlSf->bcch.pdcch.rnti =
1895 cmnLcInfo->bcchInfo.rnti;
1896 dlSf->bcch.pdcch.dci =
1897 cmnLcInfo->bcchInfo.dciInfo;
1899 /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */
1900 dlSf->bcch.txPwrOffset = cmnLcInfo->bcchInfo.txPwrOffset;
1904 (bcch=rgDBMGetBcchOnDlsch(cell,cmnLcInfo->bcchInfo.lcId)))
1908 if(TRUE == cmnLcInfo->bcchInfo.sndStatInd)
1910 RG_FREE_MSG(bcch->tb);
1911 if (rgAllocShrablSBuf (inst,(Data**)&staInd,
1912 sizeof(RguCStaIndInfo)) != ROK)
1914 err->errCause = RGERR_TOM_MEM_EXHAUST;
1917 staInd->cellId = cell->cellId;
1918 staInd->rnti = RG_INVALID_RNTI;
1919 staInd->lcId = cmnLcInfo->bcchInfo.lcId;
1920 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.subframe);
1921 /* ADD Changes for Downlink UE Timing Optimization */
1922 #ifdef LTEMAC_DLUE_TMGOPTMZ
1923 dlSf->remDatReqCnt++;
1925 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1932 SCpyMsgMsg(bcch->tb, RG_GET_MEM_REGION(rgCb[inst]),
1933 RG_GET_MEM_POOL(rgCb[inst]), &dlSf->bcch.tb);
1936 /*Store the received BCCH Data in the scheduled subframe*/
1937 dlSf->bcch.tb = cmnLcInfo->bcchInfo.pdu;
1938 #endif/*RGR_SI_SCH*/
1942 } /* end of rgHndlCmnChnl */
1945 * @brief Function for handling allocations for dedicated channels for a
1950 * Function : rgHndlSchdUe
1952 * This function shall be invoked whenever scheduler is done with the
1953 * allocations of dedicated channels for a subframe. Invoked by the function
1954 * RgSchMacSfAllocReq.
1956 * Processing steps :
1957 * 1. Loops through the list of UE's scheduled looking for the corresponding
1959 * 2. Finds the corresponding HARQ process.
1960 * 3. Invokes the DHM function to issue StatusIndications on RGU.
1963 * @param[in] RgCellCb *cell,
1964 * @param[in] CmLteTimingInfo timingInfo,
1965 * @param[in] RgInfUeInfo *ueInfo
1966 * @param[in/out] RgErrInfo *err
1972 PRIVATE S16 rgHndlSchdUe
1975 CmLteTimingInfo timingInfo,
1976 RgInfUeInfo *ueInfo,
1980 PRIVATE S16 rgHndlSchdUe(cell, timingInfo, ueInfo, err) /* laa_ut_fix */
1982 CmLteTimingInfo timingInfo;
1983 RgInfUeInfo *ueInfo;
1990 if(NULLP == ueInfo->allocInfo)
1995 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err);
1998 } /* end of rgHndlSchdUe */
2002 * @brief Function for handling Uplink allocations for Ue for a
2007 * Function : rgHndlUlUeInfo
2009 * @param[in] RgCellCb *cell,
2010 * @param[in] CmLteTimingInfo timingInfo,
2011 * @param[in] RgInfUlUeInfo *ueInfo
2017 PRIVATE S16 rgHndlUlUeInfo
2020 CmLteTimingInfo timingInfo,
2021 RgInfUlUeInfo *ueInfo
2024 PRIVATE S16 rgHndlUlUeInfo(cell, timingInfo, ueInfo)
2026 CmLteTimingInfo timingInfo;
2027 RgInfUlUeInfo *ueInfo;
2030 Inst inst = cell->macInst - RG_INST_START;
2035 TRC2(rgHndlUlUeInfo)
2037 ulSf = &cell->ulSf[(timingInfo.subframe % RGSCH_NUM_SUB_FRAMES)];
2039 /* rg003.301-MOD- Corrected the purifier memory leak */
2040 if (ulSf->numUe != ueInfo->numUes)
2042 if (ulSf->ueUlAllocInfo)
2044 rgFreeSBuf(inst,(Data **)&(ulSf->ueUlAllocInfo),
2045 ulSf->numUe * sizeof(RgUeUlAlloc));
2048 #ifdef XEON_SPECIFIC_CHANGES
2049 CM_MEAS_TIME((cell->crntTime.subframe % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_FREE);
2050 CM_ADD_INFO((cell->crntTime.subframe % RGSCH_NUM_SUB_FRAMES), CM_DBG_MEAS_FREE, ulSf->numUe);
2052 ulSf->numUe = ueInfo->numUes;
2053 if((ulSf->ueUlAllocInfo == NULLP) && (ueInfo->numUes > 0))
2055 /* Allocate memory for ulAllocInfo */
2056 if((ret = rgAllocSBuf(inst,(Data**)&(cell->ulSf[(timingInfo.subframe % RGSCH_NUM_SUB_FRAMES)].
2057 ueUlAllocInfo), ueInfo->numUes * sizeof(RgUeUlAlloc))) != ROK)
2062 #ifdef XEON_SPECIFIC_CHANGES
2063 CM_MEAS_TIME((cell->crntTime.subframe % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_ALLOC);
2064 CM_ADD_INFO((cell->crntTime.subframe % RGSCH_NUM_SUB_FRAMES), CM_DBG_MEAS_ALLOC, ueInfo->numUes);
2066 if (ulSf->ueUlAllocInfo != NULLP)
2068 for(idx = 0; idx < ueInfo->numUes; idx++)
2070 ulSf->ueUlAllocInfo[idx].rnti = ueInfo->ulAllocInfo[idx].rnti;
2071 ulSf->ueUlAllocInfo[idx].numPrb = ueInfo->ulAllocInfo[idx].numPrb;
2074 RGCPYTIMEINFO(timingInfo, ulSf->schdTime);
2076 } /* end of rgHndlUlUeInfo */
2079 * @brief Function for handling RaResp request received from scheduler to MAC
2083 * Function : rgTOMRlsSf
2085 * This function shall be invoked whenever scheduler is done with the
2086 * allocations of random access responses for a subframe.
2087 * This shall invoke RAM to create ueCbs for all the rapIds allocated and
2088 * shall invoke MUX to create RAR PDUs for raRntis allocated.
2091 * @param[in] Inst inst
2092 * @param[in] CmLteCellId cellId,
2093 * @param[in] CmLteTimingInfo timingInfo,
2094 * @param[in] RaRespInfo *rarInfo
2099 PUBLIC Void rgTOMRlsSf
2105 PUBLIC Void rgTOMRlsSf(dlSf)
2114 if(dlSf->txDone == FALSE)
2116 RLOG0(L_ERROR, "SUBFRAME Not pushed to the PHY");
2118 if (dlSf->bch.tb != NULLP)
2120 RG_FREE_MSG(dlSf->bch.tb);
2122 if (dlSf->bcch.tb != NULLP)
2124 RG_FREE_MSG(dlSf->bcch.tb);
2126 if (dlSf->pcch.tb != NULLP)
2128 RG_FREE_MSG(dlSf->pcch.tb);
2131 rgTOMEmtcRlsSf(dlSf);
2133 for(idx=0; idx < dlSf->numRaRsp; idx++)
2135 RG_FREE_MSG(dlSf->raRsp[idx].rar);
2138 /* ADD Changes for Downlink UE Timing Optimization */
2139 #ifdef LTEMAC_DLUE_TMGOPTMZ
2140 dlSf->remDatReqCnt = 0;
2141 /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2143 dlSf->statIndDone = FALSE;
2145 if (dlSf->tbs.count)
2150 RGDBGERRNEW(inst, (rgPBuf(inst),
2151 "Error Stale TBs in Subframes TBS list\n"));
2152 node = dlSf->tbs.first;
2155 hqP = (RgDlHqProcCb*)node->node;
2159 for(i=0;i< RG_MAX_TB_PER_UE;i++)
2161 if (hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.subframe % 2].sf == dlSf)
2163 cmLListDelFrm(&dlSf->tbs, &(hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.subframe % 2].sfLnk));
2164 hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.subframe % 2].sfLnk.node = NULLP;
2165 printf("\n rgTOMRlsSf:: hqP %p \n", (Void *)hqP);
2167 hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.subframe % 2].sf = NULLP;
2172 /*arjun: check if dlSf laaTb list has to be freed???*/
2173 cmLListInit(&dlSf->tbs);
2174 dlSf->txDone = FALSE;
2180 * @brief Function is called by the scheduler once it has completed the
2181 * allocation for the subframe.
2185 * Function : rgHndlFlowCntrl
2186 * This function should fill and send Flow control
2190 * @param[in] Pst *cell
2191 * @param[in] RgInfSfAlloc *sfInfo Carries all the allocation
2197 PUBLIC S16 rgHndlFlowCntrl
2200 RgInfSfAlloc *sfInfo
2203 PUBLIC S16 rgHndlFlowCntrl(cell, sfInfo)
2205 RgInfSfAlloc *sfInfo;
2208 RguFlowCntrlInd *flowCntrlInd;
2212 TRC3(rgHndlFlowCntrl);
2214 pst = &cell->rguDlSap->sapCfg.sapPst;
2215 /* flowCntrlInd is alloced in cell init time and will be re-used throughout */
2216 flowCntrlInd = cell->flowCntrlInd;
2217 flowCntrlInd->cellId = sfInfo->cellId;
2218 flowCntrlInd->numUes = sfInfo->flowCntrlInfo.numUes;
2220 for (ueIdx = 0; ueIdx < sfInfo->flowCntrlInfo.numUes; ueIdx++)
2222 flowCntrlInd->ueFlowCntrlInfo[ueIdx].ueId = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].ueId;
2223 flowCntrlInd->ueFlowCntrlInfo[ueIdx].numLcs = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].numLcs;
2225 for (lcIdx = 0; lcIdx < RGINF_MAX_NUM_DED_LC; lcIdx++)
2227 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId =
2228 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId;
2229 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt =
2230 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt;
2232 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl =
2233 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl;
2236 RgUiRguFlowCntrlInd(pst, cell->rguDlSap->sapCfg.spId,flowCntrlInd); /* TODO: Rishi confirm if the suId and pst pointer is correct */
2240 * @brief Function is called by the scheduler once it has completed the
2241 * allocation for the subframe.
2245 * Function : RgSchMacSfAllocReq
2247 * This function shall be invoked whenever scheduler is done with the
2248 * allocations of for a subframe. The sfInfo carries all the allocation
2249 * details for the common channels, RA responses and dedicated channel
2252 * Processing steps :
2253 * 1. Reset the information present in the downlink subframe that is
2255 * 2. Handle common channel allocations
2256 * 3. Handle RA Response allocations
2257 * 4. Handle dedicated channel allocations.
2259 * @param[in] Pst *pst
2260 * @param[in] RgInfSfAlloc *sfInfo Carries all the allocation
2266 PUBLIC S16 RgSchMacSfAllocReq
2269 RgInfSfAlloc *sfInfo
2272 PUBLIC S16 RgSchMacSfAllocReq(pst, sfInfo)
2274 RgInfSfAlloc *sfInfo;
2280 VOLATILE U32 startTime=0;
2283 TRC2(RgSchMacSfAllocReq)
2285 RG_IS_INST_VALID(pst->dstInst);
2286 inst = pst->dstInst - RG_INST_START;
2288 SStartTask(&startTime, PID_MAC_SF_ALLOC_REQ);
2295 if((cell = rgCb[inst].cell) == NULLP)
2297 RLOG_ARG0(L_ERROR,DBG_CELLID,sfInfo->cellId, "No cellCb found with cell");
2301 dlSf = &cell->subFrms[(sfInfo->timingInfo.subframe % RG_NUM_SUB_FRAMES)];
2303 rgTOMRlsSf(inst,dlSf);
2304 dlSf->schdTime = sfInfo->timingInfo;
2307 rgLaaInitTbInfoLst(cell);
2310 /* Fix : syed Ignore Failure Returns and continue processing.
2311 * Incomplete processing results in state sync loss between MAC-SCH. */
2313 if(TRUE == cell->emtcEnable)
2315 rgEmtcHndl(cell, sfInfo);
2318 rgHndlCmnChnl(cell, sfInfo->timingInfo, &sfInfo->cmnLcInfo, &err);
2320 rgHndlRaResp(cell, sfInfo->timingInfo, &sfInfo->rarInfo, &err);
2323 #ifdef XEON_SPECIFIC_CHANGES
2324 CM_MEAS_TIME((cell->crntTime.subframe % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_B4_UE_SCHD);
2326 rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2327 #ifdef XEON_SPECIFIC_CHANGES
2328 CM_MEAS_TIME((cell->crntTime.subframe % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_UE_SCHD);
2330 rgLaaChkAndReqTbs(dlSf,cell, inst);
2333 rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2337 if(rgHndlUlUeInfo(cell, sfInfo->ulUeInfo.timingInfo,
2338 &sfInfo->ulUeInfo) != ROK)
2343 #ifdef XEON_SPECIFIC_CHANGES
2344 CM_MEAS_TIME((cell->crntTime.subframe % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_MEAS);
2346 /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2350 /* Added the handling for pushing down
2351 * TFU Data request in the retransmission only scenario.*/
2352 #ifdef LTEMAC_DLUE_TMGOPTMZ
2353 dlSf->statIndDone = TRUE;
2354 /* Fix [ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2356 if(!(dlSf->txDone) &&
2358 (TRUE == rgLaaChkAllRxTbs(dlSf)) &&
2360 (0 == dlSf->remDatReqCnt) && (dlSf->statIndDone) &&
2361 (RG_TIMEINFO_SAME(cell->crntTime, dlSf->schdTime)))
2363 /*This is the case of rettransmission, so no need
2364 * to wait for TTI Ind to push TFU Data Request. Send
2366 if (ROK != rgTOMUtlProcDlSf (dlSf, cell, &err))
2368 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to process downlink subframe for cell");
2369 err.errType = RGERR_ROM_DEDDATREQ;
2371 /* Mark this frame as sent */
2372 dlSf->txDone = TRUE;
2375 if (sfInfo->flowCntrlInfo.numUes > 0)
2377 rgHndlFlowCntrl(cell,sfInfo);
2380 SStopTask(startTime, PID_MAC_SF_ALLOC_REQ);
2382 } /* end of RgSchMacSfAllocReq */
2384 * @brief Handler for processing data indication recieved from PHY for UEs.
2388 * Function: rgTOMProcCrntiCEInDatInd
2390 * Handler for processing data indication recieved from PHY for UEs.
2392 * Invoked by: RgLiTfuDatInd of LIM
2395 * For each DataInfo recieved
2396 * - If received a CRNTI control element
2397 * - Check if a CCCH SDU is present, if it is return failure
2398 * - Check for the existence of UE, if its isnt present return failure.
2399 * - Delegate the remaining processing to rgTOMUtlProcMsg3 which
2400 * primarily informs the scheduler about the data received and
2401 * generates Data indications towards the higher layer.
2403 * @param RgMacPdu *pdu,
2404 * @param RgUeCb *prevUeCb,
2405 * @param RgCellCb *cellCb,
2406 * @param TfuDatInfo *datInfo,
2407 * @param RgInfCeInfo *ceInfo
2413 PRIVATE S16 rgTOMProcCrntiCEInDatInd
2418 TfuDatInfo *datInfo,
2419 RgInfCeInfo *ceInfo,
2423 PRIVATE S16 rgTOMProcCrntiCEInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, subframe)
2427 TfuDatInfo *datInfo;
2428 RgInfCeInfo *ceInfo;
2432 RgUeCb *ueCb = NULLP;
2433 Inst inst = cellCb->macInst - RG_INST_START;
2441 TRC2(rgTOMProcCrntiCEInDatInd)
2447 ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2451 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2452 "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2456 prevUeCb = rgDBMGetUeCb (cellCb, ceInfo->ces.cRnti);
2457 if (prevUeCb == NULLP)
2459 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2460 "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2463 RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
2464 "CRNTI CE(%d) received through tmpCrnti(%d)",
2465 ceInfo->ces.cRnti, datInfo->rnti);
2466 rgDBMDelUeCbFromRachLst(cellCb, ueCb);
2467 rgRAMFreeUeCb(inst,ueCb);
2470 if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, subframe, NULLP)) != ROK)
2472 if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, subframe, NULLP)) != ROK)
2473 #endif /* LTEMAC_SPS */
2475 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2476 "RNTI:%d Processing for MSG3 failed",datInfo->rnti);
2482 * @brief Handler for processing data indication recieved from PHY for UEs.
2486 * Function: rgTOMProcCCCHSduInDatInd
2488 * Handler for processing data indication recieved from PHY for UEs.
2490 * Invoked by: RgLiTfuDatInd of LIM
2493 * For each DataInfo recieved
2494 * - If only CCCH SDU is present
2495 * - Invoke rgTOMUtlProcMsg3 for further processing.
2496 * - If its a non-Msg3 PDU i.e. received outside of a RA procedure
2497 * - Retrieve the UeCB
2498 * - Validate that the received PDU contains only configured Logical
2500 * - Invoke rgTOMUtlProcDatPdu for further processing. It informs the
2501 * scheduler with the information of the received Data and generates
2502 * DatIndications towards the higher layers.
2504 * @param TfuDatIndInfo *datInd
2505 * @param RgMacPdu *pdu,
2506 * @param RgUeCb *prevUeCb,
2507 * @param RgCellCb *cellCb,
2508 * @param TfuDatInfo *datInfo,
2509 * @param RgInfCeInfo *ceInfo
2515 PRIVATE S16 rgTOMProcCCCHSduInDatInd
2520 TfuDatInfo *datInfo,
2521 RgInfCeInfo *ceInfo,
2525 PRIVATE S16 rgTOMProcCCCHSduInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, subframe)
2529 TfuDatInfo *datInfo;
2530 RgInfCeInfo *ceInfo;
2534 RgUeCb *ueCb = NULLP;
2535 Inst inst = cellCb->macInst - RG_INST_START;
2543 TRC2(rgTOMProcCCCHSduInDatInd)
2549 if (ceInfo->bitMask & RG_CRNTI_CE_PRSNT)
2551 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2552 "CRNTI:%d Received MSG3 with CCCH",ceInfo->ces.cRnti);
2556 ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2560 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2561 "RNTI:%d Processing for MSG3 failed", datInfo->rnti);
2564 /* Fix: syed Drop any duplicate Msg3(CCCH Sdu) */
2565 if (ueCb->dl.hqEnt.numHqProcs)
2567 /* HqE is already initialized by a previuos Msg3 */
2568 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed. Duplicate "
2569 "MSG3 received. Dropping", datInfo->rnti);
2573 if(rgDHMHqEntInit(inst,&ueCb->dl.hqEnt,
2574 cellCb->maxDlHqProcPerUe) != ROK)
2576 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Harq Initialization failed ",
2580 RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
2581 "CCCH SDU received through tmpCrnti(%d)",datInfo->rnti);
2583 if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, subframe, NULLP)) != ROK)
2585 if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, subframe, NULLP)) != ROK)
2586 #endif /* LTEMAC_SPS */
2588 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed",
2597 /** @brief This function captures the BSR value from Control Element
2598 * Info structure and updates the effective Buffer size into the
2599 * corresponding LCG ID.
2603 * Function: rgTOMUtlL2MStoreBufSz
2606 * - update/append the Data structure based on BSR type
2608 * @param [in] RgUeCb *ueCb
2609 * @param [in] RgInfCeInfo *ceInfo
2614 PRIVATE S16 rgTOMUtlL2MStoreBufSz
2620 PRIVATE S16 rgTOMUtlL2MStoreBufSz (ueCb, ceInfo)
2622 RgInfCeInfo *ceInfo;
2627 TRC2(rgTOMUtlL2MStoreBufSz);
2629 if(ceInfo->bitMask & RG_TRUNC_BSR_CE_PRSNT)
2631 lcgId = ((ceInfo->ces.bsr.truncBsr >> 6) & 0x03);
2632 bsr = ceInfo->ces.bsr.truncBsr & 0x3F;
2633 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2635 else if(ceInfo->bitMask & RG_SHORT_BSR_CE_PRSNT)
2637 lcgId = ((ceInfo->ces.bsr.shortBsr >> 6) & 0x03);
2638 bsr = ceInfo->ces.bsr.shortBsr & 0x3F;
2639 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2642 else if(ceInfo->bitMask & RG_LONG_BSR_CE_PRSNT)
2644 ueCb->ul.lcgArr[0].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs1];
2645 ueCb->ul.lcgArr[1].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs2];
2646 ueCb->ul.lcgArr[2].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs3];
2647 ueCb->ul.lcgArr[3].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs4];
2650 } /* end of rgTOMUtlL2MStoreBufSz*/
2652 /** @brief : Compiles list of LCs received in UL data for DTCH RBs
2656 * @param [in] RgCellCb *cellCb
2657 * @param [in] RgUeCb *ueCb
2658 * @param [in] CmLteRnti rnti
2659 * @param [in] RgMacPdu *pdu
2666 PRIVATE Void rgTOML2MCompileActiveLCs
2674 PRIVATE Void rgTOML2MCompileActiveLCs(cellCb, ueCb, pdu, ceInfo)
2678 RgInfCeInfo *ceInfo;
2685 TRC2(rgTOML2MCompileActiveLCs)
2687 node = pdu->sduLst.first;
2690 sdu = (RgMacSdu*)node->node;
2692 if ((ulLcCb = rgDBMGetUlDedLcCb(ueCb, sdu->lcId)), ulLcCb != NULLP)
2694 if (ulLcCb->lcgId != 0)
2696 ceInfo->bitMask |= RG_ACTIVE_LC_PRSNT;
2697 ceInfo->ulActLCs[ulLcCb->lcId - 1] = TRUE;
2708 /**********************************************************************
2711 **********************************************************************/