01fcde09a6026bf4d754887f98f78ea19ba2d98c
[o-du/l2.git] / src / 5gnrrlc / kw_ul_ex_ms.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 - System Services Interface Functions
22     
23         Type:    C file
24   
25         Desc:    C source code for the interface to System Services
26                   of LTE-RLC
27  
28         File:    kw_ul_ex_ms.c
29   
30 *********************************************************************21*/
31 static const char* RLOG_MODULE_NAME="RLC_UL";
32 static int RLOG_MODULE_ID=2048;
33 static int RLOG_FILE_ID=206;
34
35 /** @file kw_ul_ex_ms.c
36 @brief RLC System Services Interface
37 */
38
39 \f
40 /* header (.h) include files */
41 #include "common_def.h"
42 #include "lkw.h"           /* LKW defines */
43 #include "ckw.h"           /* CKW defines */
44 #include "kwu.h"           /* KWU defines */
45 #include "rgu.h"           /* RGU defines */
46 #include "kw_err.h"        /* Err defines */
47 #include "kw_env.h"        /* RLC environment options */
48 #include "kw.h"            /* RLC defines */
49 #include "kw_ul.h"
50 #include "kw_udx.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 #include "kw.x"
58 #include "kw_ul.x"
59 #include "kw_udx.x"
60
61 #include "rlc_mac_inf.h"
62 #include "du_app_rlc_inf.h"
63
64 #ifdef TENB_STATS 
65 #include "l2_tenb_stats.x"   
66 #endif
67
68 S16 rlcUlInitExt ARGS (( Void ));
69 \f
70 /**
71  *
72  * @brief
73  *
74  *  <b> Initialize External </b>
75  *
76  *  @b Description:
77  *  Initializes variables used to interface with Upper/Lower Layer  
78  *
79  *  @return  S16
80  *      -# ROK 
81  *
82 */
83   
84 #ifdef ANSI
85 S16 rlcUlInitExt 
86 (
87 )
88 #else
89 S16 rlcUlInitExt()
90 #endif
91 {
92
93    return ROK;
94 } /* kwInitExt */
95
96
97 \f
98 /***********************************************************************
99                       System Service Interface Functions
100  ***********************************************************************/
101 /**
102  *
103  * @brief
104  *
105  *    <b> Activates Initialization </b>
106  *
107  *    @b Description:
108  *    This function is invoked by system services to initialize the LTE-RLC
109  *    layer. This is an entry point used by LTE_RLC layer to initialize its
110  *    global variables, before becoming operational.
111  *
112  *    Allowable values for parameters are specified in ssi.h.
113  *
114  *    @param[in] ent    - Specify the entity id of the LTE-RLC task.
115  *    @param[in] inst   - Specify the entity id of the LTE-RLC task.
116  *    @param[in] region - Specifies the memory region from which
117  *                         LTE-RLC should allocate structures and buffers.
118  *    @param[in] reason - Specifies the reason for calling this
119  *                         initialization function.
120  *
121  *  @return  S16
122  *      -# ROK 
123  *
124  */
125 #ifdef ANSI
126 S16 rlcUlActvInit
127 (
128 Ent    ent,                 /* entity */
129 Inst   inst,                /* instance */
130 Region region,              /* region */
131 Reason reason               /* reason */
132 )
133 #else
134 S16 rlcUlActvInit(ent, inst, region, reason)
135 Ent    ent;                 /* entity */
136 Inst   inst;                /* instance */
137 Region region;              /* region */
138 Reason reason;              /* reason */
139 #endif
140 {
141    RlcCb    *tRlcCb;
142
143    if (inst >= MAX_RLC_INSTANCES)
144    {
145        /* intance greater than MAX instances */ 
146        return RFAILED; 
147    }
148
149    if (rlcCb[inst] != NULLP)
150    {
151        return  (RFAILED);
152    }
153   
154    if (SGetSBuf(region, 0, (Data **)&tRlcCb,
155                 (Size)sizeof (RlcCb)) != ROK)    
156    {                     
157       return RFAILED;
158    }
159
160    /* Initialize rlcCb */
161    RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
162
163    /* Initialize task configuration parameters */
164    tRlcCb->init.ent     = ent;           /* entity */
165    tRlcCb->init.inst    = inst;          /* instance */
166    tRlcCb->init.region  = region;        /* static region */
167    tRlcCb->init.pool    = 0;             /* static pool */
168    tRlcCb->init.reason  = reason;        /* reason */
169    tRlcCb->init.cfgDone = FALSE;         /* configuration done */
170    tRlcCb->init.acnt    = TRUE;          /* enable accounting */
171    tRlcCb->init.usta    = TRUE;          /* enable unsolicited status */
172    tRlcCb->init.trc     = FALSE;         /* enable trace */
173    tRlcCb->init.procId  = ODU_GET_PROCID();
174
175    rlcCb[inst] = tRlcCb;
176
177    /* call external function for intialization */
178    /*
179    kwInitExt();
180    */
181 #ifdef TENB_STATS 
182    TSL2AllocStatsMem(tRlcCb->init.region, tRlcCb->init.pool); 
183 #endif
184
185    return ROK;
186 } /* rlcUlActvInit */
187
188 \f
189 /**
190  *
191  * @brief
192  *
193  *  <b> Activation Task </b>
194  *
195  *  @b Description:
196  *  Processes events received for MLTE-RLC layer via System Services from
197  *  other layers.
198  *
199  *  @param[in] pst   - Pst Structure
200  *  @param[in] mBuf  - Message Buffer
201  *
202  *  @return  S16
203  *      -# ROK 
204  *
205  */
206 #ifdef ANSI
207 S16 rlcUlActvTsk
208 (
209 Pst *pst,              /* pst structure */
210 Buffer *mBuf            /* message buffer */
211 )
212 #else
213 S16 rlcUlActvTsk(pst, mBuf)
214 Pst *pst;              /* pst structure */
215 Buffer *mBuf;           /* message buffer */
216 #endif
217 {
218    S16 ret = ROK;
219
220
221    switch(pst->srcEnt)
222    {
223       case ENTDUAPP:
224          {
225             switch(pst->event)
226             {
227 #ifdef LCLKW
228                case LKW_EVT_CFG_REQ:
229                   {
230                      ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
231                      break;
232                   }
233
234                case LKW_EVT_CNTRL_REQ:
235                   {
236                      ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
237                      break;
238                   }
239                
240                case EVENT_RLC_UL_UE_CREATE_REQ:        /* UE Create Request */
241                   {
242                      ret = unpackRlcUlUeCreateReq(RlcUlProcUeCreateReq, pst, mBuf);
243                      break;
244                   }
245
246                case LKW_EVT_STS_REQ:
247                   {
248                      ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
249                      break;
250                   }
251
252                case LKW_EVT_STA_REQ:
253                   {
254                      ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
255                      break;
256                   }
257                   /* kw005.201 added support for L2 Measurement */
258 #ifdef LTE_L2_MEAS
259                case LKW_EVT_L2MEAS_REQ:
260                   {
261                      ret = cmUnpkLkwL2MeasReq(RlcMiLkwL2MeasReq, pst, mBuf);
262                      break;
263                   }
264                case LKW_EVT_L2MEAS_SEND_REQ:
265                  {
266
267                     ret = cmUnpkLkwL2MeasSendReq(RlcMiLkwL2MeasSendReq, pst, mBuf); 
268   
269                      break;
270                  }
271                case LKW_EVT_L2MEAS_STOP_REQ:
272                  {
273                      ret = cmUnpkLkwL2MeasStopReq(RlcMiLkwL2MeasStopReq, pst, mBuf);
274                      break;
275                  }
276 #endif
277 #endif  /* LCLKW */
278                default:
279                   ODU_PUT_MSG_BUF(mBuf);
280                   if (pst->dstInst < MAX_RLC_INSTANCES)
281                   {
282                      RLOG1(L_FATAL,"Received Invalid Event[%d] from SM",
283                             pst->event);
284                   }
285                   ret = RFAILED;
286                   break;
287
288             }
289             break;
290          }
291
292       case ENTRLC:
293          {
294             switch(pst->event)
295             {
296 #ifdef LCUDX
297                case UDX_EVT_BND_CFM:              /* Bind request */
298                   {
299                      ret = cmUnpkUdxBndCfm(rlcUlUdxBndCfm, pst, mBuf );
300                      break;
301                   }
302
303                case UDX_EVT_CFG_CFM:             /* Unbind request */
304                   {
305                      ret = cmUnpkUdxCfgCfm(rlcUlUdxCfgCfm, pst, mBuf );
306                      break;
307                   }
308
309                case UDX_EVT_UEIDCHG_CFM:              /* Configuration request */
310                   {
311                      ret = cmUnpkUdxUeIdChgCfm(rlcUlUdxUeIdChgCfm, pst, mBuf);
312                      break;
313                   }
314                
315                case UDX_EVT_STA_PHBT_TMR_START:              /* Status Prohibit Timer Start */
316                   {
317                      ret = cmUnpkUdxStaProhTmrStart(rlcUlUdxStaProhTmrStart, pst, mBuf);
318                      break;
319                   }               
320
321 #endif  /* LCCKW */
322
323                default:
324                   ODU_PUT_MSG_BUF(mBuf);
325                   if (pst->dstInst < MAX_RLC_INSTANCES)
326                   {
327                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
328                             pst->event);
329                   }
330                   ret = RFAILED;
331                   break;
332
333             }
334             break;
335          }
336
337       case ENTNH:
338          {
339             switch(pst->event)
340             {
341 #ifdef LCCKW
342                case CKW_EVT_BND_REQ:              /* Bind request */
343                   {
344                      ret = cmUnpkCkwBndReq(RlcUiCkwBndReq, pst, mBuf );
345                      break;
346                   }
347
348                case CKW_EVT_UBND_REQ:             /* Unbind request */
349                   {
350                      ret = cmUnpkCkwUbndReq(RlcUiCkwUbndReq, pst, mBuf );
351                      break;
352                   }
353
354                case CKW_EVT_UEIDCHG_REQ:              /* Configuration request */
355                   {
356                      ret = cmUnpkCkwUeIdChgReq(RlcUiCkwUeIdChgReq, pst, mBuf);
357                      break;
358                   }
359
360 #endif  /* LCCKW */
361
362 #ifdef LCKWU
363                case KWU_EVT_BND_REQ:              /* Bind request */
364                   {
365                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
366                      break;
367                   }
368
369                case KWU_EVT_UBND_REQ:             /* Unbind request */
370                   {
371                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
372                      break;
373                   }
374 #endif  /* LCKWU */
375                default:
376                   ODU_PUT_MSG_BUF(mBuf);
377                   if (pst->dstInst < MAX_RLC_INSTANCES)
378                   {
379                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC", 
380                             pst->event);
381                   }
382                   ret = RFAILED;
383                   break;
384
385             }
386             break;
387          }
388
389       case ENTPJ:
390          {
391             switch(pst->event)
392             {
393 #ifdef LCKWU
394                case KWU_EVT_BND_REQ:              /* Bind request */
395                   {
396                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
397                      break;
398                   }
399
400                case KWU_EVT_UBND_REQ:             /* Unbind request */
401                   {
402                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
403                      break;
404                   }
405
406                default:
407                   ODU_PUT_MSG_BUF(mBuf);
408                   if (pst->dstInst < MAX_RLC_INSTANCES)
409                   {
410                       RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP", 
411                             pst->event);
412                   }
413                   ret = RFAILED;
414                   break;
415 #endif  /* LCKWU */
416                }
417             break;
418          }
419
420       case ENTMAC:
421          {
422             switch(pst->event)
423             {
424 #ifdef LCRGU
425                case EVTRGUBNDCFM:     /* Bind request */
426                   {
427                      ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
428                      break;
429                   }
430
431                case EVENT_UL_DATA_TO_RLC:    /* UL Data request */
432                   {
433                      ret = unpackRlcUlData(RlcProcUlData, pst, mBuf);
434                      break;
435                   }
436
437 #endif  /* LCRGU */
438
439                default:
440                   ODU_PUT_MSG_BUF(mBuf);
441                   if (pst->dstInst < MAX_RLC_INSTANCES)
442                   {
443                       RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
444                             pst->event);
445                   }
446                   ret = RFAILED;
447                   break;
448             }
449             break;
450          }
451 #if defined(L2_L3_SPLIT) && defined (TENB_T2K3K_SPECIFIC_CHANGES) && defined (MAC_RLC_UL_RBUF)
452       case ENTYS:
453          {
454             switch(pst->event)
455             {
456                case KWU_EVT_TTI_IND:
457                   {
458                      rlcUlBatchProc();
459                      ODU_PUT_MSG_BUF(mBuf);
460                      break;
461                   }
462             }
463             break;
464          }
465 #endif/* End for TENB_T2K3K_SPECIFIC_CHANGES and L2_L3_SPLIT */
466 #ifndef UL_RLC_NET_CLUSTER
467 #ifdef TENB_STATS
468       case ENTLWRMAC:
469          {
470             switch(pst->event)
471             {
472                case TENBSTATSINIT:
473                {
474                   
475                   RlcCb *tRlcCb;
476                   tRlcCb = RLC_GET_RLCCB(pst->dstInst);
477
478                   TSL2SendStatsToApp(&(tRlcCb->genCfg.lmPst), 0);
479                   ODU_PUT_MSG_BUF(mBuf);
480                   break;
481                }
482                default:
483                {
484                   printf("\n ERROR Invalid Event[%d] from CL to PDCPUL\n", 
485                          pst->event);
486                   ODU_PUT_MSG_BUF(mBuf);
487                   break;
488                }
489             }
490             break;
491          }
492 #endif
493 #endif
494       default:
495          {
496           if (pst->dstInst < MAX_RLC_INSTANCES)
497            {
498               RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",pst->event);
499            }
500             ODU_PUT_MSG_BUF(mBuf);
501             ret = RFAILED;
502             break;
503          }
504     }
505    ODU_EXIT_TASK();
506
507    return (ret);
508 } /* kwActvTsk */
509
510
511 \f  
512 /********************************************************************30**
513          End of file
514 **********************************************************************/