Moved macCellCfg to duCellCb
[o-du/l2.git] / src / 5gnrrlc / kw_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**
20   
21      Name:    LTE-RLC Layer - Upper Interface Functions
22     
23      Type:    C file
24   
25      Desc:     Source code for RLC Upper Interface Module
26                This file contains following functions
27       
28         --RlcUiCkwBndReq
29         --RlcUiCkwUbndReq
30         --RlcProcCfgReq
31
32         --RlcUiKwuBndReq
33         --RlcUiKwuUbndReq
34         --rlcProcDlData
35         --RlcUiKwuDiscSduReq 
36
37      File:     kw_uim.c
38
39 **********************************************************************/
40 static const char* RLOG_MODULE_NAME="UIM";
41 static int RLOG_MODULE_ID=2048;
42 static int RLOG_FILE_ID=205;
43
44 /** 
45  * @file kw_uim.c
46  * @brief RLC Upper Interface Module
47 */
48
49 #define RLC_MODULE RLC_DBGMASK_INF
50
51 \f
52 /* header (.h) include files */
53 #include "common_def.h"
54 #include "lkw.h"           /* LKW defines */
55 #include "ckw.h"           /* CKW defines */
56 #include "kwu.h"           /* KWU defines */
57 #include "rgu.h"           /* RGU defines */
58 #include "kw_env.h"        /* RLC environment options */
59 #include "kw.h"            /* RLC defines */
60 #include "kw_dl.h"
61 #include "kw_ul.h"
62 #include "kw_udx.h"
63
64 /* extern (.x) include files */
65 #include "lkw.x"           /* LKW */
66 #include "ckw.x"           /* CKW */
67 #include "kwu.x"           /* KWU */
68 #include "rgu.x"           /* RGU */
69 #include "kw_err.h"
70 #include "kw.x"
71 #include "kw_udx.x"
72 #include "kw_dl.x"
73 #include "kw_ul.x"
74
75
76 /*****************************************************************************
77  *                          CKW INTERFACE
78  ****************************************************************************/
79
80 /**
81  * @brief 
82  *    Handler for binding the RLC upper layer service user with 
83  *    the RLC layer.
84  *
85  * @details
86  *    This function is used by RLC user to request for binding to 
87  *    RLC. This function is called by the CKW interface to bind 
88  *    RLC's SAP (identified by spId) with the service user's
89  *    SAP (identified by suId). 
90  *
91  * @param[in] pst     Post structure
92  * @param[in] suId    Service User ID
93  * @param[in] spId    Service provider ID
94  *
95  * @return  S16
96  *    -# ROK 
97  *    -# RFAILED
98  *
99 */
100 #ifdef ANSI
101 S16 RlcUiCkwBndReq 
102 (
103 Pst    *pst,
104 SuId   suId,
105 SpId   spId 
106 )
107 #else
108 S16 RlcUiCkwBndReq (pst, suId, spId)
109 Pst    *pst; 
110 SuId   suId;
111 SpId   spId;
112 #endif
113 {
114    RlcCkwSapCb   *ckwSap;  
115    RlcCb         *tRlcCb;
116
117 #if (ERRCLASS & ERRCLS_INT_PAR)
118    if (pst->dstInst >= MAX_RLC_INSTANCES)
119    {
120       return RFAILED;
121    }
122 #endif
123
124    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
125
126    RLOG2(L_DEBUG, "spId(%d), suId(%d)", spId, suId);
127    ckwSap = &(tRlcCb->u.ulCb->ckwSap);
128    /* Take action based on the current state of the SAP */
129    switch(ckwSap->state)
130    {
131       /* SAP is configured but not bound */
132       case RLC_SAP_CFG:
133       case RLC_SAP_UBND:
134       {
135          /* copy bind configuration parameters in SSAP sap */
136          ckwSap->suId = suId;
137          ckwSap->pst.dstProcId = pst->srcProcId;
138          ckwSap->pst.dstEnt = pst->srcEnt;
139          ckwSap->pst.dstInst = pst->srcInst;
140
141          /* Update the State */
142          ckwSap->state = RLC_SAP_BND;
143
144          RLOG1(L_DEBUG, "RlcUiCkwBndReq: state (%d)", ckwSap->state);
145          break;
146       }
147       case RLC_SAP_BND:
148       {
149          /* Sap is already bound check source, destination Entity and  
150           * Proc Id  */
151          if (ckwSap->pst.dstProcId != pst->srcProcId ||
152              ckwSap->pst.dstEnt != pst->srcEnt ||
153              ckwSap->pst.dstInst != pst->srcInst ||
154              ckwSap->suId != suId)
155          {
156             RLC_SEND_SAPID_ALARM(tRlcCb,
157                                 spId, 
158                                 LKW_EVENT_CKW_BND_REQ, 
159                                 LCM_CAUSE_INV_PAR_VAL);
160
161             RLOG0(L_ERROR, "CKW SAP already Bound");
162             RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
163             return (RFAILED);
164          }
165          break;
166       }
167       default:
168       {
169 #if (ERRCLASS & ERRCLS_INT_PAR)
170          RLOG0(L_ERROR, "Invalid CKW SAP State in Bind Req");
171          RLC_SEND_SAPID_ALARM(tRlcCb,
172                              spId, 
173                              LKW_EVENT_CKW_BND_REQ, 
174                              LCM_CAUSE_INV_STATE);
175 #endif /* ERRCLASS & ERRCLS_INT_PAR */
176          RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
177          return (RFAILED);
178          break;
179       }
180    }
181
182    RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_OK);
183    return (ROK);
184
185
186 \f
187 /**
188  * @brief 
189  *    Handler for unbinding the RLC upper layer service user CKW with 
190  *    the RLC layer.
191  *
192  * @details
193  *    This function is used by RLC user to request for unbinding  
194  *    with RLC.This function is called by the CKW interface to 
195  *    unbind with RLC.  
196  *
197  * @param[in] pst     Post structure
198  * @param[in] spId    Service provider SAP ID
199  * @param[in] reason  Reason for Unbinding 
200  *
201  * @return  S16
202  *    -# ROK 
203  *    -# RFAILED
204 */ 
205 #ifdef ANSI
206 S16 RlcUiCkwUbndReq
207 (
208 Pst      *pst,   
209 SpId     spId,  
210 Reason   reason 
211 )
212 #else
213 S16 RlcUiCkwUbndReq(pst, spId, reason)
214 Pst      *pst; 
215 SpId     spId; 
216 Reason   reason;
217 #endif
218 {
219    RlcCb *tRlcCb;
220
221 #if (ERRCLASS & ERRCLS_INT_PAR)
222    if (pst->dstInst >= MAX_RLC_INSTANCES)
223    {
224       return RFAILED;
225    }
226 #endif /* ERRCLASS & ERRCLS_INT_PAR */
227    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
228
229    RLOG2(L_DEBUG,"spId(%d), reason(%d)", 
230                 spId, 
231                 reason);
232
233    UNUSED(reason);
234
235 #if (ERRCLASS & ERRCLS_INT_PAR)
236    RLC_GET_AND_VALIDATE_CKWSAP(tRlcCb, 
237                               (&(tRlcCb->u.ulCb->ckwSap)), 
238                               EKW208, 
239                               "RlcUiCkwUbndReq");
240 #endif /* ERRCLASS & ERRCLS_INT_PAR */
241
242    /* disable upper sap (CKW) */
243    tRlcCb->u.ulCb->ckwSap.state = RLC_SAP_CFG;
244    return ROK;
245
246
247 /**
248  * @brief  
249  *    Handler for configuring RLC entities.
250  *
251  * @details
252  *    This function is used by RRC to configure(add/delete/modify)
253  *    one or more RLC entities. 
254  *
255  * @param[in] pst   -  Post structure  
256  * @param[in] spId  -  Serive Provider ID 
257  * @param[in] cfg   -  Configuration information for one or more RLC entities. 
258  *
259  * @return  S16
260  *      -# ROK 
261  *      -# RFAILED
262  */
263 #ifdef ANSI
264 S16 RlcProcCfgReq
265 (
266 Pst          *pst,
267 RlcCfgInfo   *cfg
268 )
269 #else
270 S16 RlcProcCfgReq(pst, cfg)
271 Pst          *pst;
272 RlcCfgInfo   *cfg;
273 #endif
274 {
275    RlcCb        *tRlcCb;
276    RlcUlCfgTmpData   *cfgTmpData;
277
278    static U32  transCount;
279
280 #if (ERRCLASS & ERRCLS_INT_PAR)
281    if (pst->dstInst >= MAX_RLC_INSTANCES)
282    {
283       RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
284       return RFAILED;
285    }
286 #endif
287    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
288
289    RLC_ALLOC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
290
291    if (cfgTmpData == NULLP)
292    {
293       RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
294       return RFAILED;
295    }
296    
297    cfgTmpData->uprLyrTransId = cfg->transId; /*Save User TransId*/
298    cfgTmpData->transId = ++transCount;       /*Generate new TransId*/
299    cfg->transId = cfgTmpData->transId;
300    cfgTmpData->cfgInfo  = cfg;
301
302  
303    if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData) != ROK)
304    {
305       RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
306       RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
307       
308       return RFAILED;
309    }
310    
311    rlcUlHdlCfgReq(tRlcCb, cfgTmpData, cfg);
312    rlcUlUdxCfgReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),RLC_GET_UDX_SAP(tRlcCb)->spId,cfg); 
313
314    return ROK;
315
316
317 /**
318  * @brief 
319  *    Handler to change the UeId
320  *
321  * @details 
322  *    This primitive is used by RRC to change the UeId for the existing UE
323  *    context.
324  *     
325  * @param[in] pst     -  Point to the pst structure
326  * @param[in] spId    -  The ID of the service provider SAP in the RLC layer 
327  * @param[in] transId -  Transaction ID. This field uniquily identifies
328  *                       transaction between RRC and RLC
329  * @param[in] ueInfo    -  Old UE Id Info for which the change request has come 
330  * @param[in] newUeInfo -  New UE Id Info for existing UE context 
331  * 
332  * @return S16
333  *    -# ROK
334  *    -# RFAILED
335  */
336 #ifdef ANSI
337 S16 RlcUiCkwUeIdChgReq
338 (
339 Pst         *pst, 
340 SpId        spId, 
341 U32         transId, 
342 CkwUeInfo   *ueInfo,
343 CkwUeInfo   *newUeInfo
344 )
345 #else
346 S16 RlcUiCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
347 Pst         *pst;
348 SpId        spId;
349 U32         transId;
350 CkwUeInfo   *ueInfo;
351 CkwUeInfo   *newUeInfo;
352 #endif
353 {
354    S16              ret = ROK;
355    RlcCb             *tRlcCb;
356    RlcUlCfgTmpData   *cfgTmpData = NULLP;
357
358    do
359    {
360 #if (ERRCLASS & ERRCLS_INT_PAR)
361       if (pst->dstInst >= MAX_RLC_INSTANCES)
362       {
363          ret = RFAILED;
364          break;
365       }
366 #endif
367
368       tRlcCb = RLC_GET_RLCCB(pst->dstInst);
369 #ifndef ALIGN_64BIT
370       RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId,
371                    "RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))", 
372                    spId, 
373                    transId);
374 #else
375       RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId, 
376                    "RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n", 
377                    spId, 
378                    transId);
379 #endif
380
381       RLC_ALLOC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
382       if (!cfgTmpData)
383       {
384          ret = RFAILED;
385          break;
386       }
387
388       cfgTmpData->transId = transId;
389       cfgTmpData->ueInfo  = ueInfo;
390       cfgTmpData->newUeInfo  = newUeInfo; 
391
392       if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData))
393       {
394          RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
395          ret = RFAILED;
396          break;
397       }
398    }while(0);
399
400    if(ret)
401    {
402       /* there was an error in the processing, free up all the memory
403        * that was passed and could have been allocated in this function
404        */
405       /* Freeing from proper region */
406       RLC_PST_FREE(pst->region, pst->pool, newUeInfo, sizeof(CkwUeInfo));
407       RLC_PST_FREE(pst->region, pst->pool, ueInfo, sizeof(CkwUeInfo));
408
409       if(cfgTmpData)
410       {
411          RLC_FREE(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
412       }
413       return RFAILED;
414    }
415
416    if(ROK != rlcCfgValidateUeIdChng(tRlcCb,ueInfo,newUeInfo,cfgTmpData))
417    {
418       RLOG_ARG0(L_ERROR,DBG_CELLID,cfgTmpData->ueInfo->cellId, 
419             "Validation Failure for UeId change");
420    }
421
422    rlcUlUdxUeIdChgReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),
423                      RLC_GET_UDX_SAP(tRlcCb)->spId,
424                      transId, 
425                      ueInfo,
426                      newUeInfo);
427
428    return ROK;
429
430
431 \f
432 /**
433  * @brief 
434  *    Handler for Configuration Request 
435  *
436  * @param[in] gCb      RLC Instance Control Block  
437  * @param[in] cfgTmpData  Configuration stored in Transaction Block  
438  * @param[in] cfg      Configuration block
439  *
440  * @return  S16
441  *    -# ROK 
442  *    -# RFAILED
443  */
444 #ifdef ANSI
445 Void rlcUlHdlCfgReq
446 (
447 RlcCb             *gCb,
448 RlcUlCfgTmpData   *cfgTmpData,
449 RlcCfgInfo       *cfg
450 )
451 #else
452 Void rlcUlHdlCfgReq(gCb, cfgTmpData, cfg)
453 RlcCb             *gCb;
454 RlcUlCfgTmpData   *cfgTmpData;
455 RlcCfgInfo       *cfg;
456 #endif
457 {
458    U8   idx;  
459
460    cfgTmpData->ueId = cfg->ueId;
461    cfgTmpData->cellId = cfg->cellId;
462    for (idx = 0; idx < cfg->numEnt; idx++)
463    {
464       cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_OK;
465       cfgTmpData->cfgEntData[idx].entUlCfgCfm.rbId = cfg->entCfg[idx].rbId; 
466       cfgTmpData->cfgEntData[idx].entUlCfgCfm.rbType = cfg->entCfg[idx].rbType;
467       switch(cfg->entCfg[idx].cfgType)
468       {
469          case CKW_CFG_ADD:
470          case CKW_CFG_MODIFY:
471          case CKW_CFG_DELETE:
472          {
473          
474             if(cfg->entCfg[idx].dir & RLC_DIR_UL)
475             {
476                /* Configuration is for UL , thus validating */
477                if(ROK != rlcCfgValidateUlRb(gCb,
478                                            &cfg->entCfg[idx], 
479                                            &cfgTmpData->cfgEntData[idx],
480                                            cfgTmpData))
481                {
482                   RLOG_ARG2(L_ERROR,DBG_UEID, cfgTmpData->ueId,
483                         "CELLID [%u]:Validation Failure for UL RB [%d]",
484                          cfg->cellId,cfg->entCfg[idx].rbId);
485                   cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
486                   /*Validation is getting failed so no need to do configuration at DL.
487                    *Set dir as UL, so that no configuration is done at DL */
488                   cfg->entCfg[idx].dir = RLC_DIR_UL;
489                }
490             }
491             if(cfg->entCfg[idx].dir == RLC_DIR_UL)
492             {
493                /*If the configuration is for UL only then apply it */   
494                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
495                {
496                   rlcCfgApplyUlRb(gCb, 
497                                  &cfg->entCfg[idx], 
498                                  &cfgTmpData->cfgEntData[idx],
499                                  cfgTmpData);
500                }
501             }
502             break;
503          }
504          case CKW_CFG_REESTABLISH:   
505          {
506             if(cfg->entCfg[idx].dir & RLC_DIR_UL)
507             {
508                if(ROK != rlcCfgValidateReEstRb(gCb,
509                                               cfg->ueId, 
510                                               cfg->cellId, 
511                                               &cfg->entCfg[idx], 
512                                               &cfgTmpData->cfgEntData[idx]))
513                {
514                   RLOG_ARG2(L_ERROR,DBG_UEID,cfg->ueId,
515                         "CellID [%u]:Validation Failure for Reest UL RB [%d]",
516                         cfg->cellId,cfg->entCfg[idx].rbId);
517                   cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
518                   /* Setting dir as UL, so that no configuration is done at DL */
519                   cfg->entCfg[idx].dir = RLC_DIR_UL;
520                   break;
521                }
522             }
523             if(cfg->entCfg[idx].dir == RLC_DIR_UL)
524             {
525                /*If the configuration is for UL only then apply it */   
526                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
527                {
528                   rlcCfgApplyReEstUlRb(gCb,  
529                                       cfg->ueId, 
530                                       cfg->cellId,
531                                       TRUE,
532                                       &cfgTmpData->cfgEntData[idx]);
533                }
534             }
535             break;
536          }
537          case CKW_CFG_DELETE_UE :   
538          {
539             if(ROK != rlcCfgValidateDelUlUe(gCb,  
540                                            &cfg->entCfg[idx], 
541                                            &cfgTmpData->cfgEntData[idx],
542                                            cfgTmpData))
543             {
544                RLOG_ARG1(L_ERROR,DBG_CELLID,cfg->cellId,
545                      "UL UEID [%d]:Validation Failure",
546                      cfgTmpData->ueId);
547                cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
548                /* Setting dir as UL, so that no configuration is done at DL */
549                cfg->entCfg[idx].dir = RLC_DIR_UL;
550             }
551             break;
552          }
553          case CKW_CFG_DELETE_CELL :   
554          {
555             if(ROK != rlcCfgValidateDelUlCell(gCb,
556                                              cfg->cellId, 
557                                              &cfg->entCfg[idx], 
558                                              &cfgTmpData->cfgEntData[idx],
559                                              cfgTmpData))
560             {
561                RLOG_ARG0(L_ERROR,DBG_CELLID,cfg->cellId,
562                      "Del UL Cell Validation Failure");
563                cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
564                /* Setting dir as UL, so that no configuration is done at DL */
565                cfg->entCfg[idx].dir = RLC_DIR_UL;
566             }
567             break;
568          }
569       }/* switch end */
570    }/* for end */
571    RETVOID;
572 }
573
574 \f
575 /*****************************************************************************
576  *                          KWU INTERFACE
577  ****************************************************************************/
578 /**
579  * @brief  
580  *    Handler for binding the RLC upper layer service user with 
581  *    the RLC layer.
582  *
583  * @details
584  *    This function is used by RLC user to request for binding to 
585  *    RLC.This function is called by the KWU interface to bind 
586  *    RLC's SAP (identified by spId) with the service user's
587  *    SAP (identified by suId). 
588  *
589  * @param[in] pst   Post structure  
590  * @param[in] suId  Service user SAP ID 
591  * @param[in] spId  Service provider ID
592  *
593  * @return  S16
594  *    -# ROK
595  *    -# RFAILED
596  *
597  */
598 #ifdef ANSI
599 S16 RlcUiKwuBndReq 
600 (
601 Pst    *pst,  
602 SuId   suId, 
603 SpId   spId 
604 )
605 #else
606 S16 RlcUiKwuBndReq (pst, suId, spId)
607 Pst    *pst;  
608 SuId   suId; 
609 SpId   spId; 
610 #endif
611 {
612    RlcKwuSapCb   *rlckwuSap;     /* SAP Config Block */
613    RlcCb         *tRlcCb;
614    
615 #if (ERRCLASS & ERRCLS_INT_PAR)
616    if (pst->dstInst >= MAX_RLC_INSTANCES)
617    {
618       return RFAILED;
619    }
620 #endif
621    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
622    RLOG2(L_DEBUG, "RlcUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
623
624     /* Validation of input parameters */
625 #if (ERRCLASS & ERRCLS_INT_PAR)
626    if(!((spId < (S16) tRlcCb->genCfg.maxKwuSaps) && (spId >=0))) 
627    {
628       RLOG0(L_ERROR,"Invalid spId");
629       RLC_SEND_SAPID_ALARM(tRlcCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
630       return RFAILED; 
631    }
632 #endif
633
634    /* Get Sap control block */
635    rlckwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
636             (tRlcCb->u.dlCb->rlcKwuDlSap + spId):
637             (tRlcCb->u.ulCb->rlcKwuUlSap + spId);
638
639    /* Take action based on the current state of the SAP */
640    switch(rlckwuSap->state)
641    {
642       /* SAP is configured but not bound */
643       case RLC_SAP_CFG:
644       case RLC_SAP_UBND:
645       {
646          /* copy bind configuration parameters in sap */
647          rlckwuSap->suId          = suId;
648          rlckwuSap->pst.dstProcId = pst->srcProcId;
649          rlckwuSap->pst.dstEnt    = pst->srcEnt;
650          rlckwuSap->pst.dstInst   = pst->srcInst;
651
652          /* Update the State */
653          rlckwuSap->state = RLC_SAP_BND;
654
655          RLOG1(L_DEBUG, "RlcUiKwuBndReq: state (%d)", rlckwuSap->state);
656          break;
657       }
658       case RLC_SAP_BND:
659       {
660          /* Sap is already bound check source, destination Entity and Proc Id */
661          if (rlckwuSap->pst.dstProcId != pst->srcProcId ||
662              rlckwuSap->pst.dstEnt != pst->srcEnt ||
663              rlckwuSap->pst.dstInst != pst->srcInst ||
664              rlckwuSap->suId != suId)
665          {
666             RLC_SEND_SAPID_ALARM(tRlcCb,
667                                 spId, 
668                                 LKW_EVENT_KWU_BND_REQ, 
669                                 LCM_CAUSE_INV_PAR_VAL);
670             RLOG1(L_ERROR,"RLC Mode [%d] : KWU SAP already Bound",
671                   tRlcCb->genCfg.rlcMode);
672             RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_NOK);
673             return (RFAILED);
674          }
675          break;
676       }
677
678      default:
679       {
680 #if (ERRCLASS & ERRCLS_INT_PAR)
681          RLOG1(L_ERROR,"RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
682                tRlcCb->genCfg.rlcMode);
683          RLC_SEND_SAPID_ALARM(tRlcCb,
684                              spId,
685                              LKW_EVENT_KWU_BND_REQ, 
686                              LCM_CAUSE_INV_STATE);
687 #endif /* ERRCLASS & ERRCLS_INT_PAR */
688          RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_NOK);
689          return (RFAILED);
690       }
691    }
692    RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_OK);
693    return (ROK);
694
695
696 \f
697 /**
698  * @brief 
699  *    Handler for unbinding the RLC upper layer service user with 
700  *    the RLC layer.
701  *
702  * @details
703  *    This function is used by RLC user to request for unbinding  
704  *    with RLC.This function is called by the KWU interface to 
705  *    unbind with RLC. 
706  *
707  * @param[in] pst     Post structure  
708  * @param[in] spId    Service provider SAP ID 
709  * @param[in] reason  Reason for Unbinding 
710  *
711  * @return  S16
712  *     -# ROK 
713  *     -# RFAILED
714  */
715 #ifdef ANSI
716 S16 RlcUiKwuUbndReq
717 (
718 Pst      *pst,  
719 SpId     spId, 
720 Reason   reason 
721 )
722 #else
723 S16 RlcUiKwuUbndReq(pst, spId, reason)
724 Pst      *pst; 
725 SpId     spId; 
726 Reason   reason; 
727 #endif
728 {
729    RlcKwuSapCb   *rlckwuSap;   /* KWU SAP control block */
730    RlcCb         *tRlcCb;
731
732 #if (ERRCLASS & ERRCLS_INT_PAR)
733    if ((pst->dstInst >= MAX_RLC_INSTANCES) ||
734        (spId >= (S16) rlcCb[pst->dstInst]->genCfg.maxKwuSaps) ||
735        (spId < 0))
736    {
737       return  (RFAILED);
738    }
739 #endif
740
741    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
742
743    RLOG2(L_DEBUG, "spId(%d), reason(%d)", 
744                 spId, 
745                 reason);
746
747    /* Get Sap control block */
748    rlckwuSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
749             (tRlcCb->u.dlCb->rlcKwuDlSap + spId):
750             (tRlcCb->u.ulCb->rlcKwuUlSap + spId);
751
752    rlckwuSap->state = RLC_SAP_CFG;
753
754    return ROK;
755
756
757 /**
758  * @brief Handler for receiving the data(SDU) from upper layer. 
759  *
760  * @details
761  *    This function is used by RLC service user (PDCP) to 
762  *    transfer data (SDU) to RLC.
763  *
764  * @param[in] pst         Post structure  
765  * @param[in] spId        Service Provider SAP ID 
766  * @param[in] datreq  Data Request Information
767  * @param[in] mBuf        Data Buffer (SDU) 
768  *
769  * @return  uint8_t
770  *    -# ROK 
771  *    -# RFAILED
772  */
773 uint8_t rlcProcDlData(Pst *pst, KwuDatReqInfo *datReq, Buffer *mBuf)
774 {
775    uint8_t       ret = ROK;   /* Return Value */
776    RlcDlRbCb     *rbCb;       /* RB Control Block */
777    RlcCb         *tRlcCb;
778
779    DU_LOG("\nRLC : Received DL Data");
780
781 #if (ERRCLASS & ERRCLS_INT_PAR)
782    if(pst->dstInst >= MAX_RLC_INSTANCES)
783    {
784       ODU_PUT_MSG_BUF(mBuf);
785       return RFAILED;
786    }
787 #endif
788
789    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
790
791    /* Fetch the RbCb */
792    rlcDbmFetchDlRbCbByRbId(tRlcCb, &datReq->rlcId, &rbCb);
793    if(!rbCb)
794    {
795       DU_LOG("\nRLC : CellId[%u]:DL RbId [%d] not found",
796             datReq->rlcId.cellId,datReq->rlcId.rbId);
797       RLC_FREE_BUF(mBuf);
798
799       return RFAILED;
800    }
801
802    /* Dispatch according to mode of the rbCb */
803    switch (rbCb->mode)
804    {
805       case CM_LTE_MODE_TM:
806       {
807          /* Verify the user */
808          if (pst->srcEnt != ENTNH)
809          {
810             /* kw002.201 Freeing from proper region */
811             RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datReq, 
812                         sizeof(KwuDatReqInfo));
813             RLC_FREE_BUF(mBuf);
814              
815             return RFAILED;
816          }
817
818          rlcTmmQSdu(tRlcCb,rbCb, datReq, mBuf);
819          break;
820       }
821       case CM_LTE_MODE_UM:
822       {
823          rlcUmmQSdu(tRlcCb,rbCb, datReq, mBuf);
824
825          break;
826       }
827       case CM_LTE_MODE_AM:
828       {
829          rlcAmmQSdu(tRlcCb,rbCb, mBuf, datReq);
830          break;
831       }
832       default:
833       {
834          DU_LOG("\nRLC : Invalid RB Mode");
835          break;
836       }
837    }
838    return ret;
839
840
841 \f
842 /**
843  * @brief 
844  *    Handler for discarding a SDU. 
845  *
846  * @details
847  *    This function is used by RLC AM  and RLC UM entities. 
848  *    This function is called by the service user to discard a particular
849  *    RLC SDU if it is present in the SDU queue of the RB control block 
850  *    and if it is not mapped to any PDU. 
851  *
852  * @param[in] pst            Post structure  
853  * @param[in] spId           Service Provider SAP ID 
854  * @param[in] discSdu        SDU discard Information 
855  *
856  * @return  S16
857  *    -# ROK 
858  *    -# RFAILED
859  */
860 #ifdef ANSI
861 S16 RlcUiKwuDiscSduReq 
862 (
863 Pst              *pst,   
864 SpId             spId,  
865 KwuDiscSduInfo   *discSdu 
866 )
867 #else
868 S16 RlcUiKwuDiscSduReq(pst, spId, discSdu)
869 Pst              *pst;   
870 SpId             spId;  
871 KwuDiscSduInfo   *discSdu; 
872 #endif
873 {
874    RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, discSdu, sizeof(KwuDiscSduInfo));
875    return ROK;
876
877
878 /********************************************************************30**
879          End of file
880 **********************************************************************/