Muxing mac pdu and lower mac changes for Msg4
[o-du/l2.git] / src / 5gnrmac / rg_tom.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may not use this file except in compliance with the License.           #
7 #   You may obtain a copy of the License at                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
11 #   Unless required by applicable law or agreed to in writing, software        #
12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
14 #   See the License for the specific language governing permissions and        #
15 #   limitations under the License.                                             #
16 ################################################################################
17 *******************************************************************************/
18
19 /************************************************************************
20  
21      Name:     LTE-MAC layer
22   
23      Type:     C source file
24   
25      Desc:     C source code for Entry point fucntions
26   
27      File:     rg_tom.c 
28   
29 **********************************************************************/
30
31 static const char* RLOG_MODULE_NAME="MAC";
32 static int RLOG_FILE_ID=237;
33 static int RLOG_MODULE_ID=4096;
34 /** @file rg_tom.c 
35 @brief This module does processing related to handling of lower interface APIs 
36 invoked by PHY towards MAC
37 */
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 */
58
59
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"
79 #include "mac.h"
80 #include "rg.x"            /* typedefs for MAC */
81 #include "lwr_mac_fsm.h"
82 #ifdef MAC_RLC_UL_RBUF
83 #include "ss_rbuf.h"
84 #include "ss_rbuf.x"
85 #endif
86
87 /* ADD Changes for Downlink UE Timing Optimization */
88 #ifndef LTEMAC_DLUE_TMGOPTMZ 
89 PRIVATE S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf, RgCellCb   *cellCb,
90                                     RgErrInfo  *err));
91 #else
92 PUBLIC S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
93                                   RgErrInfo  *err));
94 #endif
95 PRIVATE S16 rgTOMProcCrntiCEInDatInd ARGS((
96 RgMacPdu          *pdu,
97 RgUeCb            *prevUeCb,
98 RgCellCb          *cellCb,
99 TfuDatInfo        *datInfo,
100 RgInfCeInfo       *ceInfo,
101 U16               slot
102 ));
103
104 PRIVATE S16 rgTOMProcCCCHSduInDatInd ARGS((
105 RgMacPdu          *pdu,
106 RgUeCb            *prevUeCb,
107 RgCellCb          *cellCb,
108 TfuDatInfo        *datInfo,
109 RgInfCeInfo       *ceInfo,
110 U16               slot
111 ));
112
113 PUBLIC S16 rgHndlFlowCntrl
114 (
115 RgCellCb       *cell,
116 RgInfSfAlloc        *sfInfo
117 );
118
119 EXTERN S16 RgUiRguFlowCntrlInd(Pst* pst, SuId suId, RguFlowCntrlInd *flowCntrlInd);
120 #ifdef EMTC_ENABLE
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);  
124 #endif
125 #ifdef LTE_L2_MEAS
126 PRIVATE Void rgTOML2MCompileActiveLCs ARGS
127 ((
128  RgCellCb      *cellCb, 
129  RgUeCb        *ueCb,
130  RgMacPdu      *pdu,
131  RgInfCeInfo   *ceInfo 
132  ));
133 PRIVATE S16 rgTOMUtlL2MStoreBufSz ARGS
134 ((
135  RgUeCb      *ueCb,
136  RgInfCeInfo *ceInfo
137  ));
138
139 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo ARGS
140 ((
141    RgCellCb *cellCb,
142    RgUeCb  *ueCb,
143    RgRguDedDatInd  *dDatInd
144 ));
145
146
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
161 };
162 #else
163
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,
170 3000000};
171
172 #endif
173
174 #endif
175
176 /* local defines */
177 #define RG_TOM_INF_ALLOC(_pdu, _size, _dataPtr, _ret) {\
178    _ret = cmGetMem((Ptr)&_pdu->memCp, _size, (Ptr *)&_dataPtr); \
179 }
180
181 /* global variables */
182 PUBLIC U32 rgUlrate_tfu;
183 #ifdef EMTC_ENABLE
184 EXTERN U32 grgUlrate_tfu;
185 #endif
186
187 /** @brief This function fills the PDSCH data of a downlink subframe 
188  *
189  * @details
190  *
191  *     Function: rgTOMUtlFillDatReqPdus 
192  *
193  *         Processing steps:
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
198  *
199  * @param  [out] TfuDatReqInfo *datInfo 
200  * @param  [in]  RgDlSf     *dlSf
201  * @param  [in]  RgCellCb   *cellCb
202  * @param  [out] RgErrInfo *err
203  * @return  S16
204  *      -# ROK 
205  *      -# RFAILED 
206  */
207 #ifdef ANSI
208 PRIVATE S16 rgTOMUtlFillDatReqPdus 
209 (
210  TfuDatReqInfo *datInfo,
211  RgDlSf        *dlSf,
212  RgCellCb      *cellCb,
213  RgErrInfo     *err
214  )
215 #else
216 PRIVATE S16 rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)
217  TfuDatReqInfo *datInfo;
218  RgDlSf        *dlSf;
219  RgCellCb      *cellCb;
220  RgErrInfo     *err;
221 #endif
222 {
223    S16              ret;
224    TfuDatReqPduInfo *datReq=NULLP;
225  /* Moving node declaration to limited scope for optimization */
226    RgDlHqProcCb     *hqCb;
227    U8               idx;
228    Inst             inst = cellCb->macInst - RG_INST_START;
229
230    TRC2(rgTOMUtlFillDatReqPdus)
231
232       /* first lets send the BCCH data down to PHY */
233    if (dlSf->bcch.tb != NULLP)
234    {
235       if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
236                                 &(datInfo->memCp))) != ROK)
237       {
238          err->errCause = RGERR_TOM_MEM_EXHAUST;
239          RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion ");
240          RETVALUE(ret);
241       }
242 #ifdef TFU_ALLOC_EVENT_NO_INIT
243 #ifndef L2_OPTMZ      
244       datReq->mBuf[1] = 0;
245 #else 
246      datReq->tbInfo[0].lchInfo[0].mBuf[0]=NULLP;
247 #endif
248 #endif
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
253        * during shutdown */
254       datReq->nmbOfTBs               =  1;
255 #ifndef L2_OPTMZ
256       datReq->mBuf[0]                =  dlSf->bcch.tb;
257 #else
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;
263
264 #ifdef TFU_ALLOC_EVENT_NO_INIT
265       datReq->tbInfo[1].tbPres             = FALSE;
266       datReq->tbInfo[1].lchInfo[0].mBuf[0] = NULLP;
267 #endif
268 #endif
269       cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
270       datReq->lnk.node = (PTR)datReq;
271 #ifdef TFU_UPGRADE      
272       /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
273       datReq->txPwrOffset            = dlSf->bcch.txPwrOffset;
274 #endif      
275       /* Setting the pointer to NULL post transmission */
276       dlSf->bcch.tb = NULLP;
277    }
278    /* Fill PCCH data */
279    if (dlSf->pcch.tb != NULLP)
280    {
281       if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
282                                 &(datInfo->memCp))) != ROK)
283       {
284          err->errCause = RGERR_TOM_MEM_EXHAUST;
285          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",datReq->rnti);
286          RETVALUE(ret);
287       }
288 #ifdef TFU_ALLOC_EVENT_NO_INIT
289 #ifndef L2_OPTMZ      
290       datReq->mBuf[1] = 0;
291 #endif     
292 #endif     
293       datReq->rnti                   =  RG_P_RNTI;
294       datReq->dciInfo                = dlSf->pcch.pdcch.dci;
295       datReq->nmbOfTBs               =  1;
296 #ifndef L2_OPTMZ
297       datReq->mBuf[0]                =  dlSf->pcch.tb;
298 #else
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;
305 #endif
306       datReq->tbInfo[0].numLch             = 1;
307       datReq->tbInfo[0].lchInfo[0].numPdu  = 1;
308 #endif
309       cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
310       datReq->lnk.node = (PTR)datReq;
311 #ifdef TFU_UPGRADE      
312       /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
313       datReq->txPwrOffset            = dlSf->pcch.txPwrOffset;
314 #endif      
315       dlSf->pcch.tb = NULLP;
316    }
317
318    for(idx=0; idx < dlSf->numRaRsp; idx++)
319    {
320       if ((ret = rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
321                                 &(datInfo->memCp))) != ROK)
322       {
323          err->errCause = RGERR_TOM_MEM_EXHAUST;
324          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",
325                          datReq->rnti);
326          RETVALUE(ret);
327       }
328 #ifdef TFU_ALLOC_EVENT_NO_INIT
329 #ifndef L2_OPTMZ      
330       datReq->mBuf[1] = 0;
331 #endif    
332 #endif    
333       datReq->rnti                   =  dlSf->raRsp[idx].pdcch.rnti;
334       datReq->dciInfo                = dlSf->raRsp[idx].pdcch.dci;
335       datReq->nmbOfTBs               =  1;
336 #ifndef L2_OPTMZ
337       datReq->mBuf[0]                =  dlSf->raRsp[idx].rar;
338 #else
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;
345 #endif
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);
349 #endif
350       cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
351       datReq->lnk.node = (PTR)datReq;
352 #ifdef TFU_UPGRADE      
353       /* ccpu00132314-ADD- Adding txPower offset for the PDSCH transmission */
354       datReq->txPwrOffset            = dlSf->raRsp[idx].txPwrOffset;
355 #endif
356       dlSf->raRsp[idx].rar = NULLP;
357    }
358
359    /* Fill Dedicated UE data */
360    if (dlSf->tbs.count != 0) 
361    {
362       CmLList          *node;
363       while (dlSf->tbs.first)
364       {
365          node = dlSf->tbs.first;
366          hqCb = (RgDlHqProcCb*)node->node;
367          if ((ret = rgDHMSndDatReq (cellCb, dlSf, datInfo, hqCb, err)) != ROK)
368          {
369             RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
370                             "DHM unable to fill DATA request");
371             err->errType = RGERR_TOM_TTIIND;
372             continue;
373          }
374       } /* end of while */
375    } 
376
377    RETVALUE(ROK);
378 } /* end of rgTOMUtlFillDatReqPdus*/ 
379
380 /** @brief This function does all the processing related to a single downlink
381  * subframe.
382  *
383  * @details 
384  *
385  *     Function: rgTOMUtlProcDlSf
386  *
387  *         Processing steps:
388  *         - collate control data for all UEs and send to PHY 
389  *         - collate data buffers for all UEs and send to PHY 
390  *
391  * @param  [in] RgDlSf     *dlSf
392  * @param  [in] RgCellCb   *cellCb
393  * @param  [out] RgErrInfo *err
394  * @return S16
395  */
396 /* ADD Changes for Downlink UE Timing Optimization */
397 #ifndef LTEMAC_DLUE_TMGOPTMZ 
398 #ifdef ANSI
399 PRIVATE S16 rgTOMUtlProcDlSf
400 (
401  RgDlSf     *dlSf,
402  RgCellCb   *cellCb,
403  RgErrInfo  *err
404  )
405 #else
406 PRIVATE S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
407  RgDlSf     *dlSf;
408  RgCellCb   *cellCb;
409  RgErrInfo  *err;
410 #endif
411 #else
412 #ifdef ANSI
413 PUBLIC S16 rgTOMUtlProcDlSf
414 (
415  RgDlSf     *dlSf,
416  RgCellCb   *cellCb,
417  RgErrInfo  *err
418  )
419 #else
420 PUBLIC S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
421  RgDlSf     *dlSf;
422  RgCellCb   *cellCb;
423  RgErrInfo  *err;
424 #endif
425 #endif
426 {
427    S16               ret;
428    TfuDatReqInfo     *datInfo;
429    Inst              inst = cellCb->macInst - RG_INST_START;
430
431    TRC2(rgTOMUtlProcDlSf);
432
433    /* Fill Data Request Info from scheduler to PHY */   
434    if ((ret = rgAllocEventMem(inst,(Ptr *)&datInfo, 
435                             sizeof(TfuDatReqInfo))) != ROK)
436    {
437       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to Allocate TfuDatReqInfo");
438       RETVALUE(ret);
439    }
440    else
441    {
442       cmLListInit(&datInfo->pdus);
443 #ifdef LTE_TDD
444       RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DELTA);
445 #else
446       RGADDTOCRNTTIME(dlSf->schdTime, datInfo->timingInfo, TFU_DLDATA_DLDELTA);
447 #endif
448       datInfo->cellId = cellCb->cellId;
449       if((0 == (datInfo->timingInfo.sfn % 30)) && (0 == datInfo->timingInfo.slot))
450       {
451          //printf("5GTF_CHECK rgTOMUtlProcDlSf dat (%d : %d)\n", datInfo->timingInfo.sfn, datInfo->timingInfo.slot);
452       }
453 #ifdef TFU_ALLOC_EVENT_NO_INIT
454       datInfo->bchDat.pres = 0;
455 #endif
456
457       /* Fill BCH data */
458       if (dlSf->bch.tb != NULLP)
459       {
460          datInfo->bchDat.pres = PRSNT_NODEF;
461          datInfo->bchDat.val  = dlSf->bch.tb;
462          dlSf->bch.tb = NULLP;
463       }
464 #ifdef EMTC_ENABLE
465       /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
466       if ((ret = rgTOMEmtcUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
467       {
468          RG_FREE_MEM(datInfo);
469          RETVALUE(ret);
470       }
471 #endif 
472       /* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
473       if ((ret = rgTOMUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
474       {
475          RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data for cell");
476          RG_FREE_MEM(datInfo);
477          RETVALUE(ret);
478       }
479       if((datInfo->pdus.count) || (datInfo->bchDat.pres == TRUE))
480       {
481          /* sending the data to Phy */
482          if (rgLIMTfuDatReq(inst,datInfo) != ROK)
483          {
484             RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data info for cell");               
485          }
486       }
487       else
488       {
489          /* Nothing to send: free the allocated datInfo */
490          RG_FREE_MEM(datInfo);
491       }
492    }
493    RETVALUE(ROK);
494 } /* end of */
495
496 U32  rgMacGT;
497
498 /**
499  * @brief Handler for processing TTI indication recieved from 
500  * PHY for a cell.
501  *
502  * @details
503  *
504  *     Function: macProcessSlotInd
505  *
506  *     Handler for processing slot indication recieved from PHY
507  *     for a cell.
508  *
509  *     Invoked by: macProcessSlotInd
510  *
511  *     Processing Steps:
512  *     - Get cell and update the cell's current time with the timing value given
513  *     by PHY
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
522  *     rgSCHSubFrmGet.
523  *     - Invoke rgTOMUtlProcTA to perform and timing advance processing. 
524  *     - Invoke rgTOMUtlProcDlSf to do further processing on the downlink
525  *     subframe.
526  *     - Get the downlink subframe that would occur after RG_DL_DELTA and 
527  *     invoke rgTOMUtlProcDlSfStaInd to send status indications to the higher
528  *     layer.
529  *     - Invoke GOM's TTI handler rgGOMTtiHndlr
530  *     - Invoke COM's TTI handler rgCOMTtiHndlr
531  *           
532  *  @param[in]  Inst        inst
533  *  @param[in] SlotIndInfo slotInd
534  *  @return  S16
535  *      -# ROK 
536  *      -# RFAILED 
537  **/
538 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
539 pthread_t gMacTId = 0;
540 #endif
541 PUBLIC S16 macProcessSlotInd
542 (
543 Inst          inst,
544 SlotIndInfo slotInd
545 )
546 {
547    RgCellCb             *cellCb;
548    RgErrInfo            err;
549    RgDlSf               *dlSf;
550 /* ADD Changes for Downlink UE Timing Optimization */
551 #ifdef LTEMAC_DLUE_TMGOPTMZ
552    RgDlSf               *prevDlSf;
553    CmLteTimingInfo       prevTmInfo;  
554 #endif
555    //SlotIndInfo *slotInd = &ttiInfo->cells[0];
556
557    TRC2(macProcessSlotInd);
558
559 #ifdef MAC_FREE_RING_BUF
560    gMacTId = pthread_self();
561 #endif
562
563    cellCb = rgCb[inst].cell;
564    if (cellCb == NULLP)
565    {
566       err.errType = RGERR_TOM_TTIIND;
567       err.errCause = RGERR_TOM_INV_CELL_ID;
568       RETVALUE(RFAILED);
569    }
570
571    RGCPYTIMEINFO(slotInd, cellCb->crntTime);
572
573    rgMacGT = (slotInd.sfn * RG_NUM_SUB_FRAMES_5G) + slotInd.slot;
574 #ifdef LTE_L2_MEAS
575    rgL2Meas(cellCb);
576    /*Included to track the number of 10240 cycles completed */
577
578   if((cellCb->crntTime.sfn == 0) && (cellCb->crntTime.slot==0))
579   {
580      cellCb->ttiCycle += 1;
581   }
582
583 #endif
584
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)
593    {
594       if (ROK != rgTOMUtlProcDlSf (prevDlSf, cellCb, &err))
595       {
596          RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to process "
597                 "previous downlink subframe for cell");
598          err.errType = RGERR_TOM_TTIIND;
599       }
600
601       /* Mark this frame as sent */
602       prevDlSf->txDone = TRUE;
603
604       if(prevDlSf->remDatReqCnt)
605       {
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;
612       }
613    }
614 #endif
615
616    CmLteTimingInfo   timingInfo;
617    RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DELTA);
618
619    /* Trigger for DL TTI REQ */
620    handleDlTtiReq(&timingInfo);
621
622    /* Trigger for UL TTI REQ */
623    handleUlTtiReq(&timingInfo);
624
625    dlSf = &cellCb->subFrms[(slotInd.slot % RG_NUM_SUB_FRAMES)];
626
627    if((dlSf->txDone == TRUE) ||
628       (!RG_TIMEINFO_SAME(slotInd,dlSf->schdTime)))
629    {
630    /* MS_WORKAROUND */
631 #ifndef LTEMAC_DLUE_TMGOPTMZ
632       TfuDatReqInfo     *datInfo;
633      CmLteTimingInfo   timingInfo;
634 #ifdef TFU_DL_DELTA_CHANGE
635          RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DLDATA_DLDELTA);
636 #else
637          RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DELTA);
638 #endif
639      /* Fill Data Request from MAC for BCH  */
640      if ((timingInfo.sfn % 4 == 0) && (timingInfo.slot == 0))
641      {
642          if (ROK != rgAllocEventMem(inst,(Ptr *)&datInfo, 
643                             sizeof(TfuDatReqInfo)))
644          {
645             RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
646                 "rgTOMUtlProcDlSf() Unable to Allocate TfuDatReqInfo for cell");
647             RETVALUE(RFAILED);
648          }
649          else
650          {
651             cmLListInit(&datInfo->pdus);
652             datInfo->cellId = cellCb->cellId;
653             datInfo->bchDat.pres = NOTPRSNT;
654             datInfo->timingInfo = timingInfo;
655             
656                                    
657           /* sending the dummy data req to Phy */
658             if (rgLIMTfuDatReq(inst,datInfo) != ROK)
659             {
660                RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
661                          "rgTOMUtlProcDlSf() Unable to send data info for cell");
662             }
663          
664          }
665      }      
666 #endif
667       /* Freeing as the part of CL Non RT Indication */
668       /* TDOD : Generalize for all SOCs */
669 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
670       rgDHMFreeTbBufs(inst);
671 #endif
672       RETVALUE(ROK);
673    }
674
675    /*Return if there is still some data to be received
676      from RLC for this DL SF. */
677 /* ADD Changes for Downlink UE Timing Optimization */
678 #ifdef LTEMAC_DLUE_TMGOPTMZ
679    if(0 != dlSf->remDatReqCnt) 
680    {
681       /* Freeing as the part of CL Non RT Indication */
682       /* TODO : Generalize for all SOCs and remove this flag */
683 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
684       rgDHMFreeTbBufs(inst);
685 #endif
686       RETVALUE(ROK);
687    }
688 #endif
689
690 #ifdef XEON_SPECIFIC_CHANGES
691    CM_MEAS_TIME((slotInd.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_DL_BR_PRC);
692 #endif
693
694    if (ROK != rgTOMUtlProcDlSf (dlSf, cellCb, &err))
695    {
696       //RLOG_ARG0(L_ERROR,DBG_CELLID,slotInd->cellId,
697       //              "Unable to process downlink subframe for cell");
698       err.errType = RGERR_TOM_TTIIND;
699    }
700 #ifdef XEON_SPECIFIC_CHANGES
701    CM_MEAS_TIME((slotInd->slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_DL_AFTER_PRC);
702 #endif
703
704    /* Mark this frame as sent */
705    dlSf->txDone = TRUE;
706
707    /* Freeing as the part of CL Non RT Indication */
708    /* TODO : Generalize for all SOCs and remove this flag */
709 #if !(defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD))
710    rgDHMFreeTbBufs(inst);
711 #endif 
712    RETVALUE(ROK);
713 }  /* macProcessSlotInd */
714
715 /** @brief This function allocates the RgMacPdu that will be populated by DEMUX
716  * with the SubHeaders list and the values of the Control elements.
717  *
718  * @details
719  *
720  *     Function: rgTOMUtlAllocPduEvnt
721  *
722  *         Processing steps:
723  *  @param[in]  Inst        inst
724  * @param  [out] RgMacPdu   **pdu
725  *
726  *  @return  S16
727  *      -# ROK 
728  *      -# RFAILED 
729  */
730 #ifdef ANSI
731 PRIVATE S16 rgTOMUtlAllocPduEvnt 
732 (
733 Inst             inst,
734  RgMacPdu         **pdu
735  )
736 #else
737 PRIVATE S16 rgTOMUtlAllocPduEvnt (inst,pdu)
738 Inst             inst;
739    RgMacPdu         **pdu;
740 #endif
741 {
742
743    Mem               evntMem;
744    RgUstaDgn         dgn;      /* Alarm diagnostics structure */
745    VOLATILE U32      startTime=0;
746
747    TRC2(rgTOMUtlAllocPduEvnt);
748
749    evntMem.region = rgCb[inst].rgInit.region;
750    evntMem.pool   = rgCb[inst].rgInit.pool;
751
752    /*starting Task*/
753    SStartTask(&startTime, PID_TOMUTL_CMALLCEVT);
754
755 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
756    MS_BUF_ADD_ALLOC_CALLER();
757 #endif /* */
758
759    if (cmAllocEvnt (sizeof (RgMacPdu), RG_BLKSZ, &evntMem, (Ptr*)pdu) != ROK)
760    {
761       rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
762       rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
763                                        LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
764       RLOG0(L_ERROR,"Allocation of DUX event failed");
765       RETVALUE(RFAILED);
766    }
767
768    /*stoping Task*/
769    SStopTask(startTime, PID_TOMUTL_CMALLCEVT);
770
771    RETVALUE(ROK);
772 } /* end of */ 
773
774 /** @brief This function frees up the RgMacPdu structure that has been
775  * populated by demux.
776  *
777  * @details
778  *
779  *     Function: rgTOMUtlFreePduEvnt
780  *       - Function frees up the RgMacPdu structure, in case of error it shall
781  *       free up the buffer's present in the different sdu.
782  *
783  *         Processing steps:
784  * @param  [in]  Inst        inst
785  * @param  [in] RgMacPdu   *pdu
786  * @param  [in] Bool       *error
787  * @return 
788  */
789 #ifdef ANSI
790 PRIVATE Void rgTOMUtlFreePduEvnt
791 (
792  RgMacPdu *pdu,
793  Bool      error
794  )
795 #else
796 PRIVATE Void rgTOMUtlFreePduEvnt (pdu, error)
797    RgMacPdu *pdu;
798    Bool      error;
799 #endif
800 {
801
802    RgMacSdu       *sdu;
803    CmLList        *node;
804
805    TRC2(rgTOMUtlFreePduEvnt);
806    /* Steps of freeing up the PDU.
807     * 1. loop through the subHdrLst and free up all the buffers.
808     * 2. free up the whole event
809     */
810    if ((error == TRUE) && (pdu->sduLst.count > 0))
811    {
812       node =  pdu->sduLst.first;
813       while (node)
814       {
815          sdu = (RgMacSdu*)node->node;
816          RG_FREE_MSG(sdu->mBuf);
817          node = node->next;
818       }
819    }
820    RG_FREE_MEM(pdu);
821    RETVOID;
822 } /* end of rgTOMUtlFreePduEvnt */ 
823
824 /** @brief This function allocates the RgMacPdu that will be populated by DEMUX
825  * with the SubHeaders list and the values of the Control elements.
826  *
827  * @details
828  *
829  *     Function: rgTOMInfAllocPduEvnt
830  *
831  *         Processing steps:
832  * @param  [in] Inst        inst
833  * @param  [out] RgMacPdu   **pdu
834  *
835  *  @return  S16
836  *      -# ROK 
837  *      -# RFAILED 
838  */
839 #ifdef ANSI
840 PRIVATE S16 rgTOMInfAllocPduEvnt 
841 (
842 Inst           inst,
843 RgInfSfDatInd **sfInfo
844  )
845 #else
846 PRIVATE S16 rgTOMInfAllocPduEvnt (inst,sfInfo)
847 Inst             inst;
848 RgInfSfDatInd **sfInfo;
849 #endif
850 {
851
852    Mem               evntMem;
853    RgUstaDgn         dgn;      /* Alarm diagnostics structure */
854    VOLATILE U32      startTime=0;
855
856    TRC2(rgTOMInfAllocPduEvnt);
857
858    evntMem.region = rgCb[inst].rgInit.region;
859    evntMem.pool   = rgCb[inst].rgInit.pool;
860
861    /*starting Task*/
862    SStartTask(&startTime, PID_TOMINF_CMALLCEVT);
863
864 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
865    MS_BUF_ADD_ALLOC_CALLER();
866 #endif /* */
867    if (cmAllocEvnt (sizeof (RgInfSfDatInd), RG_BLKSZ, &evntMem, (Ptr*)sfInfo) != ROK)
868    {
869       rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
870       rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
871                                        LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
872       RLOG0(L_ERROR,"Allocation failed");
873       RETVALUE(RFAILED);
874    }
875
876    /*stoping Task*/
877    SStopTask(startTime, PID_TOMINF_CMALLCEVT);
878
879    RETVALUE(ROK);
880 } /* end of */ 
881
882 /** @brief This function frees up the RgMacPdu structure that has been
883  * populated by demux.
884  *
885  * @details
886  *
887  *     Function: rgTOMInfFreePduEvnt
888  *       - Function frees up the RgMacPdu structure, in case of error it shall
889  *       free up the buffer's present in the different sdu.
890  *
891  *         Processing steps:
892  * @param  [in] RgMacPdu   *pdu
893  * @param  [in] Bool       *error
894  * @return 
895  */
896 #ifdef ANSI
897 PRIVATE Void rgTOMInfFreePduEvnt
898 (
899 RgInfSfDatInd *sfInfo
900  )
901 #else
902 PRIVATE Void rgTOMInfFreePduEvnt (sfInfo)
903 RgInfSfDatInd *sfInfo;
904 #endif
905 {
906    TRC2(rgTOMInfFreePduEvnt);
907
908    RG_FREE_MEM(sfInfo);
909    RETVOID;
910 } /* end of rgTOMUtlFreePduEvnt */
911
912 #ifdef LTE_L2_MEAS
913
914 /** @brief This function performs the preparation of information needed to set
915  * L2M Scheduled UL Throughput Information for a particular UE.
916  *
917  * @details
918  *
919  *     Function: rgTomUtlPrepareL2MUlThrpInfo
920  *      This function performs the preparation of information needed to set
921  *       L2M Scheduled UL Throughput Information for a particular UE.
922  *
923  *
924  *         Processing steps:
925  * @param  [in] RgCellCb   *cellCb
926  * @param  [in] RgUeCb       *ueCb
927  * @param  [out] RgRguDedDatInd *dDatInd
928  * @return 
929  */
930 #ifdef ANSI
931 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo
932 (
933    RgCellCb *cellCb,
934    RgUeCb  *ueCb,
935    RgRguDedDatInd  *dDatInd
936  )
937 #else
938 PRIVATE S16 rgTomUtlPrepareL2MUlThrpInfo(cellCb,ueCb,dDatInd)
939    RgCellCb *cellCb;
940    RgUeCb *ueCb;
941    RgRguDedDatInd    *dDatInd;
942 #endif
943 {
944    U8 lcId;
945    U8 lcgId;
946    U8 loop;
947    TRC2(rgTomUtlPrepareL2MUlThrpInfo);
948
949    dDatInd->burstInd = RGU_L2M_UL_BURST_END;
950    for(loop=0;loop<dDatInd->numLch;loop++)
951    {
952       lcId=dDatInd->lchData[loop].lcId;
953       if (lcId)
954       {
955          lcgId = ueCb->ul.lcCb[lcId - 1].lcgId;
956          if(ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs > 0)
957          {
958             dDatInd->burstInd = RGU_L2M_UL_BURST_START;
959             break;
960                   }
961                }
962    }
963
964    RETVALUE(ROK);
965 }
966
967 #endif
968
969 /** @brief This function is called by rgTOMDatInd. This function invokes the
970  * scheduler with the information of the received Data and any Control Elements
971  * if present. Also it generates Data indications towards the higher layers.
972  *
973  * @details
974  *
975  *     Function: 
976  *
977  *         Processing steps:
978  *         - Retrieves the RaCb with the rnti provided, if it doesnt exist
979  *         return failure. 
980  *         - If UE exists then update the Schduler with any MAC CEs if present. 
981  *         - Invoke RAM module to do Msg3 related processing rgRAMProcMsg3
982  *         - Loop through the SDU subheaders and invoke either a common data
983  *         indication (rgUIMSndCmnDatInd) or dedicated data indication
984  *         (rgUIMSndDedDatInd) towards the higher layers. 
985  *
986  * @param  [in] RgCellCb   *cellCb
987  * @param  [in] RgUeCb     *ueCb
988  * @param  [in] CmLteRnti  rnti
989  * @param  [in] RgMacPdu   *pdu
990  * @param  [out] U32       *lcgBytes
991  *  
992  *  @return  S16
993  *      -# ROK 
994  *      -# RFAILED 
995  */
996  RgUeCb  *glblueCb4;
997  RgUeCb  *glblueCb5;
998
999 #ifdef LTEMAC_SPS
1000 #ifdef ANSI
1001 PRIVATE S16 rgTOMUtlProcMsg
1002 (
1003  RgCellCb      *cellCb, 
1004  RgUeCb        *ueCb,
1005  RgMacPdu      *pdu,
1006  Bool          isSpsRnti,
1007  Bool          *spsToBeActvtd,
1008  U16           *sduSize,
1009  U16           slot,
1010  U32           *lcgBytes
1011  )
1012 #else
1013 PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,spsToBeActvtd,sduSize, slot, lcgBytes)
1014    RgCellCb      *cellCb; 
1015    RgUeCb        *ueCb;
1016    RgMacPdu      *pdu;
1017    Bool          isSpsRnti;
1018    Bool          *spsToBeActvtd;
1019    U16           *sduSize;
1020    U16           slot;
1021    U32           *lcgBytes;
1022 #endif   
1023 #else /* LTEMAC_SPS */
1024 #ifdef ANSI
1025 PRIVATE S16 rgTOMUtlProcMsg
1026 (
1027  RgCellCb      *cellCb, 
1028  RgUeCb        *ueCb,
1029  RgMacPdu      *pdu,
1030  U16           slot,
1031  U32           *lcgBytes
1032  )
1033 #else
1034 PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, slot, lcgBytes)
1035    RgCellCb      *cellCb; 
1036    RgUeCb        *ueCb;
1037    RgMacPdu      *pdu;
1038    U16           slot;
1039    U32           *lcgByes;
1040 #endif  
1041 #endif
1042 {
1043    Inst              inst = cellCb->macInst - RG_INST_START;
1044    S16               ret;
1045    RgRguCmnDatInd    *cDatInd;
1046    RgRguDedDatInd    *dDatInd;
1047    CmLList           *node;
1048    RgMacSdu          *sdu;
1049    MsgLen            ccchSz;
1050    MsgLen            cpySz;
1051 #ifdef LTEMAC_SPS
1052    Pst               schPst1;  
1053 //   RgInfSpsRelInfo   relInfo;
1054 #endif
1055
1056 #ifdef LTE_L2_MEAS
1057    U8                idx1;
1058    U8                idx2;
1059    RgUlSf            *ulSf;
1060    U16               totalBytesRcvd = 0;
1061    U16               sduLen[RGU_MAX_LC] = {0};
1062    U8                qciVal[RGU_MAX_LC] = {0};
1063    U8                numPrb = 0;
1064
1065 #endif
1066    U8                lcgId;
1067    MsgLen            bufSz;
1068
1069   /* Moved outside of LTE_L2_MEAS
1070     *          scope as this pointer will now be used to 
1071     *          check for valid Logical Channel ID
1072    */
1073    RgUlLcCb          *ulLcCb;
1074    
1075    cDatInd  = NULLP;
1076    dDatInd  = NULLP;
1077 #ifdef LTE_L2_MEAS
1078    ulSf   = NULLP;
1079    idx1   = 0;
1080    idx2   = 0;
1081 #endif
1082 #ifdef SS_RBUF 
1083    Void *elem = NULLP;
1084 #endif
1085   
1086    ulLcCb = NULLP;
1087    
1088    TRC2(rgTOMUtlProcMsg)
1089
1090 #ifndef LTE_L2_MEAS      
1091       UNUSED(slot);
1092 #endif
1093
1094    if(pdu->sduLst.first)
1095    {
1096       sdu = (RgMacSdu*)(pdu->sduLst.first->node);
1097                         glblueCb4 = ueCb;
1098       if ((sdu->lcId == RG_CCCH_LCID))
1099       {
1100          /* code for common channel dat indications */
1101          if ((ret = rgAllocShrablSBuf (inst,(Data**)&cDatInd, sizeof(RgRguCmnDatInd))) != ROK)
1102          {
1103             RETVALUE(RFAILED);
1104          }
1105          cDatInd->cellId   = cellCb->cellId;
1106          cDatInd->rnti     = ueCb->ueId;
1107          /* rg001.101: Corrected lcId value for common data indication */
1108          cDatInd->lcId     = cellCb->ulCcchId;
1109          cDatInd->pdu      = sdu->mBuf;
1110          SFndLenMsg (sdu->mBuf, &ccchSz);
1111          /* Fix : syed Contention resolution ID copy should consider only
1112           * 6 bytes of information from sdu->mBuf. Incase of CCCH sdu for reest
1113           * message/psuedo reest message, ccchSz can go beyond 6 and can corrupt 
1114           * other fields of ueCb. */
1115          if (ccchSz >= RG_CRES_LEN)
1116          {
1117             SCpyMsgFix (sdu->mBuf, (MsgLen)0, RG_CRES_LEN, ueCb->contResId.resId,
1118                         &cpySz);
1119          }
1120 #ifdef XEON_SPECIFIC_CHANGES
1121          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);
1122 #endif
1123          sdu->mBuf = NULLP;
1124          rgUIMSndCmnDatInd(inst,cellCb->rguUlSap,cDatInd);
1125          RETVALUE(ROK);
1126       } /* end of common channel processing */
1127 #ifndef SS_RBUF 
1128       if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
1129       {
1130          RETVALUE(RFAILED);
1131       }
1132 #else
1133                         glblueCb5 = ueCb;
1134       elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
1135       if (NULLP == elem)
1136       { 
1137          RETVALUE(RFAILED);
1138       }
1139       dDatInd = (RgRguDedDatInd *)elem;
1140       cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
1141 #endif
1142       dDatInd->cellId   = cellCb->cellId;
1143       dDatInd->rnti     = ueCb->ueId;
1144       dDatInd->numLch   = 0;
1145    }
1146 #ifdef LTE_L2_MEAS
1147    ulSf = &cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)];
1148    if(ulSf->ueUlAllocInfo != NULLP)
1149    {
1150      for(idx1 = 0; idx1 < ulSf->numUe; idx1++)
1151      {
1152         if(ulSf->ueUlAllocInfo[idx1].rnti == ueCb->ueId)
1153         {
1154            numPrb = ulSf->ueUlAllocInfo[idx1].numPrb;
1155            break;
1156         }
1157      }
1158    }
1159 #endif
1160    node =  pdu->sduLst.first;
1161    while (node)
1162    {
1163       sdu = (RgMacSdu*)node->node;
1164       
1165       ulLcCb = rgDBMGetUlDedLcCb (ueCb, sdu->lcId);
1166       
1167       if(ulLcCb == NULLP)
1168       {
1169          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,"Unconfigured LCID:%d CRNTI:%d"
1170                          ,sdu->lcId,ueCb->ueId);
1171          /* ccpu00128443: Fix for memory leak */
1172          /* Fix : syed Neccessary to set sdu->mBuf = NULLP */
1173          RG_FREE_MSG(sdu->mBuf);         
1174          node = node->next;
1175          continue;
1176       }
1177 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
1178       {
1179          extern S16 kwProcDlStatusPdu(Pst       *udxPst,SuId      suId,
1180                CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
1181
1182          if(ROK == kwProcDlStatusPdu(&(cellCb->rguDlSap->sapCfg.sapPst),
1183                   cellCb->rguDlSap->sapCfg.suId,
1184                   cellCb->cellId,ueCb->ueId,sdu->lcId,sdu->mBuf))
1185          {
1186             RG_FREE_MSG(sdu->mBuf);           
1187             node = node->next;
1188             continue;
1189          }
1190       }
1191 #endif
1192
1193       /* ccpu00116477- Fixed the rgUIMSndDedDatInd condition when we receive 11 sdus in the 
1194        * list we are losing 11th sdu and sending the first 10 sdus again which
1195        * is causing the duplicate packets and eNB crashing due to access
1196        * of the freed memory */
1197       if (dDatInd->numLch >= RGU_MAX_LC)
1198       {
1199          if ((ret = rgUIMSndDedDatInd(inst,ueCb->rguUlSap,dDatInd)) != ROK)
1200          {
1201             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
1202                 "Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
1203             RETVALUE(ret);
1204          }
1205 #ifndef SS_RBUF
1206          if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
1207          {
1208             RETVALUE(RFAILED);
1209          }
1210 #else
1211       elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
1212       if (NULLP == elem)
1213       { 
1214          RETVALUE(RFAILED);
1215       }
1216       dDatInd = (RgRguDedDatInd *)elem;
1217       cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
1218 #endif
1219          dDatInd->cellId   = cellCb->cellId;
1220          dDatInd->rnti     = ueCb->ueId;
1221          dDatInd->numLch   = 0;
1222       }
1223       dDatInd->lchData[dDatInd->numLch].lcId = sdu->lcId;
1224       dDatInd->lchData[dDatInd->numLch].pdu.mBuf[dDatInd->lchData[dDatInd->numLch].pdu.numPdu] = sdu->mBuf;
1225       dDatInd->lchData[dDatInd->numLch].pdu.numPdu++;
1226       lcgId = ulLcCb->lcgId;
1227       SFndLenMsg(sdu->mBuf, &bufSz);
1228 #ifdef LTE_L2_MEAS
1229       if(ulLcCb->measOn)
1230       {
1231          ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs -= bufSz; 
1232       }
1233 #endif
1234       //if ((lcgBytes != NULLP) && (ueCb->ul.lcgArr[lcgId].isGbr == TRUE))
1235       if (lcgBytes != NULLP)
1236       {
1237          lcgBytes[lcgId] += bufSz;
1238       }
1239       sdu->mBuf = NULLP;
1240       dDatInd->numLch++;
1241 #ifdef LTEMAC_SPS
1242       /* Check if data has come on SPS LC */
1243       /* KWORK_FIX: Modified the index from lcId to lcId-1 for handling lcId 10 properly */
1244       if (ueCb->ul.spsLcId[sdu->lcId-1] == TRUE)
1245       {
1246          ueCb->ul.spsDatRcvd++;
1247       }
1248             
1249       if(isSpsRnti)
1250       {
1251          /* Data rcvd on CRNTI*/
1252          /* Retrieve the LCG ID of the LCID*/
1253          /* SPS LCG has data whose size > SID Size */
1254          /* Activate SPS if data recvd on SPS LCID and size > SID Packet Size */
1255          if((ueCb->ul.spsLcId[sdu->lcId-1] == TRUE) &&
1256             (sdu->len > RG_SPS_SID_PACKET_SIZE))
1257          {
1258              *spsToBeActvtd = TRUE;
1259              *sduSize = sdu->len;
1260          }
1261       }
1262       
1263 #endif  
1264
1265 #ifdef LTE_L2_MEAS
1266       if(cellCb->qciArray[ulLcCb->qci].mask == TRUE)
1267       {
1268            sduLen[ulLcCb->qci] = sdu->len;
1269            totalBytesRcvd += sdu->len;
1270            qciVal[ulLcCb->qci] = ulLcCb->qci;
1271       }
1272 #endif
1273       node = node->next;
1274    } /* end of while for SubHeaders */
1275 #ifdef LTE_L2_MEAS
1276    for(idx2 = 0; idx2 < RGU_MAX_LC; idx2++)
1277    {
1278       if((cellCb->qciArray[qciVal[idx2]].mask == TRUE) &&
1279           totalBytesRcvd > 0)
1280       {
1281          cellCb->qciArray[qciVal[idx2]].prbCount += 
1282          ((numPrb * sduLen[idx2]) / totalBytesRcvd);
1283       }
1284       
1285       /* RRM_RBC_X */
1286       if(totalBytesRcvd > 0 && qciVal[idx2] > 0)
1287       {
1288          RG_UPD_GBR_PRB(cellCb, qciVal[idx2], ((numPrb * sduLen[idx2])/totalBytesRcvd));
1289       }
1290       /* RRM_RBC_Y */
1291    }
1292 #endif
1293 /*Added for explicit release - start*/
1294 #ifdef LTEMAC_SPS
1295
1296    if(isSpsRnti && dDatInd && dDatInd->numLch)
1297    {
1298       if(ueCb->ul.spsDatRcvd != 0)
1299       {
1300          ueCb->ul.explRelCntr = 0;
1301          ueCb->ul.spsDatRcvd = 0;
1302       }
1303       else
1304       {
1305          ueCb->ul.explRelCntr++;
1306          if (ueCb->ul.explRelCntr == ueCb->ul.explRelCnt)
1307          {
1308             ueCb->ul.explRelCntr = 0;
1309             /* Indicate scheduler for explicit release */
1310             cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
1311             rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
1312            //TODO: commented for compilation without SCH 
1313 #if 0
1314             relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1315             relInfo.cRnti = ueCb->ueId;
1316             relInfo.isExplRel = TRUE;
1317             /* Release indicator is called now through the matrix in the function below */
1318             //TODO: commented for compilation without SCH RgMacSchSpsRel( &schPst1, &relInfo );
1319 #endif
1320             ueCb->ul.implRelCntr = 0;
1321          }
1322       }
1323    } 
1324    else
1325    {
1326       /* SPS_FIX */
1327       if(ueCb->ul.spsDatRcvd != 0)
1328       {
1329          //ueCb->ul.implRelCntr = 0;
1330          ueCb->ul.explRelCntr = 0;
1331          ueCb->ul.spsDatRcvd = 0;
1332       }
1333    }
1334 #endif
1335    /*Added for explicit release - end */
1336
1337    if((dDatInd) && (dDatInd->numLch))
1338    {
1339 #ifdef LTE_L2_MEAS
1340       rgTomUtlPrepareL2MUlThrpInfo(cellCb, ueCb,dDatInd);
1341
1342       RG_CALC_TTI_CNT(cellCb, dDatInd->ttiCnt); 
1343 #endif
1344       if ((ret = rgUIMSndDedDatInd(inst,ueCb->rguUlSap,dDatInd)) != ROK)
1345       {
1346          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
1347                 "Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
1348          RETVALUE(ret);
1349       }
1350    }
1351 #ifndef SS_RBUF
1352    else if((dDatInd) && (0 == dDatInd->numLch))
1353    {
1354       /* Free the memory allocated for dDatInd if we 
1355        * have no valid LCH PDU to send to RLC.*/
1356       rgFreeSharableSBuf(inst,(Data **)&dDatInd,sizeof(RgRguDedDatInd)); 
1357    }
1358 #endif
1359    RETVALUE(ROK);
1360 } /* end of */ 
1361
1362 /** @brief This function frees up the RgMacPdu structure that has been
1363  * populated by demux.
1364  *
1365  * @details
1366  *
1367  *     Function: rgTOMUtlInsSchInfo
1368  *       - Function frees up the RgMacPdu structure, in case of error it shall
1369  *       free up the buffer's present in the different sdu.
1370  *
1371  *         Processing steps:
1372  * @param  [in] RgMacPdu   *pdu
1373  * @param  [in] Bool       *error
1374  * @return 
1375  */
1376 #ifdef LTEMAC_SPS
1377 #ifdef ANSI
1378 PRIVATE S16 rgTOMUtlInsSchInfo
1379 (
1380 RgMacPdu *pdu,
1381 RgInfSfDatInd *sfInfo,
1382 RgInfCeInfo *ceInfo,
1383 CmLteRnti   rnti,
1384 Bool        spsToBeActvtd,
1385 U16         sduSize,
1386 U32         *lcgBytes
1387 )
1388 #else
1389 PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti,spsToBeActvtd,sduSize, lcgBytes)
1390 RgMacPdu *pdu;
1391 RgInfSfDatInd *sfInfo;
1392 RgInfCeInfo *ceInfo;
1393 CmLteRnti   rnti;
1394 Bool        spsToBeActvtd;
1395 U16         sduSize;
1396 U32         *lcgBytes;
1397 #endif
1398
1399 #else
1400 #ifdef ANSI
1401 PRIVATE S16 rgTOMUtlInsSchInfo
1402 (
1403 RgMacPdu *pdu,
1404 RgInfSfDatInd *sfInfo,
1405 RgInfCeInfo *ceInfo,
1406 CmLteRnti   rnti,
1407 U32         *lcgBytes
1408 )
1409 #else
1410 PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti, lcgBytes)
1411 RgMacPdu *pdu;
1412 RgInfSfDatInd *sfInfo;
1413 RgInfCeInfo *ceInfo;
1414 CmLteRnti   rnti;
1415 U32         *lcgBytes;
1416 #endif
1417 #endif
1418 {
1419    S16            ret;
1420    RgInfUeDatInd *ueInfo;
1421    U32           lcgId = 0;
1422    U32           idx = 0;
1423
1424    TRC2(rgTOMUtlInsSchInfo);
1425
1426    RG_TOM_INF_ALLOC(sfInfo, sizeof(RgInfUeDatInd), ueInfo, ret);
1427
1428    if(ROK != ret)
1429    {
1430       RETVALUE(RFAILED);
1431    }
1432
1433    ueInfo->rnti = rnti; 
1434       
1435    ueInfo->ceInfo = *ceInfo;
1436    ueInfo->ueLstEnt.node = (PTR)ueInfo;
1437    for (lcgId = 1, idx = 0; lcgId < RGINF_MAX_LCG_PER_UE; lcgId++)
1438    {
1439       if (lcgBytes[lcgId] != 0)
1440       {
1441          /* Only GBR bytes */
1442          ueInfo->lcgInfo[idx].lcgId     = lcgId;
1443          ueInfo->lcgInfo[idx++].bytesRcvd = lcgBytes[lcgId];
1444          lcgBytes[lcgId] = 0;
1445       }
1446    }
1447    cmLListAdd2Tail(&sfInfo->ueLst, &ueInfo->ueLstEnt);
1448    RETVALUE(ROK);
1449 } /* end of rgTOMUtlInsSchInfo */
1450
1451 #include <stdlib.h>
1452 /**
1453  * @brief Handler for processing data indication recieved from PHY for UEs.
1454  *
1455  * @details
1456  *
1457  *     Function: rgTOMDatInd
1458  *
1459  *     Handler for processing data indication recieved from PHY for UEs.
1460  *
1461  *     Invoked by: RgLiTfuDatInd of LIM 
1462  *
1463  *     Processing Steps: 
1464  *     For each DataInfo recieved
1465  *      - Validate the information received and retrieve cellCb 
1466  *        Validate cellId, rnti 
1467  *      - Call De-Mux module to decode the data rgDUXDemuxData
1468  *      - If  received a CRNTI control element 
1469  *          - Check if a CCCH SDU is present, if it is return failure
1470  *          - Check for the existence of UE, if its isnt present return failure.
1471  *          - Delegate the remaining processing to rgTOMUtlProcMsg3 which
1472  *          primarily informs the scheduler about the data received and
1473  *          generates Data indications towards the higher layer.
1474  *      - If only CCCH SDU is present
1475  *        - Invoke rgTOMUtlProcMsg3 for further processing.
1476  *      - If its a non-Msg3 PDU i.e. received outside of a RA procedure
1477  *        - Retrieve the UeCB 
1478  *        - Validate that the received PDU contains only configured Logical
1479  *        Channels.
1480  *        - Invoke rgTOMUtlProcDatPdu for further processing. It informs the
1481  *        scheduler with the information of the received Data and generates
1482  *        DatIndications towards the higher layers. 
1483  *           
1484  * @param  [in] Inst        inst
1485  *  @param[in]  TfuDatIndInfo *datInd
1486  *  @return  S16
1487  *      -# ROK 
1488  *      -# RFAILED 
1489  **/
1490 #ifdef ANSI
1491 PUBLIC S16 rgTOMDatInd
1492 (
1493 Inst           inst,
1494  TfuDatIndInfo *datInd
1495  )
1496 #else
1497 PUBLIC S16 rgTOMDatInd(inst,datInd)
1498 Inst             inst;
1499  TfuDatIndInfo *datInd;
1500 #endif
1501 {
1502    S16               ret = ROK;
1503    RgErrInfo         err;
1504    RgUeCb            *ueCb;
1505    RgUeCb            *prevUeCb = NULLP;
1506    RgCellCb          *cellCb;
1507    RgMacPdu          *pdu;
1508    RgInfSfDatInd     *sfInfo;
1509    RgInfCeInfo       ceInfo; 
1510    Pst               schPst;
1511    CmLList           *node;
1512    TfuDatInfo        *datInfo;
1513    RgLowSapCb        *tfuSap;
1514    U16               slot;
1515 #ifdef LTEMAC_SPS
1516    Bool              isSpsRnti=FALSE;
1517    Pst               schPst1;  
1518   // RgInfSpsRelInfo   relInfo;
1519         Bool              spsToBeActvtd = FALSE;
1520    U16               sduSize = 0;
1521 #endif
1522    U32               lcgBytes[RGINF_MAX_LCG_PER_UE];
1523
1524
1525    TRC2(rgTOMDatInd);
1526 #ifdef STUB_TTI_HANDLING_5GTF 
1527    node =  datInd->datIndLst.first;
1528    for (;node; node=node->next)
1529    {
1530       datInfo = (TfuDatInfo*)node->node;
1531       {
1532          MsgLen len;
1533          SFndLenMsg(datInfo->mBuf, &len);
1534          rgUlrate_tfu += len;
1535          if (rgUlrate_tfu > 100000)
1536          {
1537          printf("Sowmya:rgTOMDatInd datInfo->mBuf len =%d rgUlrate_tfu=%d",len,rgUlrate_tfu);
1538          rgUlrate_tfu = 0;
1539          }
1540       }
1541    }
1542       return(RFAILED);
1543 #endif      
1544
1545    cmMemset((U8 *)&lcgBytes, 0, sizeof(lcgBytes));
1546
1547    tfuSap = &(rgCb[inst].tfuSap);
1548    ueCb = NULLP;
1549    cellCb = rgCb[inst].cell;
1550    if((cellCb == NULLP) ||
1551       (cellCb->cellId != datInd->cellId))   
1552    {
1553        
1554       RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to get the cellCb for cell");
1555       RETVALUE(RFAILED);
1556    }
1557    /* Avoiding memset as all the fields are getting initialized further */
1558
1559    if (rgTOMInfAllocPduEvnt (inst,&sfInfo) != ROK)
1560    {
1561       err.errType = RGERR_TOM_DATIND;
1562       RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
1563       node =  datInd->datIndLst.first;
1564       RETVALUE(RFAILED);
1565    }
1566    cmLListInit(&sfInfo->ueLst);
1567    sfInfo->cellId = datInd->cellId;
1568    sfInfo->timingInfo = datInd->timingInfo;
1569    slot = datInd->timingInfo.slot;
1570
1571    node =  datInd->datIndLst.first;
1572    for (;node; node=node->next)
1573    {
1574       datInfo = (TfuDatInfo*)node->node;
1575       {
1576          //extern U32 ulrate_tfu;
1577          MsgLen len;
1578          SFndLenMsg(datInfo->mBuf, &len);
1579 #ifdef STUB_TTI_HANDLING_5GTF         
1580        //  printf("Sowmya:rgTOMDatInd datInfo->mBuf len =%d",len);
1581 #endif
1582          rgUlrate_tfu += len;
1583 #ifdef EMTC_ENABLE
1584          grgUlrate_tfu += len;
1585 #endif
1586       }
1587 #ifdef STUB_TTI_HANDLING_5GTF         
1588       rgLIMUtlFreeDatIndEvnt(datInd,TRUE);
1589 #endif
1590       /* We shall call De-Mux to process the received buffer. We shall try and find
1591        * out the RaCb based on the following - 
1592        * 1. If the incoming PDU contained a CCCH SDU i.e. this is message 3.
1593        * 2. If the incoming PDU contained a CRNTI control element, i.e. we should
1594        * have a ueCb also for this 
1595        */
1596       /* Lets allocate the event that needs to be passed to DUX */
1597       if (rgTOMUtlAllocPduEvnt (inst,&pdu) != ROK)
1598       {
1599          err.errType = RGERR_TOM_DATIND;
1600          RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
1601          rgTOMInfFreePduEvnt (sfInfo);
1602          RETVALUE(RFAILED);
1603       }
1604
1605       if ((ret = rgDUXDemuxData (inst,pdu, &ceInfo, 
1606                            &datInfo->mBuf, &err)) != ROK)
1607       {
1608          //exit(1);
1609          /* Fix: sriky memory corruption precautions */
1610          rgTOMUtlFreePduEvnt (pdu, TRUE);
1611          err.errType = RGERR_TOM_DATIND;
1612          RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"DUX processing failed");
1613          tfuSap->sapSts.numPduDrop++;
1614          continue; 
1615       }
1616       /* It could be that a non-msg3 pdu contains a CRNTI Control element. We
1617        * should check for CRNTI CE and if it exists the UECb must exist, also an
1618        * if the CRNTI in the CE and the one with which the message came in are
1619        * different we shall look for an raCb as well. 
1620        */
1621
1622       if (ceInfo.bitMask & RG_CCCH_SDU_PRSNT)
1623       {
1624         ret = rgTOMProcCCCHSduInDatInd(pdu, prevUeCb, \
1625                 cellCb, datInfo, &ceInfo, slot);
1626         if (ret == RFAILED)
1627         {
1628             rgTOMUtlFreePduEvnt (pdu, TRUE);
1629             err.errType = RGERR_TOM_DATIND;
1630             tfuSap->sapSts.numPduDrop++;
1631             continue; 
1632         }
1633       } /* end of Msg3 processing */
1634
1635       else if (ceInfo.bitMask & RG_CRNTI_CE_PRSNT)
1636       {
1637         ret = rgTOMProcCrntiCEInDatInd(pdu, prevUeCb, \
1638                 cellCb, datInfo, &ceInfo, slot);
1639         if (ret == RFAILED)
1640         {
1641             rgTOMUtlFreePduEvnt (pdu, TRUE);
1642             err.errType = RGERR_TOM_DATIND;
1643             tfuSap->sapSts.numPduDrop++;
1644             continue; 
1645         }
1646
1647       } /* end of CRNTI based message */
1648       else
1649       {
1650          ueCb = rgDBMGetUeCb (cellCb, datInfo->rnti);
1651          if (ueCb == NULLP)
1652          {
1653 #ifdef LTEMAC_SPS
1654             /* Try getting the UE using SPS-RNTI. */
1655             ueCb = rgDBMGetSpsUeCb (cellCb, datInfo->rnti);
1656             if (ueCb != NULLP)
1657             {
1658                isSpsRnti = TRUE;
1659                /* Increment implrelCntr for an empty transmission */
1660                if (pdu->sduLst.count == 0)
1661                {
1662                   ueCb->ul.implRelCntr++;
1663                   if (ueCb->ul.implRelCntr == ueCb->ul.implRelCnt)
1664                   {
1665                      /* Indicate scheduler for implicit release */
1666                      cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
1667                      rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
1668
1669                      ueCb->ul.implRelCntr = 0;
1670                      ueCb->ul.explRelCntr = 0;
1671 #if 0                     
1672                                                         relInfo.cellSapId = cellCb->schInstMap.cellSapId;
1673                      relInfo.cRnti = ueCb->ueId;
1674                                                         relInfo.isExplRel= FALSE;
1675                      //TODO: commented for compilation without SCH RgMacSchSpsRel(&schPst1, &relInfo);
1676 #endif  
1677                   }
1678                }
1679                else
1680                {
1681                   /* Reset the implrelCntr */
1682                   ueCb->ul.implRelCntr = 0;
1683                }
1684             }
1685             else
1686 #endif 
1687             {
1688                /* Perform failure if ueCb is still NULLP */
1689                rgTOMUtlFreePduEvnt (pdu, TRUE);
1690                err.errType = RGERR_TOM_DATIND;
1691                RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,"RNTI:%d Unable to get the UE CB", 
1692                   datInfo->rnti);
1693                tfuSap->sapSts.numPduDrop++;
1694                continue;
1695             }
1696          }
1697 #ifdef LTE_L2_MEAS         
1698      rgTOMUtlL2MStoreBufSz(ueCb, &ceInfo);
1699      rgTOML2MCompileActiveLCs (cellCb, ueCb, pdu, &ceInfo);
1700 #endif
1701 #ifdef LTEMAC_SPS
1702          if ((ret = rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,&spsToBeActvtd,&sduSize, slot, (U32 *)&lcgBytes)) != ROK)
1703 #else
1704          if ((ret = rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, (U32 *)&lcgBytes)) != ROK)
1705 #endif /* LTEMAC_SPS */
1706          {
1707             rgTOMUtlFreePduEvnt (pdu, TRUE);
1708             err.errType = RGERR_TOM_DATIND;
1709             RLOG_ARG1(L_ERROR,DBG_CELLID,datInd->cellId,
1710                             "Unable to handle Data Indication CRNTI:%d",ueCb->ueId);
1711             tfuSap->sapSts.numPduDrop++;
1712             continue;
1713          }
1714       }
1715
1716       
1717 #ifdef LTEMAC_SPS
1718       if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti,spsToBeActvtd,sduSize, (U32 *)&lcgBytes) != ROK)
1719 #else
1720       if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti, (U32 *)&lcgBytes) != ROK)
1721 #endif
1722       
1723       {
1724          rgTOMInfFreePduEvnt (sfInfo);
1725          rgTOMUtlFreePduEvnt (pdu, FALSE);
1726          RETVALUE(RFAILED);
1727       }
1728       /* free up the PDU memory */
1729       rgTOMUtlFreePduEvnt (pdu, FALSE);
1730    }
1731    /* Free the allocated memory for ueUlAllocInfo here */
1732 #ifdef LTE_L2_MEAS
1733    if(cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].ueUlAllocInfo != NULLP)
1734    {
1735       /*ccpu00117052 - MOD - Passing double for proper NULLP
1736                              assignment */
1737       rgFreeSBuf(inst,(Data **)&(cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].ueUlAllocInfo), 
1738       ((cellCb->ulSf[(slot % RG_NUM_SUB_FRAMES)].numUe) * sizeof(RgUeUlAlloc)));
1739    }
1740 #endif
1741    /* RRM_RBC_X */
1742    /* Update PRB used for all GBR QCIs to scheduler */
1743     cmMemcpy((U8*) &sfInfo->qcisUlPrbCnt[0],
1744              (U8*) &cellCb->qcisUlPrbCnt[0],
1745              (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1746     /* clear the cellCb ul prb value */
1747     cmMemset((U8*)&cellCb->qcisUlPrbCnt[0], 0, 
1748              (RGM_MAX_QCI_REPORTS * sizeof(U32)));
1749
1750    /* RRM_RBC_Y */
1751
1752    rgGetPstToInst(&schPst, inst,cellCb->schInstMap.schInst);
1753    sfInfo->cellSapId = cellCb->schInstMap.cellSapId;
1754    //TODO: commented for compilation without SCH RgMacSchSfRecp(&schPst, sfInfo);
1755    RETVALUE(ROK);
1756 }  /* rgTOMDatInd */
1757
1758 /**
1759  * @brief Function handles allocation for common channels i.e. BCCH-BCH,
1760  * BCCH-DLSCH, PCCH-DLSCH.
1761  *
1762  * @details
1763  *
1764  *     Function : rgHndlCmnChnl
1765  *     
1766  *     This function is invoked from RgSchMacSfAllocReq. This function handles
1767  *     allocations made for common channels like BCCH and PCCH. 
1768  *
1769  *     Processing steps:
1770  *     1. If BCCH on BCH has been scheduled, send StatusIndication on RGU.
1771  *     2. If PCCH is scheduled, send StatusIndication on RGU.
1772  *     3. If BCCH on DLSCH has been scheduled and sndStatInd is TRUE, send
1773  *     StatusIndication on RGU, else copy the bcch buffer onto the downlink
1774  *     subframe. 
1775  *     
1776  *           
1777  *  @param[in] RgCellCb          *cell,
1778  *  @param[in] CmLteTimingInfo   timingInfo,
1779  *  @param[in] RgInfCmnLcInfo    *cmnLcInfo,
1780  *  @param[in/out] RgErrInfo     *err,
1781  *  @return  S16
1782  *      -# ROK 
1783  *      -# RFAILED
1784  **/
1785 #ifdef ANSI
1786 PRIVATE S16 rgHndlCmnChnl
1787 (
1788 RgCellCb            *cell,
1789 CmLteTimingInfo     timingInfo,
1790 RgInfCmnLcInfo      *cmnLcInfo,
1791 RgErrInfo           *err
1792 )
1793 #else
1794 PRIVATE S16 rgHndlCmnChnl(cell, timingInfo, cmnLcInfo, err)
1795 RgCellCb            *cell;
1796 CmLteTimingInfo     timingInfo;
1797 RgInfCmnLcInfo      *cmnLcInfo;
1798 RgErrInfo           *err;
1799 #endif
1800 {
1801    #if (ERRCLASS & ERRCLS_DEBUG)
1802    RgPcchLcCb           *pcch;
1803    #endif
1804 #ifndef RGR_SI_SCH
1805    RgBcchDlschLcCb      *bcch;
1806 #if (ERRCLASS & ERRCLS_DEBUG)
1807    RgBcchBchLcCb        *bch;
1808 #endif
1809 #endif/*RGR_SI_SCH*/
1810    RguCStaIndInfo       *staInd;
1811    RgDlSf               *dlSf;
1812    Inst                 inst = cell->macInst - RG_INST_START;
1813
1814    TRC2(rgHndlCmnChnl)
1815
1816    dlSf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
1817
1818    if(cmnLcInfo->bitMask & RGINF_BCH_INFO)
1819    {
1820 #ifndef RGR_SI_SCH
1821       #if (ERRCLASS & ERRCLS_DEBUG) 
1822       if(NULLP == (bch = rgDBMGetBcchOnBch(cell)))
1823       {
1824          RETVALUE(RFAILED);
1825       }
1826       if(cmnLcInfo->bchInfo.lcId != bch->lcId)
1827       {
1828          RETVALUE(RFAILED);
1829       }
1830       #endif
1831
1832       if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1833       {
1834          err->errCause = RGERR_TOM_MEM_EXHAUST;
1835          RETVALUE(RFAILED);
1836       }
1837       staInd->cellId = cell->cellId;
1838       staInd->rnti   = RG_INVALID_RNTI;
1839       staInd->lcId   = cmnLcInfo->bchInfo.lcId;
1840       staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1841 /* ADD Changes for Downlink UE Timing Optimization */
1842 #ifdef LTEMAC_DLUE_TMGOPTMZ
1843       dlSf->remDatReqCnt++;
1844 #endif
1845       if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1846       {
1847          RETVALUE(RFAILED);
1848       }
1849 #else
1850       /*Store the received BCH Data in the scheduled subframe*/
1851       dlSf->bch.tb = cmnLcInfo->bchInfo.pdu;
1852 #endif/*RGR_SI_SCH*/
1853    }
1854
1855    if(cmnLcInfo->bitMask & RGINF_PCCH_INFO)
1856    {
1857       #if (ERRCLASS & ERRCLS_DEBUG) 
1858       if(NULLP == (pcch = rgDBMGetPcch(cell)))
1859       {
1860          RETVALUE(RFAILED);
1861       }
1862       if(cmnLcInfo->pcchInfo.lcId != pcch->lcId)
1863       {
1864          RETVALUE(RFAILED);
1865       }
1866       #endif
1867
1868       dlSf->pcch.pdcch.rnti = 
1869                cmnLcInfo->pcchInfo.rnti;
1870       dlSf->pcch.pdcch.dci = 
1871                cmnLcInfo->pcchInfo.dciInfo;
1872 #ifdef TFU_UPGRADE               
1873       /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */         
1874       dlSf->pcch.txPwrOffset = cmnLcInfo->pcchInfo.txPwrOffset;         
1875 #endif
1876       if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
1877       {
1878          err->errCause = RGERR_TOM_MEM_EXHAUST;
1879          RETVALUE(RFAILED);
1880       }
1881       staInd->cellId = cell->cellId;
1882       staInd->rnti   = RG_INVALID_RNTI;
1883       staInd->lcId   = cmnLcInfo->pcchInfo.lcId;
1884       staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1885 /* ADD Changes for Downlink UE Timing Optimization */
1886 #ifdef LTEMAC_DLUE_TMGOPTMZ
1887       dlSf->remDatReqCnt++;
1888 #endif
1889       /* for consolidated CmnStaInd calling below function from function 
1890        * rgHndlSchedUe once CmnStaInd prepared for all UEs
1891        */
1892       if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1893       {
1894          RETVALUE(RFAILED);
1895       }
1896    }
1897
1898    if(cmnLcInfo->bitMask & RGINF_BCCH_INFO)
1899    {
1900       dlSf->bcch.pdcch.rnti = 
1901                cmnLcInfo->bcchInfo.rnti;
1902       dlSf->bcch.pdcch.dci = 
1903                cmnLcInfo->bcchInfo.dciInfo;
1904 #ifdef TFU_UPGRADE               
1905       /* ccpu00132314-ADD-Fill the tx Pwr offset from scheduler */         
1906       dlSf->bcch.txPwrOffset = cmnLcInfo->bcchInfo.txPwrOffset;         
1907 #endif      
1908 #ifndef RGR_SI_SCH
1909       if(NULLP == 
1910          (bcch=rgDBMGetBcchOnDlsch(cell,cmnLcInfo->bcchInfo.lcId)))
1911       {
1912          RETVALUE(RFAILED);
1913       }
1914       if(TRUE == cmnLcInfo->bcchInfo.sndStatInd)
1915       {
1916          RG_FREE_MSG(bcch->tb);
1917          if (rgAllocShrablSBuf (inst,(Data**)&staInd, 
1918                   sizeof(RguCStaIndInfo)) != ROK)
1919          {
1920             err->errCause = RGERR_TOM_MEM_EXHAUST;
1921             RETVALUE(RFAILED);
1922          }
1923          staInd->cellId = cell->cellId;
1924          staInd->rnti   = RG_INVALID_RNTI;
1925          staInd->lcId   = cmnLcInfo->bcchInfo.lcId;
1926          staInd->transId = (timingInfo.sfn << 8) | (timingInfo.slot);
1927 /* ADD Changes for Downlink UE Timing Optimization */
1928 #ifdef LTEMAC_DLUE_TMGOPTMZ
1929          dlSf->remDatReqCnt++;
1930 #endif
1931          if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
1932          {
1933             RETVALUE(RFAILED);
1934          }
1935       }
1936       else
1937       {
1938          SCpyMsgMsg(bcch->tb, RG_GET_MEM_REGION(rgCb[inst]),
1939                   RG_GET_MEM_POOL(rgCb[inst]), &dlSf->bcch.tb);
1940       }
1941 #else
1942       /*Store the received BCCH Data in the scheduled subframe*/
1943       dlSf->bcch.tb = cmnLcInfo->bcchInfo.pdu;
1944 #endif/*RGR_SI_SCH*/
1945    }
1946
1947    RETVALUE(ROK);
1948 } /* end of rgHndlCmnChnl */
1949
1950 /**
1951  * @brief Function for handling allocations for dedicated channels for a
1952  * subframe.
1953  *
1954  * @details
1955  *
1956  *     Function : rgHndlSchdUe
1957  *     
1958  *     This function shall be invoked whenever scheduler is done with the
1959  *     allocations of dedicated channels for a subframe. Invoked by the function
1960  *     RgSchMacSfAllocReq.
1961  *
1962  *     Processing steps :
1963  *     1. Loops through the list of UE's scheduled looking for the corresponding
1964  *     ueCb/raCb. 
1965  *     2. Finds the corresponding HARQ process.
1966  *     3. Invokes the DHM function to issue StatusIndications on RGU.
1967  *
1968  *           
1969  *  @param[in] RgCellCb            *cell,
1970  *  @param[in] CmLteTimingInfo     timingInfo,
1971  *  @param[in] RgInfUeInfo         *ueInfo
1972  *  @param[in/out] RgErrInfo       *err
1973  *  @return  S16
1974  *      -# ROK 
1975  *      -# RFAILED 
1976  **/
1977 #ifdef ANSI
1978 PRIVATE S16 rgHndlSchdUe
1979 (
1980 RgCellCb            *cell,
1981 CmLteTimingInfo     timingInfo,
1982 RgInfUeInfo         *ueInfo,
1983 RgErrInfo           *err
1984 )
1985 #else
1986 PRIVATE S16 rgHndlSchdUe(cell, timingInfo, ueInfo, err) /* laa_ut_fix */
1987 RgCellCb            *cell;
1988 CmLteTimingInfo     timingInfo;
1989 RgInfUeInfo         *ueInfo;
1990 RgErrInfo           *err;
1991 #endif
1992 {
1993
1994    TRC2(rgHndlSchdUe);
1995
1996    if(NULLP == ueInfo->allocInfo)
1997    {
1998       RETVALUE(RFAILED);
1999    }
2000
2001    rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err);
2002
2003    RETVALUE(ROK);
2004 } /* end of rgHndlSchdUe */
2005
2006 #ifdef LTE_L2_MEAS
2007 /**
2008  * @brief Function for handling Uplink allocations for Ue for a
2009  * subframe.
2010  *
2011  * @details
2012  *
2013  *     Function : rgHndlUlUeInfo
2014  *     
2015  *  @param[in] RgCellCb            *cell,
2016  *  @param[in] CmLteTimingInfo     timingInfo,
2017  *  @param[in] RgInfUlUeInfo       *ueInfo
2018  *  @return  S16
2019  *      -# ROK 
2020  *      -# RFAILED 
2021  **/
2022 #ifdef ANSI
2023 PRIVATE S16 rgHndlUlUeInfo
2024 (
2025 RgCellCb            *cell,
2026 CmLteTimingInfo     timingInfo,
2027 RgInfUlUeInfo       *ueInfo
2028 )
2029 #else
2030 PRIVATE S16 rgHndlUlUeInfo(cell, timingInfo, ueInfo)
2031 RgCellCb            *cell;
2032 CmLteTimingInfo     timingInfo;
2033 RgInfUlUeInfo       *ueInfo;
2034 #endif
2035 {
2036    Inst           inst = cell->macInst - RG_INST_START;
2037    U8             idx;
2038    RgUlSf         *ulSf;
2039    S16            ret;
2040
2041    TRC2(rgHndlUlUeInfo)
2042    
2043    ulSf = &cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)];
2044
2045    /* rg003.301-MOD- Corrected the purifier memory leak */
2046    if (ulSf->numUe != ueInfo->numUes)
2047    {
2048       if (ulSf->ueUlAllocInfo)
2049       {
2050          rgFreeSBuf(inst,(Data **)&(ulSf->ueUlAllocInfo),
2051                ulSf->numUe * sizeof(RgUeUlAlloc));
2052       }
2053    }
2054 #ifdef XEON_SPECIFIC_CHANGES
2055    CM_MEAS_TIME((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_FREE);
2056    CM_ADD_INFO((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES),  CM_DBG_MEAS_FREE, ulSf->numUe);
2057 #endif
2058    ulSf->numUe         = ueInfo->numUes;
2059    if((ulSf->ueUlAllocInfo == NULLP) && (ueInfo->numUes > 0))
2060    {
2061        /* Allocate memory for ulAllocInfo */
2062        if((ret = rgAllocSBuf(inst,(Data**)&(cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)].
2063                  ueUlAllocInfo), ueInfo->numUes *  sizeof(RgUeUlAlloc))) != ROK)
2064        {
2065           RETVALUE(ret);
2066        }
2067    }
2068 #ifdef XEON_SPECIFIC_CHANGES
2069    CM_MEAS_TIME((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MEAS_ALLOC);
2070    CM_ADD_INFO((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES), CM_DBG_MEAS_ALLOC, ueInfo->numUes);
2071 #endif
2072    if (ulSf->ueUlAllocInfo != NULLP)
2073    {
2074       for(idx = 0; idx < ueInfo->numUes; idx++)
2075       {
2076          ulSf->ueUlAllocInfo[idx].rnti   = ueInfo->ulAllocInfo[idx].rnti;
2077          ulSf->ueUlAllocInfo[idx].numPrb = ueInfo->ulAllocInfo[idx].numPrb;
2078       }
2079    }
2080    RGCPYTIMEINFO(timingInfo, ulSf->schdTime);
2081    RETVALUE(ROK);
2082 } /* end of rgHndlUlUeInfo */
2083 #endif
2084 /**
2085  * @brief Function for handling RaResp request received from scheduler to MAC
2086  *
2087  * @details
2088  *
2089  *     Function : rgTOMRlsSf
2090  *     
2091  *     This function shall be invoked whenever scheduler is done with the
2092  *     allocations of random access responses for a subframe.
2093  *     This shall invoke RAM to create ueCbs for all the rapIds allocated and 
2094  *     shall invoke MUX to create RAR PDUs for raRntis allocated.
2095  *     
2096  *           
2097  *  @param[in] Inst        inst
2098  *  @param[in] CmLteCellId         cellId,
2099  *  @param[in] CmLteTimingInfo     timingInfo,
2100  *  @param[in] RaRespInfo          *rarInfo
2101  *  @return  S16
2102  *      -# ROK 
2103  **/
2104 #ifdef ANSI
2105 PUBLIC Void rgTOMRlsSf
2106 (
2107 Inst                inst,
2108 RgDlSf              *dlSf
2109 )
2110 #else
2111 PUBLIC Void rgTOMRlsSf(dlSf)
2112 Inst                inst;
2113 RgDlSf              *dlSf;
2114 #endif
2115 {
2116    U8               idx;
2117
2118    TRC2(rgTOMRlsSf)
2119
2120    if(dlSf->txDone == FALSE)
2121    {
2122       RLOG0(L_ERROR, "SUBFRAME Not pushed to the PHY");
2123
2124       if (dlSf->bch.tb != NULLP)
2125       {
2126          RG_FREE_MSG(dlSf->bch.tb);
2127       }
2128       if (dlSf->bcch.tb != NULLP)
2129       {
2130          RG_FREE_MSG(dlSf->bcch.tb);
2131       }
2132       if (dlSf->pcch.tb != NULLP)
2133       {
2134          RG_FREE_MSG(dlSf->pcch.tb);
2135       }
2136 #ifdef EMTC_ENABLE
2137       rgTOMEmtcRlsSf(dlSf);
2138 #endif
2139       for(idx=0; idx < dlSf->numRaRsp; idx++)
2140       {
2141          RG_FREE_MSG(dlSf->raRsp[idx].rar);
2142       }
2143    }
2144 /* ADD Changes for Downlink UE Timing Optimization */
2145 #ifdef LTEMAC_DLUE_TMGOPTMZ
2146    dlSf->remDatReqCnt = 0;
2147    /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled 
2148       RLC-MAC */
2149    dlSf->statIndDone = FALSE;
2150 #endif
2151          if (dlSf->tbs.count)
2152          {
2153       U8           i;
2154       CmLList      *node;
2155       RgDlHqProcCb *hqP;
2156        RGDBGERRNEW(inst, (rgPBuf(inst),
2157                 "Error Stale TBs in Subframes TBS list\n"));
2158       node = dlSf->tbs.first;
2159                   while(node)
2160                   {
2161          hqP = (RgDlHqProcCb*)node->node;
2162          node = node->next;
2163           if (hqP)
2164           {
2165                      for(i=0;i< RG_MAX_TB_PER_UE;i++)
2166                      {
2167                                     if (hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf == dlSf)
2168                                     {
2169                                              cmLListDelFrm(&dlSf->tbs, &(hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk));
2170                                              hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk.node = NULLP;
2171                     printf("\n rgTOMRlsSf:: hqP %p \n", (Void *)hqP);
2172                                     }
2173                                     hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf = NULLP;
2174                            }
2175                         }
2176          }
2177     }
2178     /*arjun: check if dlSf laaTb list has to be freed???*/
2179    cmLListInit(&dlSf->tbs);
2180    dlSf->txDone = FALSE;
2181    dlSf->numRaRsp = 0;
2182    RETVOID;
2183 }
2184
2185 /**
2186  * @brief Function is called by the scheduler once it has completed the
2187  * allocation for the subframe. 
2188  *
2189  * @details
2190  *
2191  *     Function : rgHndlFlowCntrl
2192  *     This function should fill and send Flow control 
2193  *     indication to RLC
2194  *
2195  *           
2196  *  @param[in] Pst                 *cell       
2197  *  @param[in] RgInfSfAlloc        *sfInfo   Carries all the allocation
2198  *  information.
2199  *  @return  S16
2200  *      -# ROK 
2201  **/
2202 #ifdef ANSI
2203 PUBLIC S16 rgHndlFlowCntrl
2204 (
2205 RgCellCb       *cell,
2206 RgInfSfAlloc        *sfInfo
2207 )
2208 #else
2209 PUBLIC S16 rgHndlFlowCntrl(cell, sfInfo)
2210 RgCellCb            *cell;
2211 RgInfSfAlloc        *sfInfo;
2212 #endif
2213 {
2214    RguFlowCntrlInd  *flowCntrlInd;
2215    Pst              *pst;
2216    U32              ueIdx;
2217    U32              lcIdx;
2218    TRC3(rgHndlFlowCntrl);
2219
2220    pst = &cell->rguDlSap->sapCfg.sapPst;
2221    /* flowCntrlInd is alloced in cell init time and will be re-used throughout */
2222    flowCntrlInd = cell->flowCntrlInd;
2223    flowCntrlInd->cellId = sfInfo->cellId;
2224    flowCntrlInd->numUes = sfInfo->flowCntrlInfo.numUes; 
2225   
2226    for (ueIdx = 0; ueIdx < sfInfo->flowCntrlInfo.numUes; ueIdx++)
2227    {
2228       flowCntrlInd->ueFlowCntrlInfo[ueIdx].ueId = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].ueId;
2229       flowCntrlInd->ueFlowCntrlInfo[ueIdx].numLcs = sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].numLcs;
2230       
2231       for (lcIdx = 0; lcIdx < RGINF_MAX_NUM_DED_LC; lcIdx++)
2232       {
2233          flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId =
2234          sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].lcId;
2235          flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt = 
2236          sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].pktAdmitCnt;
2237         
2238          flowCntrlInd->ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl = 
2239          sfInfo->flowCntrlInfo.ueFlowCntrlInfo[ueIdx].lcInfo[lcIdx].maxBo4FlowCtrl;
2240       }
2241    }
2242    RgUiRguFlowCntrlInd(pst, cell->rguDlSap->sapCfg.spId,flowCntrlInd); /* TODO: Rishi confirm if the suId and pst pointer is correct */
2243    RETVALUE(ROK);
2244 }
2245 /**
2246  * @brief Function is called by the scheduler once it has completed the
2247  * allocation for the subframe. 
2248  *
2249  * @details
2250  *
2251  *     Function : RgSchMacSfAllocReq
2252  *     
2253  *     This function shall be invoked whenever scheduler is done with the
2254  *     allocations of for a subframe. The sfInfo carries all the allocation
2255  *     details for the common channels, RA responses and dedicated channel
2256  *     allocations. 
2257  *
2258  *     Processing steps :
2259  *     1. Reset the information present in the downlink subframe that is
2260  *     scheduled.
2261  *     2. Handle common channel allocations
2262  *     3. Handle RA Response allocations
2263  *     4. Handle dedicated channel allocations.
2264  *           
2265  *  @param[in] Pst                 *pst       
2266  *  @param[in] RgInfSfAlloc        *sfInfo   Carries all the allocation
2267  *  information.
2268  *  @return  S16
2269  *      -# ROK 
2270  **/
2271 #ifdef ANSI
2272 PUBLIC S16 RgSchMacSfAllocReq
2273 (
2274 Pst                 *pst,
2275 RgInfSfAlloc        *sfInfo
2276 )
2277 #else
2278 PUBLIC S16 RgSchMacSfAllocReq(pst, sfInfo)
2279 Pst                 *pst;
2280 RgInfSfAlloc        *sfInfo;
2281 #endif
2282 {
2283    RgCellCb       *cell;
2284    RgDlSf         *dlSf;
2285    RgErrInfo      err;
2286    VOLATILE U32   startTime=0;
2287    Inst           inst;
2288
2289    TRC2(RgSchMacSfAllocReq)
2290
2291    RG_IS_INST_VALID(pst->dstInst);
2292    inst = pst->dstInst - RG_INST_START;
2293    /*starting Task*/
2294    SStartTask(&startTime, PID_MAC_SF_ALLOC_REQ);
2295
2296    if(NULLP == sfInfo)
2297    {
2298       RETVALUE(RFAILED);
2299    }
2300
2301    if((cell = rgCb[inst].cell) == NULLP)
2302    {
2303       RLOG_ARG0(L_ERROR,DBG_CELLID,sfInfo->cellId, "No cellCb found with cell");
2304       RETVALUE(RFAILED);
2305    }
2306
2307    dlSf = &cell->subFrms[(sfInfo->timingInfo.slot % RG_NUM_SUB_FRAMES)];
2308
2309    rgTOMRlsSf(inst,dlSf);
2310    dlSf->schdTime = sfInfo->timingInfo;
2311
2312 #ifdef LTE_ADV
2313    rgLaaInitTbInfoLst(cell);
2314 #endif
2315
2316    /* Fix : syed Ignore Failure Returns and continue processing.
2317     * Incomplete processing results in state sync loss between MAC-SCH. */
2318 #ifdef EMTC_ENABLE
2319     if(TRUE == cell->emtcEnable)
2320     {
2321        rgEmtcHndl(cell, sfInfo);
2322     }
2323 #endif
2324    rgHndlCmnChnl(cell, sfInfo->timingInfo, &sfInfo->cmnLcInfo, &err);
2325
2326    rgHndlRaResp(cell, sfInfo->timingInfo, &sfInfo->rarInfo, &err);
2327
2328 #ifdef LTE_ADV
2329 #ifdef XEON_SPECIFIC_CHANGES
2330    CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_B4_UE_SCHD);
2331 #endif
2332    rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2333 #ifdef XEON_SPECIFIC_CHANGES
2334    CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_UE_SCHD);
2335 #endif
2336    rgLaaChkAndReqTbs(dlSf,cell, inst);
2337
2338 #else
2339    rgHndlSchdUe(cell, sfInfo->timingInfo, &sfInfo->ueInfo, &err);
2340 #endif
2341
2342 #ifdef LTE_L2_MEAS
2343    if(rgHndlUlUeInfo(cell, sfInfo->ulUeInfo.timingInfo, 
2344                      &sfInfo->ulUeInfo) != ROK)
2345    {
2346       RETVALUE(RFAILED);
2347    }
2348 #endif
2349 #ifdef XEON_SPECIFIC_CHANGES
2350    CM_MEAS_TIME((cell->crntTime.slot % RG_NUM_SUB_FRAMES), CM_DBG_MAC_TTI_IND, CM_DBG_MAC_MEAS);
2351 #endif
2352    /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled 
2353       RLC-MAC */
2354
2355
2356    /* Added the handling for pushing down
2357     * TFU Data request in the retransmission only scenario.*/ 
2358 #ifdef LTEMAC_DLUE_TMGOPTMZ
2359    dlSf->statIndDone = TRUE;
2360    /* Fix [ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled 
2361       RLC-MAC */
2362    if(!(dlSf->txDone) && 
2363 #ifdef LTE_ADV
2364          (TRUE == rgLaaChkAllRxTbs(dlSf)) && 
2365 #endif
2366          (0 == dlSf->remDatReqCnt) && (dlSf->statIndDone) && 
2367         (RG_TIMEINFO_SAME(cell->crntTime, dlSf->schdTime)))
2368    {
2369       /*This is the case of rettransmission, so no need
2370        * to wait for TTI Ind to push TFU Data Request. Send
2371        * it right away.*/
2372       if (ROK != rgTOMUtlProcDlSf (dlSf, cell, &err))
2373       {
2374          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to process downlink subframe for cell");
2375          err.errType = RGERR_ROM_DEDDATREQ;
2376       }
2377       /* Mark this frame as sent */
2378       dlSf->txDone = TRUE;
2379    }
2380 #endif
2381    if (sfInfo->flowCntrlInfo.numUes > 0)
2382    {
2383      rgHndlFlowCntrl(cell,sfInfo);
2384    }
2385    /*stoping Task*/
2386    SStopTask(startTime, PID_MAC_SF_ALLOC_REQ);
2387    RETVALUE(ROK);
2388 } /* end of RgSchMacSfAllocReq */
2389 /**
2390  * @brief Handler for processing data indication recieved from PHY for UEs.
2391  *
2392  * @details
2393  *
2394  *     Function: rgTOMProcCrntiCEInDatInd
2395  *
2396  *     Handler for processing data indication recieved from PHY for UEs.
2397  *
2398  *     Invoked by: RgLiTfuDatInd of LIM 
2399  *
2400  *     Processing Steps: 
2401  *     For each DataInfo recieved
2402  *      - If  received a CRNTI control element 
2403  *          - Check if a CCCH SDU is present, if it is return failure
2404  *          - Check for the existence of UE, if its isnt present return failure.
2405  *          - Delegate the remaining processing to rgTOMUtlProcMsg3 which
2406  *          primarily informs the scheduler about the data received and
2407  *          generates Data indications towards the higher layer.
2408  *           
2409  *  @param      RgMacPdu          *pdu,
2410  *  @param      RgUeCb            *prevUeCb,
2411  *  @param      RgCellCb          *cellCb,
2412  *  @param      TfuDatInfo        *datInfo,
2413  *  @param      RgInfCeInfo       *ceInfo
2414  *  @return  S16
2415  *      -# ROK 
2416  *      -# RFAILED 
2417  **/
2418 #ifdef ANSI
2419 PRIVATE S16 rgTOMProcCrntiCEInDatInd
2420 (
2421 RgMacPdu          *pdu,
2422 RgUeCb            *prevUeCb,
2423 RgCellCb          *cellCb,
2424 TfuDatInfo        *datInfo,
2425 RgInfCeInfo       *ceInfo,
2426 U16               slot
2427 )
2428 #else
2429 PRIVATE S16 rgTOMProcCrntiCEInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
2430 RgMacPdu          *pdu;
2431 RgUeCb            *prevUeCb;
2432 RgCellCb          *cellCb;
2433 TfuDatInfo        *datInfo;
2434 RgInfCeInfo       *ceInfo;
2435 U16               slot;
2436 #endif
2437 {
2438    RgUeCb *ueCb = NULLP;
2439    Inst   inst  = cellCb->macInst - RG_INST_START;
2440
2441
2442 #ifdef LTEMAC_SPS
2443    Bool spsToBeActvtd;
2444    U16  sduSize;
2445 #endif
2446
2447    TRC2(rgTOMProcCrntiCEInDatInd)
2448
2449 #ifndef LTE_L2_MEAS      
2450       UNUSED(slot);
2451 #endif
2452
2453    ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2454
2455    if (ueCb == NULLP)
2456    {
2457        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2458                 "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2459        RETVALUE(RFAILED);
2460    }
2461
2462    prevUeCb = rgDBMGetUeCb (cellCb, ceInfo->ces.cRnti);
2463    if (prevUeCb == NULLP)
2464    {
2465        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2466                  "RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
2467        RETVALUE(RFAILED);
2468    }
2469    RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
2470             "CRNTI CE(%d) received through tmpCrnti(%d)",
2471             ceInfo->ces.cRnti, datInfo->rnti);
2472    rgDBMDelUeCbFromRachLst(cellCb, ueCb);
2473    rgRAMFreeUeCb(inst,ueCb);
2474    ueCb = prevUeCb;
2475 #ifdef LTEMAC_SPS
2476    if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, slot, NULLP)) != ROK)
2477 #else
2478    if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, NULLP)) != ROK)
2479 #endif /* LTEMAC_SPS */
2480    {
2481        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2482                        "RNTI:%d Processing for MSG3 failed",datInfo->rnti);
2483        RETVALUE(RFAILED);
2484    }
2485    RETVALUE(ROK);
2486 }
2487 /**
2488  * @brief Handler for processing data indication recieved from PHY for UEs.
2489  *
2490  * @details
2491  *
2492  *     Function: rgTOMProcCCCHSduInDatInd
2493  *
2494  *     Handler for processing data indication recieved from PHY for UEs.
2495  *
2496  *     Invoked by: RgLiTfuDatInd of LIM 
2497  *
2498  *     Processing Steps: 
2499  *     For each DataInfo recieved
2500  *      - If only CCCH SDU is present
2501  *        - Invoke rgTOMUtlProcMsg3 for further processing.
2502  *      - If its a non-Msg3 PDU i.e. received outside of a RA procedure
2503  *        - Retrieve the UeCB 
2504  *        - Validate that the received PDU contains only configured Logical
2505  *        Channels.
2506  *        - Invoke rgTOMUtlProcDatPdu for further processing. It informs the
2507  *        scheduler with the information of the received Data and generates
2508  *        DatIndications towards the higher layers. 
2509  *           
2510  *  @param  TfuDatIndInfo *datInd
2511  *  @param  RgMacPdu          *pdu,
2512  *  @param  RgUeCb            *prevUeCb,
2513  *  @param  RgCellCb          *cellCb,
2514  *  @param  TfuDatInfo        *datInfo,
2515  *  @param  RgInfCeInfo       *ceInfo
2516  *  @return  S16
2517  *      -# ROK 
2518  *      -# RFAILED 
2519  **/
2520 #ifdef ANSI
2521 PRIVATE S16 rgTOMProcCCCHSduInDatInd
2522 (
2523 RgMacPdu          *pdu,
2524 RgUeCb            *prevUeCb,
2525 RgCellCb          *cellCb,
2526 TfuDatInfo        *datInfo,
2527 RgInfCeInfo       *ceInfo,
2528 U16               slot 
2529 )
2530 #else
2531 PRIVATE S16 rgTOMProcCCCHSduInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
2532 RgMacPdu          *pdu;
2533 RgUeCb            *prevUeCb;
2534 RgCellCb          *cellCb;
2535 TfuDatInfo        *datInfo;
2536 RgInfCeInfo       *ceInfo;
2537 U16               slot;
2538 #endif
2539 {
2540    RgUeCb *ueCb = NULLP;
2541    Inst   inst  = cellCb->macInst - RG_INST_START;
2542
2543 #ifdef LTEMAC_SPS
2544    Bool spsToBeActvtd;
2545    U16  sduSize;
2546 #endif
2547
2548
2549    TRC2(rgTOMProcCCCHSduInDatInd)
2550
2551 #ifndef LTE_L2_MEAS      
2552       UNUSED(slot);
2553 #endif
2554
2555    if (ceInfo->bitMask & RG_CRNTI_CE_PRSNT)
2556    {
2557        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2558                        "CRNTI:%d Received MSG3 with CCCH",ceInfo->ces.cRnti);
2559        RETVALUE(RFAILED);
2560    }
2561    
2562    ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
2563    
2564    if (ueCb == NULLP)
2565    {
2566        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
2567                        "RNTI:%d Processing for MSG3 failed", datInfo->rnti);
2568        RETVALUE(RFAILED);
2569    }
2570    /* Fix: syed Drop any duplicate Msg3(CCCH Sdu) */
2571    if (ueCb->dl.hqEnt.numHqProcs)
2572    {
2573       /* HqE is already initialized by a previuos Msg3 */ 
2574        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed. Duplicate "
2575           "MSG3 received. Dropping", datInfo->rnti);
2576        RETVALUE(RFAILED);
2577    }
2578    
2579    if(rgDHMHqEntInit(inst,&ueCb->dl.hqEnt,
2580                      cellCb->maxDlHqProcPerUe) != ROK)
2581    {
2582        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Harq Initialization failed ", 
2583           datInfo->rnti);
2584        RETVALUE(RFAILED);
2585    }
2586     RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
2587              "CCCH SDU received through tmpCrnti(%d)",datInfo->rnti);
2588 #ifdef LTEMAC_SPS
2589    if ((rgTOMUtlProcMsg(cellCb, ueCb, pdu, FALSE,&spsToBeActvtd,&sduSize, slot, NULLP)) != ROK)
2590 #else
2591    if ((rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, NULLP)) != ROK)
2592 #endif /* LTEMAC_SPS */
2593    {
2594        RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed", 
2595           datInfo->rnti);
2596        RETVALUE(RFAILED);
2597    }
2598    RETVALUE(ROK);
2599 }
2600
2601 #ifdef LTE_L2_MEAS
2602
2603 /** @brief This function captures the BSR value from Control Element
2604  *  Info structure and updates the effective Buffer size into the 
2605  *  corresponding LCG ID. 
2606  *
2607  * @details 
2608  *
2609  *     Function: rgTOMUtlL2MStoreBufSz
2610  *
2611  *         Processing steps:
2612  *         - update/append the Data structure based on BSR type 
2613  *
2614  * @param  [in] RgUeCb     *ueCb
2615  * @param  [in] RgInfCeInfo *ceInfo
2616  * @return S16
2617  */
2618
2619 #ifdef ANSI
2620 PRIVATE S16 rgTOMUtlL2MStoreBufSz
2621 (
2622  RgUeCb      *ueCb,
2623  RgInfCeInfo *ceInfo
2624  )
2625 #else
2626 PRIVATE S16 rgTOMUtlL2MStoreBufSz (ueCb, ceInfo)
2627  RgUeCb      *ueCb;
2628  RgInfCeInfo *ceInfo;
2629 #endif
2630 {
2631    U8 lcgId;
2632    U8 bsr;
2633    TRC2(rgTOMUtlL2MStoreBufSz);
2634
2635    if(ceInfo->bitMask & RG_TRUNC_BSR_CE_PRSNT)
2636    {
2637       lcgId = ((ceInfo->ces.bsr.truncBsr >> 6) & 0x03);
2638       bsr = ceInfo->ces.bsr.truncBsr & 0x3F;
2639       ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2640    }
2641    else if(ceInfo->bitMask & RG_SHORT_BSR_CE_PRSNT)
2642    {
2643       lcgId = ((ceInfo->ces.bsr.shortBsr >> 6) & 0x03);
2644       bsr = ceInfo->ces.bsr.shortBsr & 0x3F;
2645       ueCb->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = rgLwrBsrTbl[bsr];
2646
2647    }
2648    else if(ceInfo->bitMask & RG_LONG_BSR_CE_PRSNT)
2649    {
2650       ueCb->ul.lcgArr[0].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs1];
2651       ueCb->ul.lcgArr[1].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs2];
2652       ueCb->ul.lcgArr[2].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs3];
2653       ueCb->ul.lcgArr[3].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs4];
2654    }
2655    RETVALUE(ROK);
2656 } /* end of rgTOMUtlL2MStoreBufSz*/
2657
2658 /** @brief : Compiles list of LCs received in UL data for DTCH RBs
2659  *
2660  * @details
2661  *
2662  * @param  [in] RgCellCb   *cellCb
2663  * @param  [in] RgUeCb     *ueCb
2664  * @param  [in] CmLteRnti  rnti
2665  * @param  [in] RgMacPdu   *pdu
2666  * @param 
2667  *  @return  S16
2668  *      -# ROK 
2669  *      -# RFAILED 
2670  */
2671 #ifdef ANSI
2672 PRIVATE Void rgTOML2MCompileActiveLCs
2673 (
2674  RgCellCb      *cellCb, 
2675  RgUeCb        *ueCb,
2676  RgMacPdu      *pdu,
2677  RgInfCeInfo   *ceInfo 
2678  )
2679 #else
2680 PRIVATE Void rgTOML2MCompileActiveLCs(cellCb, ueCb, pdu, ceInfo)
2681    RgCellCb      *cellCb; 
2682    RgUeCb        *ueCb;
2683    RgMacPdu      *pdu;
2684    RgInfCeInfo   *ceInfo; 
2685 #endif 
2686 {
2687    CmLList           *node;
2688    RgMacSdu          *sdu;
2689    RgUlLcCb          *ulLcCb;
2690
2691    TRC2(rgTOML2MCompileActiveLCs)
2692
2693    node =  pdu->sduLst.first;
2694    while (node)
2695    {
2696       sdu = (RgMacSdu*)node->node;
2697       
2698       if ((ulLcCb = rgDBMGetUlDedLcCb(ueCb, sdu->lcId)), ulLcCb != NULLP)
2699       {
2700          if (ulLcCb->lcgId != 0)
2701          {
2702             ceInfo->bitMask |= RG_ACTIVE_LC_PRSNT;
2703             ceInfo->ulActLCs[ulLcCb->lcId - 1] = TRUE;
2704          }
2705       }
2706       node = node->next;
2707    }
2708
2709 } /* end of */ 
2710
2711
2712
2713 #endif
2714 /**********************************************************************
2715  
2716          End of file
2717 **********************************************************************/