518094c1e3f2f49563e0b5b781bccefd3e77b4fb
[o-du/l2.git] / src / du_app / du_f1ap_conversions.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 /* This file contains functions that maps values received in F1AP message with
20  * its corresponding values used in DU and vice-versa */
21
22 #include "common_def.h"
23 #include "SN-FieldLengthUM.h"
24 #include "SN-FieldLengthAM.h"
25 #include "T-PollRetransmit.h"
26 #include "PollPDU.h"
27 #include "PollByte.h"
28 #include "UL-AM-RLC.h"
29 #include "T-Reassembly.h"
30 #include "T-StatusProhibit.h"
31 #include "DL-AM-RLC.h"
32 #include "RLC-Config.h"
33 #include "RLC-BearerConfig.h"
34 #include "BSR-Config.h"
35 #include "PUCCH-Resource.h"
36 #include "du_app_rlc_inf.h"
37
38 /************************************************************************
39  *
40  * @brief Coverts Internal Enum value to RRC code enum for RB type 
41  *
42  * @details
43  *
44  *    Function : covertRbTypeFromIntEnumToRrcEnum
45  *
46  *    Functionality: Coverts Internal Enum value to RRC code enum for RB type 
47  *
48  * @params[in] Internal Enum value for RB type
49  * @return RRC codec enum value for RB type
50  *
51  * **********************************************************************/
52 RLC_BearerConfig__servedRadioBearer_PR covertRbTypeFromIntEnumToRrcEnum(RlcRbType rbType)
53 {
54    switch(rbType)
55    {
56       case RB_TYPE_SRB:
57          return RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
58       case RB_TYPE_DRB:
59          return RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
60       default:
61          return RLC_BearerConfig__servedRadioBearer_PR_NOTHING;
62    }
63 }
64
65 /************************************************************************
66  *
67  * @brief Coverts internal enum value to RRC code enum for RLC mode
68  *
69  * @details
70  *
71  *    Function : covertRlcModeFromIntEnumToRrcEnum
72  *
73  *    Functionality: Coverts internal enum value to RRC code enum for RLC mode
74  *
75  * @params[in] Internal enum value for RLC mode
76  * @return RRC codec enum value for RLC mode
77  *
78  * **********************************************************************/
79 RLC_Config_PR covertRlcModeFromIntEnumToRrcEnum(RlcMode mode)
80 {
81    switch(mode)
82    {
83       case RLC_AM:
84          return RLC_Config_PR_am;
85       case RLC_UM_BI_DIRECTIONAL:
86          return RLC_Config_PR_um_Bi_Directional;
87       case RLC_UM_UNI_DIRECTIONAL_UL:
88          return RLC_Config_PR_um_Uni_Directional_UL;
89       case RLC_UM_UNI_DIRECTIONAL_DL:
90          return RLC_Config_PR_um_Uni_Directional_DL;
91       default:
92          return RLC_Config_PR_NOTHING;
93    }
94 }
95
96 /************************************************************************
97  *
98  * @brief Converts Internal enum value to RRC code enum value for AM mode 
99  * SN Length
100  *
101  * @details
102  *
103  *    Function : covertAmSnLenFromIntEnumToRrcEnum 
104  *
105  *    Functionality: Converts Internal enum value to RRC code enum value for AM
106  *    mode SN Length
107  *
108  * @params[in] Internal Enum value 
109  * @return RRC Enum value
110  *
111  * **********************************************************************/
112 SN_FieldLengthAM_t covertAmSnLenFromIntEnumToRrcEnum(SnLenAm snLen)
113 {
114    switch(snLen)
115    {
116       case AM_SIZE_12:
117          return SN_FieldLengthAM_size12;
118       case AM_SIZE_18:
119          return SN_FieldLengthAM_size18; 
120       default:
121          return SN_FieldLengthAM_size12;
122    }
123 }
124
125 /************************************************************************
126  *
127  * @brief Coverts RRC ASN enum value to Internal Enum value 
128  *
129  * @details
130  *
131  *    Function : covertAmSnLenFromRrcEnumToIntEnum
132  *
133  *    Functionality: Coverts RRC ASN enum value to Internal Enum value for
134  *    AM mode SN length
135  *
136  * @params[in] RRC ASN Enum value
137  * @return Internal Enum value
138  *
139  * **********************************************************************/
140 SnLenAm covertAmSnLenFromRrcEnumToIntEnum(SN_FieldLengthAM_t snLen)
141 {
142    switch(snLen)
143    {
144       case SN_FieldLengthAM_size12:
145          return AM_SIZE_12;
146       case SN_FieldLengthAM_size18:
147          return AM_SIZE_18;
148       default:
149          return AM_SIZE_12;
150    }
151 }
152
153 /************************************************************************
154  *
155  * @brief Coverts Internal Enum value to RRC ASN enum value
156  *
157  * @details
158  *
159  *    Function : covertUmSnLenFromIntEnumToRrcEnum
160  *
161  *    Functionality: Coverts Internal ennum value to  RRC ASN enum value
162  *    for UM mode SN length
163  *
164  * @params[in] Internal enum value 
165  * @return RRC ASN value
166  *
167  * **********************************************************************/
168 SN_FieldLengthUM_t covertUmSnLenFromIntEnumToRrcEnum(SnLenUm snLen)
169 {
170    switch(snLen)
171    {
172       case UM_SIZE_6:
173          return SN_FieldLengthUM_size6;
174       case UM_SIZE_12:
175          return SN_FieldLengthUM_size12;
176       default:
177          return SN_FieldLengthUM_size12;
178    }
179 }
180
181 /************************************************************************
182  *
183  * @brief Converts RRC ASN enum value to Internal enum value
184  *
185  * @details
186  *
187  *    Function : covertUmSnLenFromRrcEnumToIntEnum 
188  *
189  *    Functionality: Converts RRC ASN enum value to Internal enum value
190  *    for UM mode SN length
191  *
192  * @params[in] RRC ASN enum value 
193  * @return Internal enum value
194  *
195  * **********************************************************************/
196 SnLenUm covertUmSnLenFromRrcEnumToIntEnum(SN_FieldLengthUM_t snLen)
197 {
198    switch(snLen)
199    {
200       case SN_FieldLengthUM_size6:
201          return UM_SIZE_6;
202       case SN_FieldLengthUM_size12:
203          return UM_SIZE_12;
204       default:
205          return UM_SIZE_12;
206    }
207 }
208
209 /************************************************************************
210  *
211  * @brief Converts poll retransmission timer value to its corresponding enum 
212  *
213  * @details
214  *
215  *    Function : covertPollRetxTmrValueToEnum
216  *
217  *    Functionality: Converts poll retransmission timer value to its
218  *    corresponding enum
219  *
220  * @params[in] Poll retransmission timer value
221  * @return Poll retransmission timer enum
222  *
223  * **********************************************************************/
224 T_PollRetransmit_t covertPollRetxTmrValueToEnum(uint16_t pollRetxTmr)
225 {
226    /* All values of poll retx timer are at interval of 5ms starting from 5ms(Enum value 0) upto 250ms
227     * Hence converting the value to enum by dividing it to 5 and subtracting 1.
228     */
229    if((pollRetxTmr <= 250) && ((pollRetxTmr%5) == 0))
230       return ((pollRetxTmr/5) -1);
231    else
232    {
233       switch(pollRetxTmr)
234       {
235          case 300:
236             return T_PollRetransmit_ms300;
237          case 350:
238             return T_PollRetransmit_ms350;
239          case 400:
240             return T_PollRetransmit_ms400;
241          case 450:
242             return T_PollRetransmit_ms450;
243          case 500:
244             return T_PollRetransmit_ms500;
245          case 800:
246             return T_PollRetransmit_ms800;
247          default:
248             return T_PollRetransmit_spare5;
249       }
250    }
251 }
252
253 /************************************************************************
254  *
255  * @brief Converts enum values into actual value of Poll retransmit timer
256  *
257  * @details
258  *
259  *    Function : covertPollRetxTmrEnumToValue
260  *
261  *    Functionality: Converts enum values into actual value of poll 
262  *    retransmit timer
263  *
264  * @params[in] Enum value of pollPdu
265  * @return Actual value of pollPdu
266  *
267  * **********************************************************************/
268
269 uint16_t covertPollRetxTmrEnumToValue(uint8_t pollRetxTmrCfg)
270 {
271    uint16_t pollRetxTmr;
272
273    /* All values of poll retx timer are at interval of 5ms.
274     * This is valid upto 250ms
275     * Hence converting the enum value to actual value by multiplying it to 5
276     */
277    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
278       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
279    else
280    {
281       switch(pollRetxTmrCfg)
282       {
283          case T_PollRetransmit_ms300:
284             pollRetxTmr = 300;
285             break;
286          case T_PollRetransmit_ms350:
287             pollRetxTmr = 350;
288             break;
289          case T_PollRetransmit_ms400:
290             pollRetxTmr = 400;
291             break;
292          case T_PollRetransmit_ms450:
293             pollRetxTmr = 450;
294             break;
295          case T_PollRetransmit_ms500:
296             pollRetxTmr = 500;
297             break;
298          case T_PollRetransmit_ms800:
299             pollRetxTmr = 800;
300             break;
301          default:
302             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
303             pollRetxTmr = 0;
304       }
305    }
306    return pollRetxTmr; 
307 }
308
309 /************************************************************************
310  *
311  * @brief Coverts the value of Poll pdu to its corresponding enum 
312  *
313  * @details
314  *
315  *    Function : covertPollPduValueToEnum
316  *
317  *    Functionality: Coverts the value of Poll pdu to its corresponding enum
318  *
319  * @params[in] Poll PDU value
320  * @return Poll PDU enum
321  *
322  * **********************************************************************/
323 PollPDU_t covertPollPduValueToEnum(int32_t pollPdu)
324 {
325    switch(pollPdu)
326    {
327       case 4:
328          return PollPDU_p4;
329       case 8:
330          return PollPDU_p8;
331       case 16:
332          return PollPDU_p16;
333       case 32:
334          return PollPDU_p32;
335       case 64:
336          return PollPDU_p64;
337       case 128:
338          return PollPDU_p128;
339       case 256:
340          return PollPDU_p256;
341       case 512:
342          return PollPDU_p512;
343       case 1024:
344          return PollPDU_p1024;
345       case 2048:
346          return PollPDU_p2048;
347       case 4096:
348          return PollPDU_p4096;
349       case 6144:
350          return PollPDU_p6144;
351       case 8192:
352          return PollPDU_p8192;
353       case 12288:
354          return PollPDU_p12288;
355       case 16384:
356          return PollPDU_p16384;
357       case 20480:
358          return PollPDU_p20480;
359       case 24576:
360          return PollPDU_p24576;
361       case 28672:
362          return PollPDU_p28672;
363       case 32768:
364          return PollPDU_p32768;
365       case 40960:
366          return PollPDU_p40960;
367       case 49152:
368          return PollPDU_p49152;
369       case 57344:
370          return PollPDU_p57344;
371       case 65536:
372          return PollPDU_p65536;
373       case -1:
374          return PollPDU_infinity;
375       default:
376          return PollPDU_spare8;
377    }
378    return PollPDU_spare8;
379 }
380
381 /*******************************************************************
382  *
383  * @brief Converts enum values into actual value of PollPdu
384  *
385  * @details
386  *
387  *    Function : covertPollPduEnumToValue
388  *
389  *    Functionality: Converts enum values into actual value of PollPdu
390  *
391  * @params[in] Enum value of pollPdu
392  * @return Actual value of pollPdu
393  *
394  * ****************************************************************/
395 int32_t covertPollPduEnumToValue(uint8_t pollPduCfg)
396 {
397    int32_t pollPdu;
398    switch(pollPduCfg)
399    {
400       case PollPDU_p4:
401          pollPdu = 4;
402          break;
403       case PollPDU_p8:
404          pollPdu = 8;
405          break;
406       case PollPDU_p16:
407          pollPdu = 16;
408          break;
409       case PollPDU_p32:
410          pollPdu = 32;
411          break;
412       case PollPDU_p64:
413          pollPdu = 64;
414          break;
415       case PollPDU_p128:
416          pollPdu = 128;
417          break;
418       case PollPDU_p256:
419          pollPdu = 256;
420          break;
421       case PollPDU_p512:
422          pollPdu = 512;
423          break;
424       case PollPDU_p1024:
425          pollPdu = 1024;
426          break;
427       case PollPDU_p2048:
428          pollPdu = 2048;
429          break;
430       case PollPDU_p4096:
431          pollPdu = 4096;
432          break;
433       case PollPDU_p6144:
434          pollPdu = 6144;
435          break;
436       case PollPDU_p8192:
437          pollPdu = 8192;
438          break;
439       case PollPDU_p12288:
440          pollPdu = 12288;
441          break;
442       case PollPDU_p16384:
443          pollPdu = 16384;
444          break;
445       case PollPDU_p20480:
446          pollPdu = 20480;
447          break;
448       case PollPDU_p24576:
449          pollPdu = 24576;
450          break;
451       case PollPDU_p28672:
452          pollPdu = 28672;
453          break;
454       case PollPDU_p32768:
455          pollPdu = 32768;
456          break;
457       case PollPDU_p40960:
458          pollPdu = 40960;
459          break;
460       case PollPDU_p49152:
461          pollPdu = 49152;
462          break;
463       case PollPDU_p57344:
464          pollPdu = 57344;
465          break;
466       case PollPDU_p65536:
467          pollPdu = 65536;
468          break;
469       case PollPDU_infinity:
470          pollPdu = -1;
471          break;
472       default:
473          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
474          pollPdu = 0;
475          break;
476    }
477    return pollPdu;
478 }
479
480 /************************************************************************
481  *
482  * @brief Converts Poll byte value to its corresponding enum 
483  *
484  * @details
485  *
486  *    Function : covertPollByteValueToEnum
487  *
488  *    Functionality: Converts Poll byte value to its corresponding enum
489  *
490  * @params[in] Poll Byte value
491  * @return Poll Byte enum
492  *
493  * **********************************************************************/
494 PollByte_t covertPollByteValueToEnum(int32_t pollByte)
495 {
496    switch(pollByte)
497    {
498       case 1000:
499          return PollByte_kB1;
500       case 2000:
501          return PollByte_kB2;
502       case 5000:
503          return PollByte_kB5;
504       case 8000:
505          return PollByte_kB8;
506       case 10000:
507          return PollByte_kB10;
508       case 15000:
509          return PollByte_kB15;
510       case 25000:
511          return PollByte_kB25;
512       case 50000:
513          return PollByte_kB50;
514       case 75000:
515          return PollByte_kB75;
516       case 100000:
517          return PollByte_kB100;
518       case 125000:
519          return PollByte_kB125;
520       case 250000:
521          return PollByte_kB250;
522       case 375000:
523          return PollByte_kB375;
524       case 500000:
525          return PollByte_kB500;
526       case 750000:
527          return PollByte_kB750;
528       case 1000000:
529          return PollByte_kB1000;
530       case 1250000:
531          return PollByte_kB1250;
532       case 1500000:
533          return PollByte_kB1500;
534       case 2000000:
535          return PollByte_kB2000;
536       case 3000000:
537          return PollByte_kB3000;
538       case 4000000:
539          return PollByte_kB4000;
540       case 4500000:
541          return PollByte_kB4500;
542       case 5000000:
543          return PollByte_kB5000;
544       case 5500000:
545          return PollByte_kB5500;
546       case 6000000:
547          return PollByte_kB6000;
548       case 6500000:
549          return PollByte_kB6500;
550       case 7000000:
551          return PollByte_kB7000;
552       case 7500000:
553          return PollByte_kB7500;
554       case 8000000:
555          return PollByte_mB8;
556       case 9000000:
557          return PollByte_mB9;
558       case 10000000:
559          return PollByte_mB10;
560       case 11000000:
561          return PollByte_mB11;
562       case 12000000:
563          return PollByte_mB12;
564       case 13000000:
565          return PollByte_mB13;
566       case 14000000:
567          return PollByte_mB14;
568       case 15000000:
569          return PollByte_mB15;
570       case 16000000:
571          return PollByte_mB16;
572       case 17000000:
573          return PollByte_mB17;
574       case 18000000:
575          return PollByte_mB18;
576       case 20000000:
577          return PollByte_mB20;
578       case 25000000:
579          return PollByte_mB25;
580       case 30000000:
581          return PollByte_mB30;
582       case 40000000:
583          return PollByte_mB40;
584       case -1:
585          return PollByte_infinity; 
586       default:
587          return PollByte_spare20;
588    }
589 }
590
591 /*******************************************************************
592  *
593  * @brief Converts enum values into actual value of poll bytes
594  *
595  * @details
596  *
597  *    Function : covertPollByteEnumToValue
598  *
599  *    Functionality: Converts enum values into actual value of pollBytes
600  *
601  * @params[in] Enum value
602  * @return Actual value
603  *
604  * ****************************************************************/
605 int32_t covertPollByteEnumToValue(uint16_t pollBytesCfg)
606 {
607    int32_t pollBytes;
608    switch(pollBytesCfg)
609    {
610       case PollByte_kB1:
611          pollBytes = 1000;
612          break;
613       case PollByte_kB2:
614          pollBytes = 2000;
615          break;
616       case PollByte_kB5:
617          pollBytes = 5000;
618          break;
619       case PollByte_kB8:
620          pollBytes = 8000;
621          break;
622       case PollByte_kB10:
623          pollBytes = 10000;
624          break;
625       case PollByte_kB15:
626          pollBytes = 15000;
627          break;
628       case PollByte_kB25:
629          pollBytes = 25000;
630          break;
631       case PollByte_kB50:
632          pollBytes = 50000;
633          break;
634       case PollByte_kB75:
635          pollBytes = 75000;
636          break;
637       case PollByte_kB100:
638          pollBytes = 100000;
639          break;
640       case PollByte_kB125:
641          pollBytes = 125000;
642          break;
643       case PollByte_kB250:
644          pollBytes = 250000;
645          break;
646       case PollByte_kB375:
647          pollBytes = 375000;
648          break;
649       case PollByte_kB500:
650          pollBytes = 500000;
651          break;
652       case PollByte_kB750:
653          pollBytes = 750000;
654          break;
655       case PollByte_kB1000:
656          pollBytes = 1000000;
657          break;
658       case PollByte_kB1250:
659          pollBytes = 1250000;
660          break;
661       case PollByte_kB1500:
662          pollBytes = 1500000;
663          break;
664       case PollByte_kB2000:
665          pollBytes = 2000000;
666          break;
667       case PollByte_kB3000:
668          pollBytes = 3000000;
669          break;
670       case PollByte_kB4000:
671          pollBytes = 4000000;
672          break;
673       case PollByte_kB4500:
674          pollBytes = 4500000;
675          break;
676       case PollByte_kB5000:
677          pollBytes = 5000000;
678          break;
679       case PollByte_kB5500:
680          pollBytes = 5500000;
681          break;
682       case PollByte_kB6000:
683          pollBytes = 6000000;
684          break;
685       case PollByte_kB6500:
686          pollBytes = 6500000;
687          break;
688       case PollByte_kB7000:
689          pollBytes = 7000000;
690          break;
691       case PollByte_kB7500:
692          pollBytes = 7500000;
693          break;
694       case PollByte_mB8:
695          pollBytes = 8000000;
696          break;
697       case PollByte_mB9:
698          pollBytes = 9000000;
699          break;
700       case PollByte_mB10:
701          pollBytes = 10000000;
702          break;
703       case PollByte_mB11:
704          pollBytes = 11000000;
705          break;
706       case PollByte_mB12:
707          pollBytes = 12000000;
708          break;
709       case PollByte_mB13:
710          pollBytes = 13000000;
711          break;
712       case PollByte_mB14:
713          pollBytes = 14000000;
714          break;
715       case PollByte_mB15:
716          pollBytes = 15000000;
717          break;
718       case PollByte_mB16:
719          pollBytes = 16000000;
720          break;
721       case PollByte_mB17:
722          pollBytes = 17000000;
723          break;
724       case PollByte_mB18:
725          pollBytes = 18000000;
726          break;
727       case PollByte_mB20:
728          pollBytes = 20000000;
729          break;
730       case PollByte_mB25:
731          pollBytes = 25000000;
732          break;
733       case PollByte_mB30:
734          pollBytes = 30000000;
735          break;
736       case PollByte_mB40:
737          pollBytes = 40000000;
738          break;
739       case PollByte_infinity:
740          pollBytes = -1;
741          break;
742       default:
743          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
744          pollBytes = 0;
745    }
746    return pollBytes;
747 }
748
749 /************************************************************************
750  *
751  * @brief Converts Max retranmission value to enum 
752  *
753  * @details
754  *
755  *    Function : covertMaxRetxValueToEnum
756  *
757  *    Functionality: Converts Max retranmission value to enum
758  *
759  * @params[in] Max retransmission value
760  * @return Max retransmission enum
761  *
762  * **********************************************************************/
763 uint8_t covertMaxRetxValueToEnum(uint8_t maxRetx)
764 {
765    switch(maxRetx)
766    {
767       case 1:
768          return UL_AM_RLC__maxRetxThreshold_t1;
769       case 2:
770          return UL_AM_RLC__maxRetxThreshold_t2;
771       case 3:
772          return UL_AM_RLC__maxRetxThreshold_t3;
773       case 4:
774          return UL_AM_RLC__maxRetxThreshold_t4;
775       case 6:
776          return UL_AM_RLC__maxRetxThreshold_t6;
777       case 8:
778          return UL_AM_RLC__maxRetxThreshold_t8;
779       case 16:
780          return UL_AM_RLC__maxRetxThreshold_t16;
781       case 32:
782          return UL_AM_RLC__maxRetxThreshold_t32;
783    }
784    return UL_AM_RLC__maxRetxThreshold_t8;
785 }
786
787 /*******************************************************************
788  *
789  * @brief Converts enum values into actual value of maxRetx
790  *
791  * @details
792  *
793  *    Function : covertMaxRetxEnumToValue
794  *
795  *    Functionality: Converts enum values into actual value of maxRetx
796  *
797  * @params[in] Enum value
798  * @return Actual value
799  *
800  * ****************************************************************/
801 uint8_t covertMaxRetxEnumToValue(uint8_t maxRetxCfg)
802 {
803    uint8_t maxRetx;
804    switch(maxRetxCfg)
805    {
806       case UL_AM_RLC__maxRetxThreshold_t1:
807          maxRetx = 1;
808          break;
809       case UL_AM_RLC__maxRetxThreshold_t2:
810          maxRetx = 2;
811          break;
812       case UL_AM_RLC__maxRetxThreshold_t3:
813          maxRetx = 3;
814          break;
815       case UL_AM_RLC__maxRetxThreshold_t4:
816          maxRetx = 4;
817          break;
818       case UL_AM_RLC__maxRetxThreshold_t6:
819          maxRetx = 6;
820          break;
821       case UL_AM_RLC__maxRetxThreshold_t8:
822          maxRetx = 8;
823          break;
824       case UL_AM_RLC__maxRetxThreshold_t16:
825          maxRetx = 16;
826          break;
827       case UL_AM_RLC__maxRetxThreshold_t32:
828          maxRetx = 32;
829          break;
830       default:
831          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
832          maxRetx = 0;
833    }
834    return maxRetx;
835 }
836
837 /************************************************************************
838  *
839  * @brief Converts reassembly timer value to its ASN enum 
840  *
841  * @details
842  *
843  *    Function : convertReasmblTmrValueToEnum
844  *
845  *    Functionality: Converts reassembly timer value to its ASN enum
846  *
847  * @params[in] Reassembly timer value
848  * @return Reassembly timer enum
849  *
850  * **********************************************************************/
851 T_Reassembly_t convertReasmblTmrValueToEnum(int8_t reasmblTmr)
852 {
853    if(reasmblTmr == 0)
854       return T_Reassembly_ms0;
855    else if((reasmblTmr >=5 && reasmblTmr <= 100) && ((reasmblTmr % 5) == 0))
856       return (reasmblTmr/5);
857    else if((reasmblTmr <= 200) && ((reasmblTmr % 10) == 0))
858       return ((reasmblTmr/10) +10);
859    else 
860       return T_Reassembly_spare1;
861 }
862
863 /*******************************************************************
864  * @brief Converts enum values into actual value of reassembly timer
865  *
866  * @details
867  *
868  *    Function : convertReasmblTmrEnumToValue
869  *
870  *    Functionality: Converts enum values into actual value of reassembly 
871  *    timer
872  *
873  * @params[in] Enum value of reassembly timer
874  * @return Actual value of reassembly timer
875  *
876  * **********************************************************************/
877
878 int8_t convertReasmblTmrEnumToValue(uint8_t reAsmblTmrCfg)
879 {
880    int8_t reAsmblTmr = 0;
881    
882    if(reAsmblTmrCfg == T_Reassembly_ms0)
883    {
884       reAsmblTmr = 0;
885    }
886    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
887    {
888      /* All values of re assembly timer are at interval of 5ms.
889       * This is valid upto 100ms
890       * Hence converting the enum value to actual value by multiplying it to 5
891       */
892       reAsmblTmr = reAsmblTmrCfg * 5;
893    }
894    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
895    {
896      /* All values of re assembly timer are at interval of 10ms.
897       * This is valid upto 200ms
898       * since enum value starts from 20 for 100ms, subtracting 10 and
899       * converting the enum value to actual value by multiplying it to 10
900       */
901       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
902    }
903    else
904    {
905       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
906       reAsmblTmr = -1;
907    }
908    return reAsmblTmr; 
909 }
910
911 /************************************************************************
912  *
913  * @brief Converts Prohibit timer value to its ASN enum 
914  *
915  * @details
916  *
917  *    Function : convertProhibitTmrValueToEnum
918  *
919  *    Functionality: Converts Prohibit timer value to its ASN enum
920  *
921  * @params[in] Prohibit timer value
922  * @return Prohibit timer enum
923  *
924  * **********************************************************************/
925 T_StatusProhibit_t convertProhibitTmrValueToEnum(int16_t prohibitTmr)
926 {
927    if(prohibitTmr == 0)
928       return T_StatusProhibit_ms0;
929    else if((prohibitTmr >= 5) && (prohibitTmr <= 250) && ((prohibitTmr % 5) == 0))
930       return prohibitTmr/5;
931    else
932    {
933       switch(prohibitTmr)
934       {
935          case 300:
936             return T_StatusProhibit_ms300;
937          case 350:
938             return T_StatusProhibit_ms350;
939          case 400:
940             return T_StatusProhibit_ms400;
941          case 450:
942             return T_StatusProhibit_ms450;
943          case 500:
944             return T_StatusProhibit_ms500;
945          case 800:
946             return T_StatusProhibit_ms800;
947          case 1000:
948             return T_StatusProhibit_ms1000;
949          case 1200:
950             return T_StatusProhibit_ms1200;
951          case 1600:
952             return T_StatusProhibit_ms1600;
953          case 2000:
954             return T_StatusProhibit_ms2000;
955          case 2400:
956             return T_StatusProhibit_ms2400;
957          default:
958             return T_StatusProhibit_spare2;
959       }
960    }
961 }
962
963 /************************************************************************
964  *
965  * @brief Converts Prohibit timer enum to its actual value
966  *
967  * @details
968  *
969  *    Function : convertProhibitTmrEnumToValue
970  *
971  *    Functionality: Converts Prohibit timer enum to its actual value
972  *
973  * @params[in] Prohibit timer enum
974  * @return Prohibit timer value
975  *
976  * **********************************************************************/
977 int16_t convertProhibitTmrEnumToValue(T_StatusProhibit_t prohibitTmr)
978 {
979    if(prohibitTmr == T_StatusProhibit_ms0)
980       return 0;
981    else if((prohibitTmr >= T_StatusProhibit_ms5) && (prohibitTmr <= T_StatusProhibit_ms250))
982       return prohibitTmr*5;
983    else
984    {
985       switch(prohibitTmr)
986       {
987          case T_StatusProhibit_ms300:
988             return 300;
989          case T_StatusProhibit_ms350:
990             return 350;
991          case T_StatusProhibit_ms400:
992             return 400;
993          case T_StatusProhibit_ms450:
994             return 450;
995          case T_StatusProhibit_ms500:
996             return 500;
997          case T_StatusProhibit_ms800:
998             return 800;
999          case T_StatusProhibit_ms1000:
1000             return 1000;
1001          case T_StatusProhibit_ms1200:
1002             return 1200;
1003          case T_StatusProhibit_ms1600:
1004             return 1600;
1005          case T_StatusProhibit_ms2000:
1006             return 2000;
1007          case T_StatusProhibit_ms2400:
1008             return 2400;
1009          default:
1010             return 35;
1011       }
1012    }
1013 }
1014
1015 /************************************************************************
1016  *
1017  * @brief Converts internal enum value to RRC ASN enum value 
1018  *
1019  * @details
1020  *
1021  *    Function : covertPucchFormatIntEnumToRrcEnum
1022  *
1023  *    Functionality: Converts internal enum value to RRC ASN enum value
1024  *    for PUCCH format
1025  *
1026  * @params[in] PUCCH format value in  internal enum
1027  * @return PUCCH format value RRC ASN enum
1028  *
1029  * **********************************************************************/
1030 PUCCH_Resource__format_PR covertPucchFormatIntEnumToRrcEnum(uint8_t pucchFormat)
1031 {
1032    switch(pucchFormat)
1033    {
1034       case PUCCH_FORMAT_0:
1035          return PUCCH_Resource__format_PR_format0;
1036       case PUCCH_FORMAT_1:
1037          return PUCCH_Resource__format_PR_format1;
1038       case PUCCH_FORMAT_2:
1039          return PUCCH_Resource__format_PR_format2;
1040       case PUCCH_FORMAT_3:
1041          return PUCCH_Resource__format_PR_format3;
1042       case PUCCH_FORMAT_4:
1043          return PUCCH_Resource__format_PR_format4;
1044       default:
1045          return PUCCH_Resource__format_PR_NOTHING;
1046    }
1047    return PUCCH_Resource__format_PR_NOTHING;
1048 }
1049
1050 /************************************************************************
1051  *
1052  * @brief Converts LC SR Delay timer value to its ASN enum value
1053  *
1054  * @details
1055  *
1056  *    Function : convertLcSrDelayTmrValueToEnum
1057  *
1058  *    Functionality: Converts LC SR Delay timer value to its ASN enum value
1059  *
1060  * @params[in] LC SR Delay timer value
1061  * @return LC SR Delay timer ASN enum
1062  *
1063  * **********************************************************************/
1064 long convertLcSrDelayTmrValueToEnum(uint16_t delayTimer)
1065 {
1066    switch(delayTimer)
1067    {
1068       case 20:
1069          return BSR_Config__logicalChannelSR_DelayTimer_sf20;
1070       case 40:
1071          return BSR_Config__logicalChannelSR_DelayTimer_sf40;
1072       case 64:
1073          return BSR_Config__logicalChannelSR_DelayTimer_sf64;
1074       case 128:
1075          return BSR_Config__logicalChannelSR_DelayTimer_sf128;
1076       case 512:
1077          return BSR_Config__logicalChannelSR_DelayTimer_sf512;
1078       case 1024:
1079          return BSR_Config__logicalChannelSR_DelayTimer_sf1024;
1080       case 2560:
1081          return BSR_Config__logicalChannelSR_DelayTimer_sf2560;
1082       default:
1083          return BSR_Config__logicalChannelSR_DelayTimer_sf2560;
1084    }
1085 }
1086
1087 /**********************************************************************
1088   End of file
1089  **********************************************************************/