cu link failure fix
[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         --KwUiCkwBndReq
29         --KwUiCkwUbndReq
30         --KwUiCkwCfgReq
31
32         --KwUiKwuBndReq
33         --KwUiKwuUbndReq
34         --KwUiKwuDatReq
35         --KwUiKwuDiscSduReq 
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 KW_MODULE KW_DBGMASK_INF
50
51 \f
52 /* header (.h) include files */
53 #include "envopt.h"        /* environment options */
54 #include "envdep.h"        /* environment dependent */
55 #include "envind.h"        /* environment independent */
56
57 #include "gen.h"           /* general */
58 #include "ssi.h"           /* system services */
59 #include "cm5.h"           /* common timer defines */
60 #include "cm_tkns.h"       /* common tokens defines */
61 #include "cm_mblk.h"       /* common memory allocation library defines */
62 #include "cm_llist.h"      /* common link list  defines  */
63 #include "cm_hash.h"       /* common hash list  defines */
64 #include "cm_lte.h"        /* common LTE defines */
65 #include "lkw.h"           /* LKW defines */
66 #include "ckw.h"           /* CKW defines */
67 #include "kwu.h"           /* KWU defines */
68 #include "rgu.h"           /* RGU defines */
69 #include "kw_env.h"        /* RLC environment options */
70 #include "kw.h"            /* RLC defines */
71 #include "kw_dl.h"
72 #include "kw_ul.h"
73 #include "kw_udx.h"
74
75 /* extern (.x) include files */
76 #include "gen.x"           /* general */
77 #include "ssi.x"           /* system services */
78
79 #include "cm5.x"           /* common timer library */
80 #include "cm_tkns.x"       /* common tokens */
81 #include "cm_mblk.x"       /* common memory allocation */
82 #include "cm_llist.x"      /* common link list */
83 #include "cm_hash.x"       /* common hash list */
84 #include "cm_lte.x"        /* common LTE includes */
85 #include "cm_lib.x"        /* common memory allocation library */
86 #include "lkw.x"           /* LKW */
87 #include "ckw.x"           /* CKW */
88 #include "kwu.x"           /* KWU */
89 #include "rgu.x"           /* RGU */
90 #include "kw_err.h"
91 #include "kw.x"
92 #include "kw_udx.x"
93 #include "kw_dl.x"
94 #include "kw_ul.x"
95
96
97 /*****************************************************************************
98  *                          CKW INTERFACE
99  ****************************************************************************/
100
101 /**
102  * @brief 
103  *    Handler for binding the RLC upper layer service user with 
104  *    the RLC layer.
105  *
106  * @details
107  *    This function is used by RLC user to request for binding to 
108  *    RLC. This function is called by the CKW interface to bind 
109  *    RLC's SAP (identified by spId) with the service user's
110  *    SAP (identified by suId). 
111  *
112  * @param[in] pst     Post structure
113  * @param[in] suId    Service User ID
114  * @param[in] spId    Service provider ID
115  *
116  * @return  S16
117  *    -# ROK 
118  *    -# RFAILED
119  *
120 */
121 #ifdef ANSI
122 PUBLIC S16 KwUiCkwBndReq 
123 (
124 Pst    *pst,
125 SuId   suId,
126 SpId   spId 
127 )
128 #else
129 PUBLIC S16 KwUiCkwBndReq (pst, suId, spId)
130 Pst    *pst; 
131 SuId   suId;
132 SpId   spId;
133 #endif
134 {
135    KwCkwSapCb   *ckwSap;  
136    KwCb         *tKwCb;
137
138    TRC3(KwUiCkwBndReq);
139
140 #if (ERRCLASS & ERRCLS_INT_PAR)
141    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
142    {
143       RETVALUE(RFAILED);
144    }
145 #endif
146
147    tKwCb = KW_GET_KWCB(pst->dstInst);
148
149    RLOG2(L_DEBUG, "spId(%d), suId(%d)", spId, suId);
150    ckwSap = &(tKwCb->u.ulCb->ckwSap);
151    /* Take action based on the current state of the SAP */
152    switch(ckwSap->state)
153    {
154       /* SAP is configured but not bound */
155       case KW_SAP_CFG:
156       case KW_SAP_UBND:
157       {
158          /* copy bind configuration parameters in SSAP sap */
159          ckwSap->suId = suId;
160          ckwSap->pst.dstProcId = pst->srcProcId;
161          ckwSap->pst.dstEnt = pst->srcEnt;
162          ckwSap->pst.dstInst = pst->srcInst;
163
164          /* Update the State */
165          ckwSap->state = KW_SAP_BND;
166
167          RLOG1(L_DEBUG, "KwUiCkwBndReq: state (%d)", ckwSap->state);
168          break;
169       }
170       case KW_SAP_BND:
171       {
172          /* Sap is already bound check source, destination Entity and  
173           * Proc Id  */
174          if (ckwSap->pst.dstProcId != pst->srcProcId ||
175              ckwSap->pst.dstEnt != pst->srcEnt ||
176              ckwSap->pst.dstInst != pst->srcInst ||
177              ckwSap->suId != suId)
178          {
179             KW_SEND_SAPID_ALARM(tKwCb,
180                                 spId, 
181                                 LKW_EVENT_CKW_BND_REQ, 
182                                 LCM_CAUSE_INV_PAR_VAL);
183
184             RLOG0(L_ERROR, "CKW SAP already Bound");
185             KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
186             RETVALUE(RFAILED);
187          }
188          break;
189       }
190       default:
191       {
192 #if (ERRCLASS & ERRCLS_INT_PAR)
193          RLOG0(L_ERROR, "Invalid CKW SAP State in Bind Req");
194          KW_SEND_SAPID_ALARM(tKwCb,
195                              spId, 
196                              LKW_EVENT_CKW_BND_REQ, 
197                              LCM_CAUSE_INV_STATE);
198 #endif /* ERRCLASS & ERRCLS_INT_PAR */
199          KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
200          RETVALUE(RFAILED);
201          break;
202       }
203    }
204
205    KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_OK);
206    RETVALUE(ROK);
207
208
209 \f
210 /**
211  * @brief 
212  *    Handler for unbinding the RLC upper layer service user CKW with 
213  *    the RLC layer.
214  *
215  * @details
216  *    This function is used by RLC user to request for unbinding  
217  *    with RLC.This function is called by the CKW interface to 
218  *    unbind with RLC.  
219  *
220  * @param[in] pst     Post structure
221  * @param[in] spId    Service provider SAP ID
222  * @param[in] reason  Reason for Unbinding 
223  *
224  * @return  S16
225  *    -# ROK 
226  *    -# RFAILED
227 */ 
228 #ifdef ANSI
229 PUBLIC S16 KwUiCkwUbndReq
230 (
231 Pst      *pst,   
232 SpId     spId,  
233 Reason   reason 
234 )
235 #else
236 PUBLIC S16 KwUiCkwUbndReq(pst, spId, reason)
237 Pst      *pst; 
238 SpId     spId; 
239 Reason   reason;
240 #endif
241 {
242    KwCb *tKwCb;
243
244    TRC3(KwUiCkwUbndReq)
245
246 #if (ERRCLASS & ERRCLS_INT_PAR)
247    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
248    {
249       RETVALUE(RFAILED);
250    }
251 #endif /* ERRCLASS & ERRCLS_INT_PAR */
252    tKwCb = KW_GET_KWCB(pst->dstInst);
253
254    RLOG2(L_DEBUG,"spId(%d), reason(%d)", 
255                 spId, 
256                 reason);
257
258    UNUSED(reason);
259
260 #if (ERRCLASS & ERRCLS_INT_PAR)
261    KW_GET_AND_VALIDATE_CKWSAP(tKwCb, 
262                               (&(tKwCb->u.ulCb->ckwSap)), 
263                               EKW208, 
264                               "KwUiCkwUbndReq");
265 #endif /* ERRCLASS & ERRCLS_INT_PAR */
266
267    /* disable upper sap (CKW) */
268    tKwCb->u.ulCb->ckwSap.state = KW_SAP_CFG;
269    RETVALUE(ROK);
270
271
272 /*******************************************************************
273  *
274  * @brief Handler for UE create request
275  *
276  * @details
277  *
278  *    Function : RlcDuappProcUeCreateReq 
279  *
280  *    Functionality:
281  *       Handler for UE create request
282  *
283  * @params[in] pst - Post Structure
284  *             cfg - Configuration information for one or more RLC entities
285  * @return ROK     - success
286  *         RFAILED - failure
287  *
288  * ****************************************************************/
289 PUBLIC S16 RlcDuappProcUeCreateReq(Pst *pst, CkwCfgInfo *ueCfg)
290 {
291    U8 idx;
292    S16 ret=ROK;
293
294    ueCfg->transId = 1;
295
296    for(idx = 0; idx < ueCfg->numEnt; idx++)
297    {
298       ueCfg->entCfg[idx].cfgType = CKW_CFG_ADD; 
299    }
300    
301    ret = KwUiCkwCfgReq(pst, ueCfg);
302    return ret;
303
304 } /* RlcDuappUeCreateReq */ 
305
306 \f
307 /**
308  * @brief  
309  *    Handler for configuring RLC entities.
310  *
311  * @details
312  *    This function is used by RRC to configure(add/delete/modify)
313  *    one or more RLC entities. 
314  *
315  * @param[in] pst   -  Post structure  
316  * @param[in] spId  -  Serive Provider ID 
317  * @param[in] cfg   -  Configuration information for one or more RLC entities. 
318  *
319  * @return  S16
320  *      -# ROK 
321  *      -# RFAILED
322  */
323 #ifdef ANSI
324 PUBLIC S16 KwUiCkwCfgReq
325 (
326 Pst          *pst,
327 //SpId         spId,
328 CkwCfgInfo   *cfg
329 )
330 #else
331 //PUBLIC S16 KwUiCkwCfgReq(pst, spId, cfg)
332 PUBLIC S16 KwUiCkwCfgReq(pst, cfg)
333 Pst          *pst;
334 //SpId         spId;
335 CkwCfgInfo   *cfg;
336 #endif
337 {
338    KwCb        *tKwCb;
339    KwUlCfgTmpData   *cfgTmpData;
340
341    static U32  transCount;
342
343
344    TRC3(KwUiCkwCfgReq)
345       
346 #if (ERRCLASS & ERRCLS_INT_PAR)
347    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
348    {
349       KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo));
350       RETVALUE(RFAILED);
351    }
352 #endif
353    tKwCb = KW_GET_KWCB(pst->dstInst);
354
355    KW_ALLOC(tKwCb, cfgTmpData, sizeof (KwUlCfgTmpData));
356
357    if (cfgTmpData == NULLP)
358    {
359       KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo));
360       RETVALUE(RFAILED);
361    }
362
363
364    cfgTmpData->uprLyrTransId = cfg->transId; /*Save User TransId*/
365    cfgTmpData->transId = ++transCount;       /*Generate new TransId*/
366    cfg->transId = cfgTmpData->transId;
367    cfgTmpData->cfgInfo  = cfg;
368  
369    if (kwDbmAddUlTransaction(tKwCb, cfgTmpData) != ROK)
370    {
371       RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
372       KW_PST_FREE(pst->region, pst->pool, cfg, sizeof(CkwCfgInfo));
373       
374       RETVALUE(RFAILED);
375    }
376    
377    kwHdlUiCkwUlCfgReq(tKwCb, cfgTmpData, cfg);
378    
379    KwUlUdxCfgReq(&(KW_GET_UDX_SAP(tKwCb)->pst),KW_GET_UDX_SAP(tKwCb)->spId,cfg); 
380
381    RETVALUE(ROK);
382
383
384 /**
385  * @brief 
386  *    Handler to change the UeId
387  *
388  * @details 
389  *    This primitive is used by RRC to change the UeId for the existing UE
390  *    context.
391  *     
392  * @param[in] pst     -  Point to the pst structure
393  * @param[in] spId    -  The ID of the service provider SAP in the RLC layer 
394  * @param[in] transId -  Transaction ID. This field uniquily identifies
395  *                       transaction between RRC and RLC
396  * @param[in] ueInfo    -  Old UE Id Info for which the change request has come 
397  * @param[in] newUeInfo -  New UE Id Info for existing UE context 
398  * 
399  * @return S16
400  *    -# ROK
401  *    -# RFAILED
402  */
403 #ifdef ANSI
404 PUBLIC S16 KwUiCkwUeIdChgReq
405 (
406 Pst         *pst, 
407 SpId        spId, 
408 U32         transId, 
409 CkwUeInfo   *ueInfo,
410 CkwUeInfo   *newUeInfo
411 )
412 #else
413 PUBLIC S16 KwUiCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
414 Pst         *pst;
415 SpId        spId;
416 U32         transId;
417 CkwUeInfo   *ueInfo;
418 CkwUeInfo   *newUeInfo;
419 #endif
420 {
421    S16              ret = ROK;
422    KwCb             *tKwCb;
423    KwUlCfgTmpData   *cfgTmpData = NULLP;
424
425    TRC3(KwUiCkwUeIdChgReq)
426
427    do
428    {
429 #if (ERRCLASS & ERRCLS_INT_PAR)
430       if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
431       {
432          ret = RFAILED;
433          break;
434       }
435 #endif
436
437       tKwCb = KW_GET_KWCB(pst->dstInst);
438 #ifndef ALIGN_64BIT
439       RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId,
440                    "KwUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))", 
441                    spId, 
442                    transId);
443 #else
444       RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId, 
445                    "KwUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n", 
446                    spId, 
447                    transId);
448 #endif
449
450       KW_ALLOC(tKwCb, cfgTmpData, sizeof (KwUlCfgTmpData));
451       if (!cfgTmpData)
452       {
453          ret = RFAILED;
454          break;
455       }
456
457       cfgTmpData->transId = transId;
458       cfgTmpData->ueInfo  = ueInfo;
459       cfgTmpData->newUeInfo  = newUeInfo; 
460
461       if (kwDbmAddUlTransaction(tKwCb, cfgTmpData))
462       {
463          RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
464          ret = RFAILED;
465          break;
466       }
467    }while(0);
468
469    if(ret)
470    {
471       /* there was an error in the processing, free up all the memory
472        * that was passed and could have been allocated in this function
473        */
474       /* Freeing from proper region */
475       KW_PST_FREE(pst->region, pst->pool, newUeInfo, sizeof(CkwUeInfo));
476       KW_PST_FREE(pst->region, pst->pool, ueInfo, sizeof(CkwUeInfo));
477
478       if(cfgTmpData)
479       {
480          KW_FREE(tKwCb, cfgTmpData, sizeof (KwUlCfgTmpData));
481       }
482       RETVALUE(RFAILED);
483    }
484
485    if(ROK != kwCfgValidateUeIdChng(tKwCb,ueInfo,newUeInfo,cfgTmpData))
486    {
487       RLOG_ARG0(L_ERROR,DBG_CELLID,cfgTmpData->ueInfo->cellId, 
488             "Validation Failure for UeId change");
489    }
490
491    KwUlUdxUeIdChgReq(&(KW_GET_UDX_SAP(tKwCb)->pst),
492                      KW_GET_UDX_SAP(tKwCb)->spId,
493                      transId, 
494                      ueInfo,
495                      newUeInfo);
496
497    RETVALUE(ROK);
498
499
500 \f
501 /**
502  * @brief 
503  *    Handler for Configuration Request 
504  *
505  * @param[in] gCb      RLC Instance Control Block  
506  * @param[in] cfgTmpData  Configuration stored in Transaction Block  
507  * @param[in] cfg      Configuration block
508  *
509  * @return  S16
510  *    -# ROK 
511  *    -# RFAILED
512  */
513 #ifdef ANSI
514 PUBLIC Void kwHdlUiCkwUlCfgReq
515 (
516 KwCb             *gCb,
517 KwUlCfgTmpData   *cfgTmpData,
518 CkwCfgInfo       *cfg
519 )
520 #else
521 PUBLIC Void kwHdlUiCkwUlCfgReq(gCb, cfgTmpData, cfg)
522 KwCb             *gCb;
523 KwUlCfgTmpData   *cfgTmpData;
524 CkwCfgInfo       *cfg;
525 #endif
526 {
527    U8   idx;  
528
529    TRC3(kwHdlUiCkwUlCfgReq)
530
531    cfgTmpData->ueId = cfg->ueId;
532    cfgTmpData->cellId = cfg->cellId;
533    for (idx = 0; idx < cfg->numEnt; idx++)
534    {
535       cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_OK;
536       cfgTmpData->cfgEntData[idx].entUlCfgCfm.rbId = cfg->entCfg[idx].rbId; 
537       cfgTmpData->cfgEntData[idx].entUlCfgCfm.rbType = cfg->entCfg[idx].rbType;
538       switch(cfg->entCfg[idx].cfgType)
539       {
540          case CKW_CFG_ADD:
541          case CKW_CFG_MODIFY:
542          case CKW_CFG_DELETE:
543          {
544          
545             if(cfg->entCfg[idx].dir & KW_DIR_UL)
546             {
547                /* Configuration is for UL , thus validating */
548                if(ROK != kwCfgValidateUlRb(gCb,
549                                            &cfg->entCfg[idx], 
550                                            &cfgTmpData->cfgEntData[idx],
551                                            cfgTmpData))
552                {
553                   RLOG_ARG2(L_ERROR,DBG_UEID, cfgTmpData->ueId,
554                         "CELLID [%u]:Validation Failure for UL RB [%d]",
555                          cfg->cellId,cfg->entCfg[idx].rbId);
556                   cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
557                   /*Validation is getting failed so no need to do configuration at DL.
558                    *Set dir as UL, so that no configuration is done at DL */
559                   cfg->entCfg[idx].dir = KW_DIR_UL;
560                }
561             }
562             if(cfg->entCfg[idx].dir == KW_DIR_UL)
563             {
564                /*If the configuration is for UL only then apply it */   
565                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
566                {
567                   kwCfgApplyUlRb(gCb, 
568                                  &cfg->entCfg[idx], 
569                                  &cfgTmpData->cfgEntData[idx],
570                                  cfgTmpData);
571                }
572             }
573             break;
574          }
575          case CKW_CFG_REESTABLISH:   
576          {
577             if(cfg->entCfg[idx].dir & KW_DIR_UL)
578             {
579                if(ROK != kwCfgValidateReEstRb(gCb,
580                                               cfg->ueId, 
581                                               cfg->cellId, 
582                                               &cfg->entCfg[idx], 
583                                               &cfgTmpData->cfgEntData[idx]))
584                {
585                   RLOG_ARG2(L_ERROR,DBG_UEID,cfg->ueId,
586                         "CellID [%u]:Validation Failure for Reest UL RB [%d]",
587                         cfg->cellId,cfg->entCfg[idx].rbId);
588                   cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
589                   /* Setting dir as UL, so that no configuration is done at DL */
590                   cfg->entCfg[idx].dir = KW_DIR_UL;
591                   break;
592                }
593             }
594             if(cfg->entCfg[idx].dir == KW_DIR_UL)
595             {
596                /*If the configuration is for UL only then apply it */   
597                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
598                {
599                   kwCfgApplyReEstUlRb(gCb,  
600                                       cfg->ueId, 
601                                       cfg->cellId,
602                                       TRUE,
603                                       &cfgTmpData->cfgEntData[idx]);
604                }
605             }
606             break;
607          }
608          case CKW_CFG_DELETE_UE :   
609          {
610             if(ROK != kwCfgValidateDelUlUe(gCb,  
611                                            &cfg->entCfg[idx], 
612                                            &cfgTmpData->cfgEntData[idx],
613                                            cfgTmpData))
614             {
615                RLOG_ARG1(L_ERROR,DBG_CELLID,cfg->cellId,
616                      "UL UEID [%d]:Validation Failure",
617                      cfgTmpData->ueId);
618                cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
619                /* Setting dir as UL, so that no configuration is done at DL */
620                cfg->entCfg[idx].dir = KW_DIR_UL;
621             }
622             break;
623          }
624          case CKW_CFG_DELETE_CELL :   
625          {
626             if(ROK != kwCfgValidateDelUlCell(gCb,
627                                              cfg->cellId, 
628                                              &cfg->entCfg[idx], 
629                                              &cfgTmpData->cfgEntData[idx],
630                                              cfgTmpData))
631             {
632                RLOG_ARG0(L_ERROR,DBG_CELLID,cfg->cellId,
633                      "Del UL Cell Validation Failure");
634                cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
635                /* Setting dir as UL, so that no configuration is done at DL */
636                cfg->entCfg[idx].dir = KW_DIR_UL;
637             }
638             break;
639          }
640       }/* switch end */
641    }/* for end */
642    RETVOID;
643 }
644
645 \f
646 /*****************************************************************************
647  *                          KWU INTERFACE
648  ****************************************************************************/
649 /**
650  * @brief  
651  *    Handler for binding the RLC upper layer service user with 
652  *    the RLC layer.
653  *
654  * @details
655  *    This function is used by RLC user to request for binding to 
656  *    RLC.This function is called by the KWU interface to bind 
657  *    RLC's SAP (identified by spId) with the service user's
658  *    SAP (identified by suId). 
659  *
660  * @param[in] pst   Post structure  
661  * @param[in] suId  Service user SAP ID 
662  * @param[in] spId  Service provider ID
663  *
664  * @return  S16
665  *    -# ROK
666  *    -# RFAILED
667  *
668  */
669 #ifdef ANSI
670 PUBLIC S16 KwUiKwuBndReq 
671 (
672 Pst    *pst,  
673 SuId   suId, 
674 SpId   spId 
675 )
676 #else
677 PUBLIC S16 KwUiKwuBndReq (pst, suId, spId)
678 Pst    *pst;  
679 SuId   suId; 
680 SpId   spId; 
681 #endif
682 {
683    KwKwuSapCb   *kwuSap;     /* SAP Config Block */
684    KwCb         *tKwCb;
685    
686    TRC3(KwUiKwuBndReq)
687
688 #if (ERRCLASS & ERRCLS_INT_PAR)
689    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
690    {
691       RETVALUE(RFAILED);
692    }
693 #endif
694    tKwCb = KW_GET_KWCB(pst->dstInst);
695    RLOG2(L_DEBUG, "KwUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
696
697     /* Validation of input parameters */
698 #if (ERRCLASS & ERRCLS_INT_PAR)
699    if(!((spId < (S16) tKwCb->genCfg.maxKwuSaps) && (spId >=0))) 
700    {
701       RLOG0(L_ERROR,"Invalid spId");
702       KW_SEND_SAPID_ALARM(tKwCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
703       RETVALUE(RFAILED); 
704    }
705 #endif
706
707    /* Get Sap control block */
708    kwuSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
709             (tKwCb->u.dlCb->kwuDlSap + spId):
710             (tKwCb->u.ulCb->kwuUlSap + spId);
711
712    /* Take action based on the current state of the SAP */
713    switch(kwuSap->state)
714    {
715       /* SAP is configured but not bound */
716       case KW_SAP_CFG:
717       case KW_SAP_UBND:
718       {
719          /* copy bind configuration parameters in sap */
720          kwuSap->suId          = suId;
721          kwuSap->pst.dstProcId = pst->srcProcId;
722          kwuSap->pst.dstEnt    = pst->srcEnt;
723          kwuSap->pst.dstInst   = pst->srcInst;
724
725          /* Update the State */
726          kwuSap->state = KW_SAP_BND;
727
728          RLOG1(L_DEBUG, "KwUiKwuBndReq: state (%d)", kwuSap->state);
729          break;
730       }
731       case KW_SAP_BND:
732       {
733          /* Sap is already bound check source, destination Entity and Proc Id */
734          if (kwuSap->pst.dstProcId != pst->srcProcId ||
735              kwuSap->pst.dstEnt != pst->srcEnt ||
736              kwuSap->pst.dstInst != pst->srcInst ||
737              kwuSap->suId != suId)
738          {
739             KW_SEND_SAPID_ALARM(tKwCb,
740                                 spId, 
741                                 LKW_EVENT_KWU_BND_REQ, 
742                                 LCM_CAUSE_INV_PAR_VAL);
743             RLOG1(L_ERROR,"RLC Mode [%d] : KWU SAP already Bound",
744                   tKwCb->genCfg.rlcMode);
745             KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_NOK);
746             RETVALUE(RFAILED);
747          }
748          break;
749       }
750
751      default:
752       {
753 #if (ERRCLASS & ERRCLS_INT_PAR)
754          RLOG1(L_ERROR,"RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
755                tKwCb->genCfg.rlcMode);
756          KW_SEND_SAPID_ALARM(tKwCb,
757                              spId,
758                              LKW_EVENT_KWU_BND_REQ, 
759                              LCM_CAUSE_INV_STATE);
760 #endif /* ERRCLASS & ERRCLS_INT_PAR */
761          KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_NOK);
762          RETVALUE(RFAILED);
763       }
764    }
765    KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_OK);
766    RETVALUE(ROK);
767
768
769 \f
770 /**
771  * @brief 
772  *    Handler for unbinding the RLC upper layer service user with 
773  *    the RLC layer.
774  *
775  * @details
776  *    This function is used by RLC user to request for unbinding  
777  *    with RLC.This function is called by the KWU interface to 
778  *    unbind with RLC. 
779  *
780  * @param[in] pst     Post structure  
781  * @param[in] spId    Service provider SAP ID 
782  * @param[in] reason  Reason for Unbinding 
783  *
784  * @return  S16
785  *     -# ROK 
786  *     -# RFAILED
787  */
788 #ifdef ANSI
789 PUBLIC S16 KwUiKwuUbndReq
790 (
791 Pst      *pst,  
792 SpId     spId, 
793 Reason   reason 
794 )
795 #else
796 PUBLIC S16 KwUiKwuUbndReq(pst, spId, reason)
797 Pst      *pst; 
798 SpId     spId; 
799 Reason   reason; 
800 #endif
801 {
802    KwKwuSapCb   *kwuSap;   /* KWU SAP control block */
803    KwCb         *tKwCb;
804
805    TRC3(KwUiKwuUbndReq)
806
807 #if (ERRCLASS & ERRCLS_INT_PAR)
808    if ((pst->dstInst >= KW_MAX_RLC_INSTANCES) ||
809        (spId >= (S16) kwCb[pst->dstInst]->genCfg.maxKwuSaps) ||
810        (spId < 0))
811    {
812       RETVALUE (RFAILED);
813    }
814 #endif
815
816    tKwCb = KW_GET_KWCB(pst->dstInst);
817
818    RLOG2(L_DEBUG, "spId(%d), reason(%d)", 
819                 spId, 
820                 reason);
821
822    /* Get Sap control block */
823    kwuSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
824             (tKwCb->u.dlCb->kwuDlSap + spId):
825             (tKwCb->u.ulCb->kwuUlSap + spId);
826
827    kwuSap->state = KW_SAP_CFG;
828
829    RETVALUE(ROK);
830
831
832 /**
833  * @brief Handler for receiving the data(SDU) from upper layer. 
834  *
835  * @details
836  *    This function is used by RLC service user (PDCP) to 
837  *    transfer data (SDU) to RLC.
838  *
839  * @param[in] pst         Post structure  
840  * @param[in] spId        Service Provider SAP ID 
841  * @param[in] datreq  Data Request Information
842  * @param[in] mBuf        Data Buffer (SDU) 
843  *
844  * @return  S16
845  *    -# ROK 
846  *    -# RFAILED
847  */
848 #ifdef ANSI
849 PUBLIC S16 KwUiKwuDatReq
850 (
851 Pst             *pst,   
852 SpId            spId,  
853 KwuDatReqInfo   *datReq, 
854 Buffer          *mBuf   
855 )
856 #else
857 PUBLIC S16 KwUiKwuDatReq(pst, spId, datReq, mBuf)
858 Pst             *pst;  
859 SpId            spId; 
860 KwuDatReqInfo   *datReq; 
861 Buffer          *mBuf;  
862 #endif
863 {
864    S16          ret = ROK;   /* Return Value */
865    KwDlRbCb     *rbCb;       /* RB Control Block */
866    KwKwuSapCb   *kwuSap;     /* SAP Config Block */
867    KwCb         *tKwCb;
868
869    TRC3(KwUiKwuDatReq)
870
871 #if (ERRCLASS & ERRCLS_INT_PAR)
872    if ((pst->dstInst >= KW_MAX_RLC_INSTANCES) ||
873        (spId >= (S16) kwCb[pst->dstInst]->genCfg.maxKwuSaps) ||
874        (spId < 0))
875    {
876       SPutMsg(mBuf);
877       RETVALUE(RFAILED);
878    }
879 #endif
880
881    tKwCb = KW_GET_KWCB(pst->dstInst);
882
883    /* Get Sap control block */
884    kwuSap = tKwCb->u.dlCb->kwuDlSap + spId;
885
886    /* Validate SAP ID under ERRORCLS */
887    KW_VALDATE_SAP(tKwCb,spId, kwuSap, ret);
888    if (ret != ROK)
889    {
890       KW_FREE_BUF(mBuf);
891       RETVALUE(RFAILED);
892    }
893
894    /* Fetch the RbCb */
895    kwDbmFetchDlRbCbByRbId(tKwCb, &datReq->rlcId, &rbCb);
896    if(!rbCb)
897    {
898       RLOG_ARG2(L_WARNING, DBG_UEID,datReq->rlcId.ueId, "CellId[%u]:DL RbId [%d] not found",
899             datReq->rlcId.cellId,datReq->rlcId.rbId);
900       KW_FREE_BUF(mBuf);
901
902       RETVALUE(RFAILED);
903    }
904
905    /* kw005.201 update the spId received in datReq to update statistics */
906    rbCb->kwuSapId = spId;
907    /* Dispatch according to mode of the rbCb */
908    switch (rbCb->mode)
909    {
910       case CM_LTE_MODE_TM:
911       {
912          /* Verify the user */
913          if (pst->srcEnt != ENTNH)
914          {
915             /* kw002.201 Freeing from proper region */
916             KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datReq, 
917                         sizeof(KwuDatReqInfo));
918             KW_FREE_BUF(mBuf);
919              
920             RETVALUE(RFAILED);
921          }
922
923          kwTmmQSdu(tKwCb,rbCb, datReq, mBuf);
924          /* kw005.201 ccpu00117318, updated statistics */
925          kwuSap->sts.sduRx++;
926          break;
927       }
928       case CM_LTE_MODE_UM:
929       {
930          kwUmmQSdu(tKwCb,rbCb, datReq, mBuf);
931
932          /* kw005.201 ccpu00117318, updated statistics */
933          kwuSap->sts.sduRx++;
934          break;
935       }
936       case CM_LTE_MODE_AM:
937       {
938          kwAmmQSdu(tKwCb,rbCb, mBuf, datReq);
939          /* kw005.201 ccpu00117318, updated statistics */
940          kwuSap->sts.sduRx++;
941          break;
942       }
943       default:
944       {
945          RLOG0(L_ERROR, "Invalid RB Mode");
946          break;
947       }
948    }
949    RETVALUE(ret);
950
951
952 \f
953 /**
954  * @brief 
955  *    Handler for discarding a SDU. 
956  *
957  * @details
958  *    This function is used by RLC AM  and RLC UM entities. 
959  *    This function is called by the service user to discard a particular
960  *    RLC SDU if it is present in the SDU queue of the RB control block 
961  *    and if it is not mapped to any PDU. 
962  *
963  * @param[in] pst            Post structure  
964  * @param[in] spId           Service Provider SAP ID 
965  * @param[in] discSdu        SDU discard Information 
966  *
967  * @return  S16
968  *    -# ROK 
969  *    -# RFAILED
970  */
971 #ifdef ANSI
972 PUBLIC S16 KwUiKwuDiscSduReq 
973 (
974 Pst              *pst,   
975 SpId             spId,  
976 KwuDiscSduInfo   *discSdu 
977 )
978 #else
979 PUBLIC S16 KwUiKwuDiscSduReq(pst, spId, discSdu)
980 Pst              *pst;   
981 SpId             spId;  
982 KwuDiscSduInfo   *discSdu; 
983 #endif
984 {
985    KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, discSdu, sizeof(KwuDiscSduInfo));
986    RETVALUE(ROK);
987
988
989 /********************************************************************30**
990          End of file
991 **********************************************************************/