openbcm

Git mirror of https://github.com/Broadcom-Network-Switching-Software/OpenBCM
git clone git://git.finwo.net/mirror/broadcom/openbcm
Log | Files | Refs | README

trunk.c (5087B)

      1 /*
      2  * 
      3  * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
      4  * 
      5  * Copyright 2007-2019 Broadcom Inc. All rights reserved.
      6  *
      7  * File:    trunk.c
      8  * Purpose: Helix5 resilient hash function implementations
      9  */
     10 
     11 #include <shared/bsl.h>
     12 
     13 #include <soc/defs.h>
     14 #if defined(BCM_HELIX5_SUPPORT)
     15 
     16 #include <bcm/debug.h>
     17 #include <bcm/error.h>
     18 
     19 /*
     20  * Function:
     21  *      _bcm_hx5_hg_rh_dynamic_size_encode
     22  * Purpose:
     23  *      Encode Higig trunk resilient hashing flow set size.
     24  * Parameters:
     25  *      dynamic_size  - (IN) Number of flow sets.
     26  *      encoded_value - (OUT) Encoded value.
     27  * Returns:
     28  *      BCM_E_xxx
     29  */
     30 int
     31 _bcm_hx5_hg_rh_dynamic_size_encode(int dynamic_size, int *encoded_value)
     32 {
     33     switch (dynamic_size) {
     34         case 64:
     35             *encoded_value = 1;
     36             break;
     37         case 128:
     38             *encoded_value = 2;
     39             break;
     40         case 256:
     41             *encoded_value = 3;
     42             break;
     43         case 512:
     44             *encoded_value = 4;
     45             break;
     46         case 1024:
     47             *encoded_value = 5;
     48             break;
     49         case 2048:
     50             *encoded_value = 6;
     51             break;
     52         case 4096:
     53             *encoded_value = 7;
     54             break;
     55         case 8192:
     56             *encoded_value = 8;
     57             break;
     58         case 16384:
     59             *encoded_value = 9;
     60             break;
     61         case 32768:
     62             *encoded_value = 10;
     63             break;
     64         default:
     65             return BCM_E_PARAM;
     66     }
     67 
     68     return BCM_E_NONE;
     69 }
     70 
     71 /*
     72  * Function:
     73  *      _bcm_hx5_hg_rh_dynamic_size_decode
     74  * Purpose:
     75  *      Decode Higig trunk resilient hashing flow set size.
     76  * Parameters:
     77  *      encoded_value - (IN) Encoded value.
     78  *      dynamic_size  - (OUT) Number of flow sets.
     79  * Returns:
     80  *      BCM_E_xxx
     81  */
     82 int
     83 _bcm_hx5_hg_rh_dynamic_size_decode(int encoded_value, int *dynamic_size)
     84 {
     85     switch (encoded_value) {
     86         case 1:
     87             *dynamic_size = 64;
     88             break;
     89         case 2:
     90             *dynamic_size = 128;
     91             break;
     92         case 3:
     93             *dynamic_size = 256;
     94             break;
     95         case 4:
     96             *dynamic_size = 512;
     97             break;
     98         case 5:
     99             *dynamic_size = 1024;
    100             break;
    101         case 6:
    102             *dynamic_size = 2048;
    103             break;
    104         case 7:
    105             *dynamic_size = 4096;
    106             break;
    107         case 8:
    108             *dynamic_size = 8192;
    109             break;
    110         case 9:
    111             *dynamic_size = 16384;
    112             break;
    113         case 10:
    114             *dynamic_size = 32768;
    115             break;
    116         default:
    117             return BCM_E_INTERNAL;
    118     }
    119 
    120     return BCM_E_NONE;
    121 }
    122 
    123 /*
    124  * Function:
    125  *      _bcm_hx5_lag_rh_dynamic_size_encode
    126  * Purpose:
    127  *      Encode LAG trunk resilient hashing flow set size.
    128  * Parameters:
    129  *      dynamic_size  - (IN) Number of flow sets.
    130  *      encoded_value - (OUT) Encoded value.
    131  * Returns:
    132  *      BCM_E_xxx
    133  */
    134 int
    135 _bcm_hx5_lag_rh_dynamic_size_encode(int dynamic_size, int *encoded_value)
    136 {
    137     switch (dynamic_size) {
    138         case 64:
    139             *encoded_value = 1;
    140             break;
    141         case 128:
    142             *encoded_value = 2;
    143             break;
    144         case 256:
    145             *encoded_value = 3;
    146             break;
    147         case 512:
    148             *encoded_value = 4;
    149             break;
    150         case 1024:
    151             *encoded_value = 5;
    152             break;
    153         case 2048:
    154             *encoded_value = 6;
    155             break;
    156         case 4096:
    157             *encoded_value = 7;
    158             break;
    159         case 8192:
    160             *encoded_value = 8;
    161             break;
    162         case 16384:
    163             *encoded_value = 9;
    164             break;
    165         case 32768:
    166             *encoded_value = 10;
    167             break;
    168         default:
    169             return BCM_E_PARAM;
    170     }
    171 
    172     return BCM_E_NONE;
    173 }
    174 
    175 /*
    176  * Function:
    177  *      _bcm_hx5_lag_rh_dynamic_size_decode
    178  * Purpose:
    179  *      Decode LAG trunk resilient hashing flow set size.
    180  * Parameters:
    181  *      encoded_value - (IN) Encoded value.
    182  *      dynamic_size  - (OUT) Number of flow sets.
    183  * Returns:
    184  *      BCM_E_xxx
    185  */
    186 int
    187 _bcm_hx5_lag_rh_dynamic_size_decode(int encoded_value, int *dynamic_size)
    188 {
    189     switch (encoded_value) {
    190         case 1:
    191             *dynamic_size = 64;
    192             break;
    193         case 2:
    194             *dynamic_size = 128;
    195             break;
    196         case 3:
    197             *dynamic_size = 256;
    198             break;
    199         case 4:
    200             *dynamic_size = 512;
    201             break;
    202         case 5:
    203             *dynamic_size = 1024;
    204             break;
    205         case 6:
    206             *dynamic_size = 2048;
    207             break;
    208         case 7:
    209             *dynamic_size = 4096;
    210             break;
    211         case 8:
    212             *dynamic_size = 8192;
    213             break;
    214         case 9:
    215             *dynamic_size = 16384;
    216             break;
    217         case 10:
    218             *dynamic_size = 32768;
    219             break;
    220         default:
    221             return BCM_E_INTERNAL;
    222     }
    223 
    224     return BCM_E_NONE;
    225 }
    226 
    227 #endif /* BCM_HELIX5_SUPPORT  */