710e9fdfaa46916e4740bcb2494033e9c6647886
[o-du/l2.git] / src / 5gnrrlc / kw_udx_ul.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 RLC layer
22  
23     Type:   C include file
24  
25     Desc:   Defines required by LTE MAC
26  
27     File:   kw_udx_ul.c
28  
29 **********************************************************************/
30 static const char* RLOG_MODULE_NAME="UDX";
31 static int RLOG_MODULE_ID=262144;
32 static int RLOG_FILE_ID=204;
33
34 /** @file kw_udx_ul.c
35 @brief  UDX Uplink Module 
36 */
37  
38 /* header include files (.h) */
39 #include "common_def.h"
40 #include "lkw.h"           /* LKW defines */
41 #include "ckw.h"           /* CKW defines */
42 #include "kwu.h"           /* KWU defines */
43 #include "rgu.h"           /* RGU defines */
44 #include "kw_err.h"        /* Err defines */
45 #include "kw_env.h"        /* RLC environment options */
46
47 #include "kw.h"            /* RLC defines */
48 #include "kw_udx.h"
49 #include "kw_ul.h"
50 #include "kw_dl.h"
51
52 /* extern (.x) include files */
53 #include "lkw.x"           /* LKW */
54 #include "ckw.x"           /* CKW */
55 #include "kwu.x"           /* KWU */
56 #include "rgu.x"           /* RGU */
57
58 #include "kw.x"
59 #include "kw_udx.x"
60 #include "kw_dl.x"
61 #include "kw_ul.x"
62
63 #include "du_app_rlc_inf.h"
64 #include "rlc_mgr.h"
65 #include "rlc_utils.h"
66
67 #define RLC_MODULE RLC_DBGMASK_UDX
68 /* local defines */
69
70 /* local externs */
71
72 /* forward references */
73
74 /* public variable declarations */
75 EXTERN S16 rlcHdlCrlcUlCfgReq ARGS((RlcCb  *gCb,RlcUlCfgTmpData *cfgTmpData,
76                                   RlcCfgCfmInfo *cfmInfo, RlcCfgCfmInfo *cfgCfm));
77
78 /**
79   * @brief
80   * UDX APIs
81   */
82 /**
83  * @brief 
84  *    Handler for bind confirmation from DL.
85  *
86  * @details
87  *    This function handles the bind confirmation received
88  *    from DL. 
89  *
90  * @param[in] pst     Post structure  
91  * @param[in] suId    Service User ID
92  * @param[in] status  Status of confirmation 
93  * 
94  * @return  S16
95  *    -# ROK 
96  *    -# RFAILED
97  */
98
99 #ifdef ANSI
100 S16 rlcUlUdxBndCfm
101 (
102 Pst    *pst,  
103 SuId   suId, 
104 U8     status 
105 )
106 #else
107 S16 rlcUlUdxBndCfm (pst, suId, status)
108 Pst    *pst; 
109 SuId   suId;   
110 U8     status; 
111 #endif
112 {
113    U16            event;        
114    U16            cause;       
115    RlcUdxUlSapCb   *udxSap;   /* RGU SAP Control Block */
116    RlcCb           *tRlcCb;
117
118 #if (ERRCLASS & ERRCLS_INT_PAR)
119    if (pst->dstInst >= MAX_RLC_INSTANCES)
120    {
121       return  (RFAILED);
122    }
123 #endif
124    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
125
126    RLCDBGP_BRIEF(tRlcCb, "rlcUlUdxBndCfm(post, suId(%d), status(%d)\n", 
127                 suId, status);
128
129 #if (ERRCLASS & ERRCLS_INT_PAR)
130    if (tRlcCb->init.cfgDone != TRUE)
131    {
132       RLOG0(L_FATAL, "General configuration not done");
133       RLC_SEND_SAPID_ALARM(tRlcCb,suId, 
134                           LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
135
136       return RFAILED;
137    }
138
139    if (suId < 0)
140    {
141       RLOG0(L_ERROR, "Invalid suId");
142       RLC_SEND_SAPID_ALARM(tRlcCb,suId, 
143                            LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
144
145       return RFAILED;
146    }
147 #endif /* ERRCLASS & ERRCLS_INT_PAR */
148
149    udxSap = tRlcCb->u.ulCb->udxUlSap + suId;
150
151    RLCDBGP_DETAIL(tRlcCb, "RlcLiRguBndCfm: For RGU SAP state=%d\n", 
152                  udxSap->state);
153
154    /* Check rguSap state */
155    switch (udxSap->state)
156    {
157       case RLC_SAP_BINDING:
158       {
159          if(TRUE == rlcChkTmr(tRlcCb,(PTR)udxSap,RLC_EVT_WAIT_BNDCFM))
160          {
161              rlcStopTmr (tRlcCb,(PTR)udxSap, RLC_EVT_WAIT_BNDCFM);
162          }
163          udxSap->retryCnt = 0;
164           
165          if (status == CM_BND_OK)
166          {
167             udxSap->state = RLC_SAP_BND;
168             event = LCM_EVENT_BND_OK;
169             cause = LKW_CAUSE_SAP_BNDENB;
170          }
171          else
172          {
173             udxSap->state = RLC_SAP_CFG;
174             event = LCM_EVENT_BND_FAIL;
175             cause = LKW_CAUSE_UNKNOWN;
176          }
177       }
178       break;
179
180      default:
181         event = LKW_EVENT_RGU_BND_CFM;
182         cause = LCM_CAUSE_INV_STATE;
183         break;
184    }
185    /* Send an alarm with proper event and cause */
186    RLC_SEND_SAPID_ALARM(tRlcCb,suId, event, cause);
187
188    return ROK;
189
190
191 /**
192  * @brief 
193  *    Handles UDX Configuration Confirm 
194  *
195  * @details
196  *    This function handles the UDX configuration Confirm from DL Instance
197  *
198  * @param[in] pst     Post structure  
199  * @param[in] suId    Service User ID
200  * @param[in] cfmInfo Confirm Information 
201  * 
202  * @return  S16
203  *    -# ROK 
204  *    -# RFAILED
205  */
206 #ifdef ANSI
207 S16 rlcUlUdxCfgCfm
208 (
209 Pst             *pst,  
210 SuId            suId, 
211 RlcCfgCfmInfo   *cfmInfo  
212 )
213 #else
214 S16 rlcUlUdxCfgCfm (pst, suId, cfmInfo)
215 Pst             *pst;   
216 SuId            suId;  
217 RlcCfgCfmInfo   *cfmInfo;  
218 #endif
219 {
220    RlcCb             *tRlcCb;
221    RlcCfgCfmInfo    *cfgCfm;
222    RlcUlCfgTmpData   *cfgTmpData;
223    Pst rspPst;
224    memset(&rspPst, 0, sizeof(Pst));
225
226 #if (ERRCLASS & ERRCLS_INT_PAR)
227    if (pst->dstInst >= MAX_RLC_INSTANCES)
228    {
229       RLC_FREE_SHRABL_BUF(pst->region,
230                          pst->pool,
231                          cfmInfo,
232                          sizeof(RlcCfgCfmInfo));
233       return  (RFAILED);
234    }
235 #endif
236    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
237    RLCDBGP_BRIEF(tRlcCb, " suId(%d)\n", suId);
238
239 #if (ERRCLASS & ERRCLS_INT_PAR)
240    if (suId < 0)
241    {
242       RLOG0(L_ERROR, "Invalid suId");
243       RLC_SEND_SAPID_ALARM(tRlcCb,suId, 
244                            LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
245       RLC_FREE_SHRABL_BUF(pst->region,
246                          pst->pool,
247                          cfmInfo,
248                          sizeof(RlcCfgCfmInfo));
249       return RFAILED;
250    }
251 #endif /* ERRCLASS & ERRCLS_INT_PAR */
252
253    if(ROK != rlcDbmFindUlTransaction(tRlcCb,cfmInfo->transId, &cfgTmpData))
254    {
255       RLOG0(L_ERROR, "Invalid transId");
256       RLC_FREE_SHRABL_BUF(pst->region,
257                          pst->pool,
258                          cfmInfo,
259                          sizeof(RlcCfgCfmInfo));
260       return  (RFAILED);
261    }
262
263    if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
264    {
265       RLC_FREE_SHRABL_BUF(pst->region,
266                          pst->pool,
267                          cfmInfo,
268                          sizeof(RlcCfgCfmInfo));
269        return RFAILED;
270    }
271       /* Allocate memory and memset to 0 for cfmInfo */
272    RLC_ALLOC(tRlcCb,cfgCfm, sizeof(RlcCfgCfmInfo));
273 #if (ERRCLASS & ERRCLS_ADD_RES)
274    if (cfgCfm == NULLP)
275    {
276       RLOG0(L_FATAL, "Memory Allocation failed.");
277       RLC_FREE_SHRABL_BUF(pst->region,
278                          pst->pool,
279                          cfmInfo,
280                          sizeof(RlcCfgCfmInfo));
281        return RFAILED;
282    }
283 #endif /* ERRCLASS & ERRCLS_ADD_RES */
284    rlcHdlCrlcUlCfgReq(tRlcCb,cfgTmpData, cfmInfo, cfgCfm);
285    FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UL_UE_CREATE_RSP);
286    SendRlcUlUeCreateRspToDu(&rspPst, cfgCfm);
287
288    /* free the memory from DL */
289    RLC_FREE_SHRABL_BUF(pst->region,
290                       pst->pool,
291                       cfmInfo,
292                       sizeof(RlcCfgCfmInfo));
293
294    /* free the cfgInfo that came from LM */
295    RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->cfgInfo, sizeof(RlcCfgInfo));
296    RLC_FREE(tRlcCb,cfgTmpData,sizeof(RlcUlCfgTmpData));
297    
298    return ROK;
299
300
301 /**
302  * @brief 
303  *    Handler for UeId change confirm 
304  *
305  * @details
306  *    This function handles the UeId Change Confirm from DL Instance 
307  *
308  *  @param[in] pst     Post structure  
309  *  @param[in] suId    Service User ID
310  *  @param[in] transId Transaction Id 
311  *  @param[in] status  Status of confirmation 
312  *  @return  S16
313  *      -# ROK 
314  *      -# RFAILED
315  */
316
317 #ifdef ANSI
318 S16 rlcUlUdxUeIdChgCfm
319 (
320 Pst        *pst,          
321 SuId       suId,           
322 U32        transId,
323 CmStatus   status
324 )
325 #else
326 S16 rlcUlUdxUeIdChgCfm (pst, suId, cfmInfo)
327 Pst        *pst;         
328 SuId       suId;        
329 U32        transId;
330 CmStatus   status;
331 #endif
332 {
333    RlcCb             *tRlcCb;
334    RlcUlCfgTmpData   *cfgTmpData;
335
336 #if (ERRCLASS & ERRCLS_INT_PAR)
337    if (pst->dstInst >= MAX_RLC_INSTANCES)
338    {
339       return  (RFAILED);
340    }
341 #endif
342    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
343
344    RLCDBGP_BRIEF(tRlcCb, " suId(%d) \n", suId);
345
346 #if (ERRCLASS & ERRCLS_INT_PAR)
347    if (suId < 0)
348    {
349       RLOG0(L_ERROR, "Invalid suId");
350       return RFAILED;
351    }
352 #endif /* ERRCLASS & ERRCLS_INT_PAR */
353
354    if(ROK != rlcDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
355    {
356       RLOG0(L_ERROR, "Invalid transId");
357       return  (RFAILED);
358    }
359
360    if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
361    {
362       return RFAILED;
363    }
364
365    if(status.status == CKW_CFG_CFM_OK)
366    {
367        if(cfgTmpData->ueCb != NULLP) 
368        {
369       rlcCfgApplyUlUeIdChng(tRlcCb, cfgTmpData->ueInfo, cfgTmpData->newUeInfo, cfgTmpData);
370    }
371    }
372    RlcUiCkwUeIdChgCfm(&(tRlcCb->u.ulCb->ckwSap.pst),
373                      tRlcCb->u.ulCb->ckwSap.suId,
374                      transId,cfgTmpData->ueInfo,status);
375    /* only newUeInfo needs to be freed here, ueInfo would be freed at the 
376       interface or by he receipient in case of tight coupling */
377    RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->newUeInfo, sizeof(CkwUeInfo));
378    RLC_FREE_WC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
379    return ROK;
380
381
382 /**
383  * @brief 
384  *    Udx Status Prohibit Timer Start
385  *
386  *  @param[in] pst     Post structure  
387  *  @param[in] suId    Service User ID
388  *  @param[in] rlcId   rlc Id 
389  *  @return  S16
390  *      -# ROK 
391  *      -# RFAILED
392  */
393 S16  rlcUlUdxStaProhTmrStart
394 (
395 Pst*         pst,
396 SuId         suId,
397 CmLteRlcId   *rlcId
398 )
399 {
400    RlcCb       *tRlcCb= NULLP;
401    RlcUlRbCb   *rbCb;        
402
403 #if (ERRCLASS & ERRCLS_INT_PAR)
404    if (pst->dstInst >= MAX_RLC_INSTANCES)
405    {
406       return  (RFAILED);
407    }
408 #endif
409    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
410
411    rlcDbmFetchUlRbCbByRbId(tRlcCb, rlcId, &rbCb);
412    if (rbCb == NULLP)
413    {    
414       RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
415             rlcId->cellId,rlcId->rbId);
416       return RFAILED;
417    }
418
419    /* Start staProhTmr */
420    rlcStartTmr(tRlcCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
421
422    return  (ROK);
423
424
425 /**
426  * @brief 
427  *    Handler for configuration confirm from DL.
428  *
429  * @param[in] gCb        - RLC Instance Control Block
430  * @param[in] cfgTmpData - Configuration Temporary Data 
431  * @param[in] cfmInfo    - DL Configuration Confirm Info
432  * @param[out] cfgCfm    - Configuration Confirm to be sent to RRC
433  *
434  * @return  S16
435  *    -# ROK 
436  *    -# RFAILED
437  */
438 #ifdef ANSI
439 S16 rlcHdlCrlcUlCfgReq
440 (
441 RlcCb             *gCb,
442 RlcUlCfgTmpData   *cfgTmpData,
443 RlcCfgCfmInfo    *cfmInfo,
444 RlcCfgCfmInfo    *cfgCfm
445 )
446 #else
447 S16 rlcHdlCrlcUlCfgReq(gCb,cfgTmpData,cfmInfo,cfmInfo)
448 RlcCb             *gCb;
449 RlcUlCfgTmpData   *cfgTmpData;
450 RlcCfgCfmInfo    *cfmInfo;
451 RlcCfgCfmInfo    *cfgCfm;
452 #endif
453 {
454    RlcCfgInfo   *cfg;
455    U32          idx;
456    U32          maxEnt;
457    
458    cfg = cfgTmpData->cfgInfo;
459    maxEnt = (cfg->numEnt < CKW_MAX_ENT_CFG)? cfg->numEnt:CKW_MAX_ENT_CFG;
460
461    for (idx = 0; idx < maxEnt; idx++)
462    {
463       RlcEntCfgCfmInfo   *entCfgCfm;
464       RlcEntCfgCfmInfo   *entDlCfgCfm;
465       RlcEntCfgInfo      *entCfg;
466
467       entCfg  = &(cfg->entCfg[idx]);
468       entCfgCfm   = &(cfgCfm->entCfgCfm[idx]);
469       entDlCfgCfm = &(cfmInfo->entCfgCfm[idx]);
470       switch (entCfg->cfgType)
471       {
472          case CKW_CFG_ADD:
473          case CKW_CFG_MODIFY:
474          case CKW_CFG_DELETE:
475             {
476                if (entCfg->dir == RLC_DIR_UL)
477                {
478                   RLC_MEM_CPY(entCfgCfm, 
479                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm, 
480                              sizeof(RlcEntCfgCfmInfo)); 
481                }
482                else if (entCfg->dir == RLC_DIR_DL)
483                {
484                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo)); 
485                }
486                else if(entCfg->dir == RLC_DIR_BOTH)
487                {
488                   if (entDlCfgCfm->status.status != CKW_CFG_CFM_OK)
489                   {
490                      rlcCfgRollBackUlRb(gCb,
491                                        cfg->ueId,
492                                        &cfg->entCfg[idx], 
493                                        &cfgTmpData->cfgEntData[idx]);
494                   }
495                   else
496                   {
497                      rlcCfgApplyUlRb(gCb,  
498                                     &cfg->entCfg[idx], 
499                                     &cfgTmpData->cfgEntData[idx],
500                                     cfgTmpData);
501                   }
502                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo)); 
503                }
504                else
505                {
506                             RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
507                                            CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_DIR);
508                   RLOG_ARG2(L_ERROR,DBG_UEID,cfg->ueId,"RBID[%d] direction[%d] is invalid",
509                          entCfg->rbId,entCfg->dir);
510                }
511                break;
512             }
513
514          case CKW_CFG_REESTABLISH:
515             {
516                if (entCfg->dir == RLC_DIR_UL)
517                {
518                   RLC_MEM_CPY(entCfgCfm, 
519                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm, 
520                              sizeof(RlcEntCfgCfmInfo)); 
521                }
522                else if (entCfg->dir == RLC_DIR_DL)
523                {
524                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo)); 
525                }
526                else
527                {
528                   if (entCfg->dir & RLC_DIR_UL)
529                   {
530                      /* Reestablish indication is sent from UL Instance only*/
531                      if (entDlCfgCfm->status.status == CKW_CFG_CFM_OK)
532                      {
533                         rlcCfgApplyReEstUlRb (gCb, cfg->ueId, 
534                                              cfg->cellId, TRUE, 
535                                              &cfgTmpData->cfgEntData[idx]);
536                      }
537                      RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo)); 
538                   }
539                }
540                break;
541             }
542          case CKW_CFG_DELETE_UE:
543             {
544                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
545                {
546                   rlcCfgApplyDelUlUe(gCb, cfgTmpData);
547                   RLC_MEM_CPY(entCfgCfm, 
548                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm, 
549                              sizeof(RlcEntCfgCfmInfo)); 
550                }
551                else
552                {
553                    RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
554                               sizeof(RlcEntCfgCfmInfo)); 
555                }
556                break;
557             }
558          case CKW_CFG_DELETE_CELL:
559             {
560                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
561                {
562                   rlcCfgApplyDelUlCell(gCb, cfgTmpData);
563                   RLC_MEM_CPY(entCfgCfm, 
564                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm, 
565                              sizeof(RlcEntCfgCfmInfo)); 
566                }
567                else
568                {
569                    RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
570                               sizeof(RlcEntCfgCfmInfo)); 
571                }
572                break;
573             }
574          default:
575             {
576                RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
577                                    CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
578
579                RLOG0(L_ERROR,"Invalid configuration type");
580             }
581       }
582    }
583
584    /* Assign number of entity configurations and suId */
585    cfgCfm->transId = cfgTmpData->uprLyrTransId;
586    cfgCfm->ueId = cfg->ueId;
587    cfgCfm->cellId = cfg->cellId;
588    cfgCfm->numEnt = cfg->numEnt;
589
590    return ROK;
591 }
592 #ifdef __cplusplus
593 }
594 #endif /* __cplusplus */
595
596 \f
597 /**********************************************************************
598          End of file
599 **********************************************************************/