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 "du_app_mac_inf.h"
80 #include "rg.x" /* typedefs for MAC */
81 #include "lwr_mac_fsm.h"
82 #ifdef MAC_RLC_UL_RBUF
87 /* ADD Changes for Downlink UE Timing Optimization */
88 #ifndef LTEMAC_DLUE_TMGOPTMZ
89 PRIVATE S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf, RgCellCb *cellCb,
92 PUBLIC S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
95 PRIVATE S16 rgTOMProcCrntiCEInDatInd ARGS((
104 PRIVATE S16 rgTOMProcCCCHSduInDatInd ARGS((
113 PUBLIC S16 rgHndlFlowCntrl
119 EXTERN S16 RgUiRguFlowCntrlInd(Pst* pst, SuId suId, RguFlowCntrlInd *flowCntrlInd);
121 EXTERN S16 rgEmtcHndl(RgCellCb *cell,RgInfSfAlloc *sfInfo);
122 EXTERN S16 rgTOMEmtcUtlFillDatReqPdus(TfuDatReqInfo *datInfo, RgDlSf *dlSf, RgCellCb *cell, RgErrInfo *err);
123 EXTERN Void rgTOMEmtcRlsSf(RgDlSf *dlSf);
126 PRIVATE Void rgTOML2MCompileActiveLCs ARGS
133 PRIVATE S16 rgTOMUtlL2MStoreBufSz ARGS
139 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo ARGS
143 RgRguDedDatInd *dDatInd
147 /* The below table takes lower values of BSR Range for a BSR value
148 This is to ensure that outstanding can be decrease to zero upon reception of
149 TB, which is not guaranteed if higher Range values are used */
150 /* Note: taking value 10 for BSR index 1 */
151 #ifndef MAC_5GTF_UPDATE
152 PRIVATE U32 rgLwrBsrTbl[64] = {
153 0, 10, 10, 12, 14, 17, 19, 22, 26,
154 31, 36, 42, 49, 57, 67, 78, 91,
155 107, 125, 146, 171, 200, 234, 274, 321,
156 376, 440, 515, 603, 706, 826, 967, 1132,
157 1326, 1552, 1817, 2127, 2490, 2915, 3413, 3995,
158 4677, 5476, 6411, 7505, 8787, 10287, 12043, 14099,
159 16507, 19325, 22624, 26487, 31009, 36304, 42502, 49759,
160 58255, 68201, 79846, 93479, 109439, 128125, 150000
164 PRIVATE U32 rgLwrBsrTbl[64] = {
165 0,10,13,16,19,23,29,35,43,53,65,80,98,120,147,181,223,274,337,414,
166 509,625,769,945,1162,1429,1757,2161,2657,3267,4017,4940,6074,7469,
167 9185,11294,13888,17077,20999,25822,31752,39045,48012,59039,72598,
168 89272,109774,134986,165989,204111,250990,308634,379519,466683,
169 573866,705666,867737,1067031,1312097,1613447,1984009,2439678,
177 #define RG_TOM_INF_ALLOC(_pdu, _size, _dataPtr, _ret) {\
178 _ret = cmGetMem((Ptr)&_pdu->memCp, _size, (Ptr *)&_dataPtr); \
181 /* global variables */
182 PUBLIC U32 rgUlrate_tfu;
184 EXTERN U32 grgUlrate_tfu;
187 /** @brief This function fills the PDSCH data of a downlink subframe
191 * Function: rgTOMUtlFillDatReqPdus
194 * - Fill BCCH on DLSCH data using datInfo
195 * - Fill PCCH on DLSCH data using datInfo
196 * - Fill Dedicated data on DLSCH data using datInfo
197 * - Fill RA RSP data using datInfo
199 * @param [out] TfuDatReqInfo *datInfo
200 * @param [in] RgDlSf *dlSf
201 * @param [in] RgCellCb *cellCb
202 * @param [out] RgErrInfo *err
208 PRIVATE S16 rgTOMUtlFillDatReqPdus
210 TfuDatReqInfo *datInfo,
216 PRIVATE S16 rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)
217 TfuDatReqInfo *datInfo;
224 TfuDatReqPduInfo *datReq=NULLP;
225 /* Moving node declaration to limited scope for optimization */
228 Inst inst = cellCb->macInst - RG_INST_START;
230 TRC2(rgTOMUtlFillDatReqPdus)
232 /* first lets send the BCCH data down to PHY */
233 if (dlSf->bcch.tb != NULLP)
235 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
236 &(datInfo->memCp))) != ROK)
238 err->errCause = RGERR_TOM_MEM_EXHAUST;
239 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion ");
242 #ifdef TFU_ALLOC_EVENT_NO_INIT
246 datReq->tbInfo[0].lchInfo[0].mBuf[0]=NULLP;
249 datReq->rnti = RG_SI_RNTI;
250 datReq->dciInfo = dlSf->bcch.pdcch.dci;
251 /* Note: SCpyMsgMsg is not done since free of unsent buffer
252 * has been taken care through cell delete by invoking rgTomRlsSf
254 datReq->nmbOfTBs = 1;
256 datReq->mBuf[0] = dlSf->bcch.tb;
258 SFndLenMsg((Buffer *)dlSf->bcch.tb, &(datReq->tbInfo[0].tbSize));
259 datReq->tbInfo[0].tbPres = TRUE;
260 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->bcch.tb;
261 datReq->tbInfo[0].numLch = 1;
262 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
264 #ifdef TFU_ALLOC_EVENT_NO_INIT
265 datReq->tbInfo[1].tbPres = FALSE;
266 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
269 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
270 datReq->lnk.node = (PTR)datReq;
272 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
273 datReq->txPwrOffset = dlSf->bcch.txPwrOffset;
275 /* Setting the pointer to NULL post transmission */
276 dlSf->bcch.tb = NULLP;
279 if (dlSf->pcch.tb != NULLP)
281 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
282 &(datInfo->memCp))) != ROK)
284 err->errCause = RGERR_TOM_MEM_EXHAUST;
285 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",datReq->rnti);
288 #ifdef TFU_ALLOC_EVENT_NO_INIT
293 datReq->rnti = RG_P_RNTI;
294 datReq->dciInfo = dlSf->pcch.pdcch.dci;
295 datReq->nmbOfTBs = 1;
297 datReq->mBuf[0] = dlSf->pcch.tb;
299 SFndLenMsg((Buffer *)dlSf->pcch.tb, &datReq->tbInfo[0].tbSize);
300 datReq->tbInfo[0].tbPres = TRUE;
301 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->pcch.tb;
302 #ifdef TFU_ALLOC_EVENT_NO_INIT
303 datReq->tbInfo[1].tbPres = FALSE;
304 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
306 datReq->tbInfo[0].numLch = 1;
307 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
309 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
310 datReq->lnk.node = (PTR)datReq;
312 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
313 datReq->txPwrOffset = dlSf->pcch.txPwrOffset;
315 dlSf->pcch.tb = NULLP;
318 for(idx=0; idx < dlSf->numRaRsp; idx++)
320 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
321 &(datInfo->memCp))) != ROK)
323 err->errCause = RGERR_TOM_MEM_EXHAUST;
324 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",
328 #ifdef TFU_ALLOC_EVENT_NO_INIT
333 datReq->rnti = dlSf->raRsp[idx].pdcch.rnti;
334 datReq->dciInfo = dlSf->raRsp[idx].pdcch.dci;
335 datReq->nmbOfTBs = 1;
337 datReq->mBuf[0] = dlSf->raRsp[idx].rar;
339 SFndLenMsg((Buffer *)dlSf->raRsp[idx].rar, &datReq->tbInfo[0].tbSize);
340 datReq->tbInfo[0].tbPres = TRUE;
341 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->raRsp[idx].rar;
342 #ifdef TFU_ALLOC_EVENT_NO_INIT
343 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
344 datReq->tbInfo[1].tbPres = FALSE;
346 datReq->tbInfo[0].numLch = 1;
347 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
348 // prc_trace_format_string(0x40,3,"UE Id=(%d) tbSz=(%d)",datReq->rnti, datReq->tbInfo[0].tbSize);
350 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
351 datReq->lnk.node = (PTR)datReq;
353 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
354 datReq->txPwrOffset = dlSf->raRsp[idx].txPwrOffset;
356 dlSf->raRsp[idx].rar = NULLP;
359 /* Fill Dedicated UE data */
360 if (dlSf->tbs.count != 0)
363 while (dlSf->tbs.first)
365 node = dlSf->tbs.first;
366 hqCb = (RgDlHqProcCb*)node->node;
367 if ((ret = rgDHMSndDatReq (cellCb, dlSf, datInfo, hqCb, err)) != ROK)
369 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
370 "DHM unable to fill DATA request");
371 err->errType = RGERR_TOM_TTIIND;
378 } /* end of rgTOMUtlFillDatReqPdus*/
380 /** @brief This function does all the processing related to a single downlink
385 * Function: rgTOMUtlProcDlSf
388 * - collate control data for all UEs and send to PHY
389 * - collate data buffers for all UEs and send to PHY
391 * @param [in] RgDlSf *dlSf
392 * @param [in] RgCellCb *cellCb
393 * @param [out] RgErrInfo *err
396 /* ADD Changes for Downlink UE Timing Optimization */
397 #ifndef LTEMAC_DLUE_TMGOPTMZ
399 PRIVATE S16 rgTOMUtlProcDlSf
406 PRIVATE S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
413 PUBLIC S16 rgTOMUtlProcDlSf
420 PUBLIC S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
428 TfuDatReqInfo *datInfo;
429 Inst inst = cellCb->macInst - RG_INST_START;
431 TRC2(rgTOMUtlProcDlSf);
433 /* Fill Data Request Info from scheduler to PHY */
434 if ((ret = rgAllocEventMem(inst,(Ptr *)&datInfo,
435 sizeof(TfuDatReqInfo))) != ROK)
437 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to Allocate TfuDatReqInfo");
442 cmLListInit(&datInfo->pdus);
444 RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DELTA);
446 RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DLDATA_DLDELTA);
448 datInfo->cellId = cellCb->cellId;
449 if((0 == (datInfo->timingInfo.sfn % 30)) && (0 == datInfo->timingInfo.slot))
451 //printf("5GTF_CHECK rgTOMUtlProcDlSf dat (%d : %d)\n", datInfo->timingInfo.sfn, datInfo->timingInfo.slot);
453 #ifdef TFU_ALLOC_EVENT_NO_INIT
454 datInfo->bchDat.pres = 0;
458 if (dlSf->bch.tb != NULLP)
460 datInfo->bchDat.pres = PRSNT_NODEF;
461 datInfo->bchDat.val = dlSf->bch.tb;
462 dlSf->bch.tb = NULLP;
465 /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
466 if ((ret = rgTOMEmtcUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
468 RG_FREE_MEM(datInfo);
472 /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
473 if ((ret = rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
475 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data for cell");
476 RG_FREE_MEM(datInfo);
479 if((datInfo->pdus.count) || (datInfo->bchDat.pres == TRUE))
481 /* sending the data to Phy */
482 if (rgLIMTfuDatReq(inst,datInfo) != ROK)
484 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data info for cell");
489 /* Nothing to send: free the allocated datInfo */
490 RG_FREE_MEM(datInfo);
499 * @brief Handler for processing TTI indication recieved from
504 * Function: macProcessSlotInd
506 * Handler for processing slot indication recieved from PHY
509 * Invoked by: macProcessSlotInd
512 * - Get cell and update the cell's current time with the timing value given
514 * - Invoke the cmPrcTmr to process the timing queue.
515 * - Append the PHICH information to the downlink subframe that needs to go
516 * out to PHY in this subframe.
517 * - Invoke DHM to release the downlink subframe that occured earlier
518 * rgDHMRlsDlsfHqProc.
519 * - Invoke the TTI handler of scheduler.
520 * - Invoke the TTI handler of RAM module.
521 * - Get the downlink subframe that has to go out to PHY in this subframe
523 * - Invoke rgTOMUtlProcTA to perform and timing advance processing.
524 * - Invoke rgTOMUtlProcDlSf to do further processing on the downlink
526 * - Get the downlink subframe that would occur after RG_DL_DELTA and
527 * invoke rgTOMUtlProcDlSfStaInd to send status indications to the higher
529 * - Invoke GOM's TTI handler rgGOMTtiHndlr
530 * - Invoke COM's TTI handler rgCOMTtiHndlr
532 * @param[in] Inst inst
533 * @param[in] SlotIndInfo slotInd
538 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
539 pthread_t gMacTId = 0;
541 PUBLIC S16 macProcessSlotInd
550 /* ADD Changes for Downlink UE Timing Optimization */
551 #ifdef LTEMAC_DLUE_TMGOPTMZ
553 CmLteTimingInfo prevTmInfo;
555 //SlotIndInfo *slotInd = &ttiInfo->cells[0];
557 TRC2(macProcessSlotInd);
559 #ifdef MAC_FREE_RING_BUF
560 gMacTId = pthread_self();
563 cellCb = rgCb[inst].cell;
566 err.errType = RGERR_TOM_TTIIND;
567 err.errCause = RGERR_TOM_INV_CELL_ID;
571 RGCPYTIMEINFO(slotInd, cellCb->crntTime);
573 rgMacGT = (slotInd.sfn * RG_NUM_SUB_FRAMES_5G) + slotInd.slot;
576 /*Included to track the number of 10240 cycles completed */
578 if((cellCb->crntTime.sfn == 0) && (cellCb->crntTime.slot==0))
580 cellCb->ttiCycle += 1;
585 /*Check if we have transmitted the previous DL SF, it could be the
586 case that we haven't received all the DATA from RLC as yet
587 and thus we would not have transmitted previous DL SF yet.*/
588 /* ADD Changes for Downlink UE Timing Optimization */
589 #ifdef LTEMAC_DLUE_TMGOPTMZ
590 RGSUBFRMCRNTTIME(slotInd, prevTmInfo, 1);
591 prevDlSf = &cellCb->subFrms[(prevTmInfo.slot % RG_NUM_SUB_FRAMES)];
592 if(FALSE == prevDlSf->txDone)
594 if (ROK != rgTOMUtlProcDlSf (prevDlSf, cellCb, &err))
596 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to process "
597 "previous downlink subframe for cell");
598 err.errType = RGERR_TOM_TTIIND;
601 /* Mark this frame as sent */
602 prevDlSf->txDone = TRUE;
604 if(prevDlSf->remDatReqCnt)
606 /*We have not received 1 or more data requests from RLC, this is
607 error scenario. MAC & SCH need to discard the allocations for
608 which data request hasn't been received as yet. And MAC
609 needs to inform SCH about the list of UEs for which
610 allocation need to be discarded. */
611 prevDlSf->remDatReqCnt = 0;
616 /* Trigger for DL TTI REQ */
617 CmLteTimingInfo dlTtiReqtimingInfo;
618 RGADDTOCRNTTIME(cellCb->crntTime, dlTtiReqtimingInfo, TFU_DELTA);
619 handleDlTtiReq(&dlTtiReqtimingInfo);
621 dlSf = &cellCb->subFrms[(slotInd.slot % RG_NUM_SUB_FRAMES)];
623 if((dlSf->txDone == TRUE) ||
624 (!RG_TIMEINFO_SAME(slotInd,dlSf->schdTime)))
627 #ifndef LTEMAC_DLUE_TMGOPTMZ
628 TfuDatReqInfo *datInfo;
629 CmLteTimingInfo timingInfo;
630 #ifdef TFU_DL_DELTA_CHANGE
631 RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DLDATA_DLDELTA);
633 RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DELTA);
635 /* Fill Data Request from MAC for BCH */
636 if ((timingInfo.sfn % 4 == 0) && (timingInfo.slot == 0))
638 if (ROK != rgAllocEventMem(inst,(Ptr *)&datInfo,
639 sizeof(TfuDatReqInfo)))
641 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
642 "rgTOMUtlProcDlSf() Unable to Allocate TfuDatReqInfo for cell");
647 cmLListInit(&datInfo->pdus);
648 datInfo->cellId = cellCb->cellId;
649 datInfo->bchDat.pres = NOTPRSNT;
650 datInfo->timingInfo = timingInfo;
653 /* sending the dummy data req to Phy */
654 if (rgLIMTfuDatReq(inst,datInfo) != ROK)
656 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
657 "rgTOMUtlProcDlSf() Unable to send data info for cell");
663 /* Freeing as the part of CL Non RT Indication */
664 /* TDOD : Generalize for all SOCs */
665 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
666 rgDHMFreeTbBufs(inst);
671 /*Return if there is still some data to be received
672 from RLC for this DL SF. */
673 /* ADD Changes for Downlink UE Timing Optimization */
674 #ifdef LTEMAC_DLUE_TMGOPTMZ
675 if(0 != dlSf->remDatReqCnt)
677 /* Freeing as the part of CL Non RT Indication */
678 /* TODO : Generalize for all SOCs and remove this flag */
679 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
680 rgDHMFreeTbBufs(inst);
686 #ifdef XEON_SPECIFIC_CHANGES
687 CM_MEAS_TIME((slotInd.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_DL_BR_PRC);
690 if (ROK != rgTOMUtlProcDlSf (dlSf, cellCb, &err))
692 //RLOG_ARG0(L_ERROR,DBG_CELLID,slotInd->cellId,
693 // "Unable to process downlink subframe for cell");
694 err.errType = RGERR_TOM_TTIIND;
696 #ifdef XEON_SPECIFIC_CHANGES
697 CM_MEAS_TIME((slotInd->slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_DL_AFTER_PRC);
700 /* Mark this frame as sent */
703 /* Freeing as the part of CL Non RT Indication */
704 /* TODO : Generalize for all SOCs and remove this flag */
705 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
706 rgDHMFreeTbBufs(inst);
709 } /* macProcessSlotInd */
711 /** @brief This function allocates the RgMacPdu that will be populated by DEMUX
712 * with the SubHeaders list and the values of the Control elements.
716 * Function: rgTOMUtlAllocPduEvnt
719 * @param[in] Inst inst
720 * @param [out] RgMacPdu **pdu
727 PRIVATE S16 rgTOMUtlAllocPduEvnt
733 PRIVATE S16 rgTOMUtlAllocPduEvnt (inst,pdu)
740 RgUstaDgn dgn; /* Alarm diagnostics structure */
741 VOLATILE U32 startTime=0;
743 TRC2(rgTOMUtlAllocPduEvnt);
745 evntMem.region = rgCb[inst].rgInit.region;
746 evntMem.pool = rgCb[inst].rgInit.pool;
749 SStartTask(&startTime, PID_TOMUTL_CMALLCEVT);
751 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
752 MS_BUF_ADD_ALLOC_CALLER();
755 if (cmAllocEvnt (sizeof (RgMacPdu), RG_BLKSZ, &evntMem, (Ptr*)pdu) != ROK)
757 rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
758 rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
759 LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
760 RLOG0(L_ERROR,"Allocation of DUX event failed");
765 SStopTask(startTime, PID_TOMUTL_CMALLCEVT);
770 /** @brief This function frees up the RgMacPdu structure that has been
771 * populated by demux.
775 * Function: rgTOMUtlFreePduEvnt
776 * - Function frees up the RgMacPdu structure, in case of error it shall
777 * free up the buffer's present in the different sdu.
780 * @param [in] Inst inst
781 * @param [in] RgMacPdu *pdu
782 * @param [in] Bool *error
786 PRIVATE Void rgTOMUtlFreePduEvnt
792 PRIVATE Void rgTOMUtlFreePduEvnt (pdu, error)
801 TRC2(rgTOMUtlFreePduEvnt);
802 /* Steps of freeing up the PDU.
803 * 1. loop through the subHdrLst and free up all the buffers.
804 * 2. free up the whole event
806 if ((error == TRUE) && (pdu->sduLst.count > 0))
808 node = pdu->sduLst.first;
811 sdu = (RgMacSdu*)node->node;
812 RG_FREE_MSG(sdu->mBuf);
818 } /* end of rgTOMUtlFreePduEvnt */
820 /** @brief This function allocates the RgMacPdu that will be populated by DEMUX
821 * with the SubHeaders list and the values of the Control elements.
825 * Function: rgTOMInfAllocPduEvnt
828 * @param [in] Inst inst
829 * @param [out] RgMacPdu **pdu
836 PRIVATE S16 rgTOMInfAllocPduEvnt
839 RgInfSfDatInd **sfInfo
842 PRIVATE S16 rgTOMInfAllocPduEvnt (inst,sfInfo)
844 RgInfSfDatInd **sfInfo;
849 RgUstaDgn dgn; /* Alarm diagnostics structure */
850 VOLATILE U32 startTime=0;
852 TRC2(rgTOMInfAllocPduEvnt);
854 evntMem.region = rgCb[inst].rgInit.region;
855 evntMem.pool = rgCb[inst].rgInit.pool;
858 SStartTask(&startTime, PID_TOMINF_CMALLCEVT);
860 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
861 MS_BUF_ADD_ALLOC_CALLER();
863 if (cmAllocEvnt (sizeof (RgInfSfDatInd), RG_BLKSZ, &evntMem, (Ptr*)sfInfo) != ROK)
865 rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
866 rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
867 LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
868 RLOG0(L_ERROR,"Allocation failed");
873 SStopTask(startTime, PID_TOMINF_CMALLCEVT);
878 /** @brief This function frees up the RgMacPdu structure that has been
879 * populated by demux.
883 * Function: rgTOMInfFreePduEvnt
884 * - Function frees up the RgMacPdu structure, in case of error it shall
885 * free up the buffer's present in the different sdu.
888 * @param [in] RgMacPdu *pdu
889 * @param [in] Bool *error
893 PRIVATE Void rgTOMInfFreePduEvnt
895 RgInfSfDatInd *sfInfo
898 PRIVATE Void rgTOMInfFreePduEvnt (sfInfo)
899 RgInfSfDatInd *sfInfo;
902 TRC2(rgTOMInfFreePduEvnt);
906 } /* end of rgTOMUtlFreePduEvnt */
910 /** @brief This function performs the preparation of information needed to set
911 * L2M Scheduled UL Throughput Information for a particular UE.
915 * Function: rgTomUtlPrepareL2MUlThrpInfo
916 * This function performs the preparation of information needed to set
917 * L2M Scheduled UL Throughput Information for a particular UE.
921 * @param [in] RgCellCb *cellCb
922 * @param [in] RgUeCb *ueCb
923 * @param [out] RgRguDedDatInd *dDatInd
927 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo
931 RgRguDedDatInd *dDatInd
934 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo(cellCb,ueCb,dDatInd)
937 RgRguDedDatInd *dDatInd;
943 TRC2(rgTomUtlPrepareL2MUlThrpInfo);
945 dDatInd->burstInd = RGU_L2M_UL_BURST_END;
946 for(loop=0;loop<dDatInd->numLch;loop++)
948 lcId=dDatInd->lchData[loop].lcId;
951 lcgId = ueCb->ul.lcCb[lcId - 1].lcgId;
952 if(ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs > 0)
954 dDatInd->burstInd = RGU_L2M_UL_BURST_START;
965 /** @brief This function is called by rgTOMDatInd. This function invokes the
966 * scheduler with the information of the received Data and any Control Elements
967 * if present. Also it generates Data indications towards the higher layers.
974 * - Retrieves the RaCb with the rnti provided, if it doesnt exist
976 * - If UE exists then update the Schduler with any MAC CEs if present.
977 * - Invoke RAM module to do Msg3 related processing rgRAMProcMsg3
978 * - Loop through the SDU subheaders and invoke either a common data
979 * indication (rgUIMSndCmnDatInd) or dedicated data indication
980 * (rgUIMSndDedDatInd) towards the higher layers.
982 * @param [in] RgCellCb *cellCb
983 * @param [in] RgUeCb *ueCb
984 * @param [in] CmLteRnti rnti
985 * @param [in] RgMacPdu *pdu
986 * @param [out] U32 *lcgBytes
997 PRIVATE S16 rgTOMUtlProcMsg
1003 Bool *spsToBeActvtd,
1009 PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,spsToBeActvtd,sduSize, slot, lcgBytes)
1014 Bool *spsToBeActvtd;
1019 #else /* LTEMAC_SPS */
1021 PRIVATE S16 rgTOMUtlProcMsg
1030 PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, slot, lcgBytes)
1039 Inst inst = cellCb->macInst - RG_INST_START;
1041 RgRguCmnDatInd *cDatInd;
1042 RgRguDedDatInd *dDatInd;
1049 // RgInfSpsRelInfo relInfo;
1056 U16 totalBytesRcvd = 0;
1057 U16 sduLen[RGU_MAX_LC] = {0};
1058 U8 qciVal[RGU_MAX_LC] = {0};
1065 /* Moved outside of LTE_L2_MEAS
1066 * scope as this pointer will now be used to
1067 * check for valid Logical Channel ID
1084 TRC2(rgTOMUtlProcMsg)
1090 if(pdu->sduLst.first)
1092 sdu = (RgMacSdu*)(pdu->sduLst.first->node);
1094 if ((sdu->lcId == RG_CCCH_LCID))
1096 /* code for common channel dat indications */
1097 if ((ret = rgAllocShrablSBuf (inst,(Data**)&cDatInd, sizeof(RgRguCmnDatInd))) != ROK)
1101 cDatInd->cellId = cellCb->cellId;
1102 cDatInd->rnti = ueCb->ueId;
1103 /* rg001.101: Corrected lcId value for common data indication */
1104 cDatInd->lcId = cellCb->ulCcchId;
1105 cDatInd->pdu = sdu->mBuf;
1106 SFndLenMsg (sdu->mBuf, &ccchSz);
1107 /* Fix : syed Contention resolution ID copy should consider only
1108 * 6 bytes of information from sdu->mBuf. Incase of CCCH sdu for reest
1109 * message/psuedo reest message, ccchSz can go beyond 6 and can corrupt
1110 * other fields of ueCb. */
1111 if (ccchSz >= RG_CRES_LEN)
1113 SCpyMsgFix (sdu->mBuf, (MsgLen)0, RG_CRES_LEN, ueCb->contResId.resId,
1116 #ifdef XEON_SPECIFIC_CHANGES
1117 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.slot);
1120 rgUIMSndCmnDatInd(inst,cellCb->rguUlSap,cDatInd);
1122 } /* end of common channel processing */
1124 if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
1130 elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
1135 dDatInd = (RgRguDedDatInd *)elem;
1136 cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
1138 dDatInd->cellId = cellCb->cellId;
1139 dDatInd->rnti = ueCb->ueId;
1140 dDatInd->numLch = 0;
1143 ulSf = &cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)];
1144 if(ulSf->ueUlAllocInfo != NULLP)
1146 for(idx1 = 0; idx1 < ulSf->numUe; idx1++)
1148 if(ulSf->ueUlAllocInfo[idx1].rnti == ueCb->ueId)
1150 numPrb = ulSf->ueUlAllocInfo[idx1].numPrb;
1156 node = pdu->sduLst.first;
1159 sdu = (RgMacSdu*)node->node;
1161 ulLcCb = rgDBMGetUlDedLcCb (ueCb, sdu->lcId);
1165 RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,"Unconfigured LCID:%d CRNTI:%d"
1166 ,sdu->lcId,ueCb->ueId);
1167 /* ccpu00128443: Fix for memory leak */
1168 /* Fix : syed Neccessary to set sdu->mBuf = NULLP */
1169 RG_FREE_MSG(sdu->mBuf);
1173 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
1175 extern S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId,
1176 CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
1178 if(ROK == kwProcDlStatusPdu(&(cellCb->rguDlSap->sapCfg.sapPst),
1179 cellCb->rguDlSap->sapCfg.suId,
1180 cellCb->cellId,ueCb->ueId,sdu->lcId,sdu->mBuf))
1182 RG_FREE_MSG(sdu->mBuf);
1189 /* ccpu00116477- Fixed the rgUIMSndDedDatInd condition when we receive 11 sdus in the
1190 * list we are losing 11th sdu and sending the first 10 sdus again which
1191 * is causing the duplicate packets and eNB crashing due to access
1192 * of the freed memory */
1193 if (dDatInd->numLch >= RGU_MAX_LC)
1195 if ((ret = rgUIMSndDedDatInd(inst,ueCb->rguUlSap,dDatInd)) != ROK)
1197 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
1198 "Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
1202 if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
1207 elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
1212 dDatInd = (RgRguDedDatInd *)elem;
1213 cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
1215 dDatInd->cellId = cellCb->cellId;
1216 dDatInd->rnti = ueCb->ueId;
1217 dDatInd->numLch = 0;
1219 dDatInd->lchData[dDatInd->numLch].lcId = sdu->lcId;
1220 dDatInd->lchData[dDatInd->numLch].pdu.mBuf[dDatInd->lchData[dDatInd->numLch].pdu.numPdu] = sdu->mBuf;
1221 dDatInd->lchData[dDatInd->numLch].pdu.numPdu++;
1222 lcgId = ulLcCb->lcgId;
1223 SFndLenMsg(sdu->mBuf, &bufSz);
1227 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs -= bufSz;
1230 //if ((lcgBytes != NULLP) && (ueCb->ul.lcgArr[lcgId].isGbr == TRUE))
1231 if (lcgBytes != NULLP)
1233 lcgBytes[lcgId] += bufSz;
1238 /* Check if data has come on SPS LC */
1239 /* KWORK_FIX: Modified the index from lcId to lcId-1 for handling lcId 10 properly */
1240 if (ueCb->ul.spsLcId[sdu->lcId-1] == TRUE)
1242 ueCb->ul.spsDatRcvd++;
1247 /* Data rcvd on CRNTI*/
1248 /* Retrieve the LCG ID of the LCID*/
1249 /* SPS LCG has data whose size > SID Size */
1250 /* Activate SPS if data recvd on SPS LCID and size > SID Packet Size */
1251 if((ueCb->ul.spsLcId[sdu->lcId-1] == TRUE) &&
1252 (sdu->len > RG_SPS_SID_PACKET_SIZE))
1254 *spsToBeActvtd = TRUE;
1255 *sduSize = sdu->len;
1262 if(cellCb->qciArray[ulLcCb->qci].mask == TRUE)
1264 sduLen[ulLcCb->qci] = sdu->len;
1265 totalBytesRcvd += sdu->len;
1266 qciVal[ulLcCb->qci] = ulLcCb->qci;
1270 } /* end of while for SubHeaders */
1272 for(idx2 = 0; idx2 < RGU_MAX_LC; idx2++)
1274 if((cellCb->qciArray[qciVal[idx2]].mask == TRUE) &&
1277 cellCb->qciArray[qciVal[idx2]].prbCount +=
1278 ((numPrb * sduLen[idx2]) / totalBytesRcvd);
1282 if(totalBytesRcvd > 0 && qciVal[idx2] > 0)
1284 RG_UPD_GBR_PRB(cellCb, qciVal[idx2], ((numPrb * sduLen[idx2])/totalBytesRcvd));
1289 /*Added for explicit release - start*/
1292 if(isSpsRnti && dDatInd && dDatInd->numLch)
1294 if(ueCb->ul.spsDatRcvd != 0)
1296 ueCb->ul.explRelCntr = 0;
1297 ueCb->ul.spsDatRcvd = 0;
1301 ueCb->ul.explRelCntr++;
1302 if (ueCb->ul.explRelCntr == ueCb->ul.explRelCnt)
1304 ueCb->ul.explRelCntr = 0;
1305 /* Indicate scheduler for explicit release */
1306 cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
1307 rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
1308 //TODO: commented for compilation without SCH
1310 relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1311 relInfo.cRnti = ueCb->ueId;
1312 relInfo.isExplRel = TRUE;
1313 /* Release indicator is called now through the matrix in the function below */
1314 //TODO: commented for compilation without SCH 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 slot = datInd->timingInfo.slot;
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, slot);
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, slot);
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;
1668 relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1669 relInfo.cRnti = ueCb->ueId;
1670 relInfo.isExplRel= FALSE;
1671 //TODO: commented for compilation without SCH RgMacSchSpsRel(&schPst1, &relInfo);
1677 /* Reset the implrelCntr */
1678 ueCb->ul.implRelCntr = 0;
1684 /* Perform failure if ueCb is still NULLP */
1685 rgTOMUtlFreePduEvnt (pdu, TRUE);
1686 err.errType = RGERR_TOM_DATIND;
1687 RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,"RNTI:%d Unable to get the UE CB",
1689 tfuSap->sapSts.numPduDrop++;
1694 rgTOMUtlL2MStoreBufSz(ueCb, &ceInfo);
1695 rgTOML2MCompileActiveLCs (cellCb, ueCb, pdu, &ceInfo);
1698 if ((ret = rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,&spsToBeActvtd,&sduSize, slot, (U32 *)&lcgBytes)) != ROK)
1700 if ((ret = rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, (U32 *)&lcgBytes)) != ROK)
1701 #endif /* LTEMAC_SPS */
1703 rgTOMUtlFreePduEvnt (pdu, TRUE);
1704 err.errType = RGERR_TOM_DATIND;
1705 RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,
1706 "Unable to handle Data Indication CRNTI:%d",ueCb->ueId);
1707 tfuSap->sapSts.numPduDrop++;
1714 if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti,spsToBeActvtd,sduSize, (U32 *)&lcgBytes) != ROK)
1716 if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti, (U32 *)&lcgBytes) != ROK)
1720 rgTOMInfFreePduEvnt (sfInfo);
1721 rgTOMUtlFreePduEvnt (pdu, FALSE);
1724 /* free up the PDU memory */
1725 rgTOMUtlFreePduEvnt (pdu, FALSE);
1727 /* Free the allocated memory for ueUlAllocInfo here */
1729 if(cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].ueUlAllocInfo != NULLP)
1731 /*ccpu00117052 - MOD - Passing double for proper NULLP
1733 rgFreeSBuf(inst,(Data **)&(cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].ueUlAllocInfo),
1734 ((cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].numUe) * sizeof(RgUeUlAlloc)));
1738 /* Update PRB used for all GBR QCIs to scheduler */
1739 cmMemcpy((U8*) &sfInfo->qcisUlPrbCnt[0],
1740 (U8*) &cellCb->qcisUlPrbCnt[0],
1741 (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1742 /* clear the cellCb ul prb value */
1743 cmMemset((U8*)&cellCb->qcisUlPrbCnt[0], 0,
1744 (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1748 rgGetPstToInst(&schPst, inst,cellCb->schInstMap.schInst);
1749 sfInfo->cellSapId = cellCb->schInstMap.cellSapId;
1750 //TODO: commented for compilation without SCH RgMacSchSfRecp(&schPst, sfInfo);
1755 * @brief Function handles allocation for common channels i.e. BCCH-BCH,
1756 * BCCH-DLSCH, PCCH-DLSCH.
1760 * Function : rgHndlCmnChnl
1762 * This function is invoked from RgSchMacSfAllocReq. This function handles
1763 * allocations made for common channels like BCCH and PCCH.
1766 * 1. If BCCH on BCH has been scheduled, send StatusIndication on RGU.
1767 * 2. If PCCH is scheduled, send StatusIndication on RGU.
1768 * 3. If BCCH on DLSCH has been scheduled and sndStatInd is TRUE, send
1769 * StatusIndication on RGU, else copy the bcch buffer onto the downlink
1773 * @param[in] RgCellCb *cell,
1774 * @param[in] CmLteTimingInfo timingInfo,
1775 * @param[in] RgInfCmnLcInfo *cmnLcInfo,
1776 * @param[in/out] RgErrInfo *err,
1782 PRIVATE S16 rgHndlCmnChnl
1785 CmLteTimingInfo timingInfo,
1786 RgInfCmnLcInfo *cmnLcInfo,
1790 PRIVATE S16 rgHndlCmnChnl(cell, timingInfo, cmnLcInfo, err)
1792 CmLteTimingInfo timingInfo;
1793 RgInfCmnLcInfo *cmnLcInfo;
1797 #if (ERRCLASS & ERRCLS_DEBUG)
1801 RgBcchDlschLcCb *bcch;
1802 #if (ERRCLASS & ERRCLS_DEBUG)
1805 #endif/*RGR_SI_SCH*/
1806 RguCStaIndInfo *staInd;
1808 Inst inst = cell->macInst - RG_INST_START;
1812 dlSf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
1814 if(cmnLcInfo->bitMask & RGINF_BCH_INFO)
1817 #if (ERRCLASS & ERRCLS_DEBUG)
1818 if(NULLP == (bch = rgDBMGetBcchOnBch(cell)))
1822 if(cmnLcInfo->bchInfo.lcId != bch->lcId)
1828 if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1830 err->errCause = RGERR_TOM_MEM_EXHAUST;
1833 staInd->cellId = cell->cellId;
1834 staInd->rnti = RG_INVALID_RNTI;
1835 staInd->lcId = cmnLcInfo->bchInfo.lcId;
1836 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1837 /* ADD Changes for Downlink UE Timing Optimization */
1838 #ifdef LTEMAC_DLUE_TMGOPTMZ
1839 dlSf->remDatReqCnt++;
1841 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1846 /*Store the received BCH Data in the scheduled subframe*/
1847 dlSf->bch.tb = cmnLcInfo->bchInfo.pdu;
1848 #endif/*RGR_SI_SCH*/
1851 if(cmnLcInfo->bitMask & RGINF_PCCH_INFO)
1853 #if (ERRCLASS & ERRCLS_DEBUG)
1854 if(NULLP == (pcch = rgDBMGetPcch(cell)))
1858 if(cmnLcInfo->pcchInfo.lcId != pcch->lcId)
1864 dlSf->pcch.pdcch.rnti =
1865 cmnLcInfo->pcchInfo.rnti;
1866 dlSf->pcch.pdcch.dci =
1867 cmnLcInfo->pcchInfo.dciInfo;
1869 /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */
1870 dlSf->pcch.txPwrOffset = cmnLcInfo->pcchInfo.txPwrOffset;
1872 if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1874 err->errCause = RGERR_TOM_MEM_EXHAUST;
1877 staInd->cellId = cell->cellId;
1878 staInd->rnti = RG_INVALID_RNTI;
1879 staInd->lcId = cmnLcInfo->pcchInfo.lcId;
1880 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1881 /* ADD Changes for Downlink UE Timing Optimization */
1882 #ifdef LTEMAC_DLUE_TMGOPTMZ
1883 dlSf->remDatReqCnt++;
1885 /* for consolidated CmnStaInd calling below function from function
1886 * rgHndlSchedUe once CmnStaInd prepared for all UEs
1888 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1894 if(cmnLcInfo->bitMask & RGINF_BCCH_INFO)
1896 dlSf->bcch.pdcch.rnti =
1897 cmnLcInfo->bcchInfo.rnti;
1898 dlSf->bcch.pdcch.dci =
1899 cmnLcInfo->bcchInfo.dciInfo;
1901 /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */
1902 dlSf->bcch.txPwrOffset = cmnLcInfo->bcchInfo.txPwrOffset;
1906 (bcch=rgDBMGetBcchOnDlsch(cell,cmnLcInfo->bcchInfo.lcId)))
1910 if(TRUE == cmnLcInfo->bcchInfo.sndStatInd)
1912 RG_FREE_MSG(bcch->tb);
1913 if (rgAllocShrablSBuf (inst,(Data**)&staInd,
1914 sizeof(RguCStaIndInfo)) != ROK)
1916 err->errCause = RGERR_TOM_MEM_EXHAUST;
1919 staInd->cellId = cell->cellId;
1920 staInd->rnti = RG_INVALID_RNTI;
1921 staInd->lcId = cmnLcInfo->bcchInfo.lcId;
1922 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1923 /* ADD Changes for Downlink UE Timing Optimization */
1924 #ifdef LTEMAC_DLUE_TMGOPTMZ
1925 dlSf->remDatReqCnt++;
1927 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1934 SCpyMsgMsg(bcch->tb, RG_GET_MEM_REGION(rgCb[inst]),
1935 RG_GET_MEM_POOL(rgCb[inst]), &dlSf->bcch.tb);
1938 /*Store the received BCCH Data in the scheduled subframe*/
1939 dlSf->bcch.tb = cmnLcInfo->bcchInfo.pdu;
1940 #endif/*RGR_SI_SCH*/
1944 } /* end of rgHndlCmnChnl */
1947 * @brief Function for handling allocations for dedicated channels for a
1952 * Function : rgHndlSchdUe
1954 * This function shall be invoked whenever scheduler is done with the
1955 * allocations of dedicated channels for a subframe. Invoked by the function
1956 * RgSchMacSfAllocReq.
1958 * Processing steps :
1959 * 1. Loops through the list of UE's scheduled looking for the corresponding
1961 * 2. Finds the corresponding HARQ process.
1962 * 3. Invokes the DHM function to issue StatusIndications on RGU.
1965 * @param[in] RgCellCb *cell,
1966 * @param[in] CmLteTimingInfo timingInfo,
1967 * @param[in] RgInfUeInfo *ueInfo
1968 * @param[in/out] RgErrInfo *err
1974 PRIVATE S16 rgHndlSchdUe
1977 CmLteTimingInfo timingInfo,
1978 RgInfUeInfo *ueInfo,
1982 PRIVATE S16 rgHndlSchdUe(cell, timingInfo, ueInfo, err) /* laa_ut_fix */
1984 CmLteTimingInfo timingInfo;
1985 RgInfUeInfo *ueInfo;
1992 if(NULLP == ueInfo->allocInfo)
1997 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err);
2000 } /* end of rgHndlSchdUe */
2004 * @brief Function for handling Uplink allocations for Ue for a
2009 * Function : rgHndlUlUeInfo
2011 * @param[in] RgCellCb *cell,
2012 * @param[in] CmLteTimingInfo timingInfo,
2013 * @param[in] RgInfUlUeInfo *ueInfo
2019 PRIVATE S16 rgHndlUlUeInfo
2022 CmLteTimingInfo timingInfo,
2023 RgInfUlUeInfo *ueInfo
2026 PRIVATE S16 rgHndlUlUeInfo(cell, timingInfo, ueInfo)
2028 CmLteTimingInfo timingInfo;
2029 RgInfUlUeInfo *ueInfo;
2032 Inst inst = cell->macInst - RG_INST_START;
2037 TRC2(rgHndlUlUeInfo)
2039 ulSf = &cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)];
2041 /* rg003.301-MOD- Corrected the purifier memory leak */
2042 if (ulSf->numUe != ueInfo->numUes)
2044 if (ulSf->ueUlAllocInfo)
2046 rgFreeSBuf(inst,(Data **)&(ulSf->ueUlAllocInfo),
2047 ulSf->numUe * sizeof(RgUeUlAlloc));
2050 #ifdef XEON_SPECIFIC_CHANGES
2051 CM_MEAS_TIME((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_FREE);
2052 CM_ADD_INFO((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MEAS_FREE, ulSf->numUe);
2054 ulSf->numUe = ueInfo->numUes;
2055 if((ulSf->ueUlAllocInfo == NULLP) && (ueInfo->numUes > 0))
2057 /* Allocate memory for ulAllocInfo */
2058 if((ret = rgAllocSBuf(inst,(Data**)&(cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)].
2059 ueUlAllocInfo), ueInfo->numUes * sizeof(RgUeUlAlloc))) != ROK)
2064 #ifdef XEON_SPECIFIC_CHANGES
2065 CM_MEAS_TIME((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_ALLOC);
2066 CM_ADD_INFO((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MEAS_ALLOC, ueInfo->numUes);
2068 if (ulSf->ueUlAllocInfo != NULLP)
2070 for(idx = 0; idx < ueInfo->numUes; idx++)
2072 ulSf->ueUlAllocInfo[idx].rnti = ueInfo->ulAllocInfo[idx].rnti;
2073 ulSf->ueUlAllocInfo[idx].numPrb = ueInfo->ulAllocInfo[idx].numPrb;
2076 RGCPYTIMEINFO(timingInfo, ulSf->schdTime);
2078 } /* end of rgHndlUlUeInfo */
2081 * @brief Function for handling RaResp request received from scheduler to MAC
2085 * Function : rgTOMRlsSf
2087 * This function shall be invoked whenever scheduler is done with the
2088 * allocations of random access responses for a subframe.
2089 * This shall invoke RAM to create ueCbs for all the rapIds allocated and
2090 * shall invoke MUX to create RAR PDUs for raRntis allocated.
2093 * @param[in] Inst inst
2094 * @param[in] CmLteCellId cellId,
2095 * @param[in] CmLteTimingInfo timingInfo,
2096 * @param[in] RaRespInfo *rarInfo
2101 PUBLIC Void rgTOMRlsSf
2107 PUBLIC Void rgTOMRlsSf(dlSf)
2116 if(dlSf->txDone == FALSE)
2118 RLOG0(L_ERROR, "SUBFRAME Not pushed to the PHY");
2120 if (dlSf->bch.tb != NULLP)
2122 RG_FREE_MSG(dlSf->bch.tb);
2124 if (dlSf->bcch.tb != NULLP)
2126 RG_FREE_MSG(dlSf->bcch.tb);
2128 if (dlSf->pcch.tb != NULLP)
2130 RG_FREE_MSG(dlSf->pcch.tb);
2133 rgTOMEmtcRlsSf(dlSf);
2135 for(idx=0; idx < dlSf->numRaRsp; idx++)
2137 RG_FREE_MSG(dlSf->raRsp[idx].rar);
2140 /* ADD Changes for Downlink UE Timing Optimization */
2141 #ifdef LTEMAC_DLUE_TMGOPTMZ
2142 dlSf->remDatReqCnt = 0;
2143 /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2145 dlSf->statIndDone = FALSE;
2147 if (dlSf->tbs.count)
2152 RGDBGERRNEW(inst, (rgPBuf(inst),
2153 "Error Stale TBs in Subframes TBS list\n"));
2154 node = dlSf->tbs.first;
2157 hqP = (RgDlHqProcCb*)node->node;
2161 for(i=0;i< RG_MAX_TB_PER_UE;i++)
2163 if (hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf == dlSf)
2165 cmLListDelFrm(&dlSf->tbs, &(hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk));
2166 hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk.node = NULLP;
2167 printf("\n rgTOMRlsSf:: hqP %p \n", (Void *)hqP);
2169 hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf = NULLP;
2174 /*arjun: check if dlSf laaTb list has to be freed???*/
2175 cmLListInit(&dlSf->tbs);
2176 dlSf->txDone = FALSE;
2182 * @brief Function is called by the scheduler once it has completed the
2183 * allocation for the subframe.
2187 * Function : rgHndlFlowCntrl
2188 * This function should fill and send Flow control
2192 * @param[in] Pst *cell
2193 * @param[in] RgInfSfAlloc *sfInfo Carries all the allocation
2199 PUBLIC S16 rgHndlFlowCntrl
2202 RgInfSfAlloc *sfInfo
2205 PUBLIC S16 rgHndlFlowCntrl(cell, sfInfo)
2207 RgInfSfAlloc *sfInfo;
2210 RguFlowCntrlInd *flowCntrlInd;
2214 TRC3(rgHndlFlowCntrl);
2216 pst = &cell->rguDlSap->sapCfg.sapPst;
2217 /* flowCntrlInd is alloced in cell init time and will be re-used throughout */
2218 flowCntrlInd = cell->flowCntrlInd;
2219 flowCntrlInd->cellId = sfInfo->cellId;
2220 flowCntrlInd->numUes = sfInfo->flowCntrlInfo.numUes;
2222 for (ueIdx = 0; ueIdx < sfInfo->flowCntrlInfo.numUes; ueIdx++)
2224 flowCntrlInd->ueFlowCntrlInfo[ueIdx].ueId = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].ueId;
2225 flowCntrlInd->ueFlowCntrlInfo[ueIdx].numLcs = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].numLcs;
2227 for (lcIdx = 0; lcIdx < RGINF_MAX_NUM_DED_LC; lcIdx++)
2229 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId =
2230 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId;
2231 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt =
2232 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt;
2234 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl =
2235 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl;
2238 RgUiRguFlowCntrlInd(pst, cell->rguDlSap->sapCfg.spId,flowCntrlInd); /* TODO: Rishi confirm if the suId and pst pointer is correct */
2242 * @brief Function is called by the scheduler once it has completed the
2243 * allocation for the subframe.
2247 * Function : RgSchMacSfAllocReq
2249 * This function shall be invoked whenever scheduler is done with the
2250 * allocations of for a subframe. The sfInfo carries all the allocation
2251 * details for the common channels, RA responses and dedicated channel
2254 * Processing steps :
2255 * 1. Reset the information present in the downlink subframe that is
2257 * 2. Handle common channel allocations
2258 * 3. Handle RA Response allocations
2259 * 4. Handle dedicated channel allocations.
2261 * @param[in] Pst *pst
2262 * @param[in] RgInfSfAlloc *sfInfo Carries all the allocation
2268 PUBLIC S16 RgSchMacSfAllocReq
2271 RgInfSfAlloc *sfInfo
2274 PUBLIC S16 RgSchMacSfAllocReq(pst, sfInfo)
2276 RgInfSfAlloc *sfInfo;
2282 VOLATILE U32 startTime=0;
2285 TRC2(RgSchMacSfAllocReq)
2287 RG_IS_INST_VALID(pst->dstInst);
2288 inst = pst->dstInst - RG_INST_START;
2290 SStartTask(&startTime, PID_MAC_SF_ALLOC_REQ);
2297 if((cell = rgCb[inst].cell) == NULLP)
2299 RLOG_ARG0(L_ERROR,DBG_CELLID,sfInfo->cellId, "No cellCb found with cell");
2303 dlSf = &cell->subFrms[(sfInfo->timingInfo.slot % RG_NUM_SUB_FRAMES)];
2305 rgTOMRlsSf(inst,dlSf);
2306 dlSf->schdTime = sfInfo->timingInfo;
2309 rgLaaInitTbInfoLst(cell);
2312 /* Fix : syed Ignore Failure Returns and continue processing.
2313 * Incomplete processing results in state sync loss between MAC-SCH. */
2315 if(TRUE == cell->emtcEnable)
2317 rgEmtcHndl(cell, sfInfo);
2320 rgHndlCmnChnl(cell, sfInfo->timingInfo, &sfInfo->cmnLcInfo, &err);
2322 rgHndlRaResp(cell, sfInfo->timingInfo, &sfInfo->rarInfo, &err);
2325 #ifdef XEON_SPECIFIC_CHANGES
2326 CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_B4_UE_SCHD);
2328 rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2329 #ifdef XEON_SPECIFIC_CHANGES
2330 CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_UE_SCHD);
2332 rgLaaChkAndReqTbs(dlSf,cell, inst);
2335 rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2339 if(rgHndlUlUeInfo(cell, sfInfo->ulUeInfo.timingInfo,
2340 &sfInfo->ulUeInfo) != ROK)
2345 #ifdef XEON_SPECIFIC_CHANGES
2346 CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_MEAS);
2348 /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2352 /* Added the handling for pushing down
2353 * TFU Data request in the retransmission only scenario.*/
2354 #ifdef LTEMAC_DLUE_TMGOPTMZ
2355 dlSf->statIndDone = TRUE;
2356 /* Fix [ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2358 if(!(dlSf->txDone) &&
2360 (TRUE == rgLaaChkAllRxTbs(dlSf)) &&
2362 (0 == dlSf->remDatReqCnt) && (dlSf->statIndDone) &&
2363 (RG_TIMEINFO_SAME(cell->crntTime, dlSf->schdTime)))
2365 /*This is the case of rettransmission, so no need
2366 * to wait for TTI Ind to push TFU Data Request. Send
2368 if (ROK != rgTOMUtlProcDlSf (dlSf, cell, &err))
2370 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to process downlink subframe for cell");
2371 err.errType = RGERR_ROM_DEDDATREQ;
2373 /* Mark this frame as sent */
2374 dlSf->txDone = TRUE;
2377 if (sfInfo->flowCntrlInfo.numUes > 0)
2379 rgHndlFlowCntrl(cell,sfInfo);
2382 SStopTask(startTime, PID_MAC_SF_ALLOC_REQ);
2384 } /* end of RgSchMacSfAllocReq */
2386 * @brief Handler for processing data indication recieved from PHY for UEs.
2390 * Function: rgTOMProcCrntiCEInDatInd
2392 * Handler for processing data indication recieved from PHY for UEs.
2394 * Invoked by: RgLiTfuDatInd of LIM
2397 * For each DataInfo recieved
2398 * - If received a CRNTI control element
2399 * - Check if a CCCH SDU is present, if it is return failure
2400 * - Check for the existence of UE, if its isnt present return failure.
2401 * - Delegate the remaining processing to rgTOMUtlProcMsg3 which
2402 * primarily informs the scheduler about the data received and
2403 * generates Data indications towards the higher layer.
2405 * @param RgMacPdu *pdu,
2406 * @param RgUeCb *prevUeCb,
2407 * @param RgCellCb *cellCb,
2408 * @param TfuDatInfo *datInfo,
2409 * @param RgInfCeInfo *ceInfo
2415 PRIVATE S16 rgTOMProcCrntiCEInDatInd
2420 TfuDatInfo *datInfo,
2421 RgInfCeInfo *ceInfo,
2425 PRIVATE S16 rgTOMProcCrntiCEInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
2429 TfuDatInfo *datInfo;
2430 RgInfCeInfo *ceInfo;
2434 RgUeCb *ueCb = NULLP;
2435 Inst inst = cellCb->macInst - RG_INST_START;
2443 TRC2(rgTOMProcCrntiCEInDatInd)
2449 ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2453 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2454 "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2458 prevUeCb = rgDBMGetUeCb (cellCb, ceInfo->ces.cRnti);
2459 if (prevUeCb == NULLP)
2461 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2462 "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2465 RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
2466 "CRNTI CE(%d) received through tmpCrnti(%d)",
2467 ceInfo->ces.cRnti, datInfo->rnti);
2468 rgDBMDelUeCbFromRachLst(cellCb, ueCb);
2469 rgRAMFreeUeCb(inst,ueCb);
2472 if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, slot, NULLP)) != ROK)
2474 if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, NULLP)) != ROK)
2475 #endif /* LTEMAC_SPS */
2477 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2478 "RNTI:%d Processing for MSG3 failed",datInfo->rnti);
2484 * @brief Handler for processing data indication recieved from PHY for UEs.
2488 * Function: rgTOMProcCCCHSduInDatInd
2490 * Handler for processing data indication recieved from PHY for UEs.
2492 * Invoked by: RgLiTfuDatInd of LIM
2495 * For each DataInfo recieved
2496 * - If only CCCH SDU is present
2497 * - Invoke rgTOMUtlProcMsg3 for further processing.
2498 * - If its a non-Msg3 PDU i.e. received outside of a RA procedure
2499 * - Retrieve the UeCB
2500 * - Validate that the received PDU contains only configured Logical
2502 * - Invoke rgTOMUtlProcDatPdu for further processing. It informs the
2503 * scheduler with the information of the received Data and generates
2504 * DatIndications towards the higher layers.
2506 * @param TfuDatIndInfo *datInd
2507 * @param RgMacPdu *pdu,
2508 * @param RgUeCb *prevUeCb,
2509 * @param RgCellCb *cellCb,
2510 * @param TfuDatInfo *datInfo,
2511 * @param RgInfCeInfo *ceInfo
2517 PRIVATE S16 rgTOMProcCCCHSduInDatInd
2522 TfuDatInfo *datInfo,
2523 RgInfCeInfo *ceInfo,
2527 PRIVATE S16 rgTOMProcCCCHSduInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
2531 TfuDatInfo *datInfo;
2532 RgInfCeInfo *ceInfo;
2536 RgUeCb *ueCb = NULLP;
2537 Inst inst = cellCb->macInst - RG_INST_START;
2545 TRC2(rgTOMProcCCCHSduInDatInd)
2551 if (ceInfo->bitMask & RG_CRNTI_CE_PRSNT)
2553 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2554 "CRNTI:%d Received MSG3 with CCCH",ceInfo->ces.cRnti);
2558 ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2562 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2563 "RNTI:%d Processing for MSG3 failed", datInfo->rnti);
2566 /* Fix: syed Drop any duplicate Msg3(CCCH Sdu) */
2567 if (ueCb->dl.hqEnt.numHqProcs)
2569 /* HqE is already initialized by a previuos Msg3 */
2570 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed. Duplicate "
2571 "MSG3 received. Dropping", datInfo->rnti);
2575 if(rgDHMHqEntInit(inst,&ueCb->dl.hqEnt,
2576 cellCb->maxDlHqProcPerUe) != ROK)
2578 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Harq Initialization failed ",
2582 RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
2583 "CCCH SDU received through tmpCrnti(%d)",datInfo->rnti);
2585 if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, slot, NULLP)) != ROK)
2587 if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, NULLP)) != ROK)
2588 #endif /* LTEMAC_SPS */
2590 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed",
2599 /** @brief This function captures the BSR value from Control Element
2600 * Info structure and updates the effective Buffer size into the
2601 * corresponding LCG ID.
2605 * Function: rgTOMUtlL2MStoreBufSz
2608 * - update/append the Data structure based on BSR type
2610 * @param [in] RgUeCb *ueCb
2611 * @param [in] RgInfCeInfo *ceInfo
2616 PRIVATE S16 rgTOMUtlL2MStoreBufSz
2622 PRIVATE S16 rgTOMUtlL2MStoreBufSz (ueCb, ceInfo)
2624 RgInfCeInfo *ceInfo;
2629 TRC2(rgTOMUtlL2MStoreBufSz);
2631 if(ceInfo->bitMask & RG_TRUNC_BSR_CE_PRSNT)
2633 lcgId = ((ceInfo->ces.bsr.truncBsr >> 6) & 0x03);
2634 bsr = ceInfo->ces.bsr.truncBsr & 0x3F;
2635 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2637 else if(ceInfo->bitMask & RG_SHORT_BSR_CE_PRSNT)
2639 lcgId = ((ceInfo->ces.bsr.shortBsr >> 6) & 0x03);
2640 bsr = ceInfo->ces.bsr.shortBsr & 0x3F;
2641 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2644 else if(ceInfo->bitMask & RG_LONG_BSR_CE_PRSNT)
2646 ueCb->ul.lcgArr[0].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs1];
2647 ueCb->ul.lcgArr[1].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs2];
2648 ueCb->ul.lcgArr[2].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs3];
2649 ueCb->ul.lcgArr[3].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs4];
2652 } /* end of rgTOMUtlL2MStoreBufSz*/
2654 /** @brief : Compiles list of LCs received in UL data for DTCH RBs
2658 * @param [in] RgCellCb *cellCb
2659 * @param [in] RgUeCb *ueCb
2660 * @param [in] CmLteRnti rnti
2661 * @param [in] RgMacPdu *pdu
2668 PRIVATE Void rgTOML2MCompileActiveLCs
2676 PRIVATE Void rgTOML2MCompileActiveLCs(cellCb, ueCb, pdu, ceInfo)
2680 RgInfCeInfo *ceInfo;
2687 TRC2(rgTOML2MCompileActiveLCs)
2689 node = pdu->sduLst.first;
2692 sdu = (RgMacSdu*)node->node;
2694 if ((ulLcCb = rgDBMGetUlDedLcCb(ueCb, sdu->lcId)), ulLcCb != NULLP)
2696 if (ulLcCb->lcgId != 0)
2698 ceInfo->bitMask |= RG_ACTIVE_LC_PRSNT;
2699 ceInfo->ulActLCs[ulLcCb->lcId - 1] = TRUE;
2710 /**********************************************************************
2713 **********************************************************************/