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