drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c

   1 /*******************************************************************************
   2
   3   Intel 10 Gigabit PCI Express Linux driver
   4   Copyright(c) 1999 - 2012 Intel Corporation.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   You should have received a copy of the GNU General Public License along with
  16   this program; if not, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   Linux NICS <linux.nics@intel.com>
  24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26
  27 *******************************************************************************/
  28
  29 #include "ixgbe.h"
  30 #include <linux/dcbnl.h>
  31 #include "ixgbe_dcb_82598.h"
  32 #include "ixgbe_dcb_82599.h"
  33
  34 /* Callbacks for DCB netlink in the kernel */
  35 #define BIT_DCB_MODE    0x01
  36 #define BIT_PFC         0x02
  37 #define BIT_PG_RX       0x04
  38 #define BIT_PG_TX       0x08
  39 #define BIT_APP_UPCHG   0x10
  40 #define BIT_LINKSPEED   0x80
  41
  42 /* Responses for the DCB_C_SET_ALL command */
  43 #define DCB_HW_CHG_RST  0  /* DCB configuration changed with reset */
  44 #define DCB_NO_HW_CHG   1  /* DCB configuration did not change */
  45 #define DCB_HW_CHG      2  /* DCB configuration changed, no reset */
  46
  47 static int ixgbe_copy_dcb_cfg(struct ixgbe_adapter *adapter, int tc_max)
  48 {
  49         struct ixgbe_dcb_config *scfg = &adapter->temp_dcb_cfg;
  50         struct ixgbe_dcb_config *dcfg = &adapter->dcb_cfg;
  51         struct tc_configuration *src = NULL;
  52         struct tc_configuration *dst = NULL;
  53         int i, j;
  54         int tx = DCB_TX_CONFIG;
  55         int rx = DCB_RX_CONFIG;
  56         int changes = 0;
  57 #ifdef IXGBE_FCOE
  58         struct dcb_app app = {
  59                               .selector = DCB_APP_IDTYPE_ETHTYPE,
  60                               .protocol = ETH_P_FCOE,
  61                              };
  62         u8 up = dcb_getapp(adapter->netdev, &app);
  63
  64         if (up && !(up & (1 << adapter->fcoe.up)))
  65                 changes |= BIT_APP_UPCHG;
  66 #endif
  67
  68         for (i = DCB_PG_ATTR_TC_0; i < tc_max + DCB_PG_ATTR_TC_0; i++) {
  69                 src = &scfg->tc_config[i - DCB_PG_ATTR_TC_0];
  70                 dst = &dcfg->tc_config[i - DCB_PG_ATTR_TC_0];
  71
  72                 if (dst->path[tx].prio_type != src->path[tx].prio_type) {
  73                         dst->path[tx].prio_type = src->path[tx].prio_type;
  74                         changes |= BIT_PG_TX;
  75                 }
  76
  77                 if (dst->path[tx].bwg_id != src->path[tx].bwg_id) {
  78                         dst->path[tx].bwg_id = src->path[tx].bwg_id;
  79                         changes |= BIT_PG_TX;
  80                 }
  81
  82                 if (dst->path[tx].bwg_percent != src->path[tx].bwg_percent) {
  83                         dst->path[tx].bwg_percent = src->path[tx].bwg_percent;
  84                         changes |= BIT_PG_TX;
  85                 }
  86
  87                 if (dst->path[tx].up_to_tc_bitmap !=
  88                                 src->path[tx].up_to_tc_bitmap) {
  89                         dst->path[tx].up_to_tc_bitmap =
  90                                 src->path[tx].up_to_tc_bitmap;
  91                         changes |= (BIT_PG_TX | BIT_PFC | BIT_APP_UPCHG);
  92                 }
  93
  94                 if (dst->path[rx].prio_type != src->path[rx].prio_type) {
  95                         dst->path[rx].prio_type = src->path[rx].prio_type;
  96                         changes |= BIT_PG_RX;
  97                 }
  98
  99                 if (dst->path[rx].bwg_id != src->path[rx].bwg_id) {
 100                         dst->path[rx].bwg_id = src->path[rx].bwg_id;
 101                         changes |= BIT_PG_RX;
 102                 }
 103
 104                 if (dst->path[rx].bwg_percent != src->path[rx].bwg_percent) {
 105                         dst->path[rx].bwg_percent = src->path[rx].bwg_percent;
 106                         changes |= BIT_PG_RX;
 107                 }
 108
 109                 if (dst->path[rx].up_to_tc_bitmap !=
 110                                 src->path[rx].up_to_tc_bitmap) {
 111                         dst->path[rx].up_to_tc_bitmap =
 112                                 src->path[rx].up_to_tc_bitmap;
 113                         changes |= (BIT_PG_RX | BIT_PFC | BIT_APP_UPCHG);
 114                 }
 115         }
 116
 117         for (i = DCB_PG_ATTR_BW_ID_0; i < DCB_PG_ATTR_BW_ID_MAX; i++) {
 118                 j = i - DCB_PG_ATTR_BW_ID_0;
 119                 if (dcfg->bw_percentage[tx][j] != scfg->bw_percentage[tx][j]) {
 120                         dcfg->bw_percentage[tx][j] = scfg->bw_percentage[tx][j];
 121                         changes |= BIT_PG_TX;
 122                 }
 123                 if (dcfg->bw_percentage[rx][j] != scfg->bw_percentage[rx][j]) {
 124                         dcfg->bw_percentage[rx][j] = scfg->bw_percentage[rx][j];
 125                         changes |= BIT_PG_RX;
 126                 }
 127         }
 128
 129         for (i = DCB_PFC_UP_ATTR_0; i < DCB_PFC_UP_ATTR_MAX; i++) {
 130                 j = i - DCB_PFC_UP_ATTR_0;
 131                 if (dcfg->tc_config[j].dcb_pfc != scfg->tc_config[j].dcb_pfc) {
 132                         dcfg->tc_config[j].dcb_pfc = scfg->tc_config[j].dcb_pfc;
 133                         changes |= BIT_PFC;
 134                 }
 135         }
 136
 137         if (dcfg->pfc_mode_enable != scfg->pfc_mode_enable) {
 138                 dcfg->pfc_mode_enable = scfg->pfc_mode_enable;
 139                 changes |= BIT_PFC;
 140         }
 141
 142         return changes;
 143 }
 144
 145 static u8 ixgbe_dcbnl_get_state(struct net_device *netdev)
 146 {
 147         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 148
 149         return !!(adapter->flags & IXGBE_FLAG_DCB_ENABLED);
 150 }
 151
 152 static u8 ixgbe_dcbnl_set_state(struct net_device *netdev, u8 state)
 153 {
 154         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 155         int err = 0;
 156
 157         /* Fail command if not in CEE mode */
 158         if (!(adapter->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 159                 return 1;
 160
 161         /* verify there is something to do, if not then exit */
 162         if (!state == !(adapter->flags & IXGBE_FLAG_DCB_ENABLED))
 163                 goto out;
 164
 165         err = ixgbe_setup_tc(netdev,
 166                              state ? adapter->dcb_cfg.num_tcs.pg_tcs : 0);
 167 out:
 168         return !!err;
 169 }
 170
 171 static void ixgbe_dcbnl_get_perm_hw_addr(struct net_device *netdev,
 172                                          u8 *perm_addr)
 173 {
 174         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 175         int i, j;
 176
 177         memset(perm_addr, 0xff, MAX_ADDR_LEN);
 178
 179         for (i = 0; i < netdev->addr_len; i++)
 180                 perm_addr[i] = adapter->hw.mac.perm_addr[i];
 181
 182         switch (adapter->hw.mac.type) {
 183         case ixgbe_mac_82599EB:
 184         case ixgbe_mac_X540:
 185                 for (j = 0; j < netdev->addr_len; j++, i++)
 186                         perm_addr[i] = adapter->hw.mac.san_addr[j];
 187                 break;
 188         default:
 189                 break;
 190         }
 191 }
 192
 193 static void ixgbe_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc,
 194                                          u8 prio, u8 bwg_id, u8 bw_pct,
 195                                          u8 up_map)
 196 {
 197         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 198
 199         if (prio != DCB_ATTR_VALUE_UNDEFINED)
 200                 adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type = prio;
 201         if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
 202                 adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id = bwg_id;
 203         if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
 204                 adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent =
 205                         bw_pct;
 206         if (up_map != DCB_ATTR_VALUE_UNDEFINED)
 207                 adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap =
 208                         up_map;
 209 }
 210
 211 static void ixgbe_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
 212                                           u8 bw_pct)
 213 {
 214         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 215
 216         adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] = bw_pct;
 217 }
 218
 219 static void ixgbe_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev, int tc,
 220                                          u8 prio, u8 bwg_id, u8 bw_pct,
 221                                          u8 up_map)
 222 {
 223         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 224
 225         if (prio != DCB_ATTR_VALUE_UNDEFINED)
 226                 adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type = prio;
 227         if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
 228                 adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id = bwg_id;
 229         if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
 230                 adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent =
 231                         bw_pct;
 232         if (up_map != DCB_ATTR_VALUE_UNDEFINED)
 233                 adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap =
 234                         up_map;
 235 }
 236
 237 static void ixgbe_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
 238                                           u8 bw_pct)
 239 {
 240         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 241
 242         adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] = bw_pct;
 243 }
 244
 245 static void ixgbe_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int tc,
 246                                          u8 *prio, u8 *bwg_id, u8 *bw_pct,
 247                                          u8 *up_map)
 248 {
 249         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 250
 251         *prio = adapter->dcb_cfg.tc_config[tc].path[0].prio_type;
 252         *bwg_id = adapter->dcb_cfg.tc_config[tc].path[0].bwg_id;
 253         *bw_pct = adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent;
 254         *up_map = adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap;
 255 }
 256
 257 static void ixgbe_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
 258                                           u8 *bw_pct)
 259 {
 260         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 261
 262         *bw_pct = adapter->dcb_cfg.bw_percentage[0][bwg_id];
 263 }
 264
 265 static void ixgbe_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int tc,
 266                                          u8 *prio, u8 *bwg_id, u8 *bw_pct,
 267                                          u8 *up_map)
 268 {
 269         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 270
 271         *prio = adapter->dcb_cfg.tc_config[tc].path[1].prio_type;
 272         *bwg_id = adapter->dcb_cfg.tc_config[tc].path[1].bwg_id;
 273         *bw_pct = adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent;
 274         *up_map = adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap;
 275 }
 276
 277 static void ixgbe_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
 278                                           u8 *bw_pct)
 279 {
 280         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 281
 282         *bw_pct = adapter->dcb_cfg.bw_percentage[1][bwg_id];
 283 }
 284
 285 static void ixgbe_dcbnl_set_pfc_cfg(struct net_device *netdev, int priority,
 286                                     u8 setting)
 287 {
 288         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 289
 290         adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc = setting;
 291         if (adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc !=
 292             adapter->dcb_cfg.tc_config[priority].dcb_pfc)
 293                 adapter->temp_dcb_cfg.pfc_mode_enable = true;
 294 }
 295
 296 static void ixgbe_dcbnl_get_pfc_cfg(struct net_device *netdev, int priority,
 297                                     u8 *setting)
 298 {
 299         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 300
 301         *setting = adapter->dcb_cfg.tc_config[priority].dcb_pfc;
 302 }
 303
 304 #ifdef IXGBE_FCOE
 305 static void ixgbe_dcbnl_devreset(struct net_device *dev)
 306 {
 307         struct ixgbe_adapter *adapter = netdev_priv(dev);
 308
 309         while (test_and_set_bit(__IXGBE_RESETTING, &adapter->state))
 310                 usleep_range(1000, 2000);
 311
 312         if (netif_running(dev))
 313                 dev->netdev_ops->ndo_stop(dev);
 314
 315         ixgbe_clear_interrupt_scheme(adapter);
 316         ixgbe_init_interrupt_scheme(adapter);
 317
 318         if (netif_running(dev))
 319                 dev->netdev_ops->ndo_open(dev);
 320
 321         clear_bit(__IXGBE_RESETTING, &adapter->state);
 322 }
 323 #endif
 324
 325 static u8 ixgbe_dcbnl_set_all(struct net_device *netdev)
 326 {
 327         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 328         struct ixgbe_dcb_config *dcb_cfg = &adapter->dcb_cfg;
 329         struct ixgbe_hw *hw = &adapter->hw;
 330         int ret = DCB_NO_HW_CHG;
 331         int i;
 332
 333         /* Fail command if not in CEE mode */
 334         if (!(adapter->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 335                 return ret;
 336
 337         adapter->dcb_set_bitmap |= ixgbe_copy_dcb_cfg(adapter,
 338                                                       MAX_TRAFFIC_CLASS);
 339         if (!adapter->dcb_set_bitmap)
 340                 return ret;
 341
 342         if (adapter->dcb_set_bitmap & (BIT_PG_TX|BIT_PG_RX)) {
 343                 u16 refill[MAX_TRAFFIC_CLASS], max[MAX_TRAFFIC_CLASS];
 344                 u8 bwg_id[MAX_TRAFFIC_CLASS], prio_type[MAX_TRAFFIC_CLASS];
 345                 /* Priority to TC mapping in CEE case default to 1:1 */
 346                 u8 prio_tc[MAX_USER_PRIORITY];
 347                 int max_frame = adapter->netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
 348
 349 #ifdef IXGBE_FCOE
 350                 if (adapter->netdev->features & NETIF_F_FCOE_MTU)
 351                         max_frame = max(max_frame, IXGBE_FCOE_JUMBO_FRAME_SIZE);
 352 #endif
 353
 354                 ixgbe_dcb_calculate_tc_credits(hw, dcb_cfg, max_frame,
 355                                                DCB_TX_CONFIG);
 356                 ixgbe_dcb_calculate_tc_credits(hw, dcb_cfg, max_frame,
 357                                                DCB_RX_CONFIG);
 358
 359                 ixgbe_dcb_unpack_refill(dcb_cfg, DCB_TX_CONFIG, refill);
 360                 ixgbe_dcb_unpack_max(dcb_cfg, max);
 361                 ixgbe_dcb_unpack_bwgid(dcb_cfg, DCB_TX_CONFIG, bwg_id);
 362                 ixgbe_dcb_unpack_prio(dcb_cfg, DCB_TX_CONFIG, prio_type);
 363                 ixgbe_dcb_unpack_map(dcb_cfg, DCB_TX_CONFIG, prio_tc);
 364
 365                 ixgbe_dcb_hw_ets_config(hw, refill, max, bwg_id,
 366                                         prio_type, prio_tc);
 367
 368                 for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
 369                         netdev_set_prio_tc_map(netdev, i, prio_tc[i]);
 370
 371                 ret = DCB_HW_CHG_RST;
 372         }
 373
 374         if (adapter->dcb_set_bitmap & BIT_PFC) {
 375                 if (dcb_cfg->pfc_mode_enable) {
 376                         u8 pfc_en;
 377                         u8 prio_tc[MAX_USER_PRIORITY];
 378
 379                         ixgbe_dcb_unpack_map(dcb_cfg, DCB_TX_CONFIG, prio_tc);
 380                         ixgbe_dcb_unpack_pfc(dcb_cfg, &pfc_en);
 381                         ixgbe_dcb_hw_pfc_config(hw, pfc_en, prio_tc);
 382                 } else {
 383                         hw->mac.ops.fc_enable(hw);
 384                 }
 385
 386                 ixgbe_set_rx_drop_en(adapter);
 387
 388                 ret = DCB_HW_CHG;
 389         }
 390
 391 #ifdef IXGBE_FCOE
 392         /* Reprogam FCoE hardware offloads when the traffic class
 393          * FCoE is using changes. This happens if the APP info
 394          * changes or the up2tc mapping is updated.
 395          */
 396         if (adapter->dcb_set_bitmap & BIT_APP_UPCHG) {
 397                 struct dcb_app app = {
 398                                       .selector = DCB_APP_IDTYPE_ETHTYPE,
 399                                       .protocol = ETH_P_FCOE,
 400                                      };
 401                 u8 up = dcb_getapp(netdev, &app);
 402
 403                 adapter->fcoe.up = ffs(up) - 1;
 404                 ixgbe_dcbnl_devreset(netdev);
 405                 ret = DCB_HW_CHG_RST;
 406         }
 407 #endif
 408
 409         adapter->dcb_set_bitmap = 0x00;
 410         return ret;
 411 }
 412
 413 static u8 ixgbe_dcbnl_getcap(struct net_device *netdev, int capid, u8 *cap)
 414 {
 415         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 416
 417         switch (capid) {
 418         case DCB_CAP_ATTR_PG:
 419                 *cap = true;
 420                 break;
 421         case DCB_CAP_ATTR_PFC:
 422                 *cap = true;
 423                 break;
 424         case DCB_CAP_ATTR_UP2TC:
 425                 *cap = false;
 426                 break;
 427         case DCB_CAP_ATTR_PG_TCS:
 428                 *cap = 0x80;
 429                 break;
 430         case DCB_CAP_ATTR_PFC_TCS:
 431                 *cap = 0x80;
 432                 break;
 433         case DCB_CAP_ATTR_GSP:
 434                 *cap = true;
 435                 break;
 436         case DCB_CAP_ATTR_BCN:
 437                 *cap = false;
 438                 break;
 439         case DCB_CAP_ATTR_DCBX:
 440                 *cap = adapter->dcbx_cap;
 441                 break;
 442         default:
 443                 *cap = false;
 444                 break;
 445         }
 446
 447         return 0;
 448 }
 449
 450 static int ixgbe_dcbnl_getnumtcs(struct net_device *netdev, int tcid, u8 *num)
 451 {
 452         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 453         u8 rval = 0;
 454
 455         if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 456                 switch (tcid) {
 457                 case DCB_NUMTCS_ATTR_PG:
 458                         *num = adapter->dcb_cfg.num_tcs.pg_tcs;
 459                         break;
 460                 case DCB_NUMTCS_ATTR_PFC:
 461                         *num = adapter->dcb_cfg.num_tcs.pfc_tcs;
 462                         break;
 463                 default:
 464                         rval = -EINVAL;
 465                         break;
 466                 }
 467         } else {
 468                 rval = -EINVAL;
 469         }
 470
 471         return rval;
 472 }
 473
 474 static int ixgbe_dcbnl_setnumtcs(struct net_device *netdev, int tcid, u8 num)
 475 {
 476         return -EINVAL;
 477 }
 478
 479 static u8 ixgbe_dcbnl_getpfcstate(struct net_device *netdev)
 480 {
 481         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 482
 483         return adapter->dcb_cfg.pfc_mode_enable;
 484 }
 485
 486 static void ixgbe_dcbnl_setpfcstate(struct net_device *netdev, u8 state)
 487 {
 488         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 489
 490         adapter->temp_dcb_cfg.pfc_mode_enable = state;
 491 }
 492
 493 /**
 494  * ixgbe_dcbnl_getapp - retrieve the DCBX application user priority
 495  * @netdev : the corresponding netdev
 496  * @idtype : identifies the id as ether type or TCP/UDP port number
 497  * @id: id is either ether type or TCP/UDP port number
 498  *
 499  * Returns : on success, returns a non-zero 802.1p user priority bitmap
 500  * otherwise returns 0 as the invalid user priority bitmap to indicate an
 501  * error.
 502  */
 503 static u8 ixgbe_dcbnl_getapp(struct net_device *netdev, u8 idtype, u16 id)
 504 {
 505         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 506         struct dcb_app app = {
 507                                 .selector = idtype,
 508                                 .protocol = id,
 509                              };
 510
 511         if (!(adapter->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 512                 return 0;
 513
 514         return dcb_getapp(netdev, &app);
 515 }
 516
 517 static int ixgbe_dcbnl_ieee_getets(struct net_device *dev,
 518                                    struct ieee_ets *ets)
 519 {
 520         struct ixgbe_adapter *adapter = netdev_priv(dev);
 521         struct ieee_ets *my_ets = adapter->ixgbe_ieee_ets;
 522
 523         ets->ets_cap = adapter->dcb_cfg.num_tcs.pg_tcs;
 524
 525         /* No IEEE PFC settings available */
 526         if (!my_ets)
 527                 return 0;
 528
 529         ets->cbs = my_ets->cbs;
 530         memcpy(ets->tc_tx_bw, my_ets->tc_tx_bw, sizeof(ets->tc_tx_bw));
 531         memcpy(ets->tc_rx_bw, my_ets->tc_rx_bw, sizeof(ets->tc_rx_bw));
 532         memcpy(ets->tc_tsa, my_ets->tc_tsa, sizeof(ets->tc_tsa));
 533         memcpy(ets->prio_tc, my_ets->prio_tc, sizeof(ets->prio_tc));
 534         return 0;
 535 }
 536
 537 static int ixgbe_dcbnl_ieee_setets(struct net_device *dev,
 538                                    struct ieee_ets *ets)
 539 {
 540         struct ixgbe_adapter *adapter = netdev_priv(dev);
 541         int max_frame = dev->mtu + ETH_HLEN + ETH_FCS_LEN;
 542         int i, err = 0;
 543         __u8 max_tc = 0;
 544
 545         if (!(adapter->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))
 546                 return -EINVAL;
 547
 548         if (!adapter->ixgbe_ieee_ets) {
 549                 adapter->ixgbe_ieee_ets = kmalloc(sizeof(struct ieee_ets),
 550                                                   GFP_KERNEL);
 551                 if (!adapter->ixgbe_ieee_ets)
 552                         return -ENOMEM;
 553         }
 554
 555         memcpy(adapter->ixgbe_ieee_ets, ets, sizeof(*adapter->ixgbe_ieee_ets));
 556
 557         for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
 558                 if (ets->prio_tc[i] > max_tc)
 559                         max_tc = ets->prio_tc[i];
 560         }
 561
 562         if (max_tc)
 563                 max_tc++;
 564
 565         if (max_tc > adapter->dcb_cfg.num_tcs.pg_tcs)
 566                 return -EINVAL;
 567
 568         if (max_tc != netdev_get_num_tc(dev))
 569                 err = ixgbe_setup_tc(dev, max_tc);
 570
 571         if (err)
 572                 goto err_out;
 573
 574         err = ixgbe_dcb_hw_ets(&adapter->hw, ets, max_frame);
 575 err_out:
 576         return err;
 577 }
 578
 579 static int ixgbe_dcbnl_ieee_getpfc(struct net_device *dev,
 580                                    struct ieee_pfc *pfc)
 581 {
 582         struct ixgbe_adapter *adapter = netdev_priv(dev);
 583         struct ieee_pfc *my_pfc = adapter->ixgbe_ieee_pfc;
 584         int i;
 585
 586         pfc->pfc_cap = adapter->dcb_cfg.num_tcs.pfc_tcs;
 587
 588         /* No IEEE PFC settings available */
 589         if (!my_pfc)
 590                 return 0;
 591
 592         pfc->pfc_en = my_pfc->pfc_en;
 593         pfc->mbc = my_pfc->mbc;
 594         pfc->delay = my_pfc->delay;
 595
 596         for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
 597                 pfc->requests[i] = adapter->stats.pxoffrxc[i];
 598                 pfc->indications[i] = adapter->stats.pxofftxc[i];
 599         }
 600
 601         return 0;
 602 }
 603
 604 static int ixgbe_dcbnl_ieee_setpfc(struct net_device *dev,
 605                                    struct ieee_pfc *pfc)
 606 {
 607         struct ixgbe_adapter *adapter = netdev_priv(dev);
 608         struct ixgbe_hw *hw = &adapter->hw;
 609         u8 *prio_tc;
 610         int err;
 611
 612         if (!(adapter->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))
 613                 return -EINVAL;
 614
 615         if (!adapter->ixgbe_ieee_pfc) {
 616                 adapter->ixgbe_ieee_pfc = kmalloc(sizeof(struct ieee_pfc),
 617                                                   GFP_KERNEL);
 618                 if (!adapter->ixgbe_ieee_pfc)
 619                         return -ENOMEM;
 620         }
 621
 622         prio_tc = adapter->ixgbe_ieee_ets->prio_tc;
 623         memcpy(adapter->ixgbe_ieee_pfc, pfc, sizeof(*adapter->ixgbe_ieee_pfc));
 624
 625         /* Enable link flow control parameters if PFC is disabled */
 626         if (pfc->pfc_en)
 627                 err = ixgbe_dcb_hw_pfc_config(hw, pfc->pfc_en, prio_tc);
 628         else
 629                 err = hw->mac.ops.fc_enable(hw);
 630
 631         ixgbe_set_rx_drop_en(adapter);
 632
 633         return err;
 634 }
 635
 636 static int ixgbe_dcbnl_ieee_setapp(struct net_device *dev,
 637                                    struct dcb_app *app)
 638 {
 639         struct ixgbe_adapter *adapter = netdev_priv(dev);
 640         int err = -EINVAL;
 641
 642         if (!(adapter->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))
 643                 return err;
 644
 645         err = dcb_ieee_setapp(dev, app);
 646
 647 #ifdef IXGBE_FCOE
 648         if (!err && app->selector == IEEE_8021QAZ_APP_SEL_ETHERTYPE &&
 649             app->protocol == ETH_P_FCOE) {
 650                 u8 app_mask = dcb_ieee_getapp_mask(dev, app);
 651
 652                 if (app_mask & (1 << adapter->fcoe.up))
 653                         return err;
 654
 655                 adapter->fcoe.up = app->priority;
 656                 ixgbe_dcbnl_devreset(dev);
 657         }
 658 #endif
 659         return 0;
 660 }
 661
 662 static int ixgbe_dcbnl_ieee_delapp(struct net_device *dev,
 663                                    struct dcb_app *app)
 664 {
 665         struct ixgbe_adapter *adapter = netdev_priv(dev);
 666         int err;
 667
 668         if (!(adapter->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))
 669                 return -EINVAL;
 670
 671         err = dcb_ieee_delapp(dev, app);
 672
 673 #ifdef IXGBE_FCOE
 674         if (!err && app->selector == IEEE_8021QAZ_APP_SEL_ETHERTYPE &&
 675             app->protocol == ETH_P_FCOE) {
 676                 u8 app_mask = dcb_ieee_getapp_mask(dev, app);
 677
 678                 if (app_mask & (1 << adapter->fcoe.up))
 679                         return err;
 680
 681                 adapter->fcoe.up = app_mask ?
 682                                    ffs(app_mask) - 1 : IXGBE_FCOE_DEFTC;
 683                 ixgbe_dcbnl_devreset(dev);
 684         }
 685 #endif
 686         return err;
 687 }
 688
 689 static u8 ixgbe_dcbnl_getdcbx(struct net_device *dev)
 690 {
 691         struct ixgbe_adapter *adapter = netdev_priv(dev);
 692         return adapter->dcbx_cap;
 693 }
 694
 695 static u8 ixgbe_dcbnl_setdcbx(struct net_device *dev, u8 mode)
 696 {
 697         struct ixgbe_adapter *adapter = netdev_priv(dev);
 698         struct ieee_ets ets = {0};
 699         struct ieee_pfc pfc = {0};
 700         int err = 0;
 701
 702         /* no support for LLD_MANAGED modes or CEE+IEEE */
 703         if ((mode & DCB_CAP_DCBX_LLD_MANAGED) ||
 704             ((mode & DCB_CAP_DCBX_VER_IEEE) && (mode & DCB_CAP_DCBX_VER_CEE)) ||
 705             !(mode & DCB_CAP_DCBX_HOST))
 706                 return 1;
 707
 708         if (mode == adapter->dcbx_cap)
 709                 return 0;
 710
 711         adapter->dcbx_cap = mode;
 712
 713         /* ETS and PFC defaults */
 714         ets.ets_cap = 8;
 715         pfc.pfc_cap = 8;
 716
 717         if (mode & DCB_CAP_DCBX_VER_IEEE) {
 718                 ixgbe_dcbnl_ieee_setets(dev, &ets);
 719                 ixgbe_dcbnl_ieee_setpfc(dev, &pfc);
 720         } else if (mode & DCB_CAP_DCBX_VER_CEE) {
 721                 u8 mask = BIT_PFC | BIT_PG_TX | BIT_PG_RX | BIT_APP_UPCHG;
 722
 723                 adapter->dcb_set_bitmap |= mask;
 724                 ixgbe_dcbnl_set_all(dev);
 725         } else {
 726                 /* Drop into single TC mode strict priority as this
 727                  * indicates CEE and IEEE versions are disabled
 728                  */
 729                 ixgbe_dcbnl_ieee_setets(dev, &ets);
 730                 ixgbe_dcbnl_ieee_setpfc(dev, &pfc);
 731                 err = ixgbe_setup_tc(dev, 0);
 732         }
 733
 734         return err ? 1 : 0;
 735 }
 736
 737 const struct dcbnl_rtnl_ops dcbnl_ops = {
 738         .ieee_getets    = ixgbe_dcbnl_ieee_getets,
 739         .ieee_setets    = ixgbe_dcbnl_ieee_setets,
 740         .ieee_getpfc    = ixgbe_dcbnl_ieee_getpfc,
 741         .ieee_setpfc    = ixgbe_dcbnl_ieee_setpfc,
 742         .ieee_setapp    = ixgbe_dcbnl_ieee_setapp,
 743         .ieee_delapp    = ixgbe_dcbnl_ieee_delapp,
 744         .getstate       = ixgbe_dcbnl_get_state,
 745         .setstate       = ixgbe_dcbnl_set_state,
 746         .getpermhwaddr  = ixgbe_dcbnl_get_perm_hw_addr,
 747         .setpgtccfgtx   = ixgbe_dcbnl_set_pg_tc_cfg_tx,
 748         .setpgbwgcfgtx  = ixgbe_dcbnl_set_pg_bwg_cfg_tx,
 749         .setpgtccfgrx   = ixgbe_dcbnl_set_pg_tc_cfg_rx,
 750         .setpgbwgcfgrx  = ixgbe_dcbnl_set_pg_bwg_cfg_rx,
 751         .getpgtccfgtx   = ixgbe_dcbnl_get_pg_tc_cfg_tx,
 752         .getpgbwgcfgtx  = ixgbe_dcbnl_get_pg_bwg_cfg_tx,
 753         .getpgtccfgrx   = ixgbe_dcbnl_get_pg_tc_cfg_rx,
 754         .getpgbwgcfgrx  = ixgbe_dcbnl_get_pg_bwg_cfg_rx,
 755         .setpfccfg      = ixgbe_dcbnl_set_pfc_cfg,
 756         .getpfccfg      = ixgbe_dcbnl_get_pfc_cfg,
 757         .setall         = ixgbe_dcbnl_set_all,
 758         .getcap         = ixgbe_dcbnl_getcap,
 759         .getnumtcs      = ixgbe_dcbnl_getnumtcs,
 760         .setnumtcs      = ixgbe_dcbnl_setnumtcs,
 761         .getpfcstate    = ixgbe_dcbnl_getpfcstate,
 762         .setpfcstate    = ixgbe_dcbnl_setpfcstate,
 763         .getapp         = ixgbe_dcbnl_getapp,
 764         .getdcbx        = ixgbe_dcbnl_getdcbx,
 765         .setdcbx        = ixgbe_dcbnl_setdcbx,
 766 };