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

   1 /*******************************************************************************
   2
   3   Intel 10 Gigabit PCI Express Linux driver
   4   Copyright(c) 1999 - 2012 Intel Corporation.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   You should have received a copy of the GNU General Public License along with
  16   this program; if not, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   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 <linux/types.h>
  29 #include <linux/module.h>
  30 #include <linux/pci.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/vmalloc.h>
  33 #include <linux/string.h>
  34 #include <linux/in.h>
  35 #include <linux/ip.h>
  36 #include <linux/tcp.h>
  37 #include <linux/ipv6.h>
  38 #ifdef NETIF_F_HW_VLAN_TX
  39 #include <linux/if_vlan.h>
  40 #endif
  41
  42 #include "ixgbe.h"
  43 #include "ixgbe_type.h"
  44 #include "ixgbe_sriov.h"
  45
  46 #ifdef CONFIG_PCI_IOV
  47 void ixgbe_enable_sriov(struct ixgbe_adapter *adapter,
  48                          const struct ixgbe_info *ii)
  49 {
  50         struct ixgbe_hw *hw = &adapter->hw;
  51         int num_vf_macvlans, i;
  52         struct vf_macvlans *mv_list;
  53         int pre_existing_vfs = 0;
  54
  55         pre_existing_vfs = pci_num_vf(adapter->pdev);
  56         if (!pre_existing_vfs && !adapter->num_vfs)
  57                 return;
  58
  59         /* If there are pre-existing VFs then we have to force
  60          * use of that many because they were not deleted the last
  61          * time someone removed the PF driver.  That would have
  62          * been because they were allocated to guest VMs and can't
  63          * be removed.  Go ahead and just re-enable the old amount.
  64          * If the user wants to change the number of VFs they can
  65          * use ethtool while making sure no VFs are allocated to
  66          * guest VMs... i.e. the right way.
  67          */
  68         if (pre_existing_vfs) {
  69                 adapter->num_vfs = pre_existing_vfs;
  70                 dev_warn(&adapter->pdev->dev, "Virtual Functions already "
  71                          "enabled for this device - Please reload all "
  72                          "VF drivers to avoid spoofed packet errors\n");
  73         } else {
  74                 int err;
  75                 /*
  76                  * The 82599 supports up to 64 VFs per physical function
  77                  * but this implementation limits allocation to 63 so that
  78                  * basic networking resources are still available to the
  79                  * physical function.  If the user requests greater thn
  80                  * 63 VFs then it is an error - reset to default of zero.
  81                  */
  82                 adapter->num_vfs = min_t(unsigned int, adapter->num_vfs, 63);
  83
  84                 err = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
  85                 if (err) {
  86                         e_err(probe, "Failed to enable PCI sriov: %d\n", err);
  87                         adapter->num_vfs = 0;
  88                         return;
  89                 }
  90         }
  91
  92         adapter->flags |= IXGBE_FLAG_SRIOV_ENABLED;
  93         e_info(probe, "SR-IOV enabled with %d VFs\n", adapter->num_vfs);
  94
  95         /* Enable VMDq flag so device will be set in VM mode */
  96         adapter->flags |= IXGBE_FLAG_VMDQ_ENABLED;
  97         if (!adapter->ring_feature[RING_F_VMDQ].limit)
  98                 adapter->ring_feature[RING_F_VMDQ].limit = 1;
  99         adapter->ring_feature[RING_F_VMDQ].offset = adapter->num_vfs;
 100
 101         num_vf_macvlans = hw->mac.num_rar_entries -
 102         (IXGBE_MAX_PF_MACVLANS + 1 + adapter->num_vfs);
 103
 104         adapter->mv_list = mv_list = kcalloc(num_vf_macvlans,
 105                                              sizeof(struct vf_macvlans),
 106                                              GFP_KERNEL);
 107         if (mv_list) {
 108                 /* Initialize list of VF macvlans */
 109                 INIT_LIST_HEAD(&adapter->vf_mvs.l);
 110                 for (i = 0; i < num_vf_macvlans; i++) {
 111                         mv_list->vf = -1;
 112                         mv_list->free = true;
 113                         mv_list->rar_entry = hw->mac.num_rar_entries -
 114                                 (i + adapter->num_vfs + 1);
 115                         list_add(&mv_list->l, &adapter->vf_mvs.l);
 116                         mv_list++;
 117                 }
 118         }
 119
 120         /* Initialize default switching mode VEB */
 121         IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);
 122         adapter->flags2 |= IXGBE_FLAG2_BRIDGE_MODE_VEB;
 123
 124         /* If call to enable VFs succeeded then allocate memory
 125          * for per VF control structures.
 126          */
 127         adapter->vfinfo =
 128                 kcalloc(adapter->num_vfs,
 129                         sizeof(struct vf_data_storage), GFP_KERNEL);
 130         if (adapter->vfinfo) {
 131                 /* Now that we're sure SR-IOV is enabled
 132                  * and memory allocated set up the mailbox parameters
 133                  */
 134                 ixgbe_init_mbx_params_pf(hw);
 135                 memcpy(&hw->mbx.ops, ii->mbx_ops, sizeof(hw->mbx.ops));
 136
 137                 /* limit trafffic classes based on VFs enabled */
 138                 if ((adapter->hw.mac.type == ixgbe_mac_82599EB) &&
 139                     (adapter->num_vfs < 16)) {
 140                         adapter->dcb_cfg.num_tcs.pg_tcs = MAX_TRAFFIC_CLASS;
 141                         adapter->dcb_cfg.num_tcs.pfc_tcs = MAX_TRAFFIC_CLASS;
 142                 } else if (adapter->num_vfs < 32) {
 143                         adapter->dcb_cfg.num_tcs.pg_tcs = 4;
 144                         adapter->dcb_cfg.num_tcs.pfc_tcs = 4;
 145                 } else {
 146                         adapter->dcb_cfg.num_tcs.pg_tcs = 1;
 147                         adapter->dcb_cfg.num_tcs.pfc_tcs = 1;
 148                 }
 149
 150                 /* We do not support RSS w/ SR-IOV */
 151                 adapter->ring_feature[RING_F_RSS].limit = 1;
 152
 153                 /* Disable RSC when in SR-IOV mode */
 154                 adapter->flags2 &= ~(IXGBE_FLAG2_RSC_CAPABLE |
 155                                      IXGBE_FLAG2_RSC_ENABLED);
 156
 157                 /* enable spoof checking for all VFs */
 158                 for (i = 0; i < adapter->num_vfs; i++)
 159                         adapter->vfinfo[i].spoofchk_enabled = true;
 160                 return;
 161         }
 162
 163         /* Oh oh */
 164         e_err(probe, "Unable to allocate memory for VF Data Storage - "
 165               "SRIOV disabled\n");
 166         ixgbe_disable_sriov(adapter);
 167 }
 168
 169 static bool ixgbe_vfs_are_assigned(struct ixgbe_adapter *adapter)
 170 {
 171         struct pci_dev *pdev = adapter->pdev;
 172         struct pci_dev *vfdev;
 173         int dev_id;
 174
 175         switch (adapter->hw.mac.type) {
 176         case ixgbe_mac_82599EB:
 177                 dev_id = IXGBE_DEV_ID_82599_VF;
 178                 break;
 179         case ixgbe_mac_X540:
 180                 dev_id = IXGBE_DEV_ID_X540_VF;
 181                 break;
 182         default:
 183                 return false;
 184         }
 185
 186         /* loop through all the VFs to see if we own any that are assigned */
 187         vfdev = pci_get_device(PCI_VENDOR_ID_INTEL, dev_id, NULL);
 188         while (vfdev) {
 189                 /* if we don't own it we don't care */
 190                 if (vfdev->is_virtfn && vfdev->physfn == pdev) {
 191                         /* if it is assigned we cannot release it */
 192                         if (vfdev->dev_flags & PCI_DEV_FLAGS_ASSIGNED)
 193                                 return true;
 194                 }
 195
 196                 vfdev = pci_get_device(PCI_VENDOR_ID_INTEL, dev_id, vfdev);
 197         }
 198
 199         return false;
 200 }
 201
 202 #endif /* #ifdef CONFIG_PCI_IOV */
 203 void ixgbe_disable_sriov(struct ixgbe_adapter *adapter)
 204 {
 205         struct ixgbe_hw *hw = &adapter->hw;
 206         u32 gpie;
 207         u32 vmdctl;
 208
 209         /* set num VFs to 0 to prevent access to vfinfo */
 210         adapter->num_vfs = 0;
 211
 212         /* free VF control structures */
 213         kfree(adapter->vfinfo);
 214         adapter->vfinfo = NULL;
 215
 216         /* free macvlan list */
 217         kfree(adapter->mv_list);
 218         adapter->mv_list = NULL;
 219
 220         /* if SR-IOV is already disabled then there is nothing to do */
 221         if (!(adapter->flags & IXGBE_FLAG_SRIOV_ENABLED))
 222                 return;
 223
 224 #ifdef CONFIG_PCI_IOV
 225         /*
 226          * If our VFs are assigned we cannot shut down SR-IOV
 227          * without causing issues, so just leave the hardware
 228          * available but disabled
 229          */
 230         if (ixgbe_vfs_are_assigned(adapter)) {
 231                 e_dev_warn("Unloading driver while VFs are assigned - VFs will not be deallocated\n");
 232                 return;
 233         }
 234         /* disable iov and allow time for transactions to clear */
 235         pci_disable_sriov(adapter->pdev);
 236 #endif
 237
 238         /* turn off device IOV mode */
 239         IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, 0);
 240         gpie = IXGBE_READ_REG(hw, IXGBE_GPIE);
 241         gpie &= ~IXGBE_GPIE_VTMODE_MASK;
 242         IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);
 243
 244         /* set default pool back to 0 */
 245         vmdctl = IXGBE_READ_REG(hw, IXGBE_VT_CTL);
 246         vmdctl &= ~IXGBE_VT_CTL_POOL_MASK;
 247         IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, vmdctl);
 248         IXGBE_WRITE_FLUSH(hw);
 249
 250         /* Disable VMDq flag so device will be set in VM mode */
 251         if (adapter->ring_feature[RING_F_VMDQ].limit == 1)
 252                 adapter->flags &= ~IXGBE_FLAG_VMDQ_ENABLED;
 253         adapter->ring_feature[RING_F_VMDQ].offset = 0;
 254
 255         /* take a breather then clean up driver data */
 256         msleep(100);
 257
 258         adapter->flags &= ~IXGBE_FLAG_SRIOV_ENABLED;
 259 }
 260
 261 static int ixgbe_set_vf_multicasts(struct ixgbe_adapter *adapter,
 262                                    u32 *msgbuf, u32 vf)
 263 {
 264         int entries = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK)
 265                        >> IXGBE_VT_MSGINFO_SHIFT;
 266         u16 *hash_list = (u16 *)&msgbuf[1];
 267         struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
 268         struct ixgbe_hw *hw = &adapter->hw;
 269         int i;
 270         u32 vector_bit;
 271         u32 vector_reg;
 272         u32 mta_reg;
 273
 274         /* only so many hash values supported */
 275         entries = min(entries, IXGBE_MAX_VF_MC_ENTRIES);
 276
 277         /*
 278          * salt away the number of multi cast addresses assigned
 279          * to this VF for later use to restore when the PF multi cast
 280          * list changes
 281          */
 282         vfinfo->num_vf_mc_hashes = entries;
 283
 284         /*
 285          * VFs are limited to using the MTA hash table for their multicast
 286          * addresses
 287          */
 288         for (i = 0; i < entries; i++) {
 289                 vfinfo->vf_mc_hashes[i] = hash_list[i];
 290         }
 291
 292         for (i = 0; i < vfinfo->num_vf_mc_hashes; i++) {
 293                 vector_reg = (vfinfo->vf_mc_hashes[i] >> 5) & 0x7F;
 294                 vector_bit = vfinfo->vf_mc_hashes[i] & 0x1F;
 295                 mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
 296                 mta_reg |= (1 << vector_bit);
 297                 IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
 298         }
 299
 300         return 0;
 301 }
 302
 303 static void ixgbe_restore_vf_macvlans(struct ixgbe_adapter *adapter)
 304 {
 305         struct ixgbe_hw *hw = &adapter->hw;
 306         struct list_head *pos;
 307         struct vf_macvlans *entry;
 308
 309         list_for_each(pos, &adapter->vf_mvs.l) {
 310                 entry = list_entry(pos, struct vf_macvlans, l);
 311                 if (!entry->free)
 312                         hw->mac.ops.set_rar(hw, entry->rar_entry,
 313                                             entry->vf_macvlan,
 314                                             entry->vf, IXGBE_RAH_AV);
 315         }
 316 }
 317
 318 void ixgbe_restore_vf_multicasts(struct ixgbe_adapter *adapter)
 319 {
 320         struct ixgbe_hw *hw = &adapter->hw;
 321         struct vf_data_storage *vfinfo;
 322         int i, j;
 323         u32 vector_bit;
 324         u32 vector_reg;
 325         u32 mta_reg;
 326
 327         for (i = 0; i < adapter->num_vfs; i++) {
 328                 vfinfo = &adapter->vfinfo[i];
 329                 for (j = 0; j < vfinfo->num_vf_mc_hashes; j++) {
 330                         hw->addr_ctrl.mta_in_use++;
 331                         vector_reg = (vfinfo->vf_mc_hashes[j] >> 5) & 0x7F;
 332                         vector_bit = vfinfo->vf_mc_hashes[j] & 0x1F;
 333                         mta_reg = IXGBE_READ_REG(hw, IXGBE_MTA(vector_reg));
 334                         mta_reg |= (1 << vector_bit);
 335                         IXGBE_WRITE_REG(hw, IXGBE_MTA(vector_reg), mta_reg);
 336                 }
 337         }
 338
 339         /* Restore any VF macvlans */
 340         ixgbe_restore_vf_macvlans(adapter);
 341 }
 342
 343 static int ixgbe_set_vf_vlan(struct ixgbe_adapter *adapter, int add, int vid,
 344                              u32 vf)
 345 {
 346         /* VLAN 0 is a special case, don't allow it to be removed */
 347         if (!vid && !add)
 348                 return 0;
 349
 350         return adapter->hw.mac.ops.set_vfta(&adapter->hw, vid, vf, (bool)add);
 351 }
 352
 353 static s32 ixgbe_set_vf_lpe(struct ixgbe_adapter *adapter, u32 *msgbuf, u32 vf)
 354 {
 355         struct ixgbe_hw *hw = &adapter->hw;
 356         int max_frame = msgbuf[1];
 357         u32 max_frs;
 358
 359         /*
 360          * For 82599EB we have to keep all PFs and VFs operating with
 361          * the same max_frame value in order to avoid sending an oversize
 362          * frame to a VF.  In order to guarantee this is handled correctly
 363          * for all cases we have several special exceptions to take into
 364          * account before we can enable the VF for receive
 365          */
 366         if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
 367                 struct net_device *dev = adapter->netdev;
 368                 int pf_max_frame = dev->mtu + ETH_HLEN;
 369                 u32 reg_offset, vf_shift, vfre;
 370                 s32 err = 0;
 371
 372 #ifdef CONFIG_FCOE
 373                 if (dev->features & NETIF_F_FCOE_MTU)
 374                         pf_max_frame = max_t(int, pf_max_frame,
 375                                              IXGBE_FCOE_JUMBO_FRAME_SIZE);
 376
 377 #endif /* CONFIG_FCOE */
 378                 switch (adapter->vfinfo[vf].vf_api) {
 379                 case ixgbe_mbox_api_11:
 380                         /*
 381                          * Version 1.1 supports jumbo frames on VFs if PF has
 382                          * jumbo frames enabled which means legacy VFs are
 383                          * disabled
 384                          */
 385                         if (pf_max_frame > ETH_FRAME_LEN)
 386                                 break;
 387                 default:
 388                         /*
 389                          * If the PF or VF are running w/ jumbo frames enabled
 390                          * we need to shut down the VF Rx path as we cannot
 391                          * support jumbo frames on legacy VFs
 392                          */
 393                         if ((pf_max_frame > ETH_FRAME_LEN) ||
 394                             (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)))
 395                                 err = -EINVAL;
 396                         break;
 397                 }
 398
 399                 /* determine VF receive enable location */
 400                 vf_shift = vf % 32;
 401                 reg_offset = vf / 32;
 402
 403                 /* enable or disable receive depending on error */
 404                 vfre = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
 405                 if (err)
 406                         vfre &= ~(1 << vf_shift);
 407                 else
 408                         vfre |= 1 << vf_shift;
 409                 IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), vfre);
 410
 411                 if (err) {
 412                         e_err(drv, "VF max_frame %d out of range\n", max_frame);
 413                         return err;
 414                 }
 415         }
 416
 417         /* MTU < 68 is an error and causes problems on some kernels */
 418         if (max_frame > IXGBE_MAX_JUMBO_FRAME_SIZE) {
 419                 e_err(drv, "VF max_frame %d out of range\n", max_frame);
 420                 return -EINVAL;
 421         }
 422
 423         /* pull current max frame size from hardware */
 424         max_frs = IXGBE_READ_REG(hw, IXGBE_MAXFRS);
 425         max_frs &= IXGBE_MHADD_MFS_MASK;
 426         max_frs >>= IXGBE_MHADD_MFS_SHIFT;
 427
 428         if (max_frs < max_frame) {
 429                 max_frs = max_frame << IXGBE_MHADD_MFS_SHIFT;
 430                 IXGBE_WRITE_REG(hw, IXGBE_MAXFRS, max_frs);
 431         }
 432
 433         e_info(hw, "VF requests change max MTU to %d\n", max_frame);
 434
 435         return 0;
 436 }
 437
 438 static void ixgbe_set_vmolr(struct ixgbe_hw *hw, u32 vf, bool aupe)
 439 {
 440         u32 vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
 441         vmolr |= (IXGBE_VMOLR_ROMPE |
 442                   IXGBE_VMOLR_BAM);
 443         if (aupe)
 444                 vmolr |= IXGBE_VMOLR_AUPE;
 445         else
 446                 vmolr &= ~IXGBE_VMOLR_AUPE;
 447         IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
 448 }
 449
 450 static void ixgbe_set_vmvir(struct ixgbe_adapter *adapter,
 451                             u16 vid, u16 qos, u32 vf)
 452 {
 453         struct ixgbe_hw *hw = &adapter->hw;
 454         u32 vmvir = vid | (qos << VLAN_PRIO_SHIFT) | IXGBE_VMVIR_VLANA_DEFAULT;
 455
 456         IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), vmvir);
 457 }
 458
 459 static void ixgbe_clear_vmvir(struct ixgbe_adapter *adapter, u32 vf)
 460 {
 461         struct ixgbe_hw *hw = &adapter->hw;
 462
 463         IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), 0);
 464 }
 465 static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)
 466 {
 467         struct ixgbe_hw *hw = &adapter->hw;
 468         struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
 469         int rar_entry = hw->mac.num_rar_entries - (vf + 1);
 470         u8 num_tcs = netdev_get_num_tc(adapter->netdev);
 471
 472         /* add PF assigned VLAN or VLAN 0 */
 473         ixgbe_set_vf_vlan(adapter, true, vfinfo->pf_vlan, vf);
 474
 475         /* reset offloads to defaults */
 476         ixgbe_set_vmolr(hw, vf, !vfinfo->pf_vlan);
 477
 478         /* set outgoing tags for VFs */
 479         if (!vfinfo->pf_vlan && !vfinfo->pf_qos && !num_tcs) {
 480                 ixgbe_clear_vmvir(adapter, vf);
 481         } else {
 482                 if (vfinfo->pf_qos || !num_tcs)
 483                         ixgbe_set_vmvir(adapter, vfinfo->pf_vlan,
 484                                         vfinfo->pf_qos, vf);
 485                 else
 486                         ixgbe_set_vmvir(adapter, vfinfo->pf_vlan,
 487                                         adapter->default_up, vf);
 488
 489                 if (vfinfo->spoofchk_enabled)
 490                         hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
 491         }
 492
 493         /* reset multicast table array for vf */
 494         adapter->vfinfo[vf].num_vf_mc_hashes = 0;
 495
 496         /* Flush and reset the mta with the new values */
 497         ixgbe_set_rx_mode(adapter->netdev);
 498
 499         hw->mac.ops.clear_rar(hw, rar_entry);
 500
 501         /* reset VF api back to unknown */
 502         adapter->vfinfo[vf].vf_api = ixgbe_mbox_api_10;
 503 }
 504
 505 static int ixgbe_set_vf_mac(struct ixgbe_adapter *adapter,
 506                             int vf, unsigned char *mac_addr)
 507 {
 508         struct ixgbe_hw *hw = &adapter->hw;
 509         int rar_entry = hw->mac.num_rar_entries - (vf + 1);
 510
 511         memcpy(adapter->vfinfo[vf].vf_mac_addresses, mac_addr, 6);
 512         hw->mac.ops.set_rar(hw, rar_entry, mac_addr, vf, IXGBE_RAH_AV);
 513
 514         return 0;
 515 }
 516
 517 static int ixgbe_set_vf_macvlan(struct ixgbe_adapter *adapter,
 518                                 int vf, int index, unsigned char *mac_addr)
 519 {
 520         struct ixgbe_hw *hw = &adapter->hw;
 521         struct list_head *pos;
 522         struct vf_macvlans *entry;
 523
 524         if (index <= 1) {
 525                 list_for_each(pos, &adapter->vf_mvs.l) {
 526                         entry = list_entry(pos, struct vf_macvlans, l);
 527                         if (entry->vf == vf) {
 528                                 entry->vf = -1;
 529                                 entry->free = true;
 530                                 entry->is_macvlan = false;
 531                                 hw->mac.ops.clear_rar(hw, entry->rar_entry);
 532                         }
 533                 }
 534         }
 535
 536         /*
 537          * If index was zero then we were asked to clear the uc list
 538          * for the VF.  We're done.
 539          */
 540         if (!index)
 541                 return 0;
 542
 543         entry = NULL;
 544
 545         list_for_each(pos, &adapter->vf_mvs.l) {
 546                 entry = list_entry(pos, struct vf_macvlans, l);
 547                 if (entry->free)
 548                         break;
 549         }
 550
 551         /*
 552          * If we traversed the entire list and didn't find a free entry
 553          * then we're out of space on the RAR table.  Also entry may
 554          * be NULL because the original memory allocation for the list
 555          * failed, which is not fatal but does mean we can't support
 556          * VF requests for MACVLAN because we couldn't allocate
 557          * memory for the list management required.
 558          */
 559         if (!entry || !entry->free)
 560                 return -ENOSPC;
 561
 562         entry->free = false;
 563         entry->is_macvlan = true;
 564         entry->vf = vf;
 565         memcpy(entry->vf_macvlan, mac_addr, ETH_ALEN);
 566
 567         hw->mac.ops.set_rar(hw, entry->rar_entry, mac_addr, vf, IXGBE_RAH_AV);
 568
 569         return 0;
 570 }
 571
 572 int ixgbe_vf_configuration(struct pci_dev *pdev, unsigned int event_mask)
 573 {
 574         unsigned char vf_mac_addr[6];
 575         struct ixgbe_adapter *adapter = pci_get_drvdata(pdev);
 576         unsigned int vfn = (event_mask & 0x3f);
 577
 578         bool enable = ((event_mask & 0x10000000U) != 0);
 579
 580         if (enable) {
 581                 eth_random_addr(vf_mac_addr);
 582                 e_info(probe, "IOV: VF %d is enabled MAC %pM\n",
 583                        vfn, vf_mac_addr);
 584                 /*
 585                  * Store away the VF "permananet" MAC address, it will ask
 586                  * for it later.
 587                  */
 588                 memcpy(adapter->vfinfo[vfn].vf_mac_addresses, vf_mac_addr, 6);
 589         }
 590
 591         return 0;
 592 }
 593
 594 static int ixgbe_vf_reset_msg(struct ixgbe_adapter *adapter, u32 vf)
 595 {
 596         struct ixgbe_hw *hw = &adapter->hw;
 597         unsigned char *vf_mac = adapter->vfinfo[vf].vf_mac_addresses;
 598         u32 reg, msgbuf[4];
 599         u32 reg_offset, vf_shift;
 600         u8 *addr = (u8 *)(&msgbuf[1]);
 601
 602         e_info(probe, "VF Reset msg received from vf %d\n", vf);
 603
 604         /* reset the filters for the device */
 605         ixgbe_vf_reset_event(adapter, vf);
 606
 607         /* set vf mac address */
 608         ixgbe_set_vf_mac(adapter, vf, vf_mac);
 609
 610         vf_shift = vf % 32;
 611         reg_offset = vf / 32;
 612
 613         /* enable transmit for vf */
 614         reg = IXGBE_READ_REG(hw, IXGBE_VFTE(reg_offset));
 615         reg |= 1 << vf_shift;
 616         IXGBE_WRITE_REG(hw, IXGBE_VFTE(reg_offset), reg);
 617
 618         /* enable receive for vf */
 619         reg = IXGBE_READ_REG(hw, IXGBE_VFRE(reg_offset));
 620         reg |= 1 << vf_shift;
 621         /*
 622          * The 82599 cannot support a mix of jumbo and non-jumbo PF/VFs.
 623          * For more info take a look at ixgbe_set_vf_lpe
 624          */
 625         if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
 626                 struct net_device *dev = adapter->netdev;
 627                 int pf_max_frame = dev->mtu + ETH_HLEN;
 628
 629 #ifdef CONFIG_FCOE
 630                 if (dev->features & NETIF_F_FCOE_MTU)
 631                         pf_max_frame = max_t(int, pf_max_frame,
 632                                              IXGBE_FCOE_JUMBO_FRAME_SIZE);
 633
 634 #endif /* CONFIG_FCOE */
 635                 if (pf_max_frame > ETH_FRAME_LEN)
 636                         reg &= ~(1 << vf_shift);
 637         }
 638         IXGBE_WRITE_REG(hw, IXGBE_VFRE(reg_offset), reg);
 639
 640         /* enable VF mailbox for further messages */
 641         adapter->vfinfo[vf].clear_to_send = true;
 642
 643         /* Enable counting of spoofed packets in the SSVPC register */
 644         reg = IXGBE_READ_REG(hw, IXGBE_VMECM(reg_offset));
 645         reg |= (1 << vf_shift);
 646         IXGBE_WRITE_REG(hw, IXGBE_VMECM(reg_offset), reg);
 647
 648         /* reply to reset with ack and vf mac address */
 649         msgbuf[0] = IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK;
 650         memcpy(addr, vf_mac, ETH_ALEN);
 651
 652         /*
 653          * Piggyback the multicast filter type so VF can compute the
 654          * correct vectors
 655          */
 656         msgbuf[3] = hw->mac.mc_filter_type;
 657         ixgbe_write_mbx(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN, vf);
 658
 659         return 0;
 660 }
 661
 662 static int ixgbe_set_vf_mac_addr(struct ixgbe_adapter *adapter,
 663                                  u32 *msgbuf, u32 vf)
 664 {
 665         u8 *new_mac = ((u8 *)(&msgbuf[1]));
 666
 667         if (!is_valid_ether_addr(new_mac)) {
 668                 e_warn(drv, "VF %d attempted to set invalid mac\n", vf);
 669                 return -1;
 670         }
 671
 672         if (adapter->vfinfo[vf].pf_set_mac &&
 673             memcmp(adapter->vfinfo[vf].vf_mac_addresses, new_mac,
 674                    ETH_ALEN)) {
 675                 e_warn(drv,
 676                        "VF %d attempted to override administratively set MAC address\n"
 677                        "Reload the VF driver to resume operations\n",
 678                        vf);
 679                 return -1;
 680         }
 681
 682         return ixgbe_set_vf_mac(adapter, vf, new_mac) < 0;
 683 }
 684
 685 static int ixgbe_set_vf_vlan_msg(struct ixgbe_adapter *adapter,
 686                                  u32 *msgbuf, u32 vf)
 687 {
 688         struct ixgbe_hw *hw = &adapter->hw;
 689         int add = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK) >> IXGBE_VT_MSGINFO_SHIFT;
 690         int vid = (msgbuf[1] & IXGBE_VLVF_VLANID_MASK);
 691         int err;
 692         u8 tcs = netdev_get_num_tc(adapter->netdev);
 693
 694         if (adapter->vfinfo[vf].pf_vlan || tcs) {
 695                 e_warn(drv,
 696                        "VF %d attempted to override administratively set VLAN configuration\n"
 697                        "Reload the VF driver to resume operations\n",
 698                        vf);
 699                 return -1;
 700         }
 701
 702         if (add)
 703                 adapter->vfinfo[vf].vlan_count++;
 704         else if (adapter->vfinfo[vf].vlan_count)
 705                 adapter->vfinfo[vf].vlan_count--;
 706
 707         err = ixgbe_set_vf_vlan(adapter, add, vid, vf);
 708         if (!err && adapter->vfinfo[vf].spoofchk_enabled)
 709                 hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
 710
 711         return err;
 712 }
 713
 714 static int ixgbe_set_vf_macvlan_msg(struct ixgbe_adapter *adapter,
 715                                     u32 *msgbuf, u32 vf)
 716 {
 717         u8 *new_mac = ((u8 *)(&msgbuf[1]));
 718         int index = (msgbuf[0] & IXGBE_VT_MSGINFO_MASK) >>
 719                     IXGBE_VT_MSGINFO_SHIFT;
 720         int err;
 721
 722         if (adapter->vfinfo[vf].pf_set_mac && index > 0) {
 723                 e_warn(drv,
 724                        "VF %d requested MACVLAN filter but is administratively denied\n",
 725                        vf);
 726                 return -1;
 727         }
 728
 729         /* An non-zero index indicates the VF is setting a filter */
 730         if (index) {
 731                 if (!is_valid_ether_addr(new_mac)) {
 732                         e_warn(drv, "VF %d attempted to set invalid mac\n", vf);
 733                         return -1;
 734                 }
 735
 736                 /*
 737                  * If the VF is allowed to set MAC filters then turn off
 738                  * anti-spoofing to avoid false positives.
 739                  */
 740                 if (adapter->vfinfo[vf].spoofchk_enabled)
 741                         ixgbe_ndo_set_vf_spoofchk(adapter->netdev, vf, false);
 742         }
 743
 744         err = ixgbe_set_vf_macvlan(adapter, vf, index, new_mac);
 745         if (err == -ENOSPC)
 746                 e_warn(drv,
 747                        "VF %d has requested a MACVLAN filter but there is no space for it\n",
 748                        vf);
 749
 750         return err < 0;
 751 }
 752
 753 static int ixgbe_negotiate_vf_api(struct ixgbe_adapter *adapter,
 754                                   u32 *msgbuf, u32 vf)
 755 {
 756         int api = msgbuf[1];
 757
 758         switch (api) {
 759         case ixgbe_mbox_api_10:
 760         case ixgbe_mbox_api_11:
 761                 adapter->vfinfo[vf].vf_api = api;
 762                 return 0;
 763         default:
 764                 break;
 765         }
 766
 767         e_info(drv, "VF %d requested invalid api version %u\n", vf, api);
 768
 769         return -1;
 770 }
 771
 772 static int ixgbe_get_vf_queues(struct ixgbe_adapter *adapter,
 773                                u32 *msgbuf, u32 vf)
 774 {
 775         struct net_device *dev = adapter->netdev;
 776         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
 777         unsigned int default_tc = 0;
 778         u8 num_tcs = netdev_get_num_tc(dev);
 779
 780         /* verify the PF is supporting the correct APIs */
 781         switch (adapter->vfinfo[vf].vf_api) {
 782         case ixgbe_mbox_api_20:
 783         case ixgbe_mbox_api_11:
 784                 break;
 785         default:
 786                 return -1;
 787         }
 788
 789         /* only allow 1 Tx queue for bandwidth limiting */
 790         msgbuf[IXGBE_VF_TX_QUEUES] = __ALIGN_MASK(1, ~vmdq->mask);
 791         msgbuf[IXGBE_VF_RX_QUEUES] = __ALIGN_MASK(1, ~vmdq->mask);
 792
 793         /* if TCs > 1 determine which TC belongs to default user priority */
 794         if (num_tcs > 1)
 795                 default_tc = netdev_get_prio_tc_map(dev, adapter->default_up);
 796
 797         /* notify VF of need for VLAN tag stripping, and correct queue */
 798         if (num_tcs)
 799                 msgbuf[IXGBE_VF_TRANS_VLAN] = num_tcs;
 800         else if (adapter->vfinfo[vf].pf_vlan || adapter->vfinfo[vf].pf_qos)
 801                 msgbuf[IXGBE_VF_TRANS_VLAN] = 1;
 802         else
 803                 msgbuf[IXGBE_VF_TRANS_VLAN] = 0;
 804
 805         /* notify VF of default queue */
 806         msgbuf[IXGBE_VF_DEF_QUEUE] = default_tc;
 807
 808         return 0;
 809 }
 810
 811 static int ixgbe_rcv_msg_from_vf(struct ixgbe_adapter *adapter, u32 vf)
 812 {
 813         u32 mbx_size = IXGBE_VFMAILBOX_SIZE;
 814         u32 msgbuf[IXGBE_VFMAILBOX_SIZE];
 815         struct ixgbe_hw *hw = &adapter->hw;
 816         s32 retval;
 817
 818         retval = ixgbe_read_mbx(hw, msgbuf, mbx_size, vf);
 819
 820         if (retval) {
 821                 pr_err("Error receiving message from VF\n");
 822                 return retval;
 823         }
 824
 825         /* this is a message we already processed, do nothing */
 826         if (msgbuf[0] & (IXGBE_VT_MSGTYPE_ACK | IXGBE_VT_MSGTYPE_NACK))
 827                 return retval;
 828
 829         /* flush the ack before we write any messages back */
 830         IXGBE_WRITE_FLUSH(hw);
 831
 832         if (msgbuf[0] == IXGBE_VF_RESET)
 833                 return ixgbe_vf_reset_msg(adapter, vf);
 834
 835         /*
 836          * until the vf completes a virtual function reset it should not be
 837          * allowed to start any configuration.
 838          */
 839         if (!adapter->vfinfo[vf].clear_to_send) {
 840                 msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
 841                 ixgbe_write_mbx(hw, msgbuf, 1, vf);
 842                 return retval;
 843         }
 844
 845         switch ((msgbuf[0] & 0xFFFF)) {
 846         case IXGBE_VF_SET_MAC_ADDR:
 847                 retval = ixgbe_set_vf_mac_addr(adapter, msgbuf, vf);
 848                 break;
 849         case IXGBE_VF_SET_MULTICAST:
 850                 retval = ixgbe_set_vf_multicasts(adapter, msgbuf, vf);
 851                 break;
 852         case IXGBE_VF_SET_VLAN:
 853                 retval = ixgbe_set_vf_vlan_msg(adapter, msgbuf, vf);
 854                 break;
 855         case IXGBE_VF_SET_LPE:
 856                 retval = ixgbe_set_vf_lpe(adapter, msgbuf, vf);
 857                 break;
 858         case IXGBE_VF_SET_MACVLAN:
 859                 retval = ixgbe_set_vf_macvlan_msg(adapter, msgbuf, vf);
 860                 break;
 861         case IXGBE_VF_API_NEGOTIATE:
 862                 retval = ixgbe_negotiate_vf_api(adapter, msgbuf, vf);
 863                 break;
 864         case IXGBE_VF_GET_QUEUES:
 865                 retval = ixgbe_get_vf_queues(adapter, msgbuf, vf);
 866                 break;
 867         default:
 868                 e_err(drv, "Unhandled Msg %8.8x\n", msgbuf[0]);
 869                 retval = IXGBE_ERR_MBX;
 870                 break;
 871         }
 872
 873         /* notify the VF of the results of what it sent us */
 874         if (retval)
 875                 msgbuf[0] |= IXGBE_VT_MSGTYPE_NACK;
 876         else
 877                 msgbuf[0] |= IXGBE_VT_MSGTYPE_ACK;
 878
 879         msgbuf[0] |= IXGBE_VT_MSGTYPE_CTS;
 880
 881         ixgbe_write_mbx(hw, msgbuf, mbx_size, vf);
 882
 883         return retval;
 884 }
 885
 886 static void ixgbe_rcv_ack_from_vf(struct ixgbe_adapter *adapter, u32 vf)
 887 {
 888         struct ixgbe_hw *hw = &adapter->hw;
 889         u32 msg = IXGBE_VT_MSGTYPE_NACK;
 890
 891         /* if device isn't clear to send it shouldn't be reading either */
 892         if (!adapter->vfinfo[vf].clear_to_send)
 893                 ixgbe_write_mbx(hw, &msg, 1, vf);
 894 }
 895
 896 void ixgbe_msg_task(struct ixgbe_adapter *adapter)
 897 {
 898         struct ixgbe_hw *hw = &adapter->hw;
 899         u32 vf;
 900
 901         for (vf = 0; vf < adapter->num_vfs; vf++) {
 902                 /* process any reset requests */
 903                 if (!ixgbe_check_for_rst(hw, vf))
 904                         ixgbe_vf_reset_event(adapter, vf);
 905
 906                 /* process any messages pending */
 907                 if (!ixgbe_check_for_msg(hw, vf))
 908                         ixgbe_rcv_msg_from_vf(adapter, vf);
 909
 910                 /* process any acks */
 911                 if (!ixgbe_check_for_ack(hw, vf))
 912                         ixgbe_rcv_ack_from_vf(adapter, vf);
 913         }
 914 }
 915
 916 void ixgbe_disable_tx_rx(struct ixgbe_adapter *adapter)
 917 {
 918         struct ixgbe_hw *hw = &adapter->hw;
 919
 920         /* disable transmit and receive for all vfs */
 921         IXGBE_WRITE_REG(hw, IXGBE_VFTE(0), 0);
 922         IXGBE_WRITE_REG(hw, IXGBE_VFTE(1), 0);
 923
 924         IXGBE_WRITE_REG(hw, IXGBE_VFRE(0), 0);
 925         IXGBE_WRITE_REG(hw, IXGBE_VFRE(1), 0);
 926 }
 927
 928 void ixgbe_ping_all_vfs(struct ixgbe_adapter *adapter)
 929 {
 930         struct ixgbe_hw *hw = &adapter->hw;
 931         u32 ping;
 932         int i;
 933
 934         for (i = 0 ; i < adapter->num_vfs; i++) {
 935                 ping = IXGBE_PF_CONTROL_MSG;
 936                 if (adapter->vfinfo[i].clear_to_send)
 937                         ping |= IXGBE_VT_MSGTYPE_CTS;
 938                 ixgbe_write_mbx(hw, &ping, 1, i);
 939         }
 940 }
 941
 942 int ixgbe_ndo_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
 943 {
 944         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 945         if (!is_valid_ether_addr(mac) || (vf >= adapter->num_vfs))
 946                 return -EINVAL;
 947         adapter->vfinfo[vf].pf_set_mac = true;
 948         dev_info(&adapter->pdev->dev, "setting MAC %pM on VF %d\n", mac, vf);
 949         dev_info(&adapter->pdev->dev, "Reload the VF driver to make this"
 950                                       " change effective.");
 951         if (test_bit(__IXGBE_DOWN, &adapter->state)) {
 952                 dev_warn(&adapter->pdev->dev, "The VF MAC address has been set,"
 953                          " but the PF device is not up.\n");
 954                 dev_warn(&adapter->pdev->dev, "Bring the PF device up before"
 955                          " attempting to use the VF device.\n");
 956         }
 957         return ixgbe_set_vf_mac(adapter, vf, mac);
 958 }
 959
 960 int ixgbe_ndo_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
 961 {
 962         int err = 0;
 963         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 964         struct ixgbe_hw *hw = &adapter->hw;
 965
 966         if ((vf >= adapter->num_vfs) || (vlan > 4095) || (qos > 7))
 967                 return -EINVAL;
 968         if (vlan || qos) {
 969                 err = ixgbe_set_vf_vlan(adapter, true, vlan, vf);
 970                 if (err)
 971                         goto out;
 972                 ixgbe_set_vmvir(adapter, vlan, qos, vf);
 973                 ixgbe_set_vmolr(hw, vf, false);
 974                 if (adapter->vfinfo[vf].spoofchk_enabled)
 975                         hw->mac.ops.set_vlan_anti_spoofing(hw, true, vf);
 976                 adapter->vfinfo[vf].vlan_count++;
 977                 adapter->vfinfo[vf].pf_vlan = vlan;
 978                 adapter->vfinfo[vf].pf_qos = qos;
 979                 dev_info(&adapter->pdev->dev,
 980                          "Setting VLAN %d, QOS 0x%x on VF %d\n", vlan, qos, vf);
 981                 if (test_bit(__IXGBE_DOWN, &adapter->state)) {
 982                         dev_warn(&adapter->pdev->dev,
 983                                  "The VF VLAN has been set,"
 984                                  " but the PF device is not up.\n");
 985                         dev_warn(&adapter->pdev->dev,
 986                                  "Bring the PF device up before"
 987                                  " attempting to use the VF device.\n");
 988                 }
 989         } else {
 990                 err = ixgbe_set_vf_vlan(adapter, false,
 991                                         adapter->vfinfo[vf].pf_vlan, vf);
 992                 ixgbe_clear_vmvir(adapter, vf);
 993                 ixgbe_set_vmolr(hw, vf, true);
 994                 hw->mac.ops.set_vlan_anti_spoofing(hw, false, vf);
 995                 if (adapter->vfinfo[vf].vlan_count)
 996                         adapter->vfinfo[vf].vlan_count--;
 997                 adapter->vfinfo[vf].pf_vlan = 0;
 998                 adapter->vfinfo[vf].pf_qos = 0;
 999        }
1000 out:
1001        return err;
1002 }
1003
1004 static int ixgbe_link_mbps(struct ixgbe_adapter *adapter)
1005 {
1006         switch (adapter->link_speed) {
1007         case IXGBE_LINK_SPEED_100_FULL:
1008                 return 100;
1009         case IXGBE_LINK_SPEED_1GB_FULL:
1010                 return 1000;
1011         case IXGBE_LINK_SPEED_10GB_FULL:
1012                 return 10000;
1013         default:
1014                 return 0;
1015         }
1016 }
1017
1018 static void ixgbe_set_vf_rate_limit(struct ixgbe_adapter *adapter, int vf)
1019 {
1020         struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
1021         struct ixgbe_hw *hw = &adapter->hw;
1022         u32 bcnrc_val = 0;
1023         u16 queue, queues_per_pool;
1024         u16 tx_rate = adapter->vfinfo[vf].tx_rate;
1025
1026         if (tx_rate) {
1027                 /* start with base link speed value */
1028                 bcnrc_val = adapter->vf_rate_link_speed;
1029
1030                 /* Calculate the rate factor values to set */
1031                 bcnrc_val <<= IXGBE_RTTBCNRC_RF_INT_SHIFT;
1032                 bcnrc_val /= tx_rate;
1033
1034                 /* clear everything but the rate factor */
1035                 bcnrc_val &= IXGBE_RTTBCNRC_RF_INT_MASK |
1036                              IXGBE_RTTBCNRC_RF_DEC_MASK;
1037
1038                 /* enable the rate scheduler */
1039                 bcnrc_val |= IXGBE_RTTBCNRC_RS_ENA;
1040         }
1041
1042         /*
1043          * Set global transmit compensation time to the MMW_SIZE in RTTBCNRM
1044          * register. Typically MMW_SIZE=0x014 if 9728-byte jumbo is supported
1045          * and 0x004 otherwise.
1046          */
1047         switch (hw->mac.type) {
1048         case ixgbe_mac_82599EB:
1049                 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRM, 0x4);
1050                 break;
1051         case ixgbe_mac_X540:
1052                 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRM, 0x14);
1053                 break;
1054         default:
1055                 break;
1056         }
1057
1058         /* determine how many queues per pool based on VMDq mask */
1059         queues_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
1060
1061         /* write value for all Tx queues belonging to VF */
1062         for (queue = 0; queue < queues_per_pool; queue++) {
1063                 unsigned int reg_idx = (vf * queues_per_pool) + queue;
1064
1065                 IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, reg_idx);
1066                 IXGBE_WRITE_REG(hw, IXGBE_RTTBCNRC, bcnrc_val);
1067         }
1068 }
1069
1070 void ixgbe_check_vf_rate_limit(struct ixgbe_adapter *adapter)
1071 {
1072         int i;
1073
1074         /* VF Tx rate limit was not set */
1075         if (!adapter->vf_rate_link_speed)
1076                 return;
1077
1078         if (ixgbe_link_mbps(adapter) != adapter->vf_rate_link_speed) {
1079                 adapter->vf_rate_link_speed = 0;
1080                 dev_info(&adapter->pdev->dev,
1081                          "Link speed has been changed. VF Transmit rate is disabled\n");
1082         }
1083
1084         for (i = 0; i < adapter->num_vfs; i++) {
1085                 if (!adapter->vf_rate_link_speed)
1086                         adapter->vfinfo[i].tx_rate = 0;
1087
1088                 ixgbe_set_vf_rate_limit(adapter, i);
1089         }
1090 }
1091
1092 int ixgbe_ndo_set_vf_bw(struct net_device *netdev, int vf, int tx_rate)
1093 {
1094         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1095         int link_speed;
1096
1097         /* verify VF is active */
1098         if (vf >= adapter->num_vfs)
1099                 return -EINVAL;
1100
1101         /* verify link is up */
1102         if (!adapter->link_up)
1103                 return -EINVAL;
1104
1105         /* verify we are linked at 10Gbps */
1106         link_speed = ixgbe_link_mbps(adapter);
1107         if (link_speed != 10000)
1108                 return -EINVAL;
1109
1110         /* rate limit cannot be less than 10Mbs or greater than link speed */
1111         if (tx_rate && ((tx_rate <= 10) || (tx_rate > link_speed)))
1112                 return -EINVAL;
1113
1114         /* store values */
1115         adapter->vf_rate_link_speed = link_speed;
1116         adapter->vfinfo[vf].tx_rate = tx_rate;
1117
1118         /* update hardware configuration */
1119         ixgbe_set_vf_rate_limit(adapter, vf);
1120
1121         return 0;
1122 }
1123
1124 int ixgbe_ndo_set_vf_spoofchk(struct net_device *netdev, int vf, bool setting)
1125 {
1126         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1127         int vf_target_reg = vf >> 3;
1128         int vf_target_shift = vf % 8;
1129         struct ixgbe_hw *hw = &adapter->hw;
1130         u32 regval;
1131
1132         adapter->vfinfo[vf].spoofchk_enabled = setting;
1133
1134         regval = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg));
1135         regval &= ~(1 << vf_target_shift);
1136         regval |= (setting << vf_target_shift);
1137         IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), regval);
1138
1139         if (adapter->vfinfo[vf].vlan_count) {
1140                 vf_target_shift += IXGBE_SPOOF_VLANAS_SHIFT;
1141                 regval = IXGBE_READ_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg));
1142                 regval &= ~(1 << vf_target_shift);
1143                 regval |= (setting << vf_target_shift);
1144                 IXGBE_WRITE_REG(hw, IXGBE_PFVFSPOOF(vf_target_reg), regval);
1145         }
1146
1147         return 0;
1148 }
1149
1150 int ixgbe_ndo_get_vf_config(struct net_device *netdev,
1151                             int vf, struct ifla_vf_info *ivi)
1152 {
1153         struct ixgbe_adapter *adapter = netdev_priv(netdev);
1154         if (vf >= adapter->num_vfs)
1155                 return -EINVAL;
1156         ivi->vf = vf;
1157         memcpy(&ivi->mac, adapter->vfinfo[vf].vf_mac_addresses, ETH_ALEN);
1158         ivi->tx_rate = adapter->vfinfo[vf].tx_rate;
1159         ivi->vlan = adapter->vfinfo[vf].pf_vlan;
1160         ivi->qos = adapter->vfinfo[vf].pf_qos;
1161         ivi->spoofchk = adapter->vfinfo[vf].spoofchk_enabled;
1162         return 0;
1163 }