Update in ODU high and near RT RIC IP address for integration
[o-du/l2.git] / src / 5gnrrlc / kw_ptli.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 - Lower Interface
22     
23         Type:    C file
24   
25         Desc:    C source code for the lower interface of LTE-RLC
26  
27         File:    kw_ptli.c
28   
29 *********************************************************************21*/
30
31 /** @file kw_ptli.c 
32 @brief RLC Lower Interface
33 */
34
35 \f
36 /* header (.h) include files */
37 #include "envopt.h"        /* environment options */
38 #include "envdep.h"        /* environment dependent */
39 #include "envind.h"        /* environment independent */
40
41 #include "gen.h"           /* general */
42 #include "ssi.h"           /* system services */
43 #include "cm5.h"           /* common timer defines */
44 #include "cm_tkns.h"       /* common tokens defines */
45 #include "cm_mblk.h"       /* common memory allocation library defines */
46 #include "cm_llist.h"      /* common link list  defines  */
47 #include "cm_hash.h"       /* common hash list  defines */
48 #include "cm_lte.h"        /* common LTE defines */
49 #include "lkw.h"           /* LKW defines */
50 #include "ckw.h"           /* CKW defines */
51 #include "kwu.h"           /* KWU defines */
52 #include "rgu.h"           /* RGU defines */
53 #ifdef KW_PDCP
54 #include "cpj.h"           /* CPJ defines */
55 #include "pju.h"           /* PJU defines */
56 #include "lpj.h"           /* LPJ defines */
57 #endif
58 #include "kw_err.h"
59 #include "kw_env.h"        /* RLC environment options */
60 #include "kw.h"            /* RLC defines */
61
62 /* extern (.x) include files */
63 #include "gen.x"           /* general */
64 #include "ssi.x"           /* system services */
65
66 #include "cm5.x"           /* common timer library */
67 #include "cm_tkns.x"       /* common tokens */
68 #include "cm_mblk.x"       /* common memory allocation */
69 #include "cm_llist.x"      /* common link list */
70 #include "cm_hash.x"       /* common hash list */
71 #include "cm_lte.x"        /* common LTE includes */
72 #include "cm_lib.x"        /* common memory allocation library */
73 #include "lkw.x"           /* LKW */
74 #include "ckw.x"           /* CKW */
75 #include "kwu.x"           /* KWU */
76 #include "rgu.x"           /* RGU */
77 #ifdef KW_PDCP
78 #include "cpj.x"           /* CPJ defines */
79 #include "pju.x"           /* PJU defines */
80 #include "lpj.x"           /* LPJ defines */
81 #endif
82 #include "kw.x"
83 #include "ss_rbuf.h"
84 #include "ss_rbuf.x"
85
86 #ifdef EGTP_TEST
87 #include "mac_stub.h"
88 #endif /* EGTP_TEST */
89
90 #ifndef LCKWLIRGU
91 #define PTKWRGU
92 #endif
93
94 #ifndef RG
95 #define PTKWRGU
96 #endif
97
98 #ifdef __cplusplus
99 EXTERN "C" {
100 #endif /* __cplusplus */
101
102
103
104 #ifdef RLC_MAC_DAT_REQ_RBUF
105 PUBLIC S16 kwLiRguDatReqRbuf(Pst *Post,SpId spId,Void *datReq);
106 #endif
107
108 #ifdef RLC_MAC_STA_RSP_RBUF
109 PUBLIC S16 kwLiRguStaRspRbuf(Pst *Post,SpId spId,Void  *staRsp);
110 #endif
111 #if defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)
112 EXTERN S16 KwDlHarqStaBatchProc (Void);
113 #endif
114
115 \f
116 /*********************************************************************
117  *             Primitives for RGU interface 
118  ********************************************************************/
119
120 /* RGU Bind Request primitive */
121
122 PUBLIC RguBndReq kwLiRguBndReqMt[] =
123 {
124 #ifdef LCKWLIRGU
125    cmPkRguBndReq,            /* 0 - loosely coupled */
126 #endif /* LCRGUIRGU */
127 #ifdef RG 
128    RgUiRguBndReq,            /* 1 - tightly coupled, MAC  */
129 #endif /* RG */
130 #ifdef LCKWLIRGU
131    cmPkRguBndReq,            /* 0 - loosely coupled */
132 #endif /* LCRGUIRGU */
133 };
134
135 /* RGU Unbind Request primitive */
136
137 PUBLIC RguBndReq kwLiRguUbndReqMt[] =
138 {
139 #ifdef LCKWLIRGU
140    cmPkRguUbndReq,            /* 0 - loosely coupled */
141 #endif /* LCRGUIRGU */
142 #ifdef RG 
143    RgUiRguUbndReq,            /* 1 - tightly coupled, MAC  */
144 #endif /* RG */
145 #ifdef LCKWLIRGU
146    cmPkRguUbndReq,            /* 0 - loosely coupled */
147 #endif /* LCRGUIRGU */
148 };
149
150 /* RGU Dedicated Channel Data Request primitive */
151
152 PUBLIC RlcMacDlData rlcMacSendDlDataOpts[] =
153 {
154 #ifdef EGTP_TEST
155    macStubSendDlData,
156    macStubSendDlData,
157    macStubSendDlData,
158 #else /* EGTP_TEST */
159 #ifdef LCKWLIRGU
160    packDlData,            /* 0 - loosely coupled */
161 #endif /* LCRGUIRGU */
162 #ifdef RG 
163    MacRlcProcDlData,      /* 1 - tightly coupled, MAC  */
164 #endif /* RG */
165 #ifdef LCKWLIRGU
166    packDlData,            /* 0 - loosely coupled */
167 #endif /* LCRGUIRGU */
168 #endif /* EGTP_TEST */
169 };
170
171
172 /* RLC logical Channel Status primitive */
173
174 PUBLIC RlcMacBoStatus rlcMacSendBOStatusOpts[] =
175 {
176 #ifdef EGTP_TEST
177    macStubBOStatus,
178    macStubBOStatus,
179    macStubBOStatus,
180 #else /* EGTP_TEST */
181 #ifdef LCKWLIRGU
182    packBOStatus,            /* 0 - loosely coupled */
183 #endif /* LCRGUIRGU */
184 #ifdef RG 
185    MacRlcProcBOStatus,            /* 1 - tightly coupled, MAC  */
186 #endif /* RG */
187 #ifdef LCKWLIRGU
188    packBOStatus,            /* 0 - LWLC loosely coupled */
189 #endif /* LCRGUIRGU */
190 #endif /* EGTP_TEST */
191 };
192
193 /* kw005.201 added support for L2 Measurement */
194 #ifdef LTE_L2_MEAS
195 #ifdef LTE_RLC_R9
196 /* RGU L2 Measurement Ul Ip Throughput Measurement Request primitive */
197
198 PUBLIC RguL2MUlThrpMeasReq kwLiRguL2MUlThrpMeasReqMt[] =
199 {
200 #ifdef LCKWLIRGU
201    cmPkRguL2MUlThrpMeasReq,            /* 0 - loosely coupled */
202 #endif /* LCRGUIRGU */
203 #ifdef RG 
204    RgUiRguL2MUlThrpMeasReq,            /* 1 - tightly coupled, MAC  */
205 #endif /* RG */
206 };
207 #endif /* LTE_RLC_R9 */
208 #endif /*  LTE_L2_MEAS */
209 \f
210 /****************************************************************************
211  *                         RGU Interface Mt functions
212  ***************************************************************************/
213 /**
214  *
215  * @brief 
216  *
217  *        Handler for RGU SAP bind Request.
218  *
219  * @b Description:
220  *
221  *        This function is used by RLC to request for binding to 
222  *        MAC for accessing MAC services.This function binds MAC's 
223  *        SAP (identified by spId) with the service user's SAP 
224  *        (identified by suId).
225  *
226  *  @param[in] pst   Post structure  
227  *  @param[in] suId  Service user SAP ID 
228  *  @param[in] spId  Service provider ID
229  *
230  *  @return  S16
231  *      -# ROK 
232  */
233
234 #ifdef ANSI
235 PUBLIC S16 KwLiRguBndReq
236 (
237 Pst  *post,                       /* post structure */
238 SuId suId,                      /* Service User Id */
239 SpId spId                       /* Service Provider Id */
240 )
241 #else
242 PUBLIC S16 KwLiRguBndReq(post, suId, spId)
243 Pst  *post;                       /* post structure */
244 SuId suId;                      /* Service User Id */
245 SpId spId;                      /* Service Provider Id */
246 #endif
247 {
248    TRC3(KwLiRguBndReq)
249
250    /* jump to specific primitive depending on configured selector */
251    (*kwLiRguBndReqMt[post->selector])(post, suId, spId);
252
253    RETVALUE(ROK);
254
255 } /* end of KwLiRguBndReq */
256
257 \f
258 /**
259  *
260  * @brief 
261  *
262  *        Handler for bind confirmation from MAC.
263  *
264  * @b Description:
265  *
266  *        This function handles the bind confirmation received
267  *        from MAC. 
268  *
269  *  @param[in] post     - Post structure  
270  *  @param[in] suId    - Service provider SAP ID 
271  *  @param[in] reason  - Reason of confirmation
272  *
273  *  @return  S16
274  *      -# ROK 
275  */
276
277 #ifdef ANSI
278 PUBLIC S16 KwLiRguUbndReq
279 (
280 Pst         *post,
281 SpId        spId,
282 Reason      reason
283 )
284 #else
285 PUBLIC S16 KwLiRguUbndReq(post, spId, reason)
286 Pst         *post;
287 SpId        spId;
288 Reason      reason;
289 #endif
290 {
291    TRC3(KwLiRguUbndReq)
292
293    /* jump to specific primitive depending on configured selector */
294    (*kwLiRguUbndReqMt[post->selector])(post, spId, reason);
295
296    RETVALUE(ROK);
297
298 } /* end of KwLiRguUbndReq */
299
300 \f  
301 /**
302  *
303  * @brief 
304  *
305  *        Handler for sending PDU(s) from RLC to MAC for dedicated logical channels. 
306  *
307  * @b Description:
308  *
309  *        This function sends PDU(s) to MAC via one or more dedicated 
310  *        logical channels along with the Buffer Occupancy of these
311  *        channels.
312  *
313  *  @param[in] post         Post structure  
314  *  @param[in] spId        Service Provider ID
315  *  @param[in] datIndInfo  Data Request Information 
316  *
317  *  @return  S16
318  *      -# ROK 
319  *      -# RFAILED
320  *
321  */
322 #ifdef ANSI
323 PUBLIC S16 RlcMacSendDlData
324 (
325 Pst               *post,
326 SpId              spId,
327 RlcMacData       *dlData
328 )
329 #else
330 PUBLIC S16 RlcMacSendDlData(post, spId, dlData)
331 Pst               *post;
332 SpId              spId;
333 RlcMacData        *dlData;
334 #endif
335 {
336    TRC3(RlcMacSendDlData)
337 #ifdef RLC_MAC_DAT_REQ_RBUF
338         post->event=EVTRGUDDATREQ;
339       if((kwLiRguDatReqRbuf(post, spId, datReq)) != ROK)
340       {
341
342       SPutStaticBuffer(post->region, post->pool,                      
343                       (Data *) datReq, sizeof(RguDDatReqInfo), 0);             
344          RETVALUE(RFAILED);
345       }
346 #else
347    /* jump to specific primitive depending on configured selector */
348    (*rlcMacSendDlDataOpts[post->selector])(post, spId, dlData);
349 #endif 
350    RETVALUE(ROK);
351
352 } /* end of KwLiRguDDatReq */
353
354
355 \f  
356 /**
357  *
358  * @brief  
359  *
360  *        Handler for reporting the Buffer Occupancy to MAC 
361  *        for logical channels.
362  *
363  * @b Description:
364  *
365  *        This function reports the Buffer Occupancy of one or more
366  *         logical channels to MAC. 
367  *
368  *  @param[in] post         Post structure  
369  *  @param[in] spId        Service Provider ID
370  *  @param[in] boSta       BO Status Information 
371  *
372  *  @return  S16
373  *      -# ROK 
374  *      -# RFAILED
375  *
376  */
377 #ifdef ANSI
378 PUBLIC S16 RlcMacSendBOStatus
379 (
380 Pst               *post,
381 SpId              spId,
382 RlcMacBOStatus    *boSta
383 )
384 #else
385 PUBLIC S16 RlcMacSendBOStatus(post, spId, staRsp)
386 Pst               *post;
387 SpId              spId;
388 RlcMacBOStatus    *boSta;
389 #endif
390 {
391    TRC3(RlcMacSendBOStatus)
392 #if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
393        post->event= EVTRGUDSTARSP;
394       if((kwLiRguStaRspRbuf(post, spId, staRsp)) != ROK)
395       {
396          RETVALUE(RFAILED);
397       }
398 #endif 
399    /* jump to specific primitive depending on configured selector */
400    (*rlcMacSendBOStatusOpts[post->selector])(post, spId, boSta);
401
402    RETVALUE(ROK);
403
404 } /* end of RlcMacSendBOStatus */
405
406
407 /* kw005.201 added support for L2 Measurement */
408 #ifdef LTE_L2_MEAS
409 #ifdef LTE_RLC_R9
410 \f  
411 /**
412  *
413  * @brief 
414  *
415  *        Handler for sending ulThrpMeasReqInfo from RLC to MAC for UL ip throughput measurement. 
416  *
417  * @b Description:
418  *
419  *        This function sends ulThrpMeasReqInfo from RLC to MAC whenver UL ip throughput
420  * measurement is ON for a single or multiple qci in a UE. This is an indication for MAC
421  * to start the T2/T1 time stamps for the coresponding LCHs in the UE.
422  *
423  *  @param[in] post                    Post structure  
424  *  @param[in] spId                   Service Provider ID
425  *  @param[in] ulThrpMeasReqInfo      Ul ip measurement request info
426  *
427  *  @return  S16
428  *      -# ROK 
429  *      -# RFAILED
430  *
431  */
432 #ifdef ANSI
433 PUBLIC S16 KwLiRguL2MUlThrpMeasReq
434 (
435 Pst                     *post,
436 SpId                    spId,
437 RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq
438 )
439 #else
440 PUBLIC S16 KwLiRguL2MUlThrpMeasReq(post, spId, l2mUlThrpMeasReq)
441 Pst                     *post;
442 SpId                    spId;
443 RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq;
444 #endif
445 {
446    TRC3(KwLiRguL2MUlThrpMeasReq)
447
448    /* jump to specific primitive depending on configured selector */
449    (*kwLiRguL2MUlThrpMeasReqMt[post->selector])(post, spId, l2mUlThrpMeasReq);
450
451    RETVALUE(ROK);
452
453 } /* end of KwLiRguL2MUlThrpMeasReq */
454
455 #endif /* LTE_RLC_R9 */
456 #endif /* LTE_L2_MEAS */
457
458
459 #ifdef MAC_RLC_UL_RBUF
460 PUBLIC S16 kwUlBatchProc ARGS ((Void));
461 EXTERN Void kwUtlFreeUlRBuf ARGS((void));
462
463 #ifdef ANSI
464 PUBLIC S16 kwUlBatchProc
465 (
466 Void
467 )
468 #else
469 PUBLIC S16 kwUlBatchProc()
470 Void;
471 #endif
472 {
473 /* Read from Ring Buffer and process PDCP packets */
474    RguDDatIndInfo   *datInd;
475    Void *elmIndx = NULLP;
476    PRIVATE Pst rlcUlRbfuPst={1,1,ENTKW,0,ENTRG,0,PRIOR0,RTESPEC,EVTRLCULDAT,0,0,0,0};
477 /* Read from Ring Buffer and process PDCP packets */
478
479 #ifndef SS_RBUF
480    RguDedDatInd1 *rguDatInd = NULLP;
481    U8 rngBufDeqIndx = 0;
482
483    elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
484    while(NULLP != elmIndx)
485    {
486       rguDatInd = (RguDedDatInd1 *)elmIndx;
487       datInd = (RguDDatIndInfo*) rguDatInd->msg; 
488       SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].nPktProc++;;//Number of pkt processed in tti
489       if(datInd != NULLP)
490       {
491          KwLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
492       }
493       else
494       {
495          RLOG0(L_ERROR,"Received NULL buffer");
496       }
497       rguDatInd->msg=NULLP;
498       SRngIncrRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
499       elmIndx = NULLP;
500       rguDatInd = NULLP;
501
502       rngBufDeqIndx++;
503
504       //if(rngBufDeqIndx >= SS_RNG_MAX_ULMAC_TO_ULRLC_DQ_CNT)
505        // break;
506
507       if((elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC)) == NULLP)
508       break;
509    }
510 #else
511    elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
512    while(NULLP != elmIndx)
513    {
514       datInd = (RguDDatIndInfo *)elmIndx;
515       KwLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
516
517       elmIndx = NULLP;
518       datInd = NULLP;
519       SRngIncrRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
520
521       if((elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC)) == NULLP)
522         break;
523    }
524 #endif
525    RETVALUE(ROK);
526
527 }
528
529 /**
530  *
531  * @brief 
532  *        Handler to clear Ring buffer from UL RLC
533  *
534  * @details
535  *         This function clears all the ring buffer content from  UL RLC
536  *
537  * @return  S16
538  *      -# ROK 
539  *      -# RFAILED
540  *
541  */
542 #ifdef ANSI
543 PUBLIC Void kwUtlFreeUlRBuf(void)
544 #else
545 PUBLIC Void kwUtlFreeUlRBuf()  
546 #endif
547 {
548    RguDDatIndInfo *datInd;
549    PTR            elem;
550    U8             numLch;
551    U8             numPdu;
552
553    TRC2(kwUtlFreeUlRBuf)
554    /* Free SS_RNG_BUF_ULMAC_TO_ULRLC  */
555    while((SDeqSRngBuf (SS_RNG_BUF_ULMAC_TO_ULRLC, &elem) == ROK))
556    {
557       datInd = (RguDDatIndInfo *)elem; 
558       for(numLch = 0; numLch< datInd->numLch; numLch++)
559       {
560          for(numPdu = 0; numPdu < datInd->lchData[numLch].pdu.numPdu; numPdu++)
561          {
562             if(datInd->lchData[numLch].pdu.mBuf[numPdu])
563             {
564                KW_FREE_BUF_WC(datInd->lchData[numLch].pdu.mBuf[numPdu]);
565             }
566          }
567       }
568       KW_PST_FREE(0, 0, datInd, sizeof(RguDDatIndInfo)); 
569    }
570 }
571 #endif
572 #ifdef RLC_MAC_STA_RSP_RBUF
573 #ifdef ANSI
574 PUBLIC S16 kwLiRguStaRspRbuf
575 (
576 Pst               *post,
577 SpId              spId,
578 Void             *staRsp
579 )
580 #else
581 PUBLIC S16 kwLiRguStaRspRbuf(post, spId, staRsp)
582 Pst               *post;
583 SpId              spId;
584 Void              *staRsp;
585 #endif /* ANSI */
586 {
587    S16 ret1 = ROK;
588    
589    Void *elem = NULLP;
590
591    RguDStaRspInfo  *staRspInfo = NULL;
592    elem = SRngGetWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
593    if (NULLP != elem)
594    {
595       staRspInfo = (RguDStaRspInfo *)elem;
596       cmMemcpy((U8 *)staRspInfo, (U8 *)staRsp, sizeof(RguDStaRspInfo)); 
597       staRspInfo->post = *post;
598       SRngIncrWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
599       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].pktRate++;
600    }   
601    else
602    {
603       RLOG0(L_ERROR,"RLC DL STA RSP RBUF is FULL!!! ");
604       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].pktDrop++;
605       ret1 = RFAILED;
606    }
607    RETVALUE(ret1);
608 } /* cmPkKwuDatReq */
609
610 #endif
611 #ifdef RLC_MAC_DAT_REQ_RBUF
612 #ifdef ANSI
613 PUBLIC S16 kwLiRguDatReqRbuf
614 (
615 Pst               *post,
616 SpId              spId,
617 Void             *datReq
618 )
619 #else
620 PUBLIC S16 kwLiRguDatReqRbuf(post, spId, datReq)
621 Pst               *post;
622 SpId              spId;
623 Void             *datReq;
624 #endif /* ANSI */
625 {
626    S16 ret1 = ROK;
627    
628    Void *elem = NULLP;
629    RguInfoRingElem *datReqRing=NULLP;
630    elem = SRngGetWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ);
631    if (NULLP != elem)
632    {
633       datReqRing = (RguInfoRingElem *) elem;
634       datReqRing->spId = spId;
635       datReqRing->event = post->event;
636       datReqRing->msg =datReq;
637       SRngIncrWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ);
638       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].pktRate++;
639    }   
640    else
641    {
642       printf("RLC DL DAT REQ RBUF is FULL!!! \n");
643       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].pktDrop++;
644       ret1 = RFAILED;
645    }
646    RETVALUE(ret1);
647 } /* cmPkKwuDatReq */
648
649 #endif 
650
651 #ifdef __cplusplus
652 }
653 #endif /* __cplusplus */
654 \f  
655 /********************************************************************30**
656          End of file
657 **********************************************************************/