lib/librte_pmd_ixgbe/ixgbe/ixgbe_dcb.c

   1 /*******************************************************************************
   2
   3 Copyright (c) 2001-2014, 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
  34
  35 #include "ixgbe_type.h"
  36 #include "ixgbe_dcb.h"
  37 #include "ixgbe_dcb_82598.h"
  38 #include "ixgbe_dcb_82599.h"
  39 #ident "$Id: ixgbe_dcb.c,v 1.55 2013/11/22 01:02:01 jtkirshe Exp $"
  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                 p->data_credits_refill = (u16)credit_refill;
 152
 153                 /* Calculate maximum credit for the TC */
 154                 credit_max = (link_percentage * IXGBE_DCB_MAX_CREDIT) / 100;
 155
 156                 /*
 157                  * Adjustment based on rule checking, if the percentage
 158                  * of a TC is too small, the maximum credit may not be
 159                  * enough to send out a jumbo frame in data plane arbitration.
 160                  */
 161                 if (credit_max && (credit_max < min_credit))
 162                         credit_max = min_credit;
 163
 164                 if (direction == IXGBE_DCB_TX_CONFIG) {
 165                         /*
 166                          * Adjustment based on rule checking, if the
 167                          * percentage of a TC is too small, the maximum
 168                          * credit may not be enough to send out a TSO
 169                          * packet in descriptor plane arbitration.
 170                          */
 171                         if (credit_max && (credit_max <
 172                             IXGBE_DCB_MIN_TSO_CREDIT)
 173                             && (hw->mac.type == ixgbe_mac_82598EB))
 174                                 credit_max = IXGBE_DCB_MIN_TSO_CREDIT;
 175
 176                         dcb_config->tc_config[i].desc_credits_max =
 177                                                                 (u16)credit_max;
 178                 }
 179
 180                 p->data_credits_max = (u16)credit_max;
 181         }
 182
 183 out:
 184         return ret_val;
 185 }
 186
 187 /**
 188  * ixgbe_dcb_unpack_pfc_cee - Unpack dcb_config PFC info
 189  * @cfg: dcb configuration to unpack into hardware consumable fields
 190  * @map: user priority to traffic class map
 191  * @pfc_up: u8 to store user priority PFC bitmask
 192  *
 193  * This unpacks the dcb configuration PFC info which is stored per
 194  * traffic class into a 8bit user priority bitmask that can be
 195  * consumed by hardware routines. The priority to tc map must be
 196  * updated before calling this routine to use current up-to maps.
 197  */
 198 void ixgbe_dcb_unpack_pfc_cee(struct ixgbe_dcb_config *cfg, u8 *map, u8 *pfc_up)
 199 {
 200         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 201         int up;
 202
 203         /*
 204          * If the TC for this user priority has PFC enabled then set the
 205          * matching bit in 'pfc_up' to reflect that PFC is enabled.
 206          */
 207         for (*pfc_up = 0, up = 0; up < IXGBE_DCB_MAX_USER_PRIORITY; up++) {
 208                 if (tc_config[map[up]].pfc != ixgbe_dcb_pfc_disabled)
 209                         *pfc_up |= 1 << up;
 210         }
 211 }
 212
 213 void ixgbe_dcb_unpack_refill_cee(struct ixgbe_dcb_config *cfg, int direction,
 214                              u16 *refill)
 215 {
 216         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 217         int tc;
 218
 219         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 220                 refill[tc] = tc_config[tc].path[direction].data_credits_refill;
 221 }
 222
 223 void ixgbe_dcb_unpack_max_cee(struct ixgbe_dcb_config *cfg, u16 *max)
 224 {
 225         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 226         int tc;
 227
 228         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 229                 max[tc] = tc_config[tc].desc_credits_max;
 230 }
 231
 232 void ixgbe_dcb_unpack_bwgid_cee(struct ixgbe_dcb_config *cfg, int direction,
 233                             u8 *bwgid)
 234 {
 235         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 236         int tc;
 237
 238         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 239                 bwgid[tc] = tc_config[tc].path[direction].bwg_id;
 240 }
 241
 242 void ixgbe_dcb_unpack_tsa_cee(struct ixgbe_dcb_config *cfg, int direction,
 243                            u8 *tsa)
 244 {
 245         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 246         int tc;
 247
 248         for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
 249                 tsa[tc] = tc_config[tc].path[direction].tsa;
 250 }
 251
 252 u8 ixgbe_dcb_get_tc_from_up(struct ixgbe_dcb_config *cfg, int direction, u8 up)
 253 {
 254         struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
 255         u8 prio_mask = 1 << up;
 256         u8 tc = cfg->num_tcs.pg_tcs;
 257
 258         /* If tc is 0 then DCB is likely not enabled or supported */
 259         if (!tc)
 260                 goto out;
 261
 262         /*
 263          * Test from maximum TC to 1 and report the first match we find.  If
 264          * we find no match we can assume that the TC is 0 since the TC must
 265          * be set for all user priorities
 266          */
 267         for (tc--; tc; tc--) {
 268                 if (prio_mask & tc_config[tc].path[direction].up_to_tc_bitmap)
 269                         break;
 270         }
 271 out:
 272         return tc;
 273 }
 274
 275 void ixgbe_dcb_unpack_map_cee(struct ixgbe_dcb_config *cfg, int direction,
 276                               u8 *map)
 277 {
 278         u8 up;
 279
 280         for (up = 0; up < IXGBE_DCB_MAX_USER_PRIORITY; up++)
 281                 map[up] = ixgbe_dcb_get_tc_from_up(cfg, direction, up);
 282 }
 283
 284 /**
 285  * ixgbe_dcb_config - Struct containing DCB settings.
 286  * @dcb_config: Pointer to DCB config structure
 287  *
 288  * This function checks DCB rules for DCB settings.
 289  * The following rules are checked:
 290  * 1. The sum of bandwidth percentages of all Bandwidth Groups must total 100%.
 291  * 2. The sum of bandwidth percentages of all Traffic Classes within a Bandwidth
 292  *    Group must total 100.
 293  * 3. A Traffic Class should not be set to both Link Strict Priority
 294  *    and Group Strict Priority.
 295  * 4. Link strict Bandwidth Groups can only have link strict traffic classes
 296  *    with zero bandwidth.
 297  */
 298 s32 ixgbe_dcb_check_config_cee(struct ixgbe_dcb_config *dcb_config)
 299 {
 300         struct ixgbe_dcb_tc_path *p;
 301         s32 ret_val = IXGBE_SUCCESS;
 302         u8 i, j, bw = 0, bw_id;
 303         u8 bw_sum[2][IXGBE_DCB_MAX_BW_GROUP];
 304         bool link_strict[2][IXGBE_DCB_MAX_BW_GROUP];
 305
 306         memset(bw_sum, 0, sizeof(bw_sum));
 307         memset(link_strict, 0, sizeof(link_strict));
 308
 309         /* First Tx, then Rx */
 310         for (i = 0; i < 2; i++) {
 311                 /* Check each traffic class for rule violation */
 312                 for (j = 0; j < IXGBE_DCB_MAX_TRAFFIC_CLASS; j++) {
 313                         p = &dcb_config->tc_config[j].path[i];
 314
 315                         bw = p->bwg_percent;
 316                         bw_id = p->bwg_id;
 317
 318                         if (bw_id >= IXGBE_DCB_MAX_BW_GROUP) {
 319                                 ret_val = IXGBE_ERR_CONFIG;
 320                                 goto err_config;
 321                         }
 322                         if (p->tsa == ixgbe_dcb_tsa_strict) {
 323                                 link_strict[i][bw_id] = true;
 324                                 /* Link strict should have zero bandwidth */
 325                                 if (bw) {
 326                                         ret_val = IXGBE_ERR_CONFIG;
 327                                         goto err_config;
 328                                 }
 329                         } else if (!bw) {
 330                                 /*
 331                                  * Traffic classes without link strict
 332                                  * should have non-zero bandwidth.
 333                                  */
 334                                 ret_val = IXGBE_ERR_CONFIG;
 335                                 goto err_config;
 336                         }
 337                         bw_sum[i][bw_id] += bw;
 338                 }
 339
 340                 bw = 0;
 341
 342                 /* Check each bandwidth group for rule violation */
 343                 for (j = 0; j < IXGBE_DCB_MAX_BW_GROUP; j++) {
 344                         bw += dcb_config->bw_percentage[i][j];
 345                         /*
 346                          * Sum of bandwidth percentages of all traffic classes
 347                          * within a Bandwidth Group must total 100 except for
 348                          * link strict group (zero bandwidth).
 349                          */
 350                         if (link_strict[i][j]) {
 351                                 if (bw_sum[i][j]) {
 352                                         /*
 353                                          * Link strict group should have zero
 354                                          * bandwidth.
 355                                          */
 356                                         ret_val = IXGBE_ERR_CONFIG;
 357                                         goto err_config;
 358                                 }
 359                         } else if (bw_sum[i][j] != IXGBE_DCB_BW_PERCENT &&
 360                                    bw_sum[i][j] != 0) {
 361                                 ret_val = IXGBE_ERR_CONFIG;
 362                                 goto err_config;
 363                         }
 364                 }
 365
 366                 if (bw != IXGBE_DCB_BW_PERCENT) {
 367                         ret_val = IXGBE_ERR_CONFIG;
 368                         goto err_config;
 369                 }
 370         }
 371
 372 err_config:
 373         DEBUGOUT2("DCB error code %d while checking %s settings.\n",
 374                   ret_val, (i == IXGBE_DCB_TX_CONFIG) ? "Tx" : "Rx");
 375
 376         return ret_val;
 377 }
 378
 379 /**
 380  * ixgbe_dcb_get_tc_stats - Returns status of each traffic class
 381  * @hw: pointer to hardware structure
 382  * @stats: pointer to statistics structure
 383  * @tc_count:  Number of elements in bwg_array.
 384  *
 385  * This function returns the status data for each of the Traffic Classes in use.
 386  */
 387 s32 ixgbe_dcb_get_tc_stats(struct ixgbe_hw *hw, struct ixgbe_hw_stats *stats,
 388                            u8 tc_count)
 389 {
 390         s32 ret = IXGBE_NOT_IMPLEMENTED;
 391         switch (hw->mac.type) {
 392         case ixgbe_mac_82598EB:
 393                 ret = ixgbe_dcb_get_tc_stats_82598(hw, stats, tc_count);
 394                 break;
 395         case ixgbe_mac_82599EB:
 396         case ixgbe_mac_X540:
 397                 ret = ixgbe_dcb_get_tc_stats_82599(hw, stats, tc_count);
 398                 break;
 399         default:
 400                 break;
 401         }
 402         return ret;
 403 }
 404
 405 /**
 406  * ixgbe_dcb_get_pfc_stats - Returns CBFC status of each traffic class
 407  * @hw: pointer to hardware structure
 408  * @stats: pointer to statistics structure
 409  * @tc_count:  Number of elements in bwg_array.
 410  *
 411  * This function returns the CBFC status data for each of the Traffic Classes.
 412  */
 413 s32 ixgbe_dcb_get_pfc_stats(struct ixgbe_hw *hw, struct ixgbe_hw_stats *stats,
 414                             u8 tc_count)
 415 {
 416         s32 ret = IXGBE_NOT_IMPLEMENTED;
 417         switch (hw->mac.type) {
 418         case ixgbe_mac_82598EB:
 419                 ret = ixgbe_dcb_get_pfc_stats_82598(hw, stats, tc_count);
 420                 break;
 421         case ixgbe_mac_82599EB:
 422         case ixgbe_mac_X540:
 423                 ret = ixgbe_dcb_get_pfc_stats_82599(hw, stats, tc_count);
 424                 break;
 425         default:
 426                 break;
 427         }
 428         return ret;
 429 }
 430
 431 /**
 432  * ixgbe_dcb_config_rx_arbiter_cee - Config Rx arbiter
 433  * @hw: pointer to hardware structure
 434  * @dcb_config: pointer to ixgbe_dcb_config structure
 435  *
 436  * Configure Rx Data Arbiter and credits for each traffic class.
 437  */
 438 s32 ixgbe_dcb_config_rx_arbiter_cee(struct ixgbe_hw *hw,
 439                                 struct ixgbe_dcb_config *dcb_config)
 440 {
 441         s32 ret = IXGBE_NOT_IMPLEMENTED;
 442         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS]     = { 0 };
 443         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS]   = { 0 };
 444         u8 map[IXGBE_DCB_MAX_USER_PRIORITY]     = { 0 };
 445         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS] = { 0 };
 446         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS]    = { 0 };
 447
 448         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 449         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 450         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 451         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 452         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 453
 454         switch (hw->mac.type) {
 455         case ixgbe_mac_82598EB:
 456                 ret = ixgbe_dcb_config_rx_arbiter_82598(hw, refill, max, tsa);
 457                 break;
 458         case ixgbe_mac_82599EB:
 459         case ixgbe_mac_X540:
 460                 ret = ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwgid,
 461                                                         tsa, map);
 462                 break;
 463         default:
 464                 break;
 465         }
 466         return ret;
 467 }
 468
 469 /**
 470  * ixgbe_dcb_config_tx_desc_arbiter_cee - Config Tx Desc arbiter
 471  * @hw: pointer to hardware structure
 472  * @dcb_config: pointer to ixgbe_dcb_config structure
 473  *
 474  * Configure Tx Descriptor Arbiter and credits for each traffic class.
 475  */
 476 s32 ixgbe_dcb_config_tx_desc_arbiter_cee(struct ixgbe_hw *hw,
 477                                      struct ixgbe_dcb_config *dcb_config)
 478 {
 479         s32 ret = IXGBE_NOT_IMPLEMENTED;
 480         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 481         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 482         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 483         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 484
 485         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 486         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 487         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 488         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 489
 490         switch (hw->mac.type) {
 491         case ixgbe_mac_82598EB:
 492                 ret = ixgbe_dcb_config_tx_desc_arbiter_82598(hw, refill, max,
 493                                                              bwgid, tsa);
 494                 break;
 495         case ixgbe_mac_82599EB:
 496         case ixgbe_mac_X540:
 497                 ret = ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max,
 498                                                              bwgid, tsa);
 499                 break;
 500         default:
 501                 break;
 502         }
 503         return ret;
 504 }
 505
 506 /**
 507  * ixgbe_dcb_config_tx_data_arbiter_cee - Config Tx data arbiter
 508  * @hw: pointer to hardware structure
 509  * @dcb_config: pointer to ixgbe_dcb_config structure
 510  *
 511  * Configure Tx Data Arbiter and credits for each traffic class.
 512  */
 513 s32 ixgbe_dcb_config_tx_data_arbiter_cee(struct ixgbe_hw *hw,
 514                                      struct ixgbe_dcb_config *dcb_config)
 515 {
 516         s32 ret = IXGBE_NOT_IMPLEMENTED;
 517         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 518         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 519         u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
 520         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 521         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 522
 523         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 524         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 525         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 526         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 527         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 528
 529         switch (hw->mac.type) {
 530         case ixgbe_mac_82598EB:
 531                 ret = ixgbe_dcb_config_tx_data_arbiter_82598(hw, refill, max,
 532                                                              bwgid, tsa);
 533                 break;
 534         case ixgbe_mac_82599EB:
 535         case ixgbe_mac_X540:
 536                 ret = ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max,
 537                                                              bwgid, tsa,
 538                                                              map);
 539                 break;
 540         default:
 541                 break;
 542         }
 543         return ret;
 544 }
 545
 546 /**
 547  * ixgbe_dcb_config_pfc_cee - Config priority flow control
 548  * @hw: pointer to hardware structure
 549  * @dcb_config: pointer to ixgbe_dcb_config structure
 550  *
 551  * Configure Priority Flow Control for each traffic class.
 552  */
 553 s32 ixgbe_dcb_config_pfc_cee(struct ixgbe_hw *hw,
 554                          struct ixgbe_dcb_config *dcb_config)
 555 {
 556         s32 ret = IXGBE_NOT_IMPLEMENTED;
 557         u8 pfc_en;
 558         u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
 559
 560         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 561         ixgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
 562
 563         switch (hw->mac.type) {
 564         case ixgbe_mac_82598EB:
 565                 ret = ixgbe_dcb_config_pfc_82598(hw, pfc_en);
 566                 break;
 567         case ixgbe_mac_82599EB:
 568         case ixgbe_mac_X540:
 569                 ret = ixgbe_dcb_config_pfc_82599(hw, pfc_en, map);
 570                 break;
 571         default:
 572                 break;
 573         }
 574         return ret;
 575 }
 576
 577 /**
 578  * ixgbe_dcb_config_tc_stats - Config traffic class statistics
 579  * @hw: pointer to hardware structure
 580  *
 581  * Configure queue statistics registers, all queues belonging to same traffic
 582  * class uses a single set of queue statistics counters.
 583  */
 584 s32 ixgbe_dcb_config_tc_stats(struct ixgbe_hw *hw)
 585 {
 586         s32 ret = IXGBE_NOT_IMPLEMENTED;
 587         switch (hw->mac.type) {
 588         case ixgbe_mac_82598EB:
 589                 ret = ixgbe_dcb_config_tc_stats_82598(hw);
 590                 break;
 591         case ixgbe_mac_82599EB:
 592         case ixgbe_mac_X540:
 593                 ret = ixgbe_dcb_config_tc_stats_82599(hw, NULL);
 594                 break;
 595         default:
 596                 break;
 597         }
 598         return ret;
 599 }
 600
 601 /**
 602  * ixgbe_dcb_hw_config_cee - Config and enable DCB
 603  * @hw: pointer to hardware structure
 604  * @dcb_config: pointer to ixgbe_dcb_config structure
 605  *
 606  * Configure dcb settings and enable dcb mode.
 607  */
 608 s32 ixgbe_dcb_hw_config_cee(struct ixgbe_hw *hw,
 609                         struct ixgbe_dcb_config *dcb_config)
 610 {
 611         s32 ret = IXGBE_NOT_IMPLEMENTED;
 612         u8 pfc_en;
 613         u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 614         u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 615         u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
 616         u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 617         u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
 618
 619         /* Unpack CEE standard containers */
 620         ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
 621         ixgbe_dcb_unpack_max_cee(dcb_config, max);
 622         ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
 623         ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
 624         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
 625
 626         switch (hw->mac.type) {
 627         case ixgbe_mac_82598EB:
 628                 ret = ixgbe_dcb_hw_config_82598(hw, dcb_config->link_speed,
 629                                                 refill, max, bwgid, tsa);
 630                 break;
 631         case ixgbe_mac_82599EB:
 632         case ixgbe_mac_X540:
 633                 ixgbe_dcb_config_82599(hw, dcb_config);
 634                 ret = ixgbe_dcb_hw_config_82599(hw, dcb_config->link_speed,
 635                                                 refill, max, bwgid,
 636                                                 tsa, map);
 637
 638                 ixgbe_dcb_config_tc_stats_82599(hw, dcb_config);
 639                 break;
 640         default:
 641                 break;
 642         }
 643
 644         if (!ret && dcb_config->pfc_mode_enable) {
 645                 ixgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
 646                 ret = ixgbe_dcb_config_pfc(hw, pfc_en, map);
 647         }
 648
 649         return ret;
 650 }
 651
 652 /* Helper routines to abstract HW specifics from DCB netlink ops */
 653 s32 ixgbe_dcb_config_pfc(struct ixgbe_hw *hw, u8 pfc_en, u8 *map)
 654 {
 655         int ret = IXGBE_ERR_PARAM;
 656
 657         switch (hw->mac.type) {
 658         case ixgbe_mac_82598EB:
 659                 ret = ixgbe_dcb_config_pfc_82598(hw, pfc_en);
 660                 break;
 661         case ixgbe_mac_82599EB:
 662         case ixgbe_mac_X540:
 663                 ret = ixgbe_dcb_config_pfc_82599(hw, pfc_en, map);
 664                 break;
 665         default:
 666                 break;
 667         }
 668         return ret;
 669 }
 670
 671 s32 ixgbe_dcb_hw_config(struct ixgbe_hw *hw, u16 *refill, u16 *max,
 672                             u8 *bwg_id, u8 *tsa, u8 *map)
 673 {
 674         switch (hw->mac.type) {
 675         case ixgbe_mac_82598EB:
 676                 ixgbe_dcb_config_rx_arbiter_82598(hw, refill, max, tsa);
 677                 ixgbe_dcb_config_tx_desc_arbiter_82598(hw, refill, max, bwg_id,
 678                                                        tsa);
 679                 ixgbe_dcb_config_tx_data_arbiter_82598(hw, refill, max, bwg_id,
 680                                                        tsa);
 681                 break;
 682         case ixgbe_mac_82599EB:
 683         case ixgbe_mac_X540:
 684                 ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwg_id,
 685                                                   tsa, map);
 686                 ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max, bwg_id,
 687                                                        tsa);
 688                 ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max, bwg_id,
 689                                                        tsa, map);
 690                 break;
 691         default:
 692                 break;
 693         }
 694         return 0;
 695 }