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 BSR Periodic timer value to its ASN enum value
1053  *
1054  * @details
1055  *
1056  *    Function : convertBsrPeriodicTmrValueToEnum
1057  *
1058  *    Functionality: Converts BSR Periodic timer timer value to its ASN enum value
1059  *
1060  * @params[in] BSR Periodic timer value
1061  * @return BSR Periodic timer ASN enum
1062  *
1063  * **********************************************************************/
1064 long convertBsrPeriodicTmrValueToEnum(int16_t periodicTmr)
1065 {
1066    switch(periodicTmr)
1067    {
1068       case 1:
1069          return BSR_Config__periodicBSR_Timer_sf1;
1070       case 5:
1071          return BSR_Config__periodicBSR_Timer_sf5;
1072       case 10:
1073          return BSR_Config__periodicBSR_Timer_sf10;
1074       case 16:
1075          return BSR_Config__periodicBSR_Timer_sf16;
1076       case 20:
1077          return BSR_Config__periodicBSR_Timer_sf20;
1078       case 32:
1079          return BSR_Config__periodicBSR_Timer_sf32;
1080       case 40:
1081          return BSR_Config__periodicBSR_Timer_sf40;
1082       case 64:
1083          return BSR_Config__periodicBSR_Timer_sf64;
1084       case 80:
1085          return BSR_Config__periodicBSR_Timer_sf80;
1086       case 128:
1087          return BSR_Config__periodicBSR_Timer_sf128;
1088       case 320:
1089          return BSR_Config__periodicBSR_Timer_sf320;
1090       case 640:
1091          return BSR_Config__periodicBSR_Timer_sf640;
1092       case 1280:
1093          return BSR_Config__periodicBSR_Timer_sf1280;
1094       case 2560:
1095          return BSR_Config__periodicBSR_Timer_sf2560;
1096       case -1:
1097          return BSR_Config__periodicBSR_Timer_infinity;
1098       default:
1099          return BSR_Config__periodicBSR_Timer_sf10;
1100    }
1101 }
1102
1103 /************************************************************************
1104  *
1105  * @brief Converts BSR Retransmission timer value to its ASN enum value
1106  *
1107  * @details
1108  *
1109  *    Function : convertBsrRetxTmrValueToEnum
1110  *
1111  *    Functionality: Converts BSR Retransmission timer timer value to its ASN enum value
1112  *
1113  * @params[in] BSR Retransmission timer value
1114  * @return BSR Restransmission timer ASN enum
1115  *
1116  * **********************************************************************/
1117 long convertBsrRetxTmrValueToEnum(uint16_t retxTmr)
1118 {
1119    switch(retxTmr)
1120    {
1121       case 10:
1122          return BSR_Config__retxBSR_Timer_sf10;
1123       case 20:
1124          return BSR_Config__retxBSR_Timer_sf20;
1125       case 40:
1126          return BSR_Config__retxBSR_Timer_sf40;
1127       case 80:
1128          return BSR_Config__retxBSR_Timer_sf80;
1129       case 160:
1130          return BSR_Config__retxBSR_Timer_sf160;
1131       case 320:
1132          return BSR_Config__retxBSR_Timer_sf320;
1133       case 640:
1134          return BSR_Config__retxBSR_Timer_sf640;
1135       case 1280:
1136          return BSR_Config__retxBSR_Timer_sf1280;
1137       case 2560:
1138          return BSR_Config__retxBSR_Timer_sf2560;
1139       case 5120:
1140          return BSR_Config__retxBSR_Timer_sf5120;
1141       case 10240:
1142          return BSR_Config__retxBSR_Timer_sf10240;
1143       default:
1144          return BSR_Config__retxBSR_Timer_sf320;
1145    }
1146 }
1147
1148 /************************************************************************
1149  *
1150  * @brief Converts LC SR Delay timer value to its ASN enum value
1151  *
1152  * @details
1153  *
1154  *    Function : convertLcSrDelayTmrValueToEnum
1155  *
1156  *    Functionality: Converts LC SR Delay timer value to its ASN enum value
1157  *
1158  * @params[in] LC SR Delay timer value
1159  * @return LC SR Delay timer ASN enum
1160  *
1161  * **********************************************************************/
1162 long convertLcSrDelayTmrValueToEnum(uint16_t delayTimer)
1163 {
1164    switch(delayTimer)
1165    {
1166       case 20:
1167          return BSR_Config__logicalChannelSR_DelayTimer_sf20;
1168       case 40:
1169          return BSR_Config__logicalChannelSR_DelayTimer_sf40;
1170       case 64:
1171          return BSR_Config__logicalChannelSR_DelayTimer_sf64;
1172       case 128:
1173          return BSR_Config__logicalChannelSR_DelayTimer_sf128;
1174       case 512:
1175          return BSR_Config__logicalChannelSR_DelayTimer_sf512;
1176       case 1024:
1177          return BSR_Config__logicalChannelSR_DelayTimer_sf1024;
1178       case 2560:
1179          return BSR_Config__logicalChannelSR_DelayTimer_sf2560;
1180       default:
1181          return BSR_Config__logicalChannelSR_DelayTimer_sf2560;
1182    }
1183 }
1184
1185 /**********************************************************************
1186   End of file
1187  **********************************************************************/