D11727.1794128053.diff
No OneTemporary
Actions

Authored By

Unknown

Size

368 KB

Referenced Files

None

Subscribers

None

D11727.1794128053.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	Index: sys/conf/files
	===================================================================
	--- sys/conf/files
	+++ sys/conf/files
	@@ -2202,11 +2202,9 @@
	compile-with "${NORMAL_C} -I$S/dev/ixgbe -DSMP"
	dev/ixgbe/if_bypass.c optional ix inet \
	compile-with "${NORMAL_C} -I$S/dev/ixgbe"
	-dev/ixgbe/ixgbe_netmap.c optional ix inet \
	- compile-with "${NORMAL_C} -I$S/dev/ixgbe"
	dev/ixgbe/if_fdir.c optional ix inet \| ixv inet \
	compile-with "${NORMAL_C} -I$S/dev/ixgbe"
	-dev/ixgbe/if_sriov.c optional ix inet \| ixv inet \
	+dev/ixgbe/if_sriov.c optional ix inet \
	compile-with "${NORMAL_C} -I$S/dev/ixgbe"
	dev/ixgbe/ix_txrx.c optional ix inet \| ixv inet \
	compile-with "${NORMAL_C} -I$S/dev/ixgbe"
	Index: sys/dev/ixgbe/if_bypass.c
	===================================================================
	--- sys/dev/ixgbe/if_bypass.c
	+++ sys/dev/ixgbe/if_bypass.c
	@@ -165,12 +165,12 @@
	error = hw->mac.ops.bypass_rw(hw,
	BYPASS_PAGE_CTL0, &state);
	ixgbe_bypass_mutex_clear(adapter);
	- if (error)
	+ if (error != 0)
	return (error);
	state = (state >> BYPASS_STATUS_OFF_SHIFT) & 0x3;

	error = sysctl_handle_int(oidp, &state, 0, req);
	- if ((error) \|\| (req->newptr == NULL))
	+ if ((error != 0) \|\| (req->newptr == NULL))
	return (error);

	/* Sanity check new state */
	@@ -437,7 +437,7 @@
	struct ixgbe_hw *hw = &adapter->hw;
	int error, tmp;
	static int timeout = 0;
	- u32 mask, arg = BYPASS_PAGE_CTL0;
	+ u32 mask, arg;

	/* Get the current hardware value */
	ixgbe_bypass_mutex_enter(adapter);
	@@ -456,48 +456,38 @@
	if ((error) \|\| (req->newptr == NULL))
	return (error);

	- mask = BYPASS_WDT_ENABLE_M;
	+ arg = 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	+ mask = BYPASS_WDT_ENABLE_M \| BYPASS_WDT_VALUE_M;
	switch (timeout) {
	- case 0: /* disables the timer */
	- break;
	- case 1:
	- arg = BYPASS_WDT_1_5 << BYPASS_WDT_TIME_SHIFT;
	- arg \|= 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	- mask \|= BYPASS_WDT_VALUE_M;
	- break;
	- case 2:
	- arg = BYPASS_WDT_2 << BYPASS_WDT_TIME_SHIFT;
	- arg \|= 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	- mask \|= BYPASS_WDT_VALUE_M;
	- break;
	- case 3:
	- arg = BYPASS_WDT_3 << BYPASS_WDT_TIME_SHIFT;
	- arg \|= 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	- mask \|= BYPASS_WDT_VALUE_M;
	- break;
	- case 4:
	- arg = BYPASS_WDT_4 << BYPASS_WDT_TIME_SHIFT;
	- arg \|= 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	- mask \|= BYPASS_WDT_VALUE_M;
	- break;
	- case 8:
	- arg = BYPASS_WDT_8 << BYPASS_WDT_TIME_SHIFT;
	- arg \|= 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	- mask \|= BYPASS_WDT_VALUE_M;
	- break;
	- case 16:
	- arg = BYPASS_WDT_16 << BYPASS_WDT_TIME_SHIFT;
	- arg \|= 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	- mask \|= BYPASS_WDT_VALUE_M;
	- break;
	- case 32:
	- arg = BYPASS_WDT_32 << BYPASS_WDT_TIME_SHIFT;
	- arg \|= 0x1 << BYPASS_WDT_ENABLE_SHIFT;
	- mask \|= BYPASS_WDT_VALUE_M;
	- break;
	- default:
	- return (EINVAL);
	+ case 0: /* disables the timer */
	+ arg = BYPASS_PAGE_CTL0;
	+ mask = BYPASS_WDT_ENABLE_M;
	+ break;
	+ case 1:
	+ arg \|= BYPASS_WDT_1_5 << BYPASS_WDT_TIME_SHIFT;
	+ break;
	+ case 2:
	+ arg \|= BYPASS_WDT_2 << BYPASS_WDT_TIME_SHIFT;
	+ break;
	+ case 3:
	+ arg \|= BYPASS_WDT_3 << BYPASS_WDT_TIME_SHIFT;
	+ break;
	+ case 4:
	+ arg \|= BYPASS_WDT_4 << BYPASS_WDT_TIME_SHIFT;
	+ break;
	+ case 8:
	+ arg \|= BYPASS_WDT_8 << BYPASS_WDT_TIME_SHIFT;
	+ break;
	+ case 16:
	+ arg \|= BYPASS_WDT_16 << BYPASS_WDT_TIME_SHIFT;
	+ break;
	+ case 32:
	+ arg \|= BYPASS_WDT_32 << BYPASS_WDT_TIME_SHIFT;
	+ break;
	+ default:
	+ return (EINVAL);
	}
	+
	/* Set the new watchdog */
	ixgbe_bypass_mutex_enter(adapter);
	error = hw->mac.ops.bypass_set(hw, BYPASS_PAGE_CTL0, mask, arg);
	@@ -541,7 +531,8 @@
	error = IXGBE_BYPASS_FW_WRITE_FAILURE;
	break;
	}
	- if (hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL1, &reset_wd)) {
	+ error = hw->mac.ops.bypass_rw(hw, BYPASS_PAGE_CTL1, &reset_wd);
	+ if (error != 0) {
	error = IXGBE_ERR_INVALID_ARGUMENT;
	break;
	}
	@@ -615,7 +606,7 @@
	&data);
	ixgbe_bypass_mutex_clear(adapter);
	if (error)
	- return (-EINVAL);
	+ return (EINVAL);
	eeprom[count].logs += data << (8 * i);
	}

	@@ -624,7 +615,7 @@
	log_off + i, &eeprom[count].actions);
	ixgbe_bypass_mutex_clear(adapter);
	if (error)
	- return (-EINVAL);
	+ return (EINVAL);

	/* Quit if not a unread log */
	if (!(eeprom[count].logs & BYPASS_LOG_CLEAR_M))
	@@ -696,21 +687,21 @@
	ixgbe_bypass_mutex_clear(adapter);

	if (error)
	- return (-EINVAL);
	+ return (EINVAL);
	}

	status = 0; /* reset */
	/* Another log command can now run */
	while (atomic_cmpset_int(&adapter->bypass.log, 1, 0) == 0)
	usec_delay(3000);
	- return(error);
	+ return (error);

	unlock_err:
	ixgbe_bypass_mutex_clear(adapter);
	status = 0; /* reset */
	while (atomic_cmpset_int(&adapter->bypass.log, 1, 0) == 0)
	usec_delay(3000);
	- return (-EINVAL);
	+ return (EINVAL);
	} /* ixgbe_bp_log */

	/************************************************************************
	@@ -802,7 +793,5 @@
	adapter, 0, ixgbe_bp_wd_reset, "S", "Bypass WD Reset");

	adapter->feat_en \|= IXGBE_FEATURE_BYPASS;
	-
	- return;
	} /* ixgbe_bypass_init */

	Index: sys/dev/ixgbe/if_fdir.c
	===================================================================
	--- sys/dev/ixgbe/if_fdir.c
	+++ sys/dev/ixgbe/if_fdir.c
	@@ -50,10 +50,11 @@
	} /* ixgbe_init_fdir */

	void
	-ixgbe_reinit_fdir(void *context, int pending)
	+ixgbe_reinit_fdir(void *context)
	{
	- struct adapter *adapter = context;
	- struct ifnet *ifp = adapter->ifp;
	+ if_ctx_t ctx = context;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ifnet *ifp = iflib_get_ifp(ctx);

	if (!(adapter->feat_en & IXGBE_FEATURE_FDIR))
	return;
	@@ -146,9 +147,9 @@

	/* TASK_INIT needs this function defined regardless if it's enabled */
	void
	-ixgbe_reinit_fdir(void *context, int pending)
	+ixgbe_reinit_fdir(void *context)
	{
	- UNREFERENCED_2PARAMETER(context, pending);
	+ UNREFERENCED_PARAMETER(context);
	} /* ixgbe_reinit_fdir */

	void
	Index: sys/dev/ixgbe/if_ix.c
	===================================================================
	--- sys/dev/ixgbe/if_ix.c
	+++ sys/dev/ixgbe/if_ix.c
	@@ -33,13 +33,16 @@
	/$FreeBSD$/


	-#ifndef IXGBE_STANDALONE_BUILD
	#include "opt_inet.h"
	#include "opt_inet6.h"
	#include "opt_rss.h"
	-#endif

	#include "ixgbe.h"
	+#include "ixgbe_sriov.h"
	+#include "ifdi_if.h"
	+
	+#include <net/netmap.h>
	+#include <dev/netmap/netmap_kern.h>

	/************************************************************************
	* Driver version
	@@ -56,180 +59,175 @@
	*
	* { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
	************************************************************************/
	-static ixgbe_vendor_info_t ixgbe_vendor_info_array[] =
	+static pci_vendor_info_t ixgbe_vendor_info_array[] =
	{
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_DUAL_PORT, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_SINGLE_PORT, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_CX4, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT2, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_DA_DUAL_PORT, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_CX4_DUAL_PORT, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_XF_LR, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_SFP_LOM, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4_MEZZ, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_XAUI_LOM, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_CX4, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_T3_LOM, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_COMBO_BACKPLANE, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BACKPLANE_FCOE, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF2, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_FCOE, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599EN_SFP, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF_QP, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_QSFP_SF_QP, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T1, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T1, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KR, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KX4, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_10G_T, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_1G_T, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_SFP, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR_L, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP_N, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII_L, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_10G_T, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T_L, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_BYPASS, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BYPASS, 0, 0, 0},
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_DUAL_PORT, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AF_SINGLE_PORT, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_CX4, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598AT2, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_DA_DUAL_PORT, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_CX4_DUAL_PORT, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_XF_LR, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82598EB_SFP_LOM, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_KX4_MEZZ, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_XAUI_LOM, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_CX4, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_T3_LOM, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_COMBO_BACKPLANE, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BACKPLANE_FCOE, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF2, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_FCOE, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599EN_SFP, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_SFP_SF_QP, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_QSFP_SF_QP, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540T1, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550T1, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KR, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_KX4, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_10G_T, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_SFP, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_KR_L, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SFP_N, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_SGMII_L, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_10G_T, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_1G_T_L, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_BYPASS, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_BYPASS, "Intel(R) PRO/10GbE PCI-Express Network Driver"),
	/* required last entry */
	- {0, 0, 0, 0, 0}
	+ PVID_END
	};

	-/************************************************************************
	- * Table of branding strings
	- ************************************************************************/
	-static char *ixgbe_strings[] = {
	- "Intel(R) PRO/10GbE PCI-Express Network Driver"
	-};
	+static void *ixgbe_register(device_t dev);
	+static int ixgbe_if_attach_pre(if_ctx_t ctx);
	+static int ixgbe_if_attach_post(if_ctx_t ctx);
	+static int ixgbe_if_detach(if_ctx_t ctx);
	+static int ixgbe_if_shutdown(if_ctx_t ctx);
	+static int ixgbe_if_suspend(if_ctx_t ctx);
	+static int ixgbe_if_resume(if_ctx_t ctx);
	+
	+static void ixgbe_if_stop(if_ctx_t ctx);
	+void ixgbe_if_enable_intr(if_ctx_t ctx);
	+static void ixgbe_if_disable_intr(if_ctx_t ctx);
	+static int ixgbe_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid);
	+static void ixgbe_if_media_status(if_ctx_t ctx, struct ifmediareq * ifmr);
	+static int ixgbe_if_media_change(if_ctx_t ctx);
	+static int ixgbe_if_msix_intr_assign(if_ctx_t, int);
	+static int ixgbe_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
	+static void ixgbe_if_crcstrip_set(if_ctx_t ctx, int onoff, int strip);
	+static void ixgbe_if_multi_set(if_ctx_t ctx);
	+static int ixgbe_if_promisc_set(if_ctx_t ctx, int flags);
	+static int ixgbe_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
	+ uint64_t *paddrs, int nrxqs, int nrxqsets);
	+static int ixgbe_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
	+ uint64_t *paddrs, int nrxqs, int nrxqsets);
	+static void ixgbe_if_queues_free(if_ctx_t ctx);
	+static void ixgbe_if_timer(if_ctx_t ctx, uint16_t);
	+static void ixgbe_if_update_admin_status(if_ctx_t ctx);
	+static void ixgbe_if_vlan_register(if_ctx_t ctx, u16 vtag);
	+static void ixgbe_if_vlan_unregister(if_ctx_t ctx, u16 vtag);
	+
	+int ixgbe_intr(void *arg);

	/************************************************************************
	* Function prototypes
	************************************************************************/
	-static int ixgbe_probe(device_t);
	-static int ixgbe_attach(device_t);
	-static int ixgbe_detach(device_t);
	-static int ixgbe_shutdown(device_t);
	-static int ixgbe_suspend(device_t);
	-static int ixgbe_resume(device_t);
	-static int ixgbe_ioctl(struct ifnet *, u_long, caddr_t);
	-static void ixgbe_init(void *);
	-static void ixgbe_init_locked(struct adapter *);
	-static void ixgbe_stop(void *);
	#if __FreeBSD_version >= 1100036
	-static uint64_t ixgbe_get_counter(struct ifnet *, ift_counter);
	+static uint64_t ixgbe_if_get_counter(if_ctx_t, ift_counter);
	#endif
	-static void ixgbe_init_device_features(struct adapter *);
	-static void ixgbe_check_fan_failure(struct adapter *, u32, bool);
	-static void ixgbe_add_media_types(struct adapter *);
	-static void ixgbe_media_status(struct ifnet , struct ifmediareq );
	-static int ixgbe_media_change(struct ifnet *);
	-static int ixgbe_allocate_pci_resources(struct adapter *);
	-static void ixgbe_get_slot_info(struct adapter *);
	-static int ixgbe_allocate_msix(struct adapter *);
	-static int ixgbe_allocate_legacy(struct adapter *);
	-static int ixgbe_configure_interrupts(struct adapter *);
	-static void ixgbe_free_pci_resources(struct adapter *);
	-static void ixgbe_local_timer(void *);
	-static int ixgbe_setup_interface(device_t, struct adapter *);
	-static void ixgbe_config_gpie(struct adapter *);
	-static void ixgbe_config_dmac(struct adapter *);
	-static void ixgbe_config_delay_values(struct adapter *);
	-static void ixgbe_config_link(struct adapter *);
	-static void ixgbe_check_wol_support(struct adapter *);
	-static int ixgbe_setup_low_power_mode(struct adapter *);
	-static void ixgbe_rearm_queues(struct adapter *, u64);
	-
	-static void ixgbe_initialize_transmit_units(struct adapter *);
	-static void ixgbe_initialize_receive_units(struct adapter *);
	-static void ixgbe_enable_rx_drop(struct adapter *);
	-static void ixgbe_disable_rx_drop(struct adapter *);
	-static void ixgbe_initialize_rss_mapping(struct adapter *);
	-
	-static void ixgbe_enable_intr(struct adapter *);
	-static void ixgbe_disable_intr(struct adapter *);
	-static void ixgbe_update_stats_counters(struct adapter *);
	-static void ixgbe_set_promisc(struct adapter *);
	-static void ixgbe_set_multi(struct adapter *);
	-static void ixgbe_update_link_status(struct adapter *);
	-static void ixgbe_set_ivar(struct adapter *, u8, u8, s8);
	-static void ixgbe_configure_ivars(struct adapter *);
	-static u8 ixgbe_mc_array_itr(struct ixgbe_hw , u8 *, u32 );
	-
	-static void ixgbe_setup_vlan_hw_support(struct adapter *);
	-static void ixgbe_register_vlan(void , struct ifnet , u16);
	-static void ixgbe_unregister_vlan(void , struct ifnet , u16);
	-
	-static void ixgbe_add_device_sysctls(struct adapter *);
	-static void ixgbe_add_hw_stats(struct adapter *);
	-static int ixgbe_set_flowcntl(struct adapter *, int);
	-static int ixgbe_set_advertise(struct adapter *, int);
	-static int ixgbe_get_advertise(struct adapter *);
	+
	+static void ixgbe_enable_queue(struct adapter *adapter, u32 vector);
	+static void ixgbe_disable_queue(struct adapter *adapter, u32 vector);
	+static void ixgbe_add_device_sysctls(if_ctx_t ctx);
	+static int ixgbe_allocate_pci_resources(if_ctx_t ctx);
	+static int ixgbe_setup_low_power_mode(if_ctx_t ctx);
	+
	+static void ixgbe_config_dmac(struct adapter *adapter);
	+static void ixgbe_configure_ivars(struct adapter *adapter);
	+static void ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector,
	+ s8 type);
	+static u8 ixgbe_mc_array_itr(struct ixgbe_hw , u8 *, u32 );
	+static bool ixgbe_sfp_probe(if_ctx_t ctx);
	+
	+static void ixgbe_free_pci_resources(if_ctx_t ctx);
	+
	+static int ixgbe_msix_link(void *arg);
	+static int ixgbe_msix_que(void *arg);
	+static void ixgbe_initialize_rss_mapping(struct adapter *adapter);
	+static void ixgbe_initialize_receive_units(if_ctx_t ctx);
	+static void ixgbe_initialize_transmit_units(if_ctx_t ctx);
	+
	+static int ixgbe_setup_interface(if_ctx_t ctx);
	+static void ixgbe_init_device_features(struct adapter *adapter);
	+static void ixgbe_check_fan_failure(struct adapter *, u32, bool);
	+static void ixgbe_add_media_types(if_ctx_t ctx);
	+static void ixgbe_update_stats_counters(struct adapter *adapter);
	+static void ixgbe_config_link(struct adapter *adapter);
	+static void ixgbe_get_slot_info(struct adapter *);
	+static void ixgbe_check_wol_support(struct adapter *adapter);
	+static void ixgbe_enable_rx_drop(struct adapter *);
	+static void ixgbe_disable_rx_drop(struct adapter *);
	+
	+static void ixgbe_add_hw_stats(struct adapter *adapter);
	+static int ixgbe_set_flowcntl(struct adapter *, int);
	+static int ixgbe_set_advertise(struct adapter *, int);
	+static int ixgbe_get_advertise(struct adapter *);
	+static void ixgbe_setup_vlan_hw_support(if_ctx_t ctx);
	+static void ixgbe_config_gpie(struct adapter *adapter);
	+static void ixgbe_config_delay_values(struct adapter *adapter);

	/* Sysctl handlers */
	-static void ixgbe_set_sysctl_value(struct adapter , const char ,
	- const char , int , int);
	-static int ixgbe_sysctl_flowcntl(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_advertise(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_interrupt_rate_handler(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_dmac(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_phy_temp(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_phy_overtemp_occurred(SYSCTL_HANDLER_ARGS);
	+static void ixgbe_set_sysctl_value(struct adapter , const char ,
	+ const char , int , int);
	+static int ixgbe_sysctl_flowcntl(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_advertise(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_interrupt_rate_handler(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_dmac(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_phy_temp(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_phy_overtemp_occurred(SYSCTL_HANDLER_ARGS);
	#ifdef IXGBE_DEBUG
	-static int ixgbe_sysctl_power_state(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_print_rss_config(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_power_state(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_print_rss_config(SYSCTL_HANDLER_ARGS);
	#endif
	-static int ixgbe_sysctl_rdh_handler(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_rdt_handler(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_tdt_handler(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_tdh_handler(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_eee_state(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_wol_enable(SYSCTL_HANDLER_ARGS);
	-static int ixgbe_sysctl_wufc(SYSCTL_HANDLER_ARGS);
	-
	-/* Support for pluggable optic modules */
	-static bool ixgbe_sfp_probe(struct adapter *);
	-
	-/* Legacy (single vector) interrupt handler */
	-static void ixgbe_legacy_irq(void *);
	-
	-/* The MSI/MSI-X Interrupt handlers */
	-static void ixgbe_msix_que(void *);
	-static void ixgbe_msix_link(void *);
	+static int ixgbe_sysctl_rdh_handler(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_rdt_handler(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_tdt_handler(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_tdh_handler(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_eee_state(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_wol_enable(SYSCTL_HANDLER_ARGS);
	+static int ixgbe_sysctl_wufc(SYSCTL_HANDLER_ARGS);

	/* Deferred interrupt tasklets */
	-static void ixgbe_handle_que(void *, int);
	-static void ixgbe_handle_link(void *, int);
	-static void ixgbe_handle_msf(void *, int);
	-static void ixgbe_handle_mod(void *, int);
	-static void ixgbe_handle_phy(void *, int);
	-
	+static void ixgbe_handle_msf(void *);
	+static void ixgbe_handle_mod(void *);
	+static void ixgbe_handle_phy(void *);

	/************************************************************************
	* FreeBSD Device Interface Entry Points
	************************************************************************/
	static device_method_t ix_methods[] = {
	/* Device interface */
	- DEVMETHOD(device_probe, ixgbe_probe),
	- DEVMETHOD(device_attach, ixgbe_attach),
	- DEVMETHOD(device_detach, ixgbe_detach),
	- DEVMETHOD(device_shutdown, ixgbe_shutdown),
	- DEVMETHOD(device_suspend, ixgbe_suspend),
	- DEVMETHOD(device_resume, ixgbe_resume),
	+ DEVMETHOD(device_register, ixgbe_register),
	+ DEVMETHOD(device_probe, iflib_device_probe),
	+ DEVMETHOD(device_attach, iflib_device_attach),
	+ DEVMETHOD(device_detach, iflib_device_detach),
	+ DEVMETHOD(device_shutdown, iflib_device_shutdown),
	+ DEVMETHOD(device_suspend, iflib_device_suspend),
	+ DEVMETHOD(device_resume, iflib_device_resume),
	#ifdef PCI_IOV
	- DEVMETHOD(pci_iov_init, ixgbe_init_iov),
	- DEVMETHOD(pci_iov_uninit, ixgbe_uninit_iov),
	- DEVMETHOD(pci_iov_add_vf, ixgbe_add_vf),
	+ DEVMETHOD(pci_iov_init, iflib_device_iov_init),
	+ DEVMETHOD(pci_iov_uninit, iflib_device_iov_uninit),
	+ DEVMETHOD(pci_iov_add_vf, iflib_device_iov_add_vf),
	#endif /* PCI_IOV */
	DEVMETHOD_END
	};
	@@ -243,15 +241,52 @@

	MODULE_DEPEND(ix, pci, 1, 1, 1);
	MODULE_DEPEND(ix, ether, 1, 1, 1);
	-#ifdef DEV_NETMAP
	-MODULE_DEPEND(ix, netmap, 1, 1, 1);
	-#endif
	+MODULE_DEPEND(ix, iflib, 1, 1, 1);
	+
	+static device_method_t ixgbe_if_methods[] = {
	+ DEVMETHOD(ifdi_attach_pre, ixgbe_if_attach_pre),
	+ DEVMETHOD(ifdi_attach_post, ixgbe_if_attach_post),
	+ DEVMETHOD(ifdi_detach, ixgbe_if_detach),
	+ DEVMETHOD(ifdi_shutdown, ixgbe_if_shutdown),
	+ DEVMETHOD(ifdi_suspend, ixgbe_if_suspend),
	+ DEVMETHOD(ifdi_resume, ixgbe_if_resume),
	+ DEVMETHOD(ifdi_init, ixgbe_if_init),
	+ DEVMETHOD(ifdi_stop, ixgbe_if_stop),
	+ DEVMETHOD(ifdi_msix_intr_assign, ixgbe_if_msix_intr_assign),
	+ DEVMETHOD(ifdi_intr_enable, ixgbe_if_enable_intr),
	+ DEVMETHOD(ifdi_intr_disable, ixgbe_if_disable_intr),
	+ DEVMETHOD(ifdi_tx_queue_intr_enable, ixgbe_if_rx_queue_intr_enable),
	+ DEVMETHOD(ifdi_rx_queue_intr_enable, ixgbe_if_rx_queue_intr_enable),
	+ DEVMETHOD(ifdi_tx_queues_alloc, ixgbe_if_tx_queues_alloc),
	+ DEVMETHOD(ifdi_rx_queues_alloc, ixgbe_if_rx_queues_alloc),
	+ DEVMETHOD(ifdi_queues_free, ixgbe_if_queues_free),
	+ DEVMETHOD(ifdi_update_admin_status, ixgbe_if_update_admin_status),
	+ DEVMETHOD(ifdi_multi_set, ixgbe_if_multi_set),
	+ DEVMETHOD(ifdi_mtu_set, ixgbe_if_mtu_set),
	+ DEVMETHOD(ifdi_crcstrip_set, ixgbe_if_crcstrip_set),
	+ DEVMETHOD(ifdi_media_status, ixgbe_if_media_status),
	+ DEVMETHOD(ifdi_media_change, ixgbe_if_media_change),
	+ DEVMETHOD(ifdi_promisc_set, ixgbe_if_promisc_set),
	+ DEVMETHOD(ifdi_timer, ixgbe_if_timer),
	+ DEVMETHOD(ifdi_vlan_register, ixgbe_if_vlan_register),
	+ DEVMETHOD(ifdi_vlan_unregister, ixgbe_if_vlan_unregister),
	+ DEVMETHOD(ifdi_get_counter, ixgbe_if_get_counter),
	+#ifdef PCI_IOV
	+ DEVMETHOD(ifdi_iov_init, ixgbe_if_iov_init),
	+ DEVMETHOD(ifdi_iov_uninit, ixgbe_if_iov_uninit),
	+ DEVMETHOD(ifdi_iov_vf_add, ixgbe_if_iov_vf_add),
	+#endif /* PCI_IOV */
	+ DEVMETHOD_END
	+};

	/*
	* TUNEABLE PARAMETERS:
	*/

	static SYSCTL_NODE(_hw, OID_AUTO, ix, CTLFLAG_RD, 0, "IXGBE driver parameters");
	+static driver_t ixgbe_if_driver = {
	+ "ixgbe_if", ixgbe_if_methods, sizeof(struct adapter)
	+};

	/*
	* AIM: Adaptive Interrupt Moderation
	@@ -260,24 +295,13 @@
	* traffic for that interrupt vector
	*/
	static int ixgbe_enable_aim = TRUE;
	-SYSCTL_INT(_hw_ix, OID_AUTO, enable_aim, CTLFLAG_RDTUN, &ixgbe_enable_aim, 0,
	+SYSCTL_INT(_hw_ix, OID_AUTO, enable_aim, CTLFLAG_RWTUN, &ixgbe_enable_aim, 0,
	"Enable adaptive interrupt moderation");

	static int ixgbe_max_interrupt_rate = (4000000 / IXGBE_LOW_LATENCY);
	SYSCTL_INT(_hw_ix, OID_AUTO, max_interrupt_rate, CTLFLAG_RDTUN,
	&ixgbe_max_interrupt_rate, 0, "Maximum interrupts per second");

	-/* How many packets rxeof tries to clean at a time */
	-static int ixgbe_rx_process_limit = 256;
	-SYSCTL_INT(_hw_ix, OID_AUTO, rx_process_limit, CTLFLAG_RDTUN,
	- &ixgbe_rx_process_limit, 0, "Maximum number of received packets to process at a time, -1 means unlimited");
	-
	-/* How many packets txeof tries to clean at a time */
	-static int ixgbe_tx_process_limit = 256;
	-SYSCTL_INT(_hw_ix, OID_AUTO, tx_process_limit, CTLFLAG_RDTUN,
	- &ixgbe_tx_process_limit, 0,
	- "Maximum number of sent packets to process at a time, -1 means unlimited");
	-
	/* Flow control setting, default to full */
	static int ixgbe_flow_control = ixgbe_fc_full;
	SYSCTL_INT(_hw_ix, OID_AUTO, flow_control, CTLFLAG_RDTUN,
	@@ -305,30 +329,6 @@
	SYSCTL_INT(_hw_ix, OID_AUTO, enable_msix, CTLFLAG_RDTUN, &ixgbe_enable_msix, 0,
	"Enable MSI-X interrupts");

	-/*
	- * Number of Queues, can be set to 0,
	- * it then autoconfigures based on the
	- * number of cpus with a max of 8. This
	- * can be overriden manually here.
	- */
	-static int ixgbe_num_queues = 0;
	-SYSCTL_INT(_hw_ix, OID_AUTO, num_queues, CTLFLAG_RDTUN, &ixgbe_num_queues, 0,
	- "Number of queues to configure, 0 indicates autoconfigure");
	-
	-/*
	- * Number of TX descriptors per ring,
	- * setting higher than RX as this seems
	- * the better performing choice.
	- */
	-static int ixgbe_txd = PERFORM_TXD;
	-SYSCTL_INT(_hw_ix, OID_AUTO, txd, CTLFLAG_RDTUN, &ixgbe_txd, 0,
	- "Number of transmit descriptors per queue");
	-
	-/* Number of RX descriptors per ring */
	-static int ixgbe_rxd = PERFORM_RXD;
	-SYSCTL_INT(_hw_ix, OID_AUTO, rxd, CTLFLAG_RDTUN, &ixgbe_rxd, 0,
	- "Number of receive descriptors per queue");
	-
	/*
	* Defining this on will allow the use
	* of unsupported SFP+ modules, note that
	@@ -347,24 +347,217 @@
	SYSCTL_INT(_hw_ix, OID_AUTO, enable_fdir, CTLFLAG_RDTUN, &ixgbe_enable_fdir, 0,
	"Enable Flow Director");

	-/* Legacy Transmit (single queue) */
	-static int ixgbe_enable_legacy_tx = 0;
	-SYSCTL_INT(_hw_ix, OID_AUTO, enable_legacy_tx, CTLFLAG_RDTUN,
	- &ixgbe_enable_legacy_tx, 0, "Enable Legacy TX flow");
	-
	/* Receive-Side Scaling */
	static int ixgbe_enable_rss = 1;
	SYSCTL_INT(_hw_ix, OID_AUTO, enable_rss, CTLFLAG_RDTUN, &ixgbe_enable_rss, 0,
	"Enable Receive-Side Scaling (RSS)");

	+#if 0
	/* Keep running tab on them for sanity check */
	static int ixgbe_total_ports;
	-
	-static int (ixgbe_start_locked)(struct ifnet , struct tx_ring *);
	-static int (ixgbe_ring_empty)(struct ifnet , struct buf_ring *);
	+#endif

	MALLOC_DEFINE(M_IXGBE, "ix", "ix driver allocations");

	+/*
	+ * For Flow Director: this is the number of TX packets we sample
	+ * for the filter pool, this means every 20th packet will be probed.
	+ *
	+ * This feature can be disabled by setting this to 0.
	+ */
	+static int atr_sample_rate = 20;
	+
	+extern struct if_txrx ixgbe_txrx;
	+
	+static struct if_shared_ctx ixgbe_sctx_init = {
	+ .isc_magic = IFLIB_MAGIC,
	+ .isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */
	+ .isc_tx_maxsize = IXGBE_TSO_SIZE,
	+
	+ .isc_tx_maxsegsize = PAGE_SIZE,
	+
	+ .isc_rx_maxsize = PAGE_SIZE*4,
	+ .isc_rx_nsegments = 1,
	+ .isc_rx_maxsegsize = PAGE_SIZE*4,
	+ .isc_nfl = 1,
	+ .isc_ntxqs = 1,
	+ .isc_nrxqs = 1,
	+
	+ .isc_admin_intrcnt = 1,
	+ .isc_vendor_info = ixgbe_vendor_info_array,
	+ .isc_driver_version = ixgbe_driver_version,
	+ .isc_driver = &ixgbe_if_driver,
	+
	+ .isc_nrxd_min = {MIN_RXD},
	+ .isc_ntxd_min = {MIN_TXD},
	+ .isc_nrxd_max = {MAX_RXD},
	+ .isc_ntxd_max = {MAX_TXD},
	+ .isc_nrxd_default = {DEFAULT_RXD},
	+ .isc_ntxd_default = {DEFAULT_TXD},
	+};
	+
	+if_shared_ctx_t ixgbe_sctx = &ixgbe_sctx_init;
	+
	+/************************************************************************
	+ * ixgbe_if_tx_queues_alloc
	+ ************************************************************************/
	+static int
	+ixgbe_if_tx_queues_alloc(if_ctx_t ctx, caddr_t vaddrs, uint64_t paddrs,
	+ int ntxqs, int ntxqsets)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ if_softc_ctx_t scctx = adapter->shared;
	+ struct ix_tx_queue *que;
	+ int i, j, error;
	+
	+ MPASS(adapter->num_tx_queues > 0);
	+ MPASS(adapter->num_tx_queues == ntxqsets);
	+ MPASS(ntxqs == 1);
	+
	+ /* Allocate queue structure memory */
	+ adapter->tx_queues =
	+ (struct ix_tx_queue )malloc(sizeof(struct ix_tx_queue) ntxqsets,
	+ M_IXGBE, M_NOWAIT \| M_ZERO);
	+ if (!adapter->tx_queues) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Unable to allocate TX ring memory\n");
	+ return (ENOMEM);
	+ }
	+
	+ for (i = 0, que = adapter->tx_queues; i < ntxqsets; i++, que++) {
	+ struct tx_ring *txr = &que->txr;
	+
	+ /* In case SR-IOV is enabled, align the index properly */
	+ txr->me = ixgbe_vf_que_index(adapter->iov_mode, adapter->pool,
	+ i);
	+
	+ txr->adapter = que->adapter = adapter;
	+ adapter->active_queues \|= (u64)1 << txr->me;
	+
	+ /* Allocate report status array */
	+ txr->tx_rsq = (qidx_t )malloc(sizeof(qidx_t) scctx->isc_ntxd[0], M_IXGBE, M_NOWAIT \| M_ZERO);
	+ if (txr->tx_rsq == NULL) {
	+ error = ENOMEM;
	+ goto fail;
	+ }
	+ for (j = 0; j < scctx->isc_ntxd[0]; j++)
	+ txr->tx_rsq[j] = QIDX_INVALID;
	+ /* get the virtual and physical address of the hardware queues */
	+ txr->tail = IXGBE_TDT(txr->me);
	+ txr->tx_base = (union ixgbe_adv_tx_desc *)vaddrs[i];
	+ txr->tx_paddr = paddrs[i];
	+
	+ txr->bytes = 0;
	+ txr->total_packets = 0;
	+
	+ /* Set the rate at which we sample packets */
	+ if (adapter->feat_en & IXGBE_FEATURE_FDIR)
	+ txr->atr_sample = atr_sample_rate;
	+
	+ }
	+
	+ iflib_config_gtask_init(ctx, &adapter->mod_task, ixgbe_handle_mod,
	+ "mod_task");
	+ iflib_config_gtask_init(ctx, &adapter->msf_task, ixgbe_handle_msf,
	+ "msf_task");
	+ iflib_config_gtask_init(ctx, &adapter->phy_task, ixgbe_handle_phy,
	+ "phy_task");
	+ if (adapter->feat_cap & IXGBE_FEATURE_SRIOV)
	+ iflib_config_gtask_init(ctx, &adapter->mbx_task,
	+ ixgbe_handle_mbx, "mbx_task");
	+ if (adapter->feat_en & IXGBE_FEATURE_FDIR)
	+ iflib_config_gtask_init(ctx, &adapter->fdir_task,
	+ ixgbe_reinit_fdir, "fdir_task");
	+
	+ device_printf(iflib_get_dev(ctx), "allocated for %d queues\n",
	+ adapter->num_tx_queues);
	+
	+ return (0);
	+
	+fail:
	+ ixgbe_if_queues_free(ctx);
	+
	+ return (error);
	+} /* ixgbe_if_tx_queues_alloc */
	+
	+/************************************************************************
	+ * ixgbe_if_rx_queues_alloc
	+ ************************************************************************/
	+static int
	+ixgbe_if_rx_queues_alloc(if_ctx_t ctx, caddr_t vaddrs, uint64_t paddrs,
	+ int nrxqs, int nrxqsets)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_rx_queue *que;
	+ int i;
	+
	+ MPASS(adapter->num_rx_queues > 0);
	+ MPASS(adapter->num_rx_queues == nrxqsets);
	+ MPASS(nrxqs == 1);
	+
	+ /* Allocate queue structure memory */
	+ adapter->rx_queues =
	+ (struct ix_rx_queue )malloc(sizeof(struct ix_rx_queue)nrxqsets,
	+ M_IXGBE, M_NOWAIT \| M_ZERO);
	+ if (!adapter->rx_queues) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Unable to allocate TX ring memory\n");
	+ return (ENOMEM);
	+ }
	+
	+ for (i = 0, que = adapter->rx_queues; i < nrxqsets; i++, que++) {
	+ struct rx_ring *rxr = &que->rxr;
	+
	+ /* In case SR-IOV is enabled, align the index properly */
	+ rxr->me = ixgbe_vf_que_index(adapter->iov_mode, adapter->pool,
	+ i);
	+
	+ rxr->adapter = que->adapter = adapter;
	+
	+ /* get the virtual and physical address of the hw queues */
	+ rxr->tail = IXGBE_RDT(rxr->me);
	+ rxr->rx_base = (union ixgbe_adv_rx_desc *)vaddrs[i];
	+ rxr->rx_paddr = paddrs[i];
	+ rxr->bytes = 0;
	+ rxr->que = que;
	+ }
	+
	+ device_printf(iflib_get_dev(ctx), "allocated for %d rx queues\n",
	+ adapter->num_rx_queues);
	+
	+ return (0);
	+} /* ixgbe_if_rx_queues_alloc */
	+
	+/************************************************************************
	+ * ixgbe_if_queues_free
	+ ************************************************************************/
	+static void
	+ixgbe_if_queues_free(if_ctx_t ctx)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_tx_queue *tx_que = adapter->tx_queues;
	+ struct ix_rx_queue *rx_que = adapter->rx_queues;
	+ int i;
	+
	+ if (tx_que != NULL) {
	+ for (i = 0; i < adapter->num_tx_queues; i++, tx_que++) {
	+ struct tx_ring *txr = &tx_que->txr;
	+ if (txr->tx_rsq == NULL)
	+ break;
	+
	+ free(txr->tx_rsq, M_IXGBE);
	+ txr->tx_rsq = NULL;
	+ }
	+
	+ free(adapter->tx_queues, M_IXGBE);
	+ adapter->tx_queues = NULL;
	+ }
	+ if (rx_que != NULL) {
	+ free(adapter->rx_queues, M_IXGBE);
	+ adapter->rx_queues = NULL;
	+ }
	+} /* ixgbe_if_queues_free */
	+
	/************************************************************************
	* ixgbe_initialize_rss_mapping
	************************************************************************/
	@@ -403,17 +596,17 @@

	/* Set up the redirection table */
	for (i = 0, j = 0; i < table_size; i++, j++) {
	- if (j == adapter->num_queues)
	+ if (j == adapter->num_rx_queues)
	j = 0;

	if (adapter->feat_en & IXGBE_FEATURE_RSS) {
	/*
	* Fetch the RSS bucket id for the given indirection
	* entry. Cap it at the number of configured buckets
	- * (which is num_queues.)
	+ * (which is num_rx_queues.)
	*/
	queue_id = rss_get_indirection_to_bucket(i);
	- queue_id = queue_id % adapter->num_queues;
	+ queue_id = queue_id % adapter->num_rx_queues;
	} else
	queue_id = (j * index_mult);

	@@ -486,14 +679,16 @@
	#define BSIZEPKT_ROUNDUP ((1<<IXGBE_SRRCTL_BSIZEPKT_SHIFT)-1)

	static void
	-ixgbe_initialize_receive_units(struct adapter *adapter)
	+ixgbe_initialize_receive_units(if_ctx_t ctx)
	{
	- struct rx_ring *rxr = adapter->rx_rings;
	- struct ixgbe_hw *hw = &adapter->hw;
	- struct ifnet *ifp = adapter->ifp;
	- int i, j;
	- u32 bufsz, fctrl, srrctl, rxcsum;
	- u32 hlreg;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ if_softc_ctx_t scctx = adapter->shared;
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ struct ix_rx_queue *que;
	+ int i, j;
	+ u32 bufsz, fctrl, srrctl, rxcsum;
	+ u32 hlreg;

	/*
	* Make sure receives are disabled while
	@@ -516,24 +711,16 @@
	hlreg \|= IXGBE_HLREG0_JUMBOEN;
	else
	hlreg &= ~IXGBE_HLREG0_JUMBOEN;
	-
	-#ifdef DEV_NETMAP
	- /* CRC stripping is conditional in Netmap */
	- if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) &&
	- (ifp->if_capenable & IFCAP_NETMAP) &&
	- !ix_crcstrip)
	- hlreg &= ~IXGBE_HLREG0_RXCRCSTRP;
	- else
	-#endif /* DEV_NETMAP */
	- hlreg \|= IXGBE_HLREG0_RXCRCSTRP;
	-
	IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg);

	bufsz = (adapter->rx_mbuf_sz + BSIZEPKT_ROUNDUP) >>
	IXGBE_SRRCTL_BSIZEPKT_SHIFT;

	- for (i = 0; i < adapter->num_queues; i++, rxr++) {
	- u64 rdba = rxr->rxdma.dma_paddr;
	+ /* Setup the Base and Length of the Rx Descriptor Ring */
	+ for (i = 0, que = adapter->rx_queues; i < adapter->num_rx_queues; i++, que++) {
	+ struct rx_ring *rxr = &que->rxr;
	+ u64 rdba = rxr->rx_paddr;
	+
	j = rxr->me;

	/* Setup the Base and Length of the Rx Descriptor Ring */
	@@ -541,7 +728,7 @@
	(rdba & 0x00000000ffffffffULL));
	IXGBE_WRITE_REG(hw, IXGBE_RDBAH(j), (rdba >> 32));
	IXGBE_WRITE_REG(hw, IXGBE_RDLEN(j),
	- adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc));
	+ scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc));

	/* Set up the SRRCTL register */
	srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(j));
	@@ -556,7 +743,7 @@
	* so we do not need to clear the bit, but do it just in case
	* this code is moved elsewhere.
	*/
	- if (adapter->num_queues > 1 &&
	+ if (adapter->num_rx_queues > 1 &&
	adapter->hw.fc.requested_mode == ixgbe_fc_none) {
	srrctl \|= IXGBE_SRRCTL_DROP_EN;
	} else {
	@@ -585,7 +772,7 @@

	ixgbe_initialize_rss_mapping(adapter);

	- if (adapter->num_queues > 1) {
	+ if (adapter->num_rx_queues > 1) {
	/* RSS and RX IPP Checksum are mutually exclusive */
	rxcsum \|= IXGBE_RXCSUM_PCSD;
	}
	@@ -599,21 +786,25 @@

	IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum);

	- return;
	} /* ixgbe_initialize_receive_units */

	/************************************************************************
	* ixgbe_initialize_transmit_units - Enable transmit units.
	************************************************************************/
	static void
	-ixgbe_initialize_transmit_units(struct adapter *adapter)
	+ixgbe_initialize_transmit_units(if_ctx_t ctx)
	{
	- struct tx_ring *txr = adapter->tx_rings;
	- struct ixgbe_hw *hw = &adapter->hw;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ if_softc_ctx_t scctx = adapter->shared;
	+ struct ix_tx_queue *que;
	+ int i;

	/* Setup the Base and Length of the Tx Descriptor Ring */
	- for (int i = 0; i < adapter->num_queues; i++, txr++) {
	- u64 tdba = txr->txdma.dma_paddr;
	+ for (i = 0, que = adapter->tx_queues; i < adapter->num_tx_queues;
	+ i++, que++) {
	+ struct tx_ring *txr = &que->txr;
	+ u64 tdba = txr->tx_paddr;
	u32 txctrl = 0;
	int j = txr->me;

	@@ -621,14 +812,16 @@
	(tdba & 0x00000000ffffffffULL));
	IXGBE_WRITE_REG(hw, IXGBE_TDBAH(j), (tdba >> 32));
	IXGBE_WRITE_REG(hw, IXGBE_TDLEN(j),
	- adapter->num_tx_desc * sizeof(union ixgbe_adv_tx_desc));
	+ scctx->isc_ntxd[0] * sizeof(union ixgbe_adv_tx_desc));

	/* Setup the HW Tx Head and Tail descriptor pointers */
	IXGBE_WRITE_REG(hw, IXGBE_TDH(j), 0);
	IXGBE_WRITE_REG(hw, IXGBE_TDT(j), 0);

	/* Cache the tail address */
	- txr->tail = IXGBE_TDT(j);
	+ txr->tx_rs_cidx = txr->tx_rs_pidx = txr->tx_cidx_processed = 0;
	+ for (int k = 0; k < scctx->isc_ntxd[0]; k++)
	+ txr->tx_rsq[k] = QIDX_INVALID;

	/* Disable Head Writeback */
	/*
	@@ -672,22 +865,32 @@
	IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs);
	}

	- return;
	} /* ixgbe_initialize_transmit_units */

	/************************************************************************
	- * ixgbe_attach - Device initialization routine
	+ * ixgbe_register
	+ ************************************************************************/
	+static void *
	+ixgbe_register(device_t dev)
	+{
	+ return (ixgbe_sctx);
	+} /* ixgbe_register */
	+
	+/************************************************************************
	+ * ixgbe_if_attach_pre - Device initialization routine, part 1
	*
	* Called when the driver is being loaded.
	- * Identifies the type of hardware, allocates all resources
	- * and initializes the hardware.
	+ * Identifies the type of hardware, initializes the hardware,
	+ * and initializes iflib structures.
	*
	* return 0 on success, positive on failure
	************************************************************************/
	static int
	-ixgbe_attach(device_t dev)
	+ixgbe_if_attach_pre(if_ctx_t ctx)
	{
	struct adapter *adapter;
	+ device_t dev;
	+ if_softc_ctx_t scctx;
	struct ixgbe_hw *hw;
	int error = 0;
	u32 ctrl_ext;
	@@ -695,17 +898,15 @@
	INIT_DEBUGOUT("ixgbe_attach: begin");

	/* Allocate, clear, and link in our adapter structure */
	- adapter = device_get_softc(dev);
	+ dev = iflib_get_dev(ctx);
	+ adapter = iflib_get_softc(ctx);
	adapter->hw.back = adapter;
	+ adapter->ctx = ctx;
	adapter->dev = dev;
	+ scctx = adapter->shared = iflib_get_softc_ctx(ctx);
	+ adapter->media = iflib_get_media(ctx);
	hw = &adapter->hw;

	- /* Core Lock Init*/
	- IXGBE_CORE_LOCK_INIT(adapter, device_get_nameunit(dev));
	-
	- /* Set up the timer callout */
	- callout_init_mtx(&adapter->timer, &adapter->core_mtx, 0);
	-
	/* Determine hardware revision */
	hw->vendor_id = pci_get_vendor(dev);
	hw->device_id = pci_get_device(dev);
	@@ -713,16 +914,10 @@
	hw->subsystem_vendor_id = pci_get_subvendor(dev);
	hw->subsystem_device_id = pci_get_subdevice(dev);

	- /*
	- * Make sure BUSMASTER is set
	- */
	- pci_enable_busmaster(dev);
	-
	/* Do base PCI setup - map BAR0 */
	- if (ixgbe_allocate_pci_resources(adapter)) {
	+ if (ixgbe_allocate_pci_resources(ctx)) {
	device_printf(dev, "Allocation of PCI resources failed\n");
	- error = ENXIO;
	- goto err_out;
	+ return (ENXIO);
	}

	/* let hardware know driver is loaded */
	@@ -733,10 +928,10 @@
	/*
	* Initialize the shared code
	*/
	- if (ixgbe_init_shared_code(hw)) {
	+ if (ixgbe_init_shared_code(hw) != 0) {
	device_printf(dev, "Unable to initialize the shared code\n");
	error = ENXIO;
	- goto err_out;
	+ goto err_pci;
	}

	if (hw->mbx.ops.init_params)
	@@ -744,38 +939,14 @@

	hw->allow_unsupported_sfp = allow_unsupported_sfp;

	- /* Pick up the 82599 settings */
	- if (hw->mac.type != ixgbe_mac_82598EB) {
	+ if (hw->mac.type != ixgbe_mac_82598EB)
	hw->phy.smart_speed = ixgbe_smart_speed;
	- adapter->num_segs = IXGBE_82599_SCATTER;
	- } else
	- adapter->num_segs = IXGBE_82598_SCATTER;

	ixgbe_init_device_features(adapter);

	- if (ixgbe_configure_interrupts(adapter)) {
	- error = ENXIO;
	- goto err_out;
	- }
	-
	- /* Allocate multicast array memory. */
	- adapter->mta = malloc(sizeof(adapter->mta)
	- MAX_NUM_MULTICAST_ADDRESSES, M_IXGBE, M_NOWAIT);
	- if (adapter->mta == NULL) {
	- device_printf(dev, "Can not allocate multicast setup array\n");
	- error = ENOMEM;
	- goto err_out;
	- }
	-
	/* Enable WoL (if supported) */
	ixgbe_check_wol_support(adapter);

	- /* Register for VLAN events */
	- adapter->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
	- ixgbe_register_vlan, adapter, EVENTHANDLER_PRI_FIRST);
	- adapter->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
	- ixgbe_unregister_vlan, adapter, EVENTHANDLER_PRI_FIRST);
	-
	/* Verify adapter fan is still functional (if applicable) */
	if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) {
	u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
	@@ -785,57 +956,9 @@
	/* Ensure SW/FW semaphore is free */
	ixgbe_init_swfw_semaphore(hw);

	- /* Enable EEE power saving */
	- if (adapter->feat_en & IXGBE_FEATURE_EEE)
	- hw->mac.ops.setup_eee(hw, TRUE);
	-
	/* Set an initial default flow control value */
	hw->fc.requested_mode = ixgbe_flow_control;

	- /* Sysctls for limiting the amount of work done in the taskqueues */
	- ixgbe_set_sysctl_value(adapter, "rx_processing_limit",
	- "max number of rx packets to process",
	- &adapter->rx_process_limit, ixgbe_rx_process_limit);
	-
	- ixgbe_set_sysctl_value(adapter, "tx_processing_limit",
	- "max number of tx packets to process",
	- &adapter->tx_process_limit, ixgbe_tx_process_limit);
	-
	- /* Do descriptor calc and sanity checks */
	- if (((ixgbe_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 \|\|
	- ixgbe_txd < MIN_TXD \|\| ixgbe_txd > MAX_TXD) {
	- device_printf(dev, "TXD config issue, using default!\n");
	- adapter->num_tx_desc = DEFAULT_TXD;
	- } else
	- adapter->num_tx_desc = ixgbe_txd;
	-
	- /*
	- * With many RX rings it is easy to exceed the
	- * system mbuf allocation. Tuning nmbclusters
	- * can alleviate this.
	- */
	- if (nmbclusters > 0) {
	- int s;
	- s = (ixgbe_rxd * adapter->num_queues) * ixgbe_total_ports;
	- if (s > nmbclusters) {
	- device_printf(dev, "RX Descriptors exceed system mbuf max, using default instead!\n");
	- ixgbe_rxd = DEFAULT_RXD;
	- }
	- }
	-
	- if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 \|\|
	- ixgbe_rxd < MIN_RXD \|\| ixgbe_rxd > MAX_RXD) {
	- device_printf(dev, "RXD config issue, using default!\n");
	- adapter->num_rx_desc = DEFAULT_RXD;
	- } else
	- adapter->num_rx_desc = ixgbe_rxd;
	-
	- /* Allocate our TX/RX Queues */
	- if (ixgbe_allocate_queues(adapter)) {
	- error = ENOMEM;
	- goto err_out;
	- }
	-
	hw->phy.reset_if_overtemp = TRUE;
	error = ixgbe_reset_hw(hw);
	hw->phy.reset_if_overtemp = FALSE;
	@@ -846,35 +969,24 @@
	* for later insertion.
	*/
	adapter->sfp_probe = TRUE;
	- error = IXGBE_SUCCESS;
	+ error = 0;
	} else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) {
	device_printf(dev, "Unsupported SFP+ module detected!\n");
	error = EIO;
	- goto err_late;
	+ goto err_pci;
	} else if (error) {
	device_printf(dev, "Hardware initialization failed\n");
	error = EIO;
	- goto err_late;
	+ goto err_pci;
	}

	/* Make sure we have a good EEPROM before we read from it */
	if (ixgbe_validate_eeprom_checksum(&adapter->hw, NULL) < 0) {
	device_printf(dev, "The EEPROM Checksum Is Not Valid\n");
	error = EIO;
	- goto err_late;
	+ goto err_pci;
	}

	- /* Setup OS specific network interface */
	- if (ixgbe_setup_interface(dev, adapter) != 0)
	- goto err_late;
	-
	- if (adapter->feat_en & IXGBE_FEATURE_MSIX)
	- error = ixgbe_allocate_msix(adapter);
	- else
	- error = ixgbe_allocate_legacy(adapter);
	- if (error)
	- goto err_late;
	-
	error = ixgbe_start_hw(hw);
	switch (error) {
	case IXGBE_ERR_EEPROM_VERSION:
	@@ -883,7 +995,7 @@
	case IXGBE_ERR_SFP_NOT_SUPPORTED:
	device_printf(dev, "Unsupported SFP+ Module\n");
	error = EIO;
	- goto err_late;
	+ goto err_pci;
	case IXGBE_ERR_SFP_NOT_PRESENT:
	device_printf(dev, "No SFP+ Module found\n");
	/* falls thru */
	@@ -891,14 +1003,121 @@
	break;
	}

	+ /* Most of the iflib initialization... */
	+
	+ iflib_set_mac(ctx, hw->mac.addr);
	+ switch (adapter->hw.mac.type) {
	+ case ixgbe_mac_X550:
	+ case ixgbe_mac_X550EM_x:
	+ case ixgbe_mac_X550EM_a:
	+ scctx->isc_rss_table_size = 512;
	+ break;
	+ default:
	+ scctx->isc_rss_table_size = 128;
	+ }
	+
	+ /* Allow legacy interrupts */
	+ ixgbe_txrx.ift_legacy_intr = ixgbe_intr;
	+
	+ scctx->isc_txqsizes[0] =
	+ roundup2(scctx->isc_ntxd[0] * sizeof(union ixgbe_adv_tx_desc) +
	+ sizeof(u32), DBA_ALIGN),
	+ scctx->isc_rxqsizes[0] =
	+ roundup2(scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc),
	+ DBA_ALIGN);
	+
	+ /* XXX */
	+ scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 32;
	+ scctx->isc_tx_csum_flags = CSUM_IP \| CSUM_TCP \| CSUM_UDP \| CSUM_TSO \|
	+ CSUM_IP6_TCP \| CSUM_IP6_UDP \| CSUM_IP6_TSO;
	+ if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
	+ scctx->isc_tx_nsegments = IXGBE_82598_SCATTER;
	+ scctx->isc_msix_bar = PCIR_BAR(MSIX_82598_BAR);
	+ } else {
	+ scctx->isc_tx_csum_flags \|= CSUM_SCTP \|CSUM_IP6_SCTP;
	+ scctx->isc_tx_nsegments = IXGBE_82599_SCATTER;
	+ scctx->isc_msix_bar = PCIR_BAR(MSIX_82599_BAR);
	+ }
	+ scctx->isc_tx_tso_segments_max = scctx->isc_tx_nsegments;
	+ scctx->isc_tx_tso_size_max = IXGBE_TSO_SIZE;
	+ scctx->isc_tx_tso_segsize_max = PAGE_SIZE;
	+
	+ scctx->isc_txrx = &ixgbe_txrx;
	+
	+ scctx->isc_capenable = IXGBE_CAPS;
	+
	+ return (0);
	+
	+err_pci:
	+ ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT);
	+ ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD;
	+ IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext);
	+ ixgbe_free_pci_resources(ctx);
	+
	+ return (error);
	+} /* ixgbe_if_attach_pre */
	+
	+ /*********************************************************************
	+ * ixgbe_if_attach_post - Device initialization routine, part 2
	+ *
	+ * Called during driver load, but after interrupts and
	+ * resources have been allocated and configured.
	+ * Sets up some data structures not relevant to iflib.
	+ *
	+ * return 0 on success, positive on failure
	+ *********************************************************************/
	+static int
	+ixgbe_if_attach_post(if_ctx_t ctx)
	+{
	+ device_t dev;
	+ struct adapter *adapter;
	+ struct ixgbe_hw *hw;
	+ int error = 0;
	+
	+ dev = iflib_get_dev(ctx);
	+ adapter = iflib_get_softc(ctx);
	+ hw = &adapter->hw;
	+
	+
	+ if (adapter->intr_type == IFLIB_INTR_LEGACY &&
	+ (adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ) == 0) {
	+ device_printf(dev, "Device does not support legacy interrupts");
	+ error = ENXIO;
	+ goto err;
	+ }
	+
	+ /* Allocate multicast array memory. */
	+ adapter->mta = malloc(sizeof(adapter->mta)
	+ MAX_NUM_MULTICAST_ADDRESSES, M_IXGBE, M_NOWAIT);
	+ if (adapter->mta == NULL) {
	+ device_printf(dev, "Can not allocate multicast setup array\n");
	+ error = ENOMEM;
	+ goto err;
	+ }
	+
	+ /* hw.ix defaults init */
	+ ixgbe_set_advertise(adapter, ixgbe_advertise_speed);
	+ adapter->enable_aim = ixgbe_enable_aim;
	+
	/* Enable the optics for 82599 SFP+ fiber */
	ixgbe_enable_tx_laser(hw);

	/* Enable power to the phy. */
	ixgbe_set_phy_power(hw, TRUE);

	+ ixgbe_initialize_iov(adapter);
	+
	+ error = ixgbe_setup_interface(ctx);
	+ if (error) {
	+ device_printf(dev, "Interface setup failed: %d\n", error);
	+ goto err;
	+ }
	+
	+ ixgbe_if_update_admin_status(ctx);
	+
	/* Initialize statistics */
	ixgbe_update_stats_counters(adapter);
	+ ixgbe_add_hw_stats(adapter);

	/* Check PCIE slot type/speed/width */
	ixgbe_get_slot_info(adapter);
	@@ -918,36 +1137,12 @@
	ixgbe_define_iov_schemas(dev, &error);

	/* Add sysctls */
	- ixgbe_add_device_sysctls(adapter);
	- ixgbe_add_hw_stats(adapter);
	-
	- /* For Netmap */
	- adapter->init_locked = ixgbe_init_locked;
	- adapter->stop_locked = ixgbe_stop;
	-
	- if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
	- ixgbe_netmap_attach(adapter);
	-
	- INIT_DEBUGOUT("ixgbe_attach: end");
	+ ixgbe_add_device_sysctls(ctx);

	return (0);
	-
	-err_late:
	- ixgbe_free_transmit_structures(adapter);
	- ixgbe_free_receive_structures(adapter);
	- free(adapter->queues, M_DEVBUF);
	-err_out:
	- if (adapter->ifp != NULL)
	- if_free(adapter->ifp);
	- ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT);
	- ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD;
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext);
	- ixgbe_free_pci_resources(adapter);
	- free(adapter->mta, M_IXGBE);
	- IXGBE_CORE_LOCK_DESTROY(adapter);
	-
	+err:
	return (error);
	-} /* ixgbe_attach */
	+} /* ixgbe_if_attach_post */

	/************************************************************************
	* ixgbe_check_wol_support
	@@ -984,70 +1179,18 @@
	* Setup networking device structure and register an interface.
	************************************************************************/
	static int
	-ixgbe_setup_interface(device_t dev, struct adapter *adapter)
	+ixgbe_setup_interface(if_ctx_t ctx)
	{
	- struct ifnet *ifp;
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ struct adapter *adapter = iflib_get_softc(ctx);

	INIT_DEBUGOUT("ixgbe_setup_interface: begin");

	- ifp = adapter->ifp = if_alloc(IFT_ETHER);
	- if (ifp == NULL) {
	- device_printf(dev, "can not allocate ifnet structure\n");
	- return (-1);
	- }
	- if_initname(ifp, device_get_name(dev), device_get_unit(dev));
	- ifp->if_baudrate = IF_Gbps(10);
	- ifp->if_init = ixgbe_init;
	- ifp->if_softc = adapter;
	- ifp->if_flags = IFF_BROADCAST \| IFF_SIMPLEX \| IFF_MULTICAST;
	- ifp->if_ioctl = ixgbe_ioctl;
	-#if __FreeBSD_version >= 1100036
	- if_setgetcounterfn(ifp, ixgbe_get_counter);
	-#endif
	-#if __FreeBSD_version >= 1100045
	- /* TSO parameters */
	- ifp->if_hw_tsomax = 65518;
	- ifp->if_hw_tsomaxsegcount = IXGBE_82599_SCATTER;
	- ifp->if_hw_tsomaxsegsize = 2048;
	-#endif
	- if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) {
	- ifp->if_start = ixgbe_legacy_start;
	- IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2);
	- ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 2;
	- IFQ_SET_READY(&ifp->if_snd);
	- ixgbe_start_locked = ixgbe_legacy_start_locked;
	- ixgbe_ring_empty = ixgbe_legacy_ring_empty;
	- } else {
	- ifp->if_transmit = ixgbe_mq_start;
	- ifp->if_qflush = ixgbe_qflush;
	- ixgbe_start_locked = ixgbe_mq_start_locked;
	- ixgbe_ring_empty = drbr_empty;
	- }
	-
	- ether_ifattach(ifp, adapter->hw.mac.addr);
	+ if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
	+ if_setbaudrate(ifp, IF_Gbps(10));

	adapter->max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;

	- /*
	- * Tell the upper layer(s) we support long frames.
	- */
	- ifp->if_hdrlen = sizeof(struct ether_vlan_header);
	-
	- /* Set capability flags */
	- ifp->if_capabilities \|= IFCAP_HWCSUM
	- \| IFCAP_HWCSUM_IPV6
	- \| IFCAP_TSO
	- \| IFCAP_LRO
	- \| IFCAP_VLAN_HWTAGGING
	- \| IFCAP_VLAN_HWTSO
	- \| IFCAP_VLAN_HWCSUM
	- \| IFCAP_JUMBO_MTU
	- \| IFCAP_VLAN_MTU
	- \| IFCAP_HWSTATS;
	-
	- /* Enable the above capabilities by default */
	- ifp->if_capenable = ifp->if_capabilities;
	-
	/*
	* Don't turn this on by default, if vlans are
	* created on another pseudo device (eg. lagg)
	@@ -1056,36 +1199,25 @@
	* using vlans directly on the ixgbe driver you can
	* enable this and get full hardware tag filtering.
	*/
	- ifp->if_capabilities \|= IFCAP_VLAN_HWFILTER;
	-
	- /*
	- * Specify the media types supported by this adapter and register
	- * callbacks to update media and link information
	- */
	- ifmedia_init(&adapter->media, IFM_IMASK, ixgbe_media_change,
	- ixgbe_media_status);
	-
	+ if_setcapenablebit(ifp, 0, IFCAP_VLAN_HWFILTER);
	adapter->phy_layer = ixgbe_get_supported_physical_layer(&adapter->hw);
	- ixgbe_add_media_types(adapter);

	- /* Set autoselect media by default */
	- ifmedia_set(&adapter->media, IFM_ETHER \| IFM_AUTO);
	+ ixgbe_add_media_types(ctx);
	+
	+ /* Autoselect media by default */
	+ ifmedia_set(adapter->media, IFM_ETHER \| IFM_AUTO);

	return (0);
	} /* ixgbe_setup_interface */

	-#if __FreeBSD_version >= 1100036
	/************************************************************************
	- * ixgbe_get_counter
	+ * ixgbe_if_get_counter
	************************************************************************/
	static uint64_t
	-ixgbe_get_counter(struct ifnet *ifp, ift_counter cnt)
	+ixgbe_if_get_counter(if_ctx_t ctx, ift_counter cnt)
	{
	- struct adapter *adapter;
	- struct tx_ring *txr;
	- uint64_t rv;
	-
	- adapter = if_getsoftc(ifp);
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ if_t ifp = iflib_get_ifp(ctx);

	switch (cnt) {
	case IFCOUNTER_IPACKETS:
	@@ -1105,103 +1237,99 @@
	case IFCOUNTER_IQDROPS:
	return (adapter->iqdrops);
	case IFCOUNTER_OQDROPS:
	- rv = 0;
	- txr = adapter->tx_rings;
	- for (int i = 0; i < adapter->num_queues; i++, txr++)
	- rv += txr->br->br_drops;
	- return (rv);
	+ return (0);
	case IFCOUNTER_IERRORS:
	return (adapter->ierrors);
	default:
	return (if_get_counter_default(ifp, cnt));
	}
	-} /* ixgbe_get_counter */
	-#endif
	+} /* ixgbe_if_get_counter */

	/************************************************************************
	* ixgbe_add_media_types
	************************************************************************/
	static void
	-ixgbe_add_media_types(struct adapter *adapter)
	+ixgbe_add_media_types(if_ctx_t ctx)
	{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	- device_t dev = adapter->dev;
	+ device_t dev = iflib_get_dev(ctx);
	u64 layer;

	- layer = adapter->phy_layer;
	+ layer = adapter->phy_layer = ixgbe_get_supported_physical_layer(hw);

	/* Media types with matching FreeBSD media defines */
	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_T, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_T, 0, NULL);
	if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_T, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_T, 0, NULL);
	if (layer & IXGBE_PHYSICAL_LAYER_100BASE_TX)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_100_TX, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_100_TX, 0, NULL);
	if (layer & IXGBE_PHYSICAL_LAYER_10BASE_T)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10_T, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10_T, 0, NULL);

	if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU \|\|
	layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_TWINAX, 0,
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_TWINAX, 0,
	NULL);

	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) {
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_LR, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_LR, 0, NULL);
	if (hw->phy.multispeed_fiber)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_LX, 0,
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_LX, 0,
	NULL);
	}
	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) {
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_SR, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_SR, 0, NULL);
	if (hw->phy.multispeed_fiber)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_SX, 0,
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_SX, 0,
	NULL);
	} else if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_SX, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_SX, 0, NULL);
	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_CX4, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_CX4, 0, NULL);

	#ifdef IFM_ETH_XTYPE
	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_KR, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_KR, 0, NULL);
	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_KX4, 0, NULL);
	+ ifmedia_add( adapter->media, IFM_ETHER \| IFM_10G_KX4, 0, NULL);
	if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_KX, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_KX, 0, NULL);
	if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX)
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_2500_KX, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_2500_KX, 0, NULL);
	#else
	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) {
	device_printf(dev, "Media supported: 10GbaseKR\n");
	device_printf(dev, "10GbaseKR mapped to 10GbaseSR\n");
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_SR, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_SR, 0, NULL);
	}
	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) {
	device_printf(dev, "Media supported: 10GbaseKX4\n");
	device_printf(dev, "10GbaseKX4 mapped to 10GbaseCX4\n");
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_10G_CX4, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_10G_CX4, 0, NULL);
	}
	if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) {
	device_printf(dev, "Media supported: 1000baseKX\n");
	device_printf(dev, "1000baseKX mapped to 1000baseCX\n");
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_CX, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_CX, 0, NULL);
	}
	if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX) {
	device_printf(dev, "Media supported: 2500baseKX\n");
	device_printf(dev, "2500baseKX mapped to 2500baseSX\n");
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_2500_SX, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_2500_SX, 0, NULL);
	}
	#endif
	if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_BX)
	device_printf(dev, "Media supported: 1000baseBX\n");

	if (hw->device_id == IXGBE_DEV_ID_82598AT) {
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_T \| IFM_FDX,
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_T \| IFM_FDX,
	0, NULL);
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_1000_T, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_1000_T, 0, NULL);
	}

	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_AUTO, 0, NULL);
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_AUTO, 0, NULL);
	} /* ixgbe_add_media_types */

	/************************************************************************
	@@ -1213,23 +1341,23 @@
	switch (hw->mac.type) {
	case ixgbe_mac_82598EB:
	if (hw->phy.type == ixgbe_phy_nl)
	- return TRUE;
	- return FALSE;
	+ return (TRUE);
	+ return (FALSE);
	case ixgbe_mac_82599EB:
	switch (hw->mac.ops.get_media_type(hw)) {
	case ixgbe_media_type_fiber:
	case ixgbe_media_type_fiber_qsfp:
	- return TRUE;
	+ return (TRUE);
	default:
	- return FALSE;
	+ return (FALSE);
	}
	case ixgbe_mac_X550EM_x:
	case ixgbe_mac_X550EM_a:
	if (hw->mac.ops.get_media_type(hw) == ixgbe_media_type_fiber)
	- return TRUE;
	- return FALSE;
	+ return (TRUE);
	+ return (FALSE);
	default:
	- return FALSE;
	+ return (FALSE);
	}
	} /* ixgbe_is_sfp */

	@@ -1246,31 +1374,24 @@
	sfp = ixgbe_is_sfp(hw);

	if (sfp) {
	- if (hw->phy.multispeed_fiber) {
	- hw->mac.ops.setup_sfp(hw);
	- ixgbe_enable_tx_laser(hw);
	- taskqueue_enqueue(adapter->tq, &adapter->msf_task);
	- } else
	- taskqueue_enqueue(adapter->tq, &adapter->mod_task);
	+ GROUPTASK_ENQUEUE(&adapter->mod_task);
	} else {
	if (hw->mac.ops.check_link)
	err = ixgbe_check_link(hw, &adapter->link_speed,
	&adapter->link_up, FALSE);
	if (err)
	- goto out;
	+ return;
	autoneg = hw->phy.autoneg_advertised;
	if ((!autoneg) && (hw->mac.ops.get_link_capabilities))
	err = hw->mac.ops.get_link_capabilities(hw, &autoneg,
	&negotiate);
	if (err)
	- goto out;
	+ return;
	if (hw->mac.ops.setup_link)
	err = hw->mac.ops.setup_link(hw, autoneg,
	adapter->link_up);
	}
	-out:

	- return;
	} /* ixgbe_config_link */

	/************************************************************************
	@@ -1399,15 +1520,16 @@
	static void
	ixgbe_add_hw_stats(struct adapter *adapter)
	{
	- device_t dev = adapter->dev;
	- struct tx_ring *txr = adapter->tx_rings;
	- struct rx_ring *rxr = adapter->rx_rings;
	+ device_t dev = iflib_get_dev(adapter->ctx);
	+ struct ix_rx_queue *rx_que;
	+ struct ix_tx_queue *tx_que;
	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
	struct sysctl_oid *tree = device_get_sysctl_tree(dev);
	struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
	struct ixgbe_hw_stats *stats = &adapter->stats.pf;
	struct sysctl_oid stat_node, queue_node;
	struct sysctl_oid_list stat_list, queue_list;
	+ int i;

	#define QUEUE_NAME_LEN 32
	char namebuf[QUEUE_NAME_LEN];
	@@ -1415,27 +1537,18 @@
	/* Driver Statistics */
	SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dropped",
	CTLFLAG_RD, &adapter->dropped_pkts, "Driver dropped packets");
	- SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "mbuf_defrag_failed",
	- CTLFLAG_RD, &adapter->mbuf_defrag_failed, "m_defrag() failed");
	SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "watchdog_events",
	CTLFLAG_RD, &adapter->watchdog_events, "Watchdog timeouts");
	SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq",
	CTLFLAG_RD, &adapter->link_irq, "Link MSI-X IRQ Handled");

	- for (int i = 0; i < adapter->num_queues; i++, txr++) {
	+ for (i = 0, tx_que = adapter->tx_queues; i < adapter->num_tx_queues; i++, tx_que++) {
	+ struct tx_ring *txr = &tx_que->txr;
	snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
	queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
	CTLFLAG_RD, NULL, "Queue Name");
	queue_list = SYSCTL_CHILDREN(queue_node);

	- SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate",
	- CTLTYPE_UINT \| CTLFLAG_RW, &adapter->queues[i],
	- sizeof(&adapter->queues[i]),
	- ixgbe_sysctl_interrupt_rate_handler, "IU",
	- "Interrupt Rate");
	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
	- CTLFLAG_RD, &(adapter->queues[i].irqs),
	- "irqs on this queue");
	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "txd_head",
	CTLTYPE_UINT \| CTLFLAG_RD, txr, sizeof(txr),
	ixgbe_sysctl_tdh_handler, "IU", "Transmit Descriptor Head");
	@@ -1444,28 +1557,26 @@
	ixgbe_sysctl_tdt_handler, "IU", "Transmit Descriptor Tail");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
	CTLFLAG_RD, &txr->tso_tx, "TSO");
	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "no_tx_dma_setup",
	- CTLFLAG_RD, &txr->no_tx_dma_setup,
	- "Driver tx dma failure in xmit");
	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "no_desc_avail",
	- CTLFLAG_RD, &txr->no_desc_avail,
	- "Queue No Descriptor Available");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_packets",
	CTLFLAG_RD, &txr->total_packets,
	"Queue Packets Transmitted");
	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "br_drops",
	- CTLFLAG_RD, &txr->br->br_drops,
	- "Packets dropped in buf_ring");
	}

	- for (int i = 0; i < adapter->num_queues; i++, rxr++) {
	- struct lro_ctrl *lro = &rxr->lro;
	-
	+ for (i = 0, rx_que = adapter->rx_queues; i < adapter->num_rx_queues; i++, rx_que++) {
	+ struct rx_ring *rxr = &rx_que->rxr;
	snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
	queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
	CTLFLAG_RD, NULL, "Queue Name");
	queue_list = SYSCTL_CHILDREN(queue_node);

	+ SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "interrupt_rate",
	+ CTLTYPE_UINT \| CTLFLAG_RW, &adapter->rx_queues[i],
	+ sizeof(&adapter->rx_queues[i]),
	+ ixgbe_sysctl_interrupt_rate_handler, "IU",
	+ "Interrupt Rate");
	+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
	+ CTLFLAG_RD, &(adapter->rx_queues[i].irqs),
	+ "irqs on this queue");
	SYSCTL_ADD_PROC(ctx, queue_list, OID_AUTO, "rxd_head",
	CTLTYPE_UINT \| CTLFLAG_RD, rxr, sizeof(rxr),
	ixgbe_sysctl_rdh_handler, "IU", "Receive Descriptor Head");
	@@ -1480,10 +1591,6 @@
	CTLFLAG_RD, &rxr->rx_copies, "Copied RX Frames");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_discarded",
	CTLFLAG_RD, &rxr->rx_discarded, "Discarded RX packets");
	- SYSCTL_ADD_U64(ctx, queue_list, OID_AUTO, "lro_queued",
	- CTLFLAG_RD, &lro->lro_queued, 0, "LRO Queued");
	- SYSCTL_ADD_U64(ctx, queue_list, OID_AUTO, "lro_flushed",
	- CTLFLAG_RD, &lro->lro_flushed, 0, "LRO Flushed");
	}

	/* MAC stats get their own sub node */
	@@ -1679,7 +1786,7 @@
	} /* ixgbe_sysctl_rdt_handler */

	/************************************************************************
	- * ixgbe_register_vlan
	+ * ixgbe_if_vlan_register
	*
	* Run via vlan config EVENT, it enables us to use the
	* HW Filter table since we can get the vlan id. This
	@@ -1687,60 +1794,45 @@
	* VFTA, init will repopulate the real table.
	************************************************************************/
	static void
	-ixgbe_register_vlan(void arg, struct ifnet ifp, u16 vtag)
	+ixgbe_if_vlan_register(if_ctx_t ctx, u16 vtag)
	{
	- struct adapter *adapter = ifp->if_softc;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	u16 index, bit;

	- if (ifp->if_softc != arg) /* Not our event */
	- return;
	-
	- if ((vtag == 0) \|\| (vtag > 4095)) /* Invalid */
	- return;
	-
	- IXGBE_CORE_LOCK(adapter);
	index = (vtag >> 5) & 0x7F;
	bit = vtag & 0x1F;
	adapter->shadow_vfta[index] \|= (1 << bit);
	++adapter->num_vlans;
	- ixgbe_setup_vlan_hw_support(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-} /* ixgbe_register_vlan */
	+ ixgbe_setup_vlan_hw_support(ctx);
	+} /* ixgbe_if_vlan_register */

	/************************************************************************
	- * ixgbe_unregister_vlan
	+ * ixgbe_if_vlan_unregister
	*
	* Run via vlan unconfig EVENT, remove our entry in the soft vfta.
	************************************************************************/
	static void
	-ixgbe_unregister_vlan(void arg, struct ifnet ifp, u16 vtag)
	+ixgbe_if_vlan_unregister(if_ctx_t ctx, u16 vtag)
	{
	- struct adapter *adapter = ifp->if_softc;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	u16 index, bit;

	- if (ifp->if_softc != arg)
	- return;
	-
	- if ((vtag == 0) \|\| (vtag > 4095)) /* Invalid */
	- return;
	-
	- IXGBE_CORE_LOCK(adapter);
	index = (vtag >> 5) & 0x7F;
	bit = vtag & 0x1F;
	adapter->shadow_vfta[index] &= ~(1 << bit);
	--adapter->num_vlans;
	/* Re-init to load the changes */
	- ixgbe_setup_vlan_hw_support(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-} /* ixgbe_unregister_vlan */
	+ ixgbe_setup_vlan_hw_support(ctx);
	+} /* ixgbe_if_vlan_unregister */

	/************************************************************************
	* ixgbe_setup_vlan_hw_support
	************************************************************************/
	static void
	-ixgbe_setup_vlan_hw_support(struct adapter *adapter)
	+ixgbe_setup_vlan_hw_support(if_ctx_t ctx)
	{
	- struct ifnet *ifp = adapter->ifp;
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	struct rx_ring *rxr;
	int i;
	@@ -1757,8 +1849,8 @@
	return;

	/* Setup the queues for vlans */
	- for (i = 0; i < adapter->num_queues; i++) {
	- rxr = &adapter->rx_rings[i];
	+ for (i = 0; i < adapter->num_rx_queues; i++) {
	+ rxr = &adapter->rx_queues[i].rxr;
	/* On 82599 the VLAN enable is per/queue in RXDCTL */
	if (hw->mac.type != ixgbe_mac_82598EB) {
	ctrl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me));
	@@ -1799,11 +1891,11 @@
	static void
	ixgbe_get_slot_info(struct adapter *adapter)
	{
	- device_t dev = adapter->dev;
	- struct ixgbe_hw *hw = &adapter->hw;
	- u32 offset;
	- u16 link;
	- int bus_info_valid = TRUE;
	+ device_t dev = iflib_get_dev(adapter->ctx);
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ int bus_info_valid = TRUE;
	+ u32 offset;
	+ u16 link;

	/* Some devices are behind an internal bridge */
	switch (hw->device_id) {
	@@ -1889,84 +1981,111 @@
	} /* ixgbe_get_slot_info */

	/************************************************************************
	- * ixgbe_enable_queue - MSI-X Interrupt Handlers and Tasklets
	+ * ixgbe_if_msix_intr_assign
	+ *
	+ * Setup MSI-X Interrupt resources and handlers
	************************************************************************/
	-static inline void
	-ixgbe_enable_queue(struct adapter *adapter, u32 vector)
	+static int
	+ixgbe_if_msix_intr_assign(if_ctx_t ctx, int msix)
	{
	- struct ixgbe_hw *hw = &adapter->hw;
	- u64 queue = (u64)(1 << vector);
	- u32 mask;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_rx_queue *rx_que = adapter->rx_queues;
	+ struct ix_tx_queue *tx_que;
	+ int error, rid, vector = 0;
	+ int cpu_id = 0;
	+ char buf[16];
	+
	+ /* Admin Que is vector 0*/
	+ rid = vector + 1;
	+ for (int i = 0; i < adapter->num_rx_queues; i++, vector++, rx_que++) {
	+ rid = vector + 1;

	- if (hw->mac.type == ixgbe_mac_82598EB) {
	- mask = (IXGBE_EIMS_RTX_QUEUE & queue);
	- IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask);
	- } else {
	- mask = (queue & 0xFFFFFFFF);
	- if (mask)
	- IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask);
	- mask = (queue >> 32);
	- if (mask)
	- IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask);
	- }
	-} /* ixgbe_enable_queue */
	+ snprintf(buf, sizeof(buf), "rxq%d", i);
	+ error = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
	+ IFLIB_INTR_RX, ixgbe_msix_que, rx_que, rx_que->rxr.me, buf);

	-/************************************************************************
	- * ixgbe_disable_queue
	- ************************************************************************/
	-static inline void
	-ixgbe_disable_queue(struct adapter *adapter, u32 vector)
	-{
	- struct ixgbe_hw *hw = &adapter->hw;
	- u64 queue = (u64)(1 << vector);
	- u32 mask;
	+ if (error) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Failed to allocate que int %d err: %d", i, error);
	+ adapter->num_rx_queues = i + 1;
	+ goto fail;
	+ }
	+
	+ rx_que->msix = vector;
	+ adapter->active_queues \|= (u64)(1 << rx_que->msix);
	+ if (adapter->feat_en & IXGBE_FEATURE_RSS) {
	+ /*
	+ * The queue ID is used as the RSS layer bucket ID.
	+ * We look up the queue ID -> RSS CPU ID and select
	+ * that.
	+ */
	+ cpu_id = rss_getcpu(i % rss_getnumbuckets());
	+ } else {
	+ /*
	+ * Bind the msix vector, and thus the
	+ * rings to the corresponding cpu.
	+ *
	+ * This just happens to match the default RSS
	+ * round-robin bucket -> queue -> CPU allocation.
	+ */
	+ if (adapter->num_rx_queues > 1)
	+ cpu_id = i;
	+ }

	- if (hw->mac.type == ixgbe_mac_82598EB) {
	- mask = (IXGBE_EIMS_RTX_QUEUE & queue);
	- IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask);
	- } else {
	- mask = (queue & 0xFFFFFFFF);
	- if (mask)
	- IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask);
	- mask = (queue >> 32);
	- if (mask)
	- IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask);
	}
	-} /* ixgbe_disable_queue */
	+ for (int i = 0; i < adapter->num_tx_queues; i++) {
	+ snprintf(buf, sizeof(buf), "txq%d", i);
	+ tx_que = &adapter->tx_queues[i];
	+ tx_que->msix = i % adapter->num_rx_queues;
	+ iflib_softirq_alloc_generic(ctx,
	+ &adapter->rx_queues[tx_que->msix].que_irq,
	+ IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
	+ }
	+ rid = vector + 1;
	+ error = iflib_irq_alloc_generic(ctx, &adapter->irq, rid,
	+ IFLIB_INTR_ADMIN, ixgbe_msix_link, adapter, 0, "aq");
	+ if (error) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Failed to register admin handler");
	+ return (error);
	+ }

	-/************************************************************************
	+ adapter->vector = vector;
	+
	+ return (0);
	+fail:
	+ iflib_irq_free(ctx, &adapter->irq);
	+ rx_que = adapter->rx_queues;
	+ for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++)
	+ iflib_irq_free(ctx, &rx_que->que_irq);
	+
	+ return (error);
	+} /* ixgbe_if_msix_intr_assign */
	+
	+/*********************************************************************
	* ixgbe_msix_que - MSI-X Queue Interrupt Service routine
	- ************************************************************************/
	-void
	+ **********************************************************************/
	+static int
	ixgbe_msix_que(void *arg)
	{
	- struct ix_queue *que = arg;
	- struct adapter *adapter = que->adapter;
	- struct ifnet *ifp = adapter->ifp;
	- struct tx_ring *txr = que->txr;
	- struct rx_ring *rxr = que->rxr;
	- bool more;
	- u32 newitr = 0;
	+ struct ix_rx_queue *que = arg;
	+ struct adapter *adapter = que->adapter;
	+#ifdef notyet
	+ struct tx_ring *txr = &que->txr;
	+#endif
	+ struct rx_ring *rxr = &que->rxr;
	+ struct ifnet *ifp = iflib_get_ifp(que->adapter->ctx);
	+ u32 newitr = 0;


	/* Protect against spurious interrupts */
	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
	- return;
	+ return 0;

	ixgbe_disable_queue(adapter, que->msix);
	++que->irqs;

	- more = ixgbe_rxeof(que);
	-
	- IXGBE_TX_LOCK(txr);
	- ixgbe_txeof(txr);
	- if (!ixgbe_ring_empty(ifp, txr->br))
	- ixgbe_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	-
	- /* Do AIM now? */
	-
	- if (adapter->enable_aim == FALSE)
	+ if (ixgbe_enable_aim == FALSE)
	goto no_calc;
	/*
	* Do Adaptive Interrupt Moderation:
	@@ -1981,11 +2100,10 @@
	que->eitr_setting = 0;

	/* Idle, do nothing */
	- if ((txr->bytes == 0) && (rxr->bytes == 0))
	- goto no_calc;
	-
	+#ifdef notyet
	if ((txr->bytes) && (txr->packets))
	newitr = txr->bytes/txr->packets;
	+#endif
	if ((rxr->bytes) && (rxr->packets))
	newitr = max(newitr, (rxr->bytes / rxr->packets));
	newitr += 24; /* account for hardware frame, crc */
	@@ -2008,18 +2126,16 @@
	que->eitr_setting = newitr;

	/* Reset state */
	+#ifdef notyet
	txr->bytes = 0;
	txr->packets = 0;
	+#endif
	rxr->bytes = 0;
	rxr->packets = 0;

	no_calc:
	- if (more)
	- taskqueue_enqueue(que->tq, &que->que_task);
	- else
	- ixgbe_enable_queue(adapter, que->msix);

	- return;
	+ return (FILTER_SCHEDULE_THREAD);
	} /* ixgbe_msix_que */

	/************************************************************************
	@@ -2029,23 +2145,21 @@
	* the interface using ifconfig.
	************************************************************************/
	static void
	-ixgbe_media_status(struct ifnet ifp, struct ifmediareq ifmr)
	+ixgbe_if_media_status(if_ctx_t ctx, struct ifmediareq * ifmr)
	{
	- struct adapter *adapter = ifp->if_softc;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	int layer;

	- INIT_DEBUGOUT("ixgbe_media_status: begin");
	- IXGBE_CORE_LOCK(adapter);
	- ixgbe_update_link_status(adapter);
	+ INIT_DEBUGOUT("ixgbe_if_media_status: begin");
	+
	+ iflib_admin_intr_deferred(ctx);

	ifmr->ifm_status = IFM_AVALID;
	ifmr->ifm_active = IFM_ETHER;

	- if (!adapter->link_active) {
	- IXGBE_CORE_UNLOCK(adapter);
	+ if (!adapter->link_active)
	return;
	- }

	ifmr->ifm_status \|= IFM_ACTIVE;
	layer = adapter->phy_layer;
	@@ -2173,7 +2287,6 @@
	if (IFM_SUBTYPE(ifmr->ifm_active) == 0)
	ifmr->ifm_active \|= IFM_UNKNOWN;

	-#if __FreeBSD_version >= 900025
	/* Display current flow control setting used on link */
	if (hw->fc.current_mode == ixgbe_fc_rx_pause \|\|
	hw->fc.current_mode == ixgbe_fc_full)
	@@ -2181,11 +2294,6 @@
	if (hw->fc.current_mode == ixgbe_fc_tx_pause \|\|
	hw->fc.current_mode == ixgbe_fc_full)
	ifmr->ifm_active \|= IFM_ETH_TXPAUSE;
	-#endif
	-
	- IXGBE_CORE_UNLOCK(adapter);
	-
	- return;
	} /* ixgbe_media_status */

	/************************************************************************
	@@ -2195,20 +2303,20 @@
	* media/mediopt option with ifconfig.
	************************************************************************/
	static int
	-ixgbe_media_change(struct ifnet *ifp)
	+ixgbe_if_media_change(if_ctx_t ctx)
	{
	- struct adapter *adapter = ifp->if_softc;
	- struct ifmedia *ifm = &adapter->media;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ifmedia *ifm = iflib_get_media(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	ixgbe_link_speed speed = 0;

	- INIT_DEBUGOUT("ixgbe_media_change: begin");
	+ INIT_DEBUGOUT("ixgbe_if_media_change: begin");

	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
	return (EINVAL);

	if (hw->phy.media_type == ixgbe_media_type_backplane)
	- return (ENODEV);
	+ return (EPERM);

	/*
	* We don't actually need to check against the supported
	@@ -2216,48 +2324,48 @@
	* that for us.
	*/
	switch (IFM_SUBTYPE(ifm->ifm_media)) {
	- case IFM_AUTO:
	- case IFM_10G_T:
	- speed \|= IXGBE_LINK_SPEED_100_FULL;
	- speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	- speed \|= IXGBE_LINK_SPEED_10GB_FULL;
	- break;
	- case IFM_10G_LRM:
	- case IFM_10G_LR:
	+ case IFM_AUTO:
	+ case IFM_10G_T:
	+ speed \|= IXGBE_LINK_SPEED_100_FULL;
	+ speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	+ speed \|= IXGBE_LINK_SPEED_10GB_FULL;
	+ break;
	+ case IFM_10G_LRM:
	+ case IFM_10G_LR:
	#ifndef IFM_ETH_XTYPE
	- case IFM_10G_SR: /* KR, too */
	- case IFM_10G_CX4: /* KX4 */
	+ case IFM_10G_SR: /* KR, too */
	+ case IFM_10G_CX4: /* KX4 */
	#else
	- case IFM_10G_KR:
	- case IFM_10G_KX4:
	+ case IFM_10G_KR:
	+ case IFM_10G_KX4:
	#endif
	- speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	- speed \|= IXGBE_LINK_SPEED_10GB_FULL;
	- break;
	+ speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	+ speed \|= IXGBE_LINK_SPEED_10GB_FULL;
	+ break;
	#ifndef IFM_ETH_XTYPE
	- case IFM_1000_CX: /* KX */
	+ case IFM_1000_CX: /* KX */
	#else
	- case IFM_1000_KX:
	+ case IFM_1000_KX:
	#endif
	- case IFM_1000_LX:
	- case IFM_1000_SX:
	- speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	- break;
	- case IFM_1000_T:
	- speed \|= IXGBE_LINK_SPEED_100_FULL;
	- speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	- break;
	- case IFM_10G_TWINAX:
	- speed \|= IXGBE_LINK_SPEED_10GB_FULL;
	- break;
	- case IFM_100_TX:
	- speed \|= IXGBE_LINK_SPEED_100_FULL;
	- break;
	- case IFM_10_T:
	- speed \|= IXGBE_LINK_SPEED_10_FULL;
	- break;
	- default:
	- goto invalid;
	+ case IFM_1000_LX:
	+ case IFM_1000_SX:
	+ speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	+ break;
	+ case IFM_1000_T:
	+ speed \|= IXGBE_LINK_SPEED_100_FULL;
	+ speed \|= IXGBE_LINK_SPEED_1GB_FULL;
	+ break;
	+ case IFM_10G_TWINAX:
	+ speed \|= IXGBE_LINK_SPEED_10GB_FULL;
	+ break;
	+ case IFM_100_TX:
	+ speed \|= IXGBE_LINK_SPEED_100_FULL;
	+ break;
	+ case IFM_10_T:
	+ speed \|= IXGBE_LINK_SPEED_10_FULL;
	+ break;
	+ default:
	+ goto invalid;
	}

	hw->mac.autotry_restart = TRUE;
	@@ -2271,44 +2379,28 @@
	return (0);

	invalid:
	- device_printf(adapter->dev, "Invalid media type!\n");
	+ device_printf(iflib_get_dev(ctx), "Invalid media type!\n");

	return (EINVAL);
	-} /* ixgbe_media_change */
	+} /* ixgbe_if_media_change */

	/************************************************************************
	* ixgbe_set_promisc
	************************************************************************/
	-static void
	-ixgbe_set_promisc(struct adapter *adapter)
	+static int
	+ixgbe_if_promisc_set(if_ctx_t ctx, int flags)
	{
	- struct ifnet *ifp = adapter->ifp;
	- int mcnt = 0;
	- u32 rctl;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ u32 rctl;
	+ int mcnt = 0;

	rctl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL);
	rctl &= (~IXGBE_FCTRL_UPE);
	if (ifp->if_flags & IFF_ALLMULTI)
	mcnt = MAX_NUM_MULTICAST_ADDRESSES;
	else {
	- struct ifmultiaddr *ifma;
	-#if __FreeBSD_version < 800000
	- IF_ADDR_LOCK(ifp);
	-#else
	- if_maddr_rlock(ifp);
	-#endif
	- TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
	- if (ifma->ifma_addr->sa_family != AF_LINK)
	- continue;
	- if (mcnt == MAX_NUM_MULTICAST_ADDRESSES)
	- break;
	- mcnt++;
	- }
	-#if __FreeBSD_version < 800000
	- IF_ADDR_UNLOCK(ifp);
	-#else
	- if_maddr_runlock(ifp);
	-#endif
	+ mcnt = if_multiaddr_count(ifp, MAX_NUM_MULTICAST_ADDRESSES);
	}
	if (mcnt < MAX_NUM_MULTICAST_ADDRESSES)
	rctl &= (~IXGBE_FCTRL_MPE);
	@@ -2322,12 +2414,13 @@
	rctl &= ~IXGBE_FCTRL_UPE;
	IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, rctl);
	}
	-} /* ixgbe_set_promisc */
	+ return (0);
	+} /* ixgbe_if_promisc_set */

	/************************************************************************
	* ixgbe_msix_link - Link status change ISR (MSI/MSI-X)
	************************************************************************/
	-static void
	+static int
	ixgbe_msix_link(void *arg)
	{
	struct adapter *adapter = arg;
	@@ -2350,7 +2443,7 @@
	/* Link status change */
	if (eicr & IXGBE_EICR_LSC) {
	IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC);
	- taskqueue_enqueue(adapter->tq, &adapter->link_task);
	+ iflib_admin_intr_deferred(adapter->ctx);
	}

	if (adapter->hw.mac.type != ixgbe_mac_82598EB) {
	@@ -2358,17 +2451,16 @@
	(eicr & IXGBE_EICR_FLOW_DIR)) {
	/* This is probably overkill :) */
	if (!atomic_cmpset_int(&adapter->fdir_reinit, 0, 1))
	- return;
	+ return (FILTER_HANDLED);
	/* Disable the interrupt */
	- IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_FLOW_DIR);
	- taskqueue_enqueue(adapter->tq, &adapter->fdir_task);
	- }
	-
	- if (eicr & IXGBE_EICR_ECC) {
	- device_printf(adapter->dev,
	- "CRITICAL: ECC ERROR!! Please Reboot!!\n");
	- IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_ECC);
	- }
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EICR_FLOW_DIR);
	+ GROUPTASK_ENQUEUE(&adapter->fdir_task);
	+ } else
	+ if (eicr & IXGBE_EICR_ECC) {
	+ device_printf(iflib_get_dev(adapter->ctx),
	+ "\nCRITICAL: ECC ERROR!! Please Reboot!!\n");
	+ IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_ECC);
	+ }

	/* Check for over temp condition */
	if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) {
	@@ -2383,8 +2475,10 @@
	retval = hw->phy.ops.check_overtemp(hw);
	if (retval != IXGBE_ERR_OVERTEMP)
	break;
	- device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n");
	- device_printf(adapter->dev, "System shutdown required!\n");
	+ device_printf(iflib_get_dev(adapter->ctx),
	+ "\nCRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n");
	+ device_printf(iflib_get_dev(adapter->ctx),
	+ "System shutdown required!\n");
	break;
	default:
	if (!(eicr & IXGBE_EICR_TS))
	@@ -2392,8 +2486,10 @@
	retval = hw->phy.ops.check_overtemp(hw);
	if (retval != IXGBE_ERR_OVERTEMP)
	break;
	- device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n");
	- device_printf(adapter->dev, "System shutdown required!\n");
	+ device_printf(iflib_get_dev(adapter->ctx),
	+ "\nCRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n");
	+ device_printf(iflib_get_dev(adapter->ctx),
	+ "System shutdown required!\n");
	IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_TS);
	break;
	}
	@@ -2402,7 +2498,7 @@
	/* Check for VF message */
	if ((adapter->feat_en & IXGBE_FEATURE_SRIOV) &&
	(eicr & IXGBE_EICR_MAILBOX))
	- taskqueue_enqueue(adapter->tq, &adapter->mbx_task);
	+ GROUPTASK_ENQUEUE(&adapter->mbx_task);
	}

	if (ixgbe_is_sfp(hw)) {
	@@ -2414,14 +2510,14 @@

	if (eicr & eicr_mask) {
	IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask);
	- taskqueue_enqueue(adapter->tq, &adapter->mod_task);
	+ GROUPTASK_ENQUEUE(&adapter->mod_task);
	}

	if ((hw->mac.type == ixgbe_mac_82599EB) &&
	(eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) {
	IXGBE_WRITE_REG(hw, IXGBE_EICR,
	IXGBE_EICR_GPI_SDP1_BY_MAC(hw));
	- taskqueue_enqueue(adapter->tq, &adapter->msf_task);
	+ GROUPTASK_ENQUEUE(&adapter->msf_task);
	}
	}

	@@ -2435,11 +2531,13 @@
	if ((hw->phy.type == ixgbe_phy_x550em_ext_t) &&
	(eicr & IXGBE_EICR_GPI_SDP0_X540)) {
	IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP0_X540);
	- taskqueue_enqueue(adapter->tq, &adapter->phy_task);
	+ GROUPTASK_ENQUEUE(&adapter->phy_task);
	}

	/* Re-enable other interrupts */
	IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_OTHER);
	+
	+ return (FILTER_HANDLED);
	} /* ixgbe_msix_link */

	/************************************************************************
	@@ -2448,9 +2546,9 @@
	static int
	ixgbe_sysctl_interrupt_rate_handler(SYSCTL_HANDLER_ARGS)
	{
	- struct ix_queue que = ((struct ix_queue )oidp->oid_arg1);
	- int error;
	- unsigned int reg, usec, rate;
	+ struct ix_rx_queue que = ((struct ix_rx_queue )oidp->oid_arg1);
	+ int error;
	+ unsigned int reg, usec, rate;

	reg = IXGBE_READ_REG(&que->adapter->hw, IXGBE_EITR(que->msix));
	usec = ((reg & 0x0FF8) >> 3);
	@@ -2478,52 +2576,54 @@
	* ixgbe_add_device_sysctls
	************************************************************************/
	static void
	-ixgbe_add_device_sysctls(struct adapter *adapter)
	+ixgbe_add_device_sysctls(if_ctx_t ctx)
	{
	- device_t dev = adapter->dev;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	struct sysctl_oid_list *child;
	- struct sysctl_ctx_list *ctx;
	+ struct sysctl_ctx_list *ctx_list;

	- ctx = device_get_sysctl_ctx(dev);
	+ ctx_list = device_get_sysctl_ctx(dev);
	child = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));

	/* Sysctls for all devices */
	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fc", CTLTYPE_INT \| CTLFLAG_RW,
	- adapter, 0, ixgbe_sysctl_flowcntl, "I", IXGBE_SYSCTL_DESC_SET_FC);
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "fc",
	+ CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_flowcntl, "I",
	+ IXGBE_SYSCTL_DESC_SET_FC);

	adapter->enable_aim = ixgbe_enable_aim;
	- SYSCTL_ADD_INT(ctx, child, OID_AUTO, "enable_aim", CTLFLAG_RW,
	+ SYSCTL_ADD_INT(ctx_list, child, OID_AUTO, "enable_aim", CTLFLAG_RW,
	&adapter->enable_aim, 1, "Interrupt Moderation");

	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "advertise_speed",
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "advertise_speed",
	CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_advertise, "I",
	IXGBE_SYSCTL_DESC_ADV_SPEED);

	#ifdef IXGBE_DEBUG
	/* testing sysctls (for all devices) */
	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "power_state",
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "power_state",
	CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_power_state,
	"I", "PCI Power State");

	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "print_rss_config",
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "print_rss_config",
	CTLTYPE_STRING \| CTLFLAG_RD, adapter, 0,
	ixgbe_sysctl_print_rss_config, "A", "Prints RSS Configuration");
	#endif
	/* for X550 series devices */
	if (hw->mac.type >= ixgbe_mac_X550)
	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "dmac",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_dmac,
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "dmac",
	+ CTLTYPE_U16 \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_dmac,
	"I", "DMA Coalesce");

	/* for WoL-capable devices */
	if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T) {
	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "wol_enable",
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wol_enable",
	CTLTYPE_INT \| CTLFLAG_RW, adapter, 0,
	ixgbe_sysctl_wol_enable, "I", "Enable/Disable Wake on LAN");

	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "wufc",
	- CTLTYPE_INT \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_wufc,
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "wufc",
	+ CTLTYPE_U32 \| CTLFLAG_RW, adapter, 0, ixgbe_sysctl_wufc,
	"I", "Enable/Disable Wake Up Filters");
	}

	@@ -2532,22 +2632,22 @@
	struct sysctl_oid *phy_node;
	struct sysctl_oid_list *phy_list;

	- phy_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "phy",
	+ phy_node = SYSCTL_ADD_NODE(ctx_list, child, OID_AUTO, "phy",
	CTLFLAG_RD, NULL, "External PHY sysctls");
	phy_list = SYSCTL_CHILDREN(phy_node);

	- SYSCTL_ADD_PROC(ctx, phy_list, OID_AUTO, "temp",
	- CTLTYPE_INT \| CTLFLAG_RD, adapter, 0, ixgbe_sysctl_phy_temp,
	+ SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO, "temp",
	+ CTLTYPE_U16 \| CTLFLAG_RD, adapter, 0, ixgbe_sysctl_phy_temp,
	"I", "Current External PHY Temperature (Celsius)");

	- SYSCTL_ADD_PROC(ctx, phy_list, OID_AUTO, "overtemp_occurred",
	- CTLTYPE_INT \| CTLFLAG_RD, adapter, 0,
	+ SYSCTL_ADD_PROC(ctx_list, phy_list, OID_AUTO,
	+ "overtemp_occurred", CTLTYPE_U16 \| CTLFLAG_RD, adapter, 0,
	ixgbe_sysctl_phy_overtemp_occurred, "I",
	"External PHY High Temperature Event Occurred");
	}

	if (adapter->feat_cap & IXGBE_FEATURE_EEE) {
	- SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "eee_state",
	+ SYSCTL_ADD_PROC(ctx_list, child, OID_AUTO, "eee_state",
	CTLTYPE_INT \| CTLFLAG_RW, adapter, 0,
	ixgbe_sysctl_eee_state, "I", "EEE Power Save State");
	}
	@@ -2557,10 +2657,11 @@
	* ixgbe_allocate_pci_resources
	************************************************************************/
	static int
	-ixgbe_allocate_pci_resources(struct adapter *adapter)
	+ixgbe_allocate_pci_resources(if_ctx_t ctx)
	{
	- device_t dev = adapter->dev;
	- int rid;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+ int rid;

	rid = PCIR_BAR(0);
	adapter->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
	@@ -2591,83 +2692,37 @@
	* return 0 on success, positive on failure
	************************************************************************/
	static int
	-ixgbe_detach(device_t dev)
	+ixgbe_if_detach(if_ctx_t ctx)
	{
	- struct adapter *adapter = device_get_softc(dev);
	- struct ix_queue *que = adapter->queues;
	- struct tx_ring *txr = adapter->tx_rings;
	- u32 ctrl_ext;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+ u32 ctrl_ext;

	INIT_DEBUGOUT("ixgbe_detach: begin");

	- /* Make sure VLANS are not using driver */
	- if (adapter->ifp->if_vlantrunk != NULL) {
	- device_printf(dev, "Vlan in use, detach first\n");
	- return (EBUSY);
	- }
	-
	if (ixgbe_pci_iov_detach(dev) != 0) {
	device_printf(dev, "SR-IOV in use; detach first.\n");
	return (EBUSY);
	}

	- ether_ifdetach(adapter->ifp);
	- /* Stop the adapter */
	- IXGBE_CORE_LOCK(adapter);
	- ixgbe_setup_low_power_mode(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-
	- for (int i = 0; i < adapter->num_queues; i++, que++, txr++) {
	- if (que->tq) {
	- if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX))
	- taskqueue_drain(que->tq, &txr->txq_task);
	- taskqueue_drain(que->tq, &que->que_task);
	- taskqueue_free(que->tq);
	- }
	- }
	+ iflib_config_gtask_deinit(&adapter->mod_task);
	+ iflib_config_gtask_deinit(&adapter->msf_task);
	+ iflib_config_gtask_deinit(&adapter->phy_task);
	+ if (adapter->feat_cap & IXGBE_FEATURE_SRIOV)
	+ iflib_config_gtask_deinit(&adapter->mbx_task);

	- /* Drain the Link queue */
	- if (adapter->tq) {
	- taskqueue_drain(adapter->tq, &adapter->link_task);
	- taskqueue_drain(adapter->tq, &adapter->mod_task);
	- taskqueue_drain(adapter->tq, &adapter->msf_task);
	- if (adapter->feat_cap & IXGBE_FEATURE_SRIOV)
	- taskqueue_drain(adapter->tq, &adapter->mbx_task);
	- taskqueue_drain(adapter->tq, &adapter->phy_task);
	- if (adapter->feat_en & IXGBE_FEATURE_FDIR)
	- taskqueue_drain(adapter->tq, &adapter->fdir_task);
	- taskqueue_free(adapter->tq);
	- }
	+ ixgbe_setup_low_power_mode(ctx);

	/* let hardware know driver is unloading */
	ctrl_ext = IXGBE_READ_REG(&adapter->hw, IXGBE_CTRL_EXT);
	ctrl_ext &= ~IXGBE_CTRL_EXT_DRV_LOAD;
	IXGBE_WRITE_REG(&adapter->hw, IXGBE_CTRL_EXT, ctrl_ext);

	- /* Unregister VLAN events */
	- if (adapter->vlan_attach != NULL)
	- EVENTHANDLER_DEREGISTER(vlan_config, adapter->vlan_attach);
	- if (adapter->vlan_detach != NULL)
	- EVENTHANDLER_DEREGISTER(vlan_unconfig, adapter->vlan_detach);
	-
	- callout_drain(&adapter->timer);
	-
	- if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
	- netmap_detach(adapter->ifp);
	-
	- ixgbe_free_pci_resources(adapter);
	- bus_generic_detach(dev);
	- if_free(adapter->ifp);
	-
	- ixgbe_free_transmit_structures(adapter);
	- ixgbe_free_receive_structures(adapter);
	- free(adapter->queues, M_DEVBUF);
	+ ixgbe_free_pci_resources(ctx);
	free(adapter->mta, M_IXGBE);

	- IXGBE_CORE_LOCK_DESTROY(adapter);
	-
	return (0);
	-} /* ixgbe_detach */
	+} /* ixgbe_if_detach */

	/************************************************************************
	* ixgbe_setup_low_power_mode - LPLU/WoL preparation
	@@ -2675,13 +2730,15 @@
	* Prepare the adapter/port for LPLU and/or WoL
	************************************************************************/
	static int
	-ixgbe_setup_low_power_mode(struct adapter *adapter)
	+ixgbe_setup_low_power_mode(if_ctx_t ctx)
	{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	- device_t dev = adapter->dev;
	+ device_t dev = iflib_get_dev(ctx);
	s32 error = 0;

	- mtx_assert(&adapter->core_mtx, MA_OWNED);
	+ if (!hw->wol_enabled)
	+ ixgbe_set_phy_power(hw, FALSE);

	/* Limit power management flow to X550EM baseT */
	if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T &&
	@@ -2707,15 +2764,15 @@
	IXGBE_WUC_WKEN \| IXGBE_WUC_PME_EN);

	/* X550EM baseT adapters need a special LPLU flow */
	- hw->phy.reset_disable = true;
	- ixgbe_stop(adapter);
	+ hw->phy.reset_disable = TRUE;
	+ ixgbe_if_stop(ctx);
	error = hw->phy.ops.enter_lplu(hw);
	if (error)
	device_printf(dev, "Error entering LPLU: %d\n", error);
	- hw->phy.reset_disable = false;
	+ hw->phy.reset_disable = FALSE;
	} else {
	/* Just stop for other adapters */
	- ixgbe_stop(adapter);
	+ ixgbe_if_stop(ctx);
	}

	return error;
	@@ -2725,19 +2782,16 @@
	* ixgbe_shutdown - Shutdown entry point
	************************************************************************/
	static int
	-ixgbe_shutdown(device_t dev)
	+ixgbe_if_shutdown(if_ctx_t ctx)
	{
	- struct adapter *adapter = device_get_softc(dev);
	- int error = 0;
	+ int error = 0;

	INIT_DEBUGOUT("ixgbe_shutdown: begin");

	- IXGBE_CORE_LOCK(adapter);
	- error = ixgbe_setup_low_power_mode(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	+ error = ixgbe_setup_low_power_mode(ctx);

	return (error);
	-} /* ixgbe_shutdown */
	+} /* ixgbe_if_shutdown */

	/************************************************************************
	* ixgbe_suspend
	@@ -2745,21 +2799,16 @@
	* From D0 to D3
	************************************************************************/
	static int
	-ixgbe_suspend(device_t dev)
	+ixgbe_if_suspend(if_ctx_t ctx)
	{
	- struct adapter *adapter = device_get_softc(dev);
	- int error = 0;
	+ int error = 0;

	INIT_DEBUGOUT("ixgbe_suspend: begin");

	- IXGBE_CORE_LOCK(adapter);
	-
	- error = ixgbe_setup_low_power_mode(adapter);
	-
	- IXGBE_CORE_UNLOCK(adapter);
	+ error = ixgbe_setup_low_power_mode(ctx);

	return (error);
	-} /* ixgbe_suspend */
	+} /* ixgbe_if_suspend */

	/************************************************************************
	* ixgbe_resume
	@@ -2767,17 +2816,16 @@
	* From D3 to D0
	************************************************************************/
	static int
	-ixgbe_resume(device_t dev)
	+ixgbe_if_resume(if_ctx_t ctx)
	{
	- struct adapter *adapter = device_get_softc(dev);
	- struct ifnet *ifp = adapter->ifp;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	u32 wus;

	INIT_DEBUGOUT("ixgbe_resume: begin");

	- IXGBE_CORE_LOCK(adapter);
	-
	/* Read & clear WUS register */
	wus = IXGBE_READ_REG(hw, IXGBE_WUS);
	if (wus)
	@@ -2792,81 +2840,105 @@
	* will re-advertise all previous advertised speeds
	*/
	if (ifp->if_flags & IFF_UP)
	- ixgbe_init_locked(adapter);
	-
	- IXGBE_CORE_UNLOCK(adapter);
	+ ixgbe_if_init(ctx);

	return (0);
	-} /* ixgbe_resume */
	+} /* ixgbe_if_resume */

	/************************************************************************
	- * ixgbe_set_if_hwassist - Set the various hardware offload abilities.
	+ * ixgbe_if_mtu_set - Ioctl mtu entry point
	*
	- * Takes the ifnet's if_capenable flags (e.g. set by the user using
	- * ifconfig) and indicates to the OS via the ifnet's if_hwassist
	- * field what mbuf offload flags the driver will understand.
	+ * Return 0 on success, EINVAL on failure
	************************************************************************/
	-static void
	-ixgbe_set_if_hwassist(struct adapter *adapter)
	+static int
	+ixgbe_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
	{
	- struct ifnet *ifp = adapter->ifp;
	-
	- ifp->if_hwassist = 0;
	-#if __FreeBSD_version >= 1000000
	- if (ifp->if_capenable & IFCAP_TSO4)
	- ifp->if_hwassist \|= CSUM_IP_TSO;
	- if (ifp->if_capenable & IFCAP_TSO6)
	- ifp->if_hwassist \|= CSUM_IP6_TSO;
	- if (ifp->if_capenable & IFCAP_TXCSUM) {
	- ifp->if_hwassist \|= (CSUM_IP \| CSUM_IP_UDP \| CSUM_IP_TCP);
	- if (adapter->hw.mac.type != ixgbe_mac_82598EB)
	- ifp->if_hwassist \|= CSUM_IP_SCTP;
	- }
	- if (ifp->if_capenable & IFCAP_TXCSUM_IPV6) {
	- ifp->if_hwassist \|= (CSUM_IP6_UDP \| CSUM_IP6_TCP);
	- if (adapter->hw.mac.type != ixgbe_mac_82598EB)
	- ifp->if_hwassist \|= CSUM_IP6_SCTP;
	- }
	-#else
	- if (ifp->if_capenable & IFCAP_TSO)
	- ifp->if_hwassist \|= CSUM_TSO;
	- if (ifp->if_capenable & IFCAP_TXCSUM) {
	- ifp->if_hwassist \|= (CSUM_TCP \| CSUM_UDP);
	- if (adapter->hw.mac.type != ixgbe_mac_82598EB)
	- ifp->if_hwassist \|= CSUM_SCTP;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ int error = 0;
	+
	+ IOCTL_DEBUGOUT("ioctl: SIOCIFMTU (Set Interface MTU)");
	+
	+ if (mtu > IXGBE_MAX_MTU) {
	+ error = EINVAL;
	+ } else {
	+ adapter->max_frame_size = mtu + IXGBE_MTU_HDR;
	}
	-#endif
	-} /* ixgbe_set_if_hwassist */
	+
	+ return error;
	+} /* ixgbe_if_mtu_set */

	/************************************************************************
	- * ixgbe_init_locked - Init entry point
	+ * ixgbe_if_crcstrip_set
	+ ************************************************************************/
	+static void
	+ixgbe_if_crcstrip_set(if_ctx_t ctx, int onoff, int crcstrip)
	+{
	+ struct adapter *sc = iflib_get_softc(ctx);
	+ struct ixgbe_hw *hw = &sc->hw;
	+ /* crc stripping is set in two places:
	+ * IXGBE_HLREG0 (modified on init_locked and hw reset)
	+ * IXGBE_RDRXCTL (set by the original driver in
	+ * ixgbe_setup_hw_rsc() called in init_locked.
	+ * We disable the setting when netmap is compiled in).
	+ * We update the values here, but also in ixgbe.c because
	+ * init_locked sometimes is called outside our control.
	+ */
	+ uint32_t hl, rxc;
	+
	+ hl = IXGBE_READ_REG(hw, IXGBE_HLREG0);
	+ rxc = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
	+#ifdef NETMAP
	+ if (netmap_verbose)
	+ D("%s read HLREG 0x%x rxc 0x%x",
	+ onoff ? "enter" : "exit", hl, rxc);
	+#endif
	+ /* hw requirements ... */
	+ rxc &= ~IXGBE_RDRXCTL_RSCFRSTSIZE;
	+ rxc \|= IXGBE_RDRXCTL_RSCACKC;
	+ if (onoff && !crcstrip) {
	+ /* keep the crc. Fast rx */
	+ hl &= ~IXGBE_HLREG0_RXCRCSTRP;
	+ rxc &= ~IXGBE_RDRXCTL_CRCSTRIP;
	+ } else {
	+ /* reset default mode */
	+ hl \|= IXGBE_HLREG0_RXCRCSTRP;
	+ rxc \|= IXGBE_RDRXCTL_CRCSTRIP;
	+ }
	+#ifdef NETMAP
	+ if (netmap_verbose)
	+ D("%s write HLREG 0x%x rxc 0x%x",
	+ onoff ? "enter" : "exit", hl, rxc);
	+#endif
	+ IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hl);
	+ IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, rxc);
	+} /* ixgbe_if_crcstrip_set */
	+
	+/*********************************************************************
	+ * ixgbe_if_init - Init entry point
	*
	* Used in two ways: It is used by the stack as an init
	* entry point in network interface structure. It is also
	* used by the driver as a hw/sw initialization routine to
	* get to a consistent state.
	*
	- * return 0 on success, positive on failure
	- ************************************************************************/
	+ * Return 0 on success, positive on failure
	+ **********************************************************************/
	void
	-ixgbe_init_locked(struct adapter *adapter)
	+ixgbe_if_init(if_ctx_t ctx)
	{
	- struct ifnet *ifp = adapter->ifp;
	- device_t dev = adapter->dev;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	- struct tx_ring *txr;
	- struct rx_ring *rxr;
	+ struct ix_rx_queue *rx_que;
	+ struct ix_tx_queue *tx_que;
	u32 txdctl, mhadd;
	u32 rxdctl, rxctrl;
	u32 ctrl_ext;
	- int err = 0;

	- mtx_assert(&adapter->core_mtx, MA_OWNED);
	- INIT_DEBUGOUT("ixgbe_init_locked: begin");
	+ int i, j, err;

	- hw->adapter_stopped = FALSE;
	- ixgbe_stop_adapter(hw);
	- callout_stop(&adapter->timer);
	+ INIT_DEBUGOUT("ixgbe_if_init: begin");

	/* Queue indices may change with IOV mode */
	ixgbe_align_all_queue_indices(adapter);
	@@ -2879,22 +2951,14 @@
	ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, 1);
	hw->addr_ctrl.rar_used_count = 1;

	- /* Set hardware offload abilities from ifnet flags */
	- ixgbe_set_if_hwassist(adapter);
	-
	- /* Prepare transmit descriptors and buffers */
	- if (ixgbe_setup_transmit_structures(adapter)) {
	- device_printf(dev, "Could not setup transmit structures\n");
	- ixgbe_stop(adapter);
	- return;
	- }
	-
	ixgbe_init_hw(hw);
	+
	ixgbe_initialize_iov(adapter);
	- ixgbe_initialize_transmit_units(adapter);
	+
	+ ixgbe_initialize_transmit_units(ctx);

	/* Setup Multicast table */
	- ixgbe_set_multi(adapter);
	+ ixgbe_if_multi_set(ctx);

	/* Determine the correct mbuf pool, based on frame size */
	if (adapter->max_frame_size <= MCLBYTES)
	@@ -2902,15 +2966,8 @@
	else
	adapter->rx_mbuf_sz = MJUMPAGESIZE;

	- /* Prepare receive descriptors and buffers */
	- if (ixgbe_setup_receive_structures(adapter)) {
	- device_printf(dev, "Could not setup receive structures\n");
	- ixgbe_stop(adapter);
	- return;
	- }
	-
	/* Configure RX settings */
	- ixgbe_initialize_receive_units(adapter);
	+ ixgbe_initialize_receive_units(ctx);

	/* Enable SDP & MSI-X interrupts based on adapter */
	ixgbe_config_gpie(adapter);
	@@ -2925,8 +2982,9 @@
	}

	/* Now enable all the queues */
	- for (int i = 0; i < adapter->num_queues; i++) {
	- txr = &adapter->tx_rings[i];
	+ for (i = 0, tx_que = adapter->tx_queues; i < adapter->num_tx_queues; i++, tx_que++) {
	+ struct tx_ring *txr = &tx_que->txr;
	+
	txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me));
	txdctl \|= IXGBE_TXDCTL_ENABLE;
	/* Set WTHRESH to 8, burst writeback */
	@@ -2942,8 +3000,9 @@
	IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl);
	}

	- for (int i = 0, j = 0; i < adapter->num_queues; i++) {
	- rxr = &adapter->rx_rings[i];
	+ for (i = 0, rx_que = adapter->rx_queues; i < adapter->num_rx_queues; i++, rx_que++) {
	+ struct rx_ring *rxr = &rx_que->rxr;
	+
	rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me));
	if (hw->mac.type == ixgbe_mac_82598EB) {
	/*
	@@ -2956,7 +3015,7 @@
	}
	rxdctl \|= IXGBE_RXDCTL_ENABLE;
	IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl);
	- for (; j < 10; j++) {
	+ for (j = 0; j < 10; j++) {
	if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) &
	IXGBE_RXDCTL_ENABLE)
	break;
	@@ -2964,35 +3023,6 @@
	msec_delay(1);
	}
	wmb();
	-
	- /*
	- * In netmap mode, we must preserve the buffers made
	- * available to userspace before the if_init()
	- * (this is true by default on the TX side, because
	- * init makes all buffers available to userspace).
	- *
	- * netmap_reset() and the device specific routines
	- * (e.g. ixgbe_setup_receive_rings()) map these
	- * buffers at the end of the NIC ring, so here we
	- * must set the RDT (tail) register to make sure
	- * they are not overwritten.
	- *
	- * In this driver the NIC ring starts at RDH = 0,
	- * RDT points to the last slot available for reception (?),
	- * so RDT = num_rx_desc - 1 means the whole ring is available.
	- */
	-#ifdef DEV_NETMAP
	- if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) &&
	- (ifp->if_capenable & IFCAP_NETMAP)) {
	- struct netmap_adapter *na = NA(adapter->ifp);
	- struct netmap_kring *kring = &na->rx_rings[i];
	- int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring);
	-
	- IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me), t);
	- } else
	-#endif /* DEV_NETMAP */
	- IXGBE_WRITE_REG(hw, IXGBE_RDT(rxr->me),
	- adapter->num_rx_desc - 1);
	}

	/* Enable Receive engine */
	@@ -3002,10 +3032,8 @@
	rxctrl \|= IXGBE_RXCTRL_RXEN;
	ixgbe_enable_rx_dma(hw, rxctrl);

	- callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter);
	-
	- /* Set up MSI-X routing */
	- if (adapter->feat_en & IXGBE_FEATURE_MSIX) {
	+ /* Set up MSI/MSI-X routing */
	+ if (ixgbe_enable_msix) {
	ixgbe_configure_ivars(adapter);
	/* Set up auto-mask */
	if (hw->mac.type == ixgbe_mac_82598EB)
	@@ -3038,6 +3066,9 @@
	/* Set moderation on the Link interrupt */
	IXGBE_WRITE_REG(hw, IXGBE_EITR(adapter->vector), IXGBE_LINK_ITR);

	+ /* Enable power to the phy. */
	+ ixgbe_set_phy_power(hw, TRUE);
	+
	/* Config/Enable Link */
	ixgbe_config_link(adapter);

	@@ -3048,13 +3079,13 @@
	ixgbe_start_hw(hw);

	/* Set up VLAN support and filter */
	- ixgbe_setup_vlan_hw_support(adapter);
	+ ixgbe_setup_vlan_hw_support(ctx);

	/* Setup DMA Coalescing */
	ixgbe_config_dmac(adapter);

	/* And now turn on interrupts */
	- ixgbe_enable_intr(adapter);
	+ ixgbe_if_enable_intr(ctx);

	/* Enable the use of the MBX by the VF's */
	if (adapter->feat_en & IXGBE_FEATURE_SRIOV) {
	@@ -3063,27 +3094,8 @@
	IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext);
	}

	- /* Now inform the stack we're ready */
	- ifp->if_drv_flags \|= IFF_DRV_RUNNING;
	-
	- return;
	} /* ixgbe_init_locked */

	-/************************************************************************
	- * ixgbe_init
	- ************************************************************************/
	-static void
	-ixgbe_init(void *arg)
	-{
	- struct adapter *adapter = arg;
	-
	- IXGBE_CORE_LOCK(adapter);
	- ixgbe_init_locked(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-
	- return;
	-} /* ixgbe_init */
	-
	/************************************************************************
	* ixgbe_set_ivar
	*
	@@ -3102,7 +3114,6 @@
	vector \|= IXGBE_IVAR_ALLOC_VAL;

	switch (hw->mac.type) {
	-
	case ixgbe_mac_82598EB:
	if (type == -1)
	entry = IXGBE_IVAR_OTHER_CAUSES_INDEX;
	@@ -3114,7 +3125,6 @@
	ivar \|= (vector << (8 * (entry & 0x3)));
	IXGBE_WRITE_REG(&adapter->hw, IXGBE_IVAR(index), ivar);
	break;
	-
	case ixgbe_mac_82599EB:
	case ixgbe_mac_X540:
	case ixgbe_mac_X550:
	@@ -3133,7 +3143,6 @@
	ivar \|= (vector << index);
	IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar);
	}
	-
	default:
	break;
	}
	@@ -3145,8 +3154,9 @@
	static void
	ixgbe_configure_ivars(struct adapter *adapter)
	{
	- struct ix_queue *que = adapter->queues;
	- u32 newitr;
	+ struct ix_rx_queue *rx_que = adapter->rx_queues;
	+ struct ix_tx_queue *tx_que = adapter->tx_queues;
	+ u32 newitr;

	if (ixgbe_max_interrupt_rate > 0)
	newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8;
	@@ -3159,17 +3169,21 @@
	newitr = 0;
	}

	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	- struct rx_ring *rxr = &adapter->rx_rings[i];
	- struct tx_ring *txr = &adapter->tx_rings[i];
	+ for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++) {
	+ struct rx_ring *rxr = &rx_que->rxr;
	+
	/* First the RX queue entry */
	- ixgbe_set_ivar(adapter, rxr->me, que->msix, 0);
	- /* ... and the TX */
	- ixgbe_set_ivar(adapter, txr->me, que->msix, 1);
	+ ixgbe_set_ivar(adapter, rxr->me, rx_que->msix, 0);
	+
	/* Set an Initial EITR value */
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(que->msix), newitr);
	+ IXGBE_WRITE_REG(&adapter->hw, IXGBE_EITR(rx_que->msix), newitr);
	}
	+ for (int i = 0; i < adapter->num_tx_queues; i++, tx_que++) {
	+ struct tx_ring *txr = &tx_que->txr;

	+ /* ... and the TX */
	+ ixgbe_set_ivar(adapter, txr->me, tx_que->msix, 1);
	+ }
	/* For the Link interrupt */
	ixgbe_set_ivar(adapter, 1, adapter->vector, -1);
	} /* ixgbe_configure_ivars */
	@@ -3185,7 +3199,7 @@

	gpie = IXGBE_READ_REG(hw, IXGBE_GPIE);

	- if (adapter->feat_en & IXGBE_FEATURE_MSIX) {
	+ if (adapter->intr_type == IFLIB_INTR_MSIX) {
	/* Enable Enhanced MSI-X mode */
	gpie \|= IXGBE_GPIE_MSIX_MODE
	\| IXGBE_GPIE_EIAME
	@@ -3216,7 +3230,6 @@

	IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);

	- return;
	} /* ixgbe_config_gpie */

	/************************************************************************
	@@ -3271,41 +3284,39 @@
	*
	* Called whenever multicast address list is updated.
	************************************************************************/
	+static int
	+ixgbe_mc_filter_apply(void arg, struct ifmultiaddr ifma, int count)
	+{
	+ struct adapter *adapter = arg;
	+ struct ixgbe_mc_addr *mta = adapter->mta;
	+
	+ if (ifma->ifma_addr->sa_family != AF_LINK)
	+ return (0);
	+ if (count == MAX_NUM_MULTICAST_ADDRESSES)
	+ return (0);
	+ bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
	+ mta[count].addr, IXGBE_ETH_LENGTH_OF_ADDRESS);
	+ mta[count].vmdq = adapter->pool;
	+
	+ return (1);
	+} /* ixgbe_mc_filter_apply */
	+
	static void
	-ixgbe_set_multi(struct adapter *adapter)
	+ixgbe_if_multi_set(if_ctx_t ctx)
	{
	- struct ifmultiaddr *ifma;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_mc_addr *mta;
	- struct ifnet *ifp = adapter->ifp;
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	u8 *update_ptr;
	int mcnt = 0;
	u32 fctrl;

	- IOCTL_DEBUGOUT("ixgbe_set_multi: begin");
	+ IOCTL_DEBUGOUT("ixgbe_if_multi_set: begin");

	mta = adapter->mta;
	bzero(mta, sizeof(mta) MAX_NUM_MULTICAST_ADDRESSES);

	-#if __FreeBSD_version < 800000
	- IF_ADDR_LOCK(ifp);
	-#else
	- if_maddr_rlock(ifp);
	-#endif
	- TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
	- if (ifma->ifma_addr->sa_family != AF_LINK)
	- continue;
	- if (mcnt == MAX_NUM_MULTICAST_ADDRESSES)
	- break;
	- bcopy(LLADDR((struct sockaddr_dl *) ifma->ifma_addr),
	- mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS);
	- mta[mcnt].vmdq = adapter->pool;
	- mcnt++;
	- }
	-#if __FreeBSD_version < 800000
	- IF_ADDR_UNLOCK(ifp);
	-#else
	- if_maddr_runlock(ifp);
	-#endif
	+ mcnt = if_multi_apply(iflib_get_ifp(ctx), ixgbe_mc_filter_apply, adapter);

	fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL);
	fctrl \|= (IXGBE_FCTRL_UPE \| IXGBE_FCTRL_MPE);
	@@ -3326,8 +3337,7 @@
	ixgbe_mc_array_itr, TRUE);
	}

	- return;
	-} /* ixgbe_set_multi */
	+} /* ixgbe_if_multi_set */

	/************************************************************************
	* ixgbe_mc_array_itr
	@@ -3356,73 +3366,25 @@
	* and runs the watchdog check.
	************************************************************************/
	static void
	-ixgbe_local_timer(void *arg)
	+ixgbe_if_timer(if_ctx_t ctx, uint16_t qid)
	{
	- struct adapter *adapter = arg;
	- device_t dev = adapter->dev;
	- struct ix_queue *que = adapter->queues;
	- u64 queues = 0;
	- int hung = 0;
	+ struct adapter *adapter = iflib_get_softc(ctx);

	- mtx_assert(&adapter->core_mtx, MA_OWNED);
	+ if (qid != 0)
	+ return;

	/* Check for pluggable optics */
	if (adapter->sfp_probe)
	- if (!ixgbe_sfp_probe(adapter))
	- goto out; /* Nothing to do */
	-
	- ixgbe_update_link_status(adapter);
	- ixgbe_update_stats_counters(adapter);
	-
	- /*
	- * Check the TX queues status
	- * - mark hung queues so we don't schedule on them
	- * - watchdog only if all queues show hung
	- */
	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	- /* Keep track of queues with work for soft irq */
	- if (que->txr->busy)
	- queues \|= ((u64)1 << que->me);
	- /*
	- * Each time txeof runs without cleaning, but there
	- * are uncleaned descriptors it increments busy. If
	- * we get to the MAX we declare it hung.
	- */
	- if (que->busy == IXGBE_QUEUE_HUNG) {
	- ++hung;
	- /* Mark the queue as inactive */
	- adapter->active_queues &= ~((u64)1 << que->me);
	- continue;
	- } else {
	- /* Check if we've come back from hung */
	- if ((adapter->active_queues & ((u64)1 << que->me)) == 0)
	- adapter->active_queues \|= ((u64)1 << que->me);
	- }
	- if (que->busy >= IXGBE_MAX_TX_BUSY) {
	- device_printf(dev,
	- "Warning queue %d appears to be hung!\n", i);
	- que->txr->busy = IXGBE_QUEUE_HUNG;
	- ++hung;
	- }
	- }
	+ if (!ixgbe_sfp_probe(ctx))
	+ return; /* Nothing to do */

	- /* Only truly watchdog if all queues show hung */
	- if (hung == adapter->num_queues)
	- goto watchdog;
	- else if (queues != 0) { /* Force an IRQ on queues with work */
	- ixgbe_rearm_queues(adapter, queues);
	- }
	+ ixgbe_check_link(&adapter->hw, &adapter->link_speed,
	+ &adapter->link_up, 0);

	-out:
	- callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter);
	- return;
	+ /* Fire off the adminq task */
	+ iflib_admin_intr_deferred(ctx);

	-watchdog:
	- device_printf(adapter->dev, "Watchdog timeout -- resetting\n");
	- adapter->ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
	- adapter->watchdog_events++;
	- ixgbe_init_locked(adapter);
	-} /* ixgbe_local_timer */
	+} /* ixgbe_if_timer */

	/************************************************************************
	* ixgbe_sfp_probe
	@@ -3430,10 +3392,11 @@
	* Determine if a port had optics inserted.
	************************************************************************/
	static bool
	-ixgbe_sfp_probe(struct adapter *adapter)
	+ixgbe_sfp_probe(if_ctx_t ctx)
	{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	- device_t dev = adapter->dev;
	+ device_t dev = iflib_get_dev(ctx);
	bool result = FALSE;

	if ((hw->phy.type == ixgbe_phy_nl) &&
	@@ -3462,11 +3425,12 @@
	* ixgbe_handle_mod - Tasklet for SFP module interrupts
	************************************************************************/
	static void
	-ixgbe_handle_mod(void *context, int pending)
	+ixgbe_handle_mod(void *context)
	{
	- struct adapter *adapter = context;
	+ if_ctx_t ctx = context;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	- device_t dev = adapter->dev;
	+ device_t dev = iflib_get_dev(ctx);
	u32 err, cage_full = 0;

	if (adapter->hw.need_crosstalk_fix) {
	@@ -3501,7 +3465,7 @@
	"Setup failure - unsupported SFP+ module type.\n");
	return;
	}
	- taskqueue_enqueue(adapter->tq, &adapter->msf_task);
	+ GROUPTASK_ENQUEUE(&adapter->msf_task);
	} /* ixgbe_handle_mod */


	@@ -3509,9 +3473,10 @@
	* ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts
	************************************************************************/
	static void
	-ixgbe_handle_msf(void *context, int pending)
	+ixgbe_handle_msf(void *context)
	{
	- struct adapter *adapter = context;
	+ if_ctx_t ctx = context;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	u32 autoneg;
	bool negotiate;
	@@ -3526,18 +3491,19 @@
	hw->mac.ops.setup_link(hw, autoneg, TRUE);

	/* Adjust media types shown in ifconfig */
	- ifmedia_removeall(&adapter->media);
	- ixgbe_add_media_types(adapter);
	- ifmedia_set(&adapter->media, IFM_ETHER \| IFM_AUTO);
	+ ifmedia_removeall(adapter->media);
	+ ixgbe_add_media_types(adapter->ctx);
	+ ifmedia_set(adapter->media, IFM_ETHER \| IFM_AUTO);
	} /* ixgbe_handle_msf */

	/************************************************************************
	* ixgbe_handle_phy - Tasklet for external PHY interrupts
	************************************************************************/
	static void
	-ixgbe_handle_phy(void *context, int pending)
	+ixgbe_handle_phy(void *context)
	{
	- struct adapter *adapter = context;
	+ if_ctx_t ctx = context;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	int error;

	@@ -3550,28 +3516,18 @@
	} /* ixgbe_handle_phy */

	/************************************************************************
	- * ixgbe_stop - Stop the hardware
	+ * ixgbe_if_stop - Stop the hardware
	*
	* Disables all traffic on the adapter by issuing a
	* global reset on the MAC and deallocates TX/RX buffers.
	************************************************************************/
	static void
	-ixgbe_stop(void *arg)
	+ixgbe_if_stop(if_ctx_t ctx)
	{
	- struct ifnet *ifp;
	- struct adapter *adapter = arg;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;

	- ifp = adapter->ifp;
	-
	- mtx_assert(&adapter->core_mtx, MA_OWNED);
	-
	- INIT_DEBUGOUT("ixgbe_stop: begin\n");
	- ixgbe_disable_intr(adapter);
	- callout_stop(&adapter->timer);
	-
	- /* Let the stack know...*/
	- ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
	+ INIT_DEBUGOUT("ixgbe_if_stop: begin\n");

	ixgbe_reset_hw(hw);
	hw->adapter_stopped = FALSE;
	@@ -3583,13 +3539,13 @@

	/* Update the stack */
	adapter->link_up = FALSE;
	- ixgbe_update_link_status(adapter);
	+ ixgbe_if_update_admin_status(ctx);

	/* reprogram the RAR[0] in case user changed it. */
	ixgbe_set_rar(&adapter->hw, 0, adapter->hw.mac.addr, 0, IXGBE_RAH_AV);

	return;
	-} /* ixgbe_stop */
	+} /* ixgbe_if_stop */

	/************************************************************************
	* ixgbe_update_link_status - Update OS on link state
	@@ -3599,10 +3555,10 @@
	* a link interrupt.
	************************************************************************/
	static void
	-ixgbe_update_link_status(struct adapter *adapter)
	+ixgbe_if_update_admin_status(if_ctx_t ctx)
	{
	- struct ifnet *ifp = adapter->ifp;
	- device_t dev = adapter->dev;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);

	if (adapter->link_up) {
	if (adapter->link_active == FALSE) {
	@@ -3615,7 +3571,9 @@
	ixgbe_fc_enable(&adapter->hw);
	/* Update DMA coalescing config */
	ixgbe_config_dmac(adapter);
	- if_link_state_change(ifp, LINK_STATE_UP);
	+ /* should actually be negotiated value */
	+ iflib_link_state_change(ctx, LINK_STATE_UP, IF_Gbps(10));
	+
	if (adapter->feat_en & IXGBE_FEATURE_SRIOV)
	ixgbe_ping_all_vfs(adapter);
	}
	@@ -3623,15 +3581,18 @@
	if (adapter->link_active == TRUE) {
	if (bootverbose)
	device_printf(dev, "Link is Down\n");
	- if_link_state_change(ifp, LINK_STATE_DOWN);
	+ iflib_link_state_change(ctx, LINK_STATE_DOWN, 0);
	adapter->link_active = FALSE;
	if (adapter->feat_en & IXGBE_FEATURE_SRIOV)
	ixgbe_ping_all_vfs(adapter);
	}
	}

	- return;
	-} /* ixgbe_update_link_status */
	+ ixgbe_update_stats_counters(adapter);
	+
	+ /* Re-enable link interrupts */
	+ IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, IXGBE_EIMS_LSC);
	+} /* ixgbe_if_update_admin_status */

	/************************************************************************
	* ixgbe_config_dmac - Configure DMA Coalescing
	@@ -3648,7 +3609,7 @@
	if (dcfg->watchdog_timer ^ adapter->dmac \|\|
	dcfg->link_speed ^ adapter->link_speed) {
	dcfg->watchdog_timer = adapter->dmac;
	- dcfg->fcoe_en = false;
	+ dcfg->fcoe_en = FALSE;
	dcfg->link_speed = adapter->link_speed;
	dcfg->num_tcs = 1;

	@@ -3660,14 +3621,15 @@
	} /* ixgbe_config_dmac */

	/************************************************************************
	- * ixgbe_enable_intr
	+ * ixgbe_if_enable_intr
	************************************************************************/
	-static void
	-ixgbe_enable_intr(struct adapter *adapter)
	+void
	+ixgbe_if_enable_intr(if_ctx_t ctx)
	{
	- struct ixgbe_hw *hw = &adapter->hw;
	- struct ix_queue *que = adapter->queues;
	- u32 mask, fwsm;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ struct ix_rx_queue *que = adapter->rx_queues;
	+ u32 mask, fwsm;

	mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE);

	@@ -3721,7 +3683,7 @@
	IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask);

	/* With MSI-X we use auto clear */
	- if (adapter->msix_mem) {
	+ if (adapter->intr_type == IFLIB_INTR_MSIX) {
	mask = IXGBE_EIMS_ENABLE_MASK;
	/* Don't autoclear Link */
	mask &= ~IXGBE_EIMS_OTHER;
	@@ -3736,21 +3698,22 @@
	* allow for handling the extended (beyond 32) MSI-X
	* vectors that can be used by 82599
	*/
	- for (int i = 0; i < adapter->num_queues; i++, que++)
	+ for (int i = 0; i < adapter->num_rx_queues; i++, que++)
	ixgbe_enable_queue(adapter, que->msix);

	IXGBE_WRITE_FLUSH(hw);

	- return;
	-} /* ixgbe_enable_intr */
	+} /* ixgbe_if_enable_intr */

	/************************************************************************
	* ixgbe_disable_intr
	************************************************************************/
	static void
	-ixgbe_disable_intr(struct adapter *adapter)
	+ixgbe_if_disable_intr(if_ctx_t ctx)
	{
	- if (adapter->msix_mem)
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+
	+ if (adapter->intr_type == IFLIB_INTR_MSIX)
	IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0);
	if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
	IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~0);
	@@ -3761,53 +3724,101 @@
	}
	IXGBE_WRITE_FLUSH(&adapter->hw);

	- return;
	-} /* ixgbe_disable_intr */
	+} /* ixgbe_if_disable_intr */
	+
	+/************************************************************************
	+ * ixgbe_if_rx_queue_intr_enable
	+ ************************************************************************/
	+static int
	+ixgbe_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_rx_queue *que = &adapter->rx_queues[rxqid];
	+
	+ ixgbe_enable_queue(adapter, que->rxr.me);
	+
	+ return (0);
	+} /* ixgbe_if_rx_queue_intr_enable */

	/************************************************************************
	- * ixgbe_legacy_irq - Legacy Interrupt Service routine
	+ * ixgbe_enable_queue
	************************************************************************/
	static void
	-ixgbe_legacy_irq(void *arg)
	+ixgbe_enable_queue(struct adapter *adapter, u32 vector)
	{
	- struct ix_queue *que = arg;
	- struct adapter *adapter = que->adapter;
	struct ixgbe_hw *hw = &adapter->hw;
	- struct ifnet *ifp = adapter->ifp;
	- struct tx_ring *txr = adapter->tx_rings;
	- bool more = false;
	- u32 eicr, eicr_mask;
	+ u64 queue = (u64)(1 << vector);
	+ u32 mask;

	- /* Silicon errata #26 on 82598 */
	- IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK);
	+ if (hw->mac.type == ixgbe_mac_82598EB) {
	+ mask = (IXGBE_EIMS_RTX_QUEUE & queue);
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask);
	+ } else {
	+ mask = (queue & 0xFFFFFFFF);
	+ if (mask)
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(0), mask);
	+ mask = (queue >> 32);
	+ if (mask)
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMS_EX(1), mask);
	+ }
	+} /* ixgbe_enable_queue */

	- eicr = IXGBE_READ_REG(hw, IXGBE_EICR);
	+/************************************************************************
	+ * ixgbe_disable_queue
	+ ************************************************************************/
	+static void
	+ixgbe_disable_queue(struct adapter *adapter, u32 vector)
	+{
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ u64 queue = (u64)(1 << vector);
	+ u32 mask;

	- ++que->irqs;
	- if (eicr == 0) {
	- ixgbe_enable_intr(adapter);
	- return;
	+ if (hw->mac.type == ixgbe_mac_82598EB) {
	+ mask = (IXGBE_EIMS_RTX_QUEUE & queue);
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMC, mask);
	+ } else {
	+ mask = (queue & 0xFFFFFFFF);
	+ if (mask)
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(0), mask);
	+ mask = (queue >> 32);
	+ if (mask)
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMC_EX(1), mask);
	}
	+} /* ixgbe_disable_queue */

	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- more = ixgbe_rxeof(que);
	+/************************************************************************
	+ * ixgbe_intr - Legacy Interrupt Service Routine
	+ ************************************************************************/
	+int
	+ixgbe_intr(void *arg)
	+{
	+ struct adapter *adapter = arg;
	+ struct ix_rx_queue *que = adapter->rx_queues;
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ if_ctx_t ctx = adapter->ctx;
	+ u32 eicr, eicr_mask;
	+
	+ eicr = IXGBE_READ_REG(hw, IXGBE_EICR);

	- IXGBE_TX_LOCK(txr);
	- ixgbe_txeof(txr);
	- if (!ixgbe_ring_empty(ifp, txr->br))
	- ixgbe_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	+ ++que->irqs;
	+ if (eicr == 0) {
	+ ixgbe_if_enable_intr(ctx);
	+ return (FILTER_HANDLED);
	}

	/* Check for fan failure */
	- if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) {
	- ixgbe_check_fan_failure(adapter, eicr, true);
	+ if ((hw->device_id == IXGBE_DEV_ID_82598AT) &&
	+ (eicr & IXGBE_EICR_GPI_SDP1)) {
	+ device_printf(adapter->dev,
	+ "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n");
	IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw));
	}

	/* Link status change */
	- if (eicr & IXGBE_EICR_LSC)
	- taskqueue_enqueue(adapter->tq, &adapter->link_task);
	+ if (eicr & IXGBE_EICR_LSC) {
	+ IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC);
	+ iflib_admin_intr_deferred(ctx);
	+ }

	if (ixgbe_is_sfp(hw)) {
	/* Pluggable optics-related interrupt */
	@@ -3818,94 +3829,52 @@

	if (eicr & eicr_mask) {
	IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask);
	- taskqueue_enqueue(adapter->tq, &adapter->mod_task);
	+ GROUPTASK_ENQUEUE(&adapter->mod_task);
	}

	if ((hw->mac.type == ixgbe_mac_82599EB) &&
	(eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) {
	IXGBE_WRITE_REG(hw, IXGBE_EICR,
	IXGBE_EICR_GPI_SDP1_BY_MAC(hw));
	- taskqueue_enqueue(adapter->tq, &adapter->msf_task);
	+ GROUPTASK_ENQUEUE(&adapter->msf_task);
	}
	}

	/* External PHY interrupt */
	if ((hw->phy.type == ixgbe_phy_x550em_ext_t) &&
	(eicr & IXGBE_EICR_GPI_SDP0_X540))
	- taskqueue_enqueue(adapter->tq, &adapter->phy_task);
	+ GROUPTASK_ENQUEUE(&adapter->phy_task);

	- if (more)
	- taskqueue_enqueue(que->tq, &que->que_task);
	- else
	- ixgbe_enable_intr(adapter);
	-
	- return;
	-} /* ixgbe_legacy_irq */
	+ return (FILTER_SCHEDULE_THREAD);
	+} /* ixgbe_intr */

	/************************************************************************
	* ixgbe_free_pci_resources
	************************************************************************/
	static void
	-ixgbe_free_pci_resources(struct adapter *adapter)
	+ixgbe_free_pci_resources(if_ctx_t ctx)
	{
	- struct ix_queue *que = adapter->queues;
	- device_t dev = adapter->dev;
	- int rid, memrid;
	-
	- if (adapter->hw.mac.type == ixgbe_mac_82598EB)
	- memrid = PCIR_BAR(MSIX_82598_BAR);
	- else
	- memrid = PCIR_BAR(MSIX_82599_BAR);
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_rx_queue *que = adapter->rx_queues;
	+ device_t dev = iflib_get_dev(ctx);

	- /*
	- * There is a slight possibility of a failure mode
	- * in attach that will result in entering this function
	- * before interrupt resources have been initialized, and
	- * in that case we do not want to execute the loops below
	- * We can detect this reliably by the state of the adapter
	- * res pointer.
	- */
	- if (adapter->res == NULL)
	- goto mem;
	+ /* Release all msix queue resources */
	+ if (adapter->intr_type == IFLIB_INTR_MSIX)
	+ iflib_irq_free(ctx, &adapter->irq);

	- /*
	- * Release all msix queue resources:
	- */
	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	- rid = que->msix + 1;
	- if (que->tag != NULL) {
	- bus_teardown_intr(dev, que->res, que->tag);
	- que->tag = NULL;
	+ if (que != NULL) {
	+ for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
	+ iflib_irq_free(ctx, &que->que_irq);
	}
	- if (que->res != NULL)
	- bus_release_resource(dev, SYS_RES_IRQ, rid, que->res);
	- }
	-
	-
	- if (adapter->tag != NULL) {
	- bus_teardown_intr(dev, adapter->res, adapter->tag);
	- adapter->tag = NULL;
	}

	- /* Clean the Legacy or Link interrupt last */
	- if (adapter->res != NULL)
	- bus_release_resource(dev, SYS_RES_IRQ, adapter->link_rid,
	- adapter->res);
	-
	-mem:
	- if ((adapter->feat_en & IXGBE_FEATURE_MSI) \|\|
	- (adapter->feat_en & IXGBE_FEATURE_MSIX))
	- pci_release_msi(dev);
	-
	- if (adapter->msix_mem != NULL)
	- bus_release_resource(dev, SYS_RES_MEMORY, memrid,
	- adapter->msix_mem);
	-
	+ /*
	+ * Free link/admin interrupt
	+ */
	if (adapter->pci_mem != NULL)
	- bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0),
	- adapter->pci_mem);
	+ bus_release_resource(dev, SYS_RES_MEMORY,
	+ PCIR_BAR(0), adapter->pci_mem);

	- return;
	} /* ixgbe_free_pci_resources */

	/************************************************************************
	@@ -3963,12 +3932,12 @@
	case ixgbe_fc_tx_pause:
	case ixgbe_fc_full:
	adapter->hw.fc.requested_mode = fc;
	- if (adapter->num_queues > 1)
	+ if (adapter->num_rx_queues > 1)
	ixgbe_disable_rx_drop(adapter);
	break;
	case ixgbe_fc_none:
	adapter->hw.fc.requested_mode = ixgbe_fc_none;
	- if (adapter->num_queues > 1)
	+ if (adapter->num_rx_queues > 1)
	ixgbe_enable_rx_drop(adapter);
	break;
	default:
	@@ -3998,8 +3967,8 @@
	struct rx_ring *rxr;
	u32 srrctl;

	- for (int i = 0; i < adapter->num_queues; i++) {
	- rxr = &adapter->rx_rings[i];
	+ for (int i = 0; i < adapter->num_rx_queues; i++) {
	+ rxr = &adapter->rx_queues[i].rxr;
	srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me));
	srrctl \|= IXGBE_SRRCTL_DROP_EN;
	IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl);
	@@ -4008,8 +3977,8 @@
	/* enable drop for each vf */
	for (int i = 0; i < adapter->num_vfs; i++) {
	IXGBE_WRITE_REG(hw, IXGBE_QDE,
	- (IXGBE_QDE_WRITE \| (i << IXGBE_QDE_IDX_SHIFT) \|
	- IXGBE_QDE_ENABLE));
	+ (IXGBE_QDE_WRITE \| (i << IXGBE_QDE_IDX_SHIFT) \|
	+ IXGBE_QDE_ENABLE));
	}
	} /* ixgbe_enable_rx_drop */

	@@ -4023,8 +3992,8 @@
	struct rx_ring *rxr;
	u32 srrctl;

	- for (int i = 0; i < adapter->num_queues; i++) {
	- rxr = &adapter->rx_rings[i];
	+ for (int i = 0; i < adapter->num_rx_queues; i++) {
	+ rxr = &adapter->rx_queues[i].rxr;
	srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me));
	srrctl &= ~IXGBE_SRRCTL_DROP_EN;
	IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl);
	@@ -4070,7 +4039,7 @@
	static int
	ixgbe_set_advertise(struct adapter *adapter, int advertise)
	{
	- device_t dev;
	+ device_t dev = iflib_get_dev(adapter->ctx);
	struct ixgbe_hw *hw;
	ixgbe_link_speed speed = 0;
	ixgbe_link_speed link_caps = 0;
	@@ -4081,7 +4050,6 @@
	if (adapter->advertise == advertise) /* no change */
	return (0);

	- dev = adapter->dev;
	hw = &adapter->hw;

	/* No speed changes for backplane media */
	@@ -4200,12 +4168,12 @@
	ixgbe_sysctl_dmac(SYSCTL_HANDLER_ARGS)
	{
	struct adapter adapter = (struct adapter )arg1;
	- struct ifnet *ifp = adapter->ifp;
	+ struct ifnet *ifp = iflib_get_ifp(adapter->ctx);
	int error;
	- u32 newval;
	+ u16 newval;

	newval = adapter->dmac;
	- error = sysctl_handle_int(oidp, &newval, 0, req);
	+ error = sysctl_handle_16(oidp, &newval, 0, req);
	if ((error) \|\| (req->newptr == NULL))
	return (error);

	@@ -4236,7 +4204,7 @@

	/* Re-initialize hardware if it's already running */
	if (ifp->if_drv_flags & IFF_DRV_RUNNING)
	- ixgbe_init(adapter);
	+ ifp->if_init(ifp);

	return (0);
	} /* ixgbe_sysctl_dmac */
	@@ -4340,7 +4308,7 @@

	new_wufc = adapter->wufc;

	- error = sysctl_handle_int(oidp, &new_wufc, 0, req);
	+ error = sysctl_handle_32(oidp, &new_wufc, 0, req);
	if ((error) \|\| (req->newptr == NULL))
	return (error);
	if (new_wufc == adapter->wufc)
	@@ -4426,14 +4394,14 @@
	u16 reg;

	if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) {
	- device_printf(adapter->dev,
	+ device_printf(iflib_get_dev(adapter->ctx),
	"Device has no supported external thermal sensor.\n");
	return (ENODEV);
	}

	if (hw->phy.ops.read_reg(hw, IXGBE_PHY_CURRENT_TEMP,
	IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, &reg)) {
	- device_printf(adapter->dev,
	+ device_printf(iflib_get_dev(adapter->ctx),
	"Error reading from PHY's current temperature register\n");
	return (EAGAIN);
	}
	@@ -4441,7 +4409,7 @@
	/* Shift temp for output */
	reg = reg >> 8;

	- return (sysctl_handle_int(oidp, NULL, reg, req));
	+ return (sysctl_handle_16(oidp, NULL, reg, req));
	} /* ixgbe_sysctl_phy_temp */

	/************************************************************************
	@@ -4458,14 +4426,14 @@
	u16 reg;

	if (hw->device_id != IXGBE_DEV_ID_X550EM_X_10G_T) {
	- device_printf(adapter->dev,
	+ device_printf(iflib_get_dev(adapter->ctx),
	"Device has no supported external thermal sensor.\n");
	return (ENODEV);
	}

	if (hw->phy.ops.read_reg(hw, IXGBE_PHY_OVERTEMP_STATUS,
	IXGBE_MDIO_VENDOR_SPECIFIC_1_DEV_TYPE, &reg)) {
	- device_printf(adapter->dev,
	+ device_printf(iflib_get_dev(adapter->ctx),
	"Error reading from PHY's temperature status register\n");
	return (EAGAIN);
	}
	@@ -4473,7 +4441,7 @@
	/* Get occurrence bit */
	reg = !!(reg & 0x4000);

	- return (sysctl_handle_int(oidp, 0, reg, req));
	+ return (sysctl_handle_16(oidp, 0, reg, req));
	} /* ixgbe_sysctl_phy_overtemp_occurred */

	/************************************************************************
	@@ -4490,6 +4458,7 @@
	{
	struct adapter adapter = (struct adapter )arg1;
	device_t dev = adapter->dev;
	+ struct ifnet *ifp = iflib_get_ifp(adapter->ctx);
	int curr_eee, new_eee, error = 0;
	s32 retval;

	@@ -4518,7 +4487,7 @@
	}

	/* Restart auto-neg */
	- ixgbe_init(adapter);
	+ ifp->if_init(ifp);

	device_printf(dev, "New EEE state: %d\n", new_eee);

	@@ -4541,8 +4510,7 @@
	\| IXGBE_FEATURE_RSS
	\| IXGBE_FEATURE_MSI
	\| IXGBE_FEATURE_MSIX
	- \| IXGBE_FEATURE_LEGACY_IRQ
	- \| IXGBE_FEATURE_LEGACY_TX;
	+ \| IXGBE_FEATURE_LEGACY_IRQ;

	/* Set capabilities first... */
	switch (adapter->hw.mac.type) {
	@@ -4613,10 +4581,6 @@
	else
	device_printf(adapter->dev, "Device does not support Flow Director. Leaving disabled.");
	}
	- /* Legacy (single queue) transmit */
	- if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) &&
	- ixgbe_enable_legacy_tx)
	- adapter->feat_en \|= IXGBE_FEATURE_LEGACY_TX;
	/*
	* Message Signal Interrupts - Extended (MSI-X)
	* Normal MSI is only enabled if MSI-X calls fail.
	@@ -4637,222 +4601,6 @@
	}
	} /* ixgbe_init_device_features */

	-/************************************************************************
	- * ixgbe_probe - Device identification routine
	- *
	- * Determines if the driver should be loaded on
	- * adapter based on its PCI vendor/device ID.
	- *
	- * return BUS_PROBE_DEFAULT on success, positive on failure
	- ************************************************************************/
	-static int
	-ixgbe_probe(device_t dev)
	-{
	- ixgbe_vendor_info_t *ent;
	-
	- u16 pci_vendor_id = 0;
	- u16 pci_device_id = 0;
	- u16 pci_subvendor_id = 0;
	- u16 pci_subdevice_id = 0;
	- char adapter_name[256];
	-
	- INIT_DEBUGOUT("ixgbe_probe: begin");
	-
	- pci_vendor_id = pci_get_vendor(dev);
	- if (pci_vendor_id != IXGBE_INTEL_VENDOR_ID)
	- return (ENXIO);
	-
	- pci_device_id = pci_get_device(dev);
	- pci_subvendor_id = pci_get_subvendor(dev);
	- pci_subdevice_id = pci_get_subdevice(dev);
	-
	- ent = ixgbe_vendor_info_array;
	- while (ent->vendor_id != 0) {
	- if ((pci_vendor_id == ent->vendor_id) &&
	- (pci_device_id == ent->device_id) &&
	- ((pci_subvendor_id == ent->subvendor_id) \|\|
	- (ent->subvendor_id == 0)) &&
	- ((pci_subdevice_id == ent->subdevice_id) \|\|
	- (ent->subdevice_id == 0))) {
	- sprintf(adapter_name, "%s, Version - %s",
	- ixgbe_strings[ent->index],
	- ixgbe_driver_version);
	- device_set_desc_copy(dev, adapter_name);
	- ++ixgbe_total_ports;
	- return (BUS_PROBE_DEFAULT);
	- }
	- ent++;
	- }
	-
	- return (ENXIO);
	-} /* ixgbe_probe */
	-
	-
	-/************************************************************************
	- * ixgbe_ioctl - Ioctl entry point
	- *
	- * Called when the user wants to configure the interface.
	- *
	- * return 0 on success, positive on failure
	- ************************************************************************/
	-static int
	-ixgbe_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
	-{
	- struct adapter *adapter = ifp->if_softc;
	- struct ifreq ifr = (struct ifreq ) data;
	-#if defined(INET) \|\| defined(INET6)
	- struct ifaddr ifa = (struct ifaddr )data;
	-#endif
	- int error = 0;
	- bool avoid_reset = FALSE;
	-
	- switch (command) {
	- case SIOCSIFADDR:
	-#ifdef INET
	- if (ifa->ifa_addr->sa_family == AF_INET)
	- avoid_reset = TRUE;
	-#endif
	-#ifdef INET6
	- if (ifa->ifa_addr->sa_family == AF_INET6)
	- avoid_reset = TRUE;
	-#endif
	- /*
	- * Calling init results in link renegotiation,
	- * so we avoid doing it when possible.
	- */
	- if (avoid_reset) {
	- ifp->if_flags \|= IFF_UP;
	- if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
	- ixgbe_init(adapter);
	-#ifdef INET
	- if (!(ifp->if_flags & IFF_NOARP))
	- arp_ifinit(ifp, ifa);
	-#endif
	- } else
	- error = ether_ioctl(ifp, command, data);
	- break;
	- case SIOCSIFMTU:
	- IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
	- if (ifr->ifr_mtu > IXGBE_MAX_MTU) {
	- error = EINVAL;
	- } else {
	- IXGBE_CORE_LOCK(adapter);
	- ifp->if_mtu = ifr->ifr_mtu;
	- adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING)
	- ixgbe_init_locked(adapter);
	- ixgbe_recalculate_max_frame(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	- }
	- break;
	- case SIOCSIFFLAGS:
	- IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)");
	- IXGBE_CORE_LOCK(adapter);
	- if (ifp->if_flags & IFF_UP) {
	- if ((ifp->if_drv_flags & IFF_DRV_RUNNING)) {
	- if ((ifp->if_flags ^ adapter->if_flags) &
	- (IFF_PROMISC \| IFF_ALLMULTI)) {
	- ixgbe_set_promisc(adapter);
	- }
	- } else
	- ixgbe_init_locked(adapter);
	- } else
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING)
	- ixgbe_stop(adapter);
	- adapter->if_flags = ifp->if_flags;
	- IXGBE_CORE_UNLOCK(adapter);
	- break;
	- case SIOCADDMULTI:
	- case SIOCDELMULTI:
	- IOCTL_DEBUGOUT("ioctl: SIOC(ADD\|DEL)MULTI");
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- IXGBE_CORE_LOCK(adapter);
	- ixgbe_disable_intr(adapter);
	- ixgbe_set_multi(adapter);
	- ixgbe_enable_intr(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	- }
	- break;
	- case SIOCSIFMEDIA:
	- case SIOCGIFMEDIA:
	- IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)");
	- error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
	- break;
	- case SIOCSIFCAP:
	- {
	- IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)");
	-
	- int mask = ifr->ifr_reqcap ^ ifp->if_capenable;
	-
	- if (!mask)
	- break;
	-
	- /* HW cannot turn these on/off separately */
	- if (mask & (IFCAP_RXCSUM \| IFCAP_RXCSUM_IPV6)) {
	- ifp->if_capenable ^= IFCAP_RXCSUM;
	- ifp->if_capenable ^= IFCAP_RXCSUM_IPV6;
	- }
	- if (mask & IFCAP_TXCSUM)
	- ifp->if_capenable ^= IFCAP_TXCSUM;
	- if (mask & IFCAP_TXCSUM_IPV6)
	- ifp->if_capenable ^= IFCAP_TXCSUM_IPV6;
	- if (mask & IFCAP_TSO4)
	- ifp->if_capenable ^= IFCAP_TSO4;
	- if (mask & IFCAP_TSO6)
	- ifp->if_capenable ^= IFCAP_TSO6;
	- if (mask & IFCAP_LRO)
	- ifp->if_capenable ^= IFCAP_LRO;
	- if (mask & IFCAP_VLAN_HWTAGGING)
	- ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
	- if (mask & IFCAP_VLAN_HWFILTER)
	- ifp->if_capenable ^= IFCAP_VLAN_HWFILTER;
	- if (mask & IFCAP_VLAN_HWTSO)
	- ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
	-
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- IXGBE_CORE_LOCK(adapter);
	- ixgbe_init_locked(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	- }
	- VLAN_CAPABILITIES(ifp);
	- break;
	- }
	-#if __FreeBSD_version >= 1100036
	- case SIOCGI2C:
	- {
	- struct ixgbe_hw *hw = &adapter->hw;
	- struct ifi2creq i2c;
	- int i;
	-
	- IOCTL_DEBUGOUT("ioctl: SIOCGI2C (Get I2C Data)");
	- error = copyin(ifr->ifr_data, &i2c, sizeof(i2c));
	- if (error != 0)
	- break;
	- if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) {
	- error = EINVAL;
	- break;
	- }
	- if (i2c.len > sizeof(i2c.data)) {
	- error = EINVAL;
	- break;
	- }
	-
	- for (i = 0; i < i2c.len; i++)
	- hw->phy.ops.read_i2c_byte(hw, i2c.offset + i,
	- i2c.dev_addr, &i2c.data[i]);
	- error = copyout(&i2c, ifr->ifr_data, sizeof(i2c));
	- break;
	- }
	-#endif
	- default:
	- IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)\n", (int)command);
	- error = ether_ioctl(ifp, command, data);
	- break;
	- }
	-
	- return (error);
	-} /* ixgbe_ioctl */
	-
	/************************************************************************
	* ixgbe_check_fan_failure
	************************************************************************/
	@@ -4868,406 +4616,3 @@
	device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n");
	} /* ixgbe_check_fan_failure */

	-/************************************************************************
	- * ixgbe_handle_que
	- ************************************************************************/
	-static void
	-ixgbe_handle_que(void *context, int pending)
	-{
	- struct ix_queue *que = context;
	- struct adapter *adapter = que->adapter;
	- struct tx_ring *txr = que->txr;
	- struct ifnet *ifp = adapter->ifp;
	-
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- ixgbe_rxeof(que);
	- IXGBE_TX_LOCK(txr);
	- ixgbe_txeof(txr);
	- if (!ixgbe_ring_empty(ifp, txr->br))
	- ixgbe_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	- }
	-
	- /* Re-enable this interrupt */
	- if (que->res != NULL)
	- ixgbe_enable_queue(adapter, que->msix);
	- else
	- ixgbe_enable_intr(adapter);
	-
	- return;
	-} /* ixgbe_handle_que */
	-
	-
	-
	-/************************************************************************
	- * ixgbe_allocate_legacy - Setup the Legacy or MSI Interrupt handler
	- ************************************************************************/
	-static int
	-ixgbe_allocate_legacy(struct adapter *adapter)
	-{
	- device_t dev = adapter->dev;
	- struct ix_queue *que = adapter->queues;
	- struct tx_ring *txr = adapter->tx_rings;
	- int error;
	-
	- /* We allocate a single interrupt resource */
	- adapter->res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
	- &adapter->link_rid, RF_SHAREABLE \| RF_ACTIVE);
	- if (adapter->res == NULL) {
	- device_printf(dev,
	- "Unable to allocate bus resource: interrupt\n");
	- return (ENXIO);
	- }
	-
	- /*
	- * Try allocating a fast interrupt and the associated deferred
	- * processing contexts.
	- */
	- if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX))
	- TASK_INIT(&txr->txq_task, 0, ixgbe_deferred_mq_start, txr);
	- TASK_INIT(&que->que_task, 0, ixgbe_handle_que, que);
	- que->tq = taskqueue_create_fast("ixgbe_que", M_NOWAIT,
	- taskqueue_thread_enqueue, &que->tq);
	- taskqueue_start_threads(&que->tq, 1, PI_NET, "%s ixq",
	- device_get_nameunit(adapter->dev));
	-
	- /* Tasklets for Link, SFP and Multispeed Fiber */
	- TASK_INIT(&adapter->link_task, 0, ixgbe_handle_link, adapter);
	- TASK_INIT(&adapter->mod_task, 0, ixgbe_handle_mod, adapter);
	- TASK_INIT(&adapter->msf_task, 0, ixgbe_handle_msf, adapter);
	- TASK_INIT(&adapter->phy_task, 0, ixgbe_handle_phy, adapter);
	- if (adapter->feat_en & IXGBE_FEATURE_FDIR)
	- TASK_INIT(&adapter->fdir_task, 0, ixgbe_reinit_fdir, adapter);
	- adapter->tq = taskqueue_create_fast("ixgbe_link", M_NOWAIT,
	- taskqueue_thread_enqueue, &adapter->tq);
	- taskqueue_start_threads(&adapter->tq, 1, PI_NET, "%s linkq",
	- device_get_nameunit(adapter->dev));
	-
	- if ((error = bus_setup_intr(dev, adapter->res,
	- INTR_TYPE_NET \| INTR_MPSAFE, NULL, ixgbe_legacy_irq, que,
	- &adapter->tag)) != 0) {
	- device_printf(dev,
	- "Failed to register fast interrupt handler: %d\n", error);
	- taskqueue_free(que->tq);
	- taskqueue_free(adapter->tq);
	- que->tq = NULL;
	- adapter->tq = NULL;
	-
	- return (error);
	- }
	- /* For simplicity in the handlers */
	- adapter->active_queues = IXGBE_EIMS_ENABLE_MASK;
	-
	- return (0);
	-} /* ixgbe_allocate_legacy */
	-
	-
	-/************************************************************************
	- * ixgbe_allocate_msix - Setup MSI-X Interrupt resources and handlers
	- ************************************************************************/
	-static int
	-ixgbe_allocate_msix(struct adapter *adapter)
	-{
	- device_t dev = adapter->dev;
	- struct ix_queue *que = adapter->queues;
	- struct tx_ring *txr = adapter->tx_rings;
	- int error, rid, vector = 0;
	- int cpu_id = 0;
	- unsigned int rss_buckets = 0;
	- cpuset_t cpu_mask;
	-
	- /*
	- * If we're doing RSS, the number of queues needs to
	- * match the number of RSS buckets that are configured.
	- *
	- * + If there's more queues than RSS buckets, we'll end
	- * up with queues that get no traffic.
	- *
	- * + If there's more RSS buckets than queues, we'll end
	- * up having multiple RSS buckets map to the same queue,
	- * so there'll be some contention.
	- */
	- rss_buckets = rss_getnumbuckets();
	- if ((adapter->feat_en & IXGBE_FEATURE_RSS) &&
	- (adapter->num_queues != rss_buckets)) {
	- device_printf(dev, "%s: number of queues (%d) != number of RSS buckets (%d); performance will be impacted.\n",
	- __func__, adapter->num_queues, rss_buckets);
	- }
	-
	- for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) {
	- rid = vector + 1;
	- que->res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
	- RF_SHAREABLE \| RF_ACTIVE);
	- if (que->res == NULL) {
	- device_printf(dev, "Unable to allocate bus resource: que interrupt [%d]\n",
	- vector);
	- return (ENXIO);
	- }
	- /* Set the handler function */
	- error = bus_setup_intr(dev, que->res,
	- INTR_TYPE_NET \| INTR_MPSAFE, NULL, ixgbe_msix_que, que,
	- &que->tag);
	- if (error) {
	- que->res = NULL;
	- device_printf(dev, "Failed to register QUE handler");
	- return (error);
	- }
	-#if __FreeBSD_version >= 800504
	- bus_describe_intr(dev, que->res, que->tag, "q%d", i);
	-#endif
	- que->msix = vector;
	- adapter->active_queues \|= (u64)(1 << que->msix);
	-
	- if (adapter->feat_en & IXGBE_FEATURE_RSS) {
	- /*
	- * The queue ID is used as the RSS layer bucket ID.
	- * We look up the queue ID -> RSS CPU ID and select
	- * that.
	- */
	- cpu_id = rss_getcpu(i % rss_buckets);
	- CPU_SETOF(cpu_id, &cpu_mask);
	- } else {
	- /*
	- * Bind the MSI-X vector, and thus the
	- * rings to the corresponding CPU.
	- *
	- * This just happens to match the default RSS
	- * round-robin bucket -> queue -> CPU allocation.
	- */
	- if (adapter->num_queues > 1)
	- cpu_id = i;
	- }
	- if (adapter->num_queues > 1)
	- bus_bind_intr(dev, que->res, cpu_id);
	-#ifdef IXGBE_DEBUG
	- if (adapter->feat_en & IXGBE_FEATURE_RSS)
	- device_printf(dev, "Bound RSS bucket %d to CPU %d\n", i,
	- cpu_id);
	- else
	- device_printf(dev, "Bound queue %d to cpu %d\n", i,
	- cpu_id);
	-#endif /* IXGBE_DEBUG */
	-
	-
	- if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX))
	- TASK_INIT(&txr->txq_task, 0, ixgbe_deferred_mq_start,
	- txr);
	- TASK_INIT(&que->que_task, 0, ixgbe_handle_que, que);
	- que->tq = taskqueue_create_fast("ixgbe_que", M_NOWAIT,
	- taskqueue_thread_enqueue, &que->tq);
	-#if __FreeBSD_version < 1100000
	- taskqueue_start_threads(&que->tq, 1, PI_NET, "%s:q%d",
	- device_get_nameunit(adapter->dev), i);
	-#else
	- if (adapter->feat_en & IXGBE_FEATURE_RSS)
	- taskqueue_start_threads_cpuset(&que->tq, 1, PI_NET,
	- &cpu_mask, "%s (bucket %d)",
	- device_get_nameunit(adapter->dev), cpu_id);
	- else
	- taskqueue_start_threads_cpuset(&que->tq, 1, PI_NET,
	- NULL, "%s:q%d", device_get_nameunit(adapter->dev),
	- i);
	-#endif
	- }
	-
	- /* and Link */
	- adapter->link_rid = vector + 1;
	- adapter->res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
	- &adapter->link_rid, RF_SHAREABLE \| RF_ACTIVE);
	- if (!adapter->res) {
	- device_printf(dev,
	- "Unable to allocate bus resource: Link interrupt [%d]\n",
	- adapter->link_rid);
	- return (ENXIO);
	- }
	- /* Set the link handler function */
	- error = bus_setup_intr(dev, adapter->res, INTR_TYPE_NET \| INTR_MPSAFE,
	- NULL, ixgbe_msix_link, adapter, &adapter->tag);
	- if (error) {
	- adapter->res = NULL;
	- device_printf(dev, "Failed to register LINK handler");
	- return (error);
	- }
	-#if __FreeBSD_version >= 800504
	- bus_describe_intr(dev, adapter->res, adapter->tag, "link");
	-#endif
	- adapter->vector = vector;
	- /* Tasklets for Link, SFP and Multispeed Fiber */
	- TASK_INIT(&adapter->link_task, 0, ixgbe_handle_link, adapter);
	- TASK_INIT(&adapter->mod_task, 0, ixgbe_handle_mod, adapter);
	- TASK_INIT(&adapter->msf_task, 0, ixgbe_handle_msf, adapter);
	- if (adapter->feat_cap & IXGBE_FEATURE_SRIOV)
	- TASK_INIT(&adapter->mbx_task, 0, ixgbe_handle_mbx, adapter);
	- TASK_INIT(&adapter->phy_task, 0, ixgbe_handle_phy, adapter);
	- if (adapter->feat_en & IXGBE_FEATURE_FDIR)
	- TASK_INIT(&adapter->fdir_task, 0, ixgbe_reinit_fdir, adapter);
	- adapter->tq = taskqueue_create_fast("ixgbe_link", M_NOWAIT,
	- taskqueue_thread_enqueue, &adapter->tq);
	- taskqueue_start_threads(&adapter->tq, 1, PI_NET, "%s linkq",
	- device_get_nameunit(adapter->dev));
	-
	- return (0);
	-} /* ixgbe_allocate_msix */
	-
	-/************************************************************************
	- * ixgbe_configure_interrupts
	- *
	- * Setup MSI-X, MSI, or legacy interrupts (in that order).
	- * This will also depend on user settings.
	- ************************************************************************/
	-static int
	-ixgbe_configure_interrupts(struct adapter *adapter)
	-{
	- device_t dev = adapter->dev;
	- int rid, want, queues, msgs;
	-
	- /* Default to 1 queue if MSI-X setup fails */
	- adapter->num_queues = 1;
	-
	- /* Override by tuneable */
	- if (!(adapter->feat_cap & IXGBE_FEATURE_MSIX))
	- goto msi;
	-
	- /* First try MSI-X */
	- msgs = pci_msix_count(dev);
	- if (msgs == 0)
	- goto msi;
	- rid = PCIR_BAR(MSIX_82598_BAR);
	- adapter->msix_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
	- RF_ACTIVE);
	- if (adapter->msix_mem == NULL) {
	- rid += 4; /* 82599 maps in higher BAR */
	- adapter->msix_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
	- &rid, RF_ACTIVE);
	- }
	- if (adapter->msix_mem == NULL) {
	- /* May not be enabled */
	- device_printf(adapter->dev, "Unable to map MSI-X table.\n");
	- goto msi;
	- }
	-
	- /* Figure out a reasonable auto config value */
	- queues = min(mp_ncpus, msgs - 1);
	- /* If we're doing RSS, clamp at the number of RSS buckets */
	- if (adapter->feat_en & IXGBE_FEATURE_RSS)
	- queues = min(queues, rss_getnumbuckets());
	- if (ixgbe_num_queues > queues) {
	- device_printf(adapter->dev, "ixgbe_num_queues (%d) is too large, using reduced amount (%d).\n", ixgbe_num_queues, queues);
	- ixgbe_num_queues = queues;
	- }
	-
	- if (ixgbe_num_queues != 0)
	- queues = ixgbe_num_queues;
	- /* Set max queues to 8 when autoconfiguring */
	- else
	- queues = min(queues, 8);
	-
	- /* reflect correct sysctl value */
	- ixgbe_num_queues = queues;
	-
	- /*
	- * Want one vector (RX/TX pair) per queue
	- * plus an additional for Link.
	- */
	- want = queues + 1;
	- if (msgs >= want)
	- msgs = want;
	- else {
	- device_printf(adapter->dev, "MSI-X Configuration Problem, %d vectors but %d queues wanted!\n",
	- msgs, want);
	- goto msi;
	- }
	- if ((pci_alloc_msix(dev, &msgs) == 0) && (msgs == want)) {
	- device_printf(adapter->dev,
	- "Using MSI-X interrupts with %d vectors\n", msgs);
	- adapter->num_queues = queues;
	- adapter->feat_en \|= IXGBE_FEATURE_MSIX;
	- return (0);
	- }
	- /*
	- * MSI-X allocation failed or provided us with
	- * less vectors than needed. Free MSI-X resources
	- * and we'll try enabling MSI.
	- */
	- pci_release_msi(dev);
	-
	-msi:
	- /* Without MSI-X, some features are no longer supported */
	- adapter->feat_cap &= ~IXGBE_FEATURE_RSS;
	- adapter->feat_en &= ~IXGBE_FEATURE_RSS;
	- adapter->feat_cap &= ~IXGBE_FEATURE_SRIOV;
	- adapter->feat_en &= ~IXGBE_FEATURE_SRIOV;
	-
	- if (adapter->msix_mem != NULL) {
	- bus_release_resource(dev, SYS_RES_MEMORY, rid,
	- adapter->msix_mem);
	- adapter->msix_mem = NULL;
	- }
	- msgs = 1;
	- if (pci_alloc_msi(dev, &msgs) == 0) {
	- adapter->feat_en \|= IXGBE_FEATURE_MSI;
	- adapter->link_rid = 1;
	- device_printf(adapter->dev, "Using an MSI interrupt\n");
	- return (0);
	- }
	-
	- if (!(adapter->feat_cap & IXGBE_FEATURE_LEGACY_IRQ)) {
	- device_printf(adapter->dev,
	- "Device does not support legacy interrupts.\n");
	- return 1;
	- }
	-
	- adapter->feat_en \|= IXGBE_FEATURE_LEGACY_IRQ;
	- adapter->link_rid = 0;
	- device_printf(adapter->dev, "Using a Legacy interrupt\n");
	-
	- return (0);
	-} /* ixgbe_configure_interrupts */
	-
	-
	-/************************************************************************
	- * ixgbe_handle_link - Tasklet for MSI-X Link interrupts
	- *
	- * Done outside of interrupt context since the driver might sleep
	- ************************************************************************/
	-static void
	-ixgbe_handle_link(void *context, int pending)
	-{
	- struct adapter *adapter = context;
	- struct ixgbe_hw *hw = &adapter->hw;
	-
	- ixgbe_check_link(hw, &adapter->link_speed, &adapter->link_up, 0);
	- ixgbe_update_link_status(adapter);
	-
	- /* Re-enable link interrupts */
	- IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_LSC);
	-} /* ixgbe_handle_link */
	-
	-/************************************************************************
	- * ixgbe_rearm_queues
	- ************************************************************************/
	-static void
	-ixgbe_rearm_queues(struct adapter *adapter, u64 queues)
	-{
	- u32 mask;
	-
	- switch (adapter->hw.mac.type) {
	- case ixgbe_mac_82598EB:
	- mask = (IXGBE_EIMS_RTX_QUEUE & queues);
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask);
	- break;
	- case ixgbe_mac_82599EB:
	- case ixgbe_mac_X540:
	- case ixgbe_mac_X550:
	- case ixgbe_mac_X550EM_x:
	- case ixgbe_mac_X550EM_a:
	- mask = (queues & 0xFFFFFFFF);
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(0), mask);
	- mask = (queues >> 32);
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS_EX(1), mask);
	- break;
	- default:
	- break;
	- }
	-} /* ixgbe_rearm_queues */
	-
	Index: sys/dev/ixgbe/if_ixv.c
	===================================================================
	--- sys/dev/ixgbe/if_ixv.c
	+++ sys/dev/ixgbe/if_ixv.c
	@@ -33,12 +33,14 @@
	/$FreeBSD$/


	-#ifndef IXGBE_STANDALONE_BUILD
	#include "opt_inet.h"
	#include "opt_inet6.h"
	-#endif

	#include "ixgbe.h"
	+#include "ifdi_if.h"
	+
	+#include <net/netmap.h>
	+#include <dev/netmap/netmap_kern.h>

	/************************************************************************
	* Driver version
	@@ -54,89 +56,86 @@
	*
	* { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
	************************************************************************/
	-static ixgbe_vendor_info_t ixv_vendor_info_array[] =
	+static pci_vendor_info_t ixv_vendor_info_array[] =
	{
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, 0, 0, 0},
	- {IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, 0, 0, 0},
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
	+ PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
	/* required last entry */
	- {0, 0, 0, 0, 0}
	-};
	-
	-/************************************************************************
	- * Table of branding strings
	- ************************************************************************/
	-static char *ixv_strings[] = {
	- "Intel(R) PRO/10GbE Virtual Function Network Driver"
	+PVID_END
	};

	/************************************************************************
	* Function prototypes
	************************************************************************/
	-static int ixv_probe(device_t);
	-static int ixv_attach(device_t);
	-static int ixv_detach(device_t);
	-static int ixv_shutdown(device_t);
	-static int ixv_ioctl(struct ifnet *, u_long, caddr_t);
	-static void ixv_init(void *);
	-static void ixv_init_locked(struct adapter *);
	-static void ixv_stop(void *);
	-static uint64_t ixv_get_counter(struct ifnet *, ift_counter);
	+static void *ixv_register(device_t dev);
	+static int ixv_if_attach_pre(if_ctx_t ctx);
	+static int ixv_if_attach_post(if_ctx_t ctx);
	+static int ixv_if_detach(if_ctx_t ctx);
	+
	+static int ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid);
	+static int ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t vaddrs, uint64_t paddrs, int nqs, int nqsets);
	+static int ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t vaddrs, uint64_t paddrs, int nqs, int nqsets);
	+static void ixv_if_queues_free(if_ctx_t ctx);
	+static void ixv_identify_hardware(if_ctx_t ctx);
	static void ixv_init_device_features(struct adapter *);
	-static void ixv_media_status(struct ifnet , struct ifmediareq );
	-static int ixv_media_change(struct ifnet *);
	-static int ixv_allocate_pci_resources(struct adapter *);
	-static int ixv_allocate_msix(struct adapter *);
	-static int ixv_configure_interrupts(struct adapter *);
	-static void ixv_free_pci_resources(struct adapter *);
	-static void ixv_local_timer(void *);
	-static void ixv_setup_interface(device_t, struct adapter *);
	+static int ixv_allocate_pci_resources(if_ctx_t ctx);
	+static void ixv_free_pci_resources(if_ctx_t ctx);
	+static int ixv_setup_interface(if_ctx_t ctx);
	+static void ixv_if_media_status(if_ctx_t , struct ifmediareq *);
	+static int ixv_if_media_change(if_ctx_t ctx);
	+static void ixv_if_update_admin_status(if_ctx_t ctx);
	+static int ixv_if_msix_intr_assign(if_ctx_t ctx, int msix);
	+
	+static int ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
	+static void ixv_if_init(if_ctx_t ctx);
	+static void ixv_if_local_timer(if_ctx_t ctx, uint16_t qid);
	+static void ixv_if_stop(if_ctx_t ctx);
	static int ixv_negotiate_api(struct adapter *);

	-static void ixv_initialize_transmit_units(struct adapter *);
	-static void ixv_initialize_receive_units(struct adapter *);
	+static void ixv_initialize_transmit_units(if_ctx_t ctx);
	+static void ixv_initialize_receive_units(if_ctx_t ctx);
	static void ixv_initialize_rss_mapping(struct adapter *);
	-static void ixv_check_link(struct adapter *);

	-static void ixv_enable_intr(struct adapter *);
	-static void ixv_disable_intr(struct adapter *);
	-static void ixv_set_multi(struct adapter *);
	-static void ixv_update_link_status(struct adapter *);
	-static int ixv_sysctl_debug(SYSCTL_HANDLER_ARGS);
	-static void ixv_set_ivar(struct adapter *, u8, u8, s8);
	+static void ixv_setup_vlan_support(if_ctx_t ctx);
	static void ixv_configure_ivars(struct adapter *);
	-static u8 ixv_mc_array_itr(struct ixgbe_hw , u8 *, u32 );
	+static void ixv_if_enable_intr(if_ctx_t ctx);
	+static void ixv_if_disable_intr(if_ctx_t ctx);
	+static void ixv_if_multi_set(if_ctx_t ctx);
	+
	+static void ixv_if_register_vlan(if_ctx_t, u16);
	+static void ixv_if_unregister_vlan(if_ctx_t, u16);

	-static void ixv_setup_vlan_support(struct adapter *);
	-static void ixv_register_vlan(void , struct ifnet , u16);
	-static void ixv_unregister_vlan(void , struct ifnet , u16);
	+static uint64_t ixv_if_get_counter(if_ctx_t, ift_counter);

	static void ixv_save_stats(struct adapter *);
	static void ixv_init_stats(struct adapter *);
	static void ixv_update_stats(struct adapter *);
	-static void ixv_add_stats_sysctls(struct adapter *);
	+static void ixv_add_stats_sysctls(struct adapter *adapter);
	+
	+static int ixv_sysctl_debug(SYSCTL_HANDLER_ARGS);
	+static void ixv_set_ivar(struct adapter *, u8, u8, s8);
	+
	+static u8 ixv_mc_array_itr(struct ixgbe_hw , u8 *, u32 );
	static void ixv_set_sysctl_value(struct adapter , const char ,
	const char , int , int);

	/* The MSI-X Interrupt handlers */
	-static void ixv_msix_que(void *);
	-static void ixv_msix_mbx(void *);
	-
	-/* Deferred interrupt tasklets */
	-static void ixv_handle_que(void *, int);
	-static void ixv_handle_link(void *, int);
	+static int ixv_msix_que(void *);
	+static int ixv_msix_mbx(void *);

	/************************************************************************
	* FreeBSD Device Interface Entry Points
	************************************************************************/
	static device_method_t ixv_methods[] = {
	/* Device interface */
	- DEVMETHOD(device_probe, ixv_probe),
	- DEVMETHOD(device_attach, ixv_attach),
	- DEVMETHOD(device_detach, ixv_detach),
	- DEVMETHOD(device_shutdown, ixv_shutdown),
	+ DEVMETHOD(device_register, ixv_register),
	+ DEVMETHOD(device_probe, iflib_device_probe),
	+ DEVMETHOD(device_attach, iflib_device_attach),
	+ DEVMETHOD(device_detach, iflib_device_detach),
	+ DEVMETHOD(device_shutdown, iflib_device_shutdown),
	DEVMETHOD_END
	};

	@@ -148,16 +147,44 @@
	DRIVER_MODULE(ixv, pci, ixv_driver, ixv_devclass, 0, 0);
	MODULE_DEPEND(ixv, pci, 1, 1, 1);
	MODULE_DEPEND(ixv, ether, 1, 1, 1);
	+#ifdef DEV_NETMAP
	MODULE_DEPEND(ixv, netmap, 1, 1, 1);
	+#endif /* DEV_NETMAP */
	+
	+static device_method_t ixv_if_methods[] = {
	+ DEVMETHOD(ifdi_attach_pre, ixv_if_attach_pre),
	+ DEVMETHOD(ifdi_attach_post, ixv_if_attach_post),
	+ DEVMETHOD(ifdi_detach, ixv_if_detach),
	+ DEVMETHOD(ifdi_init, ixv_if_init),
	+ DEVMETHOD(ifdi_stop, ixv_if_stop),
	+ DEVMETHOD(ifdi_msix_intr_assign, ixv_if_msix_intr_assign),
	+ DEVMETHOD(ifdi_intr_enable, ixv_if_enable_intr),
	+ DEVMETHOD(ifdi_intr_disable, ixv_if_disable_intr),
	+ DEVMETHOD(ifdi_tx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
	+ DEVMETHOD(ifdi_rx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
	+ DEVMETHOD(ifdi_tx_queues_alloc, ixv_if_tx_queues_alloc),
	+ DEVMETHOD(ifdi_rx_queues_alloc, ixv_if_rx_queues_alloc),
	+ DEVMETHOD(ifdi_queues_free, ixv_if_queues_free),
	+ DEVMETHOD(ifdi_update_admin_status, ixv_if_update_admin_status),
	+ DEVMETHOD(ifdi_multi_set, ixv_if_multi_set),
	+ DEVMETHOD(ifdi_mtu_set, ixv_if_mtu_set),
	+ DEVMETHOD(ifdi_media_status, ixv_if_media_status),
	+ DEVMETHOD(ifdi_media_change, ixv_if_media_change),
	+ DEVMETHOD(ifdi_timer, ixv_if_local_timer),
	+ DEVMETHOD(ifdi_vlan_register, ixv_if_register_vlan),
	+ DEVMETHOD(ifdi_vlan_unregister, ixv_if_unregister_vlan),
	+ DEVMETHOD(ifdi_get_counter, ixv_if_get_counter),
	+ DEVMETHOD_END
	+};
	+
	+static driver_t ixv_if_driver = {
	+ "ixv_if", ixv_if_methods, sizeof(struct adapter)
	+};

	/*
	* TUNEABLE PARAMETERS:
	*/

	-/* Number of Queues - do not exceed MSI-X vectors - 1 */
	-static int ixv_num_queues = 1;
	-TUNABLE_INT("hw.ixv.num_queues", &ixv_num_queues);
	-
	/*
	* AIM: Adaptive Interrupt Moderation
	* which means that the interrupt rate
	@@ -167,14 +194,6 @@
	static int ixv_enable_aim = FALSE;
	TUNABLE_INT("hw.ixv.enable_aim", &ixv_enable_aim);

	-/* How many packets rxeof tries to clean at a time */
	-static int ixv_rx_process_limit = 256;
	-TUNABLE_INT("hw.ixv.rx_process_limit", &ixv_rx_process_limit);
	-
	-/* How many packets txeof tries to clean at a time */
	-static int ixv_tx_process_limit = 256;
	-TUNABLE_INT("hw.ixv.tx_process_limit", &ixv_tx_process_limit);
	-
	/* Flow control setting, default to full */
	static int ixv_flow_control = ixgbe_fc_full;
	TUNABLE_INT("hw.ixv.flow_control", &ixv_flow_control);
	@@ -188,80 +207,190 @@
	static int ixv_header_split = FALSE;
	TUNABLE_INT("hw.ixv.hdr_split", &ixv_header_split);

	-/*
	- * Number of TX descriptors per ring,
	- * setting higher than RX as this seems
	- * the better performing choice.
	- */
	-static int ixv_txd = DEFAULT_TXD;
	-TUNABLE_INT("hw.ixv.txd", &ixv_txd);
	-
	-/* Number of RX descriptors per ring */
	-static int ixv_rxd = DEFAULT_RXD;
	-TUNABLE_INT("hw.ixv.rxd", &ixv_rxd);
	-
	-/* Legacy Transmit (single queue) */
	-static int ixv_enable_legacy_tx = 0;
	-TUNABLE_INT("hw.ixv.enable_legacy_tx", &ixv_enable_legacy_tx);
	-
	/*
	* Shadow VFTA table, this is needed because
	* the real filter table gets cleared during
	* a soft reset and we need to repopulate it.
	*/
	static u32 ixv_shadow_vfta[IXGBE_VFTA_SIZE];
	+extern struct if_txrx ixgbe_txrx;
	+
	+static struct if_shared_ctx ixv_sctx_init = {
	+ .isc_magic = IFLIB_MAGIC,
	+ .isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */
	+ .isc_tx_maxsize = IXGBE_TSO_SIZE,
	+
	+ .isc_tx_maxsegsize = PAGE_SIZE,
	+
	+ .isc_rx_maxsize = MJUM16BYTES,
	+ .isc_rx_nsegments = 1,
	+ .isc_rx_maxsegsize = MJUM16BYTES,
	+ .isc_nfl = 1,
	+ .isc_ntxqs = 1,
	+ .isc_nrxqs = 1,
	+ .isc_admin_intrcnt = 1,
	+ .isc_vendor_info = ixv_vendor_info_array,
	+ .isc_driver_version = ixv_driver_version,
	+ .isc_driver = &ixv_if_driver,
	+
	+ .isc_nrxd_min = {MIN_RXD},
	+ .isc_ntxd_min = {MIN_TXD},
	+ .isc_nrxd_max = {MAX_RXD},
	+ .isc_ntxd_max = {MAX_TXD},
	+ .isc_nrxd_default = {DEFAULT_RXD},
	+ .isc_ntxd_default = {DEFAULT_TXD},
	+};

	-static int (ixv_start_locked)(struct ifnet , struct tx_ring *);
	-static int (ixv_ring_empty)(struct ifnet , struct buf_ring *);
	+if_shared_ctx_t ixv_sctx = &ixv_sctx_init;
	+
	+static void *
	+ixv_register(device_t dev)
	+{
	+ return (ixv_sctx);
	+}

	/************************************************************************
	- * ixv_probe - Device identification routine
	- *
	- * Determines if the driver should be loaded on
	- * adapter based on its PCI vendor/device ID.
	- *
	- * return BUS_PROBE_DEFAULT on success, positive on failure
	+ * ixv_if_tx_queues_alloc
	************************************************************************/
	static int
	-ixv_probe(device_t dev)
	+ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t vaddrs, uint64_t paddrs,
	+ int ntxqs, int ntxqsets)
	{
	- ixgbe_vendor_info_t *ent;
	- u16 pci_vendor_id = 0;
	- u16 pci_device_id = 0;
	- u16 pci_subvendor_id = 0;
	- u16 pci_subdevice_id = 0;
	- char adapter_name[256];
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ if_softc_ctx_t scctx = adapter->shared;
	+ struct ix_tx_queue *que;
	+ int i, j, error;
	+
	+ MPASS(adapter->num_tx_queues == ntxqsets);
	+ MPASS(ntxqs == 1);
	+
	+ /* Allocate queue structure memory */
	+ adapter->tx_queues =
	+ (struct ix_tx_queue )malloc(sizeof(struct ix_tx_queue) ntxqsets,
	+ M_DEVBUF, M_NOWAIT \| M_ZERO);
	+ if (!adapter->tx_queues) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Unable to allocate TX ring memory\n");
	+ return (ENOMEM);
	+ }

	+ for (i = 0, que = adapter->tx_queues; i < ntxqsets; i++, que++) {
	+ struct tx_ring *txr = &que->txr;

	- pci_vendor_id = pci_get_vendor(dev);
	- if (pci_vendor_id != IXGBE_INTEL_VENDOR_ID)
	- return (ENXIO);
	+ txr->me = i;
	+ txr->adapter = que->adapter = adapter;
	+ adapter->active_queues \|= (u64)1 << txr->me;

	- pci_device_id = pci_get_device(dev);
	- pci_subvendor_id = pci_get_subvendor(dev);
	- pci_subdevice_id = pci_get_subdevice(dev);
	-
	- ent = ixv_vendor_info_array;
	- while (ent->vendor_id != 0) {
	- if ((pci_vendor_id == ent->vendor_id) &&
	- (pci_device_id == ent->device_id) &&
	- ((pci_subvendor_id == ent->subvendor_id) \|\|
	- (ent->subvendor_id == 0)) &&
	- ((pci_subdevice_id == ent->subdevice_id) \|\|
	- (ent->subdevice_id == 0))) {
	- sprintf(adapter_name, "%s, Version - %s",
	- ixv_strings[ent->index], ixv_driver_version);
	- device_set_desc_copy(dev, adapter_name);
	- return (BUS_PROBE_DEFAULT);
	+ /* Allocate report status array */
	+ if (!(txr->tx_rsq = (qidx_t )malloc(sizeof(qidx_t) scctx->isc_ntxd[0], M_DEVBUF, M_NOWAIT \| M_ZERO))) {
	+ error = ENOMEM;
	+ goto fail;
	}
	- ent++;
	+ for (j = 0; j < scctx->isc_ntxd[0]; j++)
	+ txr->tx_rsq[j] = QIDX_INVALID;
	+ /* get the virtual and physical address of the hardware queues */
	+ txr->tail = IXGBE_VFTDT(txr->me);
	+ txr->tx_base = (union ixgbe_adv_tx_desc )vaddrs[intxqs];
	+ txr->tx_paddr = paddrs[i*ntxqs];
	+
	+ txr->bytes = 0;
	+ txr->total_packets = 0;
	+
	}

	- return (ENXIO);
	-} /* ixv_probe */
	+ device_printf(iflib_get_dev(ctx), "allocated for %d queues\n",
	+ adapter->num_tx_queues);
	+
	+ return (0);
	+
	+ fail:
	+ ixv_if_queues_free(ctx);
	+
	+ return (error);
	+} /* ixv_if_tx_queues_alloc */

	/************************************************************************
	- * ixv_attach - Device initialization routine
	+ * ixv_if_rx_queues_alloc
	+ ************************************************************************/
	+static int
	+ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t vaddrs, uint64_t paddrs,
	+ int nrxqs, int nrxqsets)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_rx_queue *que;
	+ int i, error;
	+
	+ MPASS(adapter->num_rx_queues == nrxqsets);
	+ MPASS(nrxqs == 1);
	+
	+ /* Allocate queue structure memory */
	+ adapter->rx_queues =
	+ (struct ix_rx_queue )malloc(sizeof(struct ix_rx_queue) nrxqsets,
	+ M_DEVBUF, M_NOWAIT \| M_ZERO);
	+ if (!adapter->rx_queues) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Unable to allocate TX ring memory\n");
	+ error = ENOMEM;
	+ goto fail;
	+ }
	+
	+ for (i = 0, que = adapter->rx_queues; i < nrxqsets; i++, que++) {
	+ struct rx_ring *rxr = &que->rxr;
	+ rxr->me = i;
	+ rxr->adapter = que->adapter = adapter;
	+
	+
	+ /* get the virtual and physical address of the hw queues */
	+ rxr->tail = IXGBE_VFRDT(rxr->me);
	+ rxr->rx_base = (union ixgbe_adv_rx_desc *)vaddrs[i];
	+ rxr->rx_paddr = paddrs[i*nrxqs];
	+ rxr->bytes = 0;
	+ rxr->que = que;
	+ }
	+
	+ device_printf(iflib_get_dev(ctx), "allocated for %d rx queues\n",
	+ adapter->num_rx_queues);
	+
	+ return (0);
	+
	+fail:
	+ ixv_if_queues_free(ctx);
	+
	+ return (error);
	+} /* ixv_if_rx_queues_alloc */
	+
	+/************************************************************************
	+ * ixv_if_queues_free
	+ ************************************************************************/
	+static void
	+ixv_if_queues_free(if_ctx_t ctx)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_tx_queue *que = adapter->tx_queues;
	+ int i;
	+
	+ if (que == NULL)
	+ goto free;
	+
	+ for (i = 0; i < adapter->num_tx_queues; i++, que++) {
	+ struct tx_ring *txr = &que->txr;
	+ if (txr->tx_rsq == NULL)
	+ break;
	+
	+ free(txr->tx_rsq, M_DEVBUF);
	+ txr->tx_rsq = NULL;
	+ }
	+ if (adapter->tx_queues != NULL)
	+ free(adapter->tx_queues, M_DEVBUF);
	+free:
	+ if (adapter->rx_queues != NULL)
	+ free(adapter->rx_queues, M_DEVBUF);
	+ adapter->tx_queues = NULL;
	+ adapter->rx_queues = NULL;
	+} /* ixv_if_queues_free */
	+
	+/************************************************************************
	+ * ixv_if_attach_pre - Device initialization routine
	*
	* Called when the driver is being loaded.
	* Identifies the type of hardware, allocates all resources
	@@ -270,34 +399,28 @@
	* return 0 on success, positive on failure
	************************************************************************/
	static int
	-ixv_attach(device_t dev)
	+ixv_if_attach_pre(if_ctx_t ctx)
	{
	struct adapter *adapter;
	+ device_t dev;
	+ if_softc_ctx_t scctx;
	struct ixgbe_hw *hw;
	int error = 0;

	INIT_DEBUGOUT("ixv_attach: begin");

	- /*
	- * Make sure BUSMASTER is set, on a VM under
	- * KVM it may not be and will break things.
	- */
	- pci_enable_busmaster(dev);
	-
	/* Allocate, clear, and link in our adapter structure */
	- adapter = device_get_softc(dev);
	+ dev = iflib_get_dev(ctx);
	+ adapter = iflib_get_softc(ctx);
	adapter->dev = dev;
	+ adapter->ctx = ctx;
	adapter->hw.back = adapter;
	+ scctx = adapter->shared = iflib_get_softc_ctx(ctx);
	+ adapter->media = iflib_get_media(ctx);
	hw = &adapter->hw;

	- adapter->init_locked = ixv_init_locked;
	- adapter->stop_locked = ixv_stop;
	-
	- /* Core Lock Init*/
	- IXGBE_CORE_LOCK_INIT(adapter, device_get_nameunit(dev));
	-
	/* Do base PCI setup - map BAR0 */
	- if (ixv_allocate_pci_resources(adapter)) {
	+ if (ixv_allocate_pci_resources(ctx)) {
	device_printf(dev, "ixv_allocate_pci_resources() failed!\n");
	error = ENXIO;
	goto err_out;
	@@ -314,41 +437,8 @@
	"enable_aim", CTLFLAG_RW, &ixv_enable_aim, 1,
	"Interrupt Moderation");

	- /* Set up the timer callout */
	- callout_init_mtx(&adapter->timer, &adapter->core_mtx, 0);
	-
	- /* Save off the information about this board */
	- hw->vendor_id = pci_get_vendor(dev);
	- hw->device_id = pci_get_device(dev);
	- hw->revision_id = pci_get_revid(dev);
	- hw->subsystem_vendor_id = pci_get_subvendor(dev);
	- hw->subsystem_device_id = pci_get_subdevice(dev);
	-
	- /* A subset of set_mac_type */
	- switch (hw->device_id) {
	- case IXGBE_DEV_ID_82599_VF:
	- hw->mac.type = ixgbe_mac_82599_vf;
	- break;
	- case IXGBE_DEV_ID_X540_VF:
	- hw->mac.type = ixgbe_mac_X540_vf;
	- break;
	- case IXGBE_DEV_ID_X550_VF:
	- hw->mac.type = ixgbe_mac_X550_vf;
	- break;
	- case IXGBE_DEV_ID_X550EM_X_VF:
	- hw->mac.type = ixgbe_mac_X550EM_x_vf;
	- break;
	- case IXGBE_DEV_ID_X550EM_A_VF:
	- hw->mac.type = ixgbe_mac_X550EM_a_vf;
	- break;
	- default:
	- /* Shouldn't get here since probe succeeded */
	- device_printf(dev, "Unknown device ID!\n");
	- error = ENXIO;
	- goto err_out;
	- break;
	- }
	-
	+ /* Determine hardware revision */
	+ ixv_identify_hardware(ctx);
	ixv_init_device_features(adapter);

	/* Initialize the shared code */
	@@ -362,9 +452,6 @@
	/* Setup the mailbox */
	ixgbe_init_mbx_params_vf(hw);

	- /* Set the right number of segments */
	- adapter->num_segs = IXGBE_82599_SCATTER;
	-
	error = hw->mac.ops.reset_hw(hw);
	if (error == IXGBE_ERR_RESET_FAILED)
	device_printf(dev, "...reset_hw() failure: Reset Failed!\n");
	@@ -402,55 +489,58 @@
	bcopy(addr, hw->mac.perm_addr, sizeof(addr));
	}

	- /* Register for VLAN events */
	- adapter->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
	- ixv_register_vlan, adapter, EVENTHANDLER_PRI_FIRST);
	- adapter->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
	- ixv_unregister_vlan, adapter, EVENTHANDLER_PRI_FIRST);
	-
	- /* Sysctls for limiting the amount of work done in the taskqueues */
	- ixv_set_sysctl_value(adapter, "rx_processing_limit",
	- "max number of rx packets to process",
	- &adapter->rx_process_limit, ixv_rx_process_limit);
	-
	- ixv_set_sysctl_value(adapter, "tx_processing_limit",
	- "max number of tx packets to process",
	- &adapter->tx_process_limit, ixv_tx_process_limit);
	-
	- /* Do descriptor calc and sanity checks */
	- if (((ixv_txd * sizeof(union ixgbe_adv_tx_desc)) % DBA_ALIGN) != 0 \|\|
	- ixv_txd < MIN_TXD \|\| ixv_txd > MAX_TXD) {
	- device_printf(dev, "TXD config issue, using default!\n");
	- adapter->num_tx_desc = DEFAULT_TXD;
	- } else
	- adapter->num_tx_desc = ixv_txd;
	-
	- if (((ixv_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 \|\|
	- ixv_rxd < MIN_RXD \|\| ixv_rxd > MAX_RXD) {
	- device_printf(dev, "RXD config issue, using default!\n");
	- adapter->num_rx_desc = DEFAULT_RXD;
	- } else
	- adapter->num_rx_desc = ixv_rxd;
	-
	- /* Setup MSI-X */
	- error = ixv_configure_interrupts(adapter);
	- if (error)
	- goto err_out;
	+ /* Most of the iflib initialization... */
	+
	+ iflib_set_mac(ctx, hw->mac.addr);
	+ scctx->isc_txqsizes[0] =
	+ roundup2(scctx->isc_ntxd[0] * sizeof(union ixgbe_adv_tx_desc) +
	+ sizeof(u32), DBA_ALIGN);
	+ scctx->isc_rxqsizes[0] =
	+ roundup2(scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc),
	+ DBA_ALIGN);
	+ /* XXX */
	+ scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 1;
	+ scctx->isc_tx_csum_flags = CSUM_IP \| CSUM_TCP \| CSUM_UDP \| CSUM_TSO \|
	+ CSUM_IP6_TCP \| CSUM_IP6_UDP \| CSUM_IP6_TSO;
	+ scctx->isc_tx_nsegments = IXGBE_82599_SCATTER;
	+ scctx->isc_msix_bar = PCIR_BAR(MSIX_82598_BAR);
	+ scctx->isc_tx_tso_segments_max = scctx->isc_tx_nsegments;
	+ scctx->isc_tx_tso_size_max = IXGBE_TSO_SIZE;
	+ scctx->isc_tx_tso_segsize_max = PAGE_SIZE;
	+
	+ scctx->isc_txrx = &ixgbe_txrx;

	- /* Allocate our TX/RX Queues */
	- if (ixgbe_allocate_queues(adapter)) {
	- device_printf(dev, "ixgbe_allocate_queues() failed!\n");
	- error = ENOMEM;
	- goto err_out;
	- }
	+ /*
	+ * Tell the upper layer(s) we support everything the PF
	+ * driver does except...
	+ * hardware stats
	+ * Wake-on-LAN
	+ */
	+ scctx->isc_capenable = IXGBE_CAPS;
	+ scctx->isc_capenable ^= IFCAP_HWSTATS \| IFCAP_WOL;

	- /* Setup OS specific network interface */
	- ixv_setup_interface(dev, adapter);
	+ INIT_DEBUGOUT("ixv_if_attach_pre: end");

	- error = ixv_allocate_msix(adapter);
	+ return (0);
	+
	+err_out:
	+ ixv_free_pci_resources(ctx);
	+
	+ return (error);
	+} /* ixv_if_attach_pre */
	+
	+static int
	+ixv_if_attach_post(if_ctx_t ctx)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+ int error = 0;
	+
	+ /* Setup OS specific network interface */
	+ error = ixv_setup_interface(ctx);
	if (error) {
	- device_printf(dev, "ixv_allocate_msix() failed!\n");
	- goto err_late;
	+ device_printf(dev, "Interface setup failed: %d\n", error);
	+ goto end;
	}

	/* Do the stats setup */
	@@ -458,23 +548,9 @@
	ixv_init_stats(adapter);
	ixv_add_stats_sysctls(adapter);

	- if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
	- ixgbe_netmap_attach(adapter);
	-
	- INIT_DEBUGOUT("ixv_attach: end");
	-
	- return (0);
	-
	-err_late:
	- ixgbe_free_transmit_structures(adapter);
	- ixgbe_free_receive_structures(adapter);
	- free(adapter->queues, M_DEVBUF);
	-err_out:
	- ixv_free_pci_resources(adapter);
	- IXGBE_CORE_LOCK_DESTROY(adapter);
	-
	- return (error);
	-} /* ixv_attach */
	+end:
	+ return error;
	+} /* ixv_if_attach_post */

	/************************************************************************
	* ixv_detach - Device removal routine
	@@ -486,65 +562,38 @@
	* return 0 on success, positive on failure
	************************************************************************/
	static int
	-ixv_detach(device_t dev)
	+ixv_if_detach(if_ctx_t ctx)
	{
	- struct adapter *adapter = device_get_softc(dev);
	- struct ix_queue *que = adapter->queues;
	-
	INIT_DEBUGOUT("ixv_detach: begin");

	- /* Make sure VLANS are not using driver */
	- if (adapter->ifp->if_vlantrunk != NULL) {
	- device_printf(dev, "Vlan in use, detach first\n");
	- return (EBUSY);
	- }
	-
	- ether_ifdetach(adapter->ifp);
	- IXGBE_CORE_LOCK(adapter);
	- ixv_stop(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-
	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	- if (que->tq) {
	- struct tx_ring *txr = que->txr;
	- taskqueue_drain(que->tq, &txr->txq_task);
	- taskqueue_drain(que->tq, &que->que_task);
	- taskqueue_free(que->tq);
	- }
	- }
	-
	- /* Drain the Mailbox(link) queue */
	- if (adapter->tq) {
	- taskqueue_drain(adapter->tq, &adapter->link_task);
	- taskqueue_free(adapter->tq);
	- }
	-
	- /* Unregister VLAN events */
	- if (adapter->vlan_attach != NULL)
	- EVENTHANDLER_DEREGISTER(vlan_config, adapter->vlan_attach);
	- if (adapter->vlan_detach != NULL)
	- EVENTHANDLER_DEREGISTER(vlan_unconfig, adapter->vlan_detach);
	-
	- callout_drain(&adapter->timer);
	+ ixv_free_pci_resources(ctx);

	- if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
	- netmap_detach(adapter->ifp);
	-
	- ixv_free_pci_resources(adapter);
	- bus_generic_detach(dev);
	- if_free(adapter->ifp);
	+ return (0);
	+} /* ixv_if_detach */

	- ixgbe_free_transmit_structures(adapter);
	- ixgbe_free_receive_structures(adapter);
	- free(adapter->queues, M_DEVBUF);
	+/************************************************************************
	+ * ixv_if_mtu_set
	+ ************************************************************************/
	+static int
	+ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ int error = 0;

	- IXGBE_CORE_LOCK_DESTROY(adapter);
	+ IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
	+ if (mtu > IXGBE_MAX_FRAME_SIZE - IXGBE_MTU_HDR) {
	+ error = EINVAL;
	+ } else {
	+ ifp->if_mtu = mtu;
	+ adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
	+ }

	- return (0);
	-} /* ixv_detach */
	+ return error;
	+} /* ixv_if_mtu_set */

	/************************************************************************
	- * ixv_init_locked - Init entry point
	+ * ixv_if_init - Init entry point
	*
	* Used in two ways: It is used by the stack as an init entry
	* point in network interface structure. It is also used
	@@ -553,48 +602,39 @@
	*
	* return 0 on success, positive on failure
	************************************************************************/
	-void
	-ixv_init_locked(struct adapter *adapter)
	+static void
	+ixv_if_init(if_ctx_t ctx)
	{
	- struct ifnet *ifp = adapter->ifp;
	- device_t dev = adapter->dev;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	int error = 0;

	- INIT_DEBUGOUT("ixv_init_locked: begin");
	- mtx_assert(&adapter->core_mtx, MA_OWNED);
	+ INIT_DEBUGOUT("ixv_if_init: begin");
	hw->adapter_stopped = FALSE;
	hw->mac.ops.stop_adapter(hw);
	- callout_stop(&adapter->timer);

	/* reprogram the RAR[0] in case user changed it. */
	hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);

	/* Get the latest mac address, User can use a LAA */
	- bcopy(IF_LLADDR(adapter->ifp), hw->mac.addr,
	- IXGBE_ETH_LENGTH_OF_ADDRESS);
	+ bcopy(IF_LLADDR(ifp), hw->mac.addr, IXGBE_ETH_LENGTH_OF_ADDRESS);
	hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1);

	- /* Prepare transmit descriptors and buffers */
	- if (ixgbe_setup_transmit_structures(adapter)) {
	- device_printf(dev, "Could not setup transmit structures\n");
	- ixv_stop(adapter);
	- return;
	- }
	-
	/* Reset VF and renegotiate mailbox API version */
	hw->mac.ops.reset_hw(hw);
	error = ixv_negotiate_api(adapter);
	if (error) {
	device_printf(dev,
	- "Mailbox API negotiation failed in init_locked!\n");
	+ "Mailbox API negotiation failed in if_init!\n");
	return;
	}

	- ixv_initialize_transmit_units(adapter);
	+ ixv_initialize_transmit_units(ctx);

	/* Setup Multicast table */
	- ixv_set_multi(adapter);
	+ ixv_if_multi_set(ctx);

	/*
	* Determine the correct mbuf pool
	@@ -605,29 +645,11 @@
	else
	adapter->rx_mbuf_sz = MCLBYTES;

	- /* Prepare receive descriptors and buffers */
	- if (ixgbe_setup_receive_structures(adapter)) {
	- device_printf(dev, "Could not setup receive structures\n");
	- ixv_stop(adapter);
	- return;
	- }
	-
	/* Configure RX settings */
	- ixv_initialize_receive_units(adapter);
	-
	- /* Set the various hardware offload abilities */
	- ifp->if_hwassist = 0;
	- if (ifp->if_capenable & IFCAP_TSO4)
	- ifp->if_hwassist \|= CSUM_TSO;
	- if (ifp->if_capenable & IFCAP_TXCSUM) {
	- ifp->if_hwassist \|= (CSUM_TCP \| CSUM_UDP);
	-#if __FreeBSD_version >= 800000
	- ifp->if_hwassist \|= CSUM_SCTP;
	-#endif
	- }
	+ ixv_initialize_receive_units(ctx);

	/* Set up VLAN offload and filter */
	- ixv_setup_vlan_support(adapter);
	+ ixv_setup_vlan_support(ctx);

	/* Set up MSI-X routing */
	ixv_configure_ivars(adapter);
	@@ -645,23 +667,19 @@
	hw->mac.ops.check_link(hw, &adapter->link_speed, &adapter->link_up,
	FALSE);

	- /* Start watchdog */
	- callout_reset(&adapter->timer, hz, ixv_local_timer, adapter);
	-
	/* And now turn on interrupts */
	- ixv_enable_intr(adapter);
	+ ixv_if_enable_intr(ctx);

	/* Now inform the stack we're ready */
	ifp->if_drv_flags \|= IFF_DRV_RUNNING;
	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;

	return;
	-} /* ixv_init_locked */
	-
	-/*
	- * MSI-X Interrupt Handlers and Tasklets
	- */
	+} /* ixv_if_init */

	+/************************************************************************
	+ * ixv_enable_queue
	+ ************************************************************************/
	static inline void
	ixv_enable_queue(struct adapter *adapter, u32 vector)
	{
	@@ -673,6 +691,9 @@
	IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);
	} /* ixv_enable_queue */

	+/************************************************************************
	+ * ixv_disable_queue
	+ ************************************************************************/
	static inline void
	ixv_disable_queue(struct adapter *adapter, u32 vector)
	{
	@@ -684,44 +705,24 @@
	IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask);
	} /* ixv_disable_queue */

	-static inline void
	-ixv_rearm_queues(struct adapter *adapter, u64 queues)
	-{
	- u32 mask = (IXGBE_EIMS_RTX_QUEUE & queues);
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEICS, mask);
	-} /* ixv_rearm_queues */
	-

	/************************************************************************
	- * ixv_msix_que - MSI Queue Interrupt Service routine
	+ * ixv_msix_que - MSI-X Queue Interrupt Service routine
	************************************************************************/
	-void
	+static int
	ixv_msix_que(void *arg)
	{
	- struct ix_queue *que = arg;
	- struct adapter *adapter = que->adapter;
	- struct ifnet *ifp = adapter->ifp;
	- struct tx_ring *txr = que->txr;
	- struct rx_ring *rxr = que->rxr;
	- bool more;
	- u32 newitr = 0;
	+ struct ix_rx_queue *que = arg;
	+ struct adapter *adapter = que->adapter;
	+ struct rx_ring *rxr = &que->rxr;
	+ u32 newitr = 0;
	+#ifdef notyet
	+ struct tx_ring *txr = &que->txr;
	+#endif

	ixv_disable_queue(adapter, que->msix);
	++que->irqs;

	- more = ixgbe_rxeof(que);
	-
	- IXGBE_TX_LOCK(txr);
	- ixgbe_txeof(txr);
	- /*
	- * Make certain that if the stack
	- * has anything queued the task gets
	- * scheduled to handle it.
	- */
	- if (!ixv_ring_empty(adapter->ifp, txr->br))
	- ixv_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	-
	/* Do AIM now? */

	if (ixv_enable_aim == FALSE)
	@@ -738,12 +739,13 @@

	que->eitr_setting = 0;

	- /* Idle, do nothing */
	- if ((txr->bytes == 0) && (rxr->bytes == 0))
	- goto no_calc;
	-
	+#ifdef notyet
	if ((txr->bytes) && (txr->packets))
	newitr = txr->bytes/txr->packets;
	+#endif
	+ if (rxr->bytes == 0)
	+ goto no_calc;
	+
	if ((rxr->bytes) && (rxr->packets))
	newitr = max(newitr, (rxr->bytes / rxr->packets));
	newitr += 24; /* account for hardware frame, crc */
	@@ -763,24 +765,22 @@
	que->eitr_setting = newitr;

	/* Reset state */
	+#ifdef notyet
	txr->bytes = 0;
	txr->packets = 0;
	+#endif
	rxr->bytes = 0;
	rxr->packets = 0;

	no_calc:
	- if (more)
	- taskqueue_enqueue(que->tq, &que->que_task);
	- else /* Re-enable this interrupt */
	- ixv_enable_queue(adapter, que->msix);

	- return;
	+ return (FILTER_SCHEDULE_THREAD);
	} /* ixv_msix_que */

	/************************************************************************
	* ixv_msix_mbx
	************************************************************************/
	-static void
	+static int
	ixv_msix_mbx(void *arg)
	{
	struct adapter *adapter = arg;
	@@ -796,11 +796,11 @@

	/* Link status change */
	if (reg & IXGBE_EICR_LSC)
	- taskqueue_enqueue(adapter->tq, &adapter->link_task);
	+ iflib_admin_intr_deferred(adapter->ctx);

	IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, IXGBE_EIMS_OTHER);

	- return;
	+ return (FILTER_HANDLED);
	} /* ixv_msix_mbx */

	/************************************************************************
	@@ -810,21 +810,19 @@
	* the interface using ifconfig.
	************************************************************************/
	static void
	-ixv_media_status(struct ifnet ifp, struct ifmediareq ifmr)
	+ixv_if_media_status(if_ctx_t ctx, struct ifmediareq * ifmr)
	{
	- struct adapter *adapter = ifp->if_softc;
	+ struct adapter *adapter = iflib_get_softc(ctx);

	INIT_DEBUGOUT("ixv_media_status: begin");
	- IXGBE_CORE_LOCK(adapter);
	- ixv_update_link_status(adapter);
	+
	+ iflib_admin_intr_deferred(ctx);

	ifmr->ifm_status = IFM_AVALID;
	ifmr->ifm_active = IFM_ETHER;

	- if (!adapter->link_active) {
	- IXGBE_CORE_UNLOCK(adapter);
	+ if (!adapter->link_active)
	return;
	- }

	ifmr->ifm_status \|= IFM_ACTIVE;

	@@ -842,23 +840,19 @@
	ifmr->ifm_active \|= IFM_10_T \| IFM_FDX;
	break;
	}
	-
	- IXGBE_CORE_UNLOCK(adapter);
	-
	- return;
	-} /* ixv_media_status */
	+} /* ixv_if_media_status */

	/************************************************************************
	- * ixv_media_change - Media Ioctl callback
	+ * ixv_if_media_change - Media Ioctl callback
	*
	* Called when the user changes speed/duplex using
	* media/mediopt option with ifconfig.
	************************************************************************/
	static int
	-ixv_media_change(struct ifnet *ifp)
	+ixv_if_media_change(if_ctx_t ctx)
	{
	- struct adapter *adapter = ifp->if_softc;
	- struct ifmedia *ifm = &adapter->media;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ifmedia *ifm = iflib_get_media(ctx);

	INIT_DEBUGOUT("ixv_media_change: begin");

	@@ -874,7 +868,7 @@
	}

	return (0);
	-} /* ixv_media_change */
	+} /* ixv_if_media_change */


	/************************************************************************
	@@ -903,26 +897,22 @@


	/************************************************************************
	- * ixv_set_multi - Multicast Update
	+ * ixv_if_multi_set - Multicast Update
	*
	* Called whenever multicast address list is updated.
	************************************************************************/
	static void
	-ixv_set_multi(struct adapter *adapter)
	+ixv_if_multi_set(if_ctx_t ctx)
	{
	u8 mta[MAX_NUM_MULTICAST_ADDRESSES * IXGBE_ETH_LENGTH_OF_ADDRESS];
	+ struct adapter *adapter = iflib_get_softc(ctx);
	u8 *update_ptr;
	struct ifmultiaddr *ifma;
	- struct ifnet *ifp = adapter->ifp;
	+ if_t ifp = iflib_get_ifp(ctx);
	int mcnt = 0;

	- IOCTL_DEBUGOUT("ixv_set_multi: begin");
	+ IOCTL_DEBUGOUT("ixv_if_multi_set: begin");

	-#if __FreeBSD_version < 800000
	- IF_ADDR_LOCK(ifp);
	-#else
	- if_maddr_rlock(ifp);
	-#endif
	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
	if (ifma->ifma_addr->sa_family != AF_LINK)
	continue;
	@@ -931,19 +921,12 @@
	IXGBE_ETH_LENGTH_OF_ADDRESS);
	mcnt++;
	}
	-#if __FreeBSD_version < 800000
	- IF_ADDR_UNLOCK(ifp);
	-#else
	- if_maddr_runlock(ifp);
	-#endif

	update_ptr = mta;

	adapter->hw.mac.ops.update_mc_addr_list(&adapter->hw, update_ptr, mcnt,
	ixv_mc_array_itr, TRUE);
	-
	- return;
	-} /* ixv_set_multi */
	+} /* ixv_if_multi_set */

	/************************************************************************
	* ixv_mc_array_itr
	@@ -957,6 +940,7 @@
	{
	u8 addr = update_ptr;
	u8 *newptr;
	+
	*vmdq = 0;

	newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS;
	@@ -966,157 +950,218 @@
	} /* ixv_mc_array_itr */

	/************************************************************************
	- * ixv_local_timer - Timer routine
	+ * ixv_if_local_timer - Timer routine
	*
	* Checks for link status, updates statistics,
	* and runs the watchdog check.
	************************************************************************/
	static void
	-ixv_local_timer(void *arg)
	+ixv_if_local_timer(if_ctx_t ctx, uint16_t qid)
	{
	- struct adapter *adapter = arg;
	- device_t dev = adapter->dev;
	- struct ix_queue *que = adapter->queues;
	- u64 queues = 0;
	- int hung = 0;
	-
	- mtx_assert(&adapter->core_mtx, MA_OWNED);
	-
	- ixv_check_link(adapter);
	-
	- /* Stats Update */
	- ixv_update_stats(adapter);
	-
	- /*
	- * Check the TX queues status
	- * - mark hung queues so we don't schedule on them
	- * - watchdog only if all queues show hung
	- */
	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	- /* Keep track of queues with work for soft irq */
	- if (que->txr->busy)
	- queues \|= ((u64)1 << que->me);
	- /*
	- * Each time txeof runs without cleaning, but there
	- * are uncleaned descriptors it increments busy. If
	- * we get to the MAX we declare it hung.
	- */
	- if (que->busy == IXGBE_QUEUE_HUNG) {
	- ++hung;
	- /* Mark the queue as inactive */
	- adapter->active_queues &= ~((u64)1 << que->me);
	- continue;
	- } else {
	- /* Check if we've come back from hung */
	- if ((adapter->active_queues & ((u64)1 << que->me)) == 0)
	- adapter->active_queues \|= ((u64)1 << que->me);
	- }
	- if (que->busy >= IXGBE_MAX_TX_BUSY) {
	- device_printf(dev,
	- "Warning queue %d appears to be hung!\n", i);
	- que->txr->busy = IXGBE_QUEUE_HUNG;
	- ++hung;
	- }
	-
	- }
	-
	- /* Only truly watchdog if all queues show hung */
	- if (hung == adapter->num_queues)
	- goto watchdog;
	- else if (queues != 0) { /* Force an IRQ on queues with work */
	- ixv_rearm_queues(adapter, queues);
	- }
	-
	- callout_reset(&adapter->timer, hz, ixv_local_timer, adapter);
	-
	- return;
	-
	-watchdog:
	+ if (qid != 0)
	+ return;

	- device_printf(adapter->dev, "Watchdog timeout -- resetting\n");
	- adapter->ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
	- adapter->watchdog_events++;
	- ixv_init_locked(adapter);
	-} /* ixv_local_timer */
	+ /* Fire off the adminq task */
	+ iflib_admin_intr_deferred(ctx);
	+} /* ixv_if_local_timer */

	/************************************************************************
	- * ixv_update_link_status - Update OS on link state
	+ * ixv_if_update_admin_status - Update OS on link state
	*
	* Note: Only updates the OS on the cached link state.
	* The real check of the hardware only happens with
	* a link interrupt.
	************************************************************************/
	static void
	-ixv_update_link_status(struct adapter *adapter)
	+ixv_if_update_admin_status(if_ctx_t ctx)
	{
	- struct ifnet *ifp = adapter->ifp;
	- device_t dev = adapter->dev;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+
	+ adapter->hw.mac.get_link_status = TRUE;
	+ ixgbe_check_link(&adapter->hw, &adapter->link_speed, &adapter->link_up,
	+ FALSE);

	if (adapter->link_up) {
	if (adapter->link_active == FALSE) {
	if (bootverbose)
	- device_printf(dev,"Link is up %d Gbps %s \n",
	+ device_printf(dev, "Link is up %d Gbps %s \n",
	((adapter->link_speed == 128) ? 10 : 1),
	"Full Duplex");
	adapter->link_active = TRUE;
	- if_link_state_change(ifp, LINK_STATE_UP);
	+ iflib_link_state_change(ctx, LINK_STATE_UP,
	+ IF_Gbps(10));
	}
	} else { /* Link down */
	if (adapter->link_active == TRUE) {
	if (bootverbose)
	- device_printf(dev,"Link is Down\n");
	- if_link_state_change(ifp, LINK_STATE_DOWN);
	+ device_printf(dev, "Link is Down\n");
	+ iflib_link_state_change(ctx, LINK_STATE_DOWN, 0);
	adapter->link_active = FALSE;
	}
	}

	- return;
	-} /* ixv_update_link_status */
	+ /* Stats Update */
	+ ixv_update_stats(adapter);
	+} /* ixv_if_update_admin_status */


	/************************************************************************
	- * ixv_stop - Stop the hardware
	+ * ixv_if_stop - Stop the hardware
	*
	* Disables all traffic on the adapter by issuing a
	* global reset on the MAC and deallocates TX/RX buffers.
	************************************************************************/
	static void
	-ixv_stop(void *arg)
	+ixv_if_stop(if_ctx_t ctx)
	{
	- struct ifnet *ifp;
	- struct adapter *adapter = arg;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;

	- ifp = adapter->ifp;
	+ INIT_DEBUGOUT("ixv_stop: begin\n");

	- mtx_assert(&adapter->core_mtx, MA_OWNED);
	+ ixv_if_disable_intr(ctx);

	- INIT_DEBUGOUT("ixv_stop: begin\n");
	- ixv_disable_intr(adapter);
	+ hw->mac.ops.reset_hw(hw);
	+ adapter->hw.adapter_stopped = FALSE;
	+ hw->mac.ops.stop_adapter(hw);
	+
	+ /* Update the stack */
	+ adapter->link_up = FALSE;
	+ ixv_if_update_admin_status(ctx);

	- /* Tell the stack that the interface is no longer active */
	- ifp->if_drv_flags &= ~(IFF_DRV_RUNNING \| IFF_DRV_OACTIVE);
	+ /* reprogram the RAR[0] in case user changed it. */
	+ hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
	+} /* ixv_if_stop */
	+
	+
	+/************************************************************************
	+ * ixv_identify_hardware - Determine hardware revision.
	+ ************************************************************************/
	+static void
	+ixv_identify_hardware(if_ctx_t ctx)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+ struct ixgbe_hw *hw = &adapter->hw;
	+
	+ /* Save off the information about this board */
	+ hw->vendor_id = pci_get_vendor(dev);
	+ hw->device_id = pci_get_device(dev);
	+ hw->revision_id = pci_get_revid(dev);
	+ hw->subsystem_vendor_id = pci_get_subvendor(dev);
	+ hw->subsystem_device_id = pci_get_subdevice(dev);
	+
	+ /* A subset of set_mac_type */
	+ switch (hw->device_id) {
	+ case IXGBE_DEV_ID_82599_VF:
	+ hw->mac.type = ixgbe_mac_82599_vf;
	+ break;
	+ case IXGBE_DEV_ID_X540_VF:
	+ hw->mac.type = ixgbe_mac_X540_vf;
	+ break;
	+ case IXGBE_DEV_ID_X550_VF:
	+ hw->mac.type = ixgbe_mac_X550_vf;
	+ break;
	+ case IXGBE_DEV_ID_X550EM_X_VF:
	+ hw->mac.type = ixgbe_mac_X550EM_x_vf;
	+ break;
	+ case IXGBE_DEV_ID_X550EM_A_VF:
	+ hw->mac.type = ixgbe_mac_X550EM_a_vf;
	+ break;
	+ default:
	+ device_printf(dev, "unknown mac type\n");
	+ hw->mac.type = ixgbe_mac_unknown;
	+ break;
	+ }
	+} /* ixv_identify_hardware */
	+
	+/************************************************************************
	+ * ixv_if_msix_intr_assign - Setup MSI-X Interrupt resources and handlers
	+ ************************************************************************/
	+static int
	+ixv_if_msix_intr_assign(if_ctx_t ctx, int msix)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+ struct ix_rx_queue *rx_que = adapter->rx_queues;
	+ struct ix_tx_queue *tx_que;
	+ int error, rid, vector = 0;
	+ char buf[16];
	+
	+ for (int i = 0; i < adapter->num_rx_queues; i++, vector++, rx_que++) {
	+ rid = vector + 1;
	+
	+ snprintf(buf, sizeof(buf), "rxq%d", i);
	+ error = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
	+ IFLIB_INTR_RX, ixv_msix_que, rx_que, rx_que->rxr.me, buf);
	+
	+ if (error) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Failed to allocate que int %d err: %d", i, error);
	+ adapter->num_rx_queues = i + 1;
	+ goto fail;
	+ }
	+
	+ rx_que->msix = vector;
	+ adapter->active_queues \|= (u64)(1 << rx_que->msix);
	+
	+ }
	+
	+ for (int i = 0; i < adapter->num_tx_queues; i++) {
	+ snprintf(buf, sizeof(buf), "txq%d", i);
	+ tx_que = &adapter->tx_queues[i];
	+ tx_que->msix = i % adapter->num_rx_queues;
	+ iflib_softirq_alloc_generic(ctx,
	+ &adapter->rx_queues[tx_que->msix].que_irq,
	+ IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
	+ }
	+ rid = vector + 1;
	+ error = iflib_irq_alloc_generic(ctx, &adapter->irq, rid,
	+ IFLIB_INTR_ADMIN, ixv_msix_mbx, adapter, 0, "aq");
	+ if (error) {
	+ device_printf(iflib_get_dev(ctx),
	+ "Failed to register admin handler");
	+ return (error);
	+ }

	- hw->mac.ops.reset_hw(hw);
	- adapter->hw.adapter_stopped = FALSE;
	- hw->mac.ops.stop_adapter(hw);
	- callout_stop(&adapter->timer);
	+ adapter->vector = vector;
	+ /*
	+ * Due to a broken design QEMU will fail to properly
	+ * enable the guest for MSIX unless the vectors in
	+ * the table are all set up, so we must rewrite the
	+ * ENABLE in the MSIX control register again at this
	+ * point to cause it to successfully initialize us.
	+ */
	+ if (adapter->hw.mac.type == ixgbe_mac_82599_vf) {
	+ int msix_ctrl;
	+ pci_find_cap(dev, PCIY_MSIX, &rid);
	+ rid += PCIR_MSIX_CTRL;
	+ msix_ctrl = pci_read_config(dev, rid, 2);
	+ msix_ctrl \|= PCIM_MSIXCTRL_MSIX_ENABLE;
	+ pci_write_config(dev, rid, msix_ctrl, 2);
	+ }

	- /* reprogram the RAR[0] in case user changed it. */
	- hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
	+ return (0);

	- return;
	-} /* ixv_stop */
	+fail:
	+ iflib_irq_free(ctx, &adapter->irq);
	+ rx_que = adapter->rx_queues;
	+ for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++)
	+ iflib_irq_free(ctx, &rx_que->que_irq);

	+ return (error);
	+} /* ixv_if_msix_intr_assign */

	/************************************************************************
	* ixv_allocate_pci_resources
	************************************************************************/
	static int
	-ixv_allocate_pci_resources(struct adapter *adapter)
	+ixv_allocate_pci_resources(if_ctx_t ctx)
	{
	- device_t dev = adapter->dev;
	- int rid;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ device_t dev = iflib_get_dev(ctx);
	+ int rid;

	rid = PCIR_BAR(0);
	adapter->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
	@@ -1132,9 +1177,6 @@
	rman_get_bushandle(adapter->pci_mem);
	adapter->hw.hw_addr = (u8 *)&adapter->osdep.mem_bus_space_handle;

	- /* Pick up the tuneable queues */
	- adapter->num_queues = ixv_num_queues;
	-
	return (0);
	} /* ixv_allocate_pci_resources */

	@@ -1142,61 +1184,26 @@
	* ixv_free_pci_resources
	************************************************************************/
	static void
	-ixv_free_pci_resources(struct adapter * adapter)
	+ixv_free_pci_resources(if_ctx_t ctx)
	{
	- struct ix_queue *que = adapter->queues;
	- device_t dev = adapter->dev;
	- int rid, memrid;
	-
	- memrid = PCIR_BAR(MSIX_82598_BAR);
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_rx_queue *que = adapter->rx_queues;
	+ device_t dev = iflib_get_dev(ctx);

	- /*
	- * There is a slight possibility of a failure mode
	- * in attach that will result in entering this function
	- * before interrupt resources have been initialized, and
	- * in that case we do not want to execute the loops below
	- * We can detect this reliably by the state of the adapter
	- * res pointer.
	- */
	- if (adapter->res == NULL)
	- goto mem;
	+ /* Release all msix queue resources */
	+ if (adapter->intr_type == IFLIB_INTR_MSIX)
	+ iflib_irq_free(ctx, &adapter->irq);

	- /*
	- * Release all msix queue resources:
	- */
	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	- rid = que->msix + 1;
	- if (que->tag != NULL) {
	- bus_teardown_intr(dev, que->res, que->tag);
	- que->tag = NULL;
	+ if (que != NULL) {
	+ for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
	+ iflib_irq_free(ctx, &que->que_irq);
	}
	- if (que->res != NULL)
	- bus_release_resource(dev, SYS_RES_IRQ, rid, que->res);
	- }
	-
	-
	- /* Clean the Mailbox interrupt last */
	- rid = adapter->vector + 1;
	-
	- if (adapter->tag != NULL) {
	- bus_teardown_intr(dev, adapter->res, adapter->tag);
	- adapter->tag = NULL;
	}
	- if (adapter->res != NULL)
	- bus_release_resource(dev, SYS_RES_IRQ, rid, adapter->res);
	-
	-mem:
	- pci_release_msi(dev);
	-
	- if (adapter->msix_mem != NULL)
	- bus_release_resource(dev, SYS_RES_MEMORY, memrid,
	- adapter->msix_mem);

	+ /* Clean the Legacy or Link interrupt last */
	if (adapter->pci_mem != NULL)
	- bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0),
	- adapter->pci_mem);
	-
	- return;
	+ bus_release_resource(dev, SYS_RES_MEMORY,
	+ PCIR_BAR(0), adapter->pci_mem);
	} /* ixv_free_pci_resources */

	/************************************************************************
	@@ -1204,121 +1211,105 @@
	*
	* Setup networking device structure and register an interface.
	************************************************************************/
	-static void
	-ixv_setup_interface(device_t dev, struct adapter *adapter)
	+static int
	+ixv_setup_interface(if_ctx_t ctx)
	{
	- struct ifnet *ifp;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ if_softc_ctx_t scctx = adapter->shared;
	+ struct ifnet *ifp = iflib_get_ifp(ctx);

	INIT_DEBUGOUT("ixv_setup_interface: begin");

	- ifp = adapter->ifp = if_alloc(IFT_ETHER);
	- if (ifp == NULL)
	- panic("%s: can not if_alloc()\n", device_get_nameunit(dev));
	- if_initname(ifp, device_get_name(dev), device_get_unit(dev));
	- ifp->if_baudrate = 1000000000;
	- ifp->if_init = ixv_init;
	- ifp->if_softc = adapter;
	- ifp->if_flags = IFF_BROADCAST \| IFF_SIMPLEX \| IFF_MULTICAST;
	- ifp->if_ioctl = ixv_ioctl;
	- if_setgetcounterfn(ifp, ixv_get_counter);
	- /* TSO parameters */
	- ifp->if_hw_tsomax = 65518;
	- ifp->if_hw_tsomaxsegcount = IXGBE_82599_SCATTER;
	- ifp->if_hw_tsomaxsegsize = 2048;
	- if (adapter->feat_en & IXGBE_FEATURE_LEGACY_TX) {
	- ifp->if_start = ixgbe_legacy_start;
	- ixv_start_locked = ixgbe_legacy_start_locked;
	- ixv_ring_empty = ixgbe_legacy_ring_empty;
	- } else {
	- ifp->if_transmit = ixgbe_mq_start;
	- ifp->if_qflush = ixgbe_qflush;
	- ixv_start_locked = ixgbe_mq_start_locked;
	- ixv_ring_empty = drbr_empty;
	- }
	- IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2);
	+ if_setifheaderlen(ifp, sizeof(struct ether_vlan_header));
	+ if_setbaudrate(ifp, IF_Gbps(10));
	+ ifp->if_snd.ifq_maxlen = scctx->isc_ntxd[0] - 2;

	- ether_ifattach(ifp, adapter->hw.mac.addr);

	adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
	+ ifmedia_add(adapter->media, IFM_ETHER \| IFM_AUTO, 0, NULL);
	+ ifmedia_set(adapter->media, IFM_ETHER \| IFM_AUTO);

	- /*
	- * Tell the upper layer(s) we support long frames.
	- */
	- ifp->if_hdrlen = sizeof(struct ether_vlan_header);
	-
	- /* Set capability flags */
	- ifp->if_capabilities \|= IFCAP_HWCSUM
	- \| IFCAP_HWCSUM_IPV6
	- \| IFCAP_TSO
	- \| IFCAP_LRO
	- \| IFCAP_VLAN_HWTAGGING
	- \| IFCAP_VLAN_HWTSO
	- \| IFCAP_VLAN_HWCSUM
	- \| IFCAP_JUMBO_MTU
	- \| IFCAP_VLAN_MTU;
	-
	- /* Enable the above capabilities by default */
	- ifp->if_capenable = ifp->if_capabilities;
	-
	- /*
	- * Specify the media types supported by this adapter and register
	- * callbacks to update media and link information
	- */
	- ifmedia_init(&adapter->media, IFM_IMASK, ixv_media_change,
	- ixv_media_status);
	- ifmedia_add(&adapter->media, IFM_ETHER \| IFM_AUTO, 0, NULL);
	- ifmedia_set(&adapter->media, IFM_ETHER \| IFM_AUTO);
	-
	- return;
	+ return 0;
	} /* ixv_setup_interface */

	+/************************************************************************
	+ * ixv_if_get_counter
	+ ************************************************************************/
	+static uint64_t
	+ixv_if_get_counter(if_ctx_t ctx, ift_counter cnt)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ if_t ifp = iflib_get_ifp(ctx);
	+
	+ switch (cnt) {
	+ case IFCOUNTER_IPACKETS:
	+ return (adapter->ipackets);
	+ case IFCOUNTER_OPACKETS:
	+ return (adapter->opackets);
	+ case IFCOUNTER_IBYTES:
	+ return (adapter->ibytes);
	+ case IFCOUNTER_OBYTES:
	+ return (adapter->obytes);
	+ case IFCOUNTER_IMCASTS:
	+ return (adapter->imcasts);
	+ default:
	+ return (if_get_counter_default(ifp, cnt));
	+ }
	+} /* ixv_if_get_counter */

	/************************************************************************
	* ixv_initialize_transmit_units - Enable transmit unit.
	************************************************************************/
	static void
	-ixv_initialize_transmit_units(struct adapter *adapter)
	+ixv_initialize_transmit_units(if_ctx_t ctx)
	{
	- struct tx_ring *txr = adapter->tx_rings;
	- struct ixgbe_hw *hw = &adapter->hw;
	-
	-
	- for (int i = 0; i < adapter->num_queues; i++, txr++) {
	- u64 tdba = txr->txdma.dma_paddr;
	- u32 txctrl, txdctl;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ if_softc_ctx_t scctx = adapter->shared;
	+ struct ix_tx_queue *que = adapter->tx_queues;
	+ int i;
	+
	+ for (i = 0; i < adapter->num_tx_queues; i++, que++) {
	+ struct tx_ring *txr = &que->txr;
	+ u64 tdba = txr->tx_paddr;
	+ u32 txctrl, txdctl;
	+ int j = txr->me;

	/* Set WTHRESH to 8, burst writeback */
	- txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
	+ txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
	txdctl \|= (8 << 16);
	- IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), txdctl);
	+ IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);

	/* Set the HW Tx Head and Tail indices */
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(i), 0);
	- IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(i), 0);
	+ IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(j), 0);
	+ IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(j), 0);

	/* Set Tx Tail register */
	- txr->tail = IXGBE_VFTDT(i);
	+ txr->tail = IXGBE_VFTDT(j);
	+
	+ txr->tx_rs_cidx = txr->tx_rs_pidx = txr->tx_cidx_processed = 0;
	+ for (int k = 0; k < scctx->isc_ntxd[0]; k++)
	+ txr->tx_rsq[k] = QIDX_INVALID;

	/* Set Ring parameters */
	- IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(i),
	+ IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j),
	(tdba & 0x00000000ffffffffULL));
	- IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(i), (tdba >> 32));
	- IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(i),
	- adapter->num_tx_desc * sizeof(struct ixgbe_legacy_tx_desc));
	- txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(i));
	+ IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32));
	+ IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j),
	+ scctx->isc_ntxd[0] * sizeof(struct ixgbe_legacy_tx_desc));
	+ txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j));
	txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
	- IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(i), txctrl);
	+ IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl);

	/* Now enable */
	- txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
	+ txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
	txdctl \|= IXGBE_TXDCTL_ENABLE;
	- IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), txdctl);
	+ IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);
	}

	return;
	} /* ixv_initialize_transmit_units */

	-
	/************************************************************************
	* ixv_initialize_rss_mapping
	************************************************************************/
	@@ -1345,17 +1336,17 @@

	/* Set up the redirection table */
	for (i = 0, j = 0; i < 64; i++, j++) {
	- if (j == adapter->num_queues)
	+ if (j == adapter->num_rx_queues)
	j = 0;

	if (adapter->feat_en & IXGBE_FEATURE_RSS) {
	/*
	* Fetch the RSS bucket id for the given indirection
	* entry. Cap it at the number of configured buckets
	- * (which is num_queues.)
	+ * (which is num_rx_queues.)
	*/
	queue_id = rss_get_indirection_to_bucket(i);
	- queue_id = queue_id % adapter->num_queues;
	+ queue_id = queue_id % adapter->num_rx_queues;
	} else
	queue_id = j;

	@@ -1419,12 +1410,14 @@
	* ixv_initialize_receive_units - Setup receive registers and features.
	************************************************************************/
	static void
	-ixv_initialize_receive_units(struct adapter *adapter)
	+ixv_initialize_receive_units(if_ctx_t ctx)
	{
	- struct rx_ring *rxr = adapter->rx_rings;
	- struct ixgbe_hw *hw = &adapter->hw;
	- struct ifnet *ifp = adapter->ifp;
	- u32 bufsz, rxcsum, psrtype;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ if_softc_ctx_t scctx;
	+ struct ixgbe_hw *hw = &adapter->hw;
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+ struct ix_rx_queue *que = adapter->rx_queues;
	+ u32 bufsz, rxcsum, psrtype;

	if (ifp->if_mtu > ETHERMTU)
	bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
	@@ -1437,7 +1430,7 @@
	\| IXGBE_PSRTYPE_IPV6HDR
	\| IXGBE_PSRTYPE_L2HDR;

	- if (adapter->num_queues > 1)
	+ if (adapter->num_rx_queues > 1)
	psrtype \|= 1 << 29;

	IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype);
	@@ -1446,17 +1439,20 @@
	if (ixgbevf_rlpml_set_vf(hw, adapter->max_frame_size) != 0) {
	device_printf(adapter->dev, "There is a problem with the PF setup. It is likely the receive unit for this VF will not function correctly.\n");
	}
	+ scctx = adapter->shared;

	- for (int i = 0; i < adapter->num_queues; i++, rxr++) {
	- u64 rdba = rxr->rxdma.dma_paddr;
	- u32 reg, rxdctl;
	+ for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
	+ struct rx_ring *rxr = &que->rxr;
	+ u64 rdba = rxr->rx_paddr;
	+ u32 reg, rxdctl;
	+ int j = rxr->me;

	/* Disable the queue */
	- rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
	+ rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j));
	rxdctl &= ~IXGBE_RXDCTL_ENABLE;
	- IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), rxdctl);
	- for (int j = 0; j < 10; j++) {
	- if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)) &
	+ IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
	+ for (int k = 0; k < 10; k++) {
	+ if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
	IXGBE_RXDCTL_ENABLE)
	msec_delay(1);
	else
	@@ -1464,32 +1460,32 @@
	}
	wmb();
	/* Setup the Base and Length of the Rx Descriptor Ring */
	- IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(i),
	+ IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j),
	(rdba & 0x00000000ffffffffULL));
	- IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(i), (rdba >> 32));
	- IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(i),
	- adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc));
	+ IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32));
	+ IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j),
	+ scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc));

	/* Reset the ring indices */
	IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0);
	IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0);

	/* Set up the SRRCTL register */
	- reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i));
	+ reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j));
	reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK;
	reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK;
	reg \|= bufsz;
	reg \|= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
	- IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(i), reg);
	+ IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg);

	/* Capture Rx Tail index */
	rxr->tail = IXGBE_VFRDT(rxr->me);

	/* Do the queue enabling last */
	rxdctl \|= IXGBE_RXDCTL_ENABLE \| IXGBE_RXDCTL_VME;
	- IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), rxdctl);
	- for (int k = 0; k < 10; k++) {
	- if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)) &
	+ IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
	+ for (int l = 0; l < 10; l++) {
	+ if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
	IXGBE_RXDCTL_ENABLE)
	break;
	msec_delay(1);
	@@ -1497,6 +1493,7 @@
	wmb();

	/* Set the Tail Pointer */
	+#ifdef DEV_NETMAP
	/*
	* In netmap mode, we must preserve the buffers made
	* available to userspace before the if_init()
	@@ -1513,25 +1510,23 @@
	* RDT points to the last slot available for reception (?),
	* so RDT = num_rx_desc - 1 means the whole ring is available.
	*/
	-#ifdef DEV_NETMAP
	- if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) &&
	- (ifp->if_capenable & IFCAP_NETMAP)) {
	- struct netmap_adapter *na = NA(adapter->ifp);
	- struct netmap_kring *kring = &na->rx_rings[i];
	+ if (ifp->if_capenable & IFCAP_NETMAP) {
	+ struct netmap_adapter *na = NA(ifp);
	+ struct netmap_kring *kring = &na->rx_rings[j];
	int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring);

	IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t);
	} else
	#endif /* DEV_NETMAP */
	IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me),
	- adapter->num_rx_desc - 1);
	+ scctx->isc_nrxd[0] - 1);
	}

	rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM);

	ixv_initialize_rss_mapping(adapter);

	- if (adapter->num_queues > 1) {
	+ if (adapter->num_rx_queues > 1) {
	/* RSS and RX IPP Checksum are mutually exclusive */
	rxcsum \|= IXGBE_RXCSUM_PCSD;
	}
	@@ -1543,21 +1538,20 @@
	rxcsum \|= IXGBE_RXCSUM_IPPCSE;

	IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum);
	-
	- return;
	} /* ixv_initialize_receive_units */

	/************************************************************************
	* ixv_setup_vlan_support
	************************************************************************/
	static void
	-ixv_setup_vlan_support(struct adapter *adapter)
	+ixv_setup_vlan_support(if_ctx_t ctx)
	{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	u32 ctrl, vid, vfta, retry;

	/*
	- * We get here thru init_locked, meaning
	+ * We get here thru if_init, meaning
	* a soft reset, this has already cleared
	* the VFTA and other state, so if there
	* have been no vlan's registered do nothing.
	@@ -1566,7 +1560,7 @@
	return;

	/* Enable the queues */
	- for (int i = 0; i < adapter->num_queues; i++) {
	+ for (int i = 0; i < adapter->num_rx_queues; i++) {
	ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
	ctrl \|= IXGBE_RXDCTL_VME;
	IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), ctrl);
	@@ -1574,7 +1568,7 @@
	* Let Rx path know that it needs to store VLAN tag
	* as part of extra mbuf info.
	*/
	- adapter->rx_rings[i].vtag_strip = TRUE;
	+ adapter->rx_queues[i].rxr.vtag_strip = TRUE;
	}

	/*
	@@ -1605,7 +1599,7 @@
	} /* ixv_setup_vlan_support */

	/************************************************************************
	- * ixv_register_vlan
	+ * ixv_if_register_vlan
	*
	* Run via a vlan config EVENT, it enables us to use the
	* HW Filter table since we can get the vlan id. This just
	@@ -1613,92 +1607,83 @@
	* will repopulate the real table.
	************************************************************************/
	static void
	-ixv_register_vlan(void arg, struct ifnet ifp, u16 vtag)
	+ixv_if_register_vlan(if_ctx_t ctx, u16 vtag)
	{
	- struct adapter *adapter = ifp->if_softc;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	u16 index, bit;

	- if (ifp->if_softc != arg) /* Not our event */
	- return;
	-
	- if ((vtag == 0) \|\| (vtag > 4095)) /* Invalid */
	- return;
	-
	- IXGBE_CORE_LOCK(adapter);
	index = (vtag >> 5) & 0x7F;
	bit = vtag & 0x1F;
	ixv_shadow_vfta[index] \|= (1 << bit);
	++adapter->num_vlans;
	- /* Re-init to load the changes */
	- ixv_init_locked(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-} /* ixv_register_vlan */
	+} /* ixv_if_register_vlan */

	/************************************************************************
	- * ixv_unregister_vlan
	+ * ixv_if_unregister_vlan
	*
	* Run via a vlan unconfig EVENT, remove our entry
	* in the soft vfta.
	************************************************************************/
	static void
	-ixv_unregister_vlan(void arg, struct ifnet ifp, u16 vtag)
	+ixv_if_unregister_vlan(if_ctx_t ctx, u16 vtag)
	{
	- struct adapter *adapter = ifp->if_softc;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	u16 index, bit;

	- if (ifp->if_softc != arg)
	- return;
	-
	- if ((vtag == 0) \|\| (vtag > 4095)) /* Invalid */
	- return;
	-
	- IXGBE_CORE_LOCK(adapter);
	index = (vtag >> 5) & 0x7F;
	bit = vtag & 0x1F;
	ixv_shadow_vfta[index] &= ~(1 << bit);
	--adapter->num_vlans;
	- /* Re-init to load the changes */
	- ixv_init_locked(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-} /* ixv_unregister_vlan */
	+} /* ixv_if_unregister_vlan */

	/************************************************************************
	- * ixv_enable_intr
	+ * ixv_if_enable_intr
	************************************************************************/
	static void
	-ixv_enable_intr(struct adapter *adapter)
	+ixv_if_enable_intr(if_ctx_t ctx)
	{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw = &adapter->hw;
	- struct ix_queue *que = adapter->queues;
	+ struct ix_rx_queue *que = adapter->rx_queues;
	u32 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE);

	-
	IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);

	mask = IXGBE_EIMS_ENABLE_MASK;
	mask &= ~(IXGBE_EIMS_OTHER \| IXGBE_EIMS_LSC);
	IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask);

	- for (int i = 0; i < adapter->num_queues; i++, que++)
	+ for (int i = 0; i < adapter->num_rx_queues; i++, que++)
	ixv_enable_queue(adapter, que->msix);

	IXGBE_WRITE_FLUSH(hw);
	-
	- return;
	-} /* ixv_enable_intr */
	+} /* ixv_if_enable_intr */

	/************************************************************************
	- * ixv_disable_intr
	+ * ixv_if_disable_intr
	************************************************************************/
	static void
	-ixv_disable_intr(struct adapter *adapter)
	+ixv_if_disable_intr(if_ctx_t ctx)
	{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIAC, 0);
	IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIMC, ~0);
	IXGBE_WRITE_FLUSH(&adapter->hw);
	+} /* ixv_if_disable_intr */

	- return;
	-} /* ixv_disable_intr */
	+/************************************************************************
	+ * ixv_if_rx_queue_intr_enable
	+ ************************************************************************/
	+static int
	+ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
	+{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+ struct ix_rx_queue *que = &adapter->rx_queues[rxqid];
	+
	+ ixv_enable_queue(adapter, que->rxr.me);
	+
	+ return (0);
	+} /* ixv_if_rx_queue_intr_enable */

	/************************************************************************
	* ixv_set_ivar
	@@ -1736,9 +1721,11 @@
	static void
	ixv_configure_ivars(struct adapter *adapter)
	{
	- struct ix_queue *que = adapter->queues;
	+ struct ix_rx_queue *que = adapter->rx_queues;
	+
	+ MPASS(adapter->num_rx_queues == adapter->num_tx_queues);

	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	+ for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
	/* First the RX queue entry */
	ixv_set_ivar(adapter, i, que->msix, 0);
	/* ... and the TX */
	@@ -1752,33 +1739,6 @@
	ixv_set_ivar(adapter, 1, adapter->vector, -1);
	} /* ixv_configure_ivars */

	-
	-/************************************************************************
	- * ixv_get_counter
	- ************************************************************************/
	-static uint64_t
	-ixv_get_counter(struct ifnet *ifp, ift_counter cnt)
	-{
	- struct adapter *adapter;
	-
	- adapter = if_getsoftc(ifp);
	-
	- switch (cnt) {
	- case IFCOUNTER_IPACKETS:
	- return (adapter->ipackets);
	- case IFCOUNTER_OPACKETS:
	- return (adapter->opackets);
	- case IFCOUNTER_IBYTES:
	- return (adapter->ibytes);
	- case IFCOUNTER_OBYTES:
	- return (adapter->obytes);
	- case IFCOUNTER_IMCASTS:
	- return (adapter->imcasts);
	- default:
	- return (if_get_counter_default(ifp, cnt));
	- }
	-} /* ixv_get_counter */
	-
	/************************************************************************
	* ixv_save_stats
	*
	@@ -1862,15 +1822,15 @@
	struct ixgbe_hw *hw = &adapter->hw;
	struct ixgbevf_hw_stats *stats = &adapter->stats.vf;

	- UPDATE_STAT_32(IXGBE_VFGPRC, adapter->stats.vf.last_vfgprc,
	+ UPDATE_STAT_32(IXGBE_VFGPRC, adapter->stats.vf.last_vfgprc,
	adapter->stats.vf.vfgprc);
	- UPDATE_STAT_32(IXGBE_VFGPTC, adapter->stats.vf.last_vfgptc,
	+ UPDATE_STAT_32(IXGBE_VFGPTC, adapter->stats.vf.last_vfgptc,
	adapter->stats.vf.vfgptc);
	- UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB,
	+ UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB,
	adapter->stats.vf.last_vfgorc, adapter->stats.vf.vfgorc);
	- UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB,
	+ UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB,
	adapter->stats.vf.last_vfgotc, adapter->stats.vf.vfgotc);
	- UPDATE_STAT_32(IXGBE_VFMPRC, adapter->stats.vf.last_vfmprc,
	+ UPDATE_STAT_32(IXGBE_VFMPRC, adapter->stats.vf.last_vfmprc,
	adapter->stats.vf.vfmprc);

	/* Fill out the OS statistics structure */
	@@ -1888,8 +1848,8 @@
	ixv_add_stats_sysctls(struct adapter *adapter)
	{
	device_t dev = adapter->dev;
	- struct tx_ring *txr = adapter->tx_rings;
	- struct rx_ring *rxr = adapter->rx_rings;
	+ struct ix_tx_queue *tx_que = adapter->tx_queues;
	+ struct ix_rx_queue *rx_que = adapter->rx_queues;
	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
	struct sysctl_oid *tree = device_get_sysctl_tree(dev);
	struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
	@@ -1901,42 +1861,33 @@
	char namebuf[QUEUE_NAME_LEN];

	/* Driver Statistics */
	- SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "dropped",
	- CTLFLAG_RD, &adapter->dropped_pkts, "Driver dropped packets");
	- SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "mbuf_defrag_failed",
	- CTLFLAG_RD, &adapter->mbuf_defrag_failed, "m_defrag() failed");
	SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "watchdog_events",
	CTLFLAG_RD, &adapter->watchdog_events, "Watchdog timeouts");
	SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq",
	CTLFLAG_RD, &adapter->link_irq, "Link MSI-X IRQ Handled");

	- for (int i = 0; i < adapter->num_queues; i++, txr++) {
	+ for (int i = 0; i < adapter->num_tx_queues; i++, tx_que++) {
	+ struct tx_ring *txr = &tx_que->txr;
	snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
	queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
	CTLFLAG_RD, NULL, "Queue Name");
	queue_list = SYSCTL_CHILDREN(queue_node);

	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
	- CTLFLAG_RD, &(adapter->queues[i].irqs), "IRQs on queue");
	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "no_tx_dma_setup",
	- CTLFLAG_RD, &(txr->no_tx_dma_setup),
	- "Driver Tx DMA failure in Tx");
	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_no_desc",
	- CTLFLAG_RD, &(txr->no_desc_avail),
	- "Not-enough-descriptors count: TX");
	+ SYSCTL_ADD_ULONG(ctx, queue_list, OID_AUTO, "tso_tx",
	+ CTLFLAG_RD, &(txr->tso_tx), "TSO Packets");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_packets",
	CTLFLAG_RD, &(txr->total_packets), "TX Packets");
	- SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "br_drops",
	- CTLFLAG_RD, &(txr->br->br_drops),
	- "Packets dropped in buf_ring");
	}

	- for (int i = 0; i < adapter->num_queues; i++, rxr++) {
	+ for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++) {
	+ struct rx_ring *rxr = &rx_que->rxr;
	snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
	queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
	CTLFLAG_RD, NULL, "Queue Name");
	queue_list = SYSCTL_CHILDREN(queue_node);

	+ SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
	+ CTLFLAG_RD, &(rx_que->irqs), "IRQs on queue");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets",
	CTLFLAG_RD, &(rxr->rx_packets), "RX packets");
	SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_bytes",
	@@ -1986,34 +1937,10 @@
	{
	device_t dev = adapter->dev;
	struct ixgbe_hw *hw = &adapter->hw;
	- struct ix_queue *que = adapter->queues;
	- struct rx_ring *rxr;
	- struct tx_ring *txr;
	- struct lro_ctrl *lro;

	device_printf(dev, "Error Byte Count = %u \n",
	IXGBE_READ_REG(hw, IXGBE_ERRBC));

	- for (int i = 0; i < adapter->num_queues; i++, que++) {
	- txr = que->txr;
	- rxr = que->rxr;
	- lro = &rxr->lro;
	- device_printf(dev, "QUE(%d) IRQs Handled: %lu\n",
	- que->msix, (long)que->irqs);
	- device_printf(dev, "RX(%d) Packets Received: %lld\n",
	- rxr->me, (long long)rxr->rx_packets);
	- device_printf(dev, "RX(%d) Bytes Received: %lu\n",
	- rxr->me, (long)rxr->rx_bytes);
	- device_printf(dev, "RX(%d) LRO Queued= %lld\n",
	- rxr->me, (long long)lro->lro_queued);
	- device_printf(dev, "RX(%d) LRO Flushed= %lld\n",
	- rxr->me, (long long)lro->lro_flushed);
	- device_printf(dev, "TX(%d) Packets Sent: %lu\n",
	- txr->me, (long)txr->total_packets);
	- device_printf(dev, "TX(%d) NO Desc Avail: %lu\n",
	- txr->me, (long)txr->no_desc_avail);
	- }
	-
	device_printf(dev, "MBX IRQ Handled: %lu\n", (long)adapter->link_irq);
	} /* ixv_print_debug_info */

	@@ -2079,365 +2006,5 @@
	/* Needs advanced context descriptor regardless of offloads req'd */
	if (adapter->feat_cap & IXGBE_FEATURE_NEEDS_CTXD)
	adapter->feat_en \|= IXGBE_FEATURE_NEEDS_CTXD;
	-
	- /* Enabled via sysctl... */
	- /* Legacy (single queue) transmit */
	- if ((adapter->feat_cap & IXGBE_FEATURE_LEGACY_TX) &&
	- ixv_enable_legacy_tx)
	- adapter->feat_en \|= IXGBE_FEATURE_LEGACY_TX;
	} /* ixv_init_device_features */

	-/************************************************************************
	- * ixv_shutdown - Shutdown entry point
	- ************************************************************************/
	-static int
	-ixv_shutdown(device_t dev)
	-{
	- struct adapter *adapter = device_get_softc(dev);
	- IXGBE_CORE_LOCK(adapter);
	- ixv_stop(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-
	- return (0);
	-} /* ixv_shutdown */
	-
	-
	-/************************************************************************
	- * ixv_ioctl - Ioctl entry point
	- *
	- * Called when the user wants to configure the interface.
	- *
	- * return 0 on success, positive on failure
	- ************************************************************************/
	-static int
	-ixv_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
	-{
	- struct adapter *adapter = ifp->if_softc;
	- struct ifreq ifr = (struct ifreq )data;
	-#if defined(INET) \|\| defined(INET6)
	- struct ifaddr ifa = (struct ifaddr )data;
	- bool avoid_reset = FALSE;
	-#endif
	- int error = 0;
	-
	- switch (command) {
	-
	- case SIOCSIFADDR:
	-#ifdef INET
	- if (ifa->ifa_addr->sa_family == AF_INET)
	- avoid_reset = TRUE;
	-#endif
	-#ifdef INET6
	- if (ifa->ifa_addr->sa_family == AF_INET6)
	- avoid_reset = TRUE;
	-#endif
	-#if defined(INET) \|\| defined(INET6)
	- /*
	- * Calling init results in link renegotiation,
	- * so we avoid doing it when possible.
	- */
	- if (avoid_reset) {
	- ifp->if_flags \|= IFF_UP;
	- if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
	- ixv_init(adapter);
	- if (!(ifp->if_flags & IFF_NOARP))
	- arp_ifinit(ifp, ifa);
	- } else
	- error = ether_ioctl(ifp, command, data);
	- break;
	-#endif
	- case SIOCSIFMTU:
	- IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
	- if (ifr->ifr_mtu > IXGBE_MAX_MTU) {
	- error = EINVAL;
	- } else {
	- IXGBE_CORE_LOCK(adapter);
	- ifp->if_mtu = ifr->ifr_mtu;
	- adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING)
	- ixv_init_locked(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	- }
	- break;
	- case SIOCSIFFLAGS:
	- IOCTL_DEBUGOUT("ioctl: SIOCSIFFLAGS (Set Interface Flags)");
	- IXGBE_CORE_LOCK(adapter);
	- if (ifp->if_flags & IFF_UP) {
	- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
	- ixv_init_locked(adapter);
	- } else
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING)
	- ixv_stop(adapter);
	- adapter->if_flags = ifp->if_flags;
	- IXGBE_CORE_UNLOCK(adapter);
	- break;
	- case SIOCADDMULTI:
	- case SIOCDELMULTI:
	- IOCTL_DEBUGOUT("ioctl: SIOC(ADD\|DEL)MULTI");
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- IXGBE_CORE_LOCK(adapter);
	- ixv_disable_intr(adapter);
	- ixv_set_multi(adapter);
	- ixv_enable_intr(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	- }
	- break;
	- case SIOCSIFMEDIA:
	- case SIOCGIFMEDIA:
	- IOCTL_DEBUGOUT("ioctl: SIOCxIFMEDIA (Get/Set Interface Media)");
	- error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
	- break;
	- case SIOCSIFCAP:
	- {
	- int mask = ifr->ifr_reqcap ^ ifp->if_capenable;
	- IOCTL_DEBUGOUT("ioctl: SIOCSIFCAP (Set Capabilities)");
	- if (mask & IFCAP_HWCSUM)
	- ifp->if_capenable ^= IFCAP_HWCSUM;
	- if (mask & IFCAP_TSO4)
	- ifp->if_capenable ^= IFCAP_TSO4;
	- if (mask & IFCAP_LRO)
	- ifp->if_capenable ^= IFCAP_LRO;
	- if (mask & IFCAP_VLAN_HWTAGGING)
	- ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- IXGBE_CORE_LOCK(adapter);
	- ixv_init_locked(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	- }
	- VLAN_CAPABILITIES(ifp);
	- break;
	- }
	-
	- default:
	- IOCTL_DEBUGOUT1("ioctl: UNKNOWN (0x%X)\n", (int)command);
	- error = ether_ioctl(ifp, command, data);
	- break;
	- }
	-
	- return (error);
	-} /* ixv_ioctl */
	-
	-/************************************************************************
	- * ixv_init
	- ************************************************************************/
	-static void
	-ixv_init(void *arg)
	-{
	- struct adapter *adapter = arg;
	-
	- IXGBE_CORE_LOCK(adapter);
	- ixv_init_locked(adapter);
	- IXGBE_CORE_UNLOCK(adapter);
	-
	- return;
	-} /* ixv_init */
	-
	-
	-/************************************************************************
	- * ixv_handle_que
	- ************************************************************************/
	-static void
	-ixv_handle_que(void *context, int pending)
	-{
	- struct ix_queue *que = context;
	- struct adapter *adapter = que->adapter;
	- struct tx_ring *txr = que->txr;
	- struct ifnet *ifp = adapter->ifp;
	- bool more;
	-
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- more = ixgbe_rxeof(que);
	- IXGBE_TX_LOCK(txr);
	- ixgbe_txeof(txr);
	- if (!ixv_ring_empty(ifp, txr->br))
	- ixv_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	- if (more) {
	- taskqueue_enqueue(que->tq, &que->que_task);
	- return;
	- }
	- }
	-
	- /* Re-enable this interrupt */
	- ixv_enable_queue(adapter, que->msix);
	-
	- return;
	-} /* ixv_handle_que */
	-
	-/************************************************************************
	- * ixv_allocate_msix - Setup MSI-X Interrupt resources and handlers
	- ************************************************************************/
	-static int
	-ixv_allocate_msix(struct adapter *adapter)
	-{
	- device_t dev = adapter->dev;
	- struct ix_queue *que = adapter->queues;
	- struct tx_ring *txr = adapter->tx_rings;
	- int error, msix_ctrl, rid, vector = 0;
	-
	- for (int i = 0; i < adapter->num_queues; i++, vector++, que++, txr++) {
	- rid = vector + 1;
	- que->res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
	- RF_SHAREABLE \| RF_ACTIVE);
	- if (que->res == NULL) {
	- device_printf(dev, "Unable to allocate bus resource: que interrupt [%d]\n",
	- vector);
	- return (ENXIO);
	- }
	- /* Set the handler function */
	- error = bus_setup_intr(dev, que->res,
	- INTR_TYPE_NET \| INTR_MPSAFE, NULL,
	- ixv_msix_que, que, &que->tag);
	- if (error) {
	- que->res = NULL;
	- device_printf(dev, "Failed to register QUE handler");
	- return (error);
	- }
	-#if __FreeBSD_version >= 800504
	- bus_describe_intr(dev, que->res, que->tag, "que %d", i);
	-#endif
	- que->msix = vector;
	- adapter->active_queues \|= (u64)(1 << que->msix);
	- /*
	- * Bind the MSI-X vector, and thus the
	- * ring to the corresponding CPU.
	- */
	- if (adapter->num_queues > 1)
	- bus_bind_intr(dev, que->res, i);
	- TASK_INIT(&txr->txq_task, 0, ixgbe_deferred_mq_start, txr);
	- TASK_INIT(&que->que_task, 0, ixv_handle_que, que);
	- que->tq = taskqueue_create_fast("ixv_que", M_NOWAIT,
	- taskqueue_thread_enqueue, &que->tq);
	- taskqueue_start_threads(&que->tq, 1, PI_NET, "%s que",
	- device_get_nameunit(adapter->dev));
	- }
	-
	- /* and Mailbox */
	- rid = vector + 1;
	- adapter->res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
	- RF_SHAREABLE \| RF_ACTIVE);
	- if (!adapter->res) {
	- device_printf(dev,
	- "Unable to allocate bus resource: MBX interrupt [%d]\n",
	- rid);
	- return (ENXIO);
	- }
	- /* Set the mbx handler function */
	- error = bus_setup_intr(dev, adapter->res, INTR_TYPE_NET \| INTR_MPSAFE,
	- NULL, ixv_msix_mbx, adapter, &adapter->tag);
	- if (error) {
	- adapter->res = NULL;
	- device_printf(dev, "Failed to register LINK handler");
	- return (error);
	- }
	-#if __FreeBSD_version >= 800504
	- bus_describe_intr(dev, adapter->res, adapter->tag, "mbx");
	-#endif
	- adapter->vector = vector;
	- /* Tasklets for Mailbox */
	- TASK_INIT(&adapter->link_task, 0, ixv_handle_link, adapter);
	- adapter->tq = taskqueue_create_fast("ixv_mbx", M_NOWAIT,
	- taskqueue_thread_enqueue, &adapter->tq);
	- taskqueue_start_threads(&adapter->tq, 1, PI_NET, "%s mbxq",
	- device_get_nameunit(adapter->dev));
	- /*
	- * Due to a broken design QEMU will fail to properly
	- * enable the guest for MSI-X unless the vectors in
	- * the table are all set up, so we must rewrite the
	- * ENABLE in the MSI-X control register again at this
	- * point to cause it to successfully initialize us.
	- */
	- if (adapter->hw.mac.type == ixgbe_mac_82599_vf) {
	- pci_find_cap(dev, PCIY_MSIX, &rid);
	- rid += PCIR_MSIX_CTRL;
	- msix_ctrl = pci_read_config(dev, rid, 2);
	- msix_ctrl \|= PCIM_MSIXCTRL_MSIX_ENABLE;
	- pci_write_config(dev, rid, msix_ctrl, 2);
	- }
	-
	- return (0);
	-} /* ixv_allocate_msix */
	-
	-/************************************************************************
	- * ixv_configure_interrupts - Setup MSI-X resources
	- *
	- * Note: The VF device MUST use MSI-X, there is no fallback.
	- ************************************************************************/
	-static int
	-ixv_configure_interrupts(struct adapter *adapter)
	-{
	- device_t dev = adapter->dev;
	- int rid, want, msgs;
	-
	- /* Must have at least 2 MSI-X vectors */
	- msgs = pci_msix_count(dev);
	- if (msgs < 2)
	- goto out;
	- rid = PCIR_BAR(3);
	- adapter->msix_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
	- RF_ACTIVE);
	- if (adapter->msix_mem == NULL) {
	- device_printf(adapter->dev, "Unable to map MSI-X table \n");
	- goto out;
	- }
	-
	- /*
	- * Want vectors for the queues,
	- * plus an additional for mailbox.
	- */
	- want = adapter->num_queues + 1;
	- if (want > msgs) {
	- want = msgs;
	- adapter->num_queues = msgs - 1;
	- } else
	- msgs = want;
	- if ((pci_alloc_msix(dev, &msgs) == 0) && (msgs == want)) {
	- device_printf(adapter->dev,
	- "Using MSI-X interrupts with %d vectors\n", want);
	- /* reflect correct sysctl value */
	- ixv_num_queues = adapter->num_queues;
	-
	- return (0);
	- }
	- /* Release in case alloc was insufficient */
	- pci_release_msi(dev);
	-out:
	- if (adapter->msix_mem != NULL) {
	- bus_release_resource(dev, SYS_RES_MEMORY, rid,
	- adapter->msix_mem);
	- adapter->msix_mem = NULL;
	- }
	- device_printf(adapter->dev, "MSI-X config error\n");
	-
	- return (ENXIO);
	-} /* ixv_configure_interrupts */
	-
	-
	-/************************************************************************
	- * ixv_handle_link - Tasklet handler for MSI-X MBX interrupts
	- *
	- * Done outside of interrupt context since the driver might sleep
	- ************************************************************************/
	-static void
	-ixv_handle_link(void *context, int pending)
	-{
	- struct adapter *adapter = context;
	-
	- adapter->hw.mac.ops.check_link(&adapter->hw, &adapter->link_speed,
	- &adapter->link_up, FALSE);
	- ixv_update_link_status(adapter);
	-} /* ixv_handle_link */
	-
	-/************************************************************************
	- * ixv_check_link - Used in the local timer to poll for link changes
	- ************************************************************************/
	-static void
	-ixv_check_link(struct adapter *adapter)
	-{
	- adapter->hw.mac.get_link_status = TRUE;
	-
	- adapter->hw.mac.ops.check_link(&adapter->hw, &adapter->link_speed,
	- &adapter->link_up, FALSE);
	- ixv_update_link_status(adapter);
	-} /* ixv_check_link */
	-
	Index: sys/dev/ixgbe/if_sriov.c
	===================================================================
	--- sys/dev/ixgbe/if_sriov.c
	+++ sys/dev/ixgbe/if_sriov.c
	@@ -33,6 +33,7 @@
	/$FreeBSD$/

	#include "ixgbe.h"
	+#include "ixgbe_sriov.h"

	#ifdef PCI_IOV

	@@ -80,10 +81,14 @@
	int i;
	int index;

	- for (i = 0; i < adapter->num_queues; i++) {
	+ for (i = 0; i < adapter->num_rx_queues; i++) {
	index = ixgbe_vf_que_index(adapter->iov_mode, adapter->pool, i);
	- adapter->rx_rings[i].me = index;
	- adapter->tx_rings[i].me = index;
	+ adapter->rx_queues[i].rxr.me = index;
	+ }
	+
	+ for (i = 0; i < adapter->num_tx_queues; i++) {
	+ index = ixgbe_vf_que_index(adapter->iov_mode, adapter->pool, i);
	+ adapter->tx_queues[i].txr.me = index;
	}
	}

	@@ -233,7 +238,7 @@

	if (tag == 0) {
	/* Accept non-vlan tagged traffic. */
	- //vmolr \|= IXGBE_VMOLR_AUPE;
	+ vmolr \|= IXGBE_VMOLR_AUPE;

	/* Allow VM to tag outgoing traffic; no default tag. */
	vmvir = 0;
	@@ -269,7 +274,7 @@
	* frames on either the PF or the VF.
	*/
	if (adapter->max_frame_size > ETHER_MAX_LEN \|\|
	- vf->max_frame_size > ETHER_MAX_LEN)
	+ vf->maximum_frame_size > ETHER_MAX_LEN)
	return (FALSE);

	return (TRUE);
	@@ -281,7 +286,7 @@
	* 1.1 or later VF versions always work if they aren't using
	* jumbo frames.
	*/
	- if (vf->max_frame_size <= ETHER_MAX_LEN)
	+ if (vf->maximum_frame_size <= ETHER_MAX_LEN)
	return (TRUE);

	/*
	@@ -292,7 +297,6 @@
	return (TRUE);

	return (FALSE);
	-
	}
	} /* ixgbe_vf_frame_size_compatible */

	@@ -451,7 +455,7 @@
	}

	/* It is illegal to enable vlan tag 0. */
	- if (tag == 0 && enable != 0){
	+ if (tag == 0 && enable != 0) {
	ixgbe_send_vf_nack(adapter, vf, msg[0]);
	return;
	}
	@@ -484,8 +488,8 @@
	return;
	}

	- vf->max_frame_size = vf_max_size;
	- ixgbe_update_max_frame(adapter, vf->max_frame_size);
	+ vf->maximum_frame_size = vf_max_size;
	+ ixgbe_update_max_frame(adapter, vf->maximum_frame_size);

	/*
	* We might have to disable reception to this VF if the frame size is
	@@ -565,8 +569,12 @@


	static void
	-ixgbe_process_vf_msg(struct adapter adapter, struct ixgbe_vf vf)
	+ixgbe_process_vf_msg(if_ctx_t ctx, struct ixgbe_vf *vf)
	{
	+ struct adapter *adapter = iflib_get_softc(ctx);
	+#ifdef KTR
	+ struct ifnet *ifp = iflib_get_ifp(ctx);
	+#endif
	struct ixgbe_hw *hw;
	uint32_t msg[IXGBE_VFMAILBOX_SIZE];
	int error;
	@@ -578,8 +586,8 @@
	if (error != 0)
	return;

	- CTR3(KTR_MALLOC, "%s: received msg %x from %d",
	- adapter->ifp->if_xname, msg[0], vf->pool);
	+ CTR3(KTR_MALLOC, "%s: received msg %x from %d", ifp->if_xname,
	+ msg[0], vf->pool);
	if (msg[0] == IXGBE_VF_RESET) {
	ixgbe_vf_reset_msg(adapter, vf, msg);
	return;
	@@ -620,17 +628,16 @@

	/* Tasklet for handling VF -> PF mailbox messages */
	void
	-ixgbe_handle_mbx(void *context, int pending)
	+ixgbe_handle_mbx(void *context)
	{
	- struct adapter *adapter;
	+ if_ctx_t ctx = context;
	+ struct adapter *adapter = iflib_get_softc(ctx);
	struct ixgbe_hw *hw;
	struct ixgbe_vf *vf;
	int i;

	- adapter = context;
	hw = &adapter->hw;

	- IXGBE_CORE_LOCK(adapter);
	for (i = 0; i < adapter->num_vfs; i++) {
	vf = &adapter->vfs[i];

	@@ -639,22 +646,21 @@
	ixgbe_process_vf_reset(adapter, vf);

	if (hw->mbx.ops.check_for_msg(hw, vf->pool) == 0)
	- ixgbe_process_vf_msg(adapter, vf);
	+ ixgbe_process_vf_msg(ctx, vf);

	if (hw->mbx.ops.check_for_ack(hw, vf->pool) == 0)
	ixgbe_process_vf_ack(adapter, vf);
	}
	}
	- IXGBE_CORE_UNLOCK(adapter);
	} /* ixgbe_handle_mbx */

	int
	-ixgbe_init_iov(device_t dev, u16 num_vfs, const nvlist_t *config)
	+ixgbe_if_iov_init(if_ctx_t ctx, u16 num_vfs, const nvlist_t *config)
	{
	struct adapter *adapter;
	int retval = 0;

	- adapter = device_get_softc(dev);
	+ adapter = iflib_get_softc(ctx);
	adapter->iov_mode = IXGBE_NO_VM;

	if (num_vfs == 0) {
	@@ -682,45 +688,38 @@
	goto err_init_iov;
	}

	- IXGBE_CORE_LOCK(adapter);
	-
	adapter->vfs = malloc(sizeof(adapter->vfs) num_vfs, M_IXGBE_SRIOV,
	M_NOWAIT \| M_ZERO);

	if (adapter->vfs == NULL) {
	retval = ENOMEM;
	- IXGBE_CORE_UNLOCK(adapter);
	goto err_init_iov;
	}

	adapter->num_vfs = num_vfs;
	- adapter->init_locked(adapter);
	+ ixgbe_if_init(adapter->ctx);
	adapter->feat_en \|= IXGBE_FEATURE_SRIOV;

	- IXGBE_CORE_UNLOCK(adapter);
	-
	- return retval;
	+ return (retval);

	err_init_iov:
	adapter->num_vfs = 0;
	adapter->pool = 0;
	adapter->iov_mode = IXGBE_NO_VM;

	- return retval;
	-} /* ixgbe_init_iov */
	+ return (retval);
	+} /* ixgbe_if_iov_init */

	void
	-ixgbe_uninit_iov(device_t dev)
	+ixgbe_if_iov_uninit(if_ctx_t ctx)
	{
	struct ixgbe_hw *hw;
	struct adapter *adapter;
	uint32_t pf_reg, vf_reg;

	- adapter = device_get_softc(dev);
	+ adapter = iflib_get_softc(ctx);
	hw = &adapter->hw;

	- IXGBE_CORE_LOCK(adapter);
	-
	/* Enable rx/tx for the PF and disable it for all VFs. */
	pf_reg = IXGBE_VF_INDEX(adapter->pool);
	IXGBE_WRITE_REG(hw, IXGBE_VFRE(pf_reg), IXGBE_VF_BIT(adapter->pool));
	@@ -739,9 +738,7 @@
	adapter->vfs = NULL;
	adapter->num_vfs = 0;
	adapter->feat_en &= ~IXGBE_FEATURE_SRIOV;
	-
	- IXGBE_CORE_UNLOCK(adapter);
	-} /* ixgbe_uninit_iov */
	+} /* ixgbe_if_iov_uninit */

	static void
	ixgbe_init_vf(struct adapter adapter, struct ixgbe_vf vf)
	@@ -749,8 +746,6 @@
	struct ixgbe_hw *hw;
	uint32_t vf_index, pfmbimr;

	- IXGBE_CORE_LOCK_ASSERT(adapter);
	-
	hw = &adapter->hw;

	if (!(vf->flags & IXGBE_VF_ACTIVE))
	@@ -786,8 +781,6 @@
	if (adapter->iov_mode == IXGBE_NO_VM)
	return;

	- IXGBE_CORE_LOCK_ASSERT(adapter);
	-
	/* RMW appropriate registers based on IOV mode */
	/* Read... */
	mrqc = IXGBE_READ_REG(hw, IXGBE_MRQC);
	@@ -844,36 +837,33 @@
	{
	struct ixgbe_vf *vf;

	- IXGBE_CORE_LOCK_ASSERT(adapter);
	-
	for (int i = 0; i < adapter->num_vfs; i++) {
	vf = &adapter->vfs[i];
	if (vf->flags & IXGBE_VF_ACTIVE)
	- ixgbe_update_max_frame(adapter, vf->max_frame_size);
	+ ixgbe_update_max_frame(adapter, vf->maximum_frame_size);
	}
	} /* ixgbe_recalculate_max_frame */

	int
	-ixgbe_add_vf(device_t dev, u16 vfnum, const nvlist_t *config)
	+ixgbe_if_iov_vf_add(if_ctx_t ctx, u16 vfnum, const nvlist_t *config)
	{
	struct adapter *adapter;
	struct ixgbe_vf *vf;
	const void *mac;

	- adapter = device_get_softc(dev);
	+ adapter = iflib_get_softc(ctx);

	KASSERT(vfnum < adapter->num_vfs, ("VF index %d is out of range %d",
	vfnum, adapter->num_vfs));

	- IXGBE_CORE_LOCK(adapter);
	vf = &adapter->vfs[vfnum];
	vf->pool= vfnum;

	/* RAR[0] is used by the PF so use vfnum + 1 for VF RAR. */
	vf->rar_index = vfnum + 1;
	vf->default_vlan = 0;
	- vf->max_frame_size = ETHER_MAX_LEN;
	- ixgbe_update_max_frame(adapter, vf->max_frame_size);
	+ vf->maximum_frame_size = ETHER_MAX_LEN;
	+ ixgbe_update_max_frame(adapter, vf->maximum_frame_size);

	if (nvlist_exists_binary(config, "mac-addr")) {
	mac = nvlist_get_binary(config, "mac-addr", NULL);
	@@ -890,25 +880,16 @@
	vf->flags \|= IXGBE_VF_ACTIVE;

	ixgbe_init_vf(adapter, vf);
	- IXGBE_CORE_UNLOCK(adapter);

	return (0);
	-} /* ixgbe_add_vf */
	+} /* ixgbe_if_iov_vf_add */

	#else

	void
	-ixgbe_handle_mbx(void *context, int pending)
	+ixgbe_handle_mbx(void *context)
	{
	- UNREFERENCED_2PARAMETER(context, pending);
	+ UNREFERENCED_PARAMETER(context);
	} /* ixgbe_handle_mbx */

	-inline int
	-ixgbe_vf_que_index(int mode, int vfnum, int num)
	-{
	- UNREFERENCED_2PARAMETER(mode, vfnum);
	-
	- return num;
	-} /* ixgbe_vf_que_index */
	-
	#endif
	Index: sys/dev/ixgbe/ix_txrx.c
	===================================================================
	--- sys/dev/ixgbe/ix_txrx.c
	+++ sys/dev/ixgbe/ix_txrx.c
	@@ -41,1878 +41,436 @@

	#include "ixgbe.h"

	-/*
	- * HW RSC control:
	- * this feature only works with
	- * IPv4, and only on 82599 and later.
	- * Also this will cause IP forwarding to
	- * fail and that can't be controlled by
	- * the stack as LRO can. For all these
	- * reasons I've deemed it best to leave
	- * this off and not bother with a tuneable
	- * interface, this would need to be compiled
	- * to enable.
	- */
	-static bool ixgbe_rsc_enable = FALSE;
	-
	-/*
	- * For Flow Director: this is the
	- * number of TX packets we sample
	- * for the filter pool, this means
	- * every 20th packet will be probed.
	- *
	- * This feature can be disabled by
	- * setting this to 0.
	- */
	-static int atr_sample_rate = 20;
	-
	-/************************************************************************
	- * Local Function prototypes
	- ************************************************************************/
	-static void ixgbe_setup_transmit_ring(struct tx_ring *);
	-static void ixgbe_free_transmit_buffers(struct tx_ring *);
	-static int ixgbe_setup_receive_ring(struct rx_ring *);
	-static void ixgbe_free_receive_buffers(struct rx_ring *);
	-static void ixgbe_rx_checksum(u32, struct mbuf *, u32);
	-static void ixgbe_refresh_mbufs(struct rx_ring *, int);
	-static int ixgbe_xmit(struct tx_ring , struct mbuf *);
	-static int ixgbe_tx_ctx_setup(struct tx_ring *,
	- struct mbuf , u32 , u32 *);
	-static int ixgbe_tso_setup(struct tx_ring *,
	- struct mbuf , u32 , u32 *);
	-static __inline void ixgbe_rx_discard(struct rx_ring *, int);
	-static __inline void ixgbe_rx_input(struct rx_ring , struct ifnet ,
	- struct mbuf *, u32);
	-static int ixgbe_dma_malloc(struct adapter *, bus_size_t,
	- struct ixgbe_dma_alloc *, int);
	-static void ixgbe_dma_free(struct adapter , struct ixgbe_dma_alloc );
	-
	-/************************************************************************
	- * ixgbe_legacy_start_locked - Transmit entry point
	- *
	- * Called by the stack to initiate a transmit.
	- * The driver will remain in this routine as long as there are
	- * packets to transmit and transmit resources are available.
	- * In case resources are not available, the stack is notified
	- * and the packet is requeued.
	- ************************************************************************/
	-int
	-ixgbe_legacy_start_locked(struct ifnet ifp, struct tx_ring txr)
	-{
	- struct mbuf *m_head;
	- struct adapter *adapter = txr->adapter;
	-
	- IXGBE_TX_LOCK_ASSERT(txr);
	-
	- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
	- return (ENETDOWN);
	- if (!adapter->link_active)
	- return (ENETDOWN);
	-
	- while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
	- if (txr->tx_avail <= IXGBE_QUEUE_MIN_FREE)
	- break;
	-
	- IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
	- if (m_head == NULL)
	- break;
	-
	- if (ixgbe_xmit(txr, &m_head)) {
	- if (m_head != NULL)
	- IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
	- break;
	- }
	- /* Send a copy of the frame to the BPF listener */
	- ETHER_BPF_MTAP(ifp, m_head);
	- }
	-
	- return IXGBE_SUCCESS;
	-} /* ixgbe_legacy_start_locked */

	/************************************************************************
	- * ixgbe_legacy_start
	- *
	- * Called by the stack, this always uses the first tx ring,
	- * and should not be used with multiqueue tx enabled.
	+ * Local Function prototypes
	************************************************************************/
	-void
	-ixgbe_legacy_start(struct ifnet *ifp)
	-{
	- struct adapter *adapter = ifp->if_softc;
	- struct tx_ring *txr = adapter->tx_rings;
	-
	- if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
	- IXGBE_TX_LOCK(txr);
	- ixgbe_legacy_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	- }
	-} /* ixgbe_legacy_start */
	-
	-/************************************************************************
	- * ixgbe_mq_start - Multiqueue Transmit Entry Point
	- *
	- * (if_transmit function)
	- ************************************************************************/
	-int
	-ixgbe_mq_start(struct ifnet ifp, struct mbuf m)
	-{
	- struct adapter *adapter = ifp->if_softc;
	- struct ix_queue *que;
	- struct tx_ring *txr;
	- int i, err = 0;
	- uint32_t bucket_id;
	-
	- /*
	- * When doing RSS, map it to the same outbound queue
	- * as the incoming flow would be mapped to.
	- *
	- * If everything is setup correctly, it should be the
	- * same bucket that the current CPU we're on is.
	- */
	- if (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) {
	- if ((adapter->feat_en & IXGBE_FEATURE_RSS) &&
	- (rss_hash2bucket(m->m_pkthdr.flowid, M_HASHTYPE_GET(m),
	- &bucket_id) == 0)) {
	- i = bucket_id % adapter->num_queues;
	-#ifdef IXGBE_DEBUG
	- if (bucket_id > adapter->num_queues)
	- if_printf(ifp,
	- "bucket_id (%d) > num_queues (%d)\n",
	- bucket_id, adapter->num_queues);
	-#endif
	- } else
	- i = m->m_pkthdr.flowid % adapter->num_queues;
	- } else
	- i = curcpu % adapter->num_queues;
	-
	- /* Check for a hung queue and pick alternative */
	- if (((1 << i) & adapter->active_queues) == 0)
	- i = ffsl(adapter->active_queues);
	+static int ixgbe_isc_txd_encap(void *arg, if_pkt_info_t pi);
	+static void ixgbe_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);
	+static int ixgbe_isc_txd_credits_update(void *arg, uint16_t txqid, bool clear);

	- txr = &adapter->tx_rings[i];
	- que = &adapter->queues[i];
	-
	- err = drbr_enqueue(ifp, txr->br, m);
	- if (err)
	- return (err);
	- if (IXGBE_TX_TRYLOCK(txr)) {
	- ixgbe_mq_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	- } else
	- taskqueue_enqueue(que->tq, &txr->txq_task);
	-
	- return (0);
	-} /* ixgbe_mq_start */
	-
	-/************************************************************************
	- * ixgbe_mq_start_locked
	- ************************************************************************/
	-int
	-ixgbe_mq_start_locked(struct ifnet ifp, struct tx_ring txr)
	-{
	- struct mbuf *next;
	- int enqueued = 0, err = 0;
	-
	- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
	- return (ENETDOWN);
	- if (txr->adapter->link_active == 0)
	- return (ENETDOWN);
	-
	- /* Process the queue */
	-#if __FreeBSD_version < 901504
	- next = drbr_dequeue(ifp, txr->br);
	- while (next != NULL) {
	- if ((err = ixgbe_xmit(txr, &next)) != 0) {
	- if (next != NULL)
	- err = drbr_enqueue(ifp, txr->br, next);
	-#else
	- while ((next = drbr_peek(ifp, txr->br)) != NULL) {
	- err = ixgbe_xmit(txr, &next);
	- if (err != 0) {
	- if (next == NULL)
	- drbr_advance(ifp, txr->br);
	- else
	- drbr_putback(ifp, txr->br, next);
	-#endif
	- break;
	- }
	-#if __FreeBSD_version >= 901504
	- drbr_advance(ifp, txr->br);
	-#endif
	- enqueued++;
	-#if __FreeBSD_version >= 1100036
	- /*
	- * Since we're looking at the tx ring, we can check
	- * to see if we're a VF by examing our tail register
	- * address.
	- */
	- if ((txr->adapter->feat_en & IXGBE_FEATURE_VF) &&
	- (next->m_flags & M_MCAST))
	- if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
	-#endif
	- /* Send a copy of the frame to the BPF listener */
	- ETHER_BPF_MTAP(ifp, next);
	- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
	- break;
	-#if __FreeBSD_version < 901504
	- next = drbr_dequeue(ifp, txr->br);
	-#endif
	- }
	+static void ixgbe_isc_rxd_refill(void *arg, if_rxd_update_t iru);
	+static void ixgbe_isc_rxd_flush(void *arg, uint16_t qsidx, uint8_t flidx __unused, qidx_t pidx);
	+static int ixgbe_isc_rxd_available(void *arg, uint16_t qsidx, qidx_t pidx,
	+ qidx_t budget);
	+static int ixgbe_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri);

	- if (txr->tx_avail < IXGBE_TX_CLEANUP_THRESHOLD(txr->adapter))
	- ixgbe_txeof(txr);
	+static void ixgbe_rx_checksum(u32 staterr, if_rxd_info_t ri, u32 ptype);
	+static int ixgbe_tx_ctx_setup(struct ixgbe_adv_tx_context_desc *, if_pkt_info_t);

	- return (err);
	-} /* ixgbe_mq_start_locked */
	+extern void ixgbe_if_enable_intr(if_ctx_t ctx);
	+static int ixgbe_determine_rsstype(u16 pkt_info);

	-/************************************************************************
	- * ixgbe_deferred_mq_start
	- *
	- * Called from a taskqueue to drain queued transmit packets.
	- ************************************************************************/
	-void
	-ixgbe_deferred_mq_start(void *arg, int pending)
	-{
	- struct tx_ring *txr = arg;
	- struct adapter *adapter = txr->adapter;
	- struct ifnet *ifp = adapter->ifp;
	+struct if_txrx ixgbe_txrx = {
	+ ixgbe_isc_txd_encap,
	+ ixgbe_isc_txd_flush,
	+ ixgbe_isc_txd_credits_update,
	+ ixgbe_isc_rxd_available,
	+ ixgbe_isc_rxd_pkt_get,
	+ ixgbe_isc_rxd_refill,
	+ ixgbe_isc_rxd_flush,
	+ NULL
	+};

	- IXGBE_TX_LOCK(txr);
	- if (!drbr_empty(ifp, txr->br))
	- ixgbe_mq_start_locked(ifp, txr);
	- IXGBE_TX_UNLOCK(txr);
	-} /* ixgbe_deferred_mq_start */
	-
	-/************************************************************************
	- * ixgbe_qflush - Flush all ring buffers
	- ************************************************************************/
	-void
	-ixgbe_qflush(struct ifnet *ifp)
	-{
	- struct adapter *adapter = ifp->if_softc;
	- struct tx_ring *txr = adapter->tx_rings;
	- struct mbuf *m;
	-
	- for (int i = 0; i < adapter->num_queues; i++, txr++) {
	- IXGBE_TX_LOCK(txr);
	- while ((m = buf_ring_dequeue_sc(txr->br)) != NULL)
	- m_freem(m);
	- IXGBE_TX_UNLOCK(txr);
	- }
	- if_qflush(ifp);
	-} /* ixgbe_qflush */
	-
	-
	-/************************************************************************
	- * ixgbe_xmit
	- *
	- * Maps the mbufs to tx descriptors, allowing the
	- * TX engine to transmit the packets.
	- *
	- * Return 0 on success, positive on failure
	- ************************************************************************/
	-static int
	-ixgbe_xmit(struct tx_ring txr, struct mbuf *m_headp)
	-{
	- struct adapter *adapter = txr->adapter;
	- struct ixgbe_tx_buf *txbuf;
	- union ixgbe_adv_tx_desc *txd = NULL;
	- struct mbuf *m_head;
	- int i, j, error, nsegs;
	- int first;
	- u32 olinfo_status = 0, cmd_type_len;
	- bool remap = TRUE;
	- bus_dma_segment_t segs[adapter->num_segs];
	- bus_dmamap_t map;
	-
	- m_head = *m_headp;
	-
	- /* Basic descriptor defines */
	- cmd_type_len = (IXGBE_ADVTXD_DTYP_DATA \|
	- IXGBE_ADVTXD_DCMD_IFCS \| IXGBE_ADVTXD_DCMD_DEXT);
	-
	- if (m_head->m_flags & M_VLANTAG)
	- cmd_type_len \|= IXGBE_ADVTXD_DCMD_VLE;
	-
	- /*
	- * Important to capture the first descriptor
	- * used because it will contain the index of
	- * the one we tell the hardware to report back
	- */
	- first = txr->next_avail_desc;
	- txbuf = &txr->tx_buffers[first];
	- map = txbuf->map;
	-
	- /*
	- * Map the packet for DMA.
	- */
	-retry:
	- error = bus_dmamap_load_mbuf_sg(txr->txtag, map, *m_headp, segs,
	- &nsegs, BUS_DMA_NOWAIT);
	-
	- if (__predict_false(error)) {
	- struct mbuf *m;
	-
	- switch (error) {
	- case EFBIG:
	- /* Try it again? - one try */
	- if (remap == TRUE) {
	- remap = FALSE;
	- /*
	- * XXX: m_defrag will choke on
	- * non-MCLBYTES-sized clusters
	- */
	- m = m_defrag(*m_headp, M_NOWAIT);
	- if (m == NULL) {
	- adapter->mbuf_defrag_failed++;
	- m_freem(*m_headp);
	- *m_headp = NULL;
	- return (ENOBUFS);
	- }
	- *m_headp = m;
	- goto retry;
	- } else
	- return (error);
	- case ENOMEM:
	- txr->no_tx_dma_setup++;
	- return (error);
	- default:
	- txr->no_tx_dma_setup++;
	- m_freem(*m_headp);
	- *m_headp = NULL;
	- return (error);
	- }
	- }
	-
	- /* Make certain there are enough descriptors */
	- if (txr->tx_avail < (nsegs + 2)) {
	- txr->no_desc_avail++;
	- bus_dmamap_unload(txr->txtag, map);
	- return (ENOBUFS);
	- }
	- m_head = *m_headp;
	-
	- /*
	- * Set up the appropriate offload context
	- * this will consume the first descriptor
	- */
	- error = ixgbe_tx_ctx_setup(txr, m_head, &cmd_type_len, &olinfo_status);
	- if (__predict_false(error)) {
	- if (error == ENOBUFS)
	- *m_headp = NULL;
	- return (error);
	- }
	-
	- /* Do the flow director magic */
	- if ((adapter->feat_en & IXGBE_FEATURE_FDIR) &&
	- (txr->atr_sample) && (!adapter->fdir_reinit)) {
	- ++txr->atr_count;
	- if (txr->atr_count >= atr_sample_rate) {
	- ixgbe_atr(txr, m_head);
	- txr->atr_count = 0;
	- }
	- }
	-
	- olinfo_status \|= IXGBE_ADVTXD_CC;
	- i = txr->next_avail_desc;
	- for (j = 0; j < nsegs; j++) {
	- bus_size_t seglen;
	- bus_addr_t segaddr;
	-
	- txbuf = &txr->tx_buffers[i];
	- txd = &txr->tx_base[i];
	- seglen = segs[j].ds_len;
	- segaddr = htole64(segs[j].ds_addr);
	-
	- txd->read.buffer_addr = segaddr;
	- txd->read.cmd_type_len = htole32(txr->txd_cmd \|
	- cmd_type_len \| seglen);
	- txd->read.olinfo_status = htole32(olinfo_status);
	-
	- if (++i == txr->num_desc)
	- i = 0;
	- }
	-
	- txd->read.cmd_type_len \|= htole32(IXGBE_TXD_CMD_EOP \| IXGBE_TXD_CMD_RS);
	- txr->tx_avail -= nsegs;
	- txr->next_avail_desc = i;
	-
	- txbuf->m_head = m_head;
	- /*
	- * Here we swap the map so the last descriptor,
	- * which gets the completion interrupt has the
	- * real map, and the first descriptor gets the
	- * unused map from this descriptor.
	- */
	- txr->tx_buffers[first].map = txbuf->map;
	- txbuf->map = map;
	- bus_dmamap_sync(txr->txtag, map, BUS_DMASYNC_PREWRITE);
	-
	- /* Set the EOP descriptor that will be marked done */
	- txbuf = &txr->tx_buffers[first];
	- txbuf->eop = txd;
	-
	- bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
	- BUS_DMASYNC_PREREAD \| BUS_DMASYNC_PREWRITE);
	- /*
	- * Advance the Transmit Descriptor Tail (Tdt), this tells the
	- * hardware that this frame is available to transmit.
	- */
	- ++txr->total_packets;
	- IXGBE_WRITE_REG(&adapter->hw, txr->tail, i);
	-
	- /* Mark queue as having work */
	- if (txr->busy == 0)
	- txr->busy = 1;
	-
	- return (0);
	-} /* ixgbe_xmit */
	-
	-
	-/************************************************************************
	- * ixgbe_allocate_transmit_buffers
	- *
	- * Allocate memory for tx_buffer structures. The tx_buffer stores all
	- * the information needed to transmit a packet on the wire. This is
	- * called only once at attach, setup is done every reset.
	- ************************************************************************/
	-static int
	-ixgbe_allocate_transmit_buffers(struct tx_ring *txr)
	-{
	- struct adapter *adapter = txr->adapter;
	- device_t dev = adapter->dev;
	- struct ixgbe_tx_buf *txbuf;
	- int error, i;
	-
	- /*
	- * Setup DMA descriptor areas.
	- */
	- error = bus_dma_tag_create(
	- /* parent */ bus_get_dma_tag(adapter->dev),
	- /* alignment */ 1,
	- /* bounds */ 0,
	- /* lowaddr */ BUS_SPACE_MAXADDR,
	- /* highaddr */ BUS_SPACE_MAXADDR,
	- /* filter */ NULL,
	- /* filterarg */ NULL,
	- /* maxsize */ IXGBE_TSO_SIZE,
	- /* nsegments */ adapter->num_segs,
	- /* maxsegsize */ PAGE_SIZE,
	- /* flags */ 0,
	- /* lockfunc */ NULL,
	- /* lockfuncarg */ NULL,
	- &txr->txtag);
	- if (error != 0) {
	- device_printf(dev, "Unable to allocate TX DMA tag\n");
	- goto fail;
	- }
	-
	- txr->tx_buffers =
	- (struct ixgbe_tx_buf )malloc(sizeof(struct ixgbe_tx_buf)
	- adapter->num_tx_desc, M_DEVBUF, M_NOWAIT \| M_ZERO);
	- if (txr->tx_buffers == NULL) {
	- device_printf(dev, "Unable to allocate tx_buffer memory\n");
	- error = ENOMEM;
	- goto fail;
	- }
	-
	- /* Create the descriptor buffer dma maps */
	- txbuf = txr->tx_buffers;
	- for (i = 0; i < adapter->num_tx_desc; i++, txbuf++) {
	- error = bus_dmamap_create(txr->txtag, 0, &txbuf->map);
	- if (error != 0) {
	- device_printf(dev, "Unable to create TX DMA map\n");
	- goto fail;
	- }
	- }
	-
	- return 0;
	-fail:
	- /* We free all, it handles case where we are in the middle */
	- ixgbe_free_transmit_structures(adapter);
	-
	- return (error);
	-} /* ixgbe_allocate_transmit_buffers */
	-
	-/************************************************************************
	- * ixgbe_setup_transmit_ring - Initialize a transmit ring.
	- ************************************************************************/
	-static void
	-ixgbe_setup_transmit_ring(struct tx_ring *txr)
	-{
	- struct adapter *adapter = txr->adapter;
	- struct ixgbe_tx_buf *txbuf;
	-#ifdef DEV_NETMAP
	- struct netmap_adapter *na = NA(adapter->ifp);
	- struct netmap_slot *slot;
	-#endif /* DEV_NETMAP */
	-
	- /* Clear the old ring contents */
	- IXGBE_TX_LOCK(txr);
	-
	-#ifdef DEV_NETMAP
	- if (adapter->feat_en & IXGBE_FEATURE_NETMAP) {
	- /*
	- * (under lock): if in netmap mode, do some consistency
	- * checks and set slot to entry 0 of the netmap ring.
	- */
	- slot = netmap_reset(na, NR_TX, txr->me, 0);
	- }
	-#endif /* DEV_NETMAP */
	-
	- bzero((void *)txr->tx_base,
	- (sizeof(union ixgbe_adv_tx_desc)) * adapter->num_tx_desc);
	- /* Reset indices */
	- txr->next_avail_desc = 0;
	- txr->next_to_clean = 0;
	-
	- /* Free any existing tx buffers. */
	- txbuf = txr->tx_buffers;
	- for (int i = 0; i < txr->num_desc; i++, txbuf++) {
	- if (txbuf->m_head != NULL) {
	- bus_dmamap_sync(txr->txtag, txbuf->map,
	- BUS_DMASYNC_POSTWRITE);
	- bus_dmamap_unload(txr->txtag, txbuf->map);
	- m_freem(txbuf->m_head);
	- txbuf->m_head = NULL;
	- }
	-
	-#ifdef DEV_NETMAP
	- /*
	- * In netmap mode, set the map for the packet buffer.
	- * NOTE: Some drivers (not this one) also need to set
	- * the physical buffer address in the NIC ring.
	- * Slots in the netmap ring (indexed by "si") are
	- * kring->nkr_hwofs positions "ahead" wrt the
	- * corresponding slot in the NIC ring. In some drivers
	- * (not here) nkr_hwofs can be negative. Function
	- * netmap_idx_n2k() handles wraparounds properly.
	- */
	- if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && slot) {
	- int si = netmap_idx_n2k(&na->tx_rings[txr->me], i);
	- netmap_load_map(na, txr->txtag,
	- txbuf->map, NMB(na, slot + si));
	- }
	-#endif /* DEV_NETMAP */
	-
	- /* Clear the EOP descriptor pointer */
	- txbuf->eop = NULL;
	- }
	-
	- /* Set the rate at which we sample packets */
	- if (adapter->feat_en & IXGBE_FEATURE_FDIR)
	- txr->atr_sample = atr_sample_rate;
	-
	- /* Set number of descriptors available */
	- txr->tx_avail = adapter->num_tx_desc;
	-
	- bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
	- BUS_DMASYNC_PREREAD \| BUS_DMASYNC_PREWRITE);
	- IXGBE_TX_UNLOCK(txr);
	-} /* ixgbe_setup_transmit_ring */
	-
	-/************************************************************************
	- * ixgbe_setup_transmit_structures - Initialize all transmit rings.
	- ************************************************************************/
	-int
	-ixgbe_setup_transmit_structures(struct adapter *adapter)
	-{
	- struct tx_ring *txr = adapter->tx_rings;
	-
	- for (int i = 0; i < adapter->num_queues; i++, txr++)
	- ixgbe_setup_transmit_ring(txr);
	-
	- return (0);
	-} /* ixgbe_setup_transmit_structures */
	-
	-/************************************************************************
	- * ixgbe_free_transmit_structures - Free all transmit rings.
	- ************************************************************************/
	-void
	-ixgbe_free_transmit_structures(struct adapter *adapter)
	-{
	- struct tx_ring *txr = adapter->tx_rings;
	-
	- for (int i = 0; i < adapter->num_queues; i++, txr++) {
	- IXGBE_TX_LOCK(txr);
	- ixgbe_free_transmit_buffers(txr);
	- ixgbe_dma_free(adapter, &txr->txdma);
	- IXGBE_TX_UNLOCK(txr);
	- IXGBE_TX_LOCK_DESTROY(txr);
	- }
	- free(adapter->tx_rings, M_DEVBUF);
	-} /* ixgbe_free_transmit_structures */
	-
	-/************************************************************************
	- * ixgbe_free_transmit_buffers
	- *
	- * Free transmit ring related data structures.
	- ************************************************************************/
	-static void
	-ixgbe_free_transmit_buffers(struct tx_ring *txr)
	-{
	- struct adapter *adapter = txr->adapter;
	- struct ixgbe_tx_buf *tx_buffer;
	- int i;
	-
	- INIT_DEBUGOUT("ixgbe_free_transmit_ring: begin");
	-
	- if (txr->tx_buffers == NULL)
	- return;
	-
	- tx_buffer = txr->tx_buffers;
	- for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
	- if (tx_buffer->m_head != NULL) {
	- bus_dmamap_sync(txr->txtag, tx_buffer->map,
	- BUS_DMASYNC_POSTWRITE);
	- bus_dmamap_unload(txr->txtag, tx_buffer->map);
	- m_freem(tx_buffer->m_head);
	- tx_buffer->m_head = NULL;
	- if (tx_buffer->map != NULL) {
	- bus_dmamap_destroy(txr->txtag, tx_buffer->map);
	- tx_buffer->map = NULL;
	- }
	- } else if (tx_buffer->map != NULL) {
	- bus_dmamap_unload(txr->txtag, tx_buffer->map);
	- bus_dmamap_destroy(txr->txtag, tx_buffer->map);
	- tx_buffer->map = NULL;
	- }
	- }
	- if (txr->br != NULL)
	- buf_ring_free(txr->br, M_DEVBUF);
	- if (txr->tx_buffers != NULL) {
	- free(txr->tx_buffers, M_DEVBUF);
	- txr->tx_buffers = NULL;
	- }
	- if (txr->txtag != NULL) {
	- bus_dma_tag_destroy(txr->txtag);
	- txr->txtag = NULL;
	- }
	-} /* ixgbe_free_transmit_buffers */
	+extern if_shared_ctx_t ixgbe_sctx;

	/************************************************************************
	* ixgbe_tx_ctx_setup
	*
	* Advanced Context Descriptor setup for VLAN, CSUM or TSO
	+ *
	************************************************************************/
	static int
	-ixgbe_tx_ctx_setup(struct tx_ring txr, struct mbuf mp,
	- u32 cmd_type_len, u32 olinfo_status)
	+ixgbe_tx_ctx_setup(struct ixgbe_adv_tx_context_desc *TXD, if_pkt_info_t pi)
	{
	- struct ixgbe_adv_tx_context_desc *TXD;
	- struct ether_vlan_header *eh;
	-#ifdef INET
	- struct ip *ip;
	-#endif
	-#ifdef INET6
	- struct ip6_hdr *ip6;
	-#endif
	- int ehdrlen, ip_hlen = 0;
	- int offload = TRUE;
	- int ctxd = txr->next_avail_desc;
	- u32 vlan_macip_lens = 0;
	- u32 type_tucmd_mlhl = 0;
	- u16 vtag = 0;
	- u16 etype;
	- u8 ipproto = 0;
	- caddr_t l3d;
	-
	-
	- /* First check if TSO is to be used */
	- if (mp->m_pkthdr.csum_flags & (CSUM_IP_TSO \| CSUM_IP6_TSO))
	- return (ixgbe_tso_setup(txr, mp, cmd_type_len, olinfo_status));
	-
	- if ((mp->m_pkthdr.csum_flags & CSUM_OFFLOAD) == 0)
	- offload = FALSE;
	-
	- /* Indicate the whole packet as payload when not doing TSO */
	- *olinfo_status \|= mp->m_pkthdr.len << IXGBE_ADVTXD_PAYLEN_SHIFT;
	+ u32 vlan_macip_lens, type_tucmd_mlhl;
	+ u32 olinfo_status, mss_l4len_idx, pktlen, offload;
	+ u8 ehdrlen;

	- /* Now ready a context descriptor */
	- TXD = (struct ixgbe_adv_tx_context_desc *)&txr->tx_base[ctxd];
	-
	- /*
	- * In advanced descriptors the vlan tag must
	- * be placed into the context descriptor. Hence
	- * we need to make one even if not doing offloads.
	- */
	- if (mp->m_flags & M_VLANTAG) {
	- vtag = htole16(mp->m_pkthdr.ether_vtag);
	- vlan_macip_lens \|= (vtag << IXGBE_ADVTXD_VLAN_SHIFT);
	- } else if (!(txr->adapter->feat_en & IXGBE_FEATURE_NEEDS_CTXD) &&
	- (offload == FALSE))
	- return (0);
	+ offload = TRUE;
	+ olinfo_status = mss_l4len_idx = vlan_macip_lens = type_tucmd_mlhl = 0;
	+ /* VLAN MACLEN IPLEN */
	+ vlan_macip_lens \|= (htole16(pi->ipi_vtag) << IXGBE_ADVTXD_VLAN_SHIFT);

	/*
	- * Determine where frame payload starts.
	- * Jump over vlan headers if already present,
	- * helpful for QinQ too.
	+ * Some of our VF devices need a context descriptor for every
	+ * packet. That means the ehdrlen needs to be non-zero in order
	+ * for the host driver not to flag a malicious event. The stack
	+ * will most likely populate this for all other reasons of why
	+ * this function was called.
	*/
	- eh = mtod(mp, struct ether_vlan_header *);
	- if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
	- etype = ntohs(eh->evl_proto);
	- ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
	- } else {
	- etype = ntohs(eh->evl_encap_proto);
	+ if (pi->ipi_ehdrlen == 0) {
	ehdrlen = ETHER_HDR_LEN;
	- }
	-
	- /* Set the ether header length */
	+ ehdrlen += (pi->ipi_vtag != 0) ? ETHER_VLAN_ENCAP_LEN : 0;
	+ } else
	+ ehdrlen = pi->ipi_ehdrlen;
	vlan_macip_lens \|= ehdrlen << IXGBE_ADVTXD_MACLEN_SHIFT;

	- if (offload == FALSE)
	- goto no_offloads;
	+ pktlen = pi->ipi_len;
	+ /* First check if TSO is to be used */
	+ if (pi->ipi_csum_flags & CSUM_TSO) {
	+ /* This is used in the transmit desc in encap */
	+ pktlen = pi->ipi_len - ehdrlen - pi->ipi_ip_hlen - pi->ipi_tcp_hlen;
	+ mss_l4len_idx \|= (pi->ipi_tso_segsz << IXGBE_ADVTXD_MSS_SHIFT);
	+ mss_l4len_idx \|= (pi->ipi_tcp_hlen << IXGBE_ADVTXD_L4LEN_SHIFT);
	+ }

	- /*
	- * If the first mbuf only includes the ethernet header,
	- * jump to the next one
	- * XXX: This assumes the stack splits mbufs containing headers
	- * on header boundaries
	- * XXX: And assumes the entire IP header is contained in one mbuf
	- */
	- if (mp->m_len == ehdrlen && mp->m_next)
	- l3d = mtod(mp->m_next, caddr_t);
	+ olinfo_status \|= pktlen << IXGBE_ADVTXD_PAYLEN_SHIFT;
	+
	+ if (pi->ipi_flags & IPI_TX_IPV4) {
	+ type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_IPV4;
	+ /* Tell transmit desc to also do IPv4 checksum. */
	+ if (pi->ipi_csum_flags & (CSUM_IP\|CSUM_TSO))
	+ olinfo_status \|= IXGBE_TXD_POPTS_IXSM << 8;
	+ } else if (pi->ipi_flags & IPI_TX_IPV6)
	+ type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_IPV6;
	else
	- l3d = mtod(mp, caddr_t) + ehdrlen;
	-
	- switch (etype) {
	-#ifdef INET
	- case ETHERTYPE_IP:
	- ip = (struct ip *)(l3d);
	- ip_hlen = ip->ip_hl << 2;
	- ipproto = ip->ip_p;
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_IPV4;
	- /* Insert IPv4 checksum into data descriptors */
	- if (mp->m_pkthdr.csum_flags & CSUM_IP) {
	- ip->ip_sum = 0;
	- *olinfo_status \|= IXGBE_TXD_POPTS_IXSM << 8;
	- }
	- break;
	-#endif
	-#ifdef INET6
	- case ETHERTYPE_IPV6:
	- ip6 = (struct ip6_hdr *)(l3d);
	- ip_hlen = sizeof(struct ip6_hdr);
	- ipproto = ip6->ip6_nxt;
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_IPV6;
	- break;
	-#endif
	- default:
	- offload = FALSE;
	- break;
	- }
	+ offload = FALSE;

	- vlan_macip_lens \|= ip_hlen;
	+ vlan_macip_lens \|= pi->ipi_ip_hlen;

	- /* No support for offloads for non-L4 next headers */
	- switch (ipproto) {
	- case IPPROTO_TCP:
	- if (mp->m_pkthdr.csum_flags &
	- (CSUM_IP_TCP \| CSUM_IP6_TCP))
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_L4T_TCP;
	- else
	- offload = false;
	- break;
	- case IPPROTO_UDP:
	- if (mp->m_pkthdr.csum_flags &
	- (CSUM_IP_UDP \| CSUM_IP6_UDP))
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_L4T_UDP;
	- else
	- offload = false;
	- break;
	- case IPPROTO_SCTP:
	- if (mp->m_pkthdr.csum_flags &
	- (CSUM_IP_SCTP \| CSUM_IP6_SCTP))
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_L4T_SCTP;
	- else
	- offload = false;
	- break;
	- default:
	- offload = false;
	- break;
	+ switch (pi->ipi_ipproto) {
	+ case IPPROTO_TCP:
	+ if (pi->ipi_csum_flags & (CSUM_IP_TCP \| CSUM_IP6_TCP))
	+ type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_L4T_TCP;
	+ else
	+ offload = FALSE;
	+ break;
	+ case IPPROTO_UDP:
	+ if (pi->ipi_csum_flags & (CSUM_IP_UDP \| CSUM_IP6_UDP))
	+ type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_L4T_UDP;
	+ else
	+ offload = FALSE;
	+ break;
	+ case IPPROTO_SCTP:
	+ if (pi->ipi_csum_flags & (CSUM_IP_SCTP \| CSUM_IP6_SCTP))
	+ type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_L4T_SCTP;
	+ else
	+ offload = FALSE;
	+ break;
	+ default:
	+ offload = FALSE;
	+ break;
	}
	+/* Insert L4 checksum into data descriptors */
	+ if (offload)
	+ olinfo_status \|= IXGBE_TXD_POPTS_TXSM << 8;

	- if (offload) /* Insert L4 checksum into data descriptors */
	- *olinfo_status \|= IXGBE_TXD_POPTS_TXSM << 8;
	-
	-no_offloads:
	type_tucmd_mlhl \|= IXGBE_ADVTXD_DCMD_DEXT \| IXGBE_ADVTXD_DTYP_CTXT;

	/* Now copy bits into descriptor */
	TXD->vlan_macip_lens = htole32(vlan_macip_lens);
	TXD->type_tucmd_mlhl = htole32(type_tucmd_mlhl);
	TXD->seqnum_seed = htole32(0);
	- TXD->mss_l4len_idx = htole32(0);
	-
	- /* We've consumed the first desc, adjust counters */
	- if (++ctxd == txr->num_desc)
	- ctxd = 0;
	- txr->next_avail_desc = ctxd;
	- --txr->tx_avail;
	+ TXD->mss_l4len_idx = htole32(mss_l4len_idx);

	- return (0);
	+ return (olinfo_status);
	} /* ixgbe_tx_ctx_setup */

	/************************************************************************
	- * ixgbe_tso_setup
	- *
	- * Setup work for hardware segmentation offload (TSO) on
	- * adapters using advanced tx descriptors
	+ * ixgbe_isc_txd_encap
	************************************************************************/
	static int
	-ixgbe_tso_setup(struct tx_ring txr, struct mbuf mp, u32 *cmd_type_len,
	- u32 *olinfo_status)
	-{
	+ixgbe_isc_txd_encap(void *arg, if_pkt_info_t pi)
	+{
	+ struct adapter *sc = arg;
	+ if_softc_ctx_t scctx = sc->shared;
	+ struct ix_tx_queue *que = &sc->tx_queues[pi->ipi_qsidx];
	+ struct tx_ring *txr = &que->txr;
	+ int nsegs = pi->ipi_nsegs;
	+ bus_dma_segment_t *segs = pi->ipi_segs;
	+ union ixgbe_adv_tx_desc *txd = NULL;
	struct ixgbe_adv_tx_context_desc *TXD;
	- struct ether_vlan_header *eh;
	-#ifdef INET6
	- struct ip6_hdr *ip6;
	-#endif
	-#ifdef INET
	- struct ip *ip;
	-#endif
	- struct tcphdr *th;
	- int ctxd, ehdrlen, ip_hlen, tcp_hlen;
	- u32 vlan_macip_lens = 0;
	- u32 type_tucmd_mlhl = 0;
	- u32 mss_l4len_idx = 0, paylen;
	- u16 vtag = 0, eh_type;
	-
	- /*
	- * Determine where frame payload starts.
	- * Jump over vlan headers if already present
	- */
	- eh = mtod(mp, struct ether_vlan_header *);
	- if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
	- ehdrlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
	- eh_type = eh->evl_proto;
	+ int i, j, first, pidx_last;
	+ u32 olinfo_status, cmd, flags;
	+ qidx_t ntxd;
	+
	+ cmd = (IXGBE_ADVTXD_DTYP_DATA \|
	+ IXGBE_ADVTXD_DCMD_IFCS \| IXGBE_ADVTXD_DCMD_DEXT);
	+
	+ if (pi->ipi_mflags & M_VLANTAG)
	+ cmd \|= IXGBE_ADVTXD_DCMD_VLE;
	+
	+ i = first = pi->ipi_pidx;
	+ flags = (pi->ipi_flags & IPI_TX_INTR) ? IXGBE_TXD_CMD_RS : 0;
	+ ntxd = scctx->isc_ntxd[0];
	+
	+ TXD = (struct ixgbe_adv_tx_context_desc *) &txr->tx_base[first];
	+ if ((pi->ipi_csum_flags & CSUM_OFFLOAD) \|\|
	+ (sc->feat_en & IXGBE_FEATURE_NEEDS_CTXD) \|\|
	+ pi->ipi_vtag) {
	+ /*********************************************
	+ * Set up the appropriate offload context
	+ * this will consume the first descriptor
	+ *********************************************/
	+ olinfo_status = ixgbe_tx_ctx_setup(TXD, pi);
	+ if (pi->ipi_csum_flags & CSUM_TSO) {
	+ cmd \|= IXGBE_ADVTXD_DCMD_TSE;
	+ ++txr->tso_tx;
	+ }
	+
	+ if (++i == scctx->isc_ntxd[0])
	+ i = 0;
	} else {
	- ehdrlen = ETHER_HDR_LEN;
	- eh_type = eh->evl_encap_proto;
	- }
	-
	- switch (ntohs(eh_type)) {
	-#ifdef INET
	- case ETHERTYPE_IP:
	- ip = (struct ip *)(mp->m_data + ehdrlen);
	- if (ip->ip_p != IPPROTO_TCP)
	- return (ENXIO);
	- ip->ip_sum = 0;
	- ip_hlen = ip->ip_hl << 2;
	- th = (struct tcphdr *)((caddr_t)ip + ip_hlen);
	- th->th_sum = in_pseudo(ip->ip_src.s_addr,
	- ip->ip_dst.s_addr, htons(IPPROTO_TCP));
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_IPV4;
	- /* Tell transmit desc to also do IPv4 checksum. */
	- *olinfo_status \|= IXGBE_TXD_POPTS_IXSM << 8;
	- break;
	-#endif
	-#ifdef INET6
	- case ETHERTYPE_IPV6:
	- ip6 = (struct ip6_hdr *)(mp->m_data + ehdrlen);
	- /* XXX-BZ For now we do not pretend to support ext. hdrs. */
	- if (ip6->ip6_nxt != IPPROTO_TCP)
	- return (ENXIO);
	- ip_hlen = sizeof(struct ip6_hdr);
	- th = (struct tcphdr *)((caddr_t)ip6 + ip_hlen);
	- th->th_sum = in6_cksum_pseudo(ip6, 0, IPPROTO_TCP, 0);
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_IPV6;
	- break;
	-#endif
	- default:
	- panic("%s: CSUM_TSO but no supported IP version (0x%04x)",
	- __func__, ntohs(eh_type));
	- break;
	+ /* Indicate the whole packet as payload when not doing TSO */
	+ olinfo_status = pi->ipi_len << IXGBE_ADVTXD_PAYLEN_SHIFT;
	}

	- ctxd = txr->next_avail_desc;
	- TXD = (struct ixgbe_adv_tx_context_desc *)&txr->tx_base[ctxd];
	-
	- tcp_hlen = th->th_off << 2;
	-
	- /* This is used in the transmit desc in encap */
	- paylen = mp->m_pkthdr.len - ehdrlen - ip_hlen - tcp_hlen;
	-
	- /* VLAN MACLEN IPLEN */
	- if (mp->m_flags & M_VLANTAG) {
	- vtag = htole16(mp->m_pkthdr.ether_vtag);
	- vlan_macip_lens \|= (vtag << IXGBE_ADVTXD_VLAN_SHIFT);
	- }
	-
	- vlan_macip_lens \|= ehdrlen << IXGBE_ADVTXD_MACLEN_SHIFT;
	- vlan_macip_lens \|= ip_hlen;
	- TXD->vlan_macip_lens = htole32(vlan_macip_lens);
	-
	- /* ADV DTYPE TUCMD */
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_DCMD_DEXT \| IXGBE_ADVTXD_DTYP_CTXT;
	- type_tucmd_mlhl \|= IXGBE_ADVTXD_TUCMD_L4T_TCP;
	- TXD->type_tucmd_mlhl = htole32(type_tucmd_mlhl);
	-
	- /* MSS L4LEN IDX */
	- mss_l4len_idx \|= (mp->m_pkthdr.tso_segsz << IXGBE_ADVTXD_MSS_SHIFT);
	- mss_l4len_idx \|= (tcp_hlen << IXGBE_ADVTXD_L4LEN_SHIFT);
	- TXD->mss_l4len_idx = htole32(mss_l4len_idx);
	-
	- TXD->seqnum_seed = htole32(0);
	-
	- if (++ctxd == txr->num_desc)
	- ctxd = 0;
	-
	- txr->tx_avail--;
	- txr->next_avail_desc = ctxd;
	- *cmd_type_len \|= IXGBE_ADVTXD_DCMD_TSE;
	- *olinfo_status \|= IXGBE_TXD_POPTS_TXSM << 8;
	- *olinfo_status \|= paylen << IXGBE_ADVTXD_PAYLEN_SHIFT;
	- ++txr->tso_tx;
	-
	- return (0);
	-} /* ixgbe_tso_setup */
	-
	-
	-/************************************************************************
	- * ixgbe_txeof
	- *
	- * Examine each tx_buffer in the used queue. If the hardware is done
	- * processing the packet then free associated resources. The
	- * tx_buffer is put back on the free queue.
	- ************************************************************************/
	-void
	-ixgbe_txeof(struct tx_ring *txr)
	-{
	- struct adapter *adapter = txr->adapter;
	- struct ixgbe_tx_buf *buf;
	- union ixgbe_adv_tx_desc *txd;
	- u32 work, processed = 0;
	- u32 limit = adapter->tx_process_limit;
	-
	- mtx_assert(&txr->tx_mtx, MA_OWNED);
	-
	-#ifdef DEV_NETMAP
	- if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) &&
	- (adapter->ifp->if_capenable & IFCAP_NETMAP)) {
	- struct netmap_adapter *na = NA(adapter->ifp);
	- struct netmap_kring *kring = &na->tx_rings[txr->me];
	- txd = txr->tx_base;
	- bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
	- BUS_DMASYNC_POSTREAD);
	- /*
	- * In netmap mode, all the work is done in the context
	- * of the client thread. Interrupt handlers only wake up
	- * clients, which may be sleeping on individual rings
	- * or on a global resource for all rings.
	- * To implement tx interrupt mitigation, we wake up the client
	- * thread roughly every half ring, even if the NIC interrupts
	- * more frequently. This is implemented as follows:
	- * - ixgbe_txsync() sets kring->nr_kflags with the index of
	- * the slot that should wake up the thread (nkr_num_slots
	- * means the user thread should not be woken up);
	- * - the driver ignores tx interrupts unless netmap_mitigate=0
	- * or the slot has the DD bit set.
	- */
	- if (!netmap_mitigate \|\|
	- (kring->nr_kflags < kring->nkr_num_slots &&
	- txd[kring->nr_kflags].wb.status & IXGBE_TXD_STAT_DD)) {
	- netmap_tx_irq(adapter->ifp, txr->me);
	- }
	- return;
	- }
	-#endif /* DEV_NETMAP */
	-
	- if (txr->tx_avail == txr->num_desc) {
	- txr->busy = 0;
	- return;
	- }
	-
	- /* Get work starting point */
	- work = txr->next_to_clean;
	- buf = &txr->tx_buffers[work];
	- txd = &txr->tx_base[work];
	- work -= txr->num_desc; /* The distance to ring end */
	- bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
	- BUS_DMASYNC_POSTREAD);
	-
	- do {
	- union ixgbe_adv_tx_desc *eop = buf->eop;
	- if (eop == NULL) /* No work */
	- break;
	-
	- if ((eop->wb.status & IXGBE_TXD_STAT_DD) == 0)
	- break; /* I/O not complete */
	-
	- if (buf->m_head) {
	- txr->bytes += buf->m_head->m_pkthdr.len;
	- bus_dmamap_sync(txr->txtag, buf->map,
	- BUS_DMASYNC_POSTWRITE);
	- bus_dmamap_unload(txr->txtag, buf->map);
	- m_freem(buf->m_head);
	- buf->m_head = NULL;
	- }
	- buf->eop = NULL;
	- ++txr->tx_avail;
	-
	- /* We clean the range if multi segment */
	- while (txd != eop) {
	- ++txd;
	- ++buf;
	- ++work;
	- /* wrap the ring? */
	- if (__predict_false(!work)) {
	- work -= txr->num_desc;
	- buf = txr->tx_buffers;
	- txd = txr->tx_base;
	- }
	- if (buf->m_head) {
	- txr->bytes += buf->m_head->m_pkthdr.len;
	- bus_dmamap_sync(txr->txtag, buf->map,
	- BUS_DMASYNC_POSTWRITE);
	- bus_dmamap_unload(txr->txtag, buf->map);
	- m_freem(buf->m_head);
	- buf->m_head = NULL;
	- }
	- ++txr->tx_avail;
	- buf->eop = NULL;
	-
	- }
	- ++txr->packets;
	- ++processed;
	-
	- /* Try the next packet */
	- ++txd;
	- ++buf;
	- ++work;
	- /* reset with a wrap */
	- if (__predict_false(!work)) {
	- work -= txr->num_desc;
	- buf = txr->tx_buffers;
	- txd = txr->tx_base;
	- }
	- prefetch(txd);
	- } while (__predict_true(--limit));
	-
	- bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
	- BUS_DMASYNC_PREREAD \| BUS_DMASYNC_PREWRITE);
	-
	- work += txr->num_desc;
	- txr->next_to_clean = work;
	-
	- /*
	- * Queue Hang detection, we know there's
	- * work outstanding or the first return
	- * would have been taken, so increment busy
	- * if nothing managed to get cleaned, then
	- * in local_timer it will be checked and
	- * marked as HUNG if it exceeds a MAX attempt.
	- */
	- if ((processed == 0) && (txr->busy != IXGBE_QUEUE_HUNG))
	- ++txr->busy;
	- /*
	- * If anything gets cleaned we reset state to 1,
	- * note this will turn off HUNG if its set.
	- */
	- if (processed)
	- txr->busy = 1;
	-
	- if (txr->tx_avail == txr->num_desc)
	- txr->busy = 0;
	-
	- return;
	-} /* ixgbe_txeof */
	-
	-/************************************************************************
	- * ixgbe_rsc_count
	- *
	- * Used to detect a descriptor that has been merged by Hardware RSC.
	- ************************************************************************/
	-static inline u32
	-ixgbe_rsc_count(union ixgbe_adv_rx_desc *rx)
	-{
	- return (le32toh(rx->wb.lower.lo_dword.data) &
	- IXGBE_RXDADV_RSCCNT_MASK) >> IXGBE_RXDADV_RSCCNT_SHIFT;
	-} /* ixgbe_rsc_count */
	-
	-/************************************************************************
	- * ixgbe_setup_hw_rsc
	- *
	- * Initialize Hardware RSC (LRO) feature on 82599
	- * for an RX ring, this is toggled by the LRO capability
	- * even though it is transparent to the stack.
	- *
	- * NOTE: Since this HW feature only works with IPv4 and
	- * testing has shown soft LRO to be as effective,
	- * this feature will be disabled by default.
	- ************************************************************************/
	-static void
	-ixgbe_setup_hw_rsc(struct rx_ring *rxr)
	-{
	- struct adapter *adapter = rxr->adapter;
	- struct ixgbe_hw *hw = &adapter->hw;
	- u32 rscctrl, rdrxctl;
	-
	- /* If turning LRO/RSC off we need to disable it */
	- if ((adapter->ifp->if_capenable & IFCAP_LRO) == 0) {
	- rscctrl = IXGBE_READ_REG(hw, IXGBE_RSCCTL(rxr->me));
	- rscctrl &= ~IXGBE_RSCCTL_RSCEN;
	- return;
	- }
	-
	- rdrxctl = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
	- rdrxctl &= ~IXGBE_RDRXCTL_RSCFRSTSIZE;
	-#ifdef DEV_NETMAP
	- /* Always strip CRC unless Netmap disabled it */
	- if (!(adapter->feat_en & IXGBE_FEATURE_NETMAP) \|\|
	- !(adapter->ifp->if_capenable & IFCAP_NETMAP) \|\|
	- ix_crcstrip)
	-#endif /* DEV_NETMAP */
	- rdrxctl \|= IXGBE_RDRXCTL_CRCSTRIP;
	- rdrxctl \|= IXGBE_RDRXCTL_RSCACKC;
	- IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, rdrxctl);
	-
	- rscctrl = IXGBE_READ_REG(hw, IXGBE_RSCCTL(rxr->me));
	- rscctrl \|= IXGBE_RSCCTL_RSCEN;
	- /*
	- * Limit the total number of descriptors that
	- * can be combined, so it does not exceed 64K
	- */
	- if (rxr->mbuf_sz == MCLBYTES)
	- rscctrl \|= IXGBE_RSCCTL_MAXDESC_16;
	- else if (rxr->mbuf_sz == MJUMPAGESIZE)
	- rscctrl \|= IXGBE_RSCCTL_MAXDESC_8;
	- else if (rxr->mbuf_sz == MJUM9BYTES)
	- rscctrl \|= IXGBE_RSCCTL_MAXDESC_4;
	- else /* Using 16K cluster */
	- rscctrl \|= IXGBE_RSCCTL_MAXDESC_1;
	-
	- IXGBE_WRITE_REG(hw, IXGBE_RSCCTL(rxr->me), rscctrl);
	-
	- /* Enable TCP header recognition */
	- IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(0),
	- (IXGBE_READ_REG(hw, IXGBE_PSRTYPE(0)) \| IXGBE_PSRTYPE_TCPHDR));
	+ olinfo_status \|= IXGBE_ADVTXD_CC;
	+ for (j = 0; j < nsegs; j++) {
	+ bus_size_t seglen;

	- /* Disable RSC for ACK packets */
	- IXGBE_WRITE_REG(hw, IXGBE_RSCDBU,
	- (IXGBE_RSCDBU_RSCACKDIS \| IXGBE_READ_REG(hw, IXGBE_RSCDBU)));
	+ txd = &txr->tx_base[i];
	+ seglen = segs[j].ds_len;

	- rxr->hw_rsc = TRUE;
	-} /* ixgbe_setup_hw_rsc */
	+ txd->read.buffer_addr = htole64(segs[j].ds_addr);
	+ txd->read.cmd_type_len = htole32(cmd \| seglen);
	+ txd->read.olinfo_status = htole32(olinfo_status);

	-/************************************************************************
	- * ixgbe_refresh_mbufs
	- *
	- * Refresh mbuf buffers for RX descriptor rings
	- * - now keeps its own state so discards due to resource
	- * exhaustion are unnecessary, if an mbuf cannot be obtained
	- * it just returns, keeping its placeholder, thus it can simply
	- * be recalled to try again.
	- ************************************************************************/
	-static void
	-ixgbe_refresh_mbufs(struct rx_ring *rxr, int limit)
	-{
	- struct adapter *adapter = rxr->adapter;
	- struct ixgbe_rx_buf *rxbuf;
	- struct mbuf *mp;
	- bus_dma_segment_t seg[1];
	- int i, j, nsegs, error;
	- bool refreshed = FALSE;
	-
	- i = j = rxr->next_to_refresh;
	- /* Control the loop with one beyond */
	- if (++j == rxr->num_desc)
	- j = 0;
	-
	- while (j != limit) {
	- rxbuf = &rxr->rx_buffers[i];
	- if (rxbuf->buf == NULL) {
	- mp = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,
	- rxr->mbuf_sz);
	- if (mp == NULL)
	- goto update;
	- if (adapter->max_frame_size <= (MCLBYTES - ETHER_ALIGN))
	- m_adj(mp, ETHER_ALIGN);
	- } else
	- mp = rxbuf->buf;
	-
	- mp->m_pkthdr.len = mp->m_len = rxr->mbuf_sz;
	-
	- /* If we're dealing with an mbuf that was copied rather
	- * than replaced, there's no need to go through busdma.
	- */
	- if ((rxbuf->flags & IXGBE_RX_COPY) == 0) {
	- /* Get the memory mapping */
	- bus_dmamap_unload(rxr->ptag, rxbuf->pmap);
	- error = bus_dmamap_load_mbuf_sg(rxr->ptag, rxbuf->pmap,
	- mp, seg, &nsegs, BUS_DMA_NOWAIT);
	- if (error != 0) {
	- printf("Refresh mbufs: payload dmamap load failure - %d\n", error);
	- m_free(mp);
	- rxbuf->buf = NULL;
	- goto update;
	- }
	- rxbuf->buf = mp;
	- bus_dmamap_sync(rxr->ptag, rxbuf->pmap,
	- BUS_DMASYNC_PREREAD);
	- rxbuf->addr = rxr->rx_base[i].read.pkt_addr =
	- htole64(seg[0].ds_addr);
	- } else {
	- rxr->rx_base[i].read.pkt_addr = rxbuf->addr;
	- rxbuf->flags &= ~IXGBE_RX_COPY;
	+ pidx_last = i;
	+ if (++i == scctx->isc_ntxd[0]) {
	+ i = 0;
	}
	-
	- refreshed = TRUE;
	- /* Next is precalculated */
	- i = j;
	- rxr->next_to_refresh = i;
	- if (++j == rxr->num_desc)
	- j = 0;
	}

	-update:
	- if (refreshed) /* Update hardware tail index */
	- IXGBE_WRITE_REG(&adapter->hw, rxr->tail, rxr->next_to_refresh);
	-
	- return;
	-} /* ixgbe_refresh_mbufs */
	-
	-/************************************************************************
	- * ixgbe_allocate_receive_buffers
	- *
	- * Allocate memory for rx_buffer structures. Since we use one
	- * rx_buffer per received packet, the maximum number of rx_buffer's
	- * that we'll need is equal to the number of receive descriptors
	- * that we've allocated.
	- ************************************************************************/
	-static int
	-ixgbe_allocate_receive_buffers(struct rx_ring *rxr)
	-{
	- struct adapter *adapter = rxr->adapter;
	- device_t dev = adapter->dev;
	- struct ixgbe_rx_buf *rxbuf;
	- int bsize, error;
	-
	- bsize = sizeof(struct ixgbe_rx_buf) * rxr->num_desc;
	- rxr->rx_buffers = (struct ixgbe_rx_buf *)malloc(bsize, M_DEVBUF,
	- M_NOWAIT \| M_ZERO);
	- if (rxr->rx_buffers == NULL) {
	- device_printf(dev, "Unable to allocate rx_buffer memory\n");
	- error = ENOMEM;
	- goto fail;
	+ if (flags) {
	+ txr->tx_rsq[txr->tx_rs_pidx] = pidx_last;
	+ txr->tx_rs_pidx = (txr->tx_rs_pidx + 1) & (ntxd - 1);
	}
	+ txd->read.cmd_type_len \|= htole32(IXGBE_TXD_CMD_EOP \| flags);

	- error = bus_dma_tag_create(
	- /* parent */ bus_get_dma_tag(dev),
	- /* alignment */ 1,
	- /* bounds */ 0,
	- /* lowaddr */ BUS_SPACE_MAXADDR,
	- /* highaddr */ BUS_SPACE_MAXADDR,
	- /* filter */ NULL,
	- /* filterarg */ NULL,
	- /* maxsize */ MJUM16BYTES,
	- /* nsegments */ 1,
	- /* maxsegsize */ MJUM16BYTES,
	- /* flags */ 0,
	- /* lockfunc */ NULL,
	- /* lockfuncarg */ NULL,
	- &rxr->ptag);
	- if (error != 0) {
	- device_printf(dev, "Unable to create RX DMA tag\n");
	- goto fail;
	- }
	+ txr->bytes += pi->ipi_len;
	+ pi->ipi_new_pidx = i;

	- for (int i = 0; i < rxr->num_desc; i++, rxbuf++) {
	- rxbuf = &rxr->rx_buffers[i];
	- error = bus_dmamap_create(rxr->ptag, 0, &rxbuf->pmap);
	- if (error) {
	- device_printf(dev, "Unable to create RX dma map\n");
	- goto fail;
	- }
	- }
	+ ++txr->total_packets;

	return (0);
	-
	-fail:
	- /* Frees all, but can handle partial completion */
	- ixgbe_free_receive_structures(adapter);
	-
	- return (error);
	-} /* ixgbe_allocate_receive_buffers */
	+} /* ixgbe_isc_txd_encap */

	/************************************************************************
	- * ixgbe_free_receive_ring
	+ * ixgbe_isc_txd_flush
	************************************************************************/
	static void
	-ixgbe_free_receive_ring(struct rx_ring *rxr)
	+ixgbe_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)
	{
	- for (int i = 0; i < rxr->num_desc; i++) {
	- ixgbe_rx_discard(rxr, i);
	- }
	-} /* ixgbe_free_receive_ring */
	+ struct adapter *sc = arg;
	+ struct ix_tx_queue *que = &sc->tx_queues[txqid];
	+ struct tx_ring *txr = &que->txr;
	+
	+ IXGBE_WRITE_REG(&sc->hw, txr->tail, pidx);
	+} /* ixgbe_isc_txd_flush */

	/************************************************************************
	- * ixgbe_setup_receive_ring
	- *
	- * Initialize a receive ring and its buffers.
	+ * ixgbe_isc_txd_credits_update
	************************************************************************/
	static int
	-ixgbe_setup_receive_ring(struct rx_ring *rxr)
	-{
	- struct adapter *adapter;
	- struct ifnet *ifp;
	- device_t dev;
	- struct ixgbe_rx_buf *rxbuf;
	- struct lro_ctrl *lro = &rxr->lro;
	-#ifdef DEV_NETMAP
	- struct netmap_adapter *na = NA(rxr->adapter->ifp);
	- struct netmap_slot *slot;
	-#endif /* DEV_NETMAP */
	- bus_dma_segment_t seg[1];
	- int rsize, nsegs, error = 0;
	-
	- adapter = rxr->adapter;
	- ifp = adapter->ifp;
	- dev = adapter->dev;
	-
	- /* Clear the ring contents */
	- IXGBE_RX_LOCK(rxr);
	-
	-#ifdef DEV_NETMAP
	- if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
	- slot = netmap_reset(na, NR_RX, rxr->me, 0);
	-#endif /* DEV_NETMAP */
	-
	- rsize = roundup2(adapter->num_rx_desc *
	- sizeof(union ixgbe_adv_rx_desc), DBA_ALIGN);
	- bzero((void *)rxr->rx_base, rsize);
	- /* Cache the size */
	- rxr->mbuf_sz = adapter->rx_mbuf_sz;
	-
	- /* Free current RX buffer structs and their mbufs */
	- ixgbe_free_receive_ring(rxr);
	-
	- /* Now replenish the mbufs */
	- for (int j = 0; j != rxr->num_desc; ++j) {
	- struct mbuf *mp;
	-
	- rxbuf = &rxr->rx_buffers[j];
	-
	-#ifdef DEV_NETMAP
	- /*
	- * In netmap mode, fill the map and set the buffer
	- * address in the NIC ring, considering the offset
	- * between the netmap and NIC rings (see comment in
	- * ixgbe_setup_transmit_ring() ). No need to allocate
	- * an mbuf, so end the block with a continue;
	- */
	- if ((adapter->feat_en & IXGBE_FEATURE_NETMAP) && slot) {
	- int sj = netmap_idx_n2k(&na->rx_rings[rxr->me], j);
	- uint64_t paddr;
	- void *addr;
	-
	- addr = PNMB(na, slot + sj, &paddr);
	- netmap_load_map(na, rxr->ptag, rxbuf->pmap, addr);
	- /* Update descriptor and the cached value */
	- rxr->rx_base[j].read.pkt_addr = htole64(paddr);
	- rxbuf->addr = htole64(paddr);
	- continue;
	- }
	-#endif /* DEV_NETMAP */
	-
	- rxbuf->flags = 0;
	- rxbuf->buf = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,
	- adapter->rx_mbuf_sz);
	- if (rxbuf->buf == NULL) {
	- error = ENOBUFS;
	- goto fail;
	- }
	- mp = rxbuf->buf;
	- mp->m_pkthdr.len = mp->m_len = rxr->mbuf_sz;
	- /* Get the memory mapping */
	- error = bus_dmamap_load_mbuf_sg(rxr->ptag, rxbuf->pmap, mp, seg,
	- &nsegs, BUS_DMA_NOWAIT);
	- if (error != 0)
	- goto fail;
	- bus_dmamap_sync(rxr->ptag, rxbuf->pmap, BUS_DMASYNC_PREREAD);
	- /* Update the descriptor and the cached value */
	- rxr->rx_base[j].read.pkt_addr = htole64(seg[0].ds_addr);
	- rxbuf->addr = htole64(seg[0].ds_addr);
	- }
	-
	+ixgbe_isc_txd_credits_update(void *arg, uint16_t txqid, bool clear)
	+{
	+ struct adapter *sc = arg;
	+ if_softc_ctx_t scctx = sc->shared;
	+ struct ix_tx_queue *que = &sc->tx_queues[txqid];
	+ struct tx_ring *txr = &que->txr;
	+ qidx_t processed = 0;
	+ int updated;
	+ qidx_t cur, prev, ntxd, rs_cidx;
	+ int32_t delta;
	+ uint8_t status;
	+
	+ rs_cidx = txr->tx_rs_cidx;
	+ if (rs_cidx == txr->tx_rs_pidx)
	+ return (0);

	- /* Setup our descriptor indices */
	- rxr->next_to_check = 0;
	- rxr->next_to_refresh = 0;
	- rxr->lro_enabled = FALSE;
	- rxr->rx_copies = 0;
	- rxr->rx_bytes = 0;
	- rxr->vtag_strip = FALSE;
	+ cur = txr->tx_rsq[rs_cidx];
	+ status = txr->tx_base[cur].wb.status;
	+ updated = !!(status & IXGBE_TXD_STAT_DD);

	- bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
	- BUS_DMASYNC_PREREAD \| BUS_DMASYNC_PREWRITE);
	+ if (clear == false \|\| updated == 0)
	+ return (updated);

	- /*
	- * Now set up the LRO interface
	- */
	- if (ixgbe_rsc_enable)
	- ixgbe_setup_hw_rsc(rxr);
	- else if (ifp->if_capenable & IFCAP_LRO) {
	- int err = tcp_lro_init(lro);
	- if (err) {
	- device_printf(dev, "LRO Initialization failed!\n");
	- goto fail;
	- }
	- INIT_DEBUGOUT("RX Soft LRO Initialized\n");
	- rxr->lro_enabled = TRUE;
	- lro->ifp = adapter->ifp;
	- }
	-
	- IXGBE_RX_UNLOCK(rxr);
	+ prev = txr->tx_cidx_processed;
	+ ntxd = scctx->isc_ntxd[0];
	+ do {
	+ delta = (int32_t)cur - (int32_t)prev;
	+ if (delta < 0)
	+ delta += ntxd;
	+
	+ processed += delta;
	+ prev = cur;
	+ rs_cidx = (rs_cidx + 1) & (ntxd - 1);
	+ if (rs_cidx == txr->tx_rs_pidx)
	+ break;

	- return (0);
	+ cur = txr->tx_rsq[rs_cidx];
	+ status = txr->tx_base[cur].wb.status;
	+ } while ((status & IXGBE_TXD_STAT_DD));

	-fail:
	- ixgbe_free_receive_ring(rxr);
	- IXGBE_RX_UNLOCK(rxr);
	+ txr->tx_rs_cidx = rs_cidx;
	+ txr->tx_cidx_processed = prev;

	- return (error);
	-} /* ixgbe_setup_receive_ring */
	+ return (processed);
	+} /* ixgbe_isc_txd_credits_update */

	/************************************************************************
	- * ixgbe_setup_receive_structures - Initialize all receive rings.
	+ * ixgbe_isc_rxd_refill
	************************************************************************/
	-int
	-ixgbe_setup_receive_structures(struct adapter *adapter)
	-{
	- struct rx_ring *rxr = adapter->rx_rings;
	- int j;
	-
	- for (j = 0; j < adapter->num_queues; j++, rxr++)
	- if (ixgbe_setup_receive_ring(rxr))
	- goto fail;
	-
	- return (0);
	-fail:
	- /*
	- * Free RX buffers allocated so far, we will only handle
	- * the rings that completed, the failing case will have
	- * cleaned up for itself. 'j' failed, so its the terminus.
	- */
	- for (int i = 0; i < j; ++i) {
	- rxr = &adapter->rx_rings[i];
	- IXGBE_RX_LOCK(rxr);
	- ixgbe_free_receive_ring(rxr);
	- IXGBE_RX_UNLOCK(rxr);
	- }
	-
	- return (ENOBUFS);
	-} /* ixgbe_setup_receive_structures */
	-
	-
	-/************************************************************************
	- * ixgbe_free_receive_structures - Free all receive rings.
	- ************************************************************************/
	-void
	-ixgbe_free_receive_structures(struct adapter *adapter)
	+static void
	+ixgbe_isc_rxd_refill(void *arg, if_rxd_update_t iru)
	{
	- struct rx_ring *rxr = adapter->rx_rings;
	+ struct adapter *sc = arg;
	+ struct ix_rx_queue *que = &sc->rx_queues[iru->iru_qsidx];
	+ struct rx_ring *rxr = &que->rxr;
	+ uint64_t *paddrs;
	+ int i;
	+ uint32_t next_pidx, pidx;
	+ uint16_t count;

	- INIT_DEBUGOUT("ixgbe_free_receive_structures: begin");
	+ paddrs = iru->iru_paddrs;
	+ pidx = iru->iru_pidx;
	+ count = iru->iru_count;

	- for (int i = 0; i < adapter->num_queues; i++, rxr++) {
	- ixgbe_free_receive_buffers(rxr);
	- /* Free LRO memory */
	- tcp_lro_free(&rxr->lro);
	- /* Free the ring memory as well */
	- ixgbe_dma_free(adapter, &rxr->rxdma);
	+ for (i = 0, next_pidx = pidx; i < count; i++) {
	+ rxr->rx_base[next_pidx].read.pkt_addr = htole64(paddrs[i]);
	+ if (++next_pidx == sc->shared->isc_nrxd[0])
	+ next_pidx = 0;
	}
	-
	- free(adapter->rx_rings, M_DEVBUF);
	-} /* ixgbe_free_receive_structures */
	-
	+} /* ixgbe_isc_rxd_refill */

	/************************************************************************
	- * ixgbe_free_receive_buffers - Free receive ring data structures
	+ * ixgbe_isc_rxd_flush
	************************************************************************/
	static void
	-ixgbe_free_receive_buffers(struct rx_ring *rxr)
	+ixgbe_isc_rxd_flush(void *arg, uint16_t qsidx, uint8_t flidx __unused, qidx_t pidx)
	{
	- struct adapter *adapter = rxr->adapter;
	- struct ixgbe_rx_buf *rxbuf;
	-
	- INIT_DEBUGOUT("ixgbe_free_receive_buffers: begin");
	-
	- /* Cleanup any existing buffers */
	- if (rxr->rx_buffers != NULL) {
	- for (int i = 0; i < adapter->num_rx_desc; i++) {
	- rxbuf = &rxr->rx_buffers[i];
	- ixgbe_rx_discard(rxr, i);
	- if (rxbuf->pmap != NULL) {
	- bus_dmamap_destroy(rxr->ptag, rxbuf->pmap);
	- rxbuf->pmap = NULL;
	- }
	- }
	- if (rxr->rx_buffers != NULL) {
	- free(rxr->rx_buffers, M_DEVBUF);
	- rxr->rx_buffers = NULL;
	- }
	- }
	-
	- if (rxr->ptag != NULL) {
	- bus_dma_tag_destroy(rxr->ptag);
	- rxr->ptag = NULL;
	- }
	+ struct adapter *sc = arg;
	+ struct ix_rx_queue *que = &sc->rx_queues[qsidx];
	+ struct rx_ring *rxr = &que->rxr;

	- return;
	-} /* ixgbe_free_receive_buffers */
	-
	-/************************************************************************
	- * ixgbe_rx_input
	- ************************************************************************/
	-static __inline void
	-ixgbe_rx_input(struct rx_ring rxr, struct ifnet ifp, struct mbuf *m,
	- u32 ptype)
	-{
	- /*
	- * ATM LRO is only for IP/TCP packets and TCP checksum of the packet
	- * should be computed by hardware. Also it should not have VLAN tag in
	- * ethernet header. In case of IPv6 we do not yet support ext. hdrs.
	- */
	- if (rxr->lro_enabled &&
	- (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0 &&
	- (ptype & IXGBE_RXDADV_PKTTYPE_ETQF) == 0 &&
	- ((ptype & (IXGBE_RXDADV_PKTTYPE_IPV4 \| IXGBE_RXDADV_PKTTYPE_TCP)) ==
	- (IXGBE_RXDADV_PKTTYPE_IPV4 \| IXGBE_RXDADV_PKTTYPE_TCP) \|\|
	- (ptype & (IXGBE_RXDADV_PKTTYPE_IPV6 \| IXGBE_RXDADV_PKTTYPE_TCP)) ==
	- (IXGBE_RXDADV_PKTTYPE_IPV6 \| IXGBE_RXDADV_PKTTYPE_TCP)) &&
	- (m->m_pkthdr.csum_flags & (CSUM_DATA_VALID \| CSUM_PSEUDO_HDR)) ==
	- (CSUM_DATA_VALID \| CSUM_PSEUDO_HDR)) {
	- /*
	- * Send to the stack if:
	- * - LRO not enabled, or
	- * - no LRO resources, or
	- * - lro enqueue fails
	- */
	- if (rxr->lro.lro_cnt != 0)
	- if (tcp_lro_rx(&rxr->lro, m, 0) == 0)
	- return;
	- }
	- (*ifp->if_input)(ifp, m);
	-} /* ixgbe_rx_input */
	+ IXGBE_WRITE_REG(&sc->hw, rxr->tail, pidx);
	+} /* ixgbe_isc_rxd_flush */

	/************************************************************************
	- * ixgbe_rx_discard
	+ * ixgbe_isc_rxd_available
	************************************************************************/
	-static __inline void
	-ixgbe_rx_discard(struct rx_ring *rxr, int i)
	+static int
	+ixgbe_isc_rxd_available(void *arg, uint16_t qsidx, qidx_t pidx, qidx_t budget)
	{
	- struct ixgbe_rx_buf *rbuf;
	-
	- rbuf = &rxr->rx_buffers[i];
	+ struct adapter *sc = arg;
	+ struct ix_rx_queue *que = &sc->rx_queues[qsidx];
	+ struct rx_ring *rxr = &que->rxr;
	+ union ixgbe_adv_rx_desc *rxd;
	+ u32 staterr;
	+ int cnt, i, nrxd;

	- /*
	- * With advanced descriptors the writeback
	- * clobbers the buffer addrs, so its easier
	- * to just free the existing mbufs and take
	- * the normal refresh path to get new buffers
	- * and mapping.
	- */
	+ if (budget == 1) {
	+ rxd = &rxr->rx_base[pidx];
	+ staterr = le32toh(rxd->wb.upper.status_error);

	- if (rbuf->fmp != NULL) {/* Partial chain ? */
	- bus_dmamap_sync(rxr->ptag, rbuf->pmap, BUS_DMASYNC_POSTREAD);
	- m_freem(rbuf->fmp);
	- rbuf->fmp = NULL;
	- rbuf->buf = NULL; /* rbuf->buf is part of fmp's chain */
	- } else if (rbuf->buf) {
	- bus_dmamap_sync(rxr->ptag, rbuf->pmap, BUS_DMASYNC_POSTREAD);
	- m_free(rbuf->buf);
	- rbuf->buf = NULL;
	+ return (staterr & IXGBE_RXD_STAT_DD);
	}
	- bus_dmamap_unload(rxr->ptag, rbuf->pmap);

	- rbuf->flags = 0;
	+ nrxd = sc->shared->isc_nrxd[0];
	+ // em has cnt < nrxd. off by 1 here or there?
	+// for (cnt = 0, i = pidx; cnt < nrxd && cnt <= budget;) {
	+ for (cnt = 0, i = pidx; cnt < nrxd-1 && cnt <= budget;) {
	+ rxd = &rxr->rx_base[i];
	+ staterr = le32toh(rxd->wb.upper.status_error);

	- return;
	-} /* ixgbe_rx_discard */
	+ if ((staterr & IXGBE_RXD_STAT_DD) == 0)
	+ break;
	+ if (++i == nrxd)
	+ i = 0;
	+ if (staterr & IXGBE_RXD_STAT_EOP)
	+ cnt++;
	+ }

	+ return (cnt);
	+} /* ixgbe_isc_rxd_available */

	/************************************************************************
	- * ixgbe_rxeof
	+ * ixgbe_isc_rxd_pkt_get
	*
	- * Executes in interrupt context. It replenishes the
	- * mbufs in the descriptor and sends data which has
	- * been dma'ed into host memory to upper layer.
	+ * Routine sends data which has been dma'ed into host memory
	+ * to upper layer. Initialize ri structure.
	*
	- * Return TRUE for more work, FALSE for all clean.
	+ * Returns 0 upon success, errno on failure
	************************************************************************/
	-bool
	-ixgbe_rxeof(struct ix_queue *que)
	-{
	- struct adapter *adapter = que->adapter;
	- struct rx_ring *rxr = que->rxr;
	- struct ifnet *ifp = adapter->ifp;
	- struct lro_ctrl *lro = &rxr->lro;
	- union ixgbe_adv_rx_desc *cur;
	- struct ixgbe_rx_buf rbuf, nbuf;
	- int i, nextp, processed = 0;
	- u32 staterr = 0;
	- u32 count = adapter->rx_process_limit;
	- u16 pkt_info;
	-
	- IXGBE_RX_LOCK(rxr);
	-
	-#ifdef DEV_NETMAP
	- if (adapter->feat_en & IXGBE_FEATURE_NETMAP) {
	- /* Same as the txeof routine: wakeup clients on intr. */
	- if (netmap_rx_irq(ifp, rxr->me, &processed)) {
	- IXGBE_RX_UNLOCK(rxr);
	- return (FALSE);
	- }
	- }
	-#endif /* DEV_NETMAP */

	- for (i = rxr->next_to_check; count != 0;) {
	- struct mbuf sendmp, mp;
	- u32 rsc, ptype;
	- u16 len;
	- u16 vtag = 0;
	- bool eop;
	+static int
	+ixgbe_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
	+{
	+ struct adapter *adapter = arg;
	+ struct ix_rx_queue *que = &adapter->rx_queues[ri->iri_qsidx];
	+ struct rx_ring *rxr = &que->rxr;
	+ struct ifnet *ifp = iflib_get_ifp(adapter->ctx);
	+ union ixgbe_adv_rx_desc *rxd;
	+
	+ u16 pkt_info, len, cidx, i;
	+ u16 vtag = 0;
	+ u32 ptype;
	+ u32 staterr = 0;
	+ bool eop;
	+
	+ i = 0;
	+ cidx = ri->iri_cidx;
	+ do {
	+ rxd = &rxr->rx_base[cidx];
	+ staterr = le32toh(rxd->wb.upper.status_error);
	+ pkt_info = le16toh(rxd->wb.lower.lo_dword.hs_rss.pkt_info);

	- /* Sync the ring. */
	- bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
	- BUS_DMASYNC_POSTREAD \| BUS_DMASYNC_POSTWRITE);
	+ /* Error Checking then decrement count */
	+ MPASS ((staterr & IXGBE_RXD_STAT_DD) != 0);

	- cur = &rxr->rx_base[i];
	- staterr = le32toh(cur->wb.upper.status_error);
	- pkt_info = le16toh(cur->wb.lower.lo_dword.hs_rss.pkt_info);
	+ len = le16toh(rxd->wb.upper.length);
	+ ptype = le32toh(rxd->wb.lower.lo_dword.data) &
	+ IXGBE_RXDADV_PKTTYPE_MASK;

	- if ((staterr & IXGBE_RXD_STAT_DD) == 0)
	- break;
	- if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
	- break;
	+ ri->iri_len += len;
	+ rxr->bytes += len;

	- count--;
	- sendmp = NULL;
	- nbuf = NULL;
	- rsc = 0;
	- cur->wb.upper.status_error = 0;
	- rbuf = &rxr->rx_buffers[i];
	- mp = rbuf->buf;
	-
	- len = le16toh(cur->wb.upper.length);
	- ptype = le32toh(cur->wb.lower.lo_dword.data) &
	- IXGBE_RXDADV_PKTTYPE_MASK;
	+ rxd->wb.upper.status_error = 0;
	eop = ((staterr & IXGBE_RXD_STAT_EOP) != 0);
	+ if (staterr & IXGBE_RXD_STAT_VP) {
	+ vtag = le16toh(rxd->wb.upper.vlan);
	+ } else {
	+ vtag = 0;
	+ }

	/* Make sure bad packets are discarded */
	if (eop && (staterr & IXGBE_RXDADV_ERR_FRAME_ERR_MASK) != 0) {
	+
	#if __FreeBSD_version >= 1100036
	if (adapter->feat_en & IXGBE_FEATURE_VF)
	if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
	#endif
	- rxr->rx_discarded++;
	- ixgbe_rx_discard(rxr, i);
	- goto next_desc;
	- }
	-
	- bus_dmamap_sync(rxr->ptag, rbuf->pmap, BUS_DMASYNC_POSTREAD);
	-
	- /*
	- * On 82599 which supports a hardware
	- * LRO (called HW RSC), packets need
	- * not be fragmented across sequential
	- * descriptors, rather the next descriptor
	- * is indicated in bits of the descriptor.
	- * This also means that we might proceses
	- * more than one packet at a time, something
	- * that has never been true before, it
	- * required eliminating global chain pointers
	- * in favor of what we are doing here. -jfv
	- */
	- if (!eop) {
	- /*
	- * Figure out the next descriptor
	- * of this frame.
	- */
	- if (rxr->hw_rsc == TRUE) {
	- rsc = ixgbe_rsc_count(cur);
	- rxr->rsc_num += (rsc - 1);
	- }
	- if (rsc) { /* Get hardware index */
	- nextp = ((staterr & IXGBE_RXDADV_NEXTP_MASK) >>
	- IXGBE_RXDADV_NEXTP_SHIFT);
	- } else { /* Just sequential */
	- nextp = i + 1;
	- if (nextp == adapter->num_rx_desc)
	- nextp = 0;
	- }
	- nbuf = &rxr->rx_buffers[nextp];
	- prefetch(nbuf);
	- }
	- /*
	- * Rather than using the fmp/lmp global pointers
	- * we now keep the head of a packet chain in the
	- * buffer struct and pass this along from one
	- * descriptor to the next, until we get EOP.
	- */
	- mp->m_len = len;
	- /*
	- * See if there is a stored head
	- * that determines what we are
	- */
	- sendmp = rbuf->fmp;
	- if (sendmp != NULL) { /* secondary frag */
	- rbuf->buf = rbuf->fmp = NULL;
	- mp->m_flags &= ~M_PKTHDR;
	- sendmp->m_pkthdr.len += mp->m_len;
	- } else {
	- /*
	- * Optimize. This might be a small packet,
	- * maybe just a TCP ACK. Do a fast copy that
	- * is cache aligned into a new mbuf, and
	- * leave the old mbuf+cluster for re-use.
	- */
	- if (eop && len <= IXGBE_RX_COPY_LEN) {
	- sendmp = m_gethdr(M_NOWAIT, MT_DATA);
	- if (sendmp != NULL) {
	- sendmp->m_data += IXGBE_RX_COPY_ALIGN;
	- ixgbe_bcopy(mp->m_data, sendmp->m_data,
	- len);
	- sendmp->m_len = len;
	- rxr->rx_copies++;
	- rbuf->flags \|= IXGBE_RX_COPY;
	- }
	- }
	- if (sendmp == NULL) {
	- rbuf->buf = rbuf->fmp = NULL;
	- sendmp = mp;
	- }
	-
	- /* first desc of a non-ps chain */
	- sendmp->m_flags \|= M_PKTHDR;
	- sendmp->m_pkthdr.len = mp->m_len;
	- }
	- ++processed;
	-
	- /* Pass the head pointer on */
	- if (eop == 0) {
	- nbuf->fmp = sendmp;
	- sendmp = NULL;
	- mp->m_next = nbuf->buf;
	- } else { /* Sending this frame */
	- sendmp->m_pkthdr.rcvif = ifp;
	- rxr->rx_packets++;
	- /* capture data for AIM */
	- rxr->bytes += sendmp->m_pkthdr.len;
	- rxr->rx_bytes += sendmp->m_pkthdr.len;
	- /* Process vlan info */
	- if ((rxr->vtag_strip) && (staterr & IXGBE_RXD_STAT_VP))
	- vtag = le16toh(cur->wb.upper.vlan);
	- if (vtag) {
	- sendmp->m_pkthdr.ether_vtag = vtag;
	- sendmp->m_flags \|= M_VLANTAG;
	- }
	- if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
	- ixgbe_rx_checksum(staterr, sendmp, ptype);
	-
	- /*
	- * In case of multiqueue, we have RXCSUM.PCSD bit set
	- * and never cleared. This means we have RSS hash
	- * available to be used.
	- */
	- if (adapter->num_queues > 1) {
	- sendmp->m_pkthdr.flowid =
	- le32toh(cur->wb.lower.hi_dword.rss);
	- switch (pkt_info & IXGBE_RXDADV_RSSTYPE_MASK) {
	- case IXGBE_RXDADV_RSSTYPE_IPV4:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_IPV4);
	- break;
	- case IXGBE_RXDADV_RSSTYPE_IPV4_TCP:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_TCP_IPV4);
	- break;
	- case IXGBE_RXDADV_RSSTYPE_IPV6:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_IPV6);
	- break;
	- case IXGBE_RXDADV_RSSTYPE_IPV6_TCP:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_TCP_IPV6);
	- break;
	- case IXGBE_RXDADV_RSSTYPE_IPV6_EX:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_IPV6_EX);
	- break;
	- case IXGBE_RXDADV_RSSTYPE_IPV6_TCP_EX:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_TCP_IPV6_EX);
	- break;
	-#if __FreeBSD_version > 1100000
	- case IXGBE_RXDADV_RSSTYPE_IPV4_UDP:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_UDP_IPV4);
	- break;
	- case IXGBE_RXDADV_RSSTYPE_IPV6_UDP:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_UDP_IPV6);
	- break;
	- case IXGBE_RXDADV_RSSTYPE_IPV6_UDP_EX:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_RSS_UDP_IPV6_EX);
	- break;
	-#endif
	- default:
	- M_HASHTYPE_SET(sendmp,
	- M_HASHTYPE_OPAQUE_HASH);
	- }
	- } else {
	- sendmp->m_pkthdr.flowid = que->msix;
	- M_HASHTYPE_SET(sendmp, M_HASHTYPE_OPAQUE);
	- }
	- }
	-next_desc:
	- bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
	- BUS_DMASYNC_PREREAD \| BUS_DMASYNC_PREWRITE);
	-
	- /* Advance our pointers to the next descriptor. */
	- if (++i == rxr->num_desc)
	- i = 0;
	-
	- /* Now send to the stack or do LRO */
	- if (sendmp != NULL) {
	- rxr->next_to_check = i;
	- IXGBE_RX_UNLOCK(rxr);
	- ixgbe_rx_input(rxr, ifp, sendmp, ptype);
	- IXGBE_RX_LOCK(rxr);
	- i = rxr->next_to_check;
	- }
	-
	- /* Every 8 descriptors we go to refresh mbufs */
	- if (processed == 8) {
	- ixgbe_refresh_mbufs(rxr, i);
	- processed = 0;
	- }
	- }
	-
	- /* Refresh any remaining buf structs */
	- if (ixgbe_rx_unrefreshed(rxr))
	- ixgbe_refresh_mbufs(rxr, i);
	-
	- rxr->next_to_check = i;
	-
	- IXGBE_RX_UNLOCK(rxr);
	-
	- /*
	- * Flush any outstanding LRO work
	- */
	- tcp_lro_flush_all(lro);
	-
	- /*
	- * Still have cleaning to do?
	- */
	- if ((staterr & IXGBE_RXD_STAT_DD) != 0)
	- return (TRUE);
	-
	- return (FALSE);
	-} /* ixgbe_rxeof */

	+ rxr->rx_discarded++;
	+ return (EBADMSG);
	+ }
	+ ri->iri_frags[i].irf_flid = 0;
	+ ri->iri_frags[i].irf_idx = cidx;
	+ ri->iri_frags[i].irf_len = len;
	+ if (++cidx == adapter->shared->isc_nrxd[0])
	+ cidx = 0;
	+ i++;
	+ /* even a 16K packet shouldn't consume more than 8 clusters */
	+ MPASS(i < 9);
	+ } while (!eop);
	+
	+ rxr->rx_packets++;
	+ rxr->packets++;
	+ rxr->rx_bytes += ri->iri_len;
	+
	+ if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
	+ ixgbe_rx_checksum(staterr, ri, ptype);
	+
	+ ri->iri_flowid = le32toh(rxd->wb.lower.hi_dword.rss);
	+ ri->iri_rsstype = ixgbe_determine_rsstype(pkt_info);
	+ ri->iri_vtag = vtag;
	+ ri->iri_nfrags = i;
	+ if (vtag)
	+ ri->iri_flags \|= M_VLANTAG;
	+ return (0);
	+} /* ixgbe_isc_rxd_pkt_get */

	/************************************************************************
	* ixgbe_rx_checksum
	@@ -1922,7 +480,7 @@
	* doesn't spend time verifying the checksum.
	************************************************************************/
	static void
	-ixgbe_rx_checksum(u32 staterr, struct mbuf * mp, u32 ptype)
	+ixgbe_rx_checksum(u32 staterr, if_rxd_info_t ri, u32 ptype)
	{
	u16 status = (u16)staterr;
	u8 errors = (u8)(staterr >> 24);
	@@ -1930,270 +488,59 @@

	if ((ptype & IXGBE_RXDADV_PKTTYPE_ETQF) == 0 &&
	(ptype & IXGBE_RXDADV_PKTTYPE_SCTP) != 0)
	- sctp = true;
	+ sctp = TRUE;

	/* IPv4 checksum */
	if (status & IXGBE_RXD_STAT_IPCS) {
	- mp->m_pkthdr.csum_flags \|= CSUM_L3_CALC;
	- /* IP Checksum Good */
	- if (!(errors & IXGBE_RXD_ERR_IPE))
	- mp->m_pkthdr.csum_flags \|= CSUM_L3_VALID;
	+ if (!(errors & IXGBE_RXD_ERR_IPE)) {
	+ /* IP Checksum Good */
	+ ri->iri_csum_flags = CSUM_IP_CHECKED \| CSUM_IP_VALID;
	+ } else
	+ ri->iri_csum_flags = 0;
	}
	/* TCP/UDP/SCTP checksum */
	if (status & IXGBE_RXD_STAT_L4CS) {
	- mp->m_pkthdr.csum_flags \|= CSUM_L4_CALC;
	+ u64 type = (CSUM_DATA_VALID \| CSUM_PSEUDO_HDR);
	+#if __FreeBSD_version >= 800000
	+ if (sctp)
	+ type = CSUM_SCTP_VALID;
	+#endif
	if (!(errors & IXGBE_RXD_ERR_TCPE)) {
	- mp->m_pkthdr.csum_flags \|= CSUM_L4_VALID;
	+ ri->iri_csum_flags \|= type;
	if (!sctp)
	- mp->m_pkthdr.csum_data = htons(0xffff);
	+ ri->iri_csum_data = htons(0xffff);
	}
	}
	} /* ixgbe_rx_checksum */

	/************************************************************************
	- * ixgbe_dmamap_cb - Manage DMA'able memory.
	- ************************************************************************/
	-static void
	-ixgbe_dmamap_cb(void arg, bus_dma_segment_t segs, int nseg, int error)
	-{
	- if (error)
	- return;
	- (bus_addr_t )arg = segs->ds_addr;
	-
	- return;
	-} /* ixgbe_dmamap_cb */
	-
	-/************************************************************************
	- * ixgbe_dma_malloc
	- ************************************************************************/
	-static int
	-ixgbe_dma_malloc(struct adapter *adapter, bus_size_t size,
	- struct ixgbe_dma_alloc *dma, int mapflags)
	-{
	- device_t dev = adapter->dev;
	- int r;
	-
	- r = bus_dma_tag_create(
	- /* parent */ bus_get_dma_tag(adapter->dev),
	- /* alignment */ DBA_ALIGN,
	- /* bounds */ 0,
	- /* lowaddr */ BUS_SPACE_MAXADDR,
	- /* highaddr */ BUS_SPACE_MAXADDR,
	- /* filter */ NULL,
	- /* filterarg */ NULL,
	- /* maxsize */ size,
	- /* nsegments */ 1,
	- /* maxsegsize */ size,
	- /* flags */ BUS_DMA_ALLOCNOW,
	- /* lockfunc */ NULL,
	- /* lockfuncarg */ NULL,
	- &dma->dma_tag);
	- if (r != 0) {
	- device_printf(dev,
	- "ixgbe_dma_malloc: bus_dma_tag_create failed; error %u\n",
	- r);
	- goto fail_0;
	- }
	- r = bus_dmamem_alloc(dma->dma_tag, (void **)&dma->dma_vaddr,
	- BUS_DMA_NOWAIT, &dma->dma_map);
	- if (r != 0) {
	- device_printf(dev,
	- "ixgbe_dma_malloc: bus_dmamem_alloc failed; error %u\n", r);
	- goto fail_1;
	- }
	- r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, size,
	- ixgbe_dmamap_cb, &dma->dma_paddr, mapflags \| BUS_DMA_NOWAIT);
	- if (r != 0) {
	- device_printf(dev,
	- "ixgbe_dma_malloc: bus_dmamap_load failed; error %u\n", r);
	- goto fail_2;
	- }
	- dma->dma_size = size;
	-
	- return (0);
	-fail_2:
	- bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
	-fail_1:
	- bus_dma_tag_destroy(dma->dma_tag);
	-fail_0:
	- dma->dma_tag = NULL;
	-
	- return (r);
	-} /* ixgbe_dma_malloc */
	-
	-/************************************************************************
	- * ixgbe_dma_free
	- ************************************************************************/
	-static void
	-ixgbe_dma_free(struct adapter adapter, struct ixgbe_dma_alloc dma)
	-{
	- bus_dmamap_sync(dma->dma_tag, dma->dma_map,
	- BUS_DMASYNC_POSTREAD \| BUS_DMASYNC_POSTWRITE);
	- bus_dmamap_unload(dma->dma_tag, dma->dma_map);
	- bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
	- bus_dma_tag_destroy(dma->dma_tag);
	-} /* ixgbe_dma_free */
	-
	-
	-/************************************************************************
	- * ixgbe_allocate_queues
	+ * ixgbe_determine_rsstype
	*
	- * Allocate memory for the transmit and receive rings, and then
	- * the descriptors associated with each, called only once at attach.
	+ * Parse the packet type to determine the appropriate hash
	************************************************************************/
	-int
	-ixgbe_allocate_queues(struct adapter *adapter)
	-{
	- device_t dev = adapter->dev;
	- struct ix_queue *que;
	- struct tx_ring *txr;
	- struct rx_ring *rxr;
	- int rsize, tsize, error = IXGBE_SUCCESS;
	- int txconf = 0, rxconf = 0;
	-
	- /* First, allocate the top level queue structs */
	- adapter->queues = (struct ix_queue )malloc(sizeof(struct ix_queue)
	- adapter->num_queues, M_DEVBUF, M_NOWAIT \| M_ZERO);
	- if (adapter->queues == NULL) {
	- device_printf(dev, "Unable to allocate queue memory\n");
	- error = ENOMEM;
	- goto fail;
	- }
	-
	- /* Second, allocate the TX ring struct memory */
	- adapter->tx_rings = (struct tx_ring )malloc(sizeof(struct tx_ring)
	- adapter->num_queues, M_DEVBUF, M_NOWAIT \| M_ZERO);
	- if (adapter->tx_rings == NULL) {
	- device_printf(dev, "Unable to allocate TX ring memory\n");
	- error = ENOMEM;
	- goto tx_fail;
	- }
	-
	- /* Third, allocate the RX ring */
	- adapter->rx_rings = (struct rx_ring )malloc(sizeof(struct rx_ring)
	- adapter->num_queues, M_DEVBUF, M_NOWAIT \| M_ZERO);
	- if (adapter->rx_rings == NULL) {
	- device_printf(dev, "Unable to allocate RX ring memory\n");
	- error = ENOMEM;
	- goto rx_fail;
	- }
	-
	- /* For the ring itself */
	- tsize = roundup2(adapter->num_tx_desc * sizeof(union ixgbe_adv_tx_desc),
	- DBA_ALIGN);
	-
	- /*
	- * Now set up the TX queues, txconf is needed to handle the
	- * possibility that things fail midcourse and we need to
	- * undo memory gracefully
	- */
	- for (int i = 0; i < adapter->num_queues; i++, txconf++) {
	- /* Set up some basics */
	- txr = &adapter->tx_rings[i];
	- txr->adapter = adapter;
	- txr->br = NULL;
	- /* In case SR-IOV is enabled, align the index properly */
	- txr->me = ixgbe_vf_que_index(adapter->iov_mode, adapter->pool,
	- i);
	- txr->num_desc = adapter->num_tx_desc;
	-
	- /* Initialize the TX side lock */
	- snprintf(txr->mtx_name, sizeof(txr->mtx_name), "%s:tx(%d)",
	- device_get_nameunit(dev), txr->me);
	- mtx_init(&txr->tx_mtx, txr->mtx_name, NULL, MTX_DEF);
	-
	- if (ixgbe_dma_malloc(adapter, tsize, &txr->txdma,
	- BUS_DMA_NOWAIT)) {
	- device_printf(dev,
	- "Unable to allocate TX Descriptor memory\n");
	- error = ENOMEM;
	- goto err_tx_desc;
	- }
	- txr->tx_base = (union ixgbe_adv_tx_desc *)txr->txdma.dma_vaddr;
	- bzero((void *)txr->tx_base, tsize);
	-
	- /* Now allocate transmit buffers for the ring */
	- if (ixgbe_allocate_transmit_buffers(txr)) {
	- device_printf(dev,
	- "Critical Failure setting up transmit buffers\n");
	- error = ENOMEM;
	- goto err_tx_desc;
	- }
	- if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) {
	- /* Allocate a buf ring */
	- txr->br = buf_ring_alloc(IXGBE_BR_SIZE, M_DEVBUF,
	- M_WAITOK, &txr->tx_mtx);
	- if (txr->br == NULL) {
	- device_printf(dev,
	- "Critical Failure setting up buf ring\n");
	- error = ENOMEM;
	- goto err_tx_desc;
	- }
	- }
	- }
	-
	- /*
	- * Next the RX queues...
	- */
	- rsize = roundup2(adapter->num_rx_desc * sizeof(union ixgbe_adv_rx_desc),
	- DBA_ALIGN);
	- for (int i = 0; i < adapter->num_queues; i++, rxconf++) {
	- rxr = &adapter->rx_rings[i];
	- /* Set up some basics */
	- rxr->adapter = adapter;
	- /* In case SR-IOV is enabled, align the index properly */
	- rxr->me = ixgbe_vf_que_index(adapter->iov_mode, adapter->pool,
	- i);
	- rxr->num_desc = adapter->num_rx_desc;
	-
	- /* Initialize the RX side lock */
	- snprintf(rxr->mtx_name, sizeof(rxr->mtx_name), "%s:rx(%d)",
	- device_get_nameunit(dev), rxr->me);
	- mtx_init(&rxr->rx_mtx, rxr->mtx_name, NULL, MTX_DEF);
	-
	- if (ixgbe_dma_malloc(adapter, rsize, &rxr->rxdma,
	- BUS_DMA_NOWAIT)) {
	- device_printf(dev,
	- "Unable to allocate RxDescriptor memory\n");
	- error = ENOMEM;
	- goto err_rx_desc;
	- }
	- rxr->rx_base = (union ixgbe_adv_rx_desc *)rxr->rxdma.dma_vaddr;
	- bzero((void *)rxr->rx_base, rsize);
	-
	- /* Allocate receive buffers for the ring */
	- if (ixgbe_allocate_receive_buffers(rxr)) {
	- device_printf(dev,
	- "Critical Failure setting up receive buffers\n");
	- error = ENOMEM;
	- goto err_rx_desc;
	- }
	- }
	-
	- /*
	- * Finally set up the queue holding structs
	- */
	- for (int i = 0; i < adapter->num_queues; i++) {
	- que = &adapter->queues[i];
	- que->adapter = adapter;
	- que->me = i;
	- que->txr = &adapter->tx_rings[i];
	- que->rxr = &adapter->rx_rings[i];
	+static int
	+ixgbe_determine_rsstype(u16 pkt_info)
	+{
	+ switch (pkt_info & IXGBE_RXDADV_RSSTYPE_MASK) {
	+ case IXGBE_RXDADV_RSSTYPE_IPV4_TCP:
	+ return M_HASHTYPE_RSS_TCP_IPV4;
	+ case IXGBE_RXDADV_RSSTYPE_IPV4:
	+ return M_HASHTYPE_RSS_IPV4;
	+ case IXGBE_RXDADV_RSSTYPE_IPV6_TCP:
	+ return M_HASHTYPE_RSS_TCP_IPV6;
	+ case IXGBE_RXDADV_RSSTYPE_IPV6_EX:
	+ return M_HASHTYPE_RSS_IPV6_EX;
	+ case IXGBE_RXDADV_RSSTYPE_IPV6:
	+ return M_HASHTYPE_RSS_IPV6;
	+ case IXGBE_RXDADV_RSSTYPE_IPV6_TCP_EX:
	+ return M_HASHTYPE_RSS_TCP_IPV6_EX;
	+ case IXGBE_RXDADV_RSSTYPE_IPV4_UDP:
	+ return M_HASHTYPE_RSS_UDP_IPV4;
	+ case IXGBE_RXDADV_RSSTYPE_IPV6_UDP:
	+ return M_HASHTYPE_RSS_UDP_IPV6;
	+ case IXGBE_RXDADV_RSSTYPE_IPV6_UDP_EX:
	+ return M_HASHTYPE_RSS_UDP_IPV6_EX;
	+ default:
	+ return M_HASHTYPE_OPAQUE;
	}
	-
	- return (0);
	-
	-err_rx_desc:
	- for (rxr = adapter->rx_rings; rxconf > 0; rxr++, rxconf--)
	- ixgbe_dma_free(adapter, &rxr->rxdma);
	-err_tx_desc:
	- for (txr = adapter->tx_rings; txconf > 0; txr++, txconf--)
	- ixgbe_dma_free(adapter, &txr->txdma);
	- free(adapter->rx_rings, M_DEVBUF);
	-rx_fail:
	- free(adapter->tx_rings, M_DEVBUF);
	-tx_fail:
	- free(adapter->queues, M_DEVBUF);
	-fail:
	- return (error);
	-} /* ixgbe_allocate_queues */
	+} /* ixgbe_determine_rsstype */
	Index: sys/dev/ixgbe/ixgbe.h
	===================================================================
	--- sys/dev/ixgbe/ixgbe.h
	+++ sys/dev/ixgbe/ixgbe.h
	@@ -57,20 +57,13 @@
	#include <net/if_dl.h>
	#include <net/if_media.h>

	-#include <net/bpf.h>
	#include <net/if_types.h>
	#include <net/if_vlan_var.h>
	+#include <net/iflib.h>

	#include <netinet/in_systm.h>
	#include <netinet/in.h>
	#include <netinet/if_ether.h>
	-#include <netinet/ip.h>
	-#include <netinet/ip6.h>
	-#include <netinet/tcp.h>
	-#include <netinet/tcp_lro.h>
	-#include <netinet/udp.h>
	-
	-#include <machine/in_cksum.h>

	#include <sys/bus.h>
	#include <machine/bus.h>
	@@ -84,7 +77,7 @@
	#include <sys/proc.h>
	#include <sys/sysctl.h>
	#include <sys/endian.h>
	-#include <sys/taskqueue.h>
	+#include <sys/gtaskqueue.h>
	#include <sys/pcpu.h>
	#include <sys/smp.h>
	#include <machine/smp.h>
	@@ -105,7 +98,7 @@
	* bytes. Performance tests have show the 2K value to be optimal for top
	* performance.
	*/
	-#define DEFAULT_TXD 1024
	+#define DEFAULT_TXD 2048
	#define PERFORM_TXD 2048
	#define MAX_TXD 4096
	#define MIN_TXD 64
	@@ -120,7 +113,7 @@
	* against the system mbuf pool limit, you can tune nmbclusters
	* to adjust for this.
	*/
	-#define DEFAULT_RXD 1024
	+#define DEFAULT_RXD 2048
	#define PERFORM_RXD 2048
	#define MAX_RXD 4096
	#define MIN_RXD 64
	@@ -218,6 +211,11 @@
	#define CSUM_OFFLOAD (CSUM_IP\|CSUM_TCP\|CSUM_UDP)
	#endif

	+#define IXGBE_CAPS (IFCAP_HWCSUM \| IFCAP_HWCSUM_IPV6 \| IFCAP_TSO \| \
	+ IFCAP_LRO \| IFCAP_VLAN_HWTAGGING \| IFCAP_VLAN_HWTSO \| \
	+ IFCAP_VLAN_HWCSUM \| IFCAP_JUMBO_MTU \| IFCAP_VLAN_MTU \| \
	+ IFCAP_HWSTATS \| IFCAP_VLAN_HWFILTER \| IFCAP_WOL)
	+
	/* Backward compatibility items for very old versions */
	#ifndef pci_find_cap
	#define pci_find_cap pci_find_extcap
	@@ -240,7 +238,6 @@
	IXGBE_EITR_ITR_INT_MASK)


	-
	/************************************************************************
	* vendor_info_array
	*
	@@ -261,23 +258,8 @@
	u32 log;
	};

	-struct ixgbe_tx_buf {
	- union ixgbe_adv_tx_desc *eop;
	- struct mbuf *m_head;
	- bus_dmamap_t map;
	-};
	-
	-struct ixgbe_rx_buf {
	- struct mbuf *buf;
	- struct mbuf *fmp;
	- bus_dmamap_t pmap;
	- u_int flags;
	-#define IXGBE_RX_COPY 0x01
	- uint64_t addr;
	-};

	/*
	- * Bus dma allocation structure used by ixgbe_dma_malloc and ixgbe_dma_free
	*/
	struct ixgbe_dma_alloc {
	bus_addr_t dma_paddr;
	@@ -294,47 +276,19 @@
	u32 vmdq;
	};

	-/*
	- * Driver queue struct: this is the interrupt container
	- * for the associated tx and rx ring.
	- */
	-struct ix_queue {
	- struct adapter *adapter;
	- u32 msix; /* This queue's MSI-X vector */
	- u32 eims; /* This queue's EIMS bit */
	- u32 eitr_setting;
	- u32 me;
	- struct resource *res;
	- void *tag;
	- int busy;
	- struct tx_ring *txr;
	- struct rx_ring *rxr;
	- struct task que_task;
	- struct taskqueue *tq;
	- u64 irqs;
	-};
	-
	/*
	* The transmit ring, one per queue
	*/
	struct tx_ring {
	struct adapter *adapter;
	- struct mtx tx_mtx;
	- u32 me;
	- u32 tail;
	- int busy;
	union ixgbe_adv_tx_desc *tx_base;
	- struct ixgbe_tx_buf *tx_buffers;
	- struct ixgbe_dma_alloc txdma;
	- volatile u16 tx_avail;
	- u16 next_avail_desc;
	- u16 next_to_clean;
	- u16 num_desc;
	- u32 txd_cmd;
	- bus_dma_tag_t txtag;
	- char mtx_name[16];
	- struct buf_ring *br;
	- struct task txq_task;
	+ uint64_t tx_paddr;
	+ u32 tail;
	+ qidx_t *tx_rsq;
	+ qidx_t tx_rs_cidx;
	+ qidx_t tx_rs_pidx;
	+ qidx_t tx_cidx_processed;
	+ uint8_t me;

	/* Flow Director */
	u16 atr_sample;
	@@ -344,9 +298,6 @@
	u32 packets;
	/* Soft Stats */
	u64 tso_tx;
	- u64 no_tx_map_avail;
	- u64 no_tx_dma_setup;
	- u64 no_desc_avail;
	u64 total_packets;
	};

	@@ -355,22 +306,14 @@
	* The Receive ring, one per rx queue
	*/
	struct rx_ring {
	+ struct ix_rx_queue *que;
	struct adapter *adapter;
	- struct mtx rx_mtx;
	u32 me;
	u32 tail;
	union ixgbe_adv_rx_desc *rx_base;
	- struct ixgbe_dma_alloc rxdma;
	- struct lro_ctrl lro;
	- bool lro_enabled;
	bool hw_rsc;
	bool vtag_strip;
	- u16 next_to_refresh;
	- u16 next_to_check;
	- u16 num_desc;
	- u16 mbuf_sz;
	- char mtx_name[16];
	- struct ixgbe_rx_buf *rx_buffers;
	+ uint64_t rx_paddr;
	bus_dma_tag_t ptag;

	u32 bytes; /* Used for AIM calc */
	@@ -388,12 +331,35 @@
	u64 flm;
	};

	+/*
	+ * Driver queue struct: this is the interrupt container
	+ * for the associated tx and rx ring.
	+ */
	+struct ix_rx_queue {
	+ struct adapter *adapter;
	+ u32 msix; /* This queue's MSIX vector */
	+ u32 eims; /* This queue's EIMS bit */
	+ u32 eitr_setting;
	+ struct resource *res;
	+ void *tag;
	+ int busy;
	+ struct rx_ring rxr;
	+ struct if_irq que_irq;
	+ u64 irqs;
	+};
	+
	+struct ix_tx_queue {
	+ struct adapter *adapter;
	+ u32 msix; /* This queue's MSIX vector */
	+ struct tx_ring txr;
	+};
	+
	#define IXGBE_MAX_VF_MC 30 /* Max number of multicast entries */

	struct ixgbe_vf {
	u_int pool;
	u_int rar_index;
	- u_int max_frame_size;
	+ u_int maximum_frame_size;
	uint32_t flags;
	uint8_t ether_addr[ETHER_ADDR_LEN];
	uint16_t mc_hash[IXGBE_MAX_VF_MC];
	@@ -407,33 +373,32 @@
	struct adapter {
	struct ixgbe_hw hw;
	struct ixgbe_osdep osdep;
	+ if_ctx_t ctx;
	+ if_softc_ctx_t shared;
	+#define num_tx_queues shared->isc_ntxqsets
	+#define num_rx_queues shared->isc_nrxqsets
	+#define max_frame_size shared->isc_max_frame_size
	+#define intr_type shared->isc_intr

	device_t dev;
	struct ifnet *ifp;

	struct resource *pci_mem;
	- struct resource *msix_mem;

	/*
	* Interrupt resources: this set is
	* either used for legacy, or for Link
	* when doing MSI-X
	*/
	+ struct if_irq irq;
	void *tag;
	struct resource *res;

	- struct ifmedia media;
	- struct callout timer;
	- int link_rid;
	+ struct ifmedia *media;
	int if_flags;
	-
	- struct mtx core_mtx;
	-
	- eventhandler_tag vlan_attach;
	- eventhandler_tag vlan_detach;
	+ int msix;

	u16 num_vlans;
	- u16 num_queues;

	/*
	* Shadow VFTA table, this is needed because
	@@ -447,7 +412,6 @@
	int advertise; /* link speeds */
	int enable_aim; /* adaptive interrupt moderation */
	bool link_active;
	- u16 max_frame_size;
	u16 num_segs;
	u32 link_speed;
	bool link_up;
	@@ -464,17 +428,15 @@

	/* Support for pluggable optics */
	bool sfp_probe;
	- struct task link_task; /* Link tasklet */
	- struct task mod_task; /* SFP tasklet */
	- struct task msf_task; /* Multispeed Fiber */
	- struct task mbx_task; /* VF -> PF mailbox interrupt */
	+ struct grouptask mod_task; /* SFP tasklet */
	+ struct grouptask msf_task; /* Multispeed Fiber */
	+ struct grouptask mbx_task; /* VF -> PF mailbox interrupt */

	/* Flow Director */
	int fdir_reinit;
	- struct task fdir_task;
	+ struct grouptask fdir_task;

	- struct task phy_task; /* PHY intr tasklet */
	- struct taskqueue *tq;
	+ struct grouptask phy_task; /* PHY intr tasklet */

	/*
	* Queues:
	@@ -482,24 +444,9 @@
	* and RX/TX pair or rings associated
	* with it.
	*/
	- struct ix_queue *queues;
	-
	- /*
	- * Transmit rings
	- * Allocated at run time, an array of rings
	- */
	- struct tx_ring *tx_rings;
	- u32 num_tx_desc;
	- u32 tx_process_limit;
	-
	- /*
	- * Receive rings
	- * Allocated at run time, an array of rings
	- */
	- struct rx_ring *rx_rings;
	- u64 active_queues;
	- u32 num_rx_desc;
	- u32 rx_process_limit;
	+ struct ix_tx_queue *tx_queues;
	+ struct ix_rx_queue *rx_queues;
	+ u64 active_queues;

	/* Multicast array memory */
	struct ixgbe_mc_addr *mta;
	@@ -513,13 +460,8 @@
	/* Bypass */
	struct ixgbe_bp_data bypass;

	- /* Netmap */
	- void (init_locked)(struct adapter );
	- void (stop_locked)(void );
	-
	/* Misc stats maintained by the driver */
	unsigned long dropped_pkts;
	- unsigned long mbuf_defrag_failed;
	unsigned long mbuf_header_failed;
	unsigned long mbuf_packet_failed;
	unsigned long watchdog_events;
	@@ -546,29 +488,12 @@
	u32 feat_en;
	};

	-
	/* Precision Time Sync (IEEE 1588) defines */
	#define ETHERTYPE_IEEE1588 0x88F7
	#define PICOSECS_PER_TICK 20833
	#define TSYNC_UDP_PORT 319 /* UDP port for the protocol */
	#define IXGBE_ADVTXD_TSTAMP 0x00080000

	-
	-#define IXGBE_CORE_LOCK_INIT(_sc, _name) \
	- mtx_init(&(_sc)->core_mtx, _name, "IXGBE Core Lock", MTX_DEF)
	-#define IXGBE_CORE_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->core_mtx)
	-#define IXGBE_TX_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->tx_mtx)
	-#define IXGBE_RX_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->rx_mtx)
	-#define IXGBE_CORE_LOCK(_sc) mtx_lock(&(_sc)->core_mtx)
	-#define IXGBE_TX_LOCK(_sc) mtx_lock(&(_sc)->tx_mtx)
	-#define IXGBE_TX_TRYLOCK(_sc) mtx_trylock(&(_sc)->tx_mtx)
	-#define IXGBE_RX_LOCK(_sc) mtx_lock(&(_sc)->rx_mtx)
	-#define IXGBE_CORE_UNLOCK(_sc) mtx_unlock(&(_sc)->core_mtx)
	-#define IXGBE_TX_UNLOCK(_sc) mtx_unlock(&(_sc)->tx_mtx)
	-#define IXGBE_RX_UNLOCK(_sc) mtx_unlock(&(_sc)->rx_mtx)
	-#define IXGBE_CORE_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->core_mtx, MA_OWNED)
	-#define IXGBE_TX_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->tx_mtx, MA_OWNED)
	-
	/* For backward compatibility */
	#if !defined(PCIER_LINK_STA)
	#define PCIER_LINK_STA PCIR_EXPRESS_LINK_STA
	@@ -625,34 +550,13 @@
	drbr_needs_enqueue(struct ifnet ifp, struct buf_ring br)
	{
	#ifdef ALTQ
	- if (ALTQ_IS_ENABLED(&ifp->if_snd))
	- return (1);
	+ if (ALTQ_IS_ENABLED(&ifp->if_snd))
	+ return (1);
	#endif
	- return (!buf_ring_empty(br));
	+ return (!buf_ring_empty(br));
	}
	#endif

	-/*
	- * Find the number of unrefreshed RX descriptors
	- */
	-static inline u16
	-ixgbe_rx_unrefreshed(struct rx_ring *rxr)
	-{
	- if (rxr->next_to_check > rxr->next_to_refresh)
	- return (rxr->next_to_check - rxr->next_to_refresh - 1);
	- else
	- return ((rxr->num_desc + rxr->next_to_check) -
	- rxr->next_to_refresh - 1);
	-}
	-
	-static inline int
	-ixgbe_legacy_ring_empty(struct ifnet ifp, struct buf_ring dummy)
	-{
	- UNREFERENCED_1PARAMETER(dummy);
	-
	- return IFQ_DRV_IS_EMPTY(&ifp->if_snd);
	-}
	-
	/*
	* This checks for a zero mac addr, something that will be likely
	* unless the Admin on the Host has created one.
	@@ -670,25 +574,16 @@
	}

	/* Shared Prototypes */
	-void ixgbe_legacy_start(struct ifnet *);
	-int ixgbe_legacy_start_locked(struct ifnet , struct tx_ring );
	-int ixgbe_mq_start(struct ifnet , struct mbuf );
	-int ixgbe_mq_start_locked(struct ifnet , struct tx_ring );
	-void ixgbe_qflush(struct ifnet *);
	-void ixgbe_deferred_mq_start(void *, int);

	int ixgbe_allocate_queues(struct adapter *);
	int ixgbe_setup_transmit_structures(struct adapter *);
	void ixgbe_free_transmit_structures(struct adapter *);
	int ixgbe_setup_receive_structures(struct adapter *);
	void ixgbe_free_receive_structures(struct adapter *);
	-void ixgbe_txeof(struct tx_ring *);
	-bool ixgbe_rxeof(struct ix_queue *);
	+int ixgbe_get_regs(SYSCTL_HANDLER_ARGS);

	#include "ixgbe_bypass.h"
	-#include "ixgbe_sriov.h"
	#include "ixgbe_fdir.h"
	#include "ixgbe_rss.h"
	-#include "ixgbe_netmap.h"

	#endif /* _IXGBE_H_ */
	Index: sys/dev/ixgbe/ixgbe_common.c
	===================================================================
	--- sys/dev/ixgbe/ixgbe_common.c
	+++ sys/dev/ixgbe/ixgbe_common.c
	@@ -222,6 +222,7 @@
	ERROR_REPORT2(IXGBE_ERROR_UNSUPPORTED,
	"Device %x does not support flow control autoneg",
	hw->device_id);
	+
	return supported;
	}

	@@ -2000,7 +2001,7 @@

	usec_delay(5);
	ixgbe_standby_eeprom(hw);
	- };
	+ }

	/*
	* On some parts, SPI write time could vary from 0-20mSec on 3.3V
	@@ -2086,7 +2087,7 @@
	* EEPROM
	*/
	mask = mask >> 1;
	- };
	+ }

	/* We leave the "DI" bit set to "0" when we leave this routine. */
	eec &= ~IXGBE_EEC_DI;
	@@ -3517,7 +3518,6 @@
	if (index > 3)
	return IXGBE_ERR_PARAM;

	-
	ret_val = hw->mac.ops.prot_autoc_read(hw, &locked, &autoc_reg);
	if (ret_val != IXGBE_SUCCESS)
	goto out;
	@@ -3714,7 +3714,7 @@
	* @vmdq: VMDq pool to assign
	*
	* Puts an ethernet address into a receive address register, or
	- * finds the rar that it is aleady in; adds to the pool list
	+ * finds the rar that it is already in; adds to the pool list
	**/
	s32 ixgbe_insert_mac_addr_generic(struct ixgbe_hw hw, u8 addr, u32 vmdq)
	{
	@@ -4125,7 +4125,7 @@
	for (offset = 0; offset < IXGBE_VLVF_ENTRIES; offset++) {
	IXGBE_WRITE_REG(hw, IXGBE_VLVF(offset), 0);
	IXGBE_WRITE_REG(hw, IXGBE_VLVFB(offset * 2), 0);
	- IXGBE_WRITE_REG(hw, IXGBE_VLVFB(offset * 2 + 1), 0);
	+ IXGBE_WRITE_REG(hw, IXGBE_VLVFB((offset * 2) + 1), 0);
	}

	return IXGBE_SUCCESS;
	Index: sys/dev/ixgbe/ixgbe_fdir.h
	===================================================================
	--- sys/dev/ixgbe/ixgbe_fdir.h
	+++ sys/dev/ixgbe/ixgbe_fdir.h
	@@ -52,7 +52,7 @@

	#endif

	-void ixgbe_reinit_fdir(void *, int);
	+void ixgbe_reinit_fdir(void *);
	void ixgbe_atr(struct tx_ring , struct mbuf );

	#endif /* _IXGBE_FDIR_H_ */
	Index: sys/dev/ixgbe/ixgbe_netmap.h
	===================================================================
	--- sys/dev/ixgbe/ixgbe_netmap.h
	+++ sys/dev/ixgbe/ixgbe_netmap.h
	@@ -1,59 +0,0 @@
	-/******************************************************************************
	-
	- Copyright (c) 2001-2017, Intel Corporation
	- All rights reserved.
	-
	- Redistribution and use in source and binary forms, with or without
	- modification, are permitted provided that the following conditions are met:
	-
	- 1. Redistributions of source code must retain the above copyright notice,
	- this list of conditions and the following disclaimer.
	-
	- 2. Redistributions in binary form must reproduce the above copyright
	- notice, this list of conditions and the following disclaimer in the
	- documentation and/or other materials provided with the distribution.
	-
	- 3. Neither the name of the Intel Corporation nor the names of its
	- contributors may be used to endorse or promote products derived from
	- this software without specific prior written permission.
	-
	- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	- POSSIBILITY OF SUCH DAMAGE.
	-
	-******************************************************************************/
	-/$FreeBSD$/
	-
	-
	-#ifndef _IXGBE_NETMAP_H_
	-#define _IXGBE_NETMAP_H_
	-
	-#ifdef DEV_NETMAP
	-
	-#include <net/netmap.h>
	-#include <sys/selinfo.h>
	-#include <dev/netmap/netmap_kern.h>
	-
	-extern int ix_crcstrip;
	-
	-/*
	- * ixgbe_netmap.c contains functions for netmap
	- * support that extend the standard driver. See additional
	- * comments in ixgbe_netmap.c.
	- */
	-void ixgbe_netmap_attach(struct adapter *adapter);
	-
	-#else
	-#define ixgbe_netmap_attach(a)
	-#define netmap_detach(a)
	-#endif /* DEV_NETMAP */
	-
	-#endif /* _IXGBE_NETMAP_H_ */
	Index: sys/dev/ixgbe/ixgbe_netmap.c
	===================================================================
	--- sys/dev/ixgbe/ixgbe_netmap.c
	+++ sys/dev/ixgbe/ixgbe_netmap.c
	@@ -1,521 +0,0 @@
	-/******************************************************************************
	-
	- Copyright (c) 2001-2017, Intel Corporation
	- All rights reserved.
	-
	- Redistribution and use in source and binary forms, with or without
	- modification, are permitted provided that the following conditions are met:
	-
	- 1. Redistributions of source code must retain the above copyright notice,
	- this list of conditions and the following disclaimer.
	-
	- 2. Redistributions in binary form must reproduce the above copyright
	- notice, this list of conditions and the following disclaimer in the
	- documentation and/or other materials provided with the distribution.
	-
	- 3. Neither the name of the Intel Corporation nor the names of its
	- contributors may be used to endorse or promote products derived from
	- this software without specific prior written permission.
	-
	- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	- POSSIBILITY OF SUCH DAMAGE.
	-
	-******************************************************************************/
	-/$FreeBSD$/
	-
	-/*
	- * Copyright (C) 2011-2014 Matteo Landi, Luigi Rizzo. All rights reserved.
	- *
	- * Redistribution and use in source and binary forms, with or without
	- * modification, are permitted provided that the following conditions
	- * are met:
	- * 1. Redistributions of source code must retain the above copyright
	- * notice, this list of conditions and the following disclaimer.
	- * 2. Redistributions in binary form must reproduce the above copyright
	- * notice, this list of conditions and the following disclaimer in the
	- * documentation and/or other materials provided with the distribution.
	- *
	- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	- * SUCH DAMAGE.
	- */
	-
	-/*
	- * $FreeBSD$
	- *
	- * netmap support for: ixgbe
	- *
	- * This file is meant to be a reference on how to implement
	- * netmap support for a network driver.
	- * This file contains code but only static or inline functions used
	- * by a single driver. To avoid replication of code we just #include
	- * it near the beginning of the standard driver.
	- */
	-
	-#ifdef DEV_NETMAP
	-/*
	- * Some drivers may need the following headers. Others
	- * already include them by default
	-
	-#include <vm/vm.h>
	-#include <vm/pmap.h>
	-
	- */
	-#include "ixgbe.h"
	-
	-/*
	- * device-specific sysctl variables:
	- *
	- * ix_crcstrip: 0: keep CRC in rx frames (default), 1: strip it.
	- * During regular operations the CRC is stripped, but on some
	- * hardware reception of frames not multiple of 64 is slower,
	- * so using crcstrip=0 helps in benchmarks.
	- *
	- * ix_rx_miss, ix_rx_miss_bufs:
	- * count packets that might be missed due to lost interrupts.
	- */
	-SYSCTL_DECL(_dev_netmap);
	-static int ix_rx_miss, ix_rx_miss_bufs;
	-int ix_crcstrip;
	-SYSCTL_INT(_dev_netmap, OID_AUTO, ix_crcstrip,
	- CTLFLAG_RW, &ix_crcstrip, 0, "strip CRC on rx frames");
	-SYSCTL_INT(_dev_netmap, OID_AUTO, ix_rx_miss,
	- CTLFLAG_RW, &ix_rx_miss, 0, "potentially missed rx intr");
	-SYSCTL_INT(_dev_netmap, OID_AUTO, ix_rx_miss_bufs,
	- CTLFLAG_RW, &ix_rx_miss_bufs, 0, "potentially missed rx intr bufs");
	-
	-
	-static void
	-set_crcstrip(struct ixgbe_hw *hw, int onoff)
	-{
	- /* crc stripping is set in two places:
	- * IXGBE_HLREG0 (modified on init_locked and hw reset)
	- * IXGBE_RDRXCTL (set by the original driver in
	- * ixgbe_setup_hw_rsc() called in init_locked.
	- * We disable the setting when netmap is compiled in).
	- * We update the values here, but also in ixgbe.c because
	- * init_locked sometimes is called outside our control.
	- */
	- uint32_t hl, rxc;
	-
	- hl = IXGBE_READ_REG(hw, IXGBE_HLREG0);
	- rxc = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
	- if (netmap_verbose)
	- D("%s read HLREG 0x%x rxc 0x%x",
	- onoff ? "enter" : "exit", hl, rxc);
	- /* hw requirements ... */
	- rxc &= ~IXGBE_RDRXCTL_RSCFRSTSIZE;
	- rxc \|= IXGBE_RDRXCTL_RSCACKC;
	- if (onoff && !ix_crcstrip) {
	- /* keep the crc. Fast rx */
	- hl &= ~IXGBE_HLREG0_RXCRCSTRP;
	- rxc &= ~IXGBE_RDRXCTL_CRCSTRIP;
	- } else {
	- /* reset default mode */
	- hl \|= IXGBE_HLREG0_RXCRCSTRP;
	- rxc \|= IXGBE_RDRXCTL_CRCSTRIP;
	- }
	- if (netmap_verbose)
	- D("%s write HLREG 0x%x rxc 0x%x",
	- onoff ? "enter" : "exit", hl, rxc);
	- IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hl);
	- IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, rxc);
	-}
	-
	-
	-/*
	- * Register/unregister. We are already under netmap lock.
	- * Only called on the first register or the last unregister.
	- */
	-static int
	-ixgbe_netmap_reg(struct netmap_adapter *na, int onoff)
	-{
	- struct ifnet *ifp = na->ifp;
	- struct adapter *adapter = ifp->if_softc;
	-
	- IXGBE_CORE_LOCK(adapter);
	- adapter->stop_locked(adapter);
	-
	- set_crcstrip(&adapter->hw, onoff);
	- /* enable or disable flags and callbacks in na and ifp */
	- if (onoff) {
	- nm_set_native_flags(na);
	- } else {
	- nm_clear_native_flags(na);
	- }
	- adapter->init_locked(adapter); /* also enables intr */
	- set_crcstrip(&adapter->hw, onoff); // XXX why twice ?
	- IXGBE_CORE_UNLOCK(adapter);
	- return (ifp->if_drv_flags & IFF_DRV_RUNNING ? 0 : 1);
	-}
	-
	-
	-/*
	- * Reconcile kernel and user view of the transmit ring.
	- *
	- * All information is in the kring.
	- * Userspace wants to send packets up to the one before kring->rhead,
	- * kernel knows kring->nr_hwcur is the first unsent packet.
	- *
	- * Here we push packets out (as many as possible), and possibly
	- * reclaim buffers from previously completed transmission.
	- *
	- * The caller (netmap) guarantees that there is only one instance
	- * running at any time. Any interference with other driver
	- * methods should be handled by the individual drivers.
	- */
	-static int
	-ixgbe_netmap_txsync(struct netmap_kring *kring, int flags)
	-{
	- struct netmap_adapter *na = kring->na;
	- struct ifnet *ifp = na->ifp;
	- struct netmap_ring *ring = kring->ring;
	- u_int nm_i; /* index into the netmap ring */
	- u_int nic_i; /* index into the NIC ring */
	- u_int n;
	- u_int const lim = kring->nkr_num_slots - 1;
	- u_int const head = kring->rhead;
	- /*
	- * interrupts on every tx packet are expensive so request
	- * them every half ring, or where NS_REPORT is set
	- */
	- u_int report_frequency = kring->nkr_num_slots >> 1;
	-
	- /* device-specific */
	- struct adapter *adapter = ifp->if_softc;
	- struct tx_ring *txr = &adapter->tx_rings[kring->ring_id];
	- int reclaim_tx;
	-
	- bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
	- BUS_DMASYNC_POSTREAD);
	-
	- /*
	- * First part: process new packets to send.
	- * nm_i is the current index in the netmap ring,
	- * nic_i is the corresponding index in the NIC ring.
	- * The two numbers differ because upon a *_init() we reset
	- * the NIC ring but leave the netmap ring unchanged.
	- * For the transmit ring, we have
	- *
	- * nm_i = kring->nr_hwcur
	- * nic_i = IXGBE_TDT (not tracked in the driver)
	- * and
	- * nm_i == (nic_i + kring->nkr_hwofs) % ring_size
	- *
	- * In this driver kring->nkr_hwofs >= 0, but for other
	- * drivers it might be negative as well.
	- */
	-
	- /*
	- * If we have packets to send (kring->nr_hwcur != kring->rhead)
	- * iterate over the netmap ring, fetch length and update
	- * the corresponding slot in the NIC ring. Some drivers also
	- * need to update the buffer's physical address in the NIC slot
	- * even NS_BUF_CHANGED is not set (PNMB computes the addresses).
	- *
	- * The netmap_reload_map() calls is especially expensive,
	- * even when (as in this case) the tag is 0, so do only
	- * when the buffer has actually changed.
	- *
	- * If possible do not set the report/intr bit on all slots,
	- * but only a few times per ring or when NS_REPORT is set.
	- *
	- * Finally, on 10G and faster drivers, it might be useful
	- * to prefetch the next slot and txr entry.
	- */
	-
	- nm_i = kring->nr_hwcur;
	- if (nm_i != head) { /* we have new packets to send */
	- nic_i = netmap_idx_k2n(kring, nm_i);
	-
	- __builtin_prefetch(&ring->slot[nm_i]);
	- __builtin_prefetch(&txr->tx_buffers[nic_i]);
	-
	- for (n = 0; nm_i != head; n++) {
	- struct netmap_slot *slot = &ring->slot[nm_i];
	- u_int len = slot->len;
	- uint64_t paddr;
	- void *addr = PNMB(na, slot, &paddr);
	-
	- /* device-specific */
	- union ixgbe_adv_tx_desc *curr = &txr->tx_base[nic_i];
	- struct ixgbe_tx_buf *txbuf = &txr->tx_buffers[nic_i];
	- int flags = (slot->flags & NS_REPORT \|\|
	- nic_i == 0 \|\| nic_i == report_frequency) ?
	- IXGBE_TXD_CMD_RS : 0;
	-
	- /* prefetch for next round */
	- __builtin_prefetch(&ring->slot[nm_i + 1]);
	- __builtin_prefetch(&txr->tx_buffers[nic_i + 1]);
	-
	- NM_CHECK_ADDR_LEN(na, addr, len);
	-
	- if (slot->flags & NS_BUF_CHANGED) {
	- /* buffer has changed, reload map */
	- netmap_reload_map(na, txr->txtag, txbuf->map, addr);
	- }
	- slot->flags &= ~(NS_REPORT \| NS_BUF_CHANGED);
	-
	- /* Fill the slot in the NIC ring. */
	- /* Use legacy descriptor, they are faster? */
	- curr->read.buffer_addr = htole64(paddr);
	- curr->read.olinfo_status = 0;
	- curr->read.cmd_type_len = htole32(len \| flags \|
	- IXGBE_ADVTXD_DCMD_IFCS \| IXGBE_TXD_CMD_EOP);
	-
	- /* make sure changes to the buffer are synced */
	- bus_dmamap_sync(txr->txtag, txbuf->map,
	- BUS_DMASYNC_PREWRITE);
	-
	- nm_i = nm_next(nm_i, lim);
	- nic_i = nm_next(nic_i, lim);
	- }
	- kring->nr_hwcur = head;
	-
	- /* synchronize the NIC ring */
	- bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
	- BUS_DMASYNC_PREREAD \| BUS_DMASYNC_PREWRITE);
	-
	- /* (re)start the tx unit up to slot nic_i (excluded) */
	- IXGBE_WRITE_REG(&adapter->hw, txr->tail, nic_i);
	- }
	-
	- /*
	- * Second part: reclaim buffers for completed transmissions.
	- * Because this is expensive (we read a NIC register etc.)
	- * we only do it in specific cases (see below).
	- */
	- if (flags & NAF_FORCE_RECLAIM) {
	- reclaim_tx = 1; /* forced reclaim */
	- } else if (!nm_kr_txempty(kring)) {
	- reclaim_tx = 0; /* have buffers, no reclaim */
	- } else {
	- /*
	- * No buffers available. Locate previous slot with
	- * REPORT_STATUS set.
	- * If the slot has DD set, we can reclaim space,
	- * otherwise wait for the next interrupt.
	- * This enables interrupt moderation on the tx
	- * side though it might reduce throughput.
	- */
	- struct ixgbe_legacy_tx_desc *txd =
	- (struct ixgbe_legacy_tx_desc *)txr->tx_base;
	-
	- nic_i = txr->next_to_clean + report_frequency;
	- if (nic_i > lim)
	- nic_i -= lim + 1;
	- // round to the closest with dd set
	- nic_i = (nic_i < kring->nkr_num_slots / 4 \|\|
	- nic_i >= kring->nkr_num_slots*3/4) ?
	- 0 : report_frequency;
	- reclaim_tx = txd[nic_i].upper.fields.status & IXGBE_TXD_STAT_DD; // XXX cpu_to_le32 ?
	- }
	- if (reclaim_tx) {
	- /*
	- * Record completed transmissions.
	- * We (re)use the driver's txr->next_to_clean to keep
	- * track of the most recently completed transmission.
	- *
	- * The datasheet discourages the use of TDH to find
	- * out the number of sent packets, but we only set
	- * REPORT_STATUS in a few slots so TDH is the only
	- * good way.
	- */
	- nic_i = IXGBE_READ_REG(&adapter->hw, IXGBE_TDH(kring->ring_id));
	- if (nic_i >= kring->nkr_num_slots) { /* XXX can it happen ? */
	- D("TDH wrap %d", nic_i);
	- nic_i -= kring->nkr_num_slots;
	- }
	- if (nic_i != txr->next_to_clean) {
	- /* some tx completed, increment avail */
	- txr->next_to_clean = nic_i;
	- kring->nr_hwtail = nm_prev(netmap_idx_n2k(kring, nic_i), lim);
	- }
	- }
	-
	- return 0;
	-}
	-
	-
	-/*
	- * Reconcile kernel and user view of the receive ring.
	- * Same as for the txsync, this routine must be efficient.
	- * The caller guarantees a single invocations, but races against
	- * the rest of the driver should be handled here.
	- *
	- * On call, kring->rhead is the first packet that userspace wants
	- * to keep, and kring->rcur is the wakeup point.
	- * The kernel has previously reported packets up to kring->rtail.
	- *
	- * If (flags & NAF_FORCE_READ) also check for incoming packets irrespective
	- * of whether or not we received an interrupt.
	- */
	-static int
	-ixgbe_netmap_rxsync(struct netmap_kring *kring, int flags)
	-{
	- struct netmap_adapter *na = kring->na;
	- struct ifnet *ifp = na->ifp;
	- struct netmap_ring *ring = kring->ring;
	- u_int nm_i; /* index into the netmap ring */
	- u_int nic_i; /* index into the NIC ring */
	- u_int n;
	- u_int const lim = kring->nkr_num_slots - 1;
	- u_int const head = kring->rhead;
	- int force_update = (flags & NAF_FORCE_READ) \|\| kring->nr_kflags & NKR_PENDINTR;
	-
	- /* device-specific */
	- struct adapter *adapter = ifp->if_softc;
	- struct rx_ring *rxr = &adapter->rx_rings[kring->ring_id];
	-
	- if (head > lim)
	- return netmap_ring_reinit(kring);
	-
	- /* XXX check sync modes */
	- bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
	- BUS_DMASYNC_POSTREAD \| BUS_DMASYNC_POSTWRITE);
	-
	- /*
	- * First part: import newly received packets.
	- *
	- * nm_i is the index of the next free slot in the netmap ring,
	- * nic_i is the index of the next received packet in the NIC ring,
	- * and they may differ in case if_init() has been called while
	- * in netmap mode. For the receive ring we have
	- *
	- * nic_i = rxr->next_to_check;
	- * nm_i = kring->nr_hwtail (previous)
	- * and
	- * nm_i == (nic_i + kring->nkr_hwofs) % ring_size
	- *
	- * rxr->next_to_check is set to 0 on a ring reinit
	- */
	- if (netmap_no_pendintr \|\| force_update) {
	- int crclen = (ix_crcstrip) ? 0 : 4;
	- uint16_t slot_flags = kring->nkr_slot_flags;
	-
	- nic_i = rxr->next_to_check; // or also k2n(kring->nr_hwtail)
	- nm_i = netmap_idx_n2k(kring, nic_i);
	-
	- for (n = 0; ; n++) {
	- union ixgbe_adv_rx_desc *curr = &rxr->rx_base[nic_i];
	- uint32_t staterr = le32toh(curr->wb.upper.status_error);
	-
	- if ((staterr & IXGBE_RXD_STAT_DD) == 0)
	- break;
	- ring->slot[nm_i].len = le16toh(curr->wb.upper.length) - crclen;
	- ring->slot[nm_i].flags = slot_flags;
	- bus_dmamap_sync(rxr->ptag,
	- rxr->rx_buffers[nic_i].pmap, BUS_DMASYNC_POSTREAD);
	- nm_i = nm_next(nm_i, lim);
	- nic_i = nm_next(nic_i, lim);
	- }
	- if (n) { /* update the state variables */
	- if (netmap_no_pendintr && !force_update) {
	- /* diagnostics */
	- ix_rx_miss ++;
	- ix_rx_miss_bufs += n;
	- }
	- rxr->next_to_check = nic_i;
	- kring->nr_hwtail = nm_i;
	- }
	- kring->nr_kflags &= ~NKR_PENDINTR;
	- }
	-
	- /*
	- * Second part: skip past packets that userspace has released.
	- * (kring->nr_hwcur to kring->rhead excluded),
	- * and make the buffers available for reception.
	- * As usual nm_i is the index in the netmap ring,
	- * nic_i is the index in the NIC ring, and
	- * nm_i == (nic_i + kring->nkr_hwofs) % ring_size
	- */
	- nm_i = kring->nr_hwcur;
	- if (nm_i != head) {
	- nic_i = netmap_idx_k2n(kring, nm_i);
	- for (n = 0; nm_i != head; n++) {
	- struct netmap_slot *slot = &ring->slot[nm_i];
	- uint64_t paddr;
	- void *addr = PNMB(na, slot, &paddr);
	-
	- union ixgbe_adv_rx_desc *curr = &rxr->rx_base[nic_i];
	- struct ixgbe_rx_buf *rxbuf = &rxr->rx_buffers[nic_i];
	-
	- if (addr == NETMAP_BUF_BASE(na)) /* bad buf */
	- goto ring_reset;
	-
	- if (slot->flags & NS_BUF_CHANGED) {
	- /* buffer has changed, reload map */
	- netmap_reload_map(na, rxr->ptag, rxbuf->pmap, addr);
	- slot->flags &= ~NS_BUF_CHANGED;
	- }
	- curr->wb.upper.status_error = 0;
	- curr->read.pkt_addr = htole64(paddr);
	- bus_dmamap_sync(rxr->ptag, rxbuf->pmap,
	- BUS_DMASYNC_PREREAD);
	- nm_i = nm_next(nm_i, lim);
	- nic_i = nm_next(nic_i, lim);
	- }
	- kring->nr_hwcur = head;
	-
	- bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
	- BUS_DMASYNC_PREREAD \| BUS_DMASYNC_PREWRITE);
	- /*
	- * IMPORTANT: we must leave one free slot in the ring,
	- * so move nic_i back by one unit
	- */
	- nic_i = nm_prev(nic_i, lim);
	- IXGBE_WRITE_REG(&adapter->hw, rxr->tail, nic_i);
	- }
	-
	- return 0;
	-
	-ring_reset:
	- return netmap_ring_reinit(kring);
	-}
	-
	-
	-/*
	- * The attach routine, called near the end of ixgbe_attach(),
	- * fills the parameters for netmap_attach() and calls it.
	- * It cannot fail, in the worst case (such as no memory)
	- * netmap mode will be disabled and the driver will only
	- * operate in standard mode.
	- */
	-void
	-ixgbe_netmap_attach(struct adapter *adapter)
	-{
	- struct netmap_adapter na;
	-
	- bzero(&na, sizeof(na));
	-
	- na.ifp = adapter->ifp;
	- na.na_flags = NAF_BDG_MAYSLEEP;
	- na.num_tx_desc = adapter->num_tx_desc;
	- na.num_rx_desc = adapter->num_rx_desc;
	- na.nm_txsync = ixgbe_netmap_txsync;
	- na.nm_rxsync = ixgbe_netmap_rxsync;
	- na.nm_register = ixgbe_netmap_reg;
	- na.num_tx_rings = na.num_rx_rings = adapter->num_queues;
	- netmap_attach(&na);
	-}
	-
	-#endif /* DEV_NETMAP */
	-
	-/* end of file */
	Index: sys/dev/ixgbe/ixgbe_osdep.h
	===================================================================
	--- sys/dev/ixgbe/ixgbe_osdep.h
	+++ sys/dev/ixgbe/ixgbe_osdep.h
	@@ -1,31 +1,31 @@
	/******************************************************************************

	- Copyright (c) 2001-2017, Intel Corporation
	+ Copyright (c) 2001-2017, Intel Corporation
	All rights reserved.
	-
	- Redistribution and use in source and binary forms, with or without
	+
	+ Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions are met:
	-
	- 1. Redistributions of source code must retain the above copyright notice,
	+
	+ 1. Redistributions of source code must retain the above copyright notice,
	this list of conditions and the following disclaimer.
	-
	- 2. Redistributions in binary form must reproduce the above copyright
	- notice, this list of conditions and the following disclaimer in the
	+
	+ 2. Redistributions in binary form must reproduce the above copyright
	+ notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.
	-
	- 3. Neither the name of the Intel Corporation nor the names of its
	- contributors may be used to endorse or promote products derived from
	+
	+ 3. Neither the name of the Intel Corporation nor the names of its
	+ contributors may be used to endorse or promote products derived from
	this software without specific prior written permission.
	-
	+
	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	POSSIBILITY OF SUCH DAMAGE.

	Index: sys/dev/ixgbe/ixgbe_osdep.c
	===================================================================
	--- sys/dev/ixgbe/ixgbe_osdep.c
	+++ sys/dev/ixgbe/ixgbe_osdep.c
	@@ -1,31 +1,31 @@
	/******************************************************************************

	- Copyright (c) 2001-2017, Intel Corporation
	+ Copyright (c) 2001-2017, Intel Corporation
	All rights reserved.
	-
	- Redistribution and use in source and binary forms, with or without
	+
	+ Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions are met:
	-
	- 1. Redistributions of source code must retain the above copyright notice,
	+
	+ 1. Redistributions of source code must retain the above copyright notice,
	this list of conditions and the following disclaimer.
	-
	- 2. Redistributions in binary form must reproduce the above copyright
	- notice, this list of conditions and the following disclaimer in the
	+
	+ 2. Redistributions in binary form must reproduce the above copyright
	+ notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.
	-
	- 3. Neither the name of the Intel Corporation nor the names of its
	- contributors may be used to endorse or promote products derived from
	+
	+ 3. Neither the name of the Intel Corporation nor the names of its
	+ contributors may be used to endorse or promote products derived from
	this software without specific prior written permission.
	-
	+
	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	POSSIBILITY OF SUCH DAMAGE.

	Index: sys/dev/ixgbe/ixgbe_phy.c
	===================================================================
	--- sys/dev/ixgbe/ixgbe_phy.c
	+++ sys/dev/ixgbe/ixgbe_phy.c
	@@ -1490,21 +1490,18 @@
	hw->phy.type = ixgbe_phy_sfp_intel;
	break;
	default:
	- if (cable_tech & IXGBE_SFF_DA_PASSIVE_CABLE)
	- hw->phy.type =
	- ixgbe_phy_sfp_passive_unknown;
	- else if (cable_tech & IXGBE_SFF_DA_ACTIVE_CABLE)
	- hw->phy.type =
	- ixgbe_phy_sfp_active_unknown;
	- else
	- hw->phy.type = ixgbe_phy_sfp_unknown;
	+ hw->phy.type = ixgbe_phy_sfp_unknown;
	break;
	}
	}

	/* Allow any DA cable vendor */
	if (cable_tech & (IXGBE_SFF_DA_PASSIVE_CABLE \|
	- IXGBE_SFF_DA_ACTIVE_CABLE)) {
	+ IXGBE_SFF_DA_ACTIVE_CABLE)) {
	+ if (cable_tech & IXGBE_SFF_DA_PASSIVE_CABLE)
	+ hw->phy.type = ixgbe_phy_sfp_passive_unknown;
	+ else if (cable_tech & IXGBE_SFF_DA_ACTIVE_CABLE)
	+ hw->phy.type = ixgbe_phy_sfp_active_unknown;
	status = IXGBE_SUCCESS;
	goto out;
	}
	Index: sys/dev/ixgbe/ixgbe_sriov.h
	===================================================================
	--- sys/dev/ixgbe/ixgbe_sriov.h
	+++ sys/dev/ixgbe/ixgbe_sriov.h
	@@ -41,6 +41,7 @@
	#include <sys/nv.h>
	#include <sys/iov_schema.h>
	#include <dev/pci/pci_iov.h>
	+#include <net/iflib.h>
	#include "ixgbe_mbx.h"

	#define IXGBE_VF_CTS (1 << 0) /* VF is clear to send. */
	@@ -57,7 +58,7 @@

	#define IXGBE_VF_GET_QUEUES_RESP_LEN 5

	-#define IXGBE_API_VER_1_0 0
	+#define IXGBE_API_VER_1_0 0
	#define IXGBE_API_VER_2_0 1 /* Solaris API. Not supported. */
	#define IXGBE_API_VER_1_1 2
	#define IXGBE_API_VER_UNKNOWN UINT16_MAX
	@@ -66,15 +67,16 @@
	#define IXGBE_32_VM 32
	#define IXGBE_64_VM 64

	-int ixgbe_add_vf(device_t, u16, const nvlist_t *);
	-int ixgbe_init_iov(device_t, u16, const nvlist_t *);
	-void ixgbe_uninit_iov(device_t);
	+int ixgbe_if_iov_vf_add(if_ctx_t, u16, const nvlist_t *);
	+int ixgbe_if_iov_init(if_ctx_t, u16, const nvlist_t *);
	+void ixgbe_if_iov_uninit(if_ctx_t);
	void ixgbe_initialize_iov(struct adapter *);
	void ixgbe_recalculate_max_frame(struct adapter *);
	void ixgbe_ping_all_vfs(struct adapter *);
	int ixgbe_pci_iov_detach(device_t);
	void ixgbe_define_iov_schemas(device_t, int *);
	void ixgbe_align_all_queue_indices(struct adapter *);
	+int ixgbe_vf_que_index(int, int, int);
	u32 ixgbe_get_mtqc(int);
	u32 ixgbe_get_mrqc(int);

	@@ -91,12 +93,13 @@
	#define ixgbe_pci_iov_detach(_a) 0
	#define ixgbe_define_iov_schemas(_a,_b)
	#define ixgbe_align_all_queue_indices(_a)
	+#define ixgbe_vf_que_index(_a, _b, _c) (_c)
	#define ixgbe_get_mtqc(_a) IXGBE_MTQC_64Q_1PB
	#define ixgbe_get_mrqc(_a) 0

	#endif /* PCI_IOV */

	-void ixgbe_handle_mbx(void *, int);
	-int ixgbe_vf_que_index(int, int, int);
	+void ixgbe_if_init(if_ctx_t ctx);
	+void ixgbe_handle_mbx(void *);

	#endif
	Index: sys/dev/ixgbe/ixgbe_type.h
	===================================================================
	--- sys/dev/ixgbe/ixgbe_type.h
	+++ sys/dev/ixgbe/ixgbe_type.h
	@@ -1562,7 +1562,7 @@
	#define IXGBE_MDIO_GLOBAL_ALARM_1 0xCC00 /* Global alarm 1 */
	#define IXGBE_MDIO_GLOBAL_ALM_1_DEV_FAULT 0x0010 /* device fault */
	#define IXGBE_MDIO_GLOBAL_ALM_1_HI_TMP_FAIL 0x4000 /* high temp failure */
	-#define IXGBE_MDIO_GLOBAL_FAULT_MSG 0xC850 /* Global Fault Message */
	+#define IXGBE_MDIO_GLOBAL_FAULT_MSG 0xC850 /* Global Fault Message */
	#define IXGBE_MDIO_GLOBAL_FAULT_MSG_HI_TMP 0x8007 /* high temp failure */
	#define IXGBE_MDIO_GLOBAL_INT_MASK 0xD400 /* Global int mask */
	#define IXGBE_MDIO_GLOBAL_AN_VEN_ALM_INT_EN 0x1000 /* autoneg vendor alarm int enable */
	Index: sys/dev/ixgbe/ixgbe_vf.h
	===================================================================
	--- sys/dev/ixgbe/ixgbe_vf.h
	+++ sys/dev/ixgbe/ixgbe_vf.h
	@@ -1,31 +1,31 @@
	/******************************************************************************

	- Copyright (c) 2001-2017, Intel Corporation
	+ Copyright (c) 2001-2017, Intel Corporation
	All rights reserved.
	-
	- Redistribution and use in source and binary forms, with or without
	+
	+ Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions are met:
	-
	- 1. Redistributions of source code must retain the above copyright notice,
	+
	+ 1. Redistributions of source code must retain the above copyright notice,
	this list of conditions and the following disclaimer.
	-
	- 2. Redistributions in binary form must reproduce the above copyright
	- notice, this list of conditions and the following disclaimer in the
	+
	+ 2. Redistributions in binary form must reproduce the above copyright
	+ notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.
	-
	- 3. Neither the name of the Intel Corporation nor the names of its
	- contributors may be used to endorse or promote products derived from
	+
	+ 3. Neither the name of the Intel Corporation nor the names of its
	+ contributors may be used to endorse or promote products derived from
	this software without specific prior written permission.
	-
	+
	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	POSSIBILITY OF SUCH DAMAGE.

	Index: sys/modules/ix/Makefile
	===================================================================
	--- sys/modules/ix/Makefile
	+++ sys/modules/ix/Makefile
	@@ -3,10 +3,9 @@
	.PATH: ${SRCTOP}/sys/dev/ixgbe

	KMOD = if_ix
	-SRCS = device_if.h bus_if.h pci_if.h pci_iov_if.h
	+SRCS = device_if.h bus_if.h pci_if.h pci_iov_if.h ifdi_if.h
	SRCS += opt_inet.h opt_inet6.h opt_rss.h
	SRCS += if_ix.c if_bypass.c if_fdir.c if_sriov.c ix_txrx.c ixgbe_osdep.c
	-SRCS += ixgbe_netmap.c
	# Shared source
	SRCS += ixgbe_common.c ixgbe_api.c ixgbe_phy.c ixgbe_mbx.c ixgbe_vf.c
	SRCS += ixgbe_dcb.c ixgbe_dcb_82598.c ixgbe_dcb_82599.c
	Index: sys/modules/ixv/Makefile
	===================================================================
	--- sys/modules/ixv/Makefile
	+++ sys/modules/ixv/Makefile
	@@ -3,9 +3,9 @@
	.PATH: ${SRCTOP}/sys/dev/ixgbe

	KMOD = if_ixv
	-SRCS = device_if.h bus_if.h pci_if.h pci_iov_if.h
	+SRCS = device_if.h bus_if.h pci_if.h pci_iov_if.h ifdi_if.h
	SRCS += opt_inet.h opt_inet6.h opt_rss.h
	-SRCS += if_ixv.c if_fdir.c if_sriov.c ix_txrx.c ixgbe_osdep.c ixgbe_netmap.c
	+SRCS += if_ixv.c if_fdir.c ix_txrx.c ixgbe_osdep.c
	# Shared source
	SRCS += ixgbe_common.c ixgbe_api.c ixgbe_phy.c ixgbe_mbx.c ixgbe_vf.c
	SRCS += ixgbe_dcb.c ixgbe_dcb_82598.c ixgbe_dcb_82599.c

File Metadata

Mime Type: text/plain
Expires: Sun, Nov 8, 8:54 AM (18 h, 18 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 41576987
Default Alt Text: D11727.1794128053.diff (368 KB)

D11727.1794128053.diffNo OneTemporaryActions

D11727.1794128053.diffView Options

File Metadata

Event Timeline

D11727.1794128053.diff
No OneTemporary
Actions

D11727.1794128053.diff
View Options