sys/dev/ixgbe/ixgbe_dcb.c

   1 /******************************************************************************
   2
   3   Copyright (c) 2001-2015, Intel Corporation
   4   All rights reserved.
   5
   6   Redistribution and use in source and binary forms, with or without
   7   modification, are permitted provided that the following conditions are met:
   8
   9    1. Redistributions of source code must retain the above copyright notice,
  10       this list of conditions and the following disclaimer.
  11
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    3. Neither the name of the Intel Corporation nor the names of its
  17       contributors may be used to endorse or promote products derived from
  18       this software without specific prior written permission.
  19
  20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30   POSSIBILITY OF SUCH DAMAGE.
  31
  32 ******************************************************************************/
  33 /*$FreeBSD$*/
  34
  35
  36 #include "ixgbe_type.h"
  37 #include "ixgbe_dcb.h"
  38 #include "ixgbe_dcb_82598.h"
  39 #include "ixgbe_dcb_82599.h"
  40
  41 /**
  42  * ixgbe_dcb_calculate_tc_credits - This calculates the ieee traffic class
  43  * credits from the configured bandwidth percentages. Credits
  44  * are the smallest unit programmable into the underlying
  45  * hardware. The IEEE 802.1Qaz specification do not use bandwidth
  46  * groups so this is much simplified from the CEE case.
  47  */
  48 s32 ixgbe_dcb_calculate_tc_credits(u8 *bw, u16 *refill, u16 *max,
  49                                    int max_frame_size)
  50 {
  51         int min_percent = 100;
  52         int min_credit, multiplier;
  53         int i;
  54
  55         min_credit = ((max_frame_size / 2) + IXGBE_DCB_CREDIT_QUANTUM - 1) /
  56                         IXGBE_DCB_CREDIT_QUANTUM;
  57
  58         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
  59                 if (bw[i] < min_percent && bw[i])
  60                         min_percent = bw[i];
  61         }
  62
  63         multiplier = (min_credit / min_percent) + 1;
  64
  65         /* Find out the hw credits for each TC */
  66         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
  67                 int val = min(bw[i] * multiplier, IXGBE_DCB_MAX_CREDIT_REFILL);
  68
  69                 if (val < min_credit)
  70                         val = min_credit;
  71                 refill[i] = (u16)val;
  72
  73                 max[i] = bw[i] ? (bw[i]*IXGBE_DCB_MAX_CREDIT)/100 : min_credit;
  74         }
  75
  76         return 0;
  77 }
  78
  79 /**
  80  * ixgbe_dcb_calculate_tc_credits_cee - Calculates traffic class credits
  81  * @ixgbe_dcb_config: Struct containing DCB settings.
  82  * @direction: Configuring either Tx or Rx.
  83  *
  84  * This function calculates the credits allocated to each traffic class.
  85  * It should be called only after the rules are checked by
  86  * ixgbe_dcb_check_config_cee().
  87  */
  88 s32 ixgbe_dcb_calculate_tc_credits_cee(struct ixgbe_hw *hw,
  89                                    struct ixgbe_dcb_config *dcb_config,
  90                                    u32 max_frame_size, u8 direction)
  91 {
  92         struct ixgbe_dcb_tc_path *p;
  93         u32 min_multiplier      = 0;
  94         u16 min_percent         = 100;
  95         s32 ret_val =           IXGBE_SUCCESS;
  96         /* Initialization values default for Tx settings */
  97         u32 min_credit          = 0;
  98         u32 credit_refill       = 0;
  99         u32 credit_max          = 0;
 100         u16 link_percentage     = 0;
 101         u8  bw_percent          = 0;
 102         u8  i;
 103
 104         if (dcb_config == NULL) {
 105                 ret_val = IXGBE_ERR_CONFIG;
 106                 goto out;
 107         }
 108
 109         min_credit = ((max_frame_size / 2) + IXGBE_DCB_CREDIT_QUANTUM - 1) /
 110                      IXGBE_DCB_CREDIT_QUANTUM;
 111
 112         /* Find smallest link percentage */
 113         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
 114                 p = &dcb_config->tc_config[i].path[direction];
 115                 bw_percent = dcb_config->bw_percentage[direction][p->bwg_id];
 116                 link_percentage = p->bwg_percent;
 117
 118                 link_percentage = (link_percentage * bw_percent) / 100;
 119
 120                 if (link_percentage && link_percentage < min_percent)
 121                         min_percent = link_percentage;
 122         }
 123
 124         /*
 125          * The ratio between traffic classes will control the bandwidth
 126          * percentages seen on the wire. To calculate this ratio we use
 127          * a multiplier. It is required that the refill credits must be
 128          * larger than the max frame size so here we find the smallest
 129          * multiplier that will allow all bandwidth percentages to be
 130          * greater than the max frame size.
 131          */
 132         min_multiplier = (min_credit / min_percent) + 1;
 133
 134         /* Find out the link percentage for each TC first */
 135         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
 136                 p = &dcb_config->tc_config[i].path[direction];
 137                 bw_percent = dcb_config->bw_percentage[direction][p->bwg_id];
 138
 139                 link_percentage = p->bwg_percent;
 140                 /* Must be careful of integer division for very small nums */
 141                 link_percentage = (link_percentage * bw_percent) / 100;
 142                 if (p->bwg_percent > 0 && link_percentage == 0)
 143                         link_percentage = 1;
 144
 145                 /* Save link_percentage for reference */
 146                 p->link_percent = (u8)link_percentage;
 147
 148                 /* Calculate credit refill ratio using multiplier */
 149                 credit_refill = min(link_percentage * min_multiplier,
 150                                     (u32)IXGBE_DCB_MAX_CREDIT_REFILL);
 151
 152                 /* Refill at least minimum credit */
 153                 if (credit_refill < min_credit)
 154                         credit_refill = min_credit;
 155
 156                 p->data_credits_refill = (u16)credit_refill;
 157
 158                 /* Calculate maximum credit for the TC */
 159                 credit_max = (link_percentage * IXGBE_DCB_MAX_CREDIT) / 100;
 160
 161                 /*
 162                  * Adjustment based on rule checking, if the percentage
 163                  * of a TC is too small, the maximum credit may not be
 164                  * enough to send out a jumbo frame in data plane arbitration.
 165                  */
 166                 if (credit_max < min_credit)
 167                         credit_max = min_credit;
 168
 169                 if (direction == IXGBE_DCB_TX_CONFIG) {
 170                         /*
 171                          * Adjustment based on rule checking, if the
 172                          * percentage of a TC is too small, the maximum
 173                          * credit may not be enough to send out a TSO
 174                          * packet in descriptor plane arbitration.
 175                          */
 176                         if (credit_max && (credit_max <
 177                             IXGBE_DCB_MIN_TSO_CREDIT)
 178                             && (hw->mac.type == ixgbe_mac_82598EB))
 179                                 credit_max = IXGBE_DCB_MIN_TSO_CREDIT;
 180
 181                         dcb_config->tc_config[i].desc_credits_max =
 182                                                                 (u16)credit_max;
 183                 }
 184
 185                 p->data_credits_max = (u16)credit_max;
 186         }
 187
 188 out:
 189         return ret_val;
 190 }
 191
 192 /**
 193  * ixgbe_dcb_unpack_pfc_cee - Unpack dcb_config PFC info
 194  * @cfg: dcb configuration to unpack into hardware consumable fields
 195  * @map: user priority to traffic class map
 196  * @pfc_up: u8 to store user priority PFC bitmask
 197  *
 198  * This unpacks the dcb configuration PFC info which is stored per
 199  * traffic class into a 8bit user priority bitmask that can be
 200  * consumed by hardware routines. The priority to tc map must be
 201  * updated before calling this routine to use current up-to maps.
 202  */
 203 void ixgbe_dcb_unpack_pfc_cee(struct ixgbe_dcb_config *cfg, u8 *map, u8 *pfc_up)
 204 {
 205         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 206         int up;
 207
 208         /*
 209          * If the TC for this user priority has PFC enabled then set the
 210          * matching bit in 'pfc_up' to reflect that PFC is enabled.
 211          */
 212         for (*pfc_up = 0, up = 0; up < IXGBE_DCB_MAX_USER_PRIORITY; up++) {
 213                 if (tc_config[map[up]].pfc != ixgbe_dcb_pfc_disabled)
 214                         *pfc_up |= 1 << up;
 215         }
 216 }
 217
 218 void ixgbe_dcb_unpack_refill_cee(struct ixgbe_dcb_config *cfg, int direction,
 219                              u16 *refill)
 220 {
 221         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 222         int tc;
 223
 224         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 225                 refill[tc] = tc_config[tc].path[direction].data_credits_refill;
 226 }
 227
 228 void ixgbe_dcb_unpack_max_cee(struct ixgbe_dcb_config *cfg, u16 *max)
 229 {
 230         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 231         int tc;
 232
 233         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 234                 max[tc] = tc_config[tc].desc_credits_max;
 235 }
 236
 237 void ixgbe_dcb_unpack_bwgid_cee(struct ixgbe_dcb_config *cfg, int direction,
 238                             u8 *bwgid)
 239 {
 240         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 241         int tc;
 242
 243         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 244                 bwgid[tc] = tc_config[tc].path[direction].bwg_id;
 245 }
 246
 247 void ixgbe_dcb_unpack_tsa_cee(struct ixgbe_dcb_config *cfg, int direction,
 248                            u8 *tsa)
 249 {
 250         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 251         int tc;
 252
 253         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 254                 tsa[tc] = tc_config[tc].path[direction].tsa;
 255 }
 256
 257 u8 ixgbe_dcb_get_tc_from_up(struct ixgbe_dcb_config *cfg, int direction, u8 up)
 258 {
 259         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 260         u8 prio_mask = 1 << up;
 261         u8 tc = cfg->num_tcs.pg_tcs;
 262
 263         /* If tc is 0 then DCB is likely not enabled or supported */
 264         if (!tc)
 265                 goto out;
 266
 267         /*
 268          * Test from maximum TC to 1 and report the first match we find.  If
 269          * we find no match we can assume that the TC is 0 since the TC must
 270          * be set for all user priorities
 271          */
 272         for (tc--; tc; tc--) {
 273                 if (prio_mask & tc_config[tc].path[direction].up_to_tc_bitmap)
 274                         break;
 275         }
 276 out:
 277         return tc;
 278 }
 279
 280 void ixgbe_dcb_unpack_map_cee(struct ixgbe_dcb_config *cfg, int direction,
 281                               u8 *map)
 282 {
 283         u8 up;
 284
 285         for (up = 0; up < IXGBE_DCB_MAX_USER_PRIORITY; up++)
 286                 map[up] = ixgbe_dcb_get_tc_from_up(cfg, direction, up);
 287 }
 288
 289 /**
 290  * ixgbe_dcb_config - Struct containing DCB settings.
 291  * @dcb_config: Pointer to DCB config structure
 292  *
 293  * This function checks DCB rules for DCB settings.
 294  * The following rules are checked:
 295  * 1. The sum of bandwidth percentages of all Bandwidth Groups must total 100%.
 296  * 2. The sum of bandwidth percentages of all Traffic Classes within a Bandwidth
 297  *    Group must total 100.
 298  * 3. A Traffic Class should not be set to both Link Strict Priority
 299  *    and Group Strict Priority.
 300  * 4. Link strict Bandwidth Groups can only have link strict traffic classes
 301  *    with zero bandwidth.
 302  */
 303 s32 ixgbe_dcb_check_config_cee(struct ixgbe_dcb_config *dcb_config)
 304 {
 305         struct ixgbe_dcb_tc_path *p;
 306         s32 ret_val = IXGBE_SUCCESS;
 307         u8 i, j, bw = 0, bw_id;
 308         u8 bw_sum[2][IXGBE_DCB_MAX_BW_GROUP];
 309         bool link_strict[2][IXGBE_DCB_MAX_BW_GROUP];
 310
 311         memset(bw_sum, 0, sizeof(bw_sum));
 312         memset(link_strict, 0, sizeof(link_strict));
 313
 314         /* First Tx, then Rx */
 315         for (i = 0; i < 2; i++) {
 316                 /* Check each traffic class for rule violation */
 317                 for (j = 0; j < IXGBE_DCB_MAX_TRAFFIC_CLASS; j++) {
 318                         p = &dcb_config->tc_config[j].path[i];
 319
 320                         bw = p->bwg_percent;
 321                         bw_id = p->bwg_id;
 322
 323                         if (bw_id >= IXGBE_DCB_MAX_BW_GROUP) {
 324                                 ret_val = IXGBE_ERR_CONFIG;
 325                                 goto err_config;
 326                         }
 327                         if (p->tsa == ixgbe_dcb_tsa_strict) {
 328                                 link_strict[i][bw_id] = TRUE;
 329                                 /* Link strict should have zero bandwidth */
 330                                 if (bw) {
 331                                         ret_val = IXGBE_ERR_CONFIG;
 332                                         goto err_config;
 333                                 }
 334                         } else if (!bw) {
 335                                 /*
 336                                  * Traffic classes without link strict
 337                                  * should have non-zero bandwidth.
 338                                  */
 339                                 ret_val = IXGBE_ERR_CONFIG;
 340                                 goto err_config;
 341                         }
 342                         bw_sum[i][bw_id] += bw;
 343                 }
 344
 345                 bw = 0;
 346
 347                 /* Check each bandwidth group for rule violation */
 348                 for (j = 0; j < IXGBE_DCB_MAX_BW_GROUP; j++) {
 349                         bw += dcb_config->bw_percentage[i][j];
 350                         /*
 351                          * Sum of bandwidth percentages of all traffic classes
 352                          * within a Bandwidth Group must total 100 except for
 353                          * link strict group (zero bandwidth).
 354                          */
 355                         if (link_strict[i][j]) {
 356                                 if (bw_sum[i][j]) {
 357                                         /*
 358                                          * Link strict group should have zero
 359                                          * bandwidth.
 360                                          */
 361                                         ret_val = IXGBE_ERR_CONFIG;
 362                                         goto err_config;
 363                                 }
 364                         } else if (bw_sum[i][j] != IXGBE_DCB_BW_PERCENT &&
 365                                    bw_sum[i][j] != 0) {
 366                                 ret_val = IXGBE_ERR_CONFIG;
 367                                 goto err_config;
 368                         }
 369                 }
 370
 371                 if (bw != IXGBE_DCB_BW_PERCENT) {
 372                         ret_val = IXGBE_ERR_CONFIG;
 373                         goto err_config;
 374                 }
 375         }
 376
 377 err_config:
 378         DEBUGOUT2("DCB error code %d while checking %s settings.\n",
 379                   ret_val, (i == IXGBE_DCB_TX_CONFIG) ? "Tx" : "Rx");
 380
 381         return ret_val;
 382 }
 383
 384 /**
 385  * ixgbe_dcb_get_tc_stats - Returns status of each traffic class
 386  * @hw: pointer to hardware structure
 387  * @stats: pointer to statistics structure
 388  * @tc_count:  Number of elements in bwg_array.
 389  *
 390  * This function returns the status data for each of the Traffic Classes in use.
 391  */
 392 s32 ixgbe_dcb_get_tc_stats(struct ixgbe_hw *hw, struct ixgbe_hw_stats *stats,
 393                            u8 tc_count)
 394 {
 395         s32 ret = IXGBE_NOT_IMPLEMENTED;
 396         switch (hw->mac.type) {
 397         case ixgbe_mac_82598EB:
 398                 ret = ixgbe_dcb_get_tc_stats_82598(hw, stats, tc_count);
 399                 break;
 400         case ixgbe_mac_82599EB:
 401         case ixgbe_mac_X540:
 402         case ixgbe_mac_X550:
 403         case ixgbe_mac_X550EM_x:
 404 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 405                 ret = ixgbe_dcb_get_tc_stats_82599(hw, stats, tc_count);
 406                 break;
 407 #endif
 408         default:
 409                 break;
 410         }
 411         return ret;
 412 }
 413
 414 /**
 415  * ixgbe_dcb_get_pfc_stats - Returns CBFC status of each traffic class
 416  * @hw: pointer to hardware structure
 417  * @stats: pointer to statistics structure
 418  * @tc_count:  Number of elements in bwg_array.
 419  *
 420  * This function returns the CBFC status data for each of the Traffic Classes.
 421  */
 422 s32 ixgbe_dcb_get_pfc_stats(struct ixgbe_hw *hw, struct ixgbe_hw_stats *stats,
 423                             u8 tc_count)
 424 {
 425         s32 ret = IXGBE_NOT_IMPLEMENTED;
 426         switch (hw->mac.type) {
 427         case ixgbe_mac_82598EB:
 428                 ret = ixgbe_dcb_get_pfc_stats_82598(hw, stats, tc_count);
 429                 break;
 430         case ixgbe_mac_82599EB:
 431         case ixgbe_mac_X540:
 432         case ixgbe_mac_X550:
 433         case ixgbe_mac_X550EM_x:
 434 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 435                 ret = ixgbe_dcb_get_pfc_stats_82599(hw, stats, tc_count);
 436                 break;
 437 #endif
 438         default:
 439                 break;
 440         }
 441         return ret;
 442 }
 443
 444 /**
 445  * ixgbe_dcb_config_rx_arbiter_cee - Config Rx arbiter
 446  * @hw: pointer to hardware structure
 447  * @dcb_config: pointer to ixgbe_dcb_config structure
 448  *
 449  * Configure Rx Data Arbiter and credits for each traffic class.
 450  */
 451 s32 ixgbe_dcb_config_rx_arbiter_cee(struct ixgbe_hw *hw,
 452                                 struct ixgbe_dcb_config *dcb_config)
 453 {
 454         s32 ret = IXGBE_NOT_IMPLEMENTED;
 455         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS]     = { 0 };
 456         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS]   = { 0 };
 457         u8 map[IXGBE_DCB_MAX_USER_PRIORITY]     = { 0 };
 458         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS] = { 0 };
 459         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS]    = { 0 };
 460
 461         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 462         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 463         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 464         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 465         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 466
 467         switch (hw->mac.type) {
 468         case ixgbe_mac_82598EB:
 469                 ret = ixgbe_dcb_config_rx_arbiter_82598(hw, refill, max, tsa);
 470                 break;
 471         case ixgbe_mac_82599EB:
 472         case ixgbe_mac_X540:
 473         case ixgbe_mac_X550:
 474         case ixgbe_mac_X550EM_x:
 475 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 476                 ret = ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwgid,
 477                                                         tsa, map);
 478                 break;
 479 #endif
 480         default:
 481                 break;
 482         }
 483         return ret;
 484 }
 485
 486 /**
 487  * ixgbe_dcb_config_tx_desc_arbiter_cee - Config Tx Desc arbiter
 488  * @hw: pointer to hardware structure
 489  * @dcb_config: pointer to ixgbe_dcb_config structure
 490  *
 491  * Configure Tx Descriptor Arbiter and credits for each traffic class.
 492  */
 493 s32 ixgbe_dcb_config_tx_desc_arbiter_cee(struct ixgbe_hw *hw,
 494                                      struct ixgbe_dcb_config *dcb_config)
 495 {
 496         s32 ret = IXGBE_NOT_IMPLEMENTED;
 497         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 498         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 499         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 500         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 501
 502         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 503         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 504         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 505         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 506
 507         switch (hw->mac.type) {
 508         case ixgbe_mac_82598EB:
 509                 ret = ixgbe_dcb_config_tx_desc_arbiter_82598(hw, refill, max,
 510                                                              bwgid, tsa);
 511                 break;
 512         case ixgbe_mac_82599EB:
 513         case ixgbe_mac_X540:
 514         case ixgbe_mac_X550:
 515         case ixgbe_mac_X550EM_x:
 516 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 517                 ret = ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max,
 518                                                              bwgid, tsa);
 519                 break;
 520 #endif
 521         default:
 522                 break;
 523         }
 524         return ret;
 525 }
 526
 527 /**
 528  * ixgbe_dcb_config_tx_data_arbiter_cee - Config Tx data arbiter
 529  * @hw: pointer to hardware structure
 530  * @dcb_config: pointer to ixgbe_dcb_config structure
 531  *
 532  * Configure Tx Data Arbiter and credits for each traffic class.
 533  */
 534 s32 ixgbe_dcb_config_tx_data_arbiter_cee(struct ixgbe_hw *hw,
 535                                      struct ixgbe_dcb_config *dcb_config)
 536 {
 537         s32 ret = IXGBE_NOT_IMPLEMENTED;
 538         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 539         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 540         u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
 541         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 542         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 543
 544         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 545         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 546         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 547         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 548         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 549
 550         switch (hw->mac.type) {
 551         case ixgbe_mac_82598EB:
 552                 ret = ixgbe_dcb_config_tx_data_arbiter_82598(hw, refill, max,
 553                                                              bwgid, tsa);
 554                 break;
 555         case ixgbe_mac_82599EB:
 556         case ixgbe_mac_X540:
 557         case ixgbe_mac_X550:
 558         case ixgbe_mac_X550EM_x:
 559 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 560                 ret = ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max,
 561                                                              bwgid, tsa,
 562                                                              map);
 563                 break;
 564 #endif
 565         default:
 566                 break;
 567         }
 568         return ret;
 569 }
 570
 571 /**
 572  * ixgbe_dcb_config_pfc_cee - Config priority flow control
 573  * @hw: pointer to hardware structure
 574  * @dcb_config: pointer to ixgbe_dcb_config structure
 575  *
 576  * Configure Priority Flow Control for each traffic class.
 577  */
 578 s32 ixgbe_dcb_config_pfc_cee(struct ixgbe_hw *hw,
 579                          struct ixgbe_dcb_config *dcb_config)
 580 {
 581         s32 ret = IXGBE_NOT_IMPLEMENTED;
 582         u8 pfc_en;
 583         u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
 584
 585         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 586         ixgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
 587
 588         switch (hw->mac.type) {
 589         case ixgbe_mac_82598EB:
 590                 ret = ixgbe_dcb_config_pfc_82598(hw, pfc_en);
 591                 break;
 592         case ixgbe_mac_82599EB:
 593         case ixgbe_mac_X540:
 594         case ixgbe_mac_X550:
 595         case ixgbe_mac_X550EM_x:
 596 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 597                 ret = ixgbe_dcb_config_pfc_82599(hw, pfc_en, map);
 598                 break;
 599 #endif
 600         default:
 601                 break;
 602         }
 603         return ret;
 604 }
 605
 606 /**
 607  * ixgbe_dcb_config_tc_stats - Config traffic class statistics
 608  * @hw: pointer to hardware structure
 609  *
 610  * Configure queue statistics registers, all queues belonging to same traffic
 611  * class uses a single set of queue statistics counters.
 612  */
 613 s32 ixgbe_dcb_config_tc_stats(struct ixgbe_hw *hw)
 614 {
 615         s32 ret = IXGBE_NOT_IMPLEMENTED;
 616         switch (hw->mac.type) {
 617         case ixgbe_mac_82598EB:
 618                 ret = ixgbe_dcb_config_tc_stats_82598(hw);
 619                 break;
 620         case ixgbe_mac_82599EB:
 621         case ixgbe_mac_X540:
 622         case ixgbe_mac_X550:
 623         case ixgbe_mac_X550EM_x:
 624 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 625                 ret = ixgbe_dcb_config_tc_stats_82599(hw, NULL);
 626                 break;
 627 #endif
 628         default:
 629                 break;
 630         }
 631         return ret;
 632 }
 633
 634 /**
 635  * ixgbe_dcb_hw_config_cee - Config and enable DCB
 636  * @hw: pointer to hardware structure
 637  * @dcb_config: pointer to ixgbe_dcb_config structure
 638  *
 639  * Configure dcb settings and enable dcb mode.
 640  */
 641 s32 ixgbe_dcb_hw_config_cee(struct ixgbe_hw *hw,
 642                         struct ixgbe_dcb_config *dcb_config)
 643 {
 644         s32 ret = IXGBE_NOT_IMPLEMENTED;
 645         u8 pfc_en;
 646         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 647         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 648         u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
 649         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 650         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 651
 652         /* Unpack CEE standard containers */
 653         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 654         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 655         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 656         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 657         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 658
 659         hw->mac.ops.setup_rxpba(hw, dcb_config->num_tcs.pg_tcs,
 660                                 0, dcb_config->rx_pba_cfg);
 661
 662         switch (hw->mac.type) {
 663         case ixgbe_mac_82598EB:
 664                 ret = ixgbe_dcb_hw_config_82598(hw, dcb_config->link_speed,
 665                                                 refill, max, bwgid, tsa);
 666                 break;
 667         case ixgbe_mac_82599EB:
 668         case ixgbe_mac_X540:
 669         case ixgbe_mac_X550:
 670         case ixgbe_mac_X550EM_x:
 671 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 672                 ixgbe_dcb_config_82599(hw, dcb_config);
 673                 ret = ixgbe_dcb_hw_config_82599(hw, dcb_config->link_speed,
 674                                                 refill, max, bwgid,
 675                                                 tsa, map);
 676
 677                 ixgbe_dcb_config_tc_stats_82599(hw, dcb_config);
 678                 break;
 679 #endif
 680         default:
 681                 break;
 682         }
 683
 684         if (!ret && dcb_config->pfc_mode_enable) {
 685                 ixgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
 686                 ret = ixgbe_dcb_config_pfc(hw, pfc_en, map);
 687         }
 688
 689         return ret;
 690 }
 691
 692 /* Helper routines to abstract HW specifics from DCB netlink ops */
 693 s32 ixgbe_dcb_config_pfc(struct ixgbe_hw *hw, u8 pfc_en, u8 *map)
 694 {
 695         int ret = IXGBE_ERR_PARAM;
 696
 697         switch (hw->mac.type) {
 698         case ixgbe_mac_82598EB:
 699                 ret = ixgbe_dcb_config_pfc_82598(hw, pfc_en);
 700                 break;
 701         case ixgbe_mac_82599EB:
 702         case ixgbe_mac_X540:
 703         case ixgbe_mac_X550:
 704         case ixgbe_mac_X550EM_x:
 705 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 706                 ret = ixgbe_dcb_config_pfc_82599(hw, pfc_en, map);
 707                 break;
 708 #endif
 709         default:
 710                 break;
 711         }
 712         return ret;
 713 }
 714
 715 s32 ixgbe_dcb_hw_config(struct ixgbe_hw *hw, u16 *refill, u16 *max,
 716                             u8 *bwg_id, u8 *tsa, u8 *map)
 717 {
 718         switch (hw->mac.type) {
 719         case ixgbe_mac_82598EB:
 720                 ixgbe_dcb_config_rx_arbiter_82598(hw, refill, max, tsa);
 721                 ixgbe_dcb_config_tx_desc_arbiter_82598(hw, refill, max, bwg_id,
 722                                                        tsa);
 723                 ixgbe_dcb_config_tx_data_arbiter_82598(hw, refill, max, bwg_id,
 724                                                        tsa);
 725                 break;
 726         case ixgbe_mac_82599EB:
 727         case ixgbe_mac_X540:
 728         case ixgbe_mac_X550:
 729         case ixgbe_mac_X550EM_x:
 730 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
 731                 ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwg_id,
 732                                                   tsa, map);
 733                 ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max, bwg_id,
 734                                                        tsa);
 735                 ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max, bwg_id,
 736                                                        tsa, map);
 737                 break;
 738 #endif
 739         default:
 740                 break;
 741         }
 742         return 0;
 743 }