drivers/net/ixgbe/ixgbe_dcb_nl.c

   1 /*******************************************************************************
   2
   3   Intel 10 Gigabit PCI Express Linux driver
   4   Copyright(c) 1999 - 2009 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_RESETLINK   0x40
  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 int ixgbe_copy_dcb_cfg(struct ixgbe_dcb_config *src_dcb_cfg,
  48                        struct ixgbe_dcb_config *dst_dcb_cfg, int tc_max)
  49 {
  50         struct tc_configuration *src_tc_cfg = NULL;
  51         struct tc_configuration *dst_tc_cfg = NULL;
  52         int i;
  53
  54         if (!src_dcb_cfg || !dst_dcb_cfg)
  55                 return -EINVAL;
  56
  57         for (i = DCB_PG_ATTR_TC_0; i < tc_max + DCB_PG_ATTR_TC_0; i++) {
  58                 src_tc_cfg = &src_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];
  59                 dst_tc_cfg = &dst_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];
  60
  61                 dst_tc_cfg->path[DCB_TX_CONFIG].prio_type =
  62                                 src_tc_cfg->path[DCB_TX_CONFIG].prio_type;
  63
  64                 dst_tc_cfg->path[DCB_TX_CONFIG].bwg_id =
  65                                 src_tc_cfg->path[DCB_TX_CONFIG].bwg_id;
  66
  67                 dst_tc_cfg->path[DCB_TX_CONFIG].bwg_percent =
  68                                 src_tc_cfg->path[DCB_TX_CONFIG].bwg_percent;
  69
  70                 dst_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap =
  71                                 src_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap;
  72
  73                 dst_tc_cfg->path[DCB_RX_CONFIG].prio_type =
  74                                 src_tc_cfg->path[DCB_RX_CONFIG].prio_type;
  75
  76                 dst_tc_cfg->path[DCB_RX_CONFIG].bwg_id =
  77                                 src_tc_cfg->path[DCB_RX_CONFIG].bwg_id;
  78
  79                 dst_tc_cfg->path[DCB_RX_CONFIG].bwg_percent =
  80                                 src_tc_cfg->path[DCB_RX_CONFIG].bwg_percent;
  81
  82                 dst_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap =
  83                                 src_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap;
  84         }
  85
  86         for (i = DCB_PG_ATTR_BW_ID_0; i < DCB_PG_ATTR_BW_ID_MAX; i++) {
  87                 dst_dcb_cfg->bw_percentage[DCB_TX_CONFIG]
  88                         [i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
  89                                 [DCB_TX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
  90                 dst_dcb_cfg->bw_percentage[DCB_RX_CONFIG]
  91                         [i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
  92                                 [DCB_RX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
  93         }
  94
  95         for (i = DCB_PFC_UP_ATTR_0; i < DCB_PFC_UP_ATTR_MAX; i++) {
  96                 dst_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc =
  97                         src_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc;
  98         }
  99
 100         dst_dcb_cfg->pfc_mode_enable = src_dcb_cfg->pfc_mode_enable;
 101
 102         return 0;
 103 }
 104
 105 static u8 ixgbe_dcbnl_get_state(struct net_device *netdev)
 106 {
 107         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 108
 109         return !!(adapter->flags & IXGBE_FLAG_DCB_ENABLED);
 110 }
 111
 112 static u8 ixgbe_dcbnl_set_state(struct net_device *netdev, u8 state)
 113 {
 114         u8 err = 0;
 115         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 116
 117         if (state > 0) {
 118                 /* Turn on DCB */
 119                 if (adapter->flags & IXGBE_FLAG_DCB_ENABLED)
 120                         goto out;
 121
 122                 if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED)) {
 123                         DPRINTK(DRV, ERR, "Enable failed, needs MSI-X\n");
 124                         err = 1;
 125                         goto out;
 126                 }
 127
 128                 if (netif_running(netdev))
 129                         netdev->netdev_ops->ndo_stop(netdev);
 130                 ixgbe_clear_interrupt_scheme(adapter);
 131
 132                 if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
 133                         adapter->last_lfc_mode = adapter->hw.fc.current_mode;
 134                         adapter->hw.fc.requested_mode = ixgbe_fc_none;
 135                 }
 136                 adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
 137                 if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
 138                         adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
 139                         adapter->flags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
 140                 }
 141                 adapter->flags |= IXGBE_FLAG_DCB_ENABLED;
 142 #ifdef IXGBE_FCOE
 143                 /* Turn on FCoE offload */
 144                 if ((adapter->flags & IXGBE_FLAG_FCOE_CAPABLE) &&
 145                     (!(adapter->flags & IXGBE_FLAG_FCOE_ENABLED))) {
 146                         adapter->flags |= IXGBE_FLAG_FCOE_ENABLED;
 147                         adapter->ring_feature[RING_F_FCOE].indices =
 148                                 IXGBE_FCRETA_SIZE;
 149                         netdev->features |= NETIF_F_FCOE_CRC;
 150                         netdev->features |= NETIF_F_FSO;
 151                         netdev->vlan_features |= NETIF_F_FCOE_CRC;
 152                         netdev->vlan_features |= NETIF_F_FSO;
 153                         netdev->fcoe_ddp_xid = IXGBE_FCOE_DDP_MAX - 1;
 154                         netdev_features_change(netdev);
 155                 }
 156 #endif /* IXGBE_FCOE */
 157                 ixgbe_init_interrupt_scheme(adapter);
 158                 if (netif_running(netdev))
 159                         netdev->netdev_ops->ndo_open(netdev);
 160         } else {
 161                 /* Turn off DCB */
 162                 if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 163                         if (netif_running(netdev))
 164                                 netdev->netdev_ops->ndo_stop(netdev);
 165                         ixgbe_clear_interrupt_scheme(adapter);
 166
 167                         adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
 168                         adapter->temp_dcb_cfg.pfc_mode_enable = false;
 169                         adapter->dcb_cfg.pfc_mode_enable = false;
 170                         adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
 171                         adapter->flags |= IXGBE_FLAG_RSS_ENABLED;
 172                         if (adapter->hw.mac.type == ixgbe_mac_82599EB)
 173                                 adapter->flags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
 174
 175 #ifdef IXGBE_FCOE
 176                         /* Turn off FCoE offload */
 177                         if (adapter->flags & (IXGBE_FLAG_FCOE_CAPABLE |
 178                              IXGBE_FLAG_FCOE_ENABLED)) {
 179                                 adapter->flags &= ~IXGBE_FLAG_FCOE_ENABLED;
 180                                 adapter->ring_feature[RING_F_FCOE].indices = 0;
 181                                 netdev->features &= ~NETIF_F_FCOE_CRC;
 182                                 netdev->features &= ~NETIF_F_FSO;
 183                                 netdev->vlan_features &= ~NETIF_F_FCOE_CRC;
 184                                 netdev->vlan_features &= ~NETIF_F_FSO;
 185                                 netdev->fcoe_ddp_xid = 0;
 186                                 netdev_features_change(netdev);
 187                         }
 188 #endif /* IXGBE_FCOE */
 189                         ixgbe_init_interrupt_scheme(adapter);
 190                         if (netif_running(netdev))
 191                                 netdev->netdev_ops->ndo_open(netdev);
 192                 }
 193         }
 194 out:
 195         return err;
 196 }
 197
 198 static void ixgbe_dcbnl_get_perm_hw_addr(struct net_device *netdev,
 199                                          u8 *perm_addr)
 200 {
 201         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 202         int i, j;
 203
 204         memset(perm_addr, 0xff, MAX_ADDR_LEN);
 205
 206         for (i = 0; i < netdev->addr_len; i++)
 207                 perm_addr[i] = adapter->hw.mac.perm_addr[i];
 208
 209         if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
 210                 for (j = 0; j < netdev->addr_len; j++, i++)
 211                         perm_addr[i] = adapter->hw.mac.san_addr[j];
 212         }
 213 }
 214
 215 static void ixgbe_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc,
 216                                          u8 prio, u8 bwg_id, u8 bw_pct,
 217                                          u8 up_map)
 218 {
 219         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 220
 221         if (prio != DCB_ATTR_VALUE_UNDEFINED)
 222                 adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type = prio;
 223         if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
 224                 adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id = bwg_id;
 225         if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
 226                 adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent =
 227                         bw_pct;
 228         if (up_map != DCB_ATTR_VALUE_UNDEFINED)
 229                 adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap =
 230                         up_map;
 231
 232         if ((adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type !=
 233              adapter->dcb_cfg.tc_config[tc].path[0].prio_type) ||
 234             (adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id !=
 235              adapter->dcb_cfg.tc_config[tc].path[0].bwg_id) ||
 236             (adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent !=
 237              adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent) ||
 238             (adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap !=
 239              adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap)) {
 240                 adapter->dcb_set_bitmap |= BIT_PG_TX;
 241                 adapter->dcb_set_bitmap |= BIT_RESETLINK;
 242         }
 243 }
 244
 245 static void ixgbe_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
 246                                           u8 bw_pct)
 247 {
 248         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 249
 250         adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] = bw_pct;
 251
 252         if (adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] !=
 253             adapter->dcb_cfg.bw_percentage[0][bwg_id]) {
 254                 adapter->dcb_set_bitmap |= BIT_PG_RX;
 255                 adapter->dcb_set_bitmap |= BIT_RESETLINK;
 256         }
 257 }
 258
 259 static void ixgbe_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev, int tc,
 260                                          u8 prio, u8 bwg_id, u8 bw_pct,
 261                                          u8 up_map)
 262 {
 263         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 264
 265         if (prio != DCB_ATTR_VALUE_UNDEFINED)
 266                 adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type = prio;
 267         if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
 268                 adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id = bwg_id;
 269         if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
 270                 adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent =
 271                         bw_pct;
 272         if (up_map != DCB_ATTR_VALUE_UNDEFINED)
 273                 adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap =
 274                         up_map;
 275
 276         if ((adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type !=
 277              adapter->dcb_cfg.tc_config[tc].path[1].prio_type) ||
 278             (adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id !=
 279              adapter->dcb_cfg.tc_config[tc].path[1].bwg_id) ||
 280             (adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent !=
 281              adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent) ||
 282             (adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap !=
 283              adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap)) {
 284                 adapter->dcb_set_bitmap |= BIT_PG_RX;
 285                 adapter->dcb_set_bitmap |= BIT_RESETLINK;
 286         }
 287 }
 288
 289 static void ixgbe_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
 290                                           u8 bw_pct)
 291 {
 292         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 293
 294         adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] = bw_pct;
 295
 296         if (adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] !=
 297             adapter->dcb_cfg.bw_percentage[1][bwg_id]) {
 298                 adapter->dcb_set_bitmap |= BIT_PG_RX;
 299                 adapter->dcb_set_bitmap |= BIT_RESETLINK;
 300         }
 301 }
 302
 303 static void ixgbe_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int tc,
 304                                          u8 *prio, u8 *bwg_id, u8 *bw_pct,
 305                                          u8 *up_map)
 306 {
 307         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 308
 309         *prio = adapter->dcb_cfg.tc_config[tc].path[0].prio_type;
 310         *bwg_id = adapter->dcb_cfg.tc_config[tc].path[0].bwg_id;
 311         *bw_pct = adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent;
 312         *up_map = adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap;
 313 }
 314
 315 static void ixgbe_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
 316                                           u8 *bw_pct)
 317 {
 318         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 319
 320         *bw_pct = adapter->dcb_cfg.bw_percentage[0][bwg_id];
 321 }
 322
 323 static void ixgbe_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int tc,
 324                                          u8 *prio, u8 *bwg_id, u8 *bw_pct,
 325                                          u8 *up_map)
 326 {
 327         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 328
 329         *prio = adapter->dcb_cfg.tc_config[tc].path[1].prio_type;
 330         *bwg_id = adapter->dcb_cfg.tc_config[tc].path[1].bwg_id;
 331         *bw_pct = adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent;
 332         *up_map = adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap;
 333 }
 334
 335 static void ixgbe_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
 336                                           u8 *bw_pct)
 337 {
 338         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 339
 340         *bw_pct = adapter->dcb_cfg.bw_percentage[1][bwg_id];
 341 }
 342
 343 static void ixgbe_dcbnl_set_pfc_cfg(struct net_device *netdev, int priority,
 344                                     u8 setting)
 345 {
 346         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 347
 348         adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc = setting;
 349         if (adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc !=
 350             adapter->dcb_cfg.tc_config[priority].dcb_pfc) {
 351                 adapter->dcb_set_bitmap |= BIT_PFC;
 352                 adapter->temp_dcb_cfg.pfc_mode_enable = true;
 353         }
 354 }
 355
 356 static void ixgbe_dcbnl_get_pfc_cfg(struct net_device *netdev, int priority,
 357                                     u8 *setting)
 358 {
 359         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 360
 361         *setting = adapter->dcb_cfg.tc_config[priority].dcb_pfc;
 362 }
 363
 364 static u8 ixgbe_dcbnl_set_all(struct net_device *netdev)
 365 {
 366         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 367         int ret;
 368
 369         if (!adapter->dcb_set_bitmap)
 370                 return DCB_NO_HW_CHG;
 371
 372         /*
 373          * Only take down the adapter if the configuration change
 374          * requires a reset.
 375          */
 376         if (adapter->dcb_set_bitmap & BIT_RESETLINK) {
 377                 while (test_and_set_bit(__IXGBE_RESETTING, &adapter->state))
 378                         msleep(1);
 379
 380                 if (netif_running(netdev))
 381                         ixgbe_down(adapter);
 382         }
 383
 384         ret = ixgbe_copy_dcb_cfg(&adapter->temp_dcb_cfg, &adapter->dcb_cfg,
 385                                  adapter->ring_feature[RING_F_DCB].indices);
 386         if (ret) {
 387                 if (adapter->dcb_set_bitmap & BIT_RESETLINK)
 388                         clear_bit(__IXGBE_RESETTING, &adapter->state);
 389                 return DCB_NO_HW_CHG;
 390         }
 391
 392         if (adapter->dcb_cfg.pfc_mode_enable) {
 393                 if ((adapter->hw.mac.type != ixgbe_mac_82598EB) &&
 394                         (adapter->hw.fc.current_mode != ixgbe_fc_pfc))
 395                         adapter->last_lfc_mode = adapter->hw.fc.current_mode;
 396                 adapter->hw.fc.requested_mode = ixgbe_fc_pfc;
 397         } else {
 398                 if (adapter->hw.mac.type != ixgbe_mac_82598EB)
 399                         adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
 400                 else
 401                         adapter->hw.fc.requested_mode = ixgbe_fc_none;
 402         }
 403
 404         if (adapter->dcb_set_bitmap & BIT_RESETLINK) {
 405                 if (netif_running(netdev))
 406                         ixgbe_up(adapter);
 407                 ret = DCB_HW_CHG_RST;
 408         } else if (adapter->dcb_set_bitmap & BIT_PFC) {
 409                 if (adapter->hw.mac.type == ixgbe_mac_82598EB)
 410                         ixgbe_dcb_config_pfc_82598(&adapter->hw,
 411                                                    &adapter->dcb_cfg);
 412                 else if (adapter->hw.mac.type == ixgbe_mac_82599EB)
 413                         ixgbe_dcb_config_pfc_82599(&adapter->hw,
 414                                                    &adapter->dcb_cfg);
 415                 ret = DCB_HW_CHG;
 416         }
 417         if (adapter->dcb_cfg.pfc_mode_enable)
 418                 adapter->hw.fc.current_mode = ixgbe_fc_pfc;
 419
 420         if (adapter->dcb_set_bitmap & BIT_RESETLINK)
 421                 clear_bit(__IXGBE_RESETTING, &adapter->state);
 422         adapter->dcb_set_bitmap = 0x00;
 423         return ret;
 424 }
 425
 426 static u8 ixgbe_dcbnl_getcap(struct net_device *netdev, int capid, u8 *cap)
 427 {
 428         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 429         u8 rval = 0;
 430
 431         if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 432                 switch (capid) {
 433                 case DCB_CAP_ATTR_PG:
 434                         *cap = true;
 435                         break;
 436                 case DCB_CAP_ATTR_PFC:
 437                         *cap = true;
 438                         break;
 439                 case DCB_CAP_ATTR_UP2TC:
 440                         *cap = false;
 441                         break;
 442                 case DCB_CAP_ATTR_PG_TCS:
 443                         *cap = 0x80;
 444                         break;
 445                 case DCB_CAP_ATTR_PFC_TCS:
 446                         *cap = 0x80;
 447                         break;
 448                 case DCB_CAP_ATTR_GSP:
 449                         *cap = true;
 450                         break;
 451                 case DCB_CAP_ATTR_BCN:
 452                         *cap = false;
 453                         break;
 454                 default:
 455                         rval = -EINVAL;
 456                         break;
 457                 }
 458         } else {
 459                 rval = -EINVAL;
 460         }
 461
 462         return rval;
 463 }
 464
 465 static u8 ixgbe_dcbnl_getnumtcs(struct net_device *netdev, int tcid, u8 *num)
 466 {
 467         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 468         u8 rval = 0;
 469
 470         if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 471                 switch (tcid) {
 472                 case DCB_NUMTCS_ATTR_PG:
 473                         *num = MAX_TRAFFIC_CLASS;
 474                         break;
 475                 case DCB_NUMTCS_ATTR_PFC:
 476                         *num = MAX_TRAFFIC_CLASS;
 477                         break;
 478                 default:
 479                         rval = -EINVAL;
 480                         break;
 481                 }
 482         } else {
 483                 rval = -EINVAL;
 484         }
 485
 486         return rval;
 487 }
 488
 489 static u8 ixgbe_dcbnl_setnumtcs(struct net_device *netdev, int tcid, u8 num)
 490 {
 491         return -EINVAL;
 492 }
 493
 494 static u8 ixgbe_dcbnl_getpfcstate(struct net_device *netdev)
 495 {
 496         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 497
 498         return adapter->dcb_cfg.pfc_mode_enable;
 499 }
 500
 501 static void ixgbe_dcbnl_setpfcstate(struct net_device *netdev, u8 state)
 502 {
 503         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 504
 505         adapter->temp_dcb_cfg.pfc_mode_enable = state;
 506         if (adapter->temp_dcb_cfg.pfc_mode_enable !=
 507                 adapter->dcb_cfg.pfc_mode_enable)
 508                 adapter->dcb_set_bitmap |= BIT_PFC;
 509         return;
 510 }
 511
 512 struct dcbnl_rtnl_ops dcbnl_ops = {
 513         .getstate       = ixgbe_dcbnl_get_state,
 514         .setstate       = ixgbe_dcbnl_set_state,
 515         .getpermhwaddr  = ixgbe_dcbnl_get_perm_hw_addr,
 516         .setpgtccfgtx   = ixgbe_dcbnl_set_pg_tc_cfg_tx,
 517         .setpgbwgcfgtx  = ixgbe_dcbnl_set_pg_bwg_cfg_tx,
 518         .setpgtccfgrx   = ixgbe_dcbnl_set_pg_tc_cfg_rx,
 519         .setpgbwgcfgrx  = ixgbe_dcbnl_set_pg_bwg_cfg_rx,
 520         .getpgtccfgtx   = ixgbe_dcbnl_get_pg_tc_cfg_tx,
 521         .getpgbwgcfgtx  = ixgbe_dcbnl_get_pg_bwg_cfg_tx,
 522         .getpgtccfgrx   = ixgbe_dcbnl_get_pg_tc_cfg_rx,
 523         .getpgbwgcfgrx  = ixgbe_dcbnl_get_pg_bwg_cfg_rx,
 524         .setpfccfg      = ixgbe_dcbnl_set_pfc_cfg,
 525         .getpfccfg      = ixgbe_dcbnl_get_pfc_cfg,
 526         .setall         = ixgbe_dcbnl_set_all,
 527         .getcap         = ixgbe_dcbnl_getcap,
 528         .getnumtcs      = ixgbe_dcbnl_getnumtcs,
 529         .setnumtcs      = ixgbe_dcbnl_setnumtcs,
 530         .getpfcstate    = ixgbe_dcbnl_getpfcstate,
 531         .setpfcstate    = ixgbe_dcbnl_setpfcstate,
 532 };
 533