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