Muxing mac pdu and lower mac changes for Msg4
[o-du/l2.git] / src / 5gnrmac / rg_rom.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_rom.c
28   
29 **********************************************************************/
30
31 /** @file rg_rom.c
32 @brief APIs to handle all the primitives invoked on RGU interface.
33 */
34
35 static const char* RLOG_MODULE_NAME="MAC";
36 static int RLOG_FILE_ID=184;
37 static int RLOG_MODULE_ID=4096;
38
39 /* header include files (.h) */
40 #include "envopt.h"        /* environment options */
41 #include "envdep.h"        /* environment dependent */
42 #include "envind.h"        /* environment independent */
43   
44 #include "gen.h"           /* general */
45 #include "ssi.h"           /* system services */
46
47 #include "cm_tkns.h"       /* Common Token Defines */
48 #include "cm_llist.h"      /* Common Link List Defines */
49 #include "cm_hash.h"       /* Common Hash List Defines */
50 #include "cm_mblk.h"       /* common memory link list library */
51 #include "cm_lte.h"        /* Common LTE */
52
53 #include "rg_env.h"        /* MAC Environment Defines */
54 #include "crg.h"           /* CRG Interface defines */
55 #include "rgu.h"           /* RGU Interface defines */
56 #include "tfu.h"           /* TFU Interface defines */
57 #include "rg_sch_inf.h"           /* RGR Interface defines */
58 #include "lrg.h"           /* LRG Interface defines */
59
60 #include "rg.h"            /* MAC defines */
61 #include "rg_err.h"        /* MAC error defines */
62
63 /* header/extern include files (.x) */
64 #include "gen.x"           /* general */
65 #include "ssi.x"           /* system services */
66 #include "cm5.x"           /* Timer */
67 #include "cm_tkns.x"       /* Common Token Definitions */
68 #include "cm_llist.x"      /* Common Link List Definitions */
69 #include "cm_lib.x"        /* Common Library Definitions */
70 #include "cm_hash.x"       /* Common Hash List Definitions */
71 #include "cm_mblk.x"       /* common memory link list library */
72 #include "cm_lte.x"        /* Common LTE */
73
74 #include "crg.x"           /* CRG Interface includes */
75 #include "rgu.x"           /* RGU Interface includes */
76 #include "tfu.x"           /* TFU Interface includes */
77 #include "rg_sch_inf.x"    /* SCH Interface includes */
78 #include "rg_prg.x"        /* PRG Interface includes */
79 #include "lrg.x"           /* LRG Interface includes */
80
81 #include "du_app_mac_inf.h"
82 #include "rg.x"            /* MAC includes */
83
84 /* local defines */
85 #define RG_NON_MIMO_IDX 0
86
87 /* local typedefs */
88  
89 S16 RgMacSchBrdcmDedBoUpdtReq ARGS((Inst inst, CmLteCellId cellId, CmLteRnti rnti, CmLteLcId lcId, S32 bo ));
90 PRIVATE S16 rgROMHndlCcchDatReq     ARGS((RgCellCb *cell,
91                                     RgRguCmnDatReq *datReq, RgErrInfo *err));
92 PRIVATE S16 rgROMHndlBcchPcchDatReq ARGS((RgCellCb *cell,
93                                     RgRguCmnDatReq *datReq, RgErrInfo *err));
94 PRIVATE S16 rgROMHndlCcchStaRsp     ARGS((RgCellCb *cell, 
95                                     RgRguCmnStaRsp *staRsp, RgErrInfo *err));
96 PRIVATE S16 rgROMHndlBcchPcchStaRsp ARGS((RgCellCb *cell, 
97                                     RgRguCmnStaRsp *staRsp, RgErrInfo *err));
98
99 /* ADD Changes for Downlink UE Timing Optimization */
100 #ifdef LTEMAC_DLUE_TMGOPTMZ
101 PRIVATE S16 rgROMUpdDlSfRemDataCnt ARGS((RgCellCb  *cellCb,
102                                     RgDlSf    *dlSf));
103 PUBLIC S16 rgTOMUtlProcDlSf ARGS(( RgDlSf     *dlSf,
104                                    RgCellCb   *cellCb,
105                                    RgErrInfo  *err));
106 #endif
107
108 /* forward references */
109
110 /**
111  * @brief Handler for dedicated DatReq received on RGU for an UE.
112  *
113  * @details
114  *
115  *     Function : rgROMDedDatReq
116  *     
117  *     This function shall
118  *      -# store the BO reported for the given logical channels.
119  *      -# invoke DL HARQ for further processing.
120  *     
121  *           
122  *  @param[in]  Inst        inst
123  *  @param[in]  RgRguDedDatReq *datReq 
124  *  @return  S16
125  *      -# ROK 
126  *      -# RFAILED 
127  **/
128 #ifdef ANSI
129 PUBLIC S16 rgROMDedDatReq
130 (
131 Inst      inst,
132 RgRguDedDatReq *datReq
133 )
134 #else
135 PUBLIC S16 rgROMDedDatReq(inst,datReq)
136 Inst      inst;
137 RgRguDedDatReq *datReq;
138 #endif
139 {
140 #if 0
141    RgCellCb     *cell;
142    RgUeCb       *ue;
143    U8           idx1,idx2;
144    RgDlHqProcCb *hqProc;
145    U8           hqPId;
146    RgErrInfo    err;
147    Pst          schPst;
148    RgInfDedBoRpt boRpt;
149    CmLteTimingInfo timingInfo;
150    RgDlSf       *sf;
151 #if (ERRCLASS & ERRCLS_DEBUG)
152    RgUstaDgn   dgn;      /* Alarm diagnostics structure */
153 #endif
154 /* ADD Changes for Downlink UE Timing Optimization */
155 #ifdef LTEMAC_DLUE_TMGOPTMZ
156    S16 ret;
157 #endif
158    U32 idx;
159    //U8  datReqFailCnt = 0;
160
161    TRC2(rgROMDedDatReq)
162
163
164    if (((cell = rgCb[inst].cell) == NULLP) 
165        || (cell->cellId != datReq->cellId))
166    {
167 #if (ERRCLASS & ERRCLS_INT_PAR)
168       /* Handle Cell fetch failure */
169       RGLOGERROR(inst,ERRCLS_INT_PAR,ERG001,(ErrVal)datReq->cellId,
170             "rgROMDedDatReq(): Invalid cell Id");
171 #endif
172       err.errType = RGERR_ROM_DEDDATREQ;
173       err.errCause = RGERR_ROM_INV_CELL_ID;
174       if(cell != NULLP)
175       {
176          /* Update stats */
177          rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
178       }
179       RETVALUE(RFAILED);
180    }
181
182 /* Add loop here to scan for all UEs in the consolidated DDatReq*/
183    for(idx = 0; idx < datReq->nmbOfUeGrantPerTti; idx++)
184    {
185
186       timingInfo.slot = (U8)((datReq->datReq[idx].transId >> 8) & 0XFF);
187       timingInfo.sfn = (U16)((datReq->datReq[idx].transId >> 16) & 0xFFFF);
188       sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
189
190       if( (sf->txDone == TRUE) ||
191             (!RG_TIMEINFO_SAME(sf->schdTime,timingInfo)))
192       {
193 #if (ERRCLASS & ERRCLS_DEBUG)
194          /* Transmission is already done for this slot. This is a delayed
195           * datReq. So discard */
196          rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
197          rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
198                LRG_CAUSE_DELAYED_DATREQ, &dgn);
199 #endif
200          err.errType = RGERR_ROM_DEDDATREQ;
201          err.errCause = RGERR_ROM_DELAYED_DATREQ;
202          /* Update stats */
203          rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
204 #ifdef CA_DBG
205          {
206             EXTERN U32 dbgDelayedDatReqInMac;
207             dbgDelayedDatReqInMac++;
208          }
209 #endif /* CA_DBG */         
210 #ifndef L2_OPTMZ
211          RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
212 #endif
213          continue;
214         // RETVALUE(RFAILED);
215       }
216
217       if ((ue = rgDBMGetUeCb(cell, datReq->datReq[idx].rnti)) == NULLP)
218       {
219 #if (ERRCLASS & ERRCLS_INT_PAR)
220             /* Handle Ue fetch failure */
221             RGLOGERROR(inst,ERRCLS_INT_PAR,ERG002,(ErrVal)datReq->datReq[idx].rnti,
222                   "rgROMDedDatReq(): Invalid ue Id");
223 #endif
224             err.errType = RGERR_ROM_DEDDATREQ;
225             err.errCause = RGERR_ROM_INV_UE_ID;
226             /* Update stats */
227             rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
228             /* ADD Changes for Downlink UE Timing Optimization */
229 #ifdef LTEMAC_DLUE_TMGOPTMZ
230             /* Trying to send the prev successful PDU's 
231              * if present */
232             ret = rgROMUpdDlSfRemDataCnt(cell, sf);
233             if(ret == RFAILED)
234             {
235                RLOG0(L_INFO, "Dropping due to no ue \n");
236 #ifndef L2_OPTMZ
237                RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
238 #endif
239                /* Return from here as above functions found more datReq than expected*/
240               /* RETVALUE(ret); */
241             }
242 #endif
243             /* Conitnue for next UE */
244             continue;
245       }
246
247       hqPId = (U8)(datReq->datReq[idx].transId);
248       hqPId = hqPId >> 2;
249       /* get harq process and invoke DHM */
250       rgDHMGetHqProcFrmId(ue, hqPId, &hqProc);
251
252       if (rgDHMHndlDedDatReq(inst,hqProc, &datReq->datReq[idx], sf, &err) == RFAILED)
253       {
254          RLOG_ARG1(L_ERROR,DBG_CELLID,datReq->cellId,
255                    "Handling of Data request in DHM failedi RNTI:%d",
256                     datReq->datReq[idx].rnti);
257          err.errType = RGERR_ROM_DEDDATREQ;
258          /* errcause shall be filled in appropriately by DHM */
259          /* Update stats */
260          rgUpdtRguDedSts(inst,ue->rguDlSap,RG_RGU_SDU_DROP, datReq);
261          /* ADD Changes for Downlink UE Timing Optimization */
262 #ifdef LTEMAC_DLUE_TMGOPTMZ
263          /* Trying to send the prev successful PDU's 
264           * if present */
265          ret = rgROMUpdDlSfRemDataCnt(cell, sf);
266          if(ret == RFAILED)
267          {
268          RLOG0(L_INFO, "Dropping due to no failure of remCnt update");
269 #ifndef L2_OPTMZ
270             RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
271 #endif
272             /* Return from here as above functions found more datReq than expected*/
273             //RETVALUE(ret);
274          }
275 #endif
276          continue;
277       }
278
279       /* Merging the updation of statistics of SDUs with for loop below */ 
280
281       rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
282       schPst.event = 0;
283       boRpt.cellSapId  = cell->schInstMap.cellSapId;
284       boRpt.cellId  = datReq->cellId;
285
286       boRpt.rnti    = datReq->datReq[idx].rnti; 
287
288
289       /* Fill the DStaRsp struct and send it to scheduler */
290       for (idx1 = 0; idx1 < datReq->datReq[idx].nmbOfTbs; idx1++)
291       {
292          for(idx2 = 0; idx2 < datReq->datReq[idx].datReqTb[idx1].nmbLch; idx2++)
293          {
294             /* Updating dedicated SDUs received statistics without 
295                additional function above for optimization */
296             ue->rguDlSap->sapSts.numPduRcvd +=
297                datReq->datReq[idx].datReqTb[idx1].lchData[idx2].pdu.numPdu;
298
299             boRpt.lcId    = datReq->datReq[idx].datReqTb[idx1].lchData[idx2].lcId; 
300             boRpt.bo      = datReq->datReq[idx].datReqTb[idx1].lchData[idx2].boReport.bo;
301             boRpt.oldestSduArrTime 
302                = datReq->datReq[idx].datReqTb[idx1].lchData[idx2].boReport.oldestSduArrTime;
303             boRpt.staPduBo = datReq->datReq[idx].datReqTb[idx1].lchData[idx2].boReport.staPduBo;
304             
305             boRpt.setMaxUlPrio= datReq->datReq[idx].datReqTb[idx1].lchData[idx2].setMaxUlPrio;
306 #ifdef CCPU_OPT
307             boRpt.setMaxDlPrio= datReq->datReq[idx].datReqTb[idx1].lchData[idx2].boReport.staPduPrsnt;
308 #endif
309             RgMacSchDedBoUpdt(&schPst, &boRpt);
310          }
311       }
312
313       /* ADD Changes for Downlink UE Timing Optimization */
314 #ifdef LTEMAC_DLUE_TMGOPTMZ
315 //       sf->remDatReqCnt -= datReqFailCnt;
316       /*Presently this function is not returning RFAILED, thus not checking
317         for failure condition.*/
318       ret = rgROMUpdDlSfRemDataCnt(cell, sf);
319       if(ret == RFAILED)
320       {
321          RLOG0(L_INFO, "\n Dropping due to no failure of remCnt update(1) \n");
322 #ifndef L2_OPTMZ
323          RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
324 #endif
325          /* Return from here as above functions found more datReq than expected*/
326         // RETVALUE(ret);
327       }
328 #endif
329    } /* for loop for num of Ue per TTI*/
330
331 #endif
332    /* Data send successfully to PHY. lets retuns ROK*/
333    RETVALUE(ROK);
334 }  /* rgROMDedDatReq */
335
336
337 /**
338  * @brief Handler for DatReq received on RGU for a common logical channel.
339  *
340  * @details
341  *
342  *     Function : rgROMCmnDatReq
343  *     
344  *     This function shall invoke rgROMHndlCcchDatReq() if datReq is on CCCH
345  *     If not, it shall invoke rgROMHndlBcchPcchDatReq().
346  *     
347  *           
348  *  @param[in]  Inst        inst
349  *  @param[in]  RgRguCmnDatReq *datReq 
350  *  @return  S16
351  *      -# ROK 
352  *      -# RFAILED 
353  **/
354 #ifdef ANSI
355 PUBLIC S16 rgROMCmnDatReq
356 (
357 Inst            inst,
358 RgRguCmnDatReq *datReq
359 )
360 #else
361 PUBLIC S16 rgROMCmnDatReq(inst,datReq)
362 Inst            inst;
363 RgRguCmnDatReq *datReq;
364 #endif
365 {
366    RgCellCb    *cell;
367    RgErrInfo   err;
368    S16         ret;
369 /* ADD Changes for Downlink UE Timing Optimization */
370 #ifdef LTEMAC_DLUE_TMGOPTMZ
371    CmLteTimingInfo timingInfo;
372    RgDlSf   *sf;
373 #endif
374
375    TRC2(rgROMCmnDatReq)
376
377    ret = ROK;
378    err.errType = RGERR_ROM_CMNDATREQ;
379    if(((cell = rgCb[inst].cell) == NULLP)
380       ||(cell->cellId != datReq->cellId))
381    {
382 #if (ERRCLASS & ERRCLS_INT_PAR)
383       /* Handle Cell fetch failure */
384       RGLOGERROR(inst,ERRCLS_INT_PAR,ERG003,(ErrVal)datReq->cellId,
385                             "rgROMCmnDatReq(): Invalid cell Id");
386 #endif
387       err.errCause = RGERR_ROM_INV_CELL_ID;
388       /* Update stats */
389       if(cell != NULLP)
390       {
391          rgUpdtRguCmnSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP);
392       }
393       RETVALUE(RFAILED);
394    }
395
396    if (datReq->lcId == cell->dlCcchId)
397    {
398       ret = rgROMHndlCcchDatReq(cell, datReq, &err);
399
400       /*Get the timing Info*/
401       /* ADD Changes for Downlink UE Timing Optimization */
402 #ifdef LTEMAC_DLUE_TMGOPTMZ
403       timingInfo.slot = (U8)((datReq->transId >> 8) & 0XFF);
404       timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
405 #endif
406    } 
407    else
408    {
409       ret = rgROMHndlBcchPcchDatReq(cell, datReq, &err);
410
411       /*Get the timing Info*/
412       /* ADD Changes for Downlink UE Timing Optimization */
413 #ifdef LTEMAC_DLUE_TMGOPTMZ
414       timingInfo.slot = (U8)(datReq->transId & 0XFF);
415       timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
416 #endif
417    }
418
419    /* Update stats */
420    if (ret == RFAILED)
421    {
422       rgUpdtRguCmnSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP);
423    }
424    else
425    {
426       /* Update stats with number of SDUs received */
427       rgUpdtRguCmnSts(inst,cell->rguDlSap,RG_RGU_SDU_RCVD);
428    }
429
430    /* ADD Changes for Downlink UE Timing Optimization */
431 #ifdef LTEMAC_DLUE_TMGOPTMZ
432    RG_ARRAY_BOUND_CHECK(0, cell->subFrms, (timingInfo.slot % RG_NUM_SUB_FRAMES));
433    sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
434
435    ret = rgROMUpdDlSfRemDataCnt(cell, sf);
436    /*Added check for RFAILED as above function can return RFAILED*/
437 #endif
438
439    RETVALUE(ret);
440 }  /* rgROMCmnDatReq */
441
442 /**
443  * @brief Handler for DatReq received on RGU for CCCH.
444  *
445  * @details
446  *
447  *     Function : rgROMHndlCcchDatReq
448  *     
449  *     This function shall fetch the raCb with the given rnti and indicate msg4
450  *     arrival to RAM.
451  *     
452  *           
453  *  @param[in]  RgCellCb       *cell
454  *  @param[in]  RgRguCmnDatReq *datReq 
455  *  @param[out] RgErrInfo      *err
456  *  @return  S16
457  *      -# ROK 
458  *      -# RFAILED 
459  **/
460 #ifdef ANSI
461 PRIVATE S16 rgROMHndlCcchDatReq
462 (
463 RgCellCb       *cell,
464 RgRguCmnDatReq *datReq,
465 RgErrInfo      *err
466 )
467 #else
468 PRIVATE S16 rgROMHndlCcchDatReq(cell, datReq, err)
469 RgCellCb       *cell;
470 RgRguCmnDatReq *datReq;
471 RgErrInfo      *err;
472 #endif
473 {
474    Inst     inst = cell->macInst - RG_INST_START;
475    RgUeCb   *ue;
476    U8       hqPId;
477    RgDlHqProcCb *hqProc;
478    CmLteTimingInfo timingInfo;
479    RgDlSf   *sf;
480 #if (ERRCLASS & ERRCLS_DEBUG)
481    RgUstaDgn   dgn;      /* Alarm diagnostics structure */
482 #endif
483
484    TRC2(rgROMHndlCcchDatReq);
485
486
487    err->errType = RGERR_ROM_CMNDATREQ;
488
489    if ((ue = rgDBMGetUeCb(cell, datReq->u.rnti)) == NULLP)
490    {
491       if ((ue = rgDBMGetUeCbFromRachLst(cell, datReq->u.rnti)) == NULLP)
492       {
493    #if (ERRCLASS & ERRCLS_INT_PAR)
494          /* Handle Ue fetch failure */
495          RGLOGERROR(inst,ERRCLS_INT_PAR,ERG004,(ErrVal)datReq->u.rnti,
496                               "rgROMHndlCcchDatReq(): Invalid ue Id");
497    #endif
498          err->errCause = RGERR_ROM_INV_UE_ID;
499          RETVALUE(RFAILED);
500       }
501    }
502
503    timingInfo.slot = (U8)((datReq->transId >> 8) & 0XFF);
504    timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
505    sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
506
507    if( (sf->txDone == TRUE) ||
508        (!RG_TIMEINFO_SAME(sf->schdTime,timingInfo)))
509    {
510 #if (ERRCLASS & ERRCLS_DEBUG)
511       /* Transmission is already done for this slot. This is a delayed
512        * datReq. So discard */
513       rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
514       rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
515                               LRG_CAUSE_DELAYED_DATREQ, &dgn);
516 #endif
517       err->errCause = RGERR_ROM_DELAYED_DATREQ;
518       RETVALUE(RFAILED);
519    }
520
521    hqPId = (U8)(datReq->transId);
522    hqPId = hqPId >> 2;
523
524    /* get harq process and invoke DHM */
525    rgDHMGetHqProcFrmId(ue, hqPId, &hqProc);
526  
527    /* Changed for CR timer implementation*/
528    /* invoke DHM to process CCCH data */
529    if (rgDHMHndlCmnDatReq(inst,hqProc, datReq, err) == RFAILED)
530    {
531       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
532             "Handling of Data request in DHM failed RNTI:%d LCID:%d",
533             datReq->u.rnti,datReq->lcId);
534       /* Release First TB */
535       rgDHMRlsHqProcTB(cell, hqProc, 1);
536       /* err shall be filled in appropriately by DHM */
537       RETVALUE(RFAILED);
538    }
539  
540    RETVALUE(ROK); 
541 } /* rgROMHndlCcchDatReq */
542
543
544 /**
545  * @brief Handler for DatReq received on RGU for BCCH or PCCH.
546  *
547  * @details
548  *
549  *     Function : rgROMHndlBcchPcchDatReq
550  *     
551  *     This function shall store the buffer and time to transmit in lcCb.
552  *     
553  *           
554  *  @param[in]  RgCellCb       *cell
555  *  @param[in]  RgRguCmnDatReq *datReq 
556  *  @param[out] RgErrInfo      *err
557  *  @return  S16
558  *      -# ROK 
559  *      -# RFAILED 
560  **/
561 #ifdef ANSI
562 PRIVATE S16 rgROMHndlBcchPcchDatReq
563 (
564 RgCellCb       *cell,
565 RgRguCmnDatReq *datReq,
566 RgErrInfo      *err
567 )
568 #else
569 PRIVATE S16 rgROMHndlBcchPcchDatReq(cell, datReq, err)
570 RgCellCb       *cell;
571 RgRguCmnDatReq *datReq;
572 RgErrInfo      *err;
573 #endif
574 {
575    Inst            inst = cell->macInst - RG_INST_START;
576    RgPcchLcCb      *pcch;
577    /* Modified for SI Enhancement*/
578 #ifndef RGR_SI_SCH
579    RgBcchBchLcCb   *bch;
580    RgBcchDlschLcCb *bcch;
581 #endif/*RGR_SI_SCH*/
582    RgDlSf          *sf;
583    CmLteTimingInfo timingInfo;
584 #if (ERRCLASS & ERRCLS_DEBUG)
585    RgUstaDgn   dgn;      /* Alarm diagnostics structure */
586 #endif
587
588    TRC2(rgROMHndlBcchPcchDatReq);
589
590
591    timingInfo.slot = (U8)(datReq->transId & 0XFF);
592    timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
593    sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
594
595    if( (sf->txDone == TRUE) ||
596        (!RG_TIMEINFO_SAME(sf->schdTime,timingInfo)))
597    {
598 #if (ERRCLASS & ERRCLS_DEBUG)
599       /* Transmission is already done for this slot. This is a delayed
600        * datReq. So discard */
601       rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
602       rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
603                               LRG_CAUSE_DELAYED_DATREQ, &dgn);
604 #endif
605       err->errCause = RGERR_ROM_DELAYED_DATREQ;
606       RETVALUE(RFAILED);
607    }
608
609 #ifndef RGR_SI_SCH
610    bcch = rgDBMGetBcchOnDlsch(cell,datReq->lcId);
611    if (bcch )
612    {
613       /* Store BCCH-DLSCH data received in Scheduled slot */
614       sf->bcch.tb = datReq->pdu;
615
616       SCpyMsgMsg(datReq->pdu, RG_GET_MEM_REGION(rgCb[inst]),
617                RG_GET_MEM_POOL(rgCb[inst]), &bcch->tb);
618
619       RETVALUE(ROK);
620    }
621
622    bch = rgDBMGetBcchOnBch(cell);
623    if ((bch) && (bch->lcId == datReq->lcId))
624    {
625       /* Store BCH data received in Scheduled slot */
626       sf->bch.tb = datReq->pdu;
627       RETVALUE(ROK);
628    }
629 #endif/*RGR_SI_SCH*/
630
631    pcch = rgDBMGetPcch(cell);
632    if ((pcch) && (pcch->lcId == datReq->lcId))
633    {
634       /* Store PCCH-DLSCH data received in Scheduled slot */
635       sf->pcch.tb = datReq->pdu;
636       RETVALUE(ROK);
637    }
638
639    /* Handle lcCb fetch failure */
640    RGLOGERROR(inst,ERRCLS_INT_PAR,ERG005,(ErrVal)datReq->lcId,
641                   "rgROMHndlBcchPcchDatReq(): Invalid Lc Id");
642    err->errCause = RGERR_ROM_INV_LC_ID;
643
644    RETVALUE(RFAILED);
645 } /* rgROMHndlBcchPcchDatReq */
646
647 /**
648  * @brief Handler for StaRsp received on RGU for a dedicated logical channel.
649  *
650  * @details
651  *
652  *     Function : rgROMDedStaRsp
653  *     
654  *     This fucntion shall store the BO reported for the given logical
655  *     channel.
656  *     
657  *           
658  *  @param[in]  Inst        inst
659  *  @param[in]  RgRguDedStaRsp *staRsp 
660  *  @return  S16
661  *      -# ROK 
662  *      -# RFAILED 
663  **/
664 #ifdef ANSI
665 PUBLIC S16 rgROMDedStaRsp
666 (
667 Inst           inst,
668 RgRguDedStaRsp *staRsp
669 )
670 #else
671 PUBLIC S16 rgROMDedStaRsp(inst,staRsp)
672 Inst           inst;
673 RgRguDedStaRsp *staRsp;
674 #endif
675 {
676    RgCellCb   *cell;
677
678    /* Moving the error variables and assignments to available scope */
679
680    TRC2(rgROMDedStaRsp)
681
682    /* Avoiding memset, as the variables of this are getting 
683       initialized */
684
685
686    if(((cell = rgCb[inst].cell) != NULLP)
687       && (cell->cellId == staRsp->cellId))
688    {
689             Pst        schPst;
690 #ifdef UNUSED_VAR
691     RgInfDedBoRpt boRpt
692          boRpt.cellSapId  = cell->schInstMap.cellSapId;
693     boRpt.cellId  = staRsp->cellId;
694          boRpt.rnti    = staRsp->rnti; 
695     boRpt.lcId    = staRsp->lcId; 
696          boRpt.bo      = staRsp->boReport.bo;
697     boRpt.oldestSduArrTime = staRsp->boReport.oldestSduArrTime;
698     boRpt.staPduBo = staRsp->boReport.staPduBo;
699     boRpt.oldestSduArrTime = staRsp->boReport.oldestSduArrTime;
700 #endif
701                                 rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
702             schPst.event = 0;
703             //TODO: commented for compilation without SCH RgMacSchDedBoUpdt(&schPst, &boRpt);
704             RETVALUE(ROK);
705    }
706    RLOG_ARG2(L_ERROR,DBG_CELLID,staRsp->cellId,"Invalid cell for CRNTI:%d LCID:%d ",
707              staRsp->rnti,staRsp->lcId);
708
709    RETVALUE(RFAILED);
710 }  /* rgROMDedStaRsp */
711
712 S16 RgMacSchBrdcmDedBoUpdtReq(
713 Inst inst,
714 CmLteCellId cellId,
715 CmLteRnti rnti, 
716 CmLteLcId lcId, 
717 S32 bo 
718 )
719 {
720
721   RgCellCb   *cell;
722   //if ((cell = rgDBMGetCellCb(cellId)) != NULLP)
723   if (((cell = rgCb[inst].cell) != NULLP) &&
724         (cell->cellId == cellId))
725  {
726      Pst        schPst;
727 #ifdef UNUSED_VAR
728     RgInfDedBoRpt  boRpt;
729     boRpt.cellSapId  = cell->schInstMap.cellSapId;
730     boRpt.cellId     = cellId;
731     boRpt.rnti       = rnti; 
732     boRpt.lcId       = lcId; 
733     boRpt.bo         = bo;
734 #endif
735      rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
736      schPst.event = 0;
737      //TODO: commented for compilation without SCH RgMacSchDedBoUpdtReq (&schPst,&boRpt);
738   }
739   RETVALUE(ROK);
740 }
741 /**
742  * @brief Handler for StaRsp received on RGU for a common logical channel.
743  *
744  * @details
745  *
746  *     Function : rgROMCmnStaRsp
747  *     
748  *     This fucntion shall invoke rgROMHndlCcchStaRsp() for status response on
749  *     CCCH and shall invoke rgROMHndlBcchPcchStaRsp() for status response on
750  *     BCCH or PCCH.
751  *     
752  *           
753  *  @param[in]  Inst        inst
754  *  @param[in]  RgRguCmnStaRsp *staRsp 
755  *  @return  S16
756  *      -# ROK 
757  *      -# RFAILED 
758  **/
759 #ifdef ANSI
760 PUBLIC S16 rgROMCmnStaRsp
761 (
762 Inst            inst, 
763 RgRguCmnStaRsp *staRsp
764 )
765 #else
766 PUBLIC S16 rgROMCmnStaRsp(inst,staRsp)
767 Inst            inst;
768 RgRguCmnStaRsp *staRsp;
769 #endif
770 {
771    RgCellCb   *cell;
772    RgErrInfo  err;
773
774    TRC2(rgROMCmnStaRsp)
775
776
777    if(((cell = rgCb[inst].cell) == NULLP)
778       || (cell->cellId != staRsp->cellId))
779    {
780       /* Handle Cell fetch failure */
781       RLOG_ARG2(L_ERROR,DBG_CELLID,staRsp->cellId,
782                 "Invalid cell for CRNTI:%d LCID:%d",staRsp->u.rnti,staRsp->lcId);
783       err.errType = RGERR_ROM_CMNSTARSP;
784       err.errCause = RGERR_ROM_INV_CELL_ID;
785       RETVALUE(RFAILED);
786    }
787
788    /* handle status response on CCCH */
789    if(staRsp->lcId == cell->dlCcchId)
790    {
791       rgROMHndlCcchStaRsp(cell, staRsp, &err); 
792    }
793    else
794    {
795       rgROMHndlBcchPcchStaRsp(cell, staRsp, &err); 
796    }
797    
798    RETVALUE(ROK);
799 }  /* rgROMCmnStaRsp */
800
801 #ifdef LTE_L2_MEAS
802
803 /**
804  * @brief Handler for Request received on RGU for a UL Throughput measurement
805  * enabled logical channel.
806  *
807  * @details
808  *
809  *     Function :rgROML2MUlThrpMeasReq 
810  *     
811  *     This function shall store the L2M UL Throughput Measurement status  information 
812  *     for the given logical channel.
813  *     
814  *           
815  *  @param[in]  Inst        inst
816  *  @param[in]  RgRguL2MUlThrpMeasReq *measReq 
817  *  @return  S16
818  *      -# ROK 
819  *      -# RFAILED 
820  **/
821 #ifdef ANSI
822 PUBLIC S16 rgROML2MUlThrpMeasReq 
823 (
824 Inst                  inst,
825 RgRguL2MUlThrpMeasReq *measReq
826 )
827 #else
828 PUBLIC S16 rgROML2MUlThrpMeasReq(inst,measReq)
829 Inst                  inst;
830 RgRguL2MUlThrpMeasReq *measReq;
831 #endif
832 {
833    RgCellCb   *cell;
834    RgUeCb     *ue;
835    U8         lcgId;
836    U8         loop;
837    TRC2(rgROML2MUlThrpMeasReq)
838
839
840
841    if(((cell = rgCb[inst].cell) != NULLP)
842       &&(cell->cellId == measReq->cellId))
843    {
844       if ((ue = rgDBMGetUeCb(cell, measReq->rnti)) != NULLP)
845       {
846          for(loop=0; loop<measReq->numLcId;loop++)
847          {
848             if ((rgDBMGetUlDedLcCb(ue, measReq->lcId[loop])) != NULLP)
849             {
850                ue->ul.lcCb[measReq->lcId[loop]].measOn = measReq->enbMeas;
851                if(ue->ul.lcCb[measReq->lcId[loop]].measOn == FALSE)
852                {
853                   lcgId=ue->ul.lcCb[measReq->lcId[loop]].lcgId;
854                   ue->ul.lcgArr[lcgId].lcgBsInfo.outStndngBs = 0;
855                   ue->ul.lcgArr[lcgId].lcgBsInfo.firstDatSegRcvd = FALSE;
856                }
857             }
858          }
859          RETVALUE(ROK);
860       }
861    }
862    RLOG_ARG1(L_ERROR,DBG_CELLID,measReq->cellId,"Invalid cell CRNTI:%d",
863              measReq->rnti);
864    RETVALUE(RFAILED);
865 }  /* rgROML2MUlThrpMeasReq */
866
867 #endif
868
869 /**
870  * @brief Handler for StaRsp received on RGU for CCCH.
871  *
872  * @details
873  *
874  *     Function : rgROMHndlCcchStaRsp
875  *     
876  *     This function shall fetch the raCb with the given RNTI and ask RAM to
877  *     update BO. 
878  *     
879  *           
880  *  @param[in]  RgCellCb       *cell
881  *  @param[in]  RgRguCmnStaRsp *staRsp
882  *  @param[out] RgErrInfo      *err
883  *  @return  S16
884  *      -# ROK 
885  *      -# RFAILED 
886  **/
887 #ifdef ANSI
888 PRIVATE S16 rgROMHndlCcchStaRsp
889 (
890 RgCellCb       *cell,
891 RgRguCmnStaRsp *staRsp,
892 RgErrInfo      *err
893 )
894 #else
895 PRIVATE S16 rgROMHndlCcchStaRsp(cell, staRsp, err)
896 RgCellCb       *cell;
897 RgRguCmnStaRsp *staRsp;
898 RgErrInfo      *err;
899 #endif
900 {
901    Pst      schPst;
902    Inst     macInst = cell->macInst - RG_INST_START;
903    //RgInfCmnBoRpt boRpt;
904
905    TRC2(rgROMHndlCcchStaRsp);
906 #ifdef UNUSED_VAR
907    RgInfCmnBoRpt boRpt;
908    boRpt.cellSapId  = cell->schInstMap.cellSapId;
909    boRpt.cellId  = staRsp->cellId;
910    boRpt.u.rnti    = staRsp->u.rnti; 
911    boRpt.lcId    = staRsp->lcId; 
912    boRpt.lcType  = staRsp->lcType; 
913    boRpt.bo      = staRsp->bo;
914 #endif
915    rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
916    //TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
917
918    RETVALUE(ROK);
919 } /* rgROMHndlCcchStaRsp */
920
921
922 /**
923  * @brief Handler for StaRsp received on RGU for BCCH or PCCH.
924  *
925  * @details
926  *
927  *     Function : rgROMHndlBcchPcchStaRsp
928  *     
929  *     This function shall store the buffer and time to transmit in lcCb.
930  *     
931  *           
932  *  @param[in]  RgCellCb       *cell
933  *  @param[in]  RgRguCmnStaRsp *staRsp
934  *  @param[out] RgErrInfo      *err
935  *  @return  S16
936  *      -# ROK 
937  *      -# RFAILED 
938  **/
939 #ifdef ANSI
940 PRIVATE S16 rgROMHndlBcchPcchStaRsp
941 (
942 RgCellCb       *cell,
943 RgRguCmnStaRsp *staRsp,
944 RgErrInfo      *err
945 )
946 #else
947 PRIVATE S16 rgROMHndlBcchPcchStaRsp(cell, staRsp, err)
948 RgCellCb       *cell;
949 RgRguCmnStaRsp *staRsp;
950 RgErrInfo      *err;
951 #endif
952 {
953    Pst      schPst;
954    //RgInfCmnBoRpt boRpt;
955    Inst     macInst = cell->macInst - RG_INST_START;
956
957    TRC2(rgROMHndlBcchPcchStaRsp);
958    cmMemset((U8*)&schPst, (U8)0, sizeof(Pst));
959
960    if (rgDBMChkCmnLcCb(cell, staRsp->lcId) != ROK)
961    {
962       /* Handle lcCb fetch failure */
963       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid LCID:%d",staRsp->lcId);
964       err->errCause = RGERR_ROM_INV_LC_ID;
965       RETVALUE(RFAILED);
966    }
967    /* MS_WORKAROUND : This is to ensure that the queue for BCH is not filled with old BO requests :
968          This assumes that BO is not received more than 4 frames in advance from the enodeb application */
969    if (cell->bcchBchInfo.lcId == staRsp->lcId)
970    {
971       U16 nextBchSfn;
972
973       nextBchSfn = (cell->crntTime.sfn + 4 - (cell->crntTime.sfn%4)) % RG_MAX_SFN;
974       if ((staRsp->u.timeToTx.sfn != nextBchSfn) ||
975          ((staRsp->u.timeToTx.sfn == cell->crntTime.sfn) && (cell->crntTime.slot >= 7)))
976       {
977         RETVALUE(ROK);
978       }
979    }
980 /*
981    boRpt.cellSapId     = cell->schInstMap.cellSapId;
982    boRpt.cellId     = staRsp->cellId;
983    boRpt.u.timeToTx = staRsp->u.timeToTx; 
984    boRpt.lcId       = staRsp->lcId; 
985    boRpt.lcType     = staRsp->lcType; 
986    boRpt.bo         = staRsp->bo;*/     
987 #ifdef EMTC_ENABLE
988   if(cell->emtcEnable)
989   {
990      if(boRpt.lcType == CM_LTE_LCH_PCCH)
991      {
992         boRpt.emtcDIReason = staRsp->emtcDiReason;
993         boRpt.pnb = staRsp->pnb;
994      }
995   }
996 #endif
997    rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
998    //TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
999
1000    RETVALUE(ROK);
1001 } /* rgROMHndlBcchPcchStaRsp */
1002
1003 /* ADD Changes for Downlink UE Timing Optimization */
1004 #ifdef LTEMAC_DLUE_TMGOPTMZ
1005 /**
1006  * @brief Handler for updating DL SF information on receiving
1007  *  DL dedicated data, CCCH, BCCH/PCCH data request.
1008  *
1009  * @details
1010  *
1011  *     Function : rgROMUpdDLSfRemDataCnt
1012  *     
1013  *           
1014  *  @param[in]  RgCellCb       *cell
1015  *  @param[in]  RgDlSf         *dlSf;
1016  *  @return  S16
1017  *      -# ROK 
1018  *      -# RFAILED 
1019  **/
1020 #ifdef ANSI
1021 PRIVATE S16 rgROMUpdDlSfRemDataCnt
1022 (
1023 RgCellCb       *cellCb,
1024 RgDlSf         *dlSf
1025 )
1026 #else
1027 PRIVATE S16 rgROMUpdDlSfRemDataCnt(cellCb, dlSf)
1028 RgCellCb       *cellCb;
1029 RgDlSf         *dlSf;
1030 #endif
1031 {
1032    RgErrInfo            err;
1033    //Inst                 inst = cellCb->macInst - RG_INST_START;
1034
1035    TRC2(rgROMUpdDlSfRemDataCnt);
1036
1037
1038    if(!dlSf->remDatReqCnt)
1039    {
1040        /*This is an error scenario of RLC generating more data          
1041         * request than the allocation. Do nothing for this. */
1042       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
1043             "RX new data while remDatReqCnt is 0 for cell");
1044       RETVALUE(RFAILED);
1045    }
1046
1047    /*Decrement the remaining data request to be received countter
1048      for this SF.
1049      Check if this was the last pending data request for this DL SF.*/
1050     /* Fix[ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled 
1051      RLC-MAC */
1052    if((0 == --dlSf->remDatReqCnt) && !(dlSf->txDone) &&
1053       (RG_TIMEINFO_SAME(cellCb->crntTime, dlSf->schdTime)) && (dlSf->statIndDone))
1054    {
1055       /*Check if we have already received a TTI for this Data,
1056         if that is the case then we need to send TFU Data request 
1057         to PHY */
1058
1059       if (ROK != rgTOMUtlProcDlSf (dlSf, cellCb, &err))
1060       {
1061          RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
1062                "Unable to process downlink slot for cell");
1063          err.errType = RGERR_ROM_DEDDATREQ;
1064       }
1065
1066       /* Mark this frame as sent */
1067       dlSf->txDone = TRUE;
1068    }
1069
1070    RETVALUE(ROK);
1071 } /* rgROMUpdDlSfRemDataCnt*/
1072 #endif
1073
1074 /**********************************************************************
1075  
1076          End of file
1077 **********************************************************************/