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

   1 /*******************************************************************************
   2
   3   Intel 10 Gigabit PCI Express Linux driver
   4   Copyright(c) 1999 - 2013 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   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  24   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  25
  26 *******************************************************************************/
  27
  28 #include "ixgbe.h"
  29 #include "ixgbe_sriov.h"
  30
  31 #ifdef CONFIG_IXGBE_DCB
  32 /**
  33  * ixgbe_cache_ring_dcb_sriov - Descriptor ring to register mapping for SR-IOV
  34  * @adapter: board private structure to initialize
  35  *
  36  * Cache the descriptor ring offsets for SR-IOV to the assigned rings.  It
  37  * will also try to cache the proper offsets if RSS/FCoE are enabled along
  38  * with VMDq.
  39  *
  40  **/
  41 static bool ixgbe_cache_ring_dcb_sriov(struct ixgbe_adapter *adapter)
  42 {
  43 #ifdef IXGBE_FCOE
  44         struct ixgbe_ring_feature *fcoe = &adapter->ring_feature[RING_F_FCOE];
  45 #endif /* IXGBE_FCOE */
  46         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
  47         int i;
  48         u16 reg_idx;
  49         u8 tcs = netdev_get_num_tc(adapter->netdev);
  50
  51         /* verify we have DCB queueing enabled before proceeding */
  52         if (tcs <= 1)
  53                 return false;
  54
  55         /* verify we have VMDq enabled before proceeding */
  56         if (!(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED))
  57                 return false;
  58
  59         /* start at VMDq register offset for SR-IOV enabled setups */
  60         reg_idx = vmdq->offset * __ALIGN_MASK(1, ~vmdq->mask);
  61         for (i = 0; i < adapter->num_rx_queues; i++, reg_idx++) {
  62                 /* If we are greater than indices move to next pool */
  63                 if ((reg_idx & ~vmdq->mask) >= tcs)
  64                         reg_idx = __ALIGN_MASK(reg_idx, ~vmdq->mask);
  65                 adapter->rx_ring[i]->reg_idx = reg_idx;
  66         }
  67
  68         reg_idx = vmdq->offset * __ALIGN_MASK(1, ~vmdq->mask);
  69         for (i = 0; i < adapter->num_tx_queues; i++, reg_idx++) {
  70                 /* If we are greater than indices move to next pool */
  71                 if ((reg_idx & ~vmdq->mask) >= tcs)
  72                         reg_idx = __ALIGN_MASK(reg_idx, ~vmdq->mask);
  73                 adapter->tx_ring[i]->reg_idx = reg_idx;
  74         }
  75
  76 #ifdef IXGBE_FCOE
  77         /* nothing to do if FCoE is disabled */
  78         if (!(adapter->flags & IXGBE_FLAG_FCOE_ENABLED))
  79                 return true;
  80
  81         /* The work is already done if the FCoE ring is shared */
  82         if (fcoe->offset < tcs)
  83                 return true;
  84
  85         /* The FCoE rings exist separately, we need to move their reg_idx */
  86         if (fcoe->indices) {
  87                 u16 queues_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
  88                 u8 fcoe_tc = ixgbe_fcoe_get_tc(adapter);
  89
  90                 reg_idx = (vmdq->offset + vmdq->indices) * queues_per_pool;
  91                 for (i = fcoe->offset; i < adapter->num_rx_queues; i++) {
  92                         reg_idx = __ALIGN_MASK(reg_idx, ~vmdq->mask) + fcoe_tc;
  93                         adapter->rx_ring[i]->reg_idx = reg_idx;
  94                         reg_idx++;
  95                 }
  96
  97                 reg_idx = (vmdq->offset + vmdq->indices) * queues_per_pool;
  98                 for (i = fcoe->offset; i < adapter->num_tx_queues; i++) {
  99                         reg_idx = __ALIGN_MASK(reg_idx, ~vmdq->mask) + fcoe_tc;
 100                         adapter->tx_ring[i]->reg_idx = reg_idx;
 101                         reg_idx++;
 102                 }
 103         }
 104
 105 #endif /* IXGBE_FCOE */
 106         return true;
 107 }
 108
 109 /* ixgbe_get_first_reg_idx - Return first register index associated with ring */
 110 static void ixgbe_get_first_reg_idx(struct ixgbe_adapter *adapter, u8 tc,
 111                                     unsigned int *tx, unsigned int *rx)
 112 {
 113         struct net_device *dev = adapter->netdev;
 114         struct ixgbe_hw *hw = &adapter->hw;
 115         u8 num_tcs = netdev_get_num_tc(dev);
 116
 117         *tx = 0;
 118         *rx = 0;
 119
 120         switch (hw->mac.type) {
 121         case ixgbe_mac_82598EB:
 122                 /* TxQs/TC: 4   RxQs/TC: 8 */
 123                 *tx = tc << 2; /* 0, 4,  8, 12, 16, 20, 24, 28 */
 124                 *rx = tc << 3; /* 0, 8, 16, 24, 32, 40, 48, 56 */
 125                 break;
 126         case ixgbe_mac_82599EB:
 127         case ixgbe_mac_X540:
 128                 if (num_tcs > 4) {
 129                         /*
 130                          * TCs    : TC0/1 TC2/3 TC4-7
 131                          * TxQs/TC:    32    16     8
 132                          * RxQs/TC:    16    16    16
 133                          */
 134                         *rx = tc << 4;
 135                         if (tc < 3)
 136                                 *tx = tc << 5;          /*   0,  32,  64 */
 137                         else if (tc < 5)
 138                                 *tx = (tc + 2) << 4;    /*  80,  96 */
 139                         else
 140                                 *tx = (tc + 8) << 3;    /* 104, 112, 120 */
 141                 } else {
 142                         /*
 143                          * TCs    : TC0 TC1 TC2/3
 144                          * TxQs/TC:  64  32    16
 145                          * RxQs/TC:  32  32    32
 146                          */
 147                         *rx = tc << 5;
 148                         if (tc < 2)
 149                                 *tx = tc << 6;          /*  0,  64 */
 150                         else
 151                                 *tx = (tc + 4) << 4;    /* 96, 112 */
 152                 }
 153         default:
 154                 break;
 155         }
 156 }
 157
 158 /**
 159  * ixgbe_cache_ring_dcb - Descriptor ring to register mapping for DCB
 160  * @adapter: board private structure to initialize
 161  *
 162  * Cache the descriptor ring offsets for DCB to the assigned rings.
 163  *
 164  **/
 165 static bool ixgbe_cache_ring_dcb(struct ixgbe_adapter *adapter)
 166 {
 167         struct net_device *dev = adapter->netdev;
 168         unsigned int tx_idx, rx_idx;
 169         int tc, offset, rss_i, i;
 170         u8 num_tcs = netdev_get_num_tc(dev);
 171
 172         /* verify we have DCB queueing enabled before proceeding */
 173         if (num_tcs <= 1)
 174                 return false;
 175
 176         rss_i = adapter->ring_feature[RING_F_RSS].indices;
 177
 178         for (tc = 0, offset = 0; tc < num_tcs; tc++, offset += rss_i) {
 179                 ixgbe_get_first_reg_idx(adapter, tc, &tx_idx, &rx_idx);
 180                 for (i = 0; i < rss_i; i++, tx_idx++, rx_idx++) {
 181                         adapter->tx_ring[offset + i]->reg_idx = tx_idx;
 182                         adapter->rx_ring[offset + i]->reg_idx = rx_idx;
 183                         adapter->tx_ring[offset + i]->dcb_tc = tc;
 184                         adapter->rx_ring[offset + i]->dcb_tc = tc;
 185                 }
 186         }
 187
 188         return true;
 189 }
 190
 191 #endif
 192 /**
 193  * ixgbe_cache_ring_sriov - Descriptor ring to register mapping for sriov
 194  * @adapter: board private structure to initialize
 195  *
 196  * SR-IOV doesn't use any descriptor rings but changes the default if
 197  * no other mapping is used.
 198  *
 199  */
 200 static bool ixgbe_cache_ring_sriov(struct ixgbe_adapter *adapter)
 201 {
 202 #ifdef IXGBE_FCOE
 203         struct ixgbe_ring_feature *fcoe = &adapter->ring_feature[RING_F_FCOE];
 204 #endif /* IXGBE_FCOE */
 205         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
 206         struct ixgbe_ring_feature *rss = &adapter->ring_feature[RING_F_RSS];
 207         int i;
 208         u16 reg_idx;
 209
 210         /* only proceed if VMDq is enabled */
 211         if (!(adapter->flags & IXGBE_FLAG_VMDQ_ENABLED))
 212                 return false;
 213
 214         /* start at VMDq register offset for SR-IOV enabled setups */
 215         reg_idx = vmdq->offset * __ALIGN_MASK(1, ~vmdq->mask);
 216         for (i = 0; i < adapter->num_rx_queues; i++, reg_idx++) {
 217 #ifdef IXGBE_FCOE
 218                 /* Allow first FCoE queue to be mapped as RSS */
 219                 if (fcoe->offset && (i > fcoe->offset))
 220                         break;
 221 #endif
 222                 /* If we are greater than indices move to next pool */
 223                 if ((reg_idx & ~vmdq->mask) >= rss->indices)
 224                         reg_idx = __ALIGN_MASK(reg_idx, ~vmdq->mask);
 225                 adapter->rx_ring[i]->reg_idx = reg_idx;
 226         }
 227
 228 #ifdef IXGBE_FCOE
 229         /* FCoE uses a linear block of queues so just assigning 1:1 */
 230         for (; i < adapter->num_rx_queues; i++, reg_idx++)
 231                 adapter->rx_ring[i]->reg_idx = reg_idx;
 232
 233 #endif
 234         reg_idx = vmdq->offset * __ALIGN_MASK(1, ~vmdq->mask);
 235         for (i = 0; i < adapter->num_tx_queues; i++, reg_idx++) {
 236 #ifdef IXGBE_FCOE
 237                 /* Allow first FCoE queue to be mapped as RSS */
 238                 if (fcoe->offset && (i > fcoe->offset))
 239                         break;
 240 #endif
 241                 /* If we are greater than indices move to next pool */
 242                 if ((reg_idx & rss->mask) >= rss->indices)
 243                         reg_idx = __ALIGN_MASK(reg_idx, ~vmdq->mask);
 244                 adapter->tx_ring[i]->reg_idx = reg_idx;
 245         }
 246
 247 #ifdef IXGBE_FCOE
 248         /* FCoE uses a linear block of queues so just assigning 1:1 */
 249         for (; i < adapter->num_tx_queues; i++, reg_idx++)
 250                 adapter->tx_ring[i]->reg_idx = reg_idx;
 251
 252 #endif
 253
 254         return true;
 255 }
 256
 257 /**
 258  * ixgbe_cache_ring_rss - Descriptor ring to register mapping for RSS
 259  * @adapter: board private structure to initialize
 260  *
 261  * Cache the descriptor ring offsets for RSS to the assigned rings.
 262  *
 263  **/
 264 static bool ixgbe_cache_ring_rss(struct ixgbe_adapter *adapter)
 265 {
 266         int i;
 267
 268         for (i = 0; i < adapter->num_rx_queues; i++)
 269                 adapter->rx_ring[i]->reg_idx = i;
 270         for (i = 0; i < adapter->num_tx_queues; i++)
 271                 adapter->tx_ring[i]->reg_idx = i;
 272
 273         return true;
 274 }
 275
 276 /**
 277  * ixgbe_cache_ring_register - Descriptor ring to register mapping
 278  * @adapter: board private structure to initialize
 279  *
 280  * Once we know the feature-set enabled for the device, we'll cache
 281  * the register offset the descriptor ring is assigned to.
 282  *
 283  * Note, the order the various feature calls is important.  It must start with
 284  * the "most" features enabled at the same time, then trickle down to the
 285  * least amount of features turned on at once.
 286  **/
 287 static void ixgbe_cache_ring_register(struct ixgbe_adapter *adapter)
 288 {
 289         /* start with default case */
 290         adapter->rx_ring[0]->reg_idx = 0;
 291         adapter->tx_ring[0]->reg_idx = 0;
 292
 293 #ifdef CONFIG_IXGBE_DCB
 294         if (ixgbe_cache_ring_dcb_sriov(adapter))
 295                 return;
 296
 297         if (ixgbe_cache_ring_dcb(adapter))
 298                 return;
 299
 300 #endif
 301         if (ixgbe_cache_ring_sriov(adapter))
 302                 return;
 303
 304         ixgbe_cache_ring_rss(adapter);
 305 }
 306
 307 #define IXGBE_RSS_16Q_MASK      0xF
 308 #define IXGBE_RSS_8Q_MASK       0x7
 309 #define IXGBE_RSS_4Q_MASK       0x3
 310 #define IXGBE_RSS_2Q_MASK       0x1
 311 #define IXGBE_RSS_DISABLED_MASK 0x0
 312
 313 #ifdef CONFIG_IXGBE_DCB
 314 /**
 315  * ixgbe_set_dcb_sriov_queues: Allocate queues for SR-IOV devices w/ DCB
 316  * @adapter: board private structure to initialize
 317  *
 318  * When SR-IOV (Single Root IO Virtualiztion) is enabled, allocate queues
 319  * and VM pools where appropriate.  Also assign queues based on DCB
 320  * priorities and map accordingly..
 321  *
 322  **/
 323 static bool ixgbe_set_dcb_sriov_queues(struct ixgbe_adapter *adapter)
 324 {
 325         int i;
 326         u16 vmdq_i = adapter->ring_feature[RING_F_VMDQ].limit;
 327         u16 vmdq_m = 0;
 328 #ifdef IXGBE_FCOE
 329         u16 fcoe_i = 0;
 330 #endif
 331         u8 tcs = netdev_get_num_tc(adapter->netdev);
 332
 333         /* verify we have DCB queueing enabled before proceeding */
 334         if (tcs <= 1)
 335                 return false;
 336
 337         /* verify we have VMDq enabled before proceeding */
 338         if (!(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED))
 339                 return false;
 340
 341         /* Add starting offset to total pool count */
 342         vmdq_i += adapter->ring_feature[RING_F_VMDQ].offset;
 343
 344         /* 16 pools w/ 8 TC per pool */
 345         if (tcs > 4) {
 346                 vmdq_i = min_t(u16, vmdq_i, 16);
 347                 vmdq_m = IXGBE_82599_VMDQ_8Q_MASK;
 348         /* 32 pools w/ 4 TC per pool */
 349         } else {
 350                 vmdq_i = min_t(u16, vmdq_i, 32);
 351                 vmdq_m = IXGBE_82599_VMDQ_4Q_MASK;
 352         }
 353
 354 #ifdef IXGBE_FCOE
 355         /* queues in the remaining pools are available for FCoE */
 356         fcoe_i = (128 / __ALIGN_MASK(1, ~vmdq_m)) - vmdq_i;
 357
 358 #endif
 359         /* remove the starting offset from the pool count */
 360         vmdq_i -= adapter->ring_feature[RING_F_VMDQ].offset;
 361
 362         /* save features for later use */
 363         adapter->ring_feature[RING_F_VMDQ].indices = vmdq_i;
 364         adapter->ring_feature[RING_F_VMDQ].mask = vmdq_m;
 365
 366         /*
 367          * We do not support DCB, VMDq, and RSS all simultaneously
 368          * so we will disable RSS since it is the lowest priority
 369          */
 370         adapter->ring_feature[RING_F_RSS].indices = 1;
 371         adapter->ring_feature[RING_F_RSS].mask = IXGBE_RSS_DISABLED_MASK;
 372
 373         /* disable ATR as it is not supported when VMDq is enabled */
 374         adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
 375
 376         adapter->num_rx_pools = vmdq_i;
 377         adapter->num_rx_queues_per_pool = tcs;
 378
 379         adapter->num_tx_queues = vmdq_i * tcs;
 380         adapter->num_rx_queues = vmdq_i * tcs;
 381
 382 #ifdef IXGBE_FCOE
 383         if (adapter->flags & IXGBE_FLAG_FCOE_ENABLED) {
 384                 struct ixgbe_ring_feature *fcoe;
 385
 386                 fcoe = &adapter->ring_feature[RING_F_FCOE];
 387
 388                 /* limit ourselves based on feature limits */
 389                 fcoe_i = min_t(u16, fcoe_i, fcoe->limit);
 390
 391                 if (fcoe_i) {
 392                         /* alloc queues for FCoE separately */
 393                         fcoe->indices = fcoe_i;
 394                         fcoe->offset = vmdq_i * tcs;
 395
 396                         /* add queues to adapter */
 397                         adapter->num_tx_queues += fcoe_i;
 398                         adapter->num_rx_queues += fcoe_i;
 399                 } else if (tcs > 1) {
 400                         /* use queue belonging to FcoE TC */
 401                         fcoe->indices = 1;
 402                         fcoe->offset = ixgbe_fcoe_get_tc(adapter);
 403                 } else {
 404                         adapter->flags &= ~IXGBE_FLAG_FCOE_ENABLED;
 405
 406                         fcoe->indices = 0;
 407                         fcoe->offset = 0;
 408                 }
 409         }
 410
 411 #endif /* IXGBE_FCOE */
 412         /* configure TC to queue mapping */
 413         for (i = 0; i < tcs; i++)
 414                 netdev_set_tc_queue(adapter->netdev, i, 1, i);
 415
 416         return true;
 417 }
 418
 419 static bool ixgbe_set_dcb_queues(struct ixgbe_adapter *adapter)
 420 {
 421         struct net_device *dev = adapter->netdev;
 422         struct ixgbe_ring_feature *f;
 423         int rss_i, rss_m, i;
 424         int tcs;
 425
 426         /* Map queue offset and counts onto allocated tx queues */
 427         tcs = netdev_get_num_tc(dev);
 428
 429         /* verify we have DCB queueing enabled before proceeding */
 430         if (tcs <= 1)
 431                 return false;
 432
 433         /* determine the upper limit for our current DCB mode */
 434         rss_i = dev->num_tx_queues / tcs;
 435         if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
 436                 /* 8 TC w/ 4 queues per TC */
 437                 rss_i = min_t(u16, rss_i, 4);
 438                 rss_m = IXGBE_RSS_4Q_MASK;
 439         } else if (tcs > 4) {
 440                 /* 8 TC w/ 8 queues per TC */
 441                 rss_i = min_t(u16, rss_i, 8);
 442                 rss_m = IXGBE_RSS_8Q_MASK;
 443         } else {
 444                 /* 4 TC w/ 16 queues per TC */
 445                 rss_i = min_t(u16, rss_i, 16);
 446                 rss_m = IXGBE_RSS_16Q_MASK;
 447         }
 448
 449         /* set RSS mask and indices */
 450         f = &adapter->ring_feature[RING_F_RSS];
 451         rss_i = min_t(int, rss_i, f->limit);
 452         f->indices = rss_i;
 453         f->mask = rss_m;
 454
 455         /* disable ATR as it is not supported when multiple TCs are enabled */
 456         adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
 457
 458 #ifdef IXGBE_FCOE
 459         /* FCoE enabled queues require special configuration indexed
 460          * by feature specific indices and offset. Here we map FCoE
 461          * indices onto the DCB queue pairs allowing FCoE to own
 462          * configuration later.
 463          */
 464         if (adapter->flags & IXGBE_FLAG_FCOE_ENABLED) {
 465                 u8 tc = ixgbe_fcoe_get_tc(adapter);
 466
 467                 f = &adapter->ring_feature[RING_F_FCOE];
 468                 f->indices = min_t(u16, rss_i, f->limit);
 469                 f->offset = rss_i * tc;
 470         }
 471
 472 #endif /* IXGBE_FCOE */
 473         for (i = 0; i < tcs; i++)
 474                 netdev_set_tc_queue(dev, i, rss_i, rss_i * i);
 475
 476         adapter->num_tx_queues = rss_i * tcs;
 477         adapter->num_rx_queues = rss_i * tcs;
 478
 479         return true;
 480 }
 481
 482 #endif
 483 /**
 484  * ixgbe_set_sriov_queues - Allocate queues for SR-IOV devices
 485  * @adapter: board private structure to initialize
 486  *
 487  * When SR-IOV (Single Root IO Virtualiztion) is enabled, allocate queues
 488  * and VM pools where appropriate.  If RSS is available, then also try and
 489  * enable RSS and map accordingly.
 490  *
 491  **/
 492 static bool ixgbe_set_sriov_queues(struct ixgbe_adapter *adapter)
 493 {
 494         u16 vmdq_i = adapter->ring_feature[RING_F_VMDQ].limit;
 495         u16 vmdq_m = 0;
 496         u16 rss_i = adapter->ring_feature[RING_F_RSS].limit;
 497         u16 rss_m = IXGBE_RSS_DISABLED_MASK;
 498 #ifdef IXGBE_FCOE
 499         u16 fcoe_i = 0;
 500 #endif
 501         bool pools = (find_first_zero_bit(&adapter->fwd_bitmask, 32) > 1);
 502
 503         /* only proceed if SR-IOV is enabled */
 504         if (!(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED))
 505                 return false;
 506
 507         /* Add starting offset to total pool count */
 508         vmdq_i += adapter->ring_feature[RING_F_VMDQ].offset;
 509
 510         /* double check we are limited to maximum pools */
 511         vmdq_i = min_t(u16, IXGBE_MAX_VMDQ_INDICES, vmdq_i);
 512
 513         /* 64 pool mode with 2 queues per pool */
 514         if ((vmdq_i > 32) || (rss_i < 4) || (vmdq_i > 16 && pools)) {
 515                 vmdq_m = IXGBE_82599_VMDQ_2Q_MASK;
 516                 rss_m = IXGBE_RSS_2Q_MASK;
 517                 rss_i = min_t(u16, rss_i, 2);
 518         /* 32 pool mode with 4 queues per pool */
 519         } else {
 520                 vmdq_m = IXGBE_82599_VMDQ_4Q_MASK;
 521                 rss_m = IXGBE_RSS_4Q_MASK;
 522                 rss_i = 4;
 523         }
 524
 525 #ifdef IXGBE_FCOE
 526         /* queues in the remaining pools are available for FCoE */
 527         fcoe_i = 128 - (vmdq_i * __ALIGN_MASK(1, ~vmdq_m));
 528
 529 #endif
 530         /* remove the starting offset from the pool count */
 531         vmdq_i -= adapter->ring_feature[RING_F_VMDQ].offset;
 532
 533         /* save features for later use */
 534         adapter->ring_feature[RING_F_VMDQ].indices = vmdq_i;
 535         adapter->ring_feature[RING_F_VMDQ].mask = vmdq_m;
 536
 537         /* limit RSS based on user input and save for later use */
 538         adapter->ring_feature[RING_F_RSS].indices = rss_i;
 539         adapter->ring_feature[RING_F_RSS].mask = rss_m;
 540
 541         adapter->num_rx_pools = vmdq_i;
 542         adapter->num_rx_queues_per_pool = rss_i;
 543
 544         adapter->num_rx_queues = vmdq_i * rss_i;
 545         adapter->num_tx_queues = vmdq_i * rss_i;
 546
 547         /* disable ATR as it is not supported when VMDq is enabled */
 548         adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
 549
 550 #ifdef IXGBE_FCOE
 551         /*
 552          * FCoE can use rings from adjacent buffers to allow RSS
 553          * like behavior.  To account for this we need to add the
 554          * FCoE indices to the total ring count.
 555          */
 556         if (adapter->flags & IXGBE_FLAG_FCOE_ENABLED) {
 557                 struct ixgbe_ring_feature *fcoe;
 558
 559                 fcoe = &adapter->ring_feature[RING_F_FCOE];
 560
 561                 /* limit ourselves based on feature limits */
 562                 fcoe_i = min_t(u16, fcoe_i, fcoe->limit);
 563
 564                 if (vmdq_i > 1 && fcoe_i) {
 565                         /* alloc queues for FCoE separately */
 566                         fcoe->indices = fcoe_i;
 567                         fcoe->offset = vmdq_i * rss_i;
 568                 } else {
 569                         /* merge FCoE queues with RSS queues */
 570                         fcoe_i = min_t(u16, fcoe_i + rss_i, num_online_cpus());
 571
 572                         /* limit indices to rss_i if MSI-X is disabled */
 573                         if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
 574                                 fcoe_i = rss_i;
 575
 576                         /* attempt to reserve some queues for just FCoE */
 577                         fcoe->indices = min_t(u16, fcoe_i, fcoe->limit);
 578                         fcoe->offset = fcoe_i - fcoe->indices;
 579
 580                         fcoe_i -= rss_i;
 581                 }
 582
 583                 /* add queues to adapter */
 584                 adapter->num_tx_queues += fcoe_i;
 585                 adapter->num_rx_queues += fcoe_i;
 586         }
 587
 588 #endif
 589         return true;
 590 }
 591
 592 /**
 593  * ixgbe_set_rss_queues - Allocate queues for RSS
 594  * @adapter: board private structure to initialize
 595  *
 596  * This is our "base" multiqueue mode.  RSS (Receive Side Scaling) will try
 597  * to allocate one Rx queue per CPU, and if available, one Tx queue per CPU.
 598  *
 599  **/
 600 static bool ixgbe_set_rss_queues(struct ixgbe_adapter *adapter)
 601 {
 602         struct ixgbe_ring_feature *f;
 603         u16 rss_i;
 604
 605         /* set mask for 16 queue limit of RSS */
 606         f = &adapter->ring_feature[RING_F_RSS];
 607         rss_i = f->limit;
 608
 609         f->indices = rss_i;
 610         f->mask = IXGBE_RSS_16Q_MASK;
 611
 612         /* disable ATR by default, it will be configured below */
 613         adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
 614
 615         /*
 616          * Use Flow Director in addition to RSS to ensure the best
 617          * distribution of flows across cores, even when an FDIR flow
 618          * isn't matched.
 619          */
 620         if (rss_i > 1 && adapter->atr_sample_rate) {
 621                 f = &adapter->ring_feature[RING_F_FDIR];
 622
 623                 rss_i = f->indices = f->limit;
 624
 625                 if (!(adapter->flags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE))
 626                         adapter->flags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
 627         }
 628
 629 #ifdef IXGBE_FCOE
 630         /*
 631          * FCoE can exist on the same rings as standard network traffic
 632          * however it is preferred to avoid that if possible.  In order
 633          * to get the best performance we allocate as many FCoE queues
 634          * as we can and we place them at the end of the ring array to
 635          * avoid sharing queues with standard RSS on systems with 24 or
 636          * more CPUs.
 637          */
 638         if (adapter->flags & IXGBE_FLAG_FCOE_ENABLED) {
 639                 struct net_device *dev = adapter->netdev;
 640                 u16 fcoe_i;
 641
 642                 f = &adapter->ring_feature[RING_F_FCOE];
 643
 644                 /* merge FCoE queues with RSS queues */
 645                 fcoe_i = min_t(u16, f->limit + rss_i, num_online_cpus());
 646                 fcoe_i = min_t(u16, fcoe_i, dev->num_tx_queues);
 647
 648                 /* limit indices to rss_i if MSI-X is disabled */
 649                 if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
 650                         fcoe_i = rss_i;
 651
 652                 /* attempt to reserve some queues for just FCoE */
 653                 f->indices = min_t(u16, fcoe_i, f->limit);
 654                 f->offset = fcoe_i - f->indices;
 655                 rss_i = max_t(u16, fcoe_i, rss_i);
 656         }
 657
 658 #endif /* IXGBE_FCOE */
 659         adapter->num_rx_queues = rss_i;
 660         adapter->num_tx_queues = rss_i;
 661
 662         return true;
 663 }
 664
 665 /**
 666  * ixgbe_set_num_queues - Allocate queues for device, feature dependent
 667  * @adapter: board private structure to initialize
 668  *
 669  * This is the top level queue allocation routine.  The order here is very
 670  * important, starting with the "most" number of features turned on at once,
 671  * and ending with the smallest set of features.  This way large combinations
 672  * can be allocated if they're turned on, and smaller combinations are the
 673  * fallthrough conditions.
 674  *
 675  **/
 676 static void ixgbe_set_num_queues(struct ixgbe_adapter *adapter)
 677 {
 678         /* Start with base case */
 679         adapter->num_rx_queues = 1;
 680         adapter->num_tx_queues = 1;
 681         adapter->num_rx_pools = adapter->num_rx_queues;
 682         adapter->num_rx_queues_per_pool = 1;
 683
 684 #ifdef CONFIG_IXGBE_DCB
 685         if (ixgbe_set_dcb_sriov_queues(adapter))
 686                 return;
 687
 688         if (ixgbe_set_dcb_queues(adapter))
 689                 return;
 690
 691 #endif
 692         if (ixgbe_set_sriov_queues(adapter))
 693                 return;
 694
 695         ixgbe_set_rss_queues(adapter);
 696 }
 697
 698 static void ixgbe_acquire_msix_vectors(struct ixgbe_adapter *adapter,
 699                                        int vectors)
 700 {
 701         int err, vector_threshold;
 702
 703         /* We'll want at least 2 (vector_threshold):
 704          * 1) TxQ[0] + RxQ[0] handler
 705          * 2) Other (Link Status Change, etc.)
 706          */
 707         vector_threshold = MIN_MSIX_COUNT;
 708
 709         /*
 710          * The more we get, the more we will assign to Tx/Rx Cleanup
 711          * for the separate queues...where Rx Cleanup >= Tx Cleanup.
 712          * Right now, we simply care about how many we'll get; we'll
 713          * set them up later while requesting irq's.
 714          */
 715         while (vectors >= vector_threshold) {
 716                 err = pci_enable_msix(adapter->pdev, adapter->msix_entries,
 717                                       vectors);
 718                 if (!err) /* Success in acquiring all requested vectors. */
 719                         break;
 720                 else if (err < 0)
 721                         vectors = 0; /* Nasty failure, quit now */
 722                 else /* err == number of vectors we should try again with */
 723                         vectors = err;
 724         }
 725
 726         if (vectors < vector_threshold) {
 727                 /* Can't allocate enough MSI-X interrupts?  Oh well.
 728                  * This just means we'll go with either a single MSI
 729                  * vector or fall back to legacy interrupts.
 730                  */
 731                 netif_printk(adapter, hw, KERN_DEBUG, adapter->netdev,
 732                              "Unable to allocate MSI-X interrupts\n");
 733                 adapter->flags &= ~IXGBE_FLAG_MSIX_ENABLED;
 734                 kfree(adapter->msix_entries);
 735                 adapter->msix_entries = NULL;
 736         } else {
 737                 adapter->flags |= IXGBE_FLAG_MSIX_ENABLED; /* Woot! */
 738                 /*
 739                  * Adjust for only the vectors we'll use, which is minimum
 740                  * of max_msix_q_vectors + NON_Q_VECTORS, or the number of
 741                  * vectors we were allocated.
 742                  */
 743                 vectors -= NON_Q_VECTORS;
 744                 adapter->num_q_vectors = min(vectors, adapter->max_q_vectors);
 745         }
 746 }
 747
 748 static void ixgbe_add_ring(struct ixgbe_ring *ring,
 749                            struct ixgbe_ring_container *head)
 750 {
 751         ring->next = head->ring;
 752         head->ring = ring;
 753         head->count++;
 754 }
 755
 756 /**
 757  * ixgbe_alloc_q_vector - Allocate memory for a single interrupt vector
 758  * @adapter: board private structure to initialize
 759  * @v_count: q_vectors allocated on adapter, used for ring interleaving
 760  * @v_idx: index of vector in adapter struct
 761  * @txr_count: total number of Tx rings to allocate
 762  * @txr_idx: index of first Tx ring to allocate
 763  * @rxr_count: total number of Rx rings to allocate
 764  * @rxr_idx: index of first Rx ring to allocate
 765  *
 766  * We allocate one q_vector.  If allocation fails we return -ENOMEM.
 767  **/
 768 static int ixgbe_alloc_q_vector(struct ixgbe_adapter *adapter,
 769                                 int v_count, int v_idx,
 770                                 int txr_count, int txr_idx,
 771                                 int rxr_count, int rxr_idx)
 772 {
 773         struct ixgbe_q_vector *q_vector;
 774         struct ixgbe_ring *ring;
 775         int node = NUMA_NO_NODE;
 776         int cpu = -1;
 777         int ring_count, size;
 778         u8 tcs = netdev_get_num_tc(adapter->netdev);
 779
 780         ring_count = txr_count + rxr_count;
 781         size = sizeof(struct ixgbe_q_vector) +
 782                (sizeof(struct ixgbe_ring) * ring_count);
 783
 784         /* customize cpu for Flow Director mapping */
 785         if ((tcs <= 1) && !(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED)) {
 786                 u16 rss_i = adapter->ring_feature[RING_F_RSS].indices;
 787                 if (rss_i > 1 && adapter->atr_sample_rate) {
 788                         if (cpu_online(v_idx)) {
 789                                 cpu = v_idx;
 790                                 node = cpu_to_node(cpu);
 791                         }
 792                 }
 793         }
 794
 795         /* allocate q_vector and rings */
 796         q_vector = kzalloc_node(size, GFP_KERNEL, node);
 797         if (!q_vector)
 798                 q_vector = kzalloc(size, GFP_KERNEL);
 799         if (!q_vector)
 800                 return -ENOMEM;
 801
 802         /* setup affinity mask and node */
 803         if (cpu != -1)
 804                 cpumask_set_cpu(cpu, &q_vector->affinity_mask);
 805         q_vector->numa_node = node;
 806
 807 #ifdef CONFIG_IXGBE_DCA
 808         /* initialize CPU for DCA */
 809         q_vector->cpu = -1;
 810
 811 #endif
 812         /* initialize NAPI */
 813         netif_napi_add(adapter->netdev, &q_vector->napi,
 814                        ixgbe_poll, 64);
 815         napi_hash_add(&q_vector->napi);
 816
 817         /* tie q_vector and adapter together */
 818         adapter->q_vector[v_idx] = q_vector;
 819         q_vector->adapter = adapter;
 820         q_vector->v_idx = v_idx;
 821
 822         /* initialize work limits */
 823         q_vector->tx.work_limit = adapter->tx_work_limit;
 824
 825         /* initialize pointer to rings */
 826         ring = q_vector->ring;
 827
 828         /* intialize ITR */
 829         if (txr_count && !rxr_count) {
 830                 /* tx only vector */
 831                 if (adapter->tx_itr_setting == 1)
 832                         q_vector->itr = IXGBE_10K_ITR;
 833                 else
 834                         q_vector->itr = adapter->tx_itr_setting;
 835         } else {
 836                 /* rx or rx/tx vector */
 837                 if (adapter->rx_itr_setting == 1)
 838                         q_vector->itr = IXGBE_20K_ITR;
 839                 else
 840                         q_vector->itr = adapter->rx_itr_setting;
 841         }
 842
 843         while (txr_count) {
 844                 /* assign generic ring traits */
 845                 ring->dev = &adapter->pdev->dev;
 846                 ring->netdev = adapter->netdev;
 847
 848                 /* configure backlink on ring */
 849                 ring->q_vector = q_vector;
 850
 851                 /* update q_vector Tx values */
 852                 ixgbe_add_ring(ring, &q_vector->tx);
 853
 854                 /* apply Tx specific ring traits */
 855                 ring->count = adapter->tx_ring_count;
 856                 if (adapter->num_rx_pools > 1)
 857                         ring->queue_index =
 858                                 txr_idx % adapter->num_rx_queues_per_pool;
 859                 else
 860                         ring->queue_index = txr_idx;
 861
 862                 /* assign ring to adapter */
 863                 adapter->tx_ring[txr_idx] = ring;
 864
 865                 /* update count and index */
 866                 txr_count--;
 867                 txr_idx += v_count;
 868
 869                 /* push pointer to next ring */
 870                 ring++;
 871         }
 872
 873         while (rxr_count) {
 874                 /* assign generic ring traits */
 875                 ring->dev = &adapter->pdev->dev;
 876                 ring->netdev = adapter->netdev;
 877
 878                 /* configure backlink on ring */
 879                 ring->q_vector = q_vector;
 880
 881                 /* update q_vector Rx values */
 882                 ixgbe_add_ring(ring, &q_vector->rx);
 883
 884                 /*
 885                  * 82599 errata, UDP frames with a 0 checksum
 886                  * can be marked as checksum errors.
 887                  */
 888                 if (adapter->hw.mac.type == ixgbe_mac_82599EB)
 889                         set_bit(__IXGBE_RX_CSUM_UDP_ZERO_ERR, &ring->state);
 890
 891 #ifdef IXGBE_FCOE
 892                 if (adapter->netdev->features & NETIF_F_FCOE_MTU) {
 893                         struct ixgbe_ring_feature *f;
 894                         f = &adapter->ring_feature[RING_F_FCOE];
 895                         if ((rxr_idx >= f->offset) &&
 896                             (rxr_idx < f->offset + f->indices))
 897                                 set_bit(__IXGBE_RX_FCOE, &ring->state);
 898                 }
 899
 900 #endif /* IXGBE_FCOE */
 901                 /* apply Rx specific ring traits */
 902                 ring->count = adapter->rx_ring_count;
 903                 if (adapter->num_rx_pools > 1)
 904                         ring->queue_index =
 905                                 rxr_idx % adapter->num_rx_queues_per_pool;
 906                 else
 907                         ring->queue_index = rxr_idx;
 908
 909                 /* assign ring to adapter */
 910                 adapter->rx_ring[rxr_idx] = ring;
 911
 912                 /* update count and index */
 913                 rxr_count--;
 914                 rxr_idx += v_count;
 915
 916                 /* push pointer to next ring */
 917                 ring++;
 918         }
 919
 920         return 0;
 921 }
 922
 923 /**
 924  * ixgbe_free_q_vector - Free memory allocated for specific interrupt vector
 925  * @adapter: board private structure to initialize
 926  * @v_idx: Index of vector to be freed
 927  *
 928  * This function frees the memory allocated to the q_vector.  In addition if
 929  * NAPI is enabled it will delete any references to the NAPI struct prior
 930  * to freeing the q_vector.
 931  **/
 932 static void ixgbe_free_q_vector(struct ixgbe_adapter *adapter, int v_idx)
 933 {
 934         struct ixgbe_q_vector *q_vector = adapter->q_vector[v_idx];
 935         struct ixgbe_ring *ring;
 936
 937         ixgbe_for_each_ring(ring, q_vector->tx)
 938                 adapter->tx_ring[ring->queue_index] = NULL;
 939
 940         ixgbe_for_each_ring(ring, q_vector->rx)
 941                 adapter->rx_ring[ring->queue_index] = NULL;
 942
 943         adapter->q_vector[v_idx] = NULL;
 944         napi_hash_del(&q_vector->napi);
 945         netif_napi_del(&q_vector->napi);
 946
 947         /*
 948          * ixgbe_get_stats64() might access the rings on this vector,
 949          * we must wait a grace period before freeing it.
 950          */
 951         kfree_rcu(q_vector, rcu);
 952 }
 953
 954 /**
 955  * ixgbe_alloc_q_vectors - Allocate memory for interrupt vectors
 956  * @adapter: board private structure to initialize
 957  *
 958  * We allocate one q_vector per queue interrupt.  If allocation fails we
 959  * return -ENOMEM.
 960  **/
 961 static int ixgbe_alloc_q_vectors(struct ixgbe_adapter *adapter)
 962 {
 963         int q_vectors = adapter->num_q_vectors;
 964         int rxr_remaining = adapter->num_rx_queues;
 965         int txr_remaining = adapter->num_tx_queues;
 966         int rxr_idx = 0, txr_idx = 0, v_idx = 0;
 967         int err;
 968
 969         /* only one q_vector if MSI-X is disabled. */
 970         if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED))
 971                 q_vectors = 1;
 972
 973         if (q_vectors >= (rxr_remaining + txr_remaining)) {
 974                 for (; rxr_remaining; v_idx++) {
 975                         err = ixgbe_alloc_q_vector(adapter, q_vectors, v_idx,
 976                                                    0, 0, 1, rxr_idx);
 977
 978                         if (err)
 979                                 goto err_out;
 980
 981                         /* update counts and index */
 982                         rxr_remaining--;
 983                         rxr_idx++;
 984                 }
 985         }
 986
 987         for (; v_idx < q_vectors; v_idx++) {
 988                 int rqpv = DIV_ROUND_UP(rxr_remaining, q_vectors - v_idx);
 989                 int tqpv = DIV_ROUND_UP(txr_remaining, q_vectors - v_idx);
 990                 err = ixgbe_alloc_q_vector(adapter, q_vectors, v_idx,
 991                                            tqpv, txr_idx,
 992                                            rqpv, rxr_idx);
 993
 994                 if (err)
 995                         goto err_out;
 996
 997                 /* update counts and index */
 998                 rxr_remaining -= rqpv;
 999                 txr_remaining -= tqpv;
1000                 rxr_idx++;
1001                 txr_idx++;
1002         }
1003
1004         return 0;
1005
1006 err_out:
1007         adapter->num_tx_queues = 0;
1008         adapter->num_rx_queues = 0;
1009         adapter->num_q_vectors = 0;
1010
1011         while (v_idx--)
1012                 ixgbe_free_q_vector(adapter, v_idx);
1013
1014         return -ENOMEM;
1015 }
1016
1017 /**
1018  * ixgbe_free_q_vectors - Free memory allocated for interrupt vectors
1019  * @adapter: board private structure to initialize
1020  *
1021  * This function frees the memory allocated to the q_vectors.  In addition if
1022  * NAPI is enabled it will delete any references to the NAPI struct prior
1023  * to freeing the q_vector.
1024  **/
1025 static void ixgbe_free_q_vectors(struct ixgbe_adapter *adapter)
1026 {
1027         int v_idx = adapter->num_q_vectors;
1028
1029         adapter->num_tx_queues = 0;
1030         adapter->num_rx_queues = 0;
1031         adapter->num_q_vectors = 0;
1032
1033         while (v_idx--)
1034                 ixgbe_free_q_vector(adapter, v_idx);
1035 }
1036
1037 static void ixgbe_reset_interrupt_capability(struct ixgbe_adapter *adapter)
1038 {
1039         if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED) {
1040                 adapter->flags &= ~IXGBE_FLAG_MSIX_ENABLED;
1041                 pci_disable_msix(adapter->pdev);
1042                 kfree(adapter->msix_entries);
1043                 adapter->msix_entries = NULL;
1044         } else if (adapter->flags & IXGBE_FLAG_MSI_ENABLED) {
1045                 adapter->flags &= ~IXGBE_FLAG_MSI_ENABLED;
1046                 pci_disable_msi(adapter->pdev);
1047         }
1048 }
1049
1050 /**
1051  * ixgbe_set_interrupt_capability - set MSI-X or MSI if supported
1052  * @adapter: board private structure to initialize
1053  *
1054  * Attempt to configure the interrupts using the best available
1055  * capabilities of the hardware and the kernel.
1056  **/
1057 static void ixgbe_set_interrupt_capability(struct ixgbe_adapter *adapter)
1058 {
1059         struct ixgbe_hw *hw = &adapter->hw;
1060         int vector, v_budget, err;
1061
1062         /*
1063          * It's easy to be greedy for MSI-X vectors, but it really
1064          * doesn't do us much good if we have a lot more vectors
1065          * than CPU's.  So let's be conservative and only ask for
1066          * (roughly) the same number of vectors as there are CPU's.
1067          * The default is to use pairs of vectors.
1068          */
1069         v_budget = max(adapter->num_rx_queues, adapter->num_tx_queues);
1070         v_budget = min_t(int, v_budget, num_online_cpus());
1071         v_budget += NON_Q_VECTORS;
1072
1073         /*
1074          * At the same time, hardware can only support a maximum of
1075          * hw.mac->max_msix_vectors vectors.  With features
1076          * such as RSS and VMDq, we can easily surpass the number of Rx and Tx
1077          * descriptor queues supported by our device.  Thus, we cap it off in
1078          * those rare cases where the cpu count also exceeds our vector limit.
1079          */
1080         v_budget = min_t(int, v_budget, hw->mac.max_msix_vectors);
1081
1082         /* A failure in MSI-X entry allocation isn't fatal, but it does
1083          * mean we disable MSI-X capabilities of the adapter. */
1084         adapter->msix_entries = kcalloc(v_budget,
1085                                         sizeof(struct msix_entry), GFP_KERNEL);
1086         if (adapter->msix_entries) {
1087                 for (vector = 0; vector < v_budget; vector++)
1088                         adapter->msix_entries[vector].entry = vector;
1089
1090                 ixgbe_acquire_msix_vectors(adapter, v_budget);
1091
1092                 if (adapter->flags & IXGBE_FLAG_MSIX_ENABLED)
1093                         return;
1094         }
1095
1096         /* disable DCB if number of TCs exceeds 1 */
1097         if (netdev_get_num_tc(adapter->netdev) > 1) {
1098                 e_err(probe, "num TCs exceeds number of queues - disabling DCB\n");
1099                 netdev_reset_tc(adapter->netdev);
1100
1101                 if (adapter->hw.mac.type == ixgbe_mac_82598EB)
1102                         adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
1103
1104                 adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
1105                 adapter->temp_dcb_cfg.pfc_mode_enable = false;
1106                 adapter->dcb_cfg.pfc_mode_enable = false;
1107         }
1108         adapter->dcb_cfg.num_tcs.pg_tcs = 1;
1109         adapter->dcb_cfg.num_tcs.pfc_tcs = 1;
1110
1111         /* disable SR-IOV */
1112         ixgbe_disable_sriov(adapter);
1113
1114         /* disable RSS */
1115         adapter->ring_feature[RING_F_RSS].limit = 1;
1116
1117         ixgbe_set_num_queues(adapter);
1118         adapter->num_q_vectors = 1;
1119
1120         err = pci_enable_msi(adapter->pdev);
1121         if (err) {
1122                 netif_printk(adapter, hw, KERN_DEBUG, adapter->netdev,
1123                              "Unable to allocate MSI interrupt, "
1124                              "falling back to legacy.  Error: %d\n", err);
1125                 return;
1126         }
1127         adapter->flags |= IXGBE_FLAG_MSI_ENABLED;
1128 }
1129
1130 /**
1131  * ixgbe_init_interrupt_scheme - Determine proper interrupt scheme
1132  * @adapter: board private structure to initialize
1133  *
1134  * We determine which interrupt scheme to use based on...
1135  * - Kernel support (MSI, MSI-X)
1136  *   - which can be user-defined (via MODULE_PARAM)
1137  * - Hardware queue count (num_*_queues)
1138  *   - defined by miscellaneous hardware support/features (RSS, etc.)
1139  **/
1140 int ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter)
1141 {
1142         int err;
1143
1144         /* Number of supported queues */
1145         ixgbe_set_num_queues(adapter);
1146
1147         /* Set interrupt mode */
1148         ixgbe_set_interrupt_capability(adapter);
1149
1150         err = ixgbe_alloc_q_vectors(adapter);
1151         if (err) {
1152                 e_dev_err("Unable to allocate memory for queue vectors\n");
1153                 goto err_alloc_q_vectors;
1154         }
1155
1156         ixgbe_cache_ring_register(adapter);
1157
1158         e_dev_info("Multiqueue %s: Rx Queue count = %u, Tx Queue count = %u\n",
1159                    (adapter->num_rx_queues > 1) ? "Enabled" : "Disabled",
1160                    adapter->num_rx_queues, adapter->num_tx_queues);
1161
1162         set_bit(__IXGBE_DOWN, &adapter->state);
1163
1164         return 0;
1165
1166 err_alloc_q_vectors:
1167         ixgbe_reset_interrupt_capability(adapter);
1168         return err;
1169 }
1170
1171 /**
1172  * ixgbe_clear_interrupt_scheme - Clear the current interrupt scheme settings
1173  * @adapter: board private structure to clear interrupt scheme on
1174  *
1175  * We go through and clear interrupt specific resources and reset the structure
1176  * to pre-load conditions
1177  **/
1178 void ixgbe_clear_interrupt_scheme(struct ixgbe_adapter *adapter)
1179 {
1180         adapter->num_tx_queues = 0;
1181         adapter->num_rx_queues = 0;
1182
1183         ixgbe_free_q_vectors(adapter);
1184         ixgbe_reset_interrupt_capability(adapter);
1185 }
1186
1187 void ixgbe_tx_ctxtdesc(struct ixgbe_ring *tx_ring, u32 vlan_macip_lens,
1188                        u32 fcoe_sof_eof, u32 type_tucmd, u32 mss_l4len_idx)
1189 {
1190         struct ixgbe_adv_tx_context_desc *context_desc;
1191         u16 i = tx_ring->next_to_use;
1192
1193         context_desc = IXGBE_TX_CTXTDESC(tx_ring, i);
1194
1195         i++;
1196         tx_ring->next_to_use = (i < tx_ring->count) ? i : 0;
1197
1198         /* set bits to identify this as an advanced context descriptor */
1199         type_tucmd |= IXGBE_TXD_CMD_DEXT | IXGBE_ADVTXD_DTYP_CTXT;
1200
1201         context_desc->vlan_macip_lens   = cpu_to_le32(vlan_macip_lens);
1202         context_desc->seqnum_seed       = cpu_to_le32(fcoe_sof_eof);
1203         context_desc->type_tucmd_mlhl   = cpu_to_le32(type_tucmd);
1204         context_desc->mss_l4len_idx     = cpu_to_le32(mss_l4len_idx);
1205 }
1206