drivers/net/ixgbe/ixgbe_dcb_nl.c

   1 /*******************************************************************************
   2
   3   Intel 10 Gigabit PCI Express Linux driver
   4   Copyright(c) 1999 - 2008 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
  32 /* Callbacks for DCB netlink in the kernel */
  33 #define BIT_DCB_MODE    0x01
  34 #define BIT_PFC         0x02
  35 #define BIT_PG_RX       0x04
  36 #define BIT_PG_TX       0x08
  37 #define BIT_BCN         0x10
  38
  39 int ixgbe_copy_dcb_cfg(struct ixgbe_dcb_config *src_dcb_cfg,
  40                        struct ixgbe_dcb_config *dst_dcb_cfg, int tc_max)
  41 {
  42         struct tc_configuration *src_tc_cfg = NULL;
  43         struct tc_configuration *dst_tc_cfg = NULL;
  44         int i;
  45
  46         if (!src_dcb_cfg || !dst_dcb_cfg)
  47                 return -EINVAL;
  48
  49         for (i = DCB_PG_ATTR_TC_0; i < tc_max + DCB_PG_ATTR_TC_0; i++) {
  50                 src_tc_cfg = &src_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];
  51                 dst_tc_cfg = &dst_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];
  52
  53                 dst_tc_cfg->path[DCB_TX_CONFIG].prio_type =
  54                                 src_tc_cfg->path[DCB_TX_CONFIG].prio_type;
  55
  56                 dst_tc_cfg->path[DCB_TX_CONFIG].bwg_id =
  57                                 src_tc_cfg->path[DCB_TX_CONFIG].bwg_id;
  58
  59                 dst_tc_cfg->path[DCB_TX_CONFIG].bwg_percent =
  60                                 src_tc_cfg->path[DCB_TX_CONFIG].bwg_percent;
  61
  62                 dst_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap =
  63                                 src_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap;
  64
  65                 dst_tc_cfg->path[DCB_RX_CONFIG].prio_type =
  66                                 src_tc_cfg->path[DCB_RX_CONFIG].prio_type;
  67
  68                 dst_tc_cfg->path[DCB_RX_CONFIG].bwg_id =
  69                                 src_tc_cfg->path[DCB_RX_CONFIG].bwg_id;
  70
  71                 dst_tc_cfg->path[DCB_RX_CONFIG].bwg_percent =
  72                                 src_tc_cfg->path[DCB_RX_CONFIG].bwg_percent;
  73
  74                 dst_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap =
  75                                 src_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap;
  76         }
  77
  78         for (i = DCB_PG_ATTR_BW_ID_0; i < DCB_PG_ATTR_BW_ID_MAX; i++) {
  79                 dst_dcb_cfg->bw_percentage[DCB_TX_CONFIG]
  80                         [i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
  81                                 [DCB_TX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
  82                 dst_dcb_cfg->bw_percentage[DCB_RX_CONFIG]
  83                         [i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
  84                                 [DCB_RX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
  85         }
  86
  87         for (i = DCB_PFC_UP_ATTR_0; i < DCB_PFC_UP_ATTR_MAX; i++) {
  88                 dst_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc =
  89                         src_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc;
  90         }
  91
  92         for (i = DCB_BCN_ATTR_RP_0; i < DCB_BCN_ATTR_RP_ALL; i++) {
  93                 dst_dcb_cfg->bcn.rp_admin_mode[i - DCB_BCN_ATTR_RP_0] =
  94                         src_dcb_cfg->bcn.rp_admin_mode[i - DCB_BCN_ATTR_RP_0];
  95         }
  96         dst_dcb_cfg->bcn.rp_alpha = src_dcb_cfg->bcn.rp_alpha;
  97         dst_dcb_cfg->bcn.rp_beta = src_dcb_cfg->bcn.rp_beta;
  98         dst_dcb_cfg->bcn.rp_gd = src_dcb_cfg->bcn.rp_gd;
  99         dst_dcb_cfg->bcn.rp_gi = src_dcb_cfg->bcn.rp_gi;
 100         dst_dcb_cfg->bcn.rp_tmax = src_dcb_cfg->bcn.rp_tmax;
 101         dst_dcb_cfg->bcn.rp_td = src_dcb_cfg->bcn.rp_td;
 102         dst_dcb_cfg->bcn.rp_rmin = src_dcb_cfg->bcn.rp_rmin;
 103         dst_dcb_cfg->bcn.rp_w = src_dcb_cfg->bcn.rp_w;
 104         dst_dcb_cfg->bcn.rp_rd = src_dcb_cfg->bcn.rp_rd;
 105         dst_dcb_cfg->bcn.rp_ru = src_dcb_cfg->bcn.rp_ru;
 106         dst_dcb_cfg->bcn.rp_wrtt = src_dcb_cfg->bcn.rp_wrtt;
 107         dst_dcb_cfg->bcn.rp_ri = src_dcb_cfg->bcn.rp_ri;
 108
 109         return 0;
 110 }
 111
 112 static u8 ixgbe_dcbnl_get_state(struct net_device *netdev)
 113 {
 114         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 115
 116         DPRINTK(DRV, INFO, "Get DCB Admin Mode.\n");
 117
 118         return !!(adapter->flags & IXGBE_FLAG_DCB_ENABLED);
 119 }
 120
 121 static u16 ixgbe_dcb_select_queue(struct net_device *dev, struct sk_buff *skb)
 122 {
 123         /* All traffic should default to class 0 */
 124         return 0;
 125 }
 126
 127 static void ixgbe_dcbnl_set_state(struct net_device *netdev, u8 state)
 128 {
 129         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 130
 131         DPRINTK(DRV, INFO, "Set DCB Admin Mode.\n");
 132
 133         if (state > 0) {
 134                 /* Turn on DCB */
 135                 if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 136                         return;
 137                 } else {
 138                         if (netif_running(netdev))
 139                                 netdev->stop(netdev);
 140                         ixgbe_reset_interrupt_capability(adapter);
 141                         ixgbe_napi_del_all(adapter);
 142                         kfree(adapter->tx_ring);
 143                         kfree(adapter->rx_ring);
 144                         adapter->tx_ring = NULL;
 145                         adapter->rx_ring = NULL;
 146                         netdev->select_queue = &ixgbe_dcb_select_queue;
 147
 148                         adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
 149                         adapter->flags |= IXGBE_FLAG_DCB_ENABLED;
 150                         ixgbe_init_interrupt_scheme(adapter);
 151                         ixgbe_napi_add_all(adapter);
 152                         if (netif_running(netdev))
 153                                 netdev->open(netdev);
 154                 }
 155         } else {
 156                 /* Turn off DCB */
 157                 if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 158                         if (netif_running(netdev))
 159                                 netdev->stop(netdev);
 160                         ixgbe_reset_interrupt_capability(adapter);
 161                         ixgbe_napi_del_all(adapter);
 162                         kfree(adapter->tx_ring);
 163                         kfree(adapter->rx_ring);
 164                         adapter->tx_ring = NULL;
 165                         adapter->rx_ring = NULL;
 166                         netdev->select_queue = NULL;
 167
 168                         adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
 169                         adapter->flags |= IXGBE_FLAG_RSS_ENABLED;
 170                         ixgbe_init_interrupt_scheme(adapter);
 171                         ixgbe_napi_add_all(adapter);
 172                         if (netif_running(netdev))
 173                                 netdev->open(netdev);
 174                 } else {
 175                         return;
 176                 }
 177         }
 178 }
 179
 180 static void ixgbe_dcbnl_get_perm_hw_addr(struct net_device *netdev,
 181                                          u8 *perm_addr)
 182 {
 183         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 184         int i;
 185
 186         for (i = 0; i < netdev->addr_len; i++)
 187                 perm_addr[i] = adapter->hw.mac.perm_addr[i];
 188 }
 189
 190 static void ixgbe_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc,
 191                                          u8 prio, u8 bwg_id, u8 bw_pct,
 192                                          u8 up_map)
 193 {
 194         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 195
 196         if (prio != DCB_ATTR_VALUE_UNDEFINED)
 197                 adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type = prio;
 198         if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
 199                 adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id = bwg_id;
 200         if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
 201                 adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent =
 202                         bw_pct;
 203         if (up_map != DCB_ATTR_VALUE_UNDEFINED)
 204                 adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap =
 205                         up_map;
 206
 207         if ((adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type !=
 208              adapter->dcb_cfg.tc_config[tc].path[0].prio_type) ||
 209             (adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id !=
 210              adapter->dcb_cfg.tc_config[tc].path[0].bwg_id) ||
 211             (adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent !=
 212              adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent) ||
 213             (adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap !=
 214              adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap))
 215                 adapter->dcb_set_bitmap |= BIT_PG_TX;
 216 }
 217
 218 static void ixgbe_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
 219                                           u8 bw_pct)
 220 {
 221         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 222
 223         adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] = bw_pct;
 224
 225         if (adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] !=
 226             adapter->dcb_cfg.bw_percentage[0][bwg_id])
 227                 adapter->dcb_set_bitmap |= BIT_PG_RX;
 228 }
 229
 230 static void ixgbe_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev, int tc,
 231                                          u8 prio, u8 bwg_id, u8 bw_pct,
 232                                          u8 up_map)
 233 {
 234         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 235
 236         if (prio != DCB_ATTR_VALUE_UNDEFINED)
 237                 adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type = prio;
 238         if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
 239                 adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id = bwg_id;
 240         if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
 241                 adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent =
 242                         bw_pct;
 243         if (up_map != DCB_ATTR_VALUE_UNDEFINED)
 244                 adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap =
 245                         up_map;
 246
 247         if ((adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type !=
 248              adapter->dcb_cfg.tc_config[tc].path[1].prio_type) ||
 249             (adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id !=
 250              adapter->dcb_cfg.tc_config[tc].path[1].bwg_id) ||
 251             (adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent !=
 252              adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent) ||
 253             (adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap !=
 254              adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap))
 255                 adapter->dcb_set_bitmap |= BIT_PG_RX;
 256 }
 257
 258 static void ixgbe_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
 259                                           u8 bw_pct)
 260 {
 261         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 262
 263         adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] = bw_pct;
 264
 265         if (adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] !=
 266             adapter->dcb_cfg.bw_percentage[1][bwg_id])
 267                 adapter->dcb_set_bitmap |= BIT_PG_RX;
 268 }
 269
 270 static void ixgbe_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int tc,
 271                                          u8 *prio, u8 *bwg_id, u8 *bw_pct,
 272                                          u8 *up_map)
 273 {
 274         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 275
 276         *prio = adapter->dcb_cfg.tc_config[tc].path[0].prio_type;
 277         *bwg_id = adapter->dcb_cfg.tc_config[tc].path[0].bwg_id;
 278         *bw_pct = adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent;
 279         *up_map = adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap;
 280 }
 281
 282 static void ixgbe_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
 283                                           u8 *bw_pct)
 284 {
 285         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 286
 287         *bw_pct = adapter->dcb_cfg.bw_percentage[0][bwg_id];
 288 }
 289
 290 static void ixgbe_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int tc,
 291                                          u8 *prio, u8 *bwg_id, u8 *bw_pct,
 292                                          u8 *up_map)
 293 {
 294         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 295
 296         *prio = adapter->dcb_cfg.tc_config[tc].path[1].prio_type;
 297         *bwg_id = adapter->dcb_cfg.tc_config[tc].path[1].bwg_id;
 298         *bw_pct = adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent;
 299         *up_map = adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap;
 300 }
 301
 302 static void ixgbe_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
 303                                           u8 *bw_pct)
 304 {
 305         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 306
 307         *bw_pct = adapter->dcb_cfg.bw_percentage[1][bwg_id];
 308 }
 309
 310 static void ixgbe_dcbnl_set_pfc_cfg(struct net_device *netdev, int priority,
 311                                     u8 setting)
 312 {
 313         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 314
 315         adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc = setting;
 316         if (adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc !=
 317             adapter->dcb_cfg.tc_config[priority].dcb_pfc)
 318                 adapter->dcb_set_bitmap |= BIT_PFC;
 319 }
 320
 321 static void ixgbe_dcbnl_get_pfc_cfg(struct net_device *netdev, int priority,
 322                                     u8 *setting)
 323 {
 324         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 325
 326         *setting = adapter->dcb_cfg.tc_config[priority].dcb_pfc;
 327 }
 328
 329 static u8 ixgbe_dcbnl_set_all(struct net_device *netdev)
 330 {
 331         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 332         int ret;
 333
 334         adapter->dcb_set_bitmap &= ~BIT_BCN;    /* no set for BCN */
 335         if (!adapter->dcb_set_bitmap)
 336                 return 1;
 337
 338         while (test_and_set_bit(__IXGBE_RESETTING, &adapter->state))
 339                 msleep(1);
 340
 341         if (netif_running(netdev))
 342                 ixgbe_down(adapter);
 343
 344         ret = ixgbe_copy_dcb_cfg(&adapter->temp_dcb_cfg, &adapter->dcb_cfg,
 345                                  adapter->ring_feature[RING_F_DCB].indices);
 346         if (ret) {
 347                 clear_bit(__IXGBE_RESETTING, &adapter->state);
 348                 return ret;
 349         }
 350
 351         if (netif_running(netdev))
 352                 ixgbe_up(adapter);
 353
 354         adapter->dcb_set_bitmap = 0x00;
 355         clear_bit(__IXGBE_RESETTING, &adapter->state);
 356         return ret;
 357 }
 358
 359 static u8 ixgbe_dcbnl_getcap(struct net_device *netdev, int capid, u8 *cap)
 360 {
 361         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 362         u8 rval = 0;
 363
 364         if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 365                 switch (capid) {
 366                 case DCB_CAP_ATTR_PG:
 367                         *cap = true;
 368                         break;
 369                 case DCB_CAP_ATTR_PFC:
 370                         *cap = true;
 371                         break;
 372                 case DCB_CAP_ATTR_UP2TC:
 373                         *cap = false;
 374                         break;
 375                 case DCB_CAP_ATTR_PG_TCS:
 376                         *cap = 0x80;
 377                         break;
 378                 case DCB_CAP_ATTR_PFC_TCS:
 379                         *cap = 0x80;
 380                         break;
 381                 case DCB_CAP_ATTR_GSP:
 382                         *cap = true;
 383                         break;
 384                 case DCB_CAP_ATTR_BCN:
 385                         *cap = false;
 386                         break;
 387                 default:
 388                         rval = -EINVAL;
 389                         break;
 390                 }
 391         } else {
 392                 rval = -EINVAL;
 393         }
 394
 395         return rval;
 396 }
 397
 398 static u8 ixgbe_dcbnl_getnumtcs(struct net_device *netdev, int tcid, u8 *num)
 399 {
 400         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 401         u8 rval = 0;
 402
 403         if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
 404                 switch (tcid) {
 405                 case DCB_NUMTCS_ATTR_PG:
 406                         *num = MAX_TRAFFIC_CLASS;
 407                         break;
 408                 case DCB_NUMTCS_ATTR_PFC:
 409                         *num = MAX_TRAFFIC_CLASS;
 410                         break;
 411                 default:
 412                         rval = -EINVAL;
 413                         break;
 414                 }
 415         } else {
 416                 rval = -EINVAL;
 417         }
 418
 419         return rval;
 420 }
 421
 422 static u8 ixgbe_dcbnl_setnumtcs(struct net_device *netdev, int tcid, u8 num)
 423 {
 424         return -EINVAL;
 425 }
 426
 427 static u8 ixgbe_dcbnl_getpfcstate(struct net_device *netdev)
 428 {
 429         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 430
 431         return !!(adapter->flags & IXGBE_FLAG_DCB_ENABLED);
 432 }
 433
 434 static void ixgbe_dcbnl_setpfcstate(struct net_device *netdev, u8 state)
 435 {
 436         return;
 437 }
 438
 439 static void ixgbe_dcbnl_getbcnrp(struct net_device *netdev, int priority,
 440                                   u8 *setting)
 441 {
 442         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 443
 444         *setting = adapter->dcb_cfg.bcn.rp_admin_mode[priority];
 445 }
 446
 447
 448 static void ixgbe_dcbnl_getbcncfg(struct net_device *netdev, int enum_index,
 449                                   u32 *setting)
 450 {
 451         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 452
 453         switch (enum_index) {
 454         case DCB_BCN_ATTR_ALPHA:
 455                 *setting = adapter->dcb_cfg.bcn.rp_alpha;
 456                 break;
 457         case DCB_BCN_ATTR_BETA:
 458                 *setting = adapter->dcb_cfg.bcn.rp_beta;
 459                 break;
 460         case DCB_BCN_ATTR_GD:
 461                 *setting = adapter->dcb_cfg.bcn.rp_gd;
 462                 break;
 463         case DCB_BCN_ATTR_GI:
 464                 *setting = adapter->dcb_cfg.bcn.rp_gi;
 465                 break;
 466         case DCB_BCN_ATTR_TMAX:
 467                 *setting = adapter->dcb_cfg.bcn.rp_tmax;
 468                 break;
 469         case DCB_BCN_ATTR_TD:
 470                 *setting = adapter->dcb_cfg.bcn.rp_td;
 471                 break;
 472         case DCB_BCN_ATTR_RMIN:
 473                 *setting = adapter->dcb_cfg.bcn.rp_rmin;
 474                 break;
 475         case DCB_BCN_ATTR_W:
 476                 *setting = adapter->dcb_cfg.bcn.rp_w;
 477                 break;
 478         case DCB_BCN_ATTR_RD:
 479                 *setting = adapter->dcb_cfg.bcn.rp_rd;
 480                 break;
 481         case DCB_BCN_ATTR_RU:
 482                 *setting = adapter->dcb_cfg.bcn.rp_ru;
 483                 break;
 484         case DCB_BCN_ATTR_WRTT:
 485                 *setting = adapter->dcb_cfg.bcn.rp_wrtt;
 486                 break;
 487         case DCB_BCN_ATTR_RI:
 488                 *setting = adapter->dcb_cfg.bcn.rp_ri;
 489                 break;
 490         default:
 491                 *setting = -1;
 492         }
 493 }
 494
 495 static void ixgbe_dcbnl_setbcnrp(struct net_device *netdev, int priority,
 496                                  u8 setting)
 497 {
 498         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 499
 500         adapter->temp_dcb_cfg.bcn.rp_admin_mode[priority] = setting;
 501
 502         if (adapter->temp_dcb_cfg.bcn.rp_admin_mode[priority] !=
 503             adapter->dcb_cfg.bcn.rp_admin_mode[priority])
 504                 adapter->dcb_set_bitmap |= BIT_BCN;
 505 }
 506
 507 static void ixgbe_dcbnl_setbcncfg(struct net_device *netdev, int enum_index,
 508                                  u32 setting)
 509 {
 510         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 511
 512         switch (enum_index) {
 513         case DCB_BCN_ATTR_ALPHA:
 514                 adapter->temp_dcb_cfg.bcn.rp_alpha = setting;
 515                 if (adapter->temp_dcb_cfg.bcn.rp_alpha !=
 516                     adapter->dcb_cfg.bcn.rp_alpha)
 517                         adapter->dcb_set_bitmap |= BIT_BCN;
 518                 break;
 519         case DCB_BCN_ATTR_BETA:
 520                 adapter->temp_dcb_cfg.bcn.rp_beta = setting;
 521                 if (adapter->temp_dcb_cfg.bcn.rp_beta !=
 522                     adapter->dcb_cfg.bcn.rp_beta)
 523                         adapter->dcb_set_bitmap |= BIT_BCN;
 524                 break;
 525         case DCB_BCN_ATTR_GD:
 526                 adapter->temp_dcb_cfg.bcn.rp_gd = setting;
 527                 if (adapter->temp_dcb_cfg.bcn.rp_gd !=
 528                     adapter->dcb_cfg.bcn.rp_gd)
 529                         adapter->dcb_set_bitmap |= BIT_BCN;
 530                 break;
 531         case DCB_BCN_ATTR_GI:
 532                 adapter->temp_dcb_cfg.bcn.rp_gi = setting;
 533                 if (adapter->temp_dcb_cfg.bcn.rp_gi !=
 534                     adapter->dcb_cfg.bcn.rp_gi)
 535                         adapter->dcb_set_bitmap |= BIT_BCN;
 536                 break;
 537         case DCB_BCN_ATTR_TMAX:
 538                 adapter->temp_dcb_cfg.bcn.rp_tmax = setting;
 539                 if (adapter->temp_dcb_cfg.bcn.rp_tmax !=
 540                     adapter->dcb_cfg.bcn.rp_tmax)
 541                         adapter->dcb_set_bitmap |= BIT_BCN;
 542                 break;
 543         case DCB_BCN_ATTR_TD:
 544                 adapter->temp_dcb_cfg.bcn.rp_td = setting;
 545                 if (adapter->temp_dcb_cfg.bcn.rp_td !=
 546                     adapter->dcb_cfg.bcn.rp_td)
 547                         adapter->dcb_set_bitmap |= BIT_BCN;
 548                 break;
 549         case DCB_BCN_ATTR_RMIN:
 550                 adapter->temp_dcb_cfg.bcn.rp_rmin = setting;
 551                 if (adapter->temp_dcb_cfg.bcn.rp_rmin !=
 552                     adapter->dcb_cfg.bcn.rp_rmin)
 553                         adapter->dcb_set_bitmap |= BIT_BCN;
 554                 break;
 555         case DCB_BCN_ATTR_W:
 556                 adapter->temp_dcb_cfg.bcn.rp_w = setting;
 557                 if (adapter->temp_dcb_cfg.bcn.rp_w !=
 558                     adapter->dcb_cfg.bcn.rp_w)
 559                         adapter->dcb_set_bitmap |= BIT_BCN;
 560                 break;
 561         case DCB_BCN_ATTR_RD:
 562                 adapter->temp_dcb_cfg.bcn.rp_rd = setting;
 563                 if (adapter->temp_dcb_cfg.bcn.rp_rd !=
 564                     adapter->dcb_cfg.bcn.rp_rd)
 565                         adapter->dcb_set_bitmap |= BIT_BCN;
 566                 break;
 567         case DCB_BCN_ATTR_RU:
 568                 adapter->temp_dcb_cfg.bcn.rp_ru = setting;
 569                 if (adapter->temp_dcb_cfg.bcn.rp_ru !=
 570                     adapter->dcb_cfg.bcn.rp_ru)
 571                         adapter->dcb_set_bitmap |= BIT_BCN;
 572                 break;
 573         case DCB_BCN_ATTR_WRTT:
 574                 adapter->temp_dcb_cfg.bcn.rp_wrtt = setting;
 575                 if (adapter->temp_dcb_cfg.bcn.rp_wrtt !=
 576                     adapter->dcb_cfg.bcn.rp_wrtt)
 577                         adapter->dcb_set_bitmap |= BIT_BCN;
 578                 break;
 579         case DCB_BCN_ATTR_RI:
 580                 adapter->temp_dcb_cfg.bcn.rp_ri = setting;
 581                 if (adapter->temp_dcb_cfg.bcn.rp_ri !=
 582                     adapter->dcb_cfg.bcn.rp_ri)
 583                         adapter->dcb_set_bitmap |= BIT_BCN;
 584                 break;
 585         default:
 586                 break;
 587         }
 588 }
 589
 590 struct dcbnl_rtnl_ops dcbnl_ops = {
 591         .getstate       = ixgbe_dcbnl_get_state,
 592         .setstate       = ixgbe_dcbnl_set_state,
 593         .getpermhwaddr  = ixgbe_dcbnl_get_perm_hw_addr,
 594         .setpgtccfgtx   = ixgbe_dcbnl_set_pg_tc_cfg_tx,
 595         .setpgbwgcfgtx  = ixgbe_dcbnl_set_pg_bwg_cfg_tx,
 596         .setpgtccfgrx   = ixgbe_dcbnl_set_pg_tc_cfg_rx,
 597         .setpgbwgcfgrx  = ixgbe_dcbnl_set_pg_bwg_cfg_rx,
 598         .getpgtccfgtx   = ixgbe_dcbnl_get_pg_tc_cfg_tx,
 599         .getpgbwgcfgtx  = ixgbe_dcbnl_get_pg_bwg_cfg_tx,
 600         .getpgtccfgrx   = ixgbe_dcbnl_get_pg_tc_cfg_rx,
 601         .getpgbwgcfgrx  = ixgbe_dcbnl_get_pg_bwg_cfg_rx,
 602         .setpfccfg      = ixgbe_dcbnl_set_pfc_cfg,
 603         .getpfccfg      = ixgbe_dcbnl_get_pfc_cfg,
 604         .setall         = ixgbe_dcbnl_set_all,
 605         .getcap         = ixgbe_dcbnl_getcap,
 606         .getnumtcs      = ixgbe_dcbnl_getnumtcs,
 607         .setnumtcs      = ixgbe_dcbnl_setnumtcs,
 608         .getpfcstate    = ixgbe_dcbnl_getpfcstate,
 609         .setpfcstate    = ixgbe_dcbnl_setpfcstate,
 610         .getbcncfg      = ixgbe_dcbnl_getbcncfg,
 611         .getbcnrp       = ixgbe_dcbnl_getbcnrp,
 612         .setbcncfg      = ixgbe_dcbnl_setbcncfg,
 613         .setbcnrp       = ixgbe_dcbnl_setbcnrp
 614 };
 615