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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 1999 - 2018 Intel Corporation. */
   3
   4 #include <linux/types.h>
   5 #include <linux/module.h>
   6 #include <linux/pci.h>
   7 #include <linux/netdevice.h>
   8 #include <linux/vmalloc.h>
   9 #include <linux/string.h>
  10 #include <linux/in.h>
  11 #include <linux/ip.h>
  12 #include <linux/tcp.h>
  13 #include <linux/ipv6.h>
  14 #include <linux/if_bridge.h>
  15 #ifdef NETIF_F_HW_VLAN_CTAG_TX
  16 #include <linux/if_vlan.h>
  17 #endif
  18
  19 #include "ixgbe.h"
  20 #include "ixgbe_type.h"
  21 #include "ixgbe_mbx.h"
  22 #include "ixgbe_sriov.h"
  23
  24 #ifdef CONFIG_PCI_IOV
  25 static inline void ixgbe_alloc_vf_macvlans(struct ixgbe_adapter *adapter,
  26                                            unsigned int num_vfs)
  27 {
  28         struct ixgbe_hw *hw = &adapter->hw;
  29         struct vf_macvlans *mv_list;
  30         int num_vf_macvlans, i;
  31
  32         /* Initialize list of VF macvlans */
  33         INIT_LIST_HEAD(&adapter->vf_mvs.l);
  34
  35         num_vf_macvlans = hw->mac.num_rar_entries -
  36                           (IXGBE_MAX_PF_MACVLANS + 1 + num_vfs);
  37         if (!num_vf_macvlans)
  38                 return;
  39
  40         mv_list = kcalloc(num_vf_macvlans, sizeof(struct vf_macvlans),
  41                           GFP_KERNEL);
  42         if (mv_list) {
  43                 for (i = 0; i < num_vf_macvlans; i++) {
  44                         mv_list[i].vf = -1;
  45                         mv_list[i].free = true;
  46                         list_add(&mv_list[i].l, &adapter->vf_mvs.l);
  47                 }
  48                 adapter->mv_list = mv_list;
  49         }
  50 }
  51
  52 static int __ixgbe_enable_sriov(struct ixgbe_adapter *adapter,
  53                                 unsigned int num_vfs)
  54 {
  55         struct ixgbe_hw *hw = &adapter->hw;
  56         int i;
  57
  58         if (adapter->xdp_prog) {
  59                 e_warn(probe, "SRIOV is not supported with XDP\n");
  60                 return -EINVAL;
  61         }
  62
  63         /* Enable VMDq flag so device will be set in VM mode */
  64         adapter->flags |= IXGBE_FLAG_SRIOV_ENABLED |
  65                           IXGBE_FLAG_VMDQ_ENABLED;
  66
  67         /* Allocate memory for per VF control structures */
  68         adapter->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),
  69                                   GFP_KERNEL);
  70         if (!adapter->vfinfo)
  71                 return -ENOMEM;
  72
  73         adapter->num_vfs = num_vfs;
  74
  75         ixgbe_alloc_vf_macvlans(adapter, num_vfs);
  76         adapter->ring_feature[RING_F_VMDQ].offset = num_vfs;
  77
  78         /* Initialize default switching mode VEB */
  79         IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);
  80         adapter->bridge_mode = BRIDGE_MODE_VEB;
  81
  82         /* limit traffic classes based on VFs enabled */
  83         if ((adapter->hw.mac.type == ixgbe_mac_82599EB) && (num_vfs < 16)) {
  84                 adapter->dcb_cfg.num_tcs.pg_tcs = MAX_TRAFFIC_CLASS;
  85                 adapter->dcb_cfg.num_tcs.pfc_tcs = MAX_TRAFFIC_CLASS;
  86         } else if (num_vfs < 32) {
  87                 adapter->dcb_cfg.num_tcs.pg_tcs = 4;
  88                 adapter->dcb_cfg.num_tcs.pfc_tcs = 4;
  89         } else {
  90                 adapter->dcb_cfg.num_tcs.pg_tcs = 1;
  91                 adapter->dcb_cfg.num_tcs.pfc_tcs = 1;
  92         }
  93
  94         /* Disable RSC when in SR-IOV mode */
  95         adapter->flags2 &= ~(IXGBE_FLAG2_RSC_CAPABLE |
  96                              IXGBE_FLAG2_RSC_ENABLED);
  97
  98         for (i = 0; i < num_vfs; i++) {
  99                 /* enable spoof checking for all VFs */
 100                 adapter->vfinfo[i].spoofchk_enabled = true;
 101                 adapter->vfinfo[i].link_enable = true;
 102
 103                 /* We support VF RSS querying only for 82599 and x540
 104                  * devices at the moment. These devices share RSS
 105                  * indirection table and RSS hash key with PF therefore
 106                  * we want to disable the querying by default.
 107                  */
 108                 adapter->vfinfo[i].rss_query_enabled = false;
 109
 110                 /* Untrust all VFs */
 111                 adapter->vfinfo[i].trusted = false;
 112
 113                 /* set the default xcast mode */
 114                 adapter->vfinfo[i].xcast_mode = IXGBEVF_XCAST_MODE_NONE;
 115         }
 116
 117         e_info(probe, "SR-IOV enabled with %d VFs\n", num_vfs);
 118         return 0;
 119 }
 120
 121 /**
 122  * ixgbe_get_vfs - Find and take references to all vf devices
 123  * @adapter: Pointer to adapter struct
 124  */
 125 static void ixgbe_get_vfs(struct ixgbe_adapter *adapter)
 126 {
 127         struct pci_dev *pdev = adapter->pdev;
 128         u16 vendor = pdev->vendor;
 129         struct pci_dev *vfdev;
 130         int vf = 0;
 131         u16 vf_id;
 132         int pos;
 133
 134         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
 135         if (!pos)
 136                 return;
 137         pci_read_config_word(pdev, pos + PCI_SRIOV_VF_DID, &vf_id);
 138
 139         vfdev = pci_get_device(vendor, vf_id, NULL);
 140         for (; vfdev; vfdev = pci_get_device(vendor, vf_id, vfdev)) {
 141                 if (!vfdev->is_virtfn)
 142                         continue;
 143                 if (vfdev->physfn != pdev)
 144                         continue;
 145                 if (vf >= adapter->num_vfs)
 146                         continue;
 147                 pci_dev_get(vfdev);
 148                 adapter->vfinfo[vf].vfdev = vfdev;
 149                 ++vf;
 150         }
 151 }
 152
 153 /* Note this function is called when the user wants to enable SR-IOV
 154  * VFs using the now deprecated module parameter
 155  */
 156 void ixgbe_enable_sriov(struct ixgbe_adapter *adapter, unsigned int max_vfs)
 157 {
 158         int pre_existing_vfs = 0;
 159         unsigned int num_vfs;
 160
 161         pre_existing_vfs = pci_num_vf(adapter->pdev);
 162         if (!pre_existing_vfs && !max_vfs)
 163                 return;
 164
 165         /* If there are pre-existing VFs then we have to force
 166          * use of that many - over ride any module parameter value.
 167          * This may result from the user unloading the PF driver
 168          * while VFs were assigned to guest VMs or because the VFs
 169          * have been created via the new PCI SR-IOV sysfs interface.
 170          */
 171         if (pre_existing_vfs) {
 172                 num_vfs = pre_existing_vfs;
 173                 dev_warn(&adapter->pdev->dev,
 174                          "Virtual Functions already enabled for this device - Please reload all VF drivers to avoid spoofed packet errors\n");
 175         } else {
 176                 int err;
 177                 /*
 178                  * The 82599 supports up to 64 VFs per physical function
 179                  * but this implementation limits allocation to 63 so that
 180                  * basic networking resources are still available to the
 181                  * physical function.  If the user requests greater than
 182                  * 63 VFs then it is an error - reset to default of zero.
 183                  */
 184                 num_vfs = min_t(unsigned int, max_vfs, IXGBE_MAX_VFS_DRV_LIMIT);
 185
 186                 err = pci_enable_sriov(adapter->pdev, num_vfs);
 187                 if (err) {
 188                         e_err(probe, "Failed to enable PCI sriov: %d\n", err);
 189                         return;
 190                 }
 191         }
 192
 193         if (!__ixgbe_enable_sriov(adapter, num_vfs)) {
 194                 ixgbe_get_vfs(adapter);
 195                 return;
 196         }
 197
 198         /* If we have gotten to this point then there is no memory available
 199          * to manage the VF devices - print message and bail.
 200          */
 201         e_err(probe, "Unable to allocate memory for VF Data Storage - "
 202               "SRIOV disabled\n");
 203         ixgbe_disable_sriov(adapter);
 204 }
 205
 206 #endif /* #ifdef CONFIG_PCI_IOV */
 207 int ixgbe_disable_sriov(struct ixgbe_adapter *adapter)
 208 {
 209         unsigned int num_vfs = adapter->num_vfs, vf;
 210         unsigned long flags;
 211         int rss;
 212
 213         spin_lock_irqsave(&adapter->vfs_lock, flags);
 214         /* set num VFs to 0 to prevent access to vfinfo */
 215         adapter->num_vfs = 0;
 216         spin_unlock_irqrestore(&adapter->vfs_lock, flags);
 217
 218         /* put the reference to all of the vf devices */
 219         for (vf = 0; vf < num_vfs; ++vf) {
 220                 struct pci_dev *vfdev = adapter->vfinfo[vf].vfdev;
 221
 222                 if (!vfdev)
 223                         continue;
 224                 adapter->vfinfo[vf].vfdev = NULL;
 225                 pci_dev_put(vfdev);
 226         }
 227
 228         /* free VF control structures */
 229         kfree(adapter->vfinfo);
 230         adapter->vfinfo = NULL;
 231
 232         /* free macvlan list */
 233         kfree(adapter->mv_list);
 234         adapter->mv_list = NULL;
 235
 236         /* if SR-IOV is already disabled then there is nothing to do */
 237         if (!(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED))
 238                 return 0;
 239
 240 #ifdef CONFIG_PCI_IOV
 241         /*
 242          * If our VFs are assigned we cannot shut down SR-IOV
 243          * without causing issues, so just leave the hardware
 244          * available but disabled
 245          */
 246         if (pci_vfs_assigned(adapter->pdev)) {
 247                 e_dev_warn("Unloading driver while VFs are assigned - VFs will not be deallocated\n");
 248                 return -EPERM;
 249         }
 250         /* disable iov and allow time for transactions to clear */
 251         pci_disable_sriov(adapter->pdev);
 252 #endif
 253
 254         /* Disable VMDq flag so device will be set in VM mode */
 255         if (bitmap_weight(adapter->fwd_bitmask, adapter->num_rx_pools) == 1) {
 256                 adapter->flags &= ~IXGBE_FLAG_VMDQ_ENABLED;
 257                 adapter->flags &= ~IXGBE_FLAG_SRIOV_ENABLED;
 258                 rss = min_t(int, ixgbe_max_rss_indices(adapter),
 259                             num_online_cpus());
 260         } else {
 261                 rss = min_t(int, IXGBE_MAX_L2A_QUEUES, num_online_cpus());
 262         }
 263
 264         adapter->ring_feature[RING_F_VMDQ].offset = 0;
 265         adapter->ring_feature[RING_F_RSS].limit = rss;
 266
 267         /* take a breather then clean up driver data */
 268         msleep(100);
 269         return 0;
 270 }
 271
 272 static int ixgbe_pci_sriov_enable(struct pci_dev *dev, int num_vfs)
 273 {
 274 #ifdef CONFIG_PCI_IOV
 275         struct ixgbe_adapter *adapter = pci_get_drvdata(dev);
 276         int pre_existing_vfs = pci_num_vf(dev);
 277         int err = 0, num_rx_pools, i, limit;
 278         u8 num_tc;
 279
 280         if (pre_existing_vfs && pre_existing_vfs != num_vfs)
 281                 err = ixgbe_disable_sriov(adapter);
 282         else if (pre_existing_vfs && pre_existing_vfs == num_vfs)
 283                 return num_vfs;
 284
 285         if (err)
 286                 return err;
 287
 288         /* While the SR-IOV capability structure reports total VFs to be 64,
 289          * we limit the actual number allocated as below based on two factors.
 290          *    Num_TCs   MAX_VFs
 291          *      1         63
 292          *      <=4       31
 293          *      >4        15
 294          * First, we reserve some transmit/receive resources for the PF.
 295          * Second, VMDQ also uses the same pools that SR-IOV does. We need to
 296          * account for this, so that we don't accidentally allocate more VFs
 297          * than we have available pools. The PCI bus driver already checks for
 298          * other values out of range.
 299          */
 300         num_tc = adapter->hw_tcs;
 301         num_rx_pools = bitmap_weight(adapter->fwd_bitmask,
 302                                      adapter->num_rx_pools);
 303         limit = (num_tc > 4) ? IXGBE_MAX_VFS_8TC :
 304                 (num_tc > 1) ? IXGBE_MAX_VFS_4TC : IXGBE_MAX_VFS_1TC;
 305
 306         if (num_vfs > (limit - num_rx_pools)) {
 307                 e_dev_err("Currently configured with %d TCs, and %d offloaded macvlans. Creating more than %d VFs is not allowed\n",
 308                           num_tc, num_rx_pools - 1, limit - num_rx_pools);
 309                 return -EPERM;
 310         }
 311
 312         err = __ixgbe_enable_sriov(adapter, num_vfs);
 313         if (err)
 314                 return  err;
 315
 316         for (i = 0; i < num_vfs; i++)
 317                 ixgbe_vf_configuration(dev, (i | 0x10000000));
 318
 319         /* reset before enabling SRIOV to avoid mailbox issues */
 320         ixgbe_sriov_reinit(adapter);
 321
 322         err = pci_enable_sriov(dev, num_vfs);
 323         if (err) {
 324                 e_dev_warn("Failed to enable PCI sriov: %d\n", err);
 325                 return err;
 326         }
 327         ixgbe_get_vfs(adapter);
 328
 329         return num_vfs;
 330 #else
 331         return 0;
 332 #endif
 333 }
 334
 335 static int ixgbe_pci_sriov_disable(struct pci_dev *dev)
 336 {
 337         struct ixgbe_adapter *adapter = pci_get_drvdata(dev);
 338         int err;
 339 #ifdef CONFIG_PCI_IOV
 340         u32 current_flags = adapter->flags;
 341         int prev_num_vf = pci_num_vf(dev);
 342 #endif
 343
 344         err = ixgbe_disable_sriov(adapter);
 345
 346         /* Only reinit if no error and state changed */
 347 #ifdef CONFIG_PCI_IOV
 348         if (!err && (current_flags != adapter->flags ||
 349                      prev_num_vf != pci_num_vf(dev)))
 350                 ixgbe_sriov_reinit(adapter);
 351 #endif
 352
 353         return err;
 354 }
 355
 356 int ixgbe_pci_sriov_configure(struct pci_dev *dev, int num_vfs)
 357 {
 358         if (num_vfs == 0)
 359                 return ixgbe_pci_sriov_disable(dev);
 360         else
 361                 return ixgbe_pci_sriov_enable(dev, num_vfs);
 362 }
 363
 364 static int ixgbe_set_vf_multicasts(struct ixgbe_adapter *adapter,
 365                                    u32 *msgbuf, u32 vf)
 366 {
 367         int entries = FIELD_GET(IXGBE_VT_MSGINFO_MASK, msgbuf[0]);
 368         u16 *hash_list = (u16 *)&msgbuf[1];
 369         struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
 370         struct ixgbe_hw *hw = &adapter->hw;
 371         int i;
 372         u32 vector_bit;
 373         u32 vector_reg;
 374         u32 mta_reg;
 375         u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
 376
 377         /* only so many hash values supported */
 378         entries = min(entries, IXGBE_MAX_VF_MC_ENTRIES);
 379
 380         /*
 381          * salt away the number of multi cast addresses assigned
 382          * to this VF for later use to restore when the PF multi cast
 383          * list changes
 384          */
 385         vfinfo->num_vf_mc_hashes = entries;
 386
 387         /*
 388          * VFs are limited to using the MTA hash table for their multicast
 389          * addresses
 390          */
 391         for (i = 0; i < entries; i++) {
 392                 vfinfo->vf_mc_hashes[i] = hash_list[i];
 393         }
 394
 395         for (i = 0; i < vfinfo->num_vf_mc_hashes; i++) {
 396                 vector_reg = (vfinfo->vf_mc_hashes[i] >> 5) & 0x7F;
 397                 vector_bit = vfinfo->vf_mc_hashes[i] & 0x1F;
 398                 mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
 399                 mta_reg |= BIT(vector_bit);
 400                 IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
 401         }
 402         vmolr |= IXGBE_VMOLR_ROMPE;
 403         IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
 404
 405         return 0;
 406 }
 407
 408 #ifdef CONFIG_PCI_IOV
 409 void ixgbe_restore_vf_multicasts(struct ixgbe_adapter *adapter)
 410 {
 411         struct ixgbe_hw *hw = &adapter->hw;
 412         struct vf_data_storage *vfinfo;
 413         int i, j;
 414         u32 vector_bit;
 415         u32 vector_reg;
 416         u32 mta_reg;
 417
 418         for (i = 0; i < adapter->num_vfs; i++) {
 419                 u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(i));
 420                 vfinfo = &adapter->vfinfo[i];
 421                 for (j = 0; j < vfinfo->num_vf_mc_hashes; j++) {
 422                         hw->addr_ctrl.mta_in_use++;
 423                         vector_reg = (vfinfo->vf_mc_hashes[j] >> 5) & 0x7F;
 424                         vector_bit = vfinfo->vf_mc_hashes[j] & 0x1F;
 425                         mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
 426                         mta_reg |= BIT(vector_bit);
 427                         IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
 428                 }
 429
 430                 if (vfinfo->num_vf_mc_hashes)
 431                         vmolr |= IXGBE_VMOLR_ROMPE;
 432                 else
 433                         vmolr &= ~IXGBE_VMOLR_ROMPE;
 434                 IXGBE_WRITE_REG(hw, IXGBE_VMOLR(i), vmolr);
 435         }
 436
 437         /* Restore any VF macvlans */
 438         ixgbe_full_sync_mac_table(adapter);
 439 }
 440 #endif
 441
 442 static int ixgbe_set_vf_vlan(struct ixgbe_adapter *adapter, int add, int vid,
 443                              u32 vf)
 444 {
 445         struct ixgbe_hw *hw = &adapter->hw;
 446         int err;
 447
 448         /* If VLAN overlaps with one the PF is currently monitoring make
 449          * sure that we are able to allocate a VLVF entry.  This may be
 450          * redundant but it guarantees PF will maintain visibility to
 451          * the VLAN.
 452          */
 453         if (add && test_bit(vid, adapter->active_vlans)) {
 454                 err = hw->mac.ops.set_vfta(hw, vid, VMDQ_P(0), true, false);
 455                 if (err)
 456                         return err;
 457         }
 458
 459         err = hw->mac.ops.set_vfta(hw, vid, vf, !!add, false);
 460
 461         if (add && !err)
 462                 return err;
 463
 464         /* If we failed to add the VF VLAN or we are removing the VF VLAN
 465          * we may need to drop the PF pool bit in order to allow us to free
 466          * up the VLVF resources.
 467          */
 468         if (test_bit(vid, adapter->active_vlans) ||
 469             (adapter->flags2 & IXGBE_FLAG2_VLAN_PROMISC))
 470                 ixgbe_update_pf_promisc_vlvf(adapter, vid);
 471
 472         return err;
 473 }
 474
 475 static int ixgbe_set_vf_lpe(struct ixgbe_adapter *adapter, u32 max_frame, u32 vf)
 476 {
 477         struct ixgbe_hw *hw = &adapter->hw;
 478         u32 max_frs;
 479
 480         if (max_frame < ETH_MIN_MTU || max_frame > IXGBE_MAX_JUMBO_FRAME_SIZE) {
 481                 e_err(drv, "VF max_frame %d out of range\n", max_frame);
 482                 return -EINVAL;
 483         }
 484
 485         /*
 486          * For 82599EB we have to keep all PFs and VFs operating with
 487          * the same max_frame value in order to avoid sending an oversize
 488          * frame to a VF.  In order to guarantee this is handled correctly
 489          * for all cases we have several special exceptions to take into
 490          * account before we can enable the VF for receive
 491          */
 492         if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
 493                 struct net_device *dev = adapter->netdev;
 494                 int pf_max_frame = dev->mtu + ETH_HLEN;
 495                 u32 reg_offset, vf_shift, vfre;
 496                 int err = 0;
 497
 498 #ifdef CONFIG_FCOE
 499                 if (dev->fcoe_mtu)
 500                         pf_max_frame = max_t(int, pf_max_frame,
 501                                              IXGBE_FCOE_JUMBO_FRAME_SIZE);
 502
 503 #endif /* CONFIG_FCOE */
 504                 switch (adapter->vfinfo[vf].vf_api) {
 505                 case ixgbe_mbox_api_11:
 506                 case ixgbe_mbox_api_12:
 507                 case ixgbe_mbox_api_13:
 508                 case ixgbe_mbox_api_14:
 509                         /* Version 1.1 supports jumbo frames on VFs if PF has
 510                          * jumbo frames enabled which means legacy VFs are
 511                          * disabled
 512                          */
 513                         if (pf_max_frame > ETH_FRAME_LEN)
 514                                 break;
 515                         fallthrough;
 516                 default:
 517                         /* If the PF or VF are running w/ jumbo frames enabled
 518                          * we need to shut down the VF Rx path as we cannot
 519                          * support jumbo frames on legacy VFs
 520                          */
 521                         if ((pf_max_frame > ETH_FRAME_LEN) ||
 522                             (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)))
 523                                 err = -EINVAL;
 524                         break;
 525                 }
 526
 527                 /* determine VF receive enable location */
 528                 vf_shift = vf % 32;
 529                 reg_offset = vf / 32;
 530
 531                 /* enable or disable receive depending on error */
 532                 vfre = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
 533                 if (err)
 534                         vfre &= ~BIT(vf_shift);
 535                 else
 536                         vfre |= BIT(vf_shift);
 537                 IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), vfre);
 538
 539                 if (err) {
 540                         e_err(drv, "VF max_frame %d out of range\n", max_frame);
 541                         return err;
 542                 }
 543         }
 544
 545         /* pull current max frame size from hardware */
 546         max_frs = IXGBE_READ_REG(hw, IXGBE_MAXFRS);
 547         max_frs &= IXGBE_MHADD_MFS_MASK;
 548         max_frs >>= IXGBE_MHADD_MFS_SHIFT;
 549
 550         if (max_frs < max_frame) {
 551                 max_frs = max_frame << IXGBE_MHADD_MFS_SHIFT;
 552                 IXGBE_WRITE_REG(hw, IXGBE_MAXFRS, max_frs);
 553         }
 554
 555         e_info(hw, "VF requests change max MTU to %d\n", max_frame);
 556
 557         return 0;
 558 }
 559
 560 static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe)
 561 {
 562         u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
 563         vmolr |= IXGBE_VMOLR_BAM;
 564         if (aupe)
 565                 vmolr |= IXGBE_VMOLR_AUPE;
 566         else
 567                 vmolr &= ~IXGBE_VMOLR_AUPE;
 568         IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
 569 }
 570
 571 static void ixgbe_clear_vmvir(struct ixgbe_adapter *adapter, u32 vf)
 572 {
 573         struct ixgbe_hw *hw = &adapter->hw;
 574
 575         IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), 0);
 576 }
 577
 578 static void ixgbe_clear_vf_vlans(struct ixgbe_adapter *adapter, u32 vf)
 579 {
 580         struct ixgbe_hw *hw = &adapter->hw;
 581         u32 vlvfb_mask, pool_mask, i;
 582
 583         /* create mask for VF and other pools */
 584         pool_mask = ~BIT(VMDQ_P(0) % 32);
 585         vlvfb_mask = BIT(vf % 32);
 586
 587         /* post increment loop, covers VLVF_ENTRIES - 1 to 0 */
 588         for (i = IXGBE_VLVF_ENTRIES; i--;) {
 589                 u32 bits[2], vlvfb, vid, vfta, vlvf;
 590                 u32 word = i * 2 + vf / 32;
 591                 u32 mask;
 592
 593                 vlvfb = IXGBE_READ_REG(hw, IXGBE_VLVFB(word));
 594
 595                 /* if our bit isn't set we can skip it */
 596                 if (!(vlvfb & vlvfb_mask))
 597                         continue;
 598
 599                 /* clear our bit from vlvfb */
 600                 vlvfb ^= vlvfb_mask;
 601
 602                 /* create 64b mask to chedk to see if we should clear VLVF */
 603                 bits[word % 2] = vlvfb;
 604                 bits[~word % 2] = IXGBE_READ_REG(hw, IXGBE_VLVFB(word ^ 1));
 605
 606                 /* if other pools are present, just remove ourselves */
 607                 if (bits[(VMDQ_P(0) / 32) ^ 1] ||
 608                     (bits[VMDQ_P(0) / 32] & pool_mask))
 609                         goto update_vlvfb;
 610
 611                 /* if PF is present, leave VFTA */
 612                 if (bits[0] || bits[1])
 613                         goto update_vlvf;
 614
 615                 /* if we cannot determine VLAN just remove ourselves */
 616                 vlvf = IXGBE_READ_REG(hw, IXGBE_VLVF(i));
 617                 if (!vlvf)
 618                         goto update_vlvfb;
 619
 620                 vid = vlvf & VLAN_VID_MASK;
 621                 mask = BIT(vid % 32);
 622
 623                 /* clear bit from VFTA */
 624                 vfta = IXGBE_READ_REG(hw, IXGBE_VFTA(vid / 32));
 625                 if (vfta & mask)
 626                         IXGBE_WRITE_REG(hw, IXGBE_VFTA(vid / 32), vfta ^ mask);
 627 update_vlvf:
 628                 /* clear POOL selection enable */
 629                 IXGBE_WRITE_REG(hw, IXGBE_VLVF(i), 0);
 630
 631                 if (!(adapter->flags2 & IXGBE_FLAG2_VLAN_PROMISC))
 632                         vlvfb = 0;
 633 update_vlvfb:
 634                 /* clear pool bits */
 635                 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(word), vlvfb);
 636         }
 637 }
 638
 639 static int ixgbe_set_vf_macvlan(struct ixgbe_adapter *adapter,
 640                                 int vf, int index, unsigned char *mac_addr)
 641 {
 642         struct vf_macvlans *entry;
 643         bool found = false;
 644         int retval = 0;
 645
 646         if (index <= 1) {
 647                 list_for_each_entry(entry, &adapter->vf_mvs.l, l) {
 648                         if (entry->vf == vf) {
 649                                 entry->vf = -1;
 650                                 entry->free = true;
 651                                 entry->is_macvlan = false;
 652                                 ixgbe_del_mac_filter(adapter,
 653                                                      entry->vf_macvlan, vf);
 654                         }
 655                 }
 656         }
 657
 658         /*
 659          * If index was zero then we were asked to clear the uc list
 660          * for the VF.  We're done.
 661          */
 662         if (!index)
 663                 return 0;
 664
 665         list_for_each_entry(entry, &adapter->vf_mvs.l, l) {
 666                 if (entry->free) {
 667                         found = true;
 668                         break;
 669                 }
 670         }
 671
 672         /*
 673          * If we traversed the entire list and didn't find a free entry
 674          * then we're out of space on the RAR table.  It's also possible
 675          * for the &adapter->vf_mvs.l list to be empty because the original
 676          * memory allocation for the list failed, which is not fatal but does
 677          * mean we can't support VF requests for MACVLAN because we couldn't
 678          * allocate memory for the list management required.
 679          */
 680         if (!found)
 681                 return -ENOSPC;
 682
 683         retval = ixgbe_add_mac_filter(adapter, mac_addr, vf);
 684         if (retval < 0)
 685                 return retval;
 686
 687         entry->free = false;
 688         entry->is_macvlan = true;
 689         entry->vf = vf;
 690         memcpy(entry->vf_macvlan, mac_addr, ETH_ALEN);
 691
 692         return 0;
 693 }
 694
 695 static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)
 696 {
 697         struct ixgbe_hw *hw = &adapter->hw;
 698         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
 699         struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
 700         u32 q_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
 701         u8 num_tcs = adapter->hw_tcs;
 702         u32 reg_val;
 703         u32 queue;
 704
 705         /* remove VLAN filters beloning to this VF */
 706         ixgbe_clear_vf_vlans(adapter, vf);
 707
 708         /* add back PF assigned VLAN or VLAN 0 */
 709         ixgbe_set_vf_vlan(adapter, true, vfinfo->pf_vlan, vf);
 710
 711         /* reset offloads to defaults */
 712         ixgbe_set_vmolr(hw, vf, !vfinfo->pf_vlan);
 713
 714         /* set outgoing tags for VFs */
 715         if (!vfinfo->pf_vlan && !vfinfo->pf_qos && !num_tcs) {
 716                 ixgbe_clear_vmvir(adapter, vf);
 717         } else {
 718                 if (vfinfo->pf_qos || !num_tcs)
 719                         ixgbe_set_vmvir(adapter, vfinfo->pf_vlan,
 720                                         vfinfo->pf_qos, vf);
 721                 else
 722                         ixgbe_set_vmvir(adapter, vfinfo->pf_vlan,
 723                                         adapter->default_up, vf);
 724
 725                 if (vfinfo->spoofchk_enabled) {
 726                         hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
 727                         hw->mac.ops.set_mac_anti_spoofing(hw, true, vf);
 728                 }
 729         }
 730
 731         /* reset multicast table array for vf */
 732         adapter->vfinfo[vf].num_vf_mc_hashes = 0;
 733
 734         /* clear any ipsec table info */
 735         ixgbe_ipsec_vf_clear(adapter, vf);
 736
 737         /* Flush and reset the mta with the new values */
 738         ixgbe_set_rx_mode(adapter->netdev);
 739
 740         ixgbe_del_mac_filter(adapter, adapter->vfinfo[vf].vf_mac_addresses, vf);
 741         ixgbe_set_vf_macvlan(adapter, vf, 0, NULL);
 742
 743         /* reset VF api back to unknown */
 744         adapter->vfinfo[vf].vf_api = ixgbe_mbox_api_10;
 745
 746         /* Restart each queue for given VF */
 747         for (queue = 0; queue < q_per_pool; queue++) {
 748                 unsigned int reg_idx = (vf * q_per_pool) + queue;
 749
 750                 reg_val = IXGBE_READ_REG(hw, IXGBE_PVFTXDCTL(reg_idx));
 751
 752                 /* Re-enabling only configured queues */
 753                 if (reg_val) {
 754                         reg_val |= IXGBE_TXDCTL_ENABLE;
 755                         IXGBE_WRITE_REG(hw, IXGBE_PVFTXDCTL(reg_idx), reg_val);
 756                         reg_val &= ~IXGBE_TXDCTL_ENABLE;
 757                         IXGBE_WRITE_REG(hw, IXGBE_PVFTXDCTL(reg_idx), reg_val);
 758                 }
 759         }
 760
 761         IXGBE_WRITE_FLUSH(hw);
 762 }
 763
 764 static void ixgbe_vf_clear_mbx(struct ixgbe_adapter *adapter, u32 vf)
 765 {
 766         struct ixgbe_hw *hw = &adapter->hw;
 767         u32 word;
 768
 769         /* Clear VF's mailbox memory */
 770         for (word = 0; word < IXGBE_VFMAILBOX_SIZE; word++)
 771                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf), word, 0);
 772
 773         IXGBE_WRITE_FLUSH(hw);
 774 }
 775
 776 static int ixgbe_set_vf_mac(struct ixgbe_adapter *adapter,
 777                             int vf, unsigned char *mac_addr)
 778 {
 779         int retval;
 780
 781         ixgbe_del_mac_filter(adapter, adapter->vfinfo[vf].vf_mac_addresses, vf);
 782         retval = ixgbe_add_mac_filter(adapter, mac_addr, vf);
 783         if (retval >= 0)
 784                 memcpy(adapter->vfinfo[vf].vf_mac_addresses, mac_addr,
 785                        ETH_ALEN);
 786         else
 787                 eth_zero_addr(adapter->vfinfo[vf].vf_mac_addresses);
 788
 789         return retval;
 790 }
 791
 792 int ixgbe_vf_configuration(struct pci_dev *pdev, unsigned int event_mask)
 793 {
 794         struct ixgbe_adapter *adapter = pci_get_drvdata(pdev);
 795         unsigned int vfn = (event_mask & 0x3f);
 796
 797         bool enable = ((event_mask & 0x10000000U) != 0);
 798
 799         if (enable)
 800                 eth_zero_addr(adapter->vfinfo[vfn].vf_mac_addresses);
 801
 802         return 0;
 803 }
 804
 805 static inline void ixgbe_write_qde(struct ixgbe_adapter *adapter, u32 vf,
 806                                    u32 qde)
 807 {
 808         struct ixgbe_hw *hw = &adapter->hw;
 809         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
 810         u32 q_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
 811         int i;
 812
 813         for (i = vf * q_per_pool; i < ((vf + 1) * q_per_pool); i++) {
 814                 u32 reg;
 815
 816                 /* flush previous write */
 817                 IXGBE_WRITE_FLUSH(hw);
 818
 819                 /* indicate to hardware that we want to set drop enable */
 820                 reg = IXGBE_QDE_WRITE | qde;
 821                 reg |= i <<  IXGBE_QDE_IDX_SHIFT;
 822                 IXGBE_WRITE_REG(hw, IXGBE_QDE, reg);
 823         }
 824 }
 825
 826 /**
 827  * ixgbe_set_vf_rx_tx - Set VF rx tx
 828  * @adapter: Pointer to adapter struct
 829  * @vf: VF identifier
 830  *
 831  * Set or reset correct transmit and receive for vf
 832  **/
 833 static void ixgbe_set_vf_rx_tx(struct ixgbe_adapter *adapter, int vf)
 834 {
 835         u32 reg_cur_tx, reg_cur_rx, reg_req_tx, reg_req_rx;
 836         struct ixgbe_hw *hw = &adapter->hw;
 837         u32 reg_offset, vf_shift;
 838
 839         vf_shift = vf % 32;
 840         reg_offset = vf / 32;
 841
 842         reg_cur_tx = IXGBE_READ_REG(hw, IXGBE_VFTE(reg_offset));
 843         reg_cur_rx = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
 844
 845         if (adapter->vfinfo[vf].link_enable) {
 846                 reg_req_tx = reg_cur_tx | 1 << vf_shift;
 847                 reg_req_rx = reg_cur_rx | 1 << vf_shift;
 848         } else {
 849                 reg_req_tx = reg_cur_tx & ~(1 << vf_shift);
 850                 reg_req_rx = reg_cur_rx & ~(1 << vf_shift);
 851         }
 852
 853         /* The 82599 cannot support a mix of jumbo and non-jumbo PF/VFs.
 854          * For more info take a look at ixgbe_set_vf_lpe
 855          */
 856         if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
 857                 struct net_device *dev = adapter->netdev;
 858                 int pf_max_frame = dev->mtu + ETH_HLEN;
 859
 860 #if IS_ENABLED(CONFIG_FCOE)
 861                 if (dev->fcoe_mtu)
 862                         pf_max_frame = max_t(int, pf_max_frame,
 863                                              IXGBE_FCOE_JUMBO_FRAME_SIZE);
 864 #endif /* CONFIG_FCOE */
 865
 866                 if (pf_max_frame > ETH_FRAME_LEN)
 867                         reg_req_rx = reg_cur_rx & ~(1 << vf_shift);
 868         }
 869
 870         /* Enable/Disable particular VF */
 871         if (reg_cur_tx != reg_req_tx)
 872                 IXGBE_WRITE_REG(hw, IXGBE_VFTE(reg_offset), reg_req_tx);
 873         if (reg_cur_rx != reg_req_rx)
 874                 IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), reg_req_rx);
 875 }
 876
 877 static int ixgbe_vf_reset_msg(struct ixgbe_adapter *adapter, u32 vf)
 878 {
 879         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
 880         struct ixgbe_hw *hw = &adapter->hw;
 881         unsigned char *vf_mac = adapter->vfinfo[vf].vf_mac_addresses;
 882         u32 reg, reg_offset, vf_shift;
 883         u32 msgbuf[4] = {0, 0, 0, 0};
 884         u8 *addr = (u8 *)(&msgbuf[1]);
 885         u32 q_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
 886         int i;
 887
 888         e_info(probe, "VF Reset msg received from vf %d\n", vf);
 889
 890         /* reset the filters for the device */
 891         ixgbe_vf_reset_event(adapter, vf);
 892
 893         ixgbe_vf_clear_mbx(adapter, vf);
 894
 895         /* set vf mac address */
 896         if (!is_zero_ether_addr(vf_mac))
 897                 ixgbe_set_vf_mac(adapter, vf, vf_mac);
 898
 899         vf_shift = vf % 32;
 900         reg_offset = vf / 32;
 901
 902         /* force drop enable for all VF Rx queues */
 903         reg = IXGBE_QDE_ENABLE;
 904         if (adapter->vfinfo[vf].pf_vlan)
 905                 reg |= IXGBE_QDE_HIDE_VLAN;
 906
 907         ixgbe_write_qde(adapter, vf, reg);
 908
 909         ixgbe_set_vf_rx_tx(adapter, vf);
 910
 911         /* enable VF mailbox for further messages */
 912         adapter->vfinfo[vf].clear_to_send = true;
 913
 914         /* Enable counting of spoofed packets in the SSVPC register */
 915         reg = IXGBE_READ_REG(hw, IXGBE_VMECM(reg_offset));
 916         reg |= BIT(vf_shift);
 917         IXGBE_WRITE_REG(hw, IXGBE_VMECM(reg_offset), reg);
 918
 919         /*
 920          * Reset the VFs TDWBAL and TDWBAH registers
 921          * which are not cleared by an FLR
 922          */
 923         for (i = 0; i < q_per_pool; i++) {
 924                 IXGBE_WRITE_REG(hw, IXGBE_PVFTDWBAHn(q_per_pool, vf, i), 0);
 925                 IXGBE_WRITE_REG(hw, IXGBE_PVFTDWBALn(q_per_pool, vf, i), 0);
 926         }
 927
 928         /* reply to reset with ack and vf mac address */
 929         msgbuf[0] = IXGBE_VF_RESET;
 930         if (!is_zero_ether_addr(vf_mac) && adapter->vfinfo[vf].pf_set_mac) {
 931                 msgbuf[0] |= IXGBE_VT_MSGTYPE_ACK;
 932                 memcpy(addr, vf_mac, ETH_ALEN);
 933         } else {
 934                 msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
 935         }
 936
 937         /*
 938          * Piggyback the multicast filter type so VF can compute the
 939          * correct vectors
 940          */
 941         msgbuf[3] = hw->mac.mc_filter_type;
 942         ixgbe_write_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN, vf);
 943
 944         return 0;
 945 }
 946
 947 static int ixgbe_set_vf_mac_addr(struct ixgbe_adapter *adapter,
 948                                  u32 *msgbuf, u32 vf)
 949 {
 950         u8 *new_mac = ((u8 *)(&msgbuf[1]));
 951
 952         if (!is_valid_ether_addr(new_mac)) {
 953                 e_warn(drv, "VF %d attempted to set invalid mac\n", vf);
 954                 return -1;
 955         }
 956
 957         if (adapter->vfinfo[vf].pf_set_mac && !adapter->vfinfo[vf].trusted &&
 958             !ether_addr_equal(adapter->vfinfo[vf].vf_mac_addresses, new_mac)) {
 959                 e_warn(drv,
 960                        "VF %d attempted to override administratively set MAC address\n"
 961                        "Reload the VF driver to resume operations\n",
 962                        vf);
 963                 return -1;
 964         }
 965
 966         return ixgbe_set_vf_mac(adapter, vf, new_mac) < 0;
 967 }
 968
 969 static int ixgbe_set_vf_vlan_msg(struct ixgbe_adapter *adapter,
 970                                  u32 *msgbuf, u32 vf)
 971 {
 972         u32 add = FIELD_GET(IXGBE_VT_MSGINFO_MASK, msgbuf[0]);
 973         u32 vid = (msgbuf[1] & IXGBE_VLVF_VLANID_MASK);
 974         u8 tcs = adapter->hw_tcs;
 975
 976         if (adapter->vfinfo[vf].pf_vlan || tcs) {
 977                 e_warn(drv,
 978                        "VF %d attempted to override administratively set VLAN configuration\n"
 979                        "Reload the VF driver to resume operations\n",
 980                        vf);
 981                 return -1;
 982         }
 983
 984         /* VLAN 0 is a special case, don't allow it to be removed */
 985         if (!vid && !add)
 986                 return 0;
 987
 988         return ixgbe_set_vf_vlan(adapter, add, vid, vf);
 989 }
 990
 991 static int ixgbe_set_vf_macvlan_msg(struct ixgbe_adapter *adapter,
 992                                     u32 *msgbuf, u32 vf)
 993 {
 994         u8 *new_mac = ((u8 *)(&msgbuf[1]));
 995         int index = FIELD_GET(IXGBE_VT_MSGINFO_MASK, msgbuf[0]);
 996         int err;
 997
 998         if (adapter->vfinfo[vf].pf_set_mac && !adapter->vfinfo[vf].trusted &&
 999             index > 0) {
1000                 e_warn(drv,
1001                        "VF %d requested MACVLAN filter but is administratively denied\n",
1002                        vf);
1003                 return -1;
1004         }
1005
1006         /* An non-zero index indicates the VF is setting a filter */
1007         if (index) {
1008                 if (!is_valid_ether_addr(new_mac)) {
1009                         e_warn(drv, "VF %d attempted to set invalid mac\n", vf);
1010                         return -1;
1011                 }
1012
1013                 /*
1014                  * If the VF is allowed to set MAC filters then turn off
1015                  * anti-spoofing to avoid false positives.
1016                  */
1017                 if (adapter->vfinfo[vf].spoofchk_enabled) {
1018                         struct ixgbe_hw *hw = &adapter->hw;
1019
1020                         hw->mac.ops.set_mac_anti_spoofing(hw, false, vf);
1021                         hw->mac.ops.set_vlan_anti_spoofing(hw, false, vf);
1022                 }
1023         }
1024
1025         err = ixgbe_set_vf_macvlan(adapter, vf, index, new_mac);
1026         if (err == -ENOSPC)
1027                 e_warn(drv,
1028                        "VF %d has requested a MACVLAN filter but there is no space for it\n",
1029                        vf);
1030
1031         return err < 0;
1032 }
1033
1034 static int ixgbe_negotiate_vf_api(struct ixgbe_adapter *adapter,
1035                                   u32 *msgbuf, u32 vf)
1036 {
1037         int api = msgbuf[1];
1038
1039         switch (api) {
1040         case ixgbe_mbox_api_10:
1041         case ixgbe_mbox_api_11:
1042         case ixgbe_mbox_api_12:
1043         case ixgbe_mbox_api_13:
1044         case ixgbe_mbox_api_14:
1045                 adapter->vfinfo[vf].vf_api = api;
1046                 return 0;
1047         default:
1048                 break;
1049         }
1050
1051         e_dbg(drv, "VF %d requested unsupported api version %u\n", vf, api);
1052
1053         return -1;
1054 }
1055
1056 static int ixgbe_get_vf_queues(struct ixgbe_adapter *adapter,
1057                                u32 *msgbuf, u32 vf)
1058 {
1059         struct net_device *dev = adapter->netdev;
1060         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
1061         unsigned int default_tc = 0;
1062         u8 num_tcs = adapter->hw_tcs;
1063
1064         /* verify the PF is supporting the correct APIs */
1065         switch (adapter->vfinfo[vf].vf_api) {
1066         case ixgbe_mbox_api_20:
1067         case ixgbe_mbox_api_11:
1068         case ixgbe_mbox_api_12:
1069         case ixgbe_mbox_api_13:
1070         case ixgbe_mbox_api_14:
1071                 break;
1072         default:
1073                 return -1;
1074         }
1075
1076         /* only allow 1 Tx queue for bandwidth limiting */
1077         msgbuf[IXGBE_VF_TX_QUEUES] = __ALIGN_MASK(1, ~vmdq->mask);
1078         msgbuf[IXGBE_VF_RX_QUEUES] = __ALIGN_MASK(1, ~vmdq->mask);
1079
1080         /* if TCs > 1 determine which TC belongs to default user priority */
1081         if (num_tcs > 1)
1082                 default_tc = netdev_get_prio_tc_map(dev, adapter->default_up);
1083
1084         /* notify VF of need for VLAN tag stripping, and correct queue */
1085         if (num_tcs)
1086                 msgbuf[IXGBE_VF_TRANS_VLAN] = num_tcs;
1087         else if (adapter->vfinfo[vf].pf_vlan || adapter->vfinfo[vf].pf_qos)
1088                 msgbuf[IXGBE_VF_TRANS_VLAN] = 1;
1089         else
1090                 msgbuf[IXGBE_VF_TRANS_VLAN] = 0;
1091
1092         /* notify VF of default queue */
1093         msgbuf[IXGBE_VF_DEF_QUEUE] = default_tc;
1094
1095         return 0;
1096 }
1097
1098 static int ixgbe_get_vf_reta(struct ixgbe_adapter *adapter, u32 *msgbuf, u32 vf)
1099 {
1100         u32 i, j;
1101         u32 *out_buf = &msgbuf[1];
1102         const u8 *reta = adapter->rss_indir_tbl;
1103         u32 reta_size = ixgbe_rss_indir_tbl_entries(adapter);
1104
1105         /* Check if operation is permitted */
1106         if (!adapter->vfinfo[vf].rss_query_enabled)
1107                 return -EPERM;
1108
1109         /* verify the PF is supporting the correct API */
1110         switch (adapter->vfinfo[vf].vf_api) {
1111         case ixgbe_mbox_api_14:
1112         case ixgbe_mbox_api_13:
1113         case ixgbe_mbox_api_12:
1114                 break;
1115         default:
1116                 return -EOPNOTSUPP;
1117         }
1118
1119         /* This mailbox command is supported (required) only for 82599 and x540
1120          * VFs which support up to 4 RSS queues. Therefore we will compress the
1121          * RETA by saving only 2 bits from each entry. This way we will be able
1122          * to transfer the whole RETA in a single mailbox operation.
1123          */
1124         for (i = 0; i < reta_size / 16; i++) {
1125                 out_buf[i] = 0;
1126                 for (j = 0; j < 16; j++)
1127                         out_buf[i] |= (u32)(reta[16 * i + j] & 0x3) << (2 * j);
1128         }
1129
1130         return 0;
1131 }
1132
1133 static int ixgbe_get_vf_rss_key(struct ixgbe_adapter *adapter,
1134                                 u32 *msgbuf, u32 vf)
1135 {
1136         u32 *rss_key = &msgbuf[1];
1137
1138         /* Check if the operation is permitted */
1139         if (!adapter->vfinfo[vf].rss_query_enabled)
1140                 return -EPERM;
1141
1142         /* verify the PF is supporting the correct API */
1143         switch (adapter->vfinfo[vf].vf_api) {
1144         case ixgbe_mbox_api_14:
1145         case ixgbe_mbox_api_13:
1146         case ixgbe_mbox_api_12:
1147                 break;
1148         default:
1149                 return -EOPNOTSUPP;
1150         }
1151
1152         memcpy(rss_key, adapter->rss_key, IXGBE_RSS_KEY_SIZE);
1153
1154         return 0;
1155 }
1156
1157 static int ixgbe_update_vf_xcast_mode(struct ixgbe_adapter *adapter,
1158                                       u32 *msgbuf, u32 vf)
1159 {
1160         struct ixgbe_hw *hw = &adapter->hw;
1161         int xcast_mode = msgbuf[1];
1162         u32 vmolr, fctrl, disable, enable;
1163
1164         /* verify the PF is supporting the correct APIs */
1165         switch (adapter->vfinfo[vf].vf_api) {
1166         case ixgbe_mbox_api_12:
1167                 /* promisc introduced in 1.3 version */
1168                 if (xcast_mode == IXGBEVF_XCAST_MODE_PROMISC)
1169                         return -EOPNOTSUPP;
1170                 fallthrough;
1171         case ixgbe_mbox_api_13:
1172         case ixgbe_mbox_api_14:
1173                 break;
1174         default:
1175                 return -EOPNOTSUPP;
1176         }
1177
1178         if (xcast_mode > IXGBEVF_XCAST_MODE_MULTI &&
1179             !adapter->vfinfo[vf].trusted) {
1180                 xcast_mode = IXGBEVF_XCAST_MODE_MULTI;
1181         }
1182
1183         if (adapter->vfinfo[vf].xcast_mode == xcast_mode)
1184                 goto out;
1185
1186         switch (xcast_mode) {
1187         case IXGBEVF_XCAST_MODE_NONE:
1188                 disable = IXGBE_VMOLR_ROMPE |
1189                           IXGBE_VMOLR_MPE | IXGBE_VMOLR_UPE | IXGBE_VMOLR_VPE;
1190                 enable = IXGBE_VMOLR_BAM;
1191                 break;
1192         case IXGBEVF_XCAST_MODE_MULTI:
1193                 disable = IXGBE_VMOLR_MPE | IXGBE_VMOLR_UPE | IXGBE_VMOLR_VPE;
1194                 enable = IXGBE_VMOLR_BAM | IXGBE_VMOLR_ROMPE;
1195                 break;
1196         case IXGBEVF_XCAST_MODE_ALLMULTI:
1197                 disable = IXGBE_VMOLR_UPE | IXGBE_VMOLR_VPE;
1198                 enable = IXGBE_VMOLR_BAM | IXGBE_VMOLR_ROMPE | IXGBE_VMOLR_MPE;
1199                 break;
1200         case IXGBEVF_XCAST_MODE_PROMISC:
1201                 if (hw->mac.type <= ixgbe_mac_82599EB)
1202                         return -EOPNOTSUPP;
1203
1204                 fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
1205                 if (!(fctrl & IXGBE_FCTRL_UPE)) {
1206                         /* VF promisc requires PF in promisc */
1207                         e_warn(drv,
1208                                "Enabling VF promisc requires PF in promisc\n");
1209                         return -EPERM;
1210                 }
1211
1212                 disable = IXGBE_VMOLR_VPE;
1213                 enable = IXGBE_VMOLR_BAM | IXGBE_VMOLR_ROMPE |
1214                          IXGBE_VMOLR_MPE | IXGBE_VMOLR_UPE;
1215                 break;
1216         default:
1217                 return -EOPNOTSUPP;
1218         }
1219
1220         vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
1221         vmolr &= ~disable;
1222         vmolr |= enable;
1223         IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
1224
1225         adapter->vfinfo[vf].xcast_mode = xcast_mode;
1226
1227 out:
1228         msgbuf[1] = xcast_mode;
1229
1230         return 0;
1231 }
1232
1233 static int ixgbe_get_vf_link_state(struct ixgbe_adapter *adapter,
1234                                    u32 *msgbuf, u32 vf)
1235 {
1236         u32 *link_state = &msgbuf[1];
1237
1238         /* verify the PF is supporting the correct API */
1239         switch (adapter->vfinfo[vf].vf_api) {
1240         case ixgbe_mbox_api_12:
1241         case ixgbe_mbox_api_13:
1242         case ixgbe_mbox_api_14:
1243                 break;
1244         default:
1245                 return -EOPNOTSUPP;
1246         }
1247
1248         *link_state = adapter->vfinfo[vf].link_enable;
1249
1250         return 0;
1251 }
1252
1253 static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
1254 {
1255         u32 mbx_size = IXGBE_VFMAILBOX_SIZE;
1256         u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
1257         struct ixgbe_hw *hw = &adapter->hw;
1258         int retval;
1259
1260         retval = ixgbe_read_mbx(hw, msgbuf, mbx_size, vf);
1261
1262         if (retval) {
1263                 pr_err("Error receiving message from VF\n");
1264                 return retval;
1265         }
1266
1267         /* this is a message we already processed, do nothing */
1268         if (msgbuf[0] & (IXGBE_VT_MSGTYPE_ACK | IXGBE_VT_MSGTYPE_NACK))
1269                 return 0;
1270
1271         /* flush the ack before we write any messages back */
1272         IXGBE_WRITE_FLUSH(hw);
1273
1274         if (msgbuf[0] == IXGBE_VF_RESET)
1275                 return ixgbe_vf_reset_msg(adapter, vf);
1276
1277         /*
1278          * until the vf completes a virtual function reset it should not be
1279          * allowed to start any configuration.
1280          */
1281         if (!adapter->vfinfo[vf].clear_to_send) {
1282                 msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
1283                 ixgbe_write_mbx(hw, msgbuf, 1, vf);
1284                 return 0;
1285         }
1286
1287         switch ((msgbuf[0] & 0xFFFF)) {
1288         case IXGBE_VF_SET_MAC_ADDR:
1289                 retval = ixgbe_set_vf_mac_addr(adapter, msgbuf, vf);
1290                 break;
1291         case IXGBE_VF_SET_MULTICAST:
1292                 retval = ixgbe_set_vf_multicasts(adapter, msgbuf, vf);
1293                 break;
1294         case IXGBE_VF_SET_VLAN:
1295                 retval = ixgbe_set_vf_vlan_msg(adapter, msgbuf, vf);
1296                 break;
1297         case IXGBE_VF_SET_LPE:
1298                 retval = ixgbe_set_vf_lpe(adapter, msgbuf[1], vf);
1299                 break;
1300         case IXGBE_VF_SET_MACVLAN:
1301                 retval = ixgbe_set_vf_macvlan_msg(adapter, msgbuf, vf);
1302                 break;
1303         case IXGBE_VF_API_NEGOTIATE:
1304                 retval = ixgbe_negotiate_vf_api(adapter, msgbuf, vf);
1305                 break;
1306         case IXGBE_VF_GET_QUEUES:
1307                 retval = ixgbe_get_vf_queues(adapter, msgbuf, vf);
1308                 break;
1309         case IXGBE_VF_GET_RETA:
1310                 retval = ixgbe_get_vf_reta(adapter, msgbuf, vf);
1311                 break;
1312         case IXGBE_VF_GET_RSS_KEY:
1313                 retval = ixgbe_get_vf_rss_key(adapter, msgbuf, vf);
1314                 break;
1315         case IXGBE_VF_UPDATE_XCAST_MODE:
1316                 retval = ixgbe_update_vf_xcast_mode(adapter, msgbuf, vf);
1317                 break;
1318         case IXGBE_VF_GET_LINK_STATE:
1319                 retval = ixgbe_get_vf_link_state(adapter, msgbuf, vf);
1320                 break;
1321         case IXGBE_VF_IPSEC_ADD:
1322                 retval = ixgbe_ipsec_vf_add_sa(adapter, msgbuf, vf);
1323                 break;
1324         case IXGBE_VF_IPSEC_DEL:
1325                 retval = ixgbe_ipsec_vf_del_sa(adapter, msgbuf, vf);
1326                 break;
1327         default:
1328                 e_err(drv, "Unhandled Msg %8.8x\n", msgbuf[0]);
1329                 retval = -EIO;
1330                 break;
1331         }
1332
1333         /* notify the VF of the results of what it sent us */
1334         if (retval)
1335                 msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
1336         else
1337                 msgbuf[0] |= IXGBE_VT_MSGTYPE_ACK;
1338
1339         msgbuf[0] |= IXGBE_VT_MSGTYPE_CTS;
1340
1341         ixgbe_write_mbx(hw, msgbuf, mbx_size, vf);
1342
1343         return retval;
1344 }
1345
1346 static void ixgbe_rcv_ack_from_vf(struct ixgbe_adapter *adapter, u32 vf)
1347 {
1348         struct ixgbe_hw *hw = &adapter->hw;
1349         u32 msg = IXGBE_VT_MSGTYPE_NACK;
1350
1351         /* if device isn't clear to send it shouldn't be reading either */
1352         if (!adapter->vfinfo[vf].clear_to_send)
1353                 ixgbe_write_mbx(hw, &msg, 1, vf);
1354 }
1355
1356 void ixgbe_msg_task(struct ixgbe_adapter *adapter)
1357 {
1358         struct ixgbe_hw *hw = &adapter->hw;
1359         unsigned long flags;
1360         u32 vf;
1361
1362         spin_lock_irqsave(&adapter->vfs_lock, flags);
1363         for (vf = 0; vf < adapter->num_vfs; vf++) {
1364                 /* process any reset requests */
1365                 if (!ixgbe_check_for_rst(hw, vf))
1366                         ixgbe_vf_reset_event(adapter, vf);
1367
1368                 /* process any messages pending */
1369                 if (!ixgbe_check_for_msg(hw, vf))
1370                         ixgbe_rcv_msg_from_vf(adapter, vf);
1371
1372                 /* process any acks */
1373                 if (!ixgbe_check_for_ack(hw, vf))
1374                         ixgbe_rcv_ack_from_vf(adapter, vf);
1375         }
1376         spin_unlock_irqrestore(&adapter->vfs_lock, flags);
1377 }
1378
1379 static inline void ixgbe_ping_vf(struct ixgbe_adapter *adapter, int vf)
1380 {
1381         struct ixgbe_hw *hw = &adapter->hw;
1382         u32 ping;
1383
1384         ping = IXGBE_PF_CONTROL_MSG;
1385         if (adapter->vfinfo[vf].clear_to_send)
1386                 ping |= IXGBE_VT_MSGTYPE_CTS;
1387         ixgbe_write_mbx(hw, &ping, 1, vf);
1388 }
1389
1390 void ixgbe_ping_all_vfs(struct ixgbe_adapter *adapter)
1391 {
1392         struct ixgbe_hw *hw = &adapter->hw;
1393         u32 ping;
1394         int i;
1395
1396         for (i = 0 ; i < adapter->num_vfs; i++) {
1397                 ping = IXGBE_PF_CONTROL_MSG;
1398                 if (adapter->vfinfo[i].clear_to_send)
1399                         ping |= IXGBE_VT_MSGTYPE_CTS;
1400                 ixgbe_write_mbx(hw, &ping, 1, i);
1401         }
1402 }
1403
1404 /**
1405  * ixgbe_set_all_vfs - update vfs queues
1406  * @adapter: Pointer to adapter struct
1407  *
1408  * Update setting transmit and receive queues for all vfs
1409  **/
1410 void ixgbe_set_all_vfs(struct ixgbe_adapter *adapter)
1411 {
1412         int i;
1413
1414         for (i = 0 ; i < adapter->num_vfs; i++)
1415                 ixgbe_set_vf_link_state(adapter, i,
1416                                         adapter->vfinfo[i].link_state);
1417 }
1418
1419 int ixgbe_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1420 {
1421         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1422         int retval;
1423
1424         if (vf >= adapter->num_vfs)
1425                 return -EINVAL;
1426
1427         if (is_valid_ether_addr(mac)) {
1428                 dev_info(&adapter->pdev->dev, "setting MAC %pM on VF %d\n",
1429                          mac, vf);
1430                 dev_info(&adapter->pdev->dev, "Reload the VF driver to make this change effective.");
1431
1432                 retval = ixgbe_set_vf_mac(adapter, vf, mac);
1433                 if (retval >= 0) {
1434                         adapter->vfinfo[vf].pf_set_mac = true;
1435
1436                         if (test_bit(__IXGBE_DOWN, &adapter->state)) {
1437                                 dev_warn(&adapter->pdev->dev, "The VF MAC address has been set, but the PF device is not up.\n");
1438                                 dev_warn(&adapter->pdev->dev, "Bring the PF device up before attempting to use the VF device.\n");
1439                         }
1440                 } else {
1441                         dev_warn(&adapter->pdev->dev, "The VF MAC address was NOT set due to invalid or duplicate MAC address.\n");
1442                 }
1443         } else if (is_zero_ether_addr(mac)) {
1444                 unsigned char *vf_mac_addr =
1445                                            adapter->vfinfo[vf].vf_mac_addresses;
1446
1447                 /* nothing to do */
1448                 if (is_zero_ether_addr(vf_mac_addr))
1449                         return 0;
1450
1451                 dev_info(&adapter->pdev->dev, "removing MAC on VF %d\n", vf);
1452
1453                 retval = ixgbe_del_mac_filter(adapter, vf_mac_addr, vf);
1454                 if (retval >= 0) {
1455                         adapter->vfinfo[vf].pf_set_mac = false;
1456                         memcpy(vf_mac_addr, mac, ETH_ALEN);
1457                 } else {
1458                         dev_warn(&adapter->pdev->dev, "Could NOT remove the VF MAC address.\n");
1459                 }
1460         } else {
1461                 retval = -EINVAL;
1462         }
1463
1464         return retval;
1465 }
1466
1467 static int ixgbe_enable_port_vlan(struct ixgbe_adapter *adapter, int vf,
1468                                   u16 vlan, u8 qos)
1469 {
1470         struct ixgbe_hw *hw = &adapter->hw;
1471         int err;
1472
1473         err = ixgbe_set_vf_vlan(adapter, true, vlan, vf);
1474         if (err)
1475                 goto out;
1476
1477         /* Revoke tagless access via VLAN 0 */
1478         ixgbe_set_vf_vlan(adapter, false, 0, vf);
1479
1480         ixgbe_set_vmvir(adapter, vlan, qos, vf);
1481         ixgbe_set_vmolr(hw, vf, false);
1482
1483         /* enable hide vlan on X550 */
1484         if (hw->mac.type >= ixgbe_mac_X550)
1485                 ixgbe_write_qde(adapter, vf, IXGBE_QDE_ENABLE |
1486                                 IXGBE_QDE_HIDE_VLAN);
1487
1488         adapter->vfinfo[vf].pf_vlan = vlan;
1489         adapter->vfinfo[vf].pf_qos = qos;
1490         dev_info(&adapter->pdev->dev,
1491                  "Setting VLAN %d, QOS 0x%x on VF %d\n", vlan, qos, vf);
1492         if (test_bit(__IXGBE_DOWN, &adapter->state)) {
1493                 dev_warn(&adapter->pdev->dev,
1494                          "The VF VLAN has been set, but the PF device is not up.\n");
1495                 dev_warn(&adapter->pdev->dev,
1496                          "Bring the PF device up before attempting to use the VF device.\n");
1497         }
1498
1499 out:
1500         return err;
1501 }
1502
1503 static int ixgbe_disable_port_vlan(struct ixgbe_adapter *adapter, int vf)
1504 {
1505         struct ixgbe_hw *hw = &adapter->hw;
1506         int err;
1507
1508         err = ixgbe_set_vf_vlan(adapter, false,
1509                                 adapter->vfinfo[vf].pf_vlan, vf);
1510         /* Restore tagless access via VLAN 0 */
1511         ixgbe_set_vf_vlan(adapter, true, 0, vf);
1512         ixgbe_clear_vmvir(adapter, vf);
1513         ixgbe_set_vmolr(hw, vf, true);
1514
1515         /* disable hide VLAN on X550 */
1516         if (hw->mac.type >= ixgbe_mac_X550)
1517                 ixgbe_write_qde(adapter, vf, IXGBE_QDE_ENABLE);
1518
1519         adapter->vfinfo[vf].pf_vlan = 0;
1520         adapter->vfinfo[vf].pf_qos = 0;
1521
1522         return err;
1523 }
1524
1525 int ixgbe_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan,
1526                           u8 qos, __be16 vlan_proto)
1527 {
1528         int err = 0;
1529         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1530
1531         if ((vf >= adapter->num_vfs) || (vlan > 4095) || (qos > 7))
1532                 return -EINVAL;
1533         if (vlan_proto != htons(ETH_P_8021Q))
1534                 return -EPROTONOSUPPORT;
1535         if (vlan || qos) {
1536                 /* Check if there is already a port VLAN set, if so
1537                  * we have to delete the old one first before we
1538                  * can set the new one.  The usage model had
1539                  * previously assumed the user would delete the
1540                  * old port VLAN before setting a new one but this
1541                  * is not necessarily the case.
1542                  */
1543                 if (adapter->vfinfo[vf].pf_vlan)
1544                         err = ixgbe_disable_port_vlan(adapter, vf);
1545                 if (err)
1546                         goto out;
1547                 err = ixgbe_enable_port_vlan(adapter, vf, vlan, qos);
1548         } else {
1549                 err = ixgbe_disable_port_vlan(adapter, vf);
1550         }
1551
1552 out:
1553         return err;
1554 }
1555
1556 int ixgbe_link_mbps(struct ixgbe_adapter *adapter)
1557 {
1558         switch (adapter->link_speed) {
1559         case IXGBE_LINK_SPEED_100_FULL:
1560                 return 100;
1561         case IXGBE_LINK_SPEED_1GB_FULL:
1562                 return 1000;
1563         case IXGBE_LINK_SPEED_10GB_FULL:
1564                 return 10000;
1565         default:
1566                 return 0;
1567         }
1568 }
1569
1570 static void ixgbe_set_vf_rate_limit(struct ixgbe_adapter *adapter, int vf)
1571 {
1572         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
1573         struct ixgbe_hw *hw = &adapter->hw;
1574         u32 bcnrc_val = 0;
1575         u16 queue, queues_per_pool;
1576         u16 tx_rate = adapter->vfinfo[vf].tx_rate;
1577
1578         if (tx_rate) {
1579                 /* start with base link speed value */
1580                 bcnrc_val = adapter->vf_rate_link_speed;
1581
1582                 /* Calculate the rate factor values to set */
1583                 bcnrc_val <<= IXGBE_RTTBCNRC_RF_INT_SHIFT;
1584                 bcnrc_val /= tx_rate;
1585
1586                 /* clear everything but the rate factor */
1587                 bcnrc_val &= IXGBE_RTTBCNRC_RF_INT_MASK |
1588                              IXGBE_RTTBCNRC_RF_DEC_MASK;
1589
1590                 /* enable the rate scheduler */
1591                 bcnrc_val |= IXGBE_RTTBCNRC_RS_ENA;
1592         }
1593
1594         /*
1595          * Set global transmit compensation time to the MMW_SIZE in RTTBCNRM
1596          * register. Typically MMW_SIZE=0x014 if 9728-byte jumbo is supported
1597          * and 0x004 otherwise.
1598          */
1599         switch (hw->mac.type) {
1600         case ixgbe_mac_82599EB:
1601                 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRM, 0x4);
1602                 break;
1603         case ixgbe_mac_X540:
1604                 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRM, 0x14);
1605                 break;
1606         default:
1607                 break;
1608         }
1609
1610         /* determine how many queues per pool based on VMDq mask */
1611         queues_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
1612
1613         /* write value for all Tx queues belonging to VF */
1614         for (queue = 0; queue < queues_per_pool; queue++) {
1615                 unsigned int reg_idx = (vf * queues_per_pool) + queue;
1616
1617                 IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, reg_idx);
1618                 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRC, bcnrc_val);
1619         }
1620 }
1621
1622 void ixgbe_check_vf_rate_limit(struct ixgbe_adapter *adapter)
1623 {
1624         int i;
1625
1626         /* VF Tx rate limit was not set */
1627         if (!adapter->vf_rate_link_speed)
1628                 return;
1629
1630         if (ixgbe_link_mbps(adapter) != adapter->vf_rate_link_speed) {
1631                 adapter->vf_rate_link_speed = 0;
1632                 dev_info(&adapter->pdev->dev,
1633                          "Link speed has been changed. VF Transmit rate is disabled\n");
1634         }
1635
1636         for (i = 0; i < adapter->num_vfs; i++) {
1637                 if (!adapter->vf_rate_link_speed)
1638                         adapter->vfinfo[i].tx_rate = 0;
1639
1640                 ixgbe_set_vf_rate_limit(adapter, i);
1641         }
1642 }
1643
1644 int ixgbe_ndo_set_vf_bw(struct net_device *netdev, int vf, int min_tx_rate,
1645                         int max_tx_rate)
1646 {
1647         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1648         int link_speed;
1649
1650         /* verify VF is active */
1651         if (vf >= adapter->num_vfs)
1652                 return -EINVAL;
1653
1654         /* verify link is up */
1655         if (!adapter->link_up)
1656                 return -EINVAL;
1657
1658         /* verify we are linked at 10Gbps */
1659         link_speed = ixgbe_link_mbps(adapter);
1660         if (link_speed != 10000)
1661                 return -EINVAL;
1662
1663         if (min_tx_rate)
1664                 return -EINVAL;
1665
1666         /* rate limit cannot be less than 10Mbs or greater than link speed */
1667         if (max_tx_rate && ((max_tx_rate <= 10) || (max_tx_rate > link_speed)))
1668                 return -EINVAL;
1669
1670         /* store values */
1671         adapter->vf_rate_link_speed = link_speed;
1672         adapter->vfinfo[vf].tx_rate = max_tx_rate;
1673
1674         /* update hardware configuration */
1675         ixgbe_set_vf_rate_limit(adapter, vf);
1676
1677         return 0;
1678 }
1679
1680 int ixgbe_ndo_set_vf_spoofchk(struct net_device *netdev, int vf, bool setting)
1681 {
1682         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1683         struct ixgbe_hw *hw = &adapter->hw;
1684
1685         if (vf >= adapter->num_vfs)
1686                 return -EINVAL;
1687
1688         adapter->vfinfo[vf].spoofchk_enabled = setting;
1689
1690         /* configure MAC spoofing */
1691         hw->mac.ops.set_mac_anti_spoofing(hw, setting, vf);
1692
1693         /* configure VLAN spoofing */
1694         hw->mac.ops.set_vlan_anti_spoofing(hw, setting, vf);
1695
1696         /* Ensure LLDP and FC is set for Ethertype Antispoofing if we will be
1697          * calling set_ethertype_anti_spoofing for each VF in loop below
1698          */
1699         if (hw->mac.ops.set_ethertype_anti_spoofing) {
1700                 IXGBE_WRITE_REG(hw, IXGBE_ETQF(IXGBE_ETQF_FILTER_LLDP),
1701                                 (IXGBE_ETQF_FILTER_EN    |
1702                                  IXGBE_ETQF_TX_ANTISPOOF |
1703                                  ETH_P_LLDP));
1704
1705                 IXGBE_WRITE_REG(hw, IXGBE_ETQF(IXGBE_ETQF_FILTER_FC),
1706                                 (IXGBE_ETQF_FILTER_EN |
1707                                  IXGBE_ETQF_TX_ANTISPOOF |
1708                                  ETH_P_PAUSE));
1709
1710                 hw->mac.ops.set_ethertype_anti_spoofing(hw, setting, vf);
1711         }
1712
1713         return 0;
1714 }
1715
1716 /**
1717  * ixgbe_set_vf_link_state - Set link state
1718  * @adapter: Pointer to adapter struct
1719  * @vf: VF identifier
1720  * @state: required link state
1721  *
1722  * Set a link force state on/off a single vf
1723  **/
1724 void ixgbe_set_vf_link_state(struct ixgbe_adapter *adapter, int vf, int state)
1725 {
1726         adapter->vfinfo[vf].link_state = state;
1727
1728         switch (state) {
1729         case IFLA_VF_LINK_STATE_AUTO:
1730                 if (test_bit(__IXGBE_DOWN, &adapter->state))
1731                         adapter->vfinfo[vf].link_enable = false;
1732                 else
1733                         adapter->vfinfo[vf].link_enable = true;
1734                 break;
1735         case IFLA_VF_LINK_STATE_ENABLE:
1736                 adapter->vfinfo[vf].link_enable = true;
1737                 break;
1738         case IFLA_VF_LINK_STATE_DISABLE:
1739                 adapter->vfinfo[vf].link_enable = false;
1740                 break;
1741         }
1742
1743         ixgbe_set_vf_rx_tx(adapter, vf);
1744
1745         /* restart the VF */
1746         adapter->vfinfo[vf].clear_to_send = false;
1747         ixgbe_ping_vf(adapter, vf);
1748 }
1749
1750 /**
1751  * ixgbe_ndo_set_vf_link_state - Set link state
1752  * @netdev: network interface device structure
1753  * @vf: VF identifier
1754  * @state: required link state
1755  *
1756  * Set the link state of a specified VF, regardless of physical link state
1757  **/
1758 int ixgbe_ndo_set_vf_link_state(struct net_device *netdev, int vf, int state)
1759 {
1760         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1761         int ret = 0;
1762
1763         if (vf < 0 || vf >= adapter->num_vfs) {
1764                 dev_err(&adapter->pdev->dev,
1765                         "NDO set VF link - invalid VF identifier %d\n", vf);
1766                 return -EINVAL;
1767         }
1768
1769         switch (state) {
1770         case IFLA_VF_LINK_STATE_ENABLE:
1771                 dev_info(&adapter->pdev->dev,
1772                          "NDO set VF %d link state %d - not supported\n",
1773                         vf, state);
1774                 break;
1775         case IFLA_VF_LINK_STATE_DISABLE:
1776                 dev_info(&adapter->pdev->dev,
1777                          "NDO set VF %d link state disable\n", vf);
1778                 ixgbe_set_vf_link_state(adapter, vf, state);
1779                 break;
1780         case IFLA_VF_LINK_STATE_AUTO:
1781                 dev_info(&adapter->pdev->dev,
1782                          "NDO set VF %d link state auto\n", vf);
1783                 ixgbe_set_vf_link_state(adapter, vf, state);
1784                 break;
1785         default:
1786                 dev_err(&adapter->pdev->dev,
1787                         "NDO set VF %d - invalid link state %d\n", vf, state);
1788                 ret = -EINVAL;
1789         }
1790
1791         return ret;
1792 }
1793
1794 int ixgbe_ndo_set_vf_rss_query_en(struct net_device *netdev, int vf,
1795                                   bool setting)
1796 {
1797         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1798
1799         /* This operation is currently supported only for 82599 and x540
1800          * devices.
1801          */
1802         if (adapter->hw.mac.type < ixgbe_mac_82599EB ||
1803             adapter->hw.mac.type >= ixgbe_mac_X550)
1804                 return -EOPNOTSUPP;
1805
1806         if (vf >= adapter->num_vfs)
1807                 return -EINVAL;
1808
1809         adapter->vfinfo[vf].rss_query_enabled = setting;
1810
1811         return 0;
1812 }
1813
1814 int ixgbe_ndo_set_vf_trust(struct net_device *netdev, int vf, bool setting)
1815 {
1816         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1817
1818         if (vf >= adapter->num_vfs)
1819                 return -EINVAL;
1820
1821         /* nothing to do */
1822         if (adapter->vfinfo[vf].trusted == setting)
1823                 return 0;
1824
1825         adapter->vfinfo[vf].trusted = setting;
1826
1827         /* reset VF to reconfigure features */
1828         adapter->vfinfo[vf].clear_to_send = false;
1829         ixgbe_ping_vf(adapter, vf);
1830
1831         e_info(drv, "VF %u is %strusted\n", vf, setting ? "" : "not ");
1832
1833         return 0;
1834 }
1835
1836 int ixgbe_ndo_get_vf_config(struct net_device *netdev,
1837                             int vf, struct ifla_vf_info *ivi)
1838 {
1839         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1840         if (vf >= adapter->num_vfs)
1841                 return -EINVAL;
1842         ivi->vf = vf;
1843         memcpy(&ivi->mac, adapter->vfinfo[vf].vf_mac_addresses, ETH_ALEN);
1844         ivi->max_tx_rate = adapter->vfinfo[vf].tx_rate;
1845         ivi->min_tx_rate = 0;
1846         ivi->vlan = adapter->vfinfo[vf].pf_vlan;
1847         ivi->qos = adapter->vfinfo[vf].pf_qos;
1848         ivi->spoofchk = adapter->vfinfo[vf].spoofchk_enabled;
1849         ivi->rss_query_en = adapter->vfinfo[vf].rss_query_enabled;
1850         ivi->trusted = adapter->vfinfo[vf].trusted;
1851         ivi->linkstate = adapter->vfinfo[vf].link_state;
1852         return 0;
1853 }