MAC PDU de-mux and warning fixes
[o-du/l2.git] / src / 5gnrmac / rg_lim.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_lim.c 
28   
29 **********************************************************************/
30
31 /** @file rg_lim.c.
32 @brief It has APIs exposed by Lower Interface Modulue of MAC. It acts as an 
33 Interface handler for lower interface APIs.
34 */
35 static const char* RLOG_MODULE_NAME="MAC";
36 static int RLOG_FILE_ID=182;
37 static int RLOG_MODULE_ID=4096;
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_env.h"        /* customisable defines and macros for MAC */
56 #include "rg.h"            /* defines and macros for MAC */
57 #include "du_log.h"
58
59 /* header/extern include files (.x) */
60 #include "gen.x"           /* general layer typedefs */
61 #include "ssi.x"           /* system services typedefs */
62 #include "cm5.x"           /* common timers */
63 #include "cm_hash.x"       /* common hash list */
64 #include "cm_lib.x"        /* common library */
65 #include "cm_llist.x"      /* common linked list */
66 #include "cm_mblk.x"       /* memory management */
67 #include "cm_tkns.x"       /* common tokens */
68 #include "cm_lte.x"       /* common tokens */
69 #include "rgu.x"           /* RGU types */
70 #include "tfu.x"           /* RGU types */
71 #include "lrg.x"           /* layer management typedefs for MAC */
72 #include "crg.x"           /* layer management typedefs for MAC */
73 #include "rg_sch_inf.x"    /* SCH interface typedefs */
74 #include "rg_prg.x"    /* PRG interface typedefs */
75 #include "du_app_mac_inf.h"
76 #include "rg.x"            /* typedefs for MAC */
77
78 #include "mac_upr_inf_api.h"
79 #include "mac.h"
80
81 /* local externs */
82 #ifdef UNUSED_FUNC
83 PRIVATE S16  rgLIMValidateSap ARGS((Inst inst,SuId suId));
84 #endif
85 PRIVATE Void rgLIMUtlFreeDatIndEvnt ARGS((TfuDatIndInfo *datInd,
86                                           Bool error));
87 #ifdef RG_UNUSED
88 PRIVATE Void rgLIMUtlFreeDatReqEvnt ARGS((TfuDatReqInfo *datReq,
89                                           Bool error));
90 #endif
91 /* forward references */
92
93 /**
94  * @brief This API is invoked to send TFU SAP bind request to PHY.
95  *
96  * @details
97  *
98  *     Function : rgLIMTfuBndReq
99  *      
100  *      This API is invoked to send TFU SAP bind request to PHY. It fills in 
101  *      the Pst structure, spId and suId values and invokes bind request
102  *      primitive at TFU.
103  *           
104  *  @param[in]  Inst        inst
105  *  @param[in]  SuId            suId 
106  *  @param[in]  SpId            spId
107  *  @return  S16
108  *      -# ROK 
109  *      -# RFAILED 
110  **/
111 #ifdef ANSI
112 PUBLIC S16 rgLIMTfuBndReq
113 (
114 Inst    inst,
115 SuId    suId, 
116 SpId    spId
117 )
118 #else
119 PUBLIC S16 rgLIMTfuBndReq(inst,suId, spId)
120 Inst    inst;
121 SuId    suId; 
122 SpId    spId;
123 #endif
124 {
125    S16         ret;
126    RgLowSapCb  *tfuSap;
127    Pst         pst;
128
129    TRC2(rgLIMTfuBndReq);
130
131    /* Get the lower SAP control block from the layer control block. */
132    tfuSap = &(rgCb[inst].tfuSap);
133    (Void)cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
134    if((ret = RgLiTfuBndReq (&pst, suId, spId)) != ROK)
135    {
136       RLOG0(L_ERROR,"Call to RgLiTfuBndReq() failed");
137    }
138    RETVALUE(ret);
139 }  /* rgLIMTfuBndReq */
140
141
142 /**
143  * @brief This API is invoked to send TFU SAP unbind request to PHY.
144  *
145  * @details
146  *
147  *     Function : rgLIMTfuBndReq
148  *      
149  *      This API is invoked to send TFU SAP unbind request to PHY. It fills in 
150  *      the Pst structure and spId value and invokes unbind request
151  *      primitive at TFU.
152  *           
153  *  @param[in]  Inst        inst
154  *  @param[in]  SpId            spId
155  *  @param[in]  Reason          reason 
156  *  @return  S16
157  *      -# ROK 
158  *      -# RFAILED 
159  **/
160 #ifdef ANSI
161 PUBLIC S16 rgLIMTfuUbndReq
162 (
163 Inst    inst,
164 SpId    spId, 
165 Reason  reason
166 )
167 #else
168 PUBLIC S16 rgLIMTfuUbndReq(inst,spId, reason)
169 Inst    inst;
170 SpId    spId; 
171 Reason  reason;
172 #endif
173 {
174    S16         ret;
175    RgLowSapCb  *tfuSap;
176    Pst         pst;
177
178    TRC2(rgLIMTfuUbndReq);
179
180    /* Get the lower SAP control block from the layer control block. */
181    tfuSap = &(rgCb[inst].tfuSap);
182    cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
183    if((ret = RgLiTfuUbndReq (&pst, tfuSap->sapCfg.spId, reason)) != ROK)
184    {
185       RLOG0(L_ERROR,"Call to RgLiTfuUbndReq() failed");
186    }
187    RETVALUE(ret);
188
189 }  /* rgLIMTfuUbndReq */
190
191
192 /**
193  * @brief Bind confirm API for TFU SAP 
194  *
195  * @details
196  *
197  *     Function : RgLiTfuBndCfm
198  *      
199  *      This API is invoked by PHY to confirm TFU SAP bind. 
200  *     
201  *           
202  *  @param[in]  Pst   *pst 
203  *  @param[in]  SuId  suId 
204  *  @param[in]  U8    status
205  *  @return  S16
206  *      -# ROK 
207  *      -# RFAILED 
208  **/
209 #ifdef ANSI
210 PUBLIC S16 RgLiTfuBndCfm 
211 (
212 Pst     *pst,
213 SuId    suId, 
214 U8      status
215 )
216 #else
217 PUBLIC S16 RgLiTfuBndCfm(pst, suId, status)
218 Pst     *pst; 
219 SuId    suId; 
220 U8      status;
221 #endif
222 {
223    Inst inst;
224    S16 ret;
225    RgLowSapCb  *tfuSap;
226
227    TRC3(RgLiTfuBndCfm);
228
229
230    RG_IS_INST_VALID(pst->dstInst);
231    inst = pst->dstInst - RG_INST_START;
232    /* Lets validate suId first */
233    /* CA_Change */
234    tfuSap = &(rgCb[inst].tfuSap);
235
236    if (suId != tfuSap->sapCfg.suId)
237    {
238       RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
239             tfuSap->sapCfg.suId, suId);
240       RETVALUE(RFAILED);
241    }
242    ret = rgLMMBndCfm (pst, suId, status);
243    RETVALUE(ret);
244 }  /* RgLiTfuBndCfm */
245
246  /** @brief This function Validates the SAP information received along with the
247   * primitive from the lower layer. 
248   * Function:
249   *   Validates SAP information.
250  *  @param[in]  Inst        inst
251   * @param  suId The SAP Id
252   * @return 
253   *   -# ROK
254   *   -# RFAILED
255   */
256 #ifdef UNUSED_FUNC
257 #ifdef ANSI
258 PRIVATE S16 rgLIMValidateSap
259 (
260  Inst    inst,
261  SuId    suId
262 )
263 #else
264 PRIVATE S16 rgLIMValidateSap(inst,suId)
265  Inst    inst;
266  SuId    suId;
267 #endif
268 {
269    RgLowSapCb  *tfuSap;
270
271    TRC2(rgLIMValidateSap)
272
273    tfuSap = &(rgCb[inst].tfuSap);
274
275    /* First lets check the suId */
276    if( suId != tfuSap->sapCfg.suId)
277    {
278       RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
279             tfuSap->sapCfg.suId, suId);
280       RETVALUE(RFAILED);
281    }
282    if (tfuSap->sapSta.sapState != LRG_BND)
283    {
284       RLOG1(L_ERROR,"Lower SAP not enabled SuId (%d)",
285             tfuSap->sapCfg.suId);
286       RETVALUE(RFAILED);
287    }
288    RETVALUE(ROK);
289 } /* end of rgLIMValidateSap */
290 #endif
291 /** @brief This function frees up the TfuDatIndInfo structure
292  *
293  * @details
294  *
295  *     Function: rgLIMUtlFreeDatIndEvnt 
296  *       - Function frees up the TfuDatIndInfo structure, in case of error it shall
297  *       free up the buffer's present in the datIndLst.
298  *
299  *         Processing steps:
300  * @param  [in] TfuDatIndInfo *datInd
301  * @param  [in] Bool          *error
302  * @return 
303  */
304 #ifdef ANSI
305 PRIVATE Void rgLIMUtlFreeDatIndEvnt 
306 (
307  TfuDatIndInfo *datInd,
308  Bool          error
309  )
310 #else
311 PRIVATE Void rgLIMUtlFreeDatIndEvnt(datInd, error)
312  TfuDatIndInfo *datInd;
313  Bool          error;
314 #endif
315 {
316
317    TfuDatInfo     *datInfo;
318    CmLList        *node;
319
320    TRC2(rgLIMUtlFreeDatIndEvnt);
321    /* Steps of freeing up the TfuDatInd.
322     * 1. loop through the datIndLst and free up all the buffers.
323     * 2. free up the whole event
324     */
325    if ((error == TRUE) && (datInd->datIndLst.count > 0))
326    {
327       node =  datInd->datIndLst.first;
328       while (node)
329       {
330          datInfo = (TfuDatInfo*)node->node;
331          RG_FREE_MSG(datInfo->mBuf);
332          node = node->next;
333       }
334    }
335    RG_FREE_MEM(datInd);
336    RETVOID;
337 } /* end of rgLIMUtlFreeDatIndEvnt*/
338
339 /**
340  * @brief Downlink data indication from PHY.
341  *
342  * @details
343  *
344  *     Function : RgLiTfuDatInd
345  *      
346  *      This API is invoked by PHY to send data indication to MAC on 
347  *      recieving data from UEs.
348  *           
349  *  @param[in]  Pst              *pst
350  *  @param[in]  SuId             suId 
351  *  @param[in]  TfuDatIndInfo    *datInd
352  *  @return  S16
353  *      -# ROK 
354  *      -# RFAILED 
355  **/
356 #ifdef ANSI
357 PUBLIC S16 RgLiTfuDatInd
358 (
359 Pst                *pst, 
360 SuId               suId, 
361 TfuDatIndInfo    *datInd
362 )
363 #else
364 PUBLIC S16 RgLiTfuDatInd(pst, suId, datInd)
365 Pst                *pst; 
366 SuId               suId; 
367 TfuDatIndInfo    *datInd;
368 #endif
369 {
370    Inst             inst;
371    S16              ret;
372    VOLATILE U32     startTime=0;
373
374    TRC3(RgLiTfuDatInd);
375
376   // printf("5GTF:: DatindRcvd\n");
377
378    RG_IS_INST_VALID(pst->dstInst);
379    inst = pst->dstInst - RG_INST_START;
380    /*starting Task*/
381    SStartTask(&startTime, PID_MAC_TFU_DATIND);
382
383 #ifndef NO_ERRCLS 
384    if ((ret = rgLIMValidateSap (inst,suId)) != ROK)
385    {
386       RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"SAP Validation failed");
387       rgLIMUtlFreeDatIndEvnt(datInd, TRUE);
388       RETVALUE(ret);
389    }
390 #endif
391    /* Now call the TOM (Tfu ownership module) primitive to process further */
392    rgCb[inst].tfuSap.sapSts.numPduRcvd += 
393                     datInd->datIndLst.count;
394    ret = rgTOMDatInd(inst,datInd);
395    /* Fix: sriky memory corruption precautions */
396    /* Free up the memory for the request structure */
397    if (ret == ROK)
398    {
399       rgLIMUtlFreeDatIndEvnt(datInd, FALSE);
400    }
401    else
402    {
403       rgLIMUtlFreeDatIndEvnt(datInd, TRUE);
404    }
405
406    /*stoping Task*/
407    SStopTask(startTime, PID_MAC_TFU_DATIND);
408
409    RETVALUE(ret);
410 }  /* RgLiTfuDatInd*/
411
412 #ifdef RG_UNUSED
413 /** @brief This function frees up the TfuDatReqInfo structure.
414  *
415  * @details
416  *
417  *     Function: rgLIMUtlFreeDatReqEvnt
418  *       - Function frees up the TfuDatReqInfo structure, in case of error it shall
419  *       free up the buffer's present in the PDUs list.
420  *
421  *         Processing steps:
422  * @param  [in] TfuDatReqInfo *datReq
423  * @param  [in] Bool          *error
424  * @return 
425  */
426 #ifdef ANSI
427 PRIVATE Void rgLIMUtlFreeDatReqEvnt
428 (
429  TfuDatReqInfo *datReq,
430  Bool          error
431  )
432 #else
433 PRIVATE Void rgLIMUtlFreeDatReqEvnt(datReq, error)
434  TfuDatReqInfo *datReq;
435  Bool          error;
436 #endif
437 {
438
439    TfuDatReqPduInfo *datInfo;
440    CmLList          *node;
441    U8               i;
442
443    TRC2(rgLIMUtlFreeDatReqEvnt);
444    /* Steps of freeing up the TfuDatReq.
445     * 1. Free the bch buffer.
446     * 2. loop through the pdus list and free up all the buffers.
447     * 3. free up the whole event
448     */
449    if (error)
450    {
451       if (datReq->bchDat.pres == PRSNT_NODEF)
452       {
453          RG_FREE_MSG(datReq->bchDat.val);
454       }
455       if (datReq->pdus.count > 0)
456       {
457          node =  datReq->pdus.first;
458          while (node)
459          {
460             datInfo = (TfuDatReqPduInfo*)node->node;
461             for (i=0; i<datInfo->nmbOfTBs; i++)
462             {
463                if (datInfo->mBuf[i] != NULLP)
464                {
465                   RG_FREE_MSG(datInfo->mBuf[i]);
466                }
467             }
468             node = node->next;
469          }
470       }
471    }
472    RG_FREE_MEM(datReq);
473    RETVOID;
474 } /* end of rgLIMUtlFreeDatReqEvnt*/
475 #endif
476 /**
477  * @brief This API is invoked to send Data to PHY.
478  *
479  * @details
480  *
481  *     Function : rgLIMTfuDatReq
482  *      
483  *      This API is invoked to send Data to PHY. It 
484  *      fills in the Pst structure, spId value and invokes Data
485  *      request primitive at TFU.
486  *           
487  *  @param[in]  Inst        inst
488  *  @param[in]  TfuDatReqInfo *datReq
489  *  @return  S16
490  *      -# ROK 
491  *      -# RFAILED 
492  **/
493 #ifdef ANSI
494 PUBLIC S16 rgLIMTfuDatReq 
495 (
496 Inst          inst,
497 TfuDatReqInfo *datReq
498 )
499 #else
500 PUBLIC S16 rgLIMTfuDatReq(inst,datReq)
501 Inst          inst;
502 TfuDatReqInfo *datReq;
503 #endif
504 {
505    S16         ret;
506    RgLowSapCb  *tfuSap;
507
508    TRC2(rgLIMTfuDatReq)
509
510    /* Get the lower SAP control block from the layer control block. */
511    tfuSap = &(rgCb[inst].tfuSap);
512
513 #ifndef NO_ERRCLS
514    if (tfuSap->sapSta.sapState != LRG_BND)
515    {
516       RLOG_ARG1(L_ERROR,DBG_CELLID,datReq->cellId,"Lower SAP not bound (%d)",
517             tfuSap->sapSta.sapState);
518 #ifdef RG_UNUSED
519       /* This case will never be hit if sap is not bound then we dont get TTI */
520       rgLIMUtlFreeDatReqEvnt(datReq, TRUE);
521 #endif
522       RETVALUE(RFAILED);
523    }
524 #endif
525
526    tfuSap->sapSts.numPduTxmit += datReq->pdus.count; 
527
528    /* Using existing pst - for optimization */
529    if((ret = RgLiTfuDatReq (&tfuSap->sapCfg.sapPst, tfuSap->sapCfg.spId, 
530                             datReq)) != ROK)
531    {
532       RLOG_ARG0(L_ERROR,DBG_CELLID,datReq->cellId,"Call to RgLiTfuDatReq() failed");
533    }
534    RETVALUE(ret);
535 }  /* rgLIMTfuDatReq*/
536
537 #ifdef L2_OPTMZ
538 /**
539  * @brief This API is invoked to send Data to PHY.
540  *
541  * @details
542  *
543  *     Function : rgLIMTfuDelDatReq
544  *      
545  *      This API is invoked to send Data to PHY. It 
546  *      fills in the Pst structure, spId value and invokes Data
547  *      request primitive at TFU.
548  *           
549  *  @param[in]  Inst        inst
550  *  @param[in]  TfuDelDatReqInfo *datReq
551  *  @return  S16
552  *      -# ROK 
553  *      -# RFAILED 
554  **/
555 #ifdef ANSI
556 PUBLIC S16 rgLIMTfuDelDatReq 
557 (
558 Inst          inst,
559 TfuDelDatReqInfo *delDatReq
560 )
561 #else
562 PUBLIC S16 rgLIMTfuDatReq(inst,delDatReq)
563 Inst          inst;
564 TfuDelDatReqInfo *delDatReq;
565 #endif
566 {
567    S16         ret;
568    RgLowSapCb  *tfuSap;
569
570    TRC2(rgLIMTfuDelDatReq)
571
572    /* Get the lower SAP control block from the layer control block. */
573    tfuSap = &(rgCb[inst].tfuSap);
574
575 #ifndef NO_ERRCLS
576    if (tfuSap->sapSta.sapState != LRG_BND)
577    {
578       RLOG_ARG1(L_ERROR,DBG_CELLID,delDatReq->cellId,"Lower SAP not bound (%d)",
579             tfuSap->sapSta.sapState);
580       RETVALUE(RFAILED);
581    }
582 #endif
583
584    if((ret = RgLiTfuDelDatReq (&tfuSap->sapCfg.sapPst, tfuSap->sapCfg.spId, 
585                             delDatReq)) != ROK)
586    {
587       RLOG_ARG0(L_ERROR,DBG_CELLID,delDatReq->cellId,"Call to RgLiTfuDelDatReq() failed");
588    }
589    RETVALUE(ret);
590 }  /* rgLIMTfuDatReq*/
591 #endif /*L2_OPTMZ */
592
593 /*******************************************************************
594  *
595  * @brief Fills post structure
596  *
597  * @details
598  *
599  *    Function : fillMacToSchPst
600  *
601  *    Functionality:
602  *      Fills post structure to be used when sending msg from 
603  *      MAC to SCH
604  *
605  * @params[in] Post structure pointer 
606  * @return ROK     - success
607  *         RFAILED - failure
608  *
609  * ****************************************************************/
610 void fillMacToSchPst(Pst *pst)
611 {
612    pst->srcProcId = 0;
613    pst->dstProcId = 0;
614    pst->srcEnt = ENTRG;
615    pst->dstEnt = ENTRG;
616    pst->srcInst = 0;
617    pst->dstInst = 1;
618    pst->region = 0;
619    pst->pool =  0;
620    pst->selector = MAC_SELECTOR_TC;
621 }
622
623 /*******************************************************************
624  *
625  * @brief MAC handler for config response from PHY
626  *
627  * @details
628  *
629  *    Function : fapiMacConfigRsp
630  *
631  *    Functionality:
632  *     Processes config response from PHY and sends cell config
633  *     confirm to DU APP
634  *
635  * @params[in] 
636  * @return void
637  *
638  * ****************************************************************/
639 void fapiMacConfigRsp()
640 {
641    /* TODO : Processing of config response from PHY */
642
643    /* Send cell config cfm to DU APP */
644    MacSendCellCfgCfm(RSP_OK);
645 }
646
647 /*******************************************************************
648  *
649  * @brief Send stop indication to DU APP
650  *
651  * @details
652  *
653  *    Function : sendStopIndMacToDuApp
654  *
655  *    Functionality:
656  *       Send stop indication to DU APP
657  *
658  * @params[in] Pst info 
659  * @return ROK     - success
660  *         RFAILED - failure
661  *
662  * ****************************************************************/
663 uint8_t sendStopIndMacToDuApp()
664 {
665    Pst pst;
666    uint8_t ret = ROK;
667
668    MacCellStopInfo *cellStopId; 
669   
670    /*  Allocate sharable memory */
671    MAC_ALLOC_SHRABL_BUF(cellStopId, sizeof(MacCellStopInfo));
672    if(!cellStopId)
673    {
674       DU_LOG("\nMAC : Stop Indication memory allocation failed");
675       return RFAILED;
676    }
677    cellStopId->cellId = macCb.macCell->cellId;
678
679    /* Fill Pst */
680    pst.selector  = DU_MAC_LWLC;
681    pst.srcEnt    = ENTRG;
682    pst.dstEnt    = ENTDUAPP;
683    pst.dstInst   = 0;
684    pst.srcInst   = macCb.macInst;
685    pst.dstProcId = rgCb[pst.srcInst].rgInit.procId;
686    pst.srcProcId = rgCb[pst.srcInst].rgInit.procId;
687    pst.region = MAC_MEM_REGION;
688    pst.pool = MAC_POOL;
689    pst.event = EVENT_MAC_STOP_IND;
690    pst.route = 0;
691    pst.prior = 0;
692    pst.intfVer = 0;
693
694    ret = MacDuAppStopInd(&pst, cellStopId);
695    if(ret != ROK)
696    {
697       DU_LOG("\nMAC: Failed to send stop indication to DU APP");
698       MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, cellStopId, sizeof(MacCellStopInfo));
699    }
700    return ROK;
701 }
702 #if defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
703  /**
704  * @brief Transmission of non-rt indication from CL.
705  *
706  * @details
707  *
708  *     Function : RgLiTfuNonRtInd 
709  *      
710  *      This API is invoked by CL to indicate non-rt processing indication to MAC for a cell.
711  *           
712  *  @param[in]  Pst            *pst
713  *  @param[in]  SuId           suId 
714  *  @return  S16
715  *      -# ROK 
716  *      -# RFAILED 
717  **/
718 #ifdef ANSI
719 PUBLIC S16 RgLiTfuNonRtInd
720 (
721 Pst                 *pst,
722 SuId                suId
723 )
724 #else
725 PUBLIC S16 RgLiTfuNonRtInd(pst, suId)
726 Pst                 *pst;
727 SuId                suId;
728 #endif
729 {
730    TRC3(RgLiTfuNonRtInd);
731
732 #ifdef NO_ERRCLS
733    if (rgLIMValidateSap (pst->dstInst - RG_INST_START, suId) != ROK)
734    {
735       RGDBGERRNEW(pst->dstInst - RG_INST_START, (rgPBuf(pst->dstInst - RG_INST_START),"RgLiTfuNonRtInd() SAP Validation failed.\n"));
736       RETVALUE(RFAILED);
737    }
738 #endif
739    rgDHMFreeTbBufs(pst->dstInst - RG_INST_START);
740    RETVALUE(ROK);
741 }  /* RgLiTfuNonRtInd */
742
743 #endif
744 /**********************************************************************
745  
746          End of file
747 **********************************************************************/