Addressed comments in lower Mac
[o-du/l2.git] / src / 5gnrmac / rg_uim.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_uim.c 
28   
29 **********************************************************************/
30
31 /** @file rg_uim.c.
32 @brief This module acts as an interface handler for upper interface and 
33 manages Pst and Sap related information for upper interface APIs.
34 */
35
36 static const char* RLOG_MODULE_NAME="MAC";
37 static int RLOG_MODULE_ID=4096;
38 static int RLOG_FILE_ID=178;
39
40 /* header include files -- defines (.h) */
41
42 /* header/extern include files (.x) */
43 /* header include files (.h) */
44 #include "envopt.h"        /* environment options */
45 #include "envdep.h"        /* environment dependent */
46 #include "envind.h"        /* environment independent */
47 #include "gen.h"           /* general layer */
48 #include "ssi.h"           /* system services */
49 #include "cm5.h"           /* common timers defines */
50 #include "cm_hash.h"       /* common hash list defines */
51 #include "cm_llist.h"      /* common linked list defines */
52 #include "cm_mblk.h"       /* memory management */
53 #include "cm_tkns.h"       /* common tokens */
54 #include "cm_lte.h"
55 #include "crg.h"           /* CRG defines */
56 #include "lrg.h"           /* layer management defines for LTE-MAC */
57 #include "tfu.h"
58 #include "rgu.h"
59 #include "rg_sch_inf.h"
60 #include "rg_env.h"        /* customizable defines and macros for MAC */
61 #include "rg.h"            /* defines and macros for MAC */
62 #include "rg_err.h"        /* RG error defines */
63
64 /* header/extern include files (.x) */
65
66 #include "gen.x"           /* general layer typedefs */
67 #include "ssi.x"           /* system services typedefs */
68 #include "cm5.x"           /* common timers */
69 #include "cm_hash.x"       /* common hash list */
70 #include "cm_lib.x"        /* common library */
71 #include "cm_llist.x"      /* common linked list */
72 #include "cm_mblk.x"       /* memory management */
73 #include "cm_tkns.x"       /* common tokens */
74 #include "cm_lte.x"
75 #include "crg.x"           /* CRG types */
76 #include "lrg.x"           /* layer management typedefs for MAC */
77 #include "tfu.x"
78 #include "rgu.x"
79 #include "rg_sch_inf.x"
80 #include "rg_prg.x"        /* PRG interface typedefs*/
81 #include "du_app_mac_inf.h"
82 #include "rg.x"            /* typedefs for MAC */
83
84 #include "ss_rbuf.h"
85 #include "ss_rbuf.x"
86
87 /* local defines */
88
89 /* local typedefs */
90  
91 /* local externs */
92  
93 /* forward references */
94
95 #if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
96 PUBLIC S16 rgBatchProc(Void);
97 #endif
98 PUBLIC U8 rgRguDlSap;
99 PUBLIC U8 rgRguUlSap;
100 /**
101  * @brief Handler for Bind request.
102  *
103  * @details
104  *
105  *     Function : RgUiRguBndReq
106  *     
107  *     This function handles the bind request from MAC Service User.
108  *     
109  *           
110  *  @param[in]  Pst  *pst
111  *  @param[in]  SuId suId
112  *  @param[in]  SpId spId
113  *  @return  S16
114  *      -# ROK 
115  *      -# RFAILED 
116  **/
117 #ifdef ANSI
118 PUBLIC S16 RgUiRguBndReq
119 (
120 Pst  *pst,
121 SuId suId,
122 SpId spId
123 )
124 #else
125 PUBLIC S16 RgUiRguBndReq(pst, suId, spId)
126 Pst  *pst;
127 SuId suId;
128 SpId spId;
129 #endif
130 {
131    Inst      inst; 
132    S16       ret = ROK;
133    Pst       tmpPst;   /* Temporary Post Structure */
134    RgUstaDgn dgn;      /* Alarm diagnostics structure */
135
136    TRC3(RgUiRguBndReq)
137
138
139    RG_IS_INST_VALID(pst->dstInst);
140    inst = pst->dstInst - RG_INST_START;
141
142    tmpPst.prior       = pst->prior;
143    tmpPst.route       = pst->route;
144    tmpPst.selector    = pst->selector;
145    tmpPst.region      = rgCb[inst].rgInit.region;
146    tmpPst.pool        = rgCb[inst].rgInit.pool;
147    tmpPst.srcProcId   = rgCb[inst].rgInit.procId;
148    tmpPst.srcEnt      = rgCb[inst].rgInit.ent;
149    tmpPst.srcInst     = rgCb[inst].rgInit.inst;
150    tmpPst.event       = EVTNONE;
151    tmpPst.dstProcId   = pst->srcProcId;
152    tmpPst.dstEnt      = pst->srcEnt;
153    tmpPst.dstInst     = pst->srcInst;
154
155    if(spId == rgCb[inst].rguSap[spId].sapCfg.spId)
156    {
157       /* Check the state of the SAP */
158       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
159       {
160          case LRG_NOT_CFG: /* SAP Not configured */
161             RGDBGINFO(inst,(rgPBuf(inst), "SAP Not Configured\n"));
162             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM); 
163             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
164                   LCM_CAUSE_INV_SAP, &dgn);
165             RLOG0(L_DEBUG,"SAP Not Configured");
166             ret = RgUiRguBndCfm(&tmpPst, suId, CM_BND_NOK);
167             break;
168          case LRG_UNBND: /* SAP is not bound */
169             RLOG0(L_DEBUG,"SAP Not yet bound");
170             rgCb[inst].rguSap[spId].sapSta.sapState = LRG_BND;
171             rgCb[inst].rguSap[spId].sapCfg.suId = suId;
172             /* Send Bind Confirm with status as SUCCESS */
173             /*T2K - Passing spId as it is required to access the SAP CB*/
174             ret = rgUIMRguBndCfm(inst,spId, CM_BND_OK);
175             /* Indicate to Layer manager */ 
176             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM); 
177             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_EVENT_RGUSAP_ENB,
178                   LCM_CAUSE_UNKNOWN, &dgn);
179             break;
180          case LRG_BND: /* SAP is already bound*/
181             RLOG0(L_DEBUG,"SAP already bound");
182             /*T2K - Passing spId as it is required to access the SAP CB*/
183             ret = rgUIMRguBndCfm(inst,spId, CM_BND_OK);
184             break;
185          default: /* Should Never Enter here */
186 #if (ERRCLASS & ERRCLS_ADD_RES)      
187             RGLOGERROR(inst,ERRCLS_INT_PAR, ERG008, (ErrVal)rgCb[inst].rguSap[spId].sapSta.sapState,
188                   "Invalid SAP State:RgUiRguBndReq failed\n");
189 #endif
190             /*T2K - Passing spId as it is required to access the SAP CB*/
191             ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
192             break;
193       }
194    }
195    else
196    {
197 #if (ERRCLASS & ERRCLS_ADD_RES)      
198       RGLOGERROR(inst,ERRCLS_INT_PAR, ERG009, (ErrVal)rgCb[inst].rguSap[spId].sapCfg.spId,
199             "Invalid SAP Id:RgUiRguBndReq failed\n");
200 #endif
201       /*T2K - Passing spId as it is required to access the SAP CB*/
202       ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
203    }
204    RETVALUE(ret);
205 }  /* RgUiRguBndReq */
206
207
208 /**
209  * @brief Handler for Unbind request.
210  *
211  * @details
212  *
213  *     Function : RgUiRguUbndReq
214  *     
215  *     This function handles the unbind request from MAC Service User.
216  *     
217  *           
218  *  @param[in]  Pst    *pst
219  *  @param[in]  SpId   spId
220  *  @param[in]  Reason reason
221  *  @return  S16
222  *      -# ROK 
223  *      -# RFAILED 
224  **/
225 #ifdef ANSI
226 PUBLIC S16 RgUiRguUbndReq
227 (
228 Pst    *pst,
229 SpId   spId,
230 Reason reason
231 )
232 #else
233 PUBLIC S16 RgUiRguUbndReq(pst, spId, reason)
234 Pst    *pst;
235 SpId   spId;
236 Reason reason;
237 #endif
238 {
239    Inst      inst;
240    TRC3(RgUiRguUbndReq)
241    
242
243    RG_IS_INST_VALID(pst->dstInst);
244    inst = pst->dstInst - RG_INST_START;
245    /* SAP Id validation */
246    if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
247    {
248       switch(rgCb[inst].rguSap[spId].sapSta.sapState)
249       {
250          case LRG_BND: /* SAP is already bound*/
251             RLOG0(L_DEBUG,"SAP already bound");
252             /* setting SAP state to UN BOUND */
253             rgCb[inst].rguSap[spId].sapSta.sapState = LRG_UNBND;
254             break;
255          default:
256 #if (ERRCLASS & ERRCLS_ADD_RES)      
257      RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguUbndReq failed",
258                   rgCb[inst].rguSap[spId].sapSta.sapState);
259        
260 #endif
261             break;
262       }
263    }
264    else
265    {
266 #if (ERRCLASS & ERRCLS_ADD_RES)      
267       RGLOGERROR(inst,ERRCLS_INT_PAR, ERG011, (ErrVal)rgCb[inst].rguSap[spId].sapCfg.spId,
268             "Invalid SAP Id:RgUiRguUbndReq failed\n");
269 #endif
270       RETVALUE(RFAILED);
271    }
272    RETVALUE(ROK);
273 }  /* RgUiRguUbndReq */
274 /**
275  * @brief API for sending bind confirm from MAC to RLC
276  *
277  * @details
278  *
279  *     Function: rgUIMRguBndCfm
280  *     
281  *     This API is invoked to send bind confirm from MAC to RLC.
282  *     This API fills in Pst structure and SAP Ids and invokes 
283  *     bind confirm API towards RLC.
284  *           
285  *  @param[in] Inst        inst
286  *  @param[in]  SuId          suId
287  *  @param[in]  U8            status
288  *  @return  S16
289  *      -# ROK 
290  *      -# RFAILED 
291  **/
292 #ifdef ANSI
293 PUBLIC S16 rgUIMRguBndCfm
294 (
295 Inst inst,
296 SpId spId,
297 U8 status
298 )
299 #else
300 PUBLIC S16 rgUIMRguBndCfm(inst,spId, status)
301 Inst          inst;
302 SpId          spId;
303 U8            status;
304 #endif
305 {
306    S16  ret = ROK;
307    
308    TRC2(rgUIMRguBndCfm)
309    
310
311    ret = RgUiRguBndCfm(&rgCb[inst].rguSap[spId].sapCfg.sapPst, 
312                       rgCb[inst].rguSap[spId].sapCfg.suId, status);
313    if (ret != ROK)
314    {
315       
316       RLOG0(L_ERROR,"RgUiRguBndCfm Failed ");
317       RETVALUE(ret);
318    }
319    RETVALUE(ret);
320 }  /* rgUIMRguBndCfm*/
321
322
323 /**
324  * @brief Handler for dedicated DatReq from RGU
325  *
326  * @details
327  *
328  *     Function : RgUiRguDDatReq
329  *     
330  *     This function validates SAP and invokes ROM for further processing
331  *     
332  *  @param[in]  Pst             *pst 
333  *  @param[in]  SpId            spId 
334  *  @param[in]  RguDDatReqInfo  *datReq
335  *  @return  S16
336  *      -# ROK 
337  *      -# RFAILED 
338  **/
339 #ifdef ANSI
340 PUBLIC S16 RgUiRguDDatReq
341 (
342 Pst             *pst,
343 SpId            spId,
344 RguDDatReqInfo  *datReq
345 )
346 #else
347 PUBLIC S16 RgUiRguDDatReq(pst, spId, datReq)
348 Pst             *pst;
349 SpId            spId;
350 RguDDatReqInfo  *datReq;
351 #endif
352 {
353    S16   ret = ROK;
354    Inst  inst;
355 #ifndef NO_ERRCLS 
356    U32   id;
357    U32   id1;
358    U32   id2;
359    U32   id3;
360 #endif
361    
362    TRC3(RgUiRguDDatReq)
363
364
365    RG_IS_INST_VALID(pst->dstInst);
366    inst = pst->dstInst - RG_INST_START;
367 #ifndef NO_ERRCLS
368    if (datReq == NULLP)
369    {
370       RLOG0(L_ERROR,"Input Message Buffer is NULL");
371       RETVALUE(RFAILED);
372    }
373    
374    if(rgCb[inst].rguSap[spId].sapCfg.spId == spId)
375    {
376       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
377       {
378          case LRG_BND: /* SAP is bound */
379             RLOG0(L_DEBUG,"SAP is already bound");
380             break;
381          default: /* Should never reach here */
382 #if (ERRCLASS & ERRCLS_ADD_RES)      
383             RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguDDatReq failed",
384                   rgCb[inst].rguSap[spId].sapSta.sapState);
385 #endif
386 #ifndef L2_OPTMZ
387             for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
388             {
389                RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[id3]);
390             }
391 #endif
392             RETVALUE(RFAILED);
393       }
394    }
395    else
396    {
397 #if (ERRCLASS & ERRCLS_ADD_RES)      
398       RGLOGERROR(inst,ERRCLS_INT_PAR, ERG013, (ErrVal)spId,
399             "Invalid SAP Id:RgUiRguDDatReq failed\n");
400 #endif
401 #ifndef L2_OPTMZ
402       for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
403       {
404          RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[id3]);
405       }
406 #endif
407       RETVALUE(RFAILED);
408    }
409
410    /* Update RGU SAP statistics for received sdu count */
411    /*ccpu00118201 - ADD - Send trace only when its enabled*/
412    if(rgCb[inst].rgInit.trc)
413    {
414       for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
415       {
416          RguDDatReqPerUe *datReqPerUe = &datReq->datReq[id3];
417          for (id = 0; id < datReqPerUe->nmbOfTbs; id++)
418          {
419             for (id1 = 0; id1 < datReqPerUe->datReqTb[id].nmbLch; id1++)
420             {
421                /* rgCb.rguSap.sapSts.numPduRcvd is updated by 
422                 * rgROMDedDatReq -> rgUpdtRguDedSts function
423                 * So numPduRcvd updation is commented here */
424                /* rgCb.rguSap.sapSts.numPduRcvd +=
425                   datReq->datReqTb[id].lchData[id1].pdu.numPdu; */
426                for (id2 = 0; id2 < datReqPerUe->datReqTb[id].lchData[id1].pdu.numPdu; id2++)
427                {
428                   RG_SEND_TRC_IND(inst,datReqPerUe->datReqTb[id].
429                         lchData[id1].pdu.mBuf[id2], EVTRGUDDATREQ);
430                }
431             }
432          }
433       }
434    }
435 #endif
436
437    /* Call Ownership module for further processing */
438    ret = rgROMDedDatReq(inst,datReq);
439     SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,sizeof(RguDDatReqInfo), SS_SHARABLE_MEMORY);
440    datReq = NULLP;
441    RETVALUE(ret);
442 }  /* RgUiRguDDatReq */
443
444
445 /**
446  * @brief Handler for common DatReq from RGU
447  *
448  * @details
449  *
450  *     Function : RgUiRguCDatReq
451  *     
452  *     This function validates SAP invokes ROM for further processing
453  *     
454  *  @param[in]  Pst             *pst 
455  *  @param[in]  SpId            spId 
456  *  @param[in]  RguCDatReqInfo  *datReq
457  *  @return  S16
458  *      -# ROK 
459  *      -# RFAILED 
460  **/
461 #ifdef ANSI
462 PUBLIC S16 RgUiRguCDatReq
463 (
464 Pst             *pst,
465 SpId            spId,
466 RguCDatReqInfo  *datReq
467 )
468 #else
469 PUBLIC S16 RgUiRguCDatReq(pst, spId, datReq)
470 Pst             *pst;
471 SpId            spId;
472 RguCDatReqInfo  *datReq;
473 #endif
474 {
475    Inst  inst;
476    S16   ret = ROK;
477    
478    TRC3(RgUiRguCDatReq)
479
480
481    RG_IS_INST_VALID(pst->dstInst);
482    inst = pst->dstInst - RG_INST_START;
483 #ifndef NO_ERRCLS
484    if (datReq == NULLP)
485    {
486       RLOG0(L_ERROR,"Input Message Buffer is NULL");
487       RETVALUE(RFAILED);
488    }
489    
490    if(rgCb[inst].rguSap[spId].sapCfg.spId == spId)
491    {
492       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
493       {
494          case LRG_BND: /* SAP is bound */
495             RLOG0(L_DEBUG,"SAP is already bound");
496             break;
497          default: /* Should never reach here */
498 #if (ERRCLASS & ERRCLS_ADD_RES)      
499             RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguCDatReq failed",
500                   rgCb[inst].rguSap[spId].sapSta.sapState);
501 #endif
502             RETVALUE(RFAILED);
503       }
504    }
505    else
506    {
507 #if (ERRCLASS & ERRCLS_ADD_RES)      
508       RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguCDatReq failed ",spId);
509 #endif
510       RETVALUE(RFAILED);
511    }
512 #endif
513
514    /* Update RGU SAP statistics for received sdu count */
515    /* rgCb.rguSap.sapSts.numPduRcvd is updated by 
516     * rgROMCmnDatReq ->rgUpdtRguCmnSts function
517     * So numPduRcvd updation is commented here */
518    /* rgCb.rguSap.sapSts.numPduRcvd++; */
519
520    ret = rgROMCmnDatReq(inst,datReq);
521    /*ccpu00118201 - ADD - Send trace only when its enabled*/
522    if(rgCb[inst].rgInit.trc)
523    {
524       RG_SEND_TRC_IND(inst,datReq->pdu, EVTRGUCDATREQ);
525    }
526    if (ret == RFAILED)
527    {
528       RG_DROP_RGUCDATREQ_MBUF(datReq);
529    }
530    ret = SPutStaticBuffer(pst->region, pst->pool,(Data *)datReq,sizeof(RguCDatReqInfo) , SS_SHARABLE_MEMORY);
531    datReq = NULLP;
532    RETVALUE(ret);
533 }  /* RgUiRguCDatReq */
534
535
536 /**
537  * @brief Handler for dedicated StaRsp from RGU
538  *
539  * @details
540  *
541  *     Function : RgUiRguDStaRsp
542  *     
543  *     This function validates SAP and invokes ROM for further processing
544  *           
545  *  @param[in]  Pst             *pst 
546  *  @param[in]  SpId            spId 
547  *  @param[in]  RguDStaRspInfo  *staRsp
548  *  @return  S16
549  *      -# ROK 
550  *      -# RFAILED 
551  **/
552 #ifdef ANSI
553 PUBLIC S16 RgUiRguDStaRsp
554 (
555 Pst             *pst,
556 SpId            spId,
557 RguDStaRspInfo  *staRsp
558 )
559 #else
560 PUBLIC S16 RgUiRguDStaRsp(pst, spId, staRsp)
561 Pst             *pst;
562 SpId            spId;
563 RguDStaRspInfo  *staRsp;
564 #endif
565 {
566    Inst  inst;
567
568    S16              ret       = ROK;
569    VOLATILE U32     startTime = 0;
570
571    TRC3(RgUiRguDStaRsp)
572
573    RG_IS_INST_VALID(pst->dstInst);
574    inst = pst->dstInst - RG_INST_START;
575    /*starting Task*/
576    SStartTask(&startTime, PID_MAC_STA_RSP);
577
578    ret = rgROMDedStaRsp(inst,staRsp);
579    if (ret != ROK)
580    {
581       RLOG_ARG0(L_ERROR,DBG_CELLID,staRsp->cellId,
582                 "Processing Of Status Response Failed");
583    }
584
585
586    /*stoping Task*/
587    SStopTask(startTime, PID_MAC_STA_RSP);
588    RETVALUE(ret);
589 }  /* RgUiRguDStaRsp */
590
591
592 /**
593  * @brief Handler for common StaRsp from RGU
594  *
595  * @details
596  *
597  *     Function : RgUiRguCStaRsp
598  *     
599  *     This function validates SAP and invokes ROM 
600  *     for further processing
601  *     
602  *           
603  *  @param[in]  Pst             *pst 
604  *  @param[in]  SpId            spId 
605  *  @param[in]  RguCStaRspInfo  *staRsp
606  *  @return  S16
607  *      -# ROK 
608  *      -# RFAILED 
609  **/
610 #ifdef ANSI
611 PUBLIC S16 RgUiRguCStaRsp
612 (
613 Pst             *pst,
614 SpId            spId,
615 RguCStaRspInfo  *staRsp
616 )
617 #else
618 PUBLIC S16 RgUiRguCStaRsp(pst, spId, staRsp)
619 Pst             *pst;
620 SpId            spId;
621 RguCStaRspInfo  *staRsp;
622 #endif
623 {
624    Inst  inst;
625    S16   ret = ROK;
626
627    TRC3(RgUiRguCStaRsp)
628    
629
630    RG_IS_INST_VALID(pst->dstInst);
631    inst = pst->dstInst - RG_INST_START;
632 #ifndef NO_ERRCLS
633    if (staRsp == NULLP)
634    {
635       RLOG0(L_ERROR,"Input Response Buffer is NULL");
636       RETVALUE(RFAILED);
637    }
638
639    if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
640    {
641       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
642       {
643          case LRG_BND: /* SAP is bound */
644             RLOG0(L_DEBUG,"SAP is already bound");
645             break;
646          default: /* Should never reach here */
647 #if (ERRCLASS & ERRCLS_ADD_RES)      
648             RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguCStaRsp failed",
649                   rgCb[inst].rguSap[spId].sapSta.sapState);
650 #endif
651             RETVALUE(RFAILED);
652       }
653    }
654    else
655    {
656 #if (ERRCLASS & ERRCLS_ADD_RES)      
657       RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguCStaRsp failed",spId);
658 #endif
659       RETVALUE(RFAILED);
660    }
661 #endif
662
663    ret = rgROMCmnStaRsp(inst,staRsp);
664    if (ret != ROK)
665    {
666       RLOG_ARG0(L_ERROR,DBG_CELLID,staRsp->cellId,"Processing Of Status Response Failed");
667       RETVALUE(ret);
668    }
669
670    ret = SPutStaticBuffer(pst->region, pst->pool, (Data *)staRsp,sizeof(RguCStaRspInfo) , SS_SHARABLE_MEMORY);
671    staRsp = NULLP;
672    RETVALUE(ret);
673 }  /* RgUiRguCStaRsp */
674
675 #ifdef LTE_L2_MEAS
676
677 /**
678  * @brief Handler for L2M MeasReq from RGU
679  *
680  * @details
681  *
682  *     Function :RgUiRguL2MUlThrpMeasReq 
683  *     
684  *     This function validates SAP and invokes ROM for further processing
685  *           
686  *  @param[in]  Pst             *pst 
687  *  @param[in]  SpId            spId 
688  *  @param[in]  RguL2MUlThrpMeasReqInfo  *measReq
689  *  @return  S16
690  *      -# ROK 
691  *      -# RFAILED 
692  **/
693 #ifdef ANSI
694 PUBLIC S16 RgUiRguL2MUlThrpMeasReq 
695 (
696 Pst             *pst,
697 SpId            spId,
698 RguL2MUlThrpMeasReqInfo  *measReq
699 )
700 #else
701 PUBLIC S16 RgUiRguL2MUlThrpMeasReq(pst, spId, measReq)
702 Pst             *pst;
703 SpId            spId;
704 RguL2MUlThrpMeasReqInfo  *measReq;
705 #endif
706 {
707    Inst  inst;
708
709    S16   ret = ROK;
710
711    TRC3(RgUiRguL2MUlThrpMeasReq)
712    
713
714    RG_IS_INST_VALID(pst->dstInst);
715    inst = pst->dstInst - RG_INST_START;
716 #ifndef NO_ERRCLS
717    if (measReq == NULLP)
718    {
719       RLOG0(L_ERROR,"Input Response Buffer is NULL");
720       RETVALUE(RFAILED);
721    }
722
723    if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
724    {
725       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
726       {
727          case LRG_BND: /* SAP is bound */
728             RLOG0(L_DEBUG,"SAP is already bound");
729             break;
730          default: /* Should never reach here */
731 #if (ERRCLASS & ERRCLS_ADD_RES)      
732             RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguL2MUlThrpMeasReq failed",
733                   rgCb[inst].rguSap[spId].sapSta.sapState);
734 #endif
735             RETVALUE(RFAILED);
736       }
737    }
738    else
739    {
740 #if (ERRCLASS & ERRCLS_ADD_RES)      
741       RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguL2MUlThrpMeasReq failed",spId);
742 #endif
743       RETVALUE(RFAILED);
744    }
745 #endif
746
747    ret = rgROML2MUlThrpMeasReq(inst,measReq);
748    if (ret != ROK)
749    {
750       RLOG_ARG0(L_ERROR,DBG_CELLID,measReq->cellId,"Processing Of Meas Request Failed");
751    }
752
753   SPutStaticBuffer(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo) , SS_SHARABLE_MEMORY);
754    measReq= NULLP;
755    RETVALUE(ret);
756 }  /* RgUiRguL2MUlThrpMeasReq */
757 #endif
758
759 /**
760  * @brief Handler for sending staInd to dedicated logical channels of a UE 
761  *
762  * @details
763  *
764  *     Function : rgUIMSndDedStaInd
765  *     
766  *     This function fills SAP and Pst information to send the staInd to
767  *     a UE.
768  *     
769  *           
770  *  @param[in] Inst        inst
771  *  @param[in] RgUpSapCb  *rguSap 
772  *  @param[in]  RgRguDedStaInd  *staInd
773  *  @return  S16
774  *      -# ROK 
775  *      -# RFAILED 
776  **/
777 #ifdef ANSI
778 PUBLIC S16 rgUIMSndDedStaInd
779 (
780 Inst         inst,
781 RgUpSapCb    *rguSap,
782 RgRguDedStaInd  *staInd
783 )
784 #else
785 PUBLIC S16 rgUIMSndDedStaInd(inst,rguSap,staInd)
786 Inst         inst;
787 RgUpSapCb    *rguSap;
788 RgRguDedStaInd  *staInd;
789 #endif
790 {
791    S16  ret = ROK;
792    
793    TRC2(rgUIMSndDedStaInd)
794    
795    RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndDedStaInd(): staInd = %p;\n", (void *)staInd));
796    
797    ret = RgUiRguDStaInd(&(rguSap->sapCfg.sapPst), rguSap->sapCfg.suId, 
798          staInd);
799    if (ret != ROK)
800    {
801       RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"RgUiRguDStaInd Failed");
802       RETVALUE(ret);
803    }
804    RETVALUE(ret);
805 }  /* rgUIMSndDedStaInd */
806
807
808 /**
809  * @brief Handler for sending staInd to a common logical channel.
810  *
811  * @details
812  *
813  *     Function : rgUIMSndCmnStaInd
814  *     
815  *     This function fills SAP and Pst information to send the staInd to
816  *     a common logical channel.
817  *     
818  *           
819  *  @param[in] Inst        inst
820  *  @param[in] RgUpSapCb  *rguSap 
821  *  @param[in]  RgRguCmnStaInd  *staInd
822  *  @return  S16
823  *      -# ROK 
824  *      -# RFAILED 
825  **/
826 #ifdef ANSI
827 PUBLIC S16 rgUIMSndCmnStaInd
828 (
829 Inst            inst,
830 RgUpSapCb    *rguDlSap,
831 RgRguCmnStaInd  *staInd
832 )
833 #else
834 PUBLIC S16 rgUIMSndCmnStaInd(inst,rguDlSap,staInd)
835 Inst          inst,
836 RgUpSapCb    *rguDlSap,
837 RgRguCmnStaInd  *staInd;
838 #endif
839 {
840    S16  ret = ROK;
841
842
843    TRC2(rgUIMSndCmnStaInd)
844    
845
846    ret = RgUiRguCStaInd(&(rguDlSap->sapCfg.sapPst), rguDlSap->sapCfg.suId, 
847          staInd);
848    if (ret != ROK)
849    {
850       RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"RgUiRguCStaInd Failed");
851       RETVALUE(ret);
852    }
853    RETVALUE(ret);
854 }  /* rgUIMSndCmnStaInd */
855
856
857 /**
858  * @brief Handler for sending datInd to dedicated logical channels of a UE 
859  *
860  * @details
861  *
862  *     Function : rgUIMSndDedDatInd
863  *     
864  *     This function fills SAP and Pst information to send the datInd to
865  *     a UE.
866  *     
867  *           
868  *  @param[in] Inst        inst
869  *  @param[in] RgUpSapCb  *rguUlSap 
870  *  @param[in]  RgRguDedDatInd  *datInd
871  *  @return  S16
872  *      -# ROK 
873  *      -# RFAILED 
874  **/
875 #ifdef ANSI
876 PUBLIC S16 rgUIMSndDedDatInd
877 (
878 Inst         inst,
879 RgUpSapCb    *rguUlSap,
880 RgRguDedDatInd  *datInd
881 )
882 #else
883 PUBLIC S16 rgUIMSndDedDatInd(datInd)
884 Inst         inst;
885 RgUpSapCb    *rguUlSap;
886 RgRguDedDatInd  *datInd;
887 #endif
888 {
889    S16  ret = ROK;
890
891
892    TRC2(rgUIMSndDedDatInd)
893    
894
895    rguUlSap->sapSts.numPduTxmit += datInd->numLch;
896 #ifndef SS_RBUF
897    ret = RgUiRguDDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId, 
898          datInd);
899    if (ret != ROK)
900    {
901       RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"RgUiRguDdatInd Failed");
902       RETVALUE(ret);
903    }
904 #else
905    SRngIncrWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
906    SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].pktRate++;
907 #endif
908    RETVALUE(ret);
909 }  /* rgUIMSndDedDatInd */
910
911
912 /**
913  * @brief Handler for sending datInd to a common logical channel.
914  *
915  * @details
916  *
917  *     Function : rgUIMSndCmnDatInd
918  *     
919  *     This function fills SAP and Pst information to send the datInd to
920  *     a common logical channel.
921  *     
922  *           
923  *  @param[in] Inst        inst
924  *  @param[in] RgUpSapCb  *rguSap 
925  *  @param[in]  RgRguCmnDatInd  *datInd
926  *  @return  S16
927  *      -# ROK 
928  *      -# RFAILED 
929  **/
930 #ifdef ANSI
931 PUBLIC S16 rgUIMSndCmnDatInd
932 (
933 Inst         inst,
934 RgUpSapCb    *rguUlSap,
935 RgRguCmnDatInd  *datInd
936 )
937 #else
938 PUBLIC S16 rgUIMSndCmnDatInd(datInd)
939 Inst         inst;
940 RgUpSapCb    *rguUlSap;
941 RgRguCmnDatInd  *datInd;
942 #endif
943 {
944    S16  ret = ROK;
945
946    TRC2(rgUIMSndCmnDatInd)
947
948
949    RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndCmnDatInd(): staInd = %p;\n", (void *)datInd));
950
951    rguUlSap->sapSts.numPduTxmit++;
952
953    RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndCmnDatInd suId = %d\n", rguUlSap->sapCfg.suId));   
954    ret = RgUiRguCDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId, 
955          datInd);
956    if (ret != ROK)
957    {
958       RGDBGERRNEW(inst,(rgPBuf(inst),"RgUiRguCDatInd Failed\n"));
959       RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"RgUiRguCDatInd Failed");
960       RETVALUE(ret);
961    }
962    RETVALUE(ret);
963 }  /* rgUIMSndCmnDatInd */
964
965 /**
966
967  * @brief API for bind request from RRC towards MAC. 
968  *
969  * @details
970  *
971  *     Function: RgUiCrgBndReq
972  *     
973  *     This API is invoked by RRC towards MAC to bind CRG SAP. 
974  *     These API validates the Pst, spId, suId and sends the bind confirm to RRC.
975  *
976  *           
977  *  @param[in]  Pst   *pst
978  *  @param[in]  SuId  suId
979  *  @param[in]  SpId  spId
980  *  @return  S16
981  *      -# ROK 
982  *      -# RFAILED 
983  **/
984 #ifdef ANSI
985 PUBLIC S16 RgUiCrgBndReq
986 (
987 Pst   *pst, 
988 SuId  suId,
989 SpId  spId
990 )
991 #else
992 PUBLIC S16 RgUiCrgBndReq(pst, suId, spId)
993 Pst   *pst; 
994 SuId  suId;
995 SpId  spId;
996 #endif
997 {
998    S16       ret = ROK;
999    Pst       tmpPst;   /* Temporary Post Structure */
1000    RgUstaDgn dgn;      /* Alarm diagnostics structure */
1001    Inst      inst;
1002
1003    TRC3(RgUiCrgBndReq)
1004
1005
1006    RG_IS_INST_VALID(pst->dstInst);
1007    inst = pst->dstInst - RG_INST_START;
1008
1009    tmpPst.prior       = pst->prior;
1010    tmpPst.route       = pst->route;
1011    tmpPst.selector    = pst->selector;
1012    tmpPst.region      = rgCb[inst].rgInit.region;
1013    tmpPst.pool        = rgCb[inst].rgInit.pool;
1014    tmpPst.srcProcId   = rgCb[inst].rgInit.procId;
1015    tmpPst.srcEnt      = rgCb[inst].rgInit.ent;
1016    tmpPst.srcInst     = rgCb[inst].rgInit.inst;
1017    tmpPst.event       = EVTNONE;
1018    tmpPst.dstProcId   = pst->srcProcId;
1019    tmpPst.dstEnt      = pst->srcEnt;
1020    tmpPst.dstInst     = pst->srcInst;
1021
1022
1023    if(spId == rgCb[inst].crgSap.sapCfg.spId)
1024    {
1025       /* Check the state of the SAP */
1026       switch (rgCb[inst].crgSap.sapSta.sapState)
1027       {
1028          case LRG_NOT_CFG: /* SAP Not configured */
1029             
1030             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM); 
1031             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
1032                   LCM_CAUSE_INV_SAP, &dgn);
1033             RLOG0(L_DEBUG,"SAP Not Configured");
1034             ret = RgUiCrgBndCfm(&tmpPst, suId, CM_BND_NOK);
1035             break;
1036          case LRG_UNBND: /* SAP is not bound */
1037             RLOG0(L_DEBUG,"SAP Not yet bound");
1038             
1039             rgCb[inst].crgSap.sapSta.sapState = LRG_BND;
1040             rgCb[inst].crgSap.sapCfg.suId = suId;
1041             /* Send Bind Confirm with status as SUCCESS */
1042             ret = rgUIMCrgBndCfm(inst,suId, CM_BND_OK);
1043             /* Indicate to Layer manager */
1044             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM); 
1045             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_EVENT_CRGSAP_ENB,
1046                   LCM_CAUSE_UNKNOWN, &dgn);
1047             break;
1048          case LRG_BND: /* SAP is already bound*/
1049             RLOG0(L_DEBUG,"SAP is already bound");
1050             
1051             ret = rgUIMCrgBndCfm(inst,suId, CM_BND_OK);
1052             break;
1053          default: /* Should Never Enter here */
1054 #if (ERRCLASS & ERRCLS_ADD_RES)      
1055             RLOG1(L_ERROR,"Invalid SAP State:%d RgUiCrgBndReq failed",
1056                   rgCb[inst].crgSap.sapSta.sapState);
1057 #endif
1058             ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
1059             break;
1060       }
1061    }
1062    else
1063    {
1064 #if (ERRCLASS & ERRCLS_ADD_RES)      
1065       RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiCrgBndReq failed",
1066            rgCb[inst].crgSap.sapCfg.spId);
1067 #endif
1068       ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
1069    }
1070    RETVALUE(ret);
1071 }  /* RgUiCrgBndReq */
1072
1073
1074 /**
1075  * @brief API for unbind request from RRC towards MAC. 
1076  *
1077  * @details
1078  *
1079  *     Function: RgUiCrgUbndReq
1080  *     
1081  *     This API is invoked by RRC towards MAC to unbind CRG SAP. 
1082  *     These API validates the Pst, spId, suId and sends the bind confirm to RRC.
1083  *
1084  *           
1085  *  @param[in]  Pst    *pst
1086  *  @param[in]  SuId   suId
1087  *  @param[in]  Reason reason
1088  *  @return  S16
1089  *      -# ROK 
1090  *      -# RFAILED 
1091  **/
1092 #ifdef ANSI
1093 PUBLIC S16 RgUiCrgUbndReq
1094 (
1095 Pst    *pst,
1096 SpId   spId,
1097 Reason reason
1098 )
1099 #else
1100 PUBLIC S16 RgUiCrgUbndReq(pst, spId, reason)
1101 Pst    *pst; 
1102 SpId   spId;
1103 Reason reason;
1104 #endif
1105 {
1106    Inst      inst;
1107    TRC3(RgUiCrgUbndReq)
1108
1109
1110    RG_IS_INST_VALID(pst->dstInst);
1111    inst = pst->dstInst - RG_INST_START;
1112    /* SAP Id validation */
1113    if (spId == rgCb[inst].crgSap.sapCfg.spId)
1114    {
1115       switch(rgCb[inst].crgSap.sapSta.sapState)
1116       {
1117          case LRG_BND: /* SAP is already bound*/
1118             /* setting SAP state to UN BOUND */
1119             RLOG0(L_DEBUG, "SAP is already bound");
1120             
1121             rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
1122             break;
1123          default:
1124 #if (ERRCLASS & ERRCLS_ADD_RES)
1125             RLOG1(L_ERROR,"Invalid SAP State:%d RgUiCrgUbndReq failed",
1126                   rgCb[inst].crgSap.sapSta.sapState);
1127 #endif
1128             RETVALUE(RFAILED);
1129       }
1130    }
1131    else
1132    {
1133 #if (ERRCLASS & ERRCLS_ADD_RES)      
1134       RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiCrgUbndReq failed",
1135             rgCb[inst].crgSap.sapCfg.spId);
1136 #endif
1137       RETVALUE(RFAILED);
1138    }
1139    RETVALUE(ROK);
1140 }  /* RgUiCrgUbndReq */
1141
1142 /**
1143  * @brief API for sending bind confirm from MAC to RRC
1144  *
1145  * @details
1146  *
1147  *     Function: rgUIMRgrBndCfm
1148  *     
1149  *     This API is invoked to send bind confirm from MAC to RRC.
1150  *     This API fills in Pst structure and SAP Ids and invokes 
1151  *     bind confirm API towards RRC.
1152  *           
1153  *  @param[in] Inst        inst
1154  *  @param[in]  SuId          suId
1155  *  @param[in]  U8            status
1156  *  @return  S16
1157  *      -# ROK 
1158  *      -# RFAILED 
1159  **/
1160 #ifdef ANSI
1161 PUBLIC S16 rgUIMCrgBndCfm
1162 (
1163 Inst  inst,
1164 SuId suId,
1165 U8 status
1166 )
1167 #else
1168 PUBLIC S16 rgUIMCrgBndCfm(inst,suId, status)
1169 Inst          inst;
1170 SuId          suId;
1171 U8            status;
1172 #endif
1173 {
1174    TRC2(rgUIMCrgBndCfm)
1175    
1176
1177    if(RgUiCrgBndCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, status) != ROK)
1178    {
1179       RLOG0(L_ERROR,"RgUiCrgBndCfm Failed ");
1180       RETVALUE(RFAILED);
1181    }
1182
1183    RETVALUE(ROK);
1184 }  /* rgUIMCrgBndCfm*/
1185
1186 /**
1187  * @brief API for configuration request from RRC towards MAC. 
1188  *
1189  * @details
1190  *
1191  *     Function: RgUiCrgCfgReq
1192  *     
1193  *     This API is invoked by RRC towards MAC to configure MAC. 
1194  *     These API validates the Pst, spId, suId and transfers the config request 
1195  *     specific information to corresponding ownership module (COM) API.
1196  *
1197  *           
1198  *  @param[in]  Pst           *pst
1199  *  @param[in]  SpId          spId
1200  *  @param[in]  CrgCfgTransId transId
1201  *  @param[in]  CrgCfgReqInfo *cfgReqInfo
1202  *  @return  S16
1203  *      -# ROK 
1204  *      -# RFAILED 
1205  **/
1206 #ifdef ANSI
1207 PUBLIC S16 RgUiCrgCfgReq
1208 (
1209 Pst           *pst, 
1210 SpId          spId,
1211 CrgCfgTransId transId,
1212 CrgCfgReqInfo *cfgReqInfo
1213 )
1214 #else
1215 PUBLIC S16 RgUiCrgCfgReq(pst, spId, transId, cfgReqInfo)
1216 Pst           *pst; 
1217 SpId          spId;
1218 CrgCfgTransId transId;
1219 CrgCfgReqInfo *cfgReqInfo;
1220 #endif
1221 {
1222    Inst      inst;
1223    S16       ret       = ROK;
1224    U8        cfmStatus = 0x00ff;
1225    U8        prntTrans[CRG_CFG_TRANSID_SIZE+1];
1226
1227    TRC3(RgUiCrgCfgReq);
1228
1229    RG_IS_INST_VALID(pst->dstInst);
1230    inst = pst->dstInst - RG_INST_START;
1231    /* Ensuring transId is always Null terminated. */
1232    cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, CRG_CFG_TRANSID_SIZE);
1233    prntTrans[CRG_CFG_TRANSID_SIZE] = '\0';
1234
1235
1236    /* CrgCfgReqInfo Validation for NULLP */
1237    if (cfgReqInfo == NULLP)
1238    {
1239       RLOG0(L_ERROR,"Input Param crgReqInfo is NULL ");
1240       rgUIMCrgCfgCfm(inst,transId, cfmStatus); 
1241       RETVALUE(RFAILED);
1242    }
1243
1244    /* Upper SAP Id and State validation */
1245    if (spId == rgCb[inst].crgSap.sapCfg.spId)
1246    {
1247       switch(rgCb[inst].crgSap.sapSta.sapState)
1248       {
1249          case LRG_BND: /* SAP is already bound */
1250             RLOG0(L_DEBUG,"SAP is already bound");
1251             break;
1252          default: /* Should never reach here */
1253 #if (ERRCLASS & ERRCLS_ADD_RES)      
1254             RLOG1(L_ERROR,"Invalid SAP State:%d RgUiCrgCfgReq failed",
1255                   rgCb[inst].crgSap.sapSta.sapState);
1256 #endif
1257          SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
1258                sizeof(CrgCfgReqInfo));
1259          cfgReqInfo = NULLP;
1260
1261             rgUIMCrgCfgCfm(inst,transId, cfmStatus);
1262             RETVALUE(RFAILED);
1263       }
1264    }
1265    else
1266    {
1267 #if (ERRCLASS & ERRCLS_ADD_RES)      
1268       RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiCrgCfgReq failed",
1269             rgCb[inst].crgSap.sapCfg.spId);
1270 #endif
1271       SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
1272             sizeof(CrgCfgReqInfo));
1273       cfgReqInfo = NULLP;
1274       rgUIMCrgCfgCfm(inst,transId, cfmStatus); 
1275       RETVALUE(RFAILED);
1276    }
1277    ret = rgCOMCfgReq(inst,transId, cfgReqInfo);
1278    SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
1279          sizeof(CrgCfgReqInfo));
1280    cfgReqInfo = NULLP;
1281    if (ret != ROK)
1282    {
1283       RLOG0(L_ERROR,"Configuration Request Handling Failed ");
1284       RETVALUE(RFAILED);
1285    }
1286
1287    RETVALUE(ROK);
1288 }  /* RgUiCrgCfgReq */
1289
1290 /**
1291  * @brief API for sending configuration confirm from MAC to RRC
1292  *
1293  * @details
1294  *
1295  *     Function: rgUIMCrgCfgCfm
1296  *     
1297  *     This API is invoked to send configuration confirm from MAC to RRC.
1298  *     This API fills in Pst structure and SAP Ids and invokes 
1299  *     config confirm API towards RRC.
1300  *           
1301  *  @param[in] Inst        inst
1302  *  @param[in]  CrgCfgTransId transId
1303  *  @param[in]  U8            status
1304  *  @return  S16
1305  *      -# ROK 
1306  *      -# RFAILED 
1307  **/
1308 #ifdef ANSI
1309 PUBLIC S16 rgUIMCrgCfgCfm
1310 (
1311 Inst      inst,
1312 CrgCfgTransId transId,
1313 U8            status
1314 )
1315 #else
1316 PUBLIC S16 rgUIMCrgCfgCfm(inst,transId, status)
1317 Inst      inst;
1318 CrgCfgTransId transId;
1319 U8            status;
1320 #endif
1321 {
1322    S16  ret = ROK;
1323    U8   prntTrans[CRG_CFG_TRANSID_SIZE+1];
1324
1325    TRC2(rgUIMCrgCfgCfm)
1326    
1327    cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, CRG_CFG_TRANSID_SIZE);
1328    prntTrans[CRG_CFG_TRANSID_SIZE] = '\0';
1329
1330
1331    ret = RgUiCrgCfgCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, transId, status);
1332    if (ret != ROK)
1333    {
1334       RLOG0(L_ERROR,"RgUiCrgCfgCfm Failed ");
1335       RETVALUE(ret);
1336    }
1337
1338    RETVALUE(ret);
1339 }  /* rgUIMCrgCfgCfm */
1340 #if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
1341
1342 #ifdef ANSI
1343 PUBLIC S16 rgBatchProc
1344 (
1345 Void
1346 )
1347 #else
1348 PUBLIC S16 rgBatchProc()
1349 Void;
1350 #endif
1351 {
1352 /* Read from Ring Buffer and process RLC BO Update */
1353    Pst pst = {0};
1354    SpId spId = 0;
1355    RguDStaRspInfo  *staRsp;
1356    U32 elmIndx = 0;
1357 #ifndef LTE_ADV
1358 /* Fill pst */
1359    pst.srcProcId = 1;
1360    pst.dstProcId = 1;
1361    pst.dstEnt = ENTRG;
1362    pst.dstInst = 0;
1363    pst.srcEnt = ENTKW;
1364    pst.srcInst = 1;
1365    pst.prior = PRIOR0;
1366    pst.route = RTESPEC;
1367    pst.event = EVTRGUDSTARSP;
1368    pst.region = 0;
1369    pst.pool = 0;
1370    pst.selector = 2; /*SM_SELECTOR_LC */
1371 #else
1372 #endif
1373   
1374    elmIndx = (U32)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
1375    while(NULLP != elmIndx)
1376    {
1377       staRsp = (RguDStaRspInfo *)elmIndx;
1378 #ifdef LTE_ADV
1379       pst = staRsp->post;
1380 #endif
1381       RgUiRguDStaRsp(&pst, spId, staRsp);
1382
1383       elmIndx = NULLP;
1384       staRsp = NULLP;
1385       SRngIncrRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
1386
1387       if((elmIndx = (U32)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC)) == NULLP)
1388       break;
1389    }
1390    RETVALUE(ROK);
1391 }
1392 #endif
1393
1394 /**********************************************************************
1395  
1396          End of file
1397 **********************************************************************/