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) */
40 #include "envopt.h" /* environment options */
41 #include "envdep.h" /* environment dependent */
42 #include "envind.h" /* environment independent */
43 #include "gen.h" /* general layer */
44 #include "ssi.h" /* system services */
45 #include "cm5.h" /* common timers defines */
46 #include "cm_hash.h" /* common hash list defines */
47 #include "cm_llist.h" /* common linked list defines */
48 #include "cm_mblk.h" /* memory management */
49 #include "cm_tkns.h" /* common tokens */
50 #include "cm_lte.h" /* common tokens */
51 #include "rgu.h" /* RGU defines */
52 #include "tfu.h" /* RGU defines */
53 #include "lrg.h" /* layer management defines for LTE-MAC */
54 #include "crg.h" /* layer management defines for LTE-MAC */
55 #include "rg_sch_inf.h" /* layer management defines for LTE-MAC */
56 #include "rg.h" /* defines and macros for MAC */
57 #include "rg_env.h" /* defines and macros for MAC */
58 #include "rg_err.h" /* defines and macros for MAC */
61 /* header/extern include files (.x) */
62 #include "gen.x" /* general layer typedefs */
63 #include "ssi.x" /* system services typedefs */
64 #include "cm5.x" /* common timers */
65 #include "cm_hash.x" /* common hash list */
66 #include "cm_lib.x" /* common library */
67 #include "cm_llist.x" /* common linked list */
68 #include "cm_mblk.x" /* memory management */
69 #include "cm_tkns.x" /* common tokens */
70 #include "cm_lte.x" /* common tokens */
71 #include "rgu.x" /* RGU types */
72 #include "tfu.x" /* RGU types */
73 #include "lrg.x" /* layer management typedefs for MAC */
74 #include "crg.x" /* CRG interface typedefs */
75 #include "rg_sch_inf.x" /* SCH interface typedefs */
76 #include "rg_prg.x" /* PRG interface typedefs */
77 #include "rgm.x" /* layer management typedefs for MAC */
78 #include "rgm.h" /* layer management typedefs for MAC */
79 #include "du_app_mac_inf.h"
81 #include "rg.x" /* typedefs for MAC */
82 #include "lwr_mac_fsm.h"
83 #ifdef MAC_RLC_UL_RBUF
88 /* ADD Changes for Downlink UE Timing Optimization */
89 #ifndef LTEMAC_DLUE_TMGOPTMZ
90 PRIVATE S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf, RgCellCb *cellCb,
93 PUBLIC S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
96 PRIVATE S16 rgTOMProcCrntiCEInDatInd ARGS((
105 PRIVATE S16 rgTOMProcCCCHSduInDatInd ARGS((
114 PUBLIC S16 rgHndlFlowCntrl
120 EXTERN S16 RgUiRguFlowCntrlInd(Pst* pst, SuId suId, RguFlowCntrlInd *flowCntrlInd);
122 EXTERN S16 rgEmtcHndl(RgCellCb *cell,RgInfSfAlloc *sfInfo);
123 EXTERN S16 rgTOMEmtcUtlFillDatReqPdus(TfuDatReqInfo *datInfo, RgDlSf *dlSf, RgCellCb *cell, RgErrInfo *err);
124 EXTERN Void rgTOMEmtcRlsSf(RgDlSf *dlSf);
127 PRIVATE Void rgTOML2MCompileActiveLCs ARGS
134 PRIVATE S16 rgTOMUtlL2MStoreBufSz ARGS
140 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo ARGS
144 RgRguDedDatInd *dDatInd
148 /* The below table takes lower values of BSR Range for a BSR value
149 This is to ensure that outstanding can be decrease to zero upon reception of
150 TB, which is not guaranteed if higher Range values are used */
151 /* Note: taking value 10 for BSR index 1 */
152 #ifndef MAC_5GTF_UPDATE
153 PRIVATE U32 rgLwrBsrTbl[64] = {
154 0, 10, 10, 12, 14, 17, 19, 22, 26,
155 31, 36, 42, 49, 57, 67, 78, 91,
156 107, 125, 146, 171, 200, 234, 274, 321,
157 376, 440, 515, 603, 706, 826, 967, 1132,
158 1326, 1552, 1817, 2127, 2490, 2915, 3413, 3995,
159 4677, 5476, 6411, 7505, 8787, 10287, 12043, 14099,
160 16507, 19325, 22624, 26487, 31009, 36304, 42502, 49759,
161 58255, 68201, 79846, 93479, 109439, 128125, 150000
165 PRIVATE U32 rgLwrBsrTbl[64] = {
166 0,10,13,16,19,23,29,35,43,53,65,80,98,120,147,181,223,274,337,414,
167 509,625,769,945,1162,1429,1757,2161,2657,3267,4017,4940,6074,7469,
168 9185,11294,13888,17077,20999,25822,31752,39045,48012,59039,72598,
169 89272,109774,134986,165989,204111,250990,308634,379519,466683,
170 573866,705666,867737,1067031,1312097,1613447,1984009,2439678,
178 #define RG_TOM_INF_ALLOC(_pdu, _size, _dataPtr, _ret) {\
179 _ret = cmGetMem((Ptr)&_pdu->memCp, _size, (Ptr *)&_dataPtr); \
182 /* global variables */
183 PUBLIC U32 rgUlrate_tfu;
185 EXTERN U32 grgUlrate_tfu;
188 /** @brief This function fills the PDSCH data of a downlink subframe
192 * Function: rgTOMUtlFillDatReqPdus
195 * - Fill BCCH on DLSCH data using datInfo
196 * - Fill PCCH on DLSCH data using datInfo
197 * - Fill Dedicated data on DLSCH data using datInfo
198 * - Fill RA RSP data using datInfo
200 * @param [out] TfuDatReqInfo *datInfo
201 * @param [in] RgDlSf *dlSf
202 * @param [in] RgCellCb *cellCb
203 * @param [out] RgErrInfo *err
209 PRIVATE S16 rgTOMUtlFillDatReqPdus
211 TfuDatReqInfo *datInfo,
217 PRIVATE S16 rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)
218 TfuDatReqInfo *datInfo;
225 TfuDatReqPduInfo *datReq=NULLP;
226 /* Moving node declaration to limited scope for optimization */
229 Inst inst = cellCb->macInst - RG_INST_START;
231 TRC2(rgTOMUtlFillDatReqPdus)
233 /* first lets send the BCCH data down to PHY */
234 if (dlSf->bcch.tb != NULLP)
236 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
237 &(datInfo->memCp))) != ROK)
239 err->errCause = RGERR_TOM_MEM_EXHAUST;
240 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion ");
243 #ifdef TFU_ALLOC_EVENT_NO_INIT
247 datReq->tbInfo[0].lchInfo[0].mBuf[0]=NULLP;
250 datReq->rnti = RG_SI_RNTI;
251 datReq->dciInfo = dlSf->bcch.pdcch.dci;
252 /* Note: SCpyMsgMsg is not done since free of unsent buffer
253 * has been taken care through cell delete by invoking rgTomRlsSf
255 datReq->nmbOfTBs = 1;
257 datReq->mBuf[0] = dlSf->bcch.tb;
259 SFndLenMsg((Buffer *)dlSf->bcch.tb, &(datReq->tbInfo[0].tbSize));
260 datReq->tbInfo[0].tbPres = TRUE;
261 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->bcch.tb;
262 datReq->tbInfo[0].numLch = 1;
263 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
265 #ifdef TFU_ALLOC_EVENT_NO_INIT
266 datReq->tbInfo[1].tbPres = FALSE;
267 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
270 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
271 datReq->lnk.node = (PTR)datReq;
273 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
274 datReq->txPwrOffset = dlSf->bcch.txPwrOffset;
276 /* Setting the pointer to NULL post transmission */
277 dlSf->bcch.tb = NULLP;
280 if (dlSf->pcch.tb != NULLP)
282 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
283 &(datInfo->memCp))) != ROK)
285 err->errCause = RGERR_TOM_MEM_EXHAUST;
286 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",datReq->rnti);
289 #ifdef TFU_ALLOC_EVENT_NO_INIT
294 datReq->rnti = RG_P_RNTI;
295 datReq->dciInfo = dlSf->pcch.pdcch.dci;
296 datReq->nmbOfTBs = 1;
298 datReq->mBuf[0] = dlSf->pcch.tb;
300 SFndLenMsg((Buffer *)dlSf->pcch.tb, &datReq->tbInfo[0].tbSize);
301 datReq->tbInfo[0].tbPres = TRUE;
302 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->pcch.tb;
303 #ifdef TFU_ALLOC_EVENT_NO_INIT
304 datReq->tbInfo[1].tbPres = FALSE;
305 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
307 datReq->tbInfo[0].numLch = 1;
308 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
310 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
311 datReq->lnk.node = (PTR)datReq;
313 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
314 datReq->txPwrOffset = dlSf->pcch.txPwrOffset;
316 dlSf->pcch.tb = NULLP;
319 for(idx=0; idx < dlSf->numRaRsp; idx++)
321 if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
322 &(datInfo->memCp))) != ROK)
324 err->errCause = RGERR_TOM_MEM_EXHAUST;
325 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",
329 #ifdef TFU_ALLOC_EVENT_NO_INIT
334 datReq->rnti = dlSf->raRsp[idx].pdcch.rnti;
335 datReq->dciInfo = dlSf->raRsp[idx].pdcch.dci;
336 datReq->nmbOfTBs = 1;
338 datReq->mBuf[0] = dlSf->raRsp[idx].rar;
340 SFndLenMsg((Buffer *)dlSf->raRsp[idx].rar, &datReq->tbInfo[0].tbSize);
341 datReq->tbInfo[0].tbPres = TRUE;
342 datReq->tbInfo[0].lchInfo[0].mBuf[0] = dlSf->raRsp[idx].rar;
343 #ifdef TFU_ALLOC_EVENT_NO_INIT
344 datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
345 datReq->tbInfo[1].tbPres = FALSE;
347 datReq->tbInfo[0].numLch = 1;
348 datReq->tbInfo[0].lchInfo[0].numPdu = 1;
349 // prc_trace_format_string(0x40,3,"UE Id=(%d) tbSz=(%d)",datReq->rnti, datReq->tbInfo[0].tbSize);
351 cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
352 datReq->lnk.node = (PTR)datReq;
354 /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
355 datReq->txPwrOffset = dlSf->raRsp[idx].txPwrOffset;
357 dlSf->raRsp[idx].rar = NULLP;
360 /* Fill Dedicated UE data */
361 if (dlSf->tbs.count != 0)
364 while (dlSf->tbs.first)
366 node = dlSf->tbs.first;
367 hqCb = (RgDlHqProcCb*)node->node;
368 if ((ret = rgDHMSndDatReq (cellCb, dlSf, datInfo, hqCb, err)) != ROK)
370 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
371 "DHM unable to fill DATA request");
372 err->errType = RGERR_TOM_TTIIND;
379 } /* end of rgTOMUtlFillDatReqPdus*/
381 /** @brief This function does all the processing related to a single downlink
386 * Function: rgTOMUtlProcDlSf
389 * - collate control data for all UEs and send to PHY
390 * - collate data buffers for all UEs and send to PHY
392 * @param [in] RgDlSf *dlSf
393 * @param [in] RgCellCb *cellCb
394 * @param [out] RgErrInfo *err
397 /* ADD Changes for Downlink UE Timing Optimization */
398 #ifndef LTEMAC_DLUE_TMGOPTMZ
400 PRIVATE S16 rgTOMUtlProcDlSf
407 PRIVATE S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
414 PUBLIC S16 rgTOMUtlProcDlSf
421 PUBLIC S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
429 TfuDatReqInfo *datInfo;
430 Inst inst = cellCb->macInst - RG_INST_START;
432 TRC2(rgTOMUtlProcDlSf);
434 /* Fill Data Request Info from scheduler to PHY */
435 if ((ret = rgAllocEventMem(inst,(Ptr *)&datInfo,
436 sizeof(TfuDatReqInfo))) != ROK)
438 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to Allocate TfuDatReqInfo");
443 cmLListInit(&datInfo->pdus);
445 RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DELTA);
447 RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DLDATA_DLDELTA);
449 datInfo->cellId = cellCb->cellId;
450 if((0 == (datInfo->timingInfo.sfn % 30)) && (0 == datInfo->timingInfo.slot))
452 //printf("5GTF_CHECK rgTOMUtlProcDlSf dat (%d : %d)\n", datInfo->timingInfo.sfn, datInfo->timingInfo.slot);
454 #ifdef TFU_ALLOC_EVENT_NO_INIT
455 datInfo->bchDat.pres = 0;
459 if (dlSf->bch.tb != NULLP)
461 datInfo->bchDat.pres = PRSNT_NODEF;
462 datInfo->bchDat.val = dlSf->bch.tb;
463 dlSf->bch.tb = NULLP;
466 /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
467 if ((ret = rgTOMEmtcUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
469 RG_FREE_MEM(datInfo);
473 /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
474 if ((ret = rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
476 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data for cell");
477 RG_FREE_MEM(datInfo);
480 if((datInfo->pdus.count) || (datInfo->bchDat.pres == TRUE))
482 /* sending the data to Phy */
483 if (rgLIMTfuDatReq(inst,datInfo) != ROK)
485 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data info for cell");
490 /* Nothing to send: free the allocated datInfo */
491 RG_FREE_MEM(datInfo);
500 * @brief Handler for processing TTI indication recieved from
505 * Function: macProcessSlotInd
507 * Handler for processing slot indication recieved from PHY
510 * Invoked by: macProcessSlotInd
513 * - Get cell and update the cell's current time with the timing value given
515 * - Invoke the cmPrcTmr to process the timing queue.
516 * - Append the PHICH information to the downlink subframe that needs to go
517 * out to PHY in this subframe.
518 * - Invoke DHM to release the downlink subframe that occured earlier
519 * rgDHMRlsDlsfHqProc.
520 * - Invoke the TTI handler of scheduler.
521 * - Invoke the TTI handler of RAM module.
522 * - Get the downlink subframe that has to go out to PHY in this subframe
524 * - Invoke rgTOMUtlProcTA to perform and timing advance processing.
525 * - Invoke rgTOMUtlProcDlSf to do further processing on the downlink
527 * - Get the downlink subframe that would occur after RG_DL_DELTA and
528 * invoke rgTOMUtlProcDlSfStaInd to send status indications to the higher
530 * - Invoke GOM's TTI handler rgGOMTtiHndlr
531 * - Invoke COM's TTI handler rgCOMTtiHndlr
533 * @param[in] Inst inst
534 * @param[in] SlotIndInfo slotInd
539 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
540 pthread_t gMacTId = 0;
542 PUBLIC S16 macProcessSlotInd
551 /* ADD Changes for Downlink UE Timing Optimization */
552 #ifdef LTEMAC_DLUE_TMGOPTMZ
554 CmLteTimingInfo prevTmInfo;
556 //SlotIndInfo *slotInd = &ttiInfo->cells[0];
558 TRC2(macProcessSlotInd);
560 #ifdef MAC_FREE_RING_BUF
561 gMacTId = pthread_self();
564 cellCb = rgCb[inst].cell;
567 err.errType = RGERR_TOM_TTIIND;
568 err.errCause = RGERR_TOM_INV_CELL_ID;
572 RGCPYTIMEINFO(slotInd, cellCb->crntTime);
574 rgMacGT = (slotInd.sfn * RG_NUM_SUB_FRAMES_5G) + slotInd.slot;
577 /*Included to track the number of 10240 cycles completed */
579 if((cellCb->crntTime.sfn == 0) && (cellCb->crntTime.slot==0))
581 cellCb->ttiCycle += 1;
586 /*Check if we have transmitted the previous DL SF, it could be the
587 case that we haven't received all the DATA from RLC as yet
588 and thus we would not have transmitted previous DL SF yet.*/
589 /* ADD Changes for Downlink UE Timing Optimization */
590 #ifdef LTEMAC_DLUE_TMGOPTMZ
591 RGSUBFRMCRNTTIME(slotInd, prevTmInfo, 1);
592 prevDlSf = &cellCb->subFrms[(prevTmInfo.slot % RG_NUM_SUB_FRAMES)];
593 if(FALSE == prevDlSf->txDone)
595 if (ROK != rgTOMUtlProcDlSf (prevDlSf, cellCb, &err))
597 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to process "
598 "previous downlink subframe for cell");
599 err.errType = RGERR_TOM_TTIIND;
602 /* Mark this frame as sent */
603 prevDlSf->txDone = TRUE;
605 if(prevDlSf->remDatReqCnt)
607 /*We have not received 1 or more data requests from RLC, this is
608 error scenario. MAC & SCH need to discard the allocations for
609 which data request hasn't been received as yet. And MAC
610 needs to inform SCH about the list of UEs for which
611 allocation need to be discarded. */
612 prevDlSf->remDatReqCnt = 0;
618 /* Trigger for DL TTI REQ */
619 handleDlTtiReq(slotInd);
621 /* Trigger for UL TTI REQ */
622 handleUlTtiReq(slotInd);
624 dlSf = &cellCb->subFrms[(slotInd.slot % RG_NUM_SUB_FRAMES)];
626 if((dlSf->txDone == TRUE) ||
627 (!RG_TIMEINFO_SAME(slotInd,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.slot == 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((slotInd.slot % 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,slotInd->cellId,
696 // "Unable to process downlink subframe for cell");
697 err.errType = RGERR_TOM_TTIIND;
699 #ifdef XEON_SPECIFIC_CHANGES
700 CM_MEAS_TIME((slotInd->slot % 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);
712 } /* macProcessSlotInd */
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, slot, lcgBytes)
1017 Bool *spsToBeActvtd;
1022 #else /* LTEMAC_SPS */
1024 PRIVATE S16 rgTOMUtlProcMsg
1033 PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, slot, 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.slot);
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[(slot % 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 //TODO: commented for compilation without SCH
1313 relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1314 relInfo.cRnti = ueCb->ueId;
1315 relInfo.isExplRel = TRUE;
1316 /* Release indicator is called now through the matrix in the function below */
1317 //TODO: commented for compilation without SCH RgMacSchSpsRel( &schPst1, &relInfo );
1319 ueCb->ul.implRelCntr = 0;
1326 if(ueCb->ul.spsDatRcvd != 0)
1328 //ueCb->ul.implRelCntr = 0;
1329 ueCb->ul.explRelCntr = 0;
1330 ueCb->ul.spsDatRcvd = 0;
1334 /*Added for explicit release - end */
1336 if((dDatInd) && (dDatInd->numLch))
1339 rgTomUtlPrepareL2MUlThrpInfo(cellCb, ueCb,dDatInd);
1341 RG_CALC_TTI_CNT(cellCb, dDatInd->ttiCnt);
1343 if ((ret = rgUIMSndDedDatInd(inst,ueCb->rguUlSap,dDatInd)) != ROK)
1345 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
1346 "Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
1351 else if((dDatInd) && (0 == dDatInd->numLch))
1353 /* Free the memory allocated for dDatInd if we
1354 * have no valid LCH PDU to send to RLC.*/
1355 rgFreeSharableSBuf(inst,(Data **)&dDatInd,sizeof(RgRguDedDatInd));
1361 /** @brief This function frees up the RgMacPdu structure that has been
1362 * populated by demux.
1366 * Function: rgTOMUtlInsSchInfo
1367 * - Function frees up the RgMacPdu structure, in case of error it shall
1368 * free up the buffer's present in the different sdu.
1371 * @param [in] RgMacPdu *pdu
1372 * @param [in] Bool *error
1377 PRIVATE S16 rgTOMUtlInsSchInfo
1380 RgInfSfDatInd *sfInfo,
1381 RgInfCeInfo *ceInfo,
1388 PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti,spsToBeActvtd,sduSize, lcgBytes)
1390 RgInfSfDatInd *sfInfo;
1391 RgInfCeInfo *ceInfo;
1400 PRIVATE S16 rgTOMUtlInsSchInfo
1403 RgInfSfDatInd *sfInfo,
1404 RgInfCeInfo *ceInfo,
1409 PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti, lcgBytes)
1411 RgInfSfDatInd *sfInfo;
1412 RgInfCeInfo *ceInfo;
1419 RgInfUeDatInd *ueInfo;
1423 TRC2(rgTOMUtlInsSchInfo);
1425 RG_TOM_INF_ALLOC(sfInfo, sizeof(RgInfUeDatInd), ueInfo, ret);
1432 ueInfo->rnti = rnti;
1434 ueInfo->ceInfo = *ceInfo;
1435 ueInfo->ueLstEnt.node = (PTR)ueInfo;
1436 for (lcgId = 1, idx = 0; lcgId < RGINF_MAX_LCG_PER_UE; lcgId++)
1438 if (lcgBytes[lcgId] != 0)
1440 /* Only GBR bytes */
1441 ueInfo->lcgInfo[idx].lcgId = lcgId;
1442 ueInfo->lcgInfo[idx++].bytesRcvd = lcgBytes[lcgId];
1443 lcgBytes[lcgId] = 0;
1446 cmLListAdd2Tail(&sfInfo->ueLst, &ueInfo->ueLstEnt);
1448 } /* end of rgTOMUtlInsSchInfo */
1452 * @brief Handler for processing data indication recieved from PHY for UEs.
1456 * Function: rgTOMDatInd
1458 * Handler for processing data indication recieved from PHY for UEs.
1460 * Invoked by: RgLiTfuDatInd of LIM
1463 * For each DataInfo recieved
1464 * - Validate the information received and retrieve cellCb
1465 * Validate cellId, rnti
1466 * - Call De-Mux module to decode the data rgDUXDemuxData
1467 * - If received a CRNTI control element
1468 * - Check if a CCCH SDU is present, if it is return failure
1469 * - Check for the existence of UE, if its isnt present return failure.
1470 * - Delegate the remaining processing to rgTOMUtlProcMsg3 which
1471 * primarily informs the scheduler about the data received and
1472 * generates Data indications towards the higher layer.
1473 * - If only CCCH SDU is present
1474 * - Invoke rgTOMUtlProcMsg3 for further processing.
1475 * - If its a non-Msg3 PDU i.e. received outside of a RA procedure
1476 * - Retrieve the UeCB
1477 * - Validate that the received PDU contains only configured Logical
1479 * - Invoke rgTOMUtlProcDatPdu for further processing. It informs the
1480 * scheduler with the information of the received Data and generates
1481 * DatIndications towards the higher layers.
1483 * @param [in] Inst inst
1484 * @param[in] TfuDatIndInfo *datInd
1490 PUBLIC S16 rgTOMDatInd
1493 TfuDatIndInfo *datInd
1496 PUBLIC S16 rgTOMDatInd(inst,datInd)
1498 TfuDatIndInfo *datInd;
1504 RgUeCb *prevUeCb = NULLP;
1507 RgInfSfDatInd *sfInfo;
1511 TfuDatInfo *datInfo;
1515 Bool isSpsRnti=FALSE;
1517 // RgInfSpsRelInfo relInfo;
1518 Bool spsToBeActvtd = FALSE;
1521 U32 lcgBytes[RGINF_MAX_LCG_PER_UE];
1525 #ifdef STUB_TTI_HANDLING_5GTF
1526 node = datInd->datIndLst.first;
1527 for (;node; node=node->next)
1529 datInfo = (TfuDatInfo*)node->node;
1532 SFndLenMsg(datInfo->mBuf, &len);
1533 rgUlrate_tfu += len;
1534 if (rgUlrate_tfu > 100000)
1536 printf("Sowmya:rgTOMDatInd datInfo->mBuf len =%d rgUlrate_tfu=%d",len,rgUlrate_tfu);
1544 cmMemset((U8 *)&lcgBytes, 0, sizeof(lcgBytes));
1546 tfuSap = &(rgCb[inst].tfuSap);
1548 cellCb = rgCb[inst].cell;
1549 if((cellCb == NULLP) ||
1550 (cellCb->cellId != datInd->cellId))
1553 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to get the cellCb for cell");
1556 /* Avoiding memset as all the fields are getting initialized further */
1558 if (rgTOMInfAllocPduEvnt (inst,&sfInfo) != ROK)
1560 err.errType = RGERR_TOM_DATIND;
1561 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
1562 node = datInd->datIndLst.first;
1565 cmLListInit(&sfInfo->ueLst);
1566 sfInfo->cellId = datInd->cellId;
1567 sfInfo->timingInfo = datInd->timingInfo;
1568 slot = datInd->timingInfo.slot;
1570 node = datInd->datIndLst.first;
1571 for (;node; node=node->next)
1573 datInfo = (TfuDatInfo*)node->node;
1575 //extern U32 ulrate_tfu;
1577 SFndLenMsg(datInfo->mBuf, &len);
1578 #ifdef STUB_TTI_HANDLING_5GTF
1579 // printf("Sowmya:rgTOMDatInd datInfo->mBuf len =%d",len);
1581 rgUlrate_tfu += len;
1583 grgUlrate_tfu += len;
1586 #ifdef STUB_TTI_HANDLING_5GTF
1587 rgLIMUtlFreeDatIndEvnt(datInd,TRUE);
1589 /* We shall call De-Mux to process the received buffer. We shall try and find
1590 * out the RaCb based on the following -
1591 * 1. If the incoming PDU contained a CCCH SDU i.e. this is message 3.
1592 * 2. If the incoming PDU contained a CRNTI control element, i.e. we should
1593 * have a ueCb also for this
1595 /* Lets allocate the event that needs to be passed to DUX */
1596 if (rgTOMUtlAllocPduEvnt (inst,&pdu) != ROK)
1598 err.errType = RGERR_TOM_DATIND;
1599 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
1600 rgTOMInfFreePduEvnt (sfInfo);
1604 if ((ret = rgDUXDemuxData (inst,pdu, &ceInfo,
1605 &datInfo->mBuf, &err)) != ROK)
1608 /* Fix: sriky memory corruption precautions */
1609 rgTOMUtlFreePduEvnt (pdu, TRUE);
1610 err.errType = RGERR_TOM_DATIND;
1611 RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"DUX processing failed");
1612 tfuSap->sapSts.numPduDrop++;
1615 /* It could be that a non-msg3 pdu contains a CRNTI Control element. We
1616 * should check for CRNTI CE and if it exists the UECb must exist, also an
1617 * if the CRNTI in the CE and the one with which the message came in are
1618 * different we shall look for an raCb as well.
1621 if (ceInfo.bitMask & RG_CCCH_SDU_PRSNT)
1623 ret = rgTOMProcCCCHSduInDatInd(pdu, prevUeCb, \
1624 cellCb, datInfo, &ceInfo, slot);
1627 rgTOMUtlFreePduEvnt (pdu, TRUE);
1628 err.errType = RGERR_TOM_DATIND;
1629 tfuSap->sapSts.numPduDrop++;
1632 } /* end of Msg3 processing */
1634 else if (ceInfo.bitMask & RG_CRNTI_CE_PRSNT)
1636 ret = rgTOMProcCrntiCEInDatInd(pdu, prevUeCb, \
1637 cellCb, datInfo, &ceInfo, slot);
1640 rgTOMUtlFreePduEvnt (pdu, TRUE);
1641 err.errType = RGERR_TOM_DATIND;
1642 tfuSap->sapSts.numPduDrop++;
1646 } /* end of CRNTI based message */
1649 ueCb = rgDBMGetUeCb (cellCb, datInfo->rnti);
1653 /* Try getting the UE using SPS-RNTI. */
1654 ueCb = rgDBMGetSpsUeCb (cellCb, datInfo->rnti);
1658 /* Increment implrelCntr for an empty transmission */
1659 if (pdu->sduLst.count == 0)
1661 ueCb->ul.implRelCntr++;
1662 if (ueCb->ul.implRelCntr == ueCb->ul.implRelCnt)
1664 /* Indicate scheduler for implicit release */
1665 cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
1666 rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
1668 ueCb->ul.implRelCntr = 0;
1669 ueCb->ul.explRelCntr = 0;
1671 relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1672 relInfo.cRnti = ueCb->ueId;
1673 relInfo.isExplRel= FALSE;
1674 //TODO: commented for compilation without SCH RgMacSchSpsRel(&schPst1, &relInfo);
1680 /* Reset the implrelCntr */
1681 ueCb->ul.implRelCntr = 0;
1687 /* Perform failure if ueCb is still NULLP */
1688 rgTOMUtlFreePduEvnt (pdu, TRUE);
1689 err.errType = RGERR_TOM_DATIND;
1690 RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,"RNTI:%d Unable to get the UE CB",
1692 tfuSap->sapSts.numPduDrop++;
1697 rgTOMUtlL2MStoreBufSz(ueCb, &ceInfo);
1698 rgTOML2MCompileActiveLCs (cellCb, ueCb, pdu, &ceInfo);
1701 if ((ret = rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,&spsToBeActvtd,&sduSize, slot, (U32 *)&lcgBytes)) != ROK)
1703 if ((ret = rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, (U32 *)&lcgBytes)) != ROK)
1704 #endif /* LTEMAC_SPS */
1706 rgTOMUtlFreePduEvnt (pdu, TRUE);
1707 err.errType = RGERR_TOM_DATIND;
1708 RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,
1709 "Unable to handle Data Indication CRNTI:%d",ueCb->ueId);
1710 tfuSap->sapSts.numPduDrop++;
1717 if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti,spsToBeActvtd,sduSize, (U32 *)&lcgBytes) != ROK)
1719 if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti, (U32 *)&lcgBytes) != ROK)
1723 rgTOMInfFreePduEvnt (sfInfo);
1724 rgTOMUtlFreePduEvnt (pdu, FALSE);
1727 /* free up the PDU memory */
1728 rgTOMUtlFreePduEvnt (pdu, FALSE);
1730 /* Free the allocated memory for ueUlAllocInfo here */
1732 if(cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].ueUlAllocInfo != NULLP)
1734 /*ccpu00117052 - MOD - Passing double for proper NULLP
1736 rgFreeSBuf(inst,(Data **)&(cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].ueUlAllocInfo),
1737 ((cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].numUe) * sizeof(RgUeUlAlloc)));
1741 /* Update PRB used for all GBR QCIs to scheduler */
1742 cmMemcpy((U8*) &sfInfo->qcisUlPrbCnt[0],
1743 (U8*) &cellCb->qcisUlPrbCnt[0],
1744 (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1745 /* clear the cellCb ul prb value */
1746 cmMemset((U8*)&cellCb->qcisUlPrbCnt[0], 0,
1747 (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1751 rgGetPstToInst(&schPst, inst,cellCb->schInstMap.schInst);
1752 sfInfo->cellSapId = cellCb->schInstMap.cellSapId;
1753 //TODO: commented for compilation without SCH RgMacSchSfRecp(&schPst, sfInfo);
1758 * @brief Function handles allocation for common channels i.e. BCCH-BCH,
1759 * BCCH-DLSCH, PCCH-DLSCH.
1763 * Function : rgHndlCmnChnl
1765 * This function is invoked from RgSchMacSfAllocReq. This function handles
1766 * allocations made for common channels like BCCH and PCCH.
1769 * 1. If BCCH on BCH has been scheduled, send StatusIndication on RGU.
1770 * 2. If PCCH is scheduled, send StatusIndication on RGU.
1771 * 3. If BCCH on DLSCH has been scheduled and sndStatInd is TRUE, send
1772 * StatusIndication on RGU, else copy the bcch buffer onto the downlink
1776 * @param[in] RgCellCb *cell,
1777 * @param[in] CmLteTimingInfo timingInfo,
1778 * @param[in] RgInfCmnLcInfo *cmnLcInfo,
1779 * @param[in/out] RgErrInfo *err,
1785 PRIVATE S16 rgHndlCmnChnl
1788 CmLteTimingInfo timingInfo,
1789 RgInfCmnLcInfo *cmnLcInfo,
1793 PRIVATE S16 rgHndlCmnChnl(cell, timingInfo, cmnLcInfo, err)
1795 CmLteTimingInfo timingInfo;
1796 RgInfCmnLcInfo *cmnLcInfo;
1800 #if (ERRCLASS & ERRCLS_DEBUG)
1804 RgBcchDlschLcCb *bcch;
1805 #if (ERRCLASS & ERRCLS_DEBUG)
1808 #endif/*RGR_SI_SCH*/
1809 RguCStaIndInfo *staInd;
1811 Inst inst = cell->macInst - RG_INST_START;
1815 dlSf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
1817 if(cmnLcInfo->bitMask & RGINF_BCH_INFO)
1820 #if (ERRCLASS & ERRCLS_DEBUG)
1821 if(NULLP == (bch = rgDBMGetBcchOnBch(cell)))
1825 if(cmnLcInfo->bchInfo.lcId != bch->lcId)
1831 if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1833 err->errCause = RGERR_TOM_MEM_EXHAUST;
1836 staInd->cellId = cell->cellId;
1837 staInd->rnti = RG_INVALID_RNTI;
1838 staInd->lcId = cmnLcInfo->bchInfo.lcId;
1839 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1840 /* ADD Changes for Downlink UE Timing Optimization */
1841 #ifdef LTEMAC_DLUE_TMGOPTMZ
1842 dlSf->remDatReqCnt++;
1844 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1849 /*Store the received BCH Data in the scheduled subframe*/
1850 dlSf->bch.tb = cmnLcInfo->bchInfo.pdu;
1851 #endif/*RGR_SI_SCH*/
1854 if(cmnLcInfo->bitMask & RGINF_PCCH_INFO)
1856 #if (ERRCLASS & ERRCLS_DEBUG)
1857 if(NULLP == (pcch = rgDBMGetPcch(cell)))
1861 if(cmnLcInfo->pcchInfo.lcId != pcch->lcId)
1867 dlSf->pcch.pdcch.rnti =
1868 cmnLcInfo->pcchInfo.rnti;
1869 dlSf->pcch.pdcch.dci =
1870 cmnLcInfo->pcchInfo.dciInfo;
1872 /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */
1873 dlSf->pcch.txPwrOffset = cmnLcInfo->pcchInfo.txPwrOffset;
1875 if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1877 err->errCause = RGERR_TOM_MEM_EXHAUST;
1880 staInd->cellId = cell->cellId;
1881 staInd->rnti = RG_INVALID_RNTI;
1882 staInd->lcId = cmnLcInfo->pcchInfo.lcId;
1883 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1884 /* ADD Changes for Downlink UE Timing Optimization */
1885 #ifdef LTEMAC_DLUE_TMGOPTMZ
1886 dlSf->remDatReqCnt++;
1888 /* for consolidated CmnStaInd calling below function from function
1889 * rgHndlSchedUe once CmnStaInd prepared for all UEs
1891 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1897 if(cmnLcInfo->bitMask & RGINF_BCCH_INFO)
1899 dlSf->bcch.pdcch.rnti =
1900 cmnLcInfo->bcchInfo.rnti;
1901 dlSf->bcch.pdcch.dci =
1902 cmnLcInfo->bcchInfo.dciInfo;
1904 /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */
1905 dlSf->bcch.txPwrOffset = cmnLcInfo->bcchInfo.txPwrOffset;
1909 (bcch=rgDBMGetBcchOnDlsch(cell,cmnLcInfo->bcchInfo.lcId)))
1913 if(TRUE == cmnLcInfo->bcchInfo.sndStatInd)
1915 RG_FREE_MSG(bcch->tb);
1916 if (rgAllocShrablSBuf (inst,(Data**)&staInd,
1917 sizeof(RguCStaIndInfo)) != ROK)
1919 err->errCause = RGERR_TOM_MEM_EXHAUST;
1922 staInd->cellId = cell->cellId;
1923 staInd->rnti = RG_INVALID_RNTI;
1924 staInd->lcId = cmnLcInfo->bcchInfo.lcId;
1925 staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1926 /* ADD Changes for Downlink UE Timing Optimization */
1927 #ifdef LTEMAC_DLUE_TMGOPTMZ
1928 dlSf->remDatReqCnt++;
1930 if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1937 SCpyMsgMsg(bcch->tb, RG_GET_MEM_REGION(rgCb[inst]),
1938 RG_GET_MEM_POOL(rgCb[inst]), &dlSf->bcch.tb);
1941 /*Store the received BCCH Data in the scheduled subframe*/
1942 dlSf->bcch.tb = cmnLcInfo->bcchInfo.pdu;
1943 #endif/*RGR_SI_SCH*/
1947 } /* end of rgHndlCmnChnl */
1950 * @brief Function for handling allocations for dedicated channels for a
1955 * Function : rgHndlSchdUe
1957 * This function shall be invoked whenever scheduler is done with the
1958 * allocations of dedicated channels for a subframe. Invoked by the function
1959 * RgSchMacSfAllocReq.
1961 * Processing steps :
1962 * 1. Loops through the list of UE's scheduled looking for the corresponding
1964 * 2. Finds the corresponding HARQ process.
1965 * 3. Invokes the DHM function to issue StatusIndications on RGU.
1968 * @param[in] RgCellCb *cell,
1969 * @param[in] CmLteTimingInfo timingInfo,
1970 * @param[in] RgInfUeInfo *ueInfo
1971 * @param[in/out] RgErrInfo *err
1977 PRIVATE S16 rgHndlSchdUe
1980 CmLteTimingInfo timingInfo,
1981 RgInfUeInfo *ueInfo,
1985 PRIVATE S16 rgHndlSchdUe(cell, timingInfo, ueInfo, err) /* laa_ut_fix */
1987 CmLteTimingInfo timingInfo;
1988 RgInfUeInfo *ueInfo;
1995 if(NULLP == ueInfo->allocInfo)
2000 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err);
2003 } /* end of rgHndlSchdUe */
2007 * @brief Function for handling Uplink allocations for Ue for a
2012 * Function : rgHndlUlUeInfo
2014 * @param[in] RgCellCb *cell,
2015 * @param[in] CmLteTimingInfo timingInfo,
2016 * @param[in] RgInfUlUeInfo *ueInfo
2022 PRIVATE S16 rgHndlUlUeInfo
2025 CmLteTimingInfo timingInfo,
2026 RgInfUlUeInfo *ueInfo
2029 PRIVATE S16 rgHndlUlUeInfo(cell, timingInfo, ueInfo)
2031 CmLteTimingInfo timingInfo;
2032 RgInfUlUeInfo *ueInfo;
2035 Inst inst = cell->macInst - RG_INST_START;
2040 TRC2(rgHndlUlUeInfo)
2042 ulSf = &cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)];
2044 /* rg003.301-MOD- Corrected the purifier memory leak */
2045 if (ulSf->numUe != ueInfo->numUes)
2047 if (ulSf->ueUlAllocInfo)
2049 rgFreeSBuf(inst,(Data **)&(ulSf->ueUlAllocInfo),
2050 ulSf->numUe * sizeof(RgUeUlAlloc));
2053 #ifdef XEON_SPECIFIC_CHANGES
2054 CM_MEAS_TIME((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_FREE);
2055 CM_ADD_INFO((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MEAS_FREE, ulSf->numUe);
2057 ulSf->numUe = ueInfo->numUes;
2058 if((ulSf->ueUlAllocInfo == NULLP) && (ueInfo->numUes > 0))
2060 /* Allocate memory for ulAllocInfo */
2061 if((ret = rgAllocSBuf(inst,(Data**)&(cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)].
2062 ueUlAllocInfo), ueInfo->numUes * sizeof(RgUeUlAlloc))) != ROK)
2067 #ifdef XEON_SPECIFIC_CHANGES
2068 CM_MEAS_TIME((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_ALLOC);
2069 CM_ADD_INFO((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MEAS_ALLOC, ueInfo->numUes);
2071 if (ulSf->ueUlAllocInfo != NULLP)
2073 for(idx = 0; idx < ueInfo->numUes; idx++)
2075 ulSf->ueUlAllocInfo[idx].rnti = ueInfo->ulAllocInfo[idx].rnti;
2076 ulSf->ueUlAllocInfo[idx].numPrb = ueInfo->ulAllocInfo[idx].numPrb;
2079 RGCPYTIMEINFO(timingInfo, ulSf->schdTime);
2081 } /* end of rgHndlUlUeInfo */
2084 * @brief Function for handling RaResp request received from scheduler to MAC
2088 * Function : rgTOMRlsSf
2090 * This function shall be invoked whenever scheduler is done with the
2091 * allocations of random access responses for a subframe.
2092 * This shall invoke RAM to create ueCbs for all the rapIds allocated and
2093 * shall invoke MUX to create RAR PDUs for raRntis allocated.
2096 * @param[in] Inst inst
2097 * @param[in] CmLteCellId cellId,
2098 * @param[in] CmLteTimingInfo timingInfo,
2099 * @param[in] RaRespInfo *rarInfo
2104 PUBLIC Void rgTOMRlsSf
2110 PUBLIC Void rgTOMRlsSf(dlSf)
2119 if(dlSf->txDone == FALSE)
2121 RLOG0(L_ERROR, "SUBFRAME Not pushed to the PHY");
2123 if (dlSf->bch.tb != NULLP)
2125 RG_FREE_MSG(dlSf->bch.tb);
2127 if (dlSf->bcch.tb != NULLP)
2129 RG_FREE_MSG(dlSf->bcch.tb);
2131 if (dlSf->pcch.tb != NULLP)
2133 RG_FREE_MSG(dlSf->pcch.tb);
2136 rgTOMEmtcRlsSf(dlSf);
2138 for(idx=0; idx < dlSf->numRaRsp; idx++)
2140 RG_FREE_MSG(dlSf->raRsp[idx].rar);
2143 /* ADD Changes for Downlink UE Timing Optimization */
2144 #ifdef LTEMAC_DLUE_TMGOPTMZ
2145 dlSf->remDatReqCnt = 0;
2146 /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2148 dlSf->statIndDone = FALSE;
2150 if (dlSf->tbs.count)
2155 RGDBGERRNEW(inst, (rgPBuf(inst),
2156 "Error Stale TBs in Subframes TBS list\n"));
2157 node = dlSf->tbs.first;
2160 hqP = (RgDlHqProcCb*)node->node;
2164 for(i=0;i< RG_MAX_TB_PER_UE;i++)
2166 if (hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf == dlSf)
2168 cmLListDelFrm(&dlSf->tbs, &(hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk));
2169 hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk.node = NULLP;
2170 printf("\n rgTOMRlsSf:: hqP %p \n", (Void *)hqP);
2172 hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf = NULLP;
2177 /*arjun: check if dlSf laaTb list has to be freed???*/
2178 cmLListInit(&dlSf->tbs);
2179 dlSf->txDone = FALSE;
2185 * @brief Function is called by the scheduler once it has completed the
2186 * allocation for the subframe.
2190 * Function : rgHndlFlowCntrl
2191 * This function should fill and send Flow control
2195 * @param[in] Pst *cell
2196 * @param[in] RgInfSfAlloc *sfInfo Carries all the allocation
2202 PUBLIC S16 rgHndlFlowCntrl
2205 RgInfSfAlloc *sfInfo
2208 PUBLIC S16 rgHndlFlowCntrl(cell, sfInfo)
2210 RgInfSfAlloc *sfInfo;
2213 RguFlowCntrlInd *flowCntrlInd;
2217 TRC3(rgHndlFlowCntrl);
2219 pst = &cell->rguDlSap->sapCfg.sapPst;
2220 /* flowCntrlInd is alloced in cell init time and will be re-used throughout */
2221 flowCntrlInd = cell->flowCntrlInd;
2222 flowCntrlInd->cellId = sfInfo->cellId;
2223 flowCntrlInd->numUes = sfInfo->flowCntrlInfo.numUes;
2225 for (ueIdx = 0; ueIdx < sfInfo->flowCntrlInfo.numUes; ueIdx++)
2227 flowCntrlInd->ueFlowCntrlInfo[ueIdx].ueId = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].ueId;
2228 flowCntrlInd->ueFlowCntrlInfo[ueIdx].numLcs = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].numLcs;
2230 for (lcIdx = 0; lcIdx < RGINF_MAX_NUM_DED_LC; lcIdx++)
2232 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId =
2233 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId;
2234 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt =
2235 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt;
2237 flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl =
2238 sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl;
2241 RgUiRguFlowCntrlInd(pst, cell->rguDlSap->sapCfg.spId,flowCntrlInd); /* TODO: Rishi confirm if the suId and pst pointer is correct */
2245 * @brief Function is called by the scheduler once it has completed the
2246 * allocation for the subframe.
2250 * Function : RgSchMacSfAllocReq
2252 * This function shall be invoked whenever scheduler is done with the
2253 * allocations of for a subframe. The sfInfo carries all the allocation
2254 * details for the common channels, RA responses and dedicated channel
2257 * Processing steps :
2258 * 1. Reset the information present in the downlink subframe that is
2260 * 2. Handle common channel allocations
2261 * 3. Handle RA Response allocations
2262 * 4. Handle dedicated channel allocations.
2264 * @param[in] Pst *pst
2265 * @param[in] RgInfSfAlloc *sfInfo Carries all the allocation
2271 PUBLIC S16 RgSchMacSfAllocReq
2274 RgInfSfAlloc *sfInfo
2277 PUBLIC S16 RgSchMacSfAllocReq(pst, sfInfo)
2279 RgInfSfAlloc *sfInfo;
2285 VOLATILE U32 startTime=0;
2288 TRC2(RgSchMacSfAllocReq)
2290 RG_IS_INST_VALID(pst->dstInst);
2291 inst = pst->dstInst - RG_INST_START;
2293 SStartTask(&startTime, PID_MAC_SF_ALLOC_REQ);
2300 if((cell = rgCb[inst].cell) == NULLP)
2302 RLOG_ARG0(L_ERROR,DBG_CELLID,sfInfo->cellId, "No cellCb found with cell");
2306 dlSf = &cell->subFrms[(sfInfo->timingInfo.slot % RG_NUM_SUB_FRAMES)];
2308 rgTOMRlsSf(inst,dlSf);
2309 dlSf->schdTime = sfInfo->timingInfo;
2312 rgLaaInitTbInfoLst(cell);
2315 /* Fix : syed Ignore Failure Returns and continue processing.
2316 * Incomplete processing results in state sync loss between MAC-SCH. */
2318 if(TRUE == cell->emtcEnable)
2320 rgEmtcHndl(cell, sfInfo);
2323 rgHndlCmnChnl(cell, sfInfo->timingInfo, &sfInfo->cmnLcInfo, &err);
2325 rgHndlRaResp(cell, sfInfo->timingInfo, &sfInfo->rarInfo, &err);
2328 #ifdef XEON_SPECIFIC_CHANGES
2329 CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_B4_UE_SCHD);
2331 rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2332 #ifdef XEON_SPECIFIC_CHANGES
2333 CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_UE_SCHD);
2335 rgLaaChkAndReqTbs(dlSf,cell, inst);
2338 rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2342 if(rgHndlUlUeInfo(cell, sfInfo->ulUeInfo.timingInfo,
2343 &sfInfo->ulUeInfo) != ROK)
2348 #ifdef XEON_SPECIFIC_CHANGES
2349 CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_MEAS);
2351 /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2355 /* Added the handling for pushing down
2356 * TFU Data request in the retransmission only scenario.*/
2357 #ifdef LTEMAC_DLUE_TMGOPTMZ
2358 dlSf->statIndDone = TRUE;
2359 /* Fix [ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
2361 if(!(dlSf->txDone) &&
2363 (TRUE == rgLaaChkAllRxTbs(dlSf)) &&
2365 (0 == dlSf->remDatReqCnt) && (dlSf->statIndDone) &&
2366 (RG_TIMEINFO_SAME(cell->crntTime, dlSf->schdTime)))
2368 /*This is the case of rettransmission, so no need
2369 * to wait for TTI Ind to push TFU Data Request. Send
2371 if (ROK != rgTOMUtlProcDlSf (dlSf, cell, &err))
2373 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to process downlink subframe for cell");
2374 err.errType = RGERR_ROM_DEDDATREQ;
2376 /* Mark this frame as sent */
2377 dlSf->txDone = TRUE;
2380 if (sfInfo->flowCntrlInfo.numUes > 0)
2382 rgHndlFlowCntrl(cell,sfInfo);
2385 SStopTask(startTime, PID_MAC_SF_ALLOC_REQ);
2387 } /* end of RgSchMacSfAllocReq */
2389 * @brief Handler for processing data indication recieved from PHY for UEs.
2393 * Function: rgTOMProcCrntiCEInDatInd
2395 * Handler for processing data indication recieved from PHY for UEs.
2397 * Invoked by: RgLiTfuDatInd of LIM
2400 * For each DataInfo recieved
2401 * - If received a CRNTI control element
2402 * - Check if a CCCH SDU is present, if it is return failure
2403 * - Check for the existence of UE, if its isnt present return failure.
2404 * - Delegate the remaining processing to rgTOMUtlProcMsg3 which
2405 * primarily informs the scheduler about the data received and
2406 * generates Data indications towards the higher layer.
2408 * @param RgMacPdu *pdu,
2409 * @param RgUeCb *prevUeCb,
2410 * @param RgCellCb *cellCb,
2411 * @param TfuDatInfo *datInfo,
2412 * @param RgInfCeInfo *ceInfo
2418 PRIVATE S16 rgTOMProcCrntiCEInDatInd
2423 TfuDatInfo *datInfo,
2424 RgInfCeInfo *ceInfo,
2428 PRIVATE S16 rgTOMProcCrntiCEInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
2432 TfuDatInfo *datInfo;
2433 RgInfCeInfo *ceInfo;
2437 RgUeCb *ueCb = NULLP;
2438 Inst inst = cellCb->macInst - RG_INST_START;
2446 TRC2(rgTOMProcCrntiCEInDatInd)
2452 ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2456 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2457 "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2461 prevUeCb = rgDBMGetUeCb (cellCb, ceInfo->ces.cRnti);
2462 if (prevUeCb == NULLP)
2464 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2465 "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2468 RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
2469 "CRNTI CE(%d) received through tmpCrnti(%d)",
2470 ceInfo->ces.cRnti, datInfo->rnti);
2471 rgDBMDelUeCbFromRachLst(cellCb, ueCb);
2472 rgRAMFreeUeCb(inst,ueCb);
2475 if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, slot, NULLP)) != ROK)
2477 if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, NULLP)) != ROK)
2478 #endif /* LTEMAC_SPS */
2480 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2481 "RNTI:%d Processing for MSG3 failed",datInfo->rnti);
2487 * @brief Handler for processing data indication recieved from PHY for UEs.
2491 * Function: rgTOMProcCCCHSduInDatInd
2493 * Handler for processing data indication recieved from PHY for UEs.
2495 * Invoked by: RgLiTfuDatInd of LIM
2498 * For each DataInfo recieved
2499 * - If only CCCH SDU is present
2500 * - Invoke rgTOMUtlProcMsg3 for further processing.
2501 * - If its a non-Msg3 PDU i.e. received outside of a RA procedure
2502 * - Retrieve the UeCB
2503 * - Validate that the received PDU contains only configured Logical
2505 * - Invoke rgTOMUtlProcDatPdu for further processing. It informs the
2506 * scheduler with the information of the received Data and generates
2507 * DatIndications towards the higher layers.
2509 * @param TfuDatIndInfo *datInd
2510 * @param RgMacPdu *pdu,
2511 * @param RgUeCb *prevUeCb,
2512 * @param RgCellCb *cellCb,
2513 * @param TfuDatInfo *datInfo,
2514 * @param RgInfCeInfo *ceInfo
2520 PRIVATE S16 rgTOMProcCCCHSduInDatInd
2525 TfuDatInfo *datInfo,
2526 RgInfCeInfo *ceInfo,
2530 PRIVATE S16 rgTOMProcCCCHSduInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
2534 TfuDatInfo *datInfo;
2535 RgInfCeInfo *ceInfo;
2539 RgUeCb *ueCb = NULLP;
2540 Inst inst = cellCb->macInst - RG_INST_START;
2548 TRC2(rgTOMProcCCCHSduInDatInd)
2554 if (ceInfo->bitMask & RG_CRNTI_CE_PRSNT)
2556 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2557 "CRNTI:%d Received MSG3 with CCCH",ceInfo->ces.cRnti);
2561 ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2565 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2566 "RNTI:%d Processing for MSG3 failed", datInfo->rnti);
2569 /* Fix: syed Drop any duplicate Msg3(CCCH Sdu) */
2570 if (ueCb->dl.hqEnt.numHqProcs)
2572 /* HqE is already initialized by a previuos Msg3 */
2573 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed. Duplicate "
2574 "MSG3 received. Dropping", datInfo->rnti);
2578 if(rgDHMHqEntInit(inst,&ueCb->dl.hqEnt,
2579 cellCb->maxDlHqProcPerUe) != ROK)
2581 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Harq Initialization failed ",
2585 RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
2586 "CCCH SDU received through tmpCrnti(%d)",datInfo->rnti);
2588 if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, slot, NULLP)) != ROK)
2590 if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, NULLP)) != ROK)
2591 #endif /* LTEMAC_SPS */
2593 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed",
2602 /** @brief This function captures the BSR value from Control Element
2603 * Info structure and updates the effective Buffer size into the
2604 * corresponding LCG ID.
2608 * Function: rgTOMUtlL2MStoreBufSz
2611 * - update/append the Data structure based on BSR type
2613 * @param [in] RgUeCb *ueCb
2614 * @param [in] RgInfCeInfo *ceInfo
2619 PRIVATE S16 rgTOMUtlL2MStoreBufSz
2625 PRIVATE S16 rgTOMUtlL2MStoreBufSz (ueCb, ceInfo)
2627 RgInfCeInfo *ceInfo;
2632 TRC2(rgTOMUtlL2MStoreBufSz);
2634 if(ceInfo->bitMask & RG_TRUNC_BSR_CE_PRSNT)
2636 lcgId = ((ceInfo->ces.bsr.truncBsr >> 6) & 0x03);
2637 bsr = ceInfo->ces.bsr.truncBsr & 0x3F;
2638 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2640 else if(ceInfo->bitMask & RG_SHORT_BSR_CE_PRSNT)
2642 lcgId = ((ceInfo->ces.bsr.shortBsr >> 6) & 0x03);
2643 bsr = ceInfo->ces.bsr.shortBsr & 0x3F;
2644 ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2647 else if(ceInfo->bitMask & RG_LONG_BSR_CE_PRSNT)
2649 ueCb->ul.lcgArr[0].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs1];
2650 ueCb->ul.lcgArr[1].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs2];
2651 ueCb->ul.lcgArr[2].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs3];
2652 ueCb->ul.lcgArr[3].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs4];
2655 } /* end of rgTOMUtlL2MStoreBufSz*/
2657 /** @brief : Compiles list of LCs received in UL data for DTCH RBs
2661 * @param [in] RgCellCb *cellCb
2662 * @param [in] RgUeCb *ueCb
2663 * @param [in] CmLteRnti rnti
2664 * @param [in] RgMacPdu *pdu
2671 PRIVATE Void rgTOML2MCompileActiveLCs
2679 PRIVATE Void rgTOML2MCompileActiveLCs(cellCb, ueCb, pdu, ceInfo)
2683 RgInfCeInfo *ceInfo;
2690 TRC2(rgTOML2MCompileActiveLCs)
2692 node = pdu->sduLst.first;
2695 sdu = (RgMacSdu*)node->node;
2697 if ((ulLcCb = rgDBMGetUlDedLcCb(ueCb, sdu->lcId)), ulLcCb != NULLP)
2699 if (ulLcCb->lcgId != 0)
2701 ceInfo->bitMask |= RG_ACTIVE_LC_PRSNT;
2702 ceInfo->ulActLCs[ulLcCb->lcId - 1] = TRUE;
2713 /**********************************************************************
2716 **********************************************************************/