 @@ -1,2138 +1,2143 @@
-/* $NetBSD: ixgbe.c,v 1.306 2022/02/01 04:59:16 msaitoh Exp $ */
+/* $NetBSD: ixgbe.c,v 1.307 2022/02/16 10:29:13 msaitoh Exp $ */
 /******************************************************************************
   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:
 . Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.
 . 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.
 . 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: head/sys/dev/ixgbe/if_ix.c 331224 2018-03-19 20:55:05Z erj $*/
 /*
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Coyote Point Systems, Inc.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ixgbe.c,v 1.306 2022/02/01 04:59:16 msaitoh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ixgbe.c,v 1.307 2022/02/16 10:29:13 msaitoh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_inet6.h"
 #include "opt_net_mpsafe.h"
 #endif
 #include "ixgbe.h"
 #include "ixgbe_phy.h"
 #include "ixgbe_sriov.h"
 #include <sys/cprng.h>
 #include <dev/mii/mii.h>
 #include <dev/mii/miivar.h>
 /************************************************************************
  * Driver version
  ************************************************************************/
 static const char ixgbe_driver_version[] = "4.0.1-k";
 /* XXX NetBSD: + 3.3.24 */
 /************************************************************************
  * PCI Device ID Table
+ *
  *   Used by probe to select devices to load on
  *   Last field stores an index into ixgbe_strings
  *   Last entry must be all 0s
+ *
  *   { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
  ************************************************************************/
 static const ixgbe_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_BX, 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_KR, 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_SFP_EM, 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_X_XFI, 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_QSFP, 0, 0, 0},
 	{IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_QSFP_N, 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},
 	/* required last entry */
 	{0, 0, 0, 0, 0}
 };
 /************************************************************************
  * Table of branding strings
  ************************************************************************/
 static const char    *ixgbe_strings[] = {
 	"Intel(R) PRO/10GbE PCI-Express Network Driver"
 };
 /************************************************************************
  * Function prototypes
  ************************************************************************/
 static int	ixgbe_probe(device_t, cfdata_t, void *);
 static void	ixgbe_quirks(struct adapter *);
 static void	ixgbe_attach(device_t, device_t, void *);
 static int	ixgbe_detach(device_t, int);
 #if 0
 static int	ixgbe_shutdown(device_t);
 #endif
 static bool	ixgbe_suspend(device_t, const pmf_qual_t *);
 static bool	ixgbe_resume(device_t, const pmf_qual_t *);
 static int	ixgbe_ifflags_cb(struct ethercom *);
 static int	ixgbe_ioctl(struct ifnet *, u_long, void *);
 static int	ixgbe_init(struct ifnet *);
 static void	ixgbe_init_locked(struct adapter *);
 static void	ixgbe_ifstop(struct ifnet *, int);
 static void	ixgbe_stop_locked(void *);
 static void	ixgbe_init_device_features(struct adapter *);
 static int	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 *,
 		    const struct pci_attach_args *);
 static void	ixgbe_free_deferred_handlers(struct adapter *);
 static void	ixgbe_get_slot_info(struct adapter *);
 static int	ixgbe_allocate_msix(struct adapter *,
 		    const struct pci_attach_args *);
 static int	ixgbe_allocate_legacy(struct adapter *,
 		    const struct pci_attach_args *);
 static int	ixgbe_configure_interrupts(struct adapter *);
 static void	ixgbe_free_pciintr_resources(struct adapter *);
 static void	ixgbe_free_pci_resources(struct adapter *);
 static void	ixgbe_local_timer(void *);
 static void	ixgbe_handle_timer(struct work *, void *);
 static void	ixgbe_recovery_mode_timer(void *);
 static void	ixgbe_handle_recovery_mode_timer(struct work *, 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_schedule_admin_tasklet(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 *);
 #if 0
 static void	ixgbe_rearm_queues(struct adapter *, u64);
 #endif
 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_rxfilter(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_eitr_write(struct adapter *, uint32_t, uint32_t);
 static void	ixgbe_setup_vlan_hw_tagging(struct adapter *);
 static void	ixgbe_setup_vlan_hw_support(struct adapter *);
 static int	ixgbe_vlan_cb(struct ethercom *, uint16_t, bool);
 static int	ixgbe_register_vlan(struct adapter *, u16);
 static int	ixgbe_unregister_vlan(struct adapter *, u16);
 static void	ixgbe_add_device_sysctls(struct adapter *);
 static void	ixgbe_add_hw_stats(struct adapter *);
 static void	ixgbe_clear_evcnt(struct adapter *);
 static int	ixgbe_set_flowcntl(struct adapter *, int);
 static int	ixgbe_set_advertise(struct adapter *, int);
 static int	ixgbe_get_default_advertise(struct adapter *);
 /* Sysctl handlers */
 static void	ixgbe_set_sysctl_value(struct adapter *, const char *,
 		     const char *, int *, int);
 static int	ixgbe_sysctl_flowcntl(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_advertise(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_dmac(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_phy_temp(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_PROTO);
 #ifdef IXGBE_DEBUG
 static int	ixgbe_sysctl_power_state(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_print_rss_config(SYSCTLFN_PROTO);
 #endif
 static int	ixgbe_sysctl_next_to_check_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_next_to_refresh_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_rdh_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_rdt_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_tdt_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_tdh_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_eee_state(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_debug(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_rx_copy_len(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_wol_enable(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_wufc(SYSCTLFN_PROTO);
 /* Interrupt functions */
 static int	ixgbe_msix_que(void *);
 static int	ixgbe_msix_admin(void *);
 static void	ixgbe_intr_admin_common(struct adapter *, u32, u32 *);
 static int	ixgbe_legacy_irq(void *);
 /* Event handlers running on workqueue */
 static void	ixgbe_handle_que(void *);
 static void	ixgbe_handle_link(void *);
 static void	ixgbe_handle_msf(void *);
 static void	ixgbe_handle_mod(void *, bool);
 static void	ixgbe_handle_phy(void *);
 /* Deferred workqueue handlers */
 static void	ixgbe_handle_admin(struct work *, void *);
 static void	ixgbe_handle_que_work(struct work *, void *);
 static const ixgbe_vendor_info_t *ixgbe_lookup(const struct pci_attach_args *);
 /************************************************************************
  *  NetBSD Device Interface Entry Points
  ************************************************************************/
 CFATTACH_DECL3_NEW(ixg, sizeof(struct adapter),
     ixgbe_probe, ixgbe_attach, ixgbe_detach, NULL, NULL, NULL,
     DVF_DETACH_SHUTDOWN);
 #if 0
 devclass_t ix_devclass;
 DRIVER_MODULE(ix, pci, ix_driver, ix_devclass, 0, 0);
 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
 #endif
 /*
  * TUNEABLE PARAMETERS:
  */
 /*
  * AIM: Adaptive Interrupt Moderation
  * which means that the interrupt rate
  * is varied over time based on the
  * traffic for that interrupt vector
  */
 static bool ixgbe_enable_aim = true;
 #define SYSCTL_INT(_a1, _a2, _a3, _a4, _a5, _a6, _a7)
 SYSCTL_INT(_hw_ix, OID_AUTO, enable_aim, CTLFLAG_RDTUN, &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,
     &ixgbe_flow_control, 0, "Default flow control used for all adapters");
 /* Which packet processing uses workqueue or softint */
 static bool ixgbe_txrx_workqueue = false;
 /*
  * Smart speed setting, default to on
  * this only works as a compile option
  * right now as its during attach, set
  * this to 'ixgbe_smart_speed_off' to
  * disable.
  */
 static int ixgbe_smart_speed = ixgbe_smart_speed_on;
 /*
  * MSI-X should be the default for best performance,
  * but this allows it to be forced off for testing.
  */
 static int ixgbe_enable_msix = 1;
 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 overridden 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
  * doing so you are on your own :)
  */
 static int allow_unsupported_sfp = false;
 #define TUNABLE_INT(__x, __y)
 TUNABLE_INT("hw.ix.unsupported_sfp", &allow_unsupported_sfp);
 /*
  * Not sure if Flow Director is fully baked,
  * so we'll default to turning it off.
  */
 static int ixgbe_enable_fdir = 0;
 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
 static int (*ixgbe_start_locked)(struct ifnet *, struct tx_ring *);
 static int (*ixgbe_ring_empty)(struct ifnet *, pcq_t *);
 #endif
 #ifdef NET_MPSAFE
 #define IXGBE_MPSAFE		1
 #define IXGBE_CALLOUT_FLAGS	CALLOUT_MPSAFE
 #define IXGBE_SOFTINT_FLAGS	SOFTINT_MPSAFE
 #define IXGBE_WORKQUEUE_FLAGS	WQ_PERCPU | WQ_MPSAFE
 #define IXGBE_TASKLET_WQ_FLAGS	WQ_MPSAFE
 #else
 #define IXGBE_CALLOUT_FLAGS	0
 #define IXGBE_SOFTINT_FLAGS	0
 #define IXGBE_WORKQUEUE_FLAGS	WQ_PERCPU
 #define IXGBE_TASKLET_WQ_FLAGS	0
 #endif
 #define IXGBE_WORKQUEUE_PRI PRI_SOFTNET
 /************************************************************************
  * ixgbe_initialize_rss_mapping
  ************************************************************************/
 static void
 ixgbe_initialize_rss_mapping(struct adapter *adapter)
+{
 	struct ixgbe_hw	*hw = &adapter->hw;
 	u32		reta = 0, mrqc, rss_key[10];
 	int		queue_id, table_size, index_mult;
 	int		i, j;
 	u32		rss_hash_config;
 	/* force use default RSS key. */
 #ifdef __NetBSD__
 	rss_getkey((uint8_t *) &rss_key);
 #else
 	if (adapter->feat_en & IXGBE_FEATURE_RSS) {
 		/* Fetch the configured RSS key */
 		rss_getkey((uint8_t *) &rss_key);
 	} else {
 		/* set up random bits */
 		cprng_fast(&rss_key, sizeof(rss_key));
+	}
 #endif
 	/* Set multiplier for RETA setup and table size based on MAC */
 	index_mult = 0x1;
 	table_size = 128;
 	switch (adapter->hw.mac.type) {
 	case ixgbe_mac_82598EB:
 		index_mult = 0x11;
 		break;
 	case ixgbe_mac_X550:
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		table_size = 512;
 		break;
 	default:
 		break;
+	}
 	/* Set up the redirection table */
 	for (i = 0, j = 0; i < table_size; i++, j++) {
 		if (j == adapter->num_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.)
 			 */
 			queue_id = rss_get_indirection_to_bucket(i);
 			queue_id = queue_id % adapter->num_queues;
 		} else
 			queue_id = (j * index_mult);
 		/*
 		 * The low 8 bits are for hash value (n+0);
 		 * The next 8 bits are for hash value (n+1), etc.
 		 */
 		reta = reta >> 8;
 		reta = reta | (((uint32_t) queue_id) << 24);
 		if ((i & 3) == 3) {
 			if (i < 128)
 				IXGBE_WRITE_REG(hw, IXGBE_RETA(i >> 2), reta);
 			else
 				IXGBE_WRITE_REG(hw, IXGBE_ERETA((i >> 2) - 32),
 				    reta);
 			reta = 0;
+		}
+	}
 	/* Now fill our hash function seeds */
 	for (i = 0; i < 10; i++)
 		IXGBE_WRITE_REG(hw, IXGBE_RSSRK(i), rss_key[i]);
 	/* Perform hash on these packet types */
 	if (adapter->feat_en & IXGBE_FEATURE_RSS)
 		rss_hash_config = rss_gethashconfig();
 	else {
 		/*
 		 * Disable UDP - IP fragments aren't currently being handled
 		 * and so we end up with a mix of 2-tuple and 4-tuple
 		 * traffic.
 		 */
 		rss_hash_config = RSS_HASHTYPE_RSS_IPV4
 				| RSS_HASHTYPE_RSS_TCP_IPV4
 				| RSS_HASHTYPE_RSS_IPV6
 				| RSS_HASHTYPE_RSS_TCP_IPV6
 				| RSS_HASHTYPE_RSS_IPV6_EX
 				| RSS_HASHTYPE_RSS_TCP_IPV6_EX;
+	}
 	mrqc = IXGBE_MRQC_RSSEN;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP;
 	if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX)
 		mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP;
 	mrqc |= ixgbe_get_mrqc(adapter->iov_mode);
 	IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
 } /* ixgbe_initialize_rss_mapping */
 /************************************************************************
  * ixgbe_initialize_receive_units - Setup receive registers and features.
  ************************************************************************/
 #define BSIZEPKT_ROUNDUP ((1<<IXGBE_SRRCTL_BSIZEPKT_SHIFT)-1)
 static void
 ixgbe_initialize_receive_units(struct adapter *adapter)
+{
 	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;
 	/*
 	 * Make sure receives are disabled while
 	 * setting up the descriptor ring
 	 */
 	ixgbe_disable_rx(hw);
 	/* Enable broadcasts */
 	fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
 	fctrl |= IXGBE_FCTRL_BAM;
 	if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
 		fctrl |= IXGBE_FCTRL_DPF;
 		fctrl |= IXGBE_FCTRL_PMCF;
+	}
 	IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
 	/* Set for Jumbo Frames? */
 	hlreg = IXGBE_READ_REG(hw, IXGBE_HLREG0);
 	if (ifp->if_mtu > ETHERMTU)
 		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;
 		u32 reg;
 		int regnum = i / 4;	/* 1 register per 4 queues */
 		int regshift = i % 4;	/* 4 bits per 1 queue */
 		j = rxr->me;
 		/* Setup the Base and Length of the Rx Descriptor Ring */
 		IXGBE_WRITE_REG(hw, IXGBE_RDBAL(j),
 		    (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));
 		/* Set up the SRRCTL register */
 		srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(j));
 		srrctl &= ~IXGBE_SRRCTL_BSIZEHDR_MASK;
 		srrctl &= ~IXGBE_SRRCTL_BSIZEPKT_MASK;
 		srrctl |= bufsz;
 		srrctl |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
 		/* Set RQSMR (Receive Queue Statistic Mapping) register */
 		reg = IXGBE_READ_REG(hw, IXGBE_RQSMR(regnum));
 		reg &= ~(0x000000ffUL << (regshift * 8));
 		reg |= i << (regshift * 8);
 		IXGBE_WRITE_REG(hw, IXGBE_RQSMR(regnum), reg);
 		/*
 		 * Set DROP_EN iff we have no flow control and >1 queue.
 		 * Note that srrctl was cleared shortly before during reset,
 		 * 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 &&
 		    adapter->hw.fc.requested_mode == ixgbe_fc_none) {
 			srrctl |= IXGBE_SRRCTL_DROP_EN;
 		} else {
 			srrctl &= ~IXGBE_SRRCTL_DROP_EN;
+		}
 		IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(j), srrctl);
 		/* Setup the HW Rx Head and Tail Descriptor Pointers */
 		IXGBE_WRITE_REG(hw, IXGBE_RDH(j), 0);
 		IXGBE_WRITE_REG(hw, IXGBE_RDT(j), 0);
 		/* Set the driver rx tail address */
 		rxr->tail =  IXGBE_RDT(rxr->me);
+	}
 	if (adapter->hw.mac.type != ixgbe_mac_82598EB) {
 		u32 psrtype = IXGBE_PSRTYPE_TCPHDR
 			    | IXGBE_PSRTYPE_UDPHDR
 			    | IXGBE_PSRTYPE_IPV4HDR
 			    | IXGBE_PSRTYPE_IPV6HDR;
 		IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(0), psrtype);
+	}
 	rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM);
 	ixgbe_initialize_rss_mapping(adapter);
 	if (adapter->num_queues > 1) {
 		/* RSS and RX IPP Checksum are mutually exclusive */
 		rxcsum |= IXGBE_RXCSUM_PCSD;
+	}
 	if (ifp->if_capenable & IFCAP_RXCSUM)
 		rxcsum |= IXGBE_RXCSUM_PCSD;
 	/* This is useful for calculating UDP/IP fragment checksums */
 	if (!(rxcsum & IXGBE_RXCSUM_PCSD))
 		rxcsum |= IXGBE_RXCSUM_IPPCSE;
 	IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum);
 } /* ixgbe_initialize_receive_units */
 /************************************************************************
  * ixgbe_initialize_transmit_units - Enable transmit units.
  ************************************************************************/
 static void
 ixgbe_initialize_transmit_units(struct adapter *adapter)
+{
 	struct tx_ring	*txr = adapter->tx_rings;
 	struct ixgbe_hw	*hw = &adapter->hw;
 	int i;
 	INIT_DEBUGOUT("ixgbe_initialize_transmit_units");
 	/* Setup the Base and Length of the Tx Descriptor Ring */
 	for (i = 0; i < adapter->num_queues; i++, txr++) {
 		u64 tdba = txr->txdma.dma_paddr;
 		u32 txctrl = 0;
 		u32 tqsmreg, reg;
 		int regnum = i / 4;	/* 1 register per 4 queues */
 		int regshift = i % 4;	/* 4 bits per 1 queue */
 		int j = txr->me;
 		IXGBE_WRITE_REG(hw, IXGBE_TDBAL(j),
 		    (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));
 		/*
 		 * Set TQSMR (Transmit Queue Statistic Mapping) register.
 		 * Register location is different between 82598 and others.
 		 */
 		if (adapter->hw.mac.type == ixgbe_mac_82598EB)
 			tqsmreg = IXGBE_TQSMR(regnum);
 		else
 			tqsmreg = IXGBE_TQSM(regnum);
 		reg = IXGBE_READ_REG(hw, tqsmreg);
 		reg &= ~(0x000000ffUL << (regshift * 8));
 		reg |= i << (regshift * 8);
 		IXGBE_WRITE_REG(hw, tqsmreg, reg);
 		/* 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->txr_no_space = false;
 		/* Disable Head Writeback */
 		/*
 		 * Note: for X550 series devices, these registers are actually
 		 * prefixed with TPH_ instead of DCA_, but the addresses and
 		 * fields remain the same.
 		 */
 		switch (hw->mac.type) {
 		case ixgbe_mac_82598EB:
 			txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL(j));
 			break;
 		default:
 			txctrl = IXGBE_READ_REG(hw, IXGBE_DCA_TXCTRL_82599(j));
 			break;
+		}
 		txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
 		switch (hw->mac.type) {
 		case ixgbe_mac_82598EB:
 			IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(j), txctrl);
 			break;
 		default:
 			IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(j), txctrl);
 			break;
+		}
+	}
 	if (hw->mac.type != ixgbe_mac_82598EB) {
 		u32 dmatxctl, rttdcs;
 		dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL);
 		dmatxctl |= IXGBE_DMATXCTL_TE;
 		IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl);
 		/* Disable arbiter to set MTQC */
 		rttdcs = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
 		rttdcs |= IXGBE_RTTDCS_ARBDIS;
 		IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs);
 		IXGBE_WRITE_REG(hw, IXGBE_MTQC,
 		    ixgbe_get_mtqc(adapter->iov_mode));
 		rttdcs &= ~IXGBE_RTTDCS_ARBDIS;
 		IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs);
+	}
 	return;
 } /* ixgbe_initialize_transmit_units */
 static void
 ixgbe_quirks(struct adapter *adapter)
+{
 	device_t dev = adapter->dev;
 	struct ixgbe_hw *hw = &adapter->hw;
 	const char *vendor, *product;
 	if (hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N) {
 		/*
 		 * Quirk for inverted logic of SFP+'s MOD_ABS on GIGABYTE
 		 * MA10-ST0.
 		 */
 		vendor = pmf_get_platform("system-vendor");
 		product = pmf_get_platform("system-product");
 		if ((vendor == NULL) || (product == NULL))
 			return;
 		if ((strcmp(vendor, "GIGABYTE") == 0) &&
 		    (strcmp(product, "MA10-ST0") == 0)) {
 			aprint_verbose_dev(dev,
 			    "Enable SFP+ MOD_ABS inverse quirk\n");
 			adapter->hw.quirks |= IXGBE_QUIRK_MOD_ABS_INVERT;
+		}
+	}
+}
 /************************************************************************
  * ixgbe_attach - Device initialization routine
+ *
  *   Called when the driver is being loaded.
  *   Identifies the type of hardware, allocates all resources
  *   and initializes the hardware.
+ *
  *   return 0 on success, positive on failure
  ************************************************************************/
 static void
 ixgbe_attach(device_t parent, device_t dev, void *aux)
+{
 	struct adapter	*adapter;
 	struct ixgbe_hw *hw;
 	int		error = -1;
 	u32		ctrl_ext;
 	u16		high, low, nvmreg;
 	pcireg_t	id, subid;
 	const ixgbe_vendor_info_t *ent;
 	struct pci_attach_args *pa = aux;
 	bool unsupported_sfp = false;
 	const char *str;
 	char wqname[MAXCOMLEN];
 	char buf[256];
 	INIT_DEBUGOUT("ixgbe_attach: begin");
 	/* Allocate, clear, and link in our adapter structure */
 	adapter = device_private(dev);
 	adapter->hw.back = adapter;
 	adapter->dev = dev;
 	hw = &adapter->hw;
 	adapter->osdep.pc = pa->pa_pc;
 	adapter->osdep.tag = pa->pa_tag;
 	if (pci_dma64_available(pa))
 		adapter->osdep.dmat = pa->pa_dmat64;
 	else
 		adapter->osdep.dmat = pa->pa_dmat;
 	adapter->osdep.attached = false;
 	adapter->osdep.detaching = false;
 	ent = ixgbe_lookup(pa);
 	KASSERT(ent != NULL);
 	aprint_normal(": %s, Version - %s\n",
 	    ixgbe_strings[ent->index], ixgbe_driver_version);
 	/* Core Lock Init */
 	IXGBE_CORE_LOCK_INIT(adapter, device_xname(dev));
 	/* Set up the timer callout and workqueue */
 	callout_init(&adapter->timer, IXGBE_CALLOUT_FLAGS);
 	snprintf(wqname, sizeof(wqname), "%s-timer", device_xname(dev));
 	error = workqueue_create(&adapter->timer_wq, wqname,
 	    ixgbe_handle_timer, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET,
 	    IXGBE_TASKLET_WQ_FLAGS);
 	if (error) {
 		aprint_error_dev(dev,
 		    "could not create timer workqueue (%d)\n", error);
 		goto err_out;
+	}
 	/* Determine hardware revision */
 	id = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG);
 	subid = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
 	hw->vendor_id = PCI_VENDOR(id);
 	hw->device_id = PCI_PRODUCT(id);
 	hw->revision_id =
 	    PCI_REVISION(pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG));
 	hw->subsystem_vendor_id = PCI_SUBSYS_VENDOR(subid);
 	hw->subsystem_device_id = PCI_SUBSYS_ID(subid);
 	/* Set quirk flags */
 	ixgbe_quirks(adapter);
 	/*
 	 * Make sure BUSMASTER is set
 	 */
 	ixgbe_pci_enable_busmaster(pa->pa_pc, pa->pa_tag);
 	/* Do base PCI setup - map BAR0 */
 	if (ixgbe_allocate_pci_resources(adapter, pa)) {
 		aprint_error_dev(dev, "Allocation of PCI resources failed\n");
 		error = ENXIO;
 		goto err_out;
+	}
 	/* let hardware know driver is loaded */
 	ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT);
 	ctrl_ext |= IXGBE_CTRL_EXT_DRV_LOAD;
 	IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext);
 	/*
 	 * Initialize the shared code
 	 */
 	if (ixgbe_init_shared_code(hw) != 0) {
 		aprint_error_dev(dev, "Unable to initialize the shared code\n");
 		error = ENXIO;
 		goto err_out;
+	}
 	switch (hw->mac.type) {
 	case ixgbe_mac_82598EB:
 		str = "82598EB";
 		break;
 	case ixgbe_mac_82599EB:
 		str = "82599EB";
 		break;
 	case ixgbe_mac_X540:
 		str = "X540";
 		break;
 	case ixgbe_mac_X550:
 		str = "X550";
 		break;
 	case ixgbe_mac_X550EM_x:
 		str = "X550EM X";
 		break;
 	case ixgbe_mac_X550EM_a:
 		str = "X550EM A";
 		break;
 	default:
 		str = "Unknown";
 		break;
+	}
 	aprint_normal_dev(dev, "device %s\n", str);
 	hw->allow_unsupported_sfp = allow_unsupported_sfp;
 	/* Pick up the 82599 settings */
 	if (hw->mac.type != ixgbe_mac_82598EB)
 		hw->phy.smart_speed = ixgbe_smart_speed;
 	/* Set the right number of segments */
 	KASSERT(IXGBE_82599_SCATTER_MAX >= IXGBE_SCATTER_DEFAULT);
 	adapter->num_segs = IXGBE_SCATTER_DEFAULT;
 	/* Ensure SW/FW semaphore is free */
 	ixgbe_init_swfw_semaphore(hw);
 	hw->mac.ops.set_lan_id(hw);
 	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_DEVBUF, M_WAITOK);
 	/* Enable WoL (if supported) */
 	ixgbe_check_wol_support(adapter);
 	/* Register for VLAN events */
 	ether_set_vlan_cb(&adapter->osdep.ec, ixgbe_vlan_cb);
 	/* Verify adapter fan is still functional (if applicable) */
 	if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) {
 		u32 esdp = IXGBE_READ_REG(hw, IXGBE_ESDP);
 		ixgbe_check_fan_failure(adapter, esdp, FALSE);
+	}
 	/* 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) {
 		aprint_error_dev(dev, "TXD config issue, using default!\n");
 		adapter->num_tx_desc = DEFAULT_TXD;
 	} else
 		adapter->num_tx_desc = ixgbe_txd;
 	if (((ixgbe_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 ||
 	    ixgbe_rxd < MIN_RXD || ixgbe_rxd > MAX_RXD) {
 		aprint_error_dev(dev, "RXD config issue, using default!\n");
 		adapter->num_rx_desc = DEFAULT_RXD;
 	} else
 		adapter->num_rx_desc = ixgbe_rxd;
 	/* Set default high limit of copying mbuf in rxeof */
 	adapter->rx_copy_len = IXGBE_RX_COPY_LEN_MAX;
 	/* 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;
 	if (error == IXGBE_ERR_SFP_NOT_PRESENT)
 		error = IXGBE_SUCCESS;
 	else if (error == IXGBE_ERR_SFP_NOT_SUPPORTED) {
 		aprint_error_dev(dev, "Unsupported SFP+ module detected!\n");
 		unsupported_sfp = true;
 		error = IXGBE_SUCCESS;
 	} else if (error) {
 		aprint_error_dev(dev,
 		    "Hardware initialization failed(error = %d)\n", error);
 		error = EIO;
 		goto err_late;
+	}
 	/* Make sure we have a good EEPROM before we read from it */
 	if (ixgbe_validate_eeprom_checksum(&adapter->hw, NULL) < 0) {
 		aprint_error_dev(dev, "The EEPROM Checksum Is Not Valid\n");
 		error = EIO;
 		goto err_late;
+	}
 	aprint_normal("%s:", device_xname(dev));
 	/* NVM Image Version */
 	high = low = 0;
 	switch (hw->mac.type) {
 	case ixgbe_mac_82598EB:
 		/*
 		 * Print version from the dev starter version (0x29). The
 		 * location is the same as newer device's IXGBE_NVM_MAP_VER.
 		 */
 		hw->eeprom.ops.read(hw, IXGBE_NVM_MAP_VER, &nvmreg);
 		if (nvmreg == 0xffff)
 			break;
 		high = (nvmreg >> 12) & 0x0f;
 		low = (nvmreg >> 4) & 0xff;
 		id = nvmreg & 0x0f;
 		/*
 		 * The following output might not be correct. Some 82598 cards
 		 * have 0x1070 or 0x2090. 82598 spec update notes about 2.9.0.
 		 */
 		aprint_normal(" NVM Image Version %u.%u.%u,", high, low, id);
 		break;
 	case ixgbe_mac_X540:
 	case ixgbe_mac_X550EM_a:
 		hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg);
 		if (nvmreg == 0xffff)
 			break;
 		high = (nvmreg >> 12) & 0x0f;
 		low = (nvmreg >> 4) & 0xff;
 		id = nvmreg & 0x0f;
 		aprint_normal(" NVM Image Version %u.", high);
 		if (hw->mac.type == ixgbe_mac_X540)
 			str = "%x";
 		else
 			str = "%02x";
 		aprint_normal(str, low);
 		aprint_normal(" ID 0x%x,", id);
 		break;
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550:
 		hw->eeprom.ops.read(hw, IXGBE_NVM_IMAGE_VER, &nvmreg);
 		if (nvmreg == 0xffff)
 			break;
 		high = (nvmreg >> 12) & 0x0f;
 		low = nvmreg & 0xff;
 		aprint_normal(" NVM Image Version %u.%02x,", high, low);
 		break;
 	default:
 		break;
+	}
 	hw->eeprom.nvm_image_ver_high = high;
 	hw->eeprom.nvm_image_ver_low = low;
 	/* PHY firmware revision */
 	switch (hw->mac.type) {
 	case ixgbe_mac_X540:
 	case ixgbe_mac_X550:
 		hw->eeprom.ops.read(hw, IXGBE_PHYFW_REV, &nvmreg);
 		if (nvmreg == 0xffff)
 			break;
 		high = (nvmreg >> 12) & 0x0f;
 		low = (nvmreg >> 4) & 0xff;
 		id = nvmreg & 0x000f;
 		aprint_normal(" PHY FW Revision %u.", high);
 		if (hw->mac.type == ixgbe_mac_X540)
 			str = "%x";
 		else
 			str = "%02x";
 		aprint_normal(str, low);
 		aprint_normal(" ID 0x%x,", id);
 		break;
 	default:
 		break;
+	}
 	/* NVM Map version & OEM NVM Image version */
 	switch (hw->mac.type) {
 	case ixgbe_mac_X550:
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		hw->eeprom.ops.read(hw, IXGBE_NVM_MAP_VER, &nvmreg);
 		if (nvmreg != 0xffff) {
 			high = (nvmreg >> 12) & 0x0f;
 			low = nvmreg & 0x00ff;
 			aprint_normal(" NVM Map version %u.%02x,", high, low);
+		}
 		hw->eeprom.ops.read(hw, IXGBE_OEM_NVM_IMAGE_VER, &nvmreg);
 		if (nvmreg != 0xffff) {
 			high = (nvmreg >> 12) & 0x0f;
 			low = nvmreg & 0x00ff;
 			aprint_verbose(" OEM NVM Image version %u.%02x,", high,
 			    low);
+		}
 		break;
 	default:
 		break;
+	}
 	/* Print the ETrackID */
 	hw->eeprom.ops.read(hw, IXGBE_ETRACKID_H, &high);
 	hw->eeprom.ops.read(hw, IXGBE_ETRACKID_L, &low);
 	aprint_normal(" ETrackID %08x\n", ((uint32_t)high << 16) | low);
 	/* Printed Board Assembly number */
 	error = ixgbe_read_pba_string(hw, buf, IXGBE_PBANUM_LENGTH);
 	aprint_normal_dev(dev, "PBA number %s\n", error ? "unknown" : buf);
 	if (adapter->feat_en & IXGBE_FEATURE_MSIX) {
 		error = ixgbe_allocate_msix(adapter, pa);
 		if (error) {
 			/* Free allocated queue structures first */
 			ixgbe_free_queues(adapter);
 			/* Fallback to legacy interrupt */
 			adapter->feat_en &= ~IXGBE_FEATURE_MSIX;
 			if (adapter->feat_cap & IXGBE_FEATURE_MSI)
 				adapter->feat_en |= IXGBE_FEATURE_MSI;
 			adapter->num_queues = 1;
 			/* Allocate our TX/RX Queues again */
 			if (ixgbe_allocate_queues(adapter)) {
 				error = ENOMEM;
 				goto err_out;
+			}
+		}
+	}
 	/* Recovery mode */
 	switch (adapter->hw.mac.type) {
 	case ixgbe_mac_X550:
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		/* >= 2.00 */
 		if (hw->eeprom.nvm_image_ver_high >= 2) {
 			adapter->feat_cap |= IXGBE_FEATURE_RECOVERY_MODE;
 			adapter->feat_en |= IXGBE_FEATURE_RECOVERY_MODE;
+		}
 		break;
 	default:
 		break;
+	}
 	if ((adapter->feat_en & IXGBE_FEATURE_MSIX) == 0)
 		error = ixgbe_allocate_legacy(adapter, pa);
 	if (error)
 		goto err_late;
 	/* Tasklets for Link, SFP, Multispeed Fiber and Flow Director */
 	mutex_init(&(adapter)->admin_mtx, MUTEX_DEFAULT, IPL_NET);
 	snprintf(wqname, sizeof(wqname), "%s-admin", device_xname(dev));
 	error = workqueue_create(&adapter->admin_wq, wqname,
 	    ixgbe_handle_admin, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET,
 	    IXGBE_TASKLET_WQ_FLAGS);
 	if (error) {
 		aprint_error_dev(dev,
 		    "could not create admin workqueue (%d)\n", error);
 		goto err_out;
+	}
 	error = ixgbe_start_hw(hw);
 	switch (error) {
 	case IXGBE_ERR_EEPROM_VERSION:
 		aprint_error_dev(dev, "This device is a pre-production adapter/"
 		    "LOM.  Please be aware there may be issues associated "
 		    "with your hardware.\nIf you are experiencing problems "
 		    "please contact your Intel or hardware representative "
 		    "who provided you with this hardware.\n");
 		break;
 	default:
 		break;
+	}
 	/* Setup OS specific network interface */
 	if (ixgbe_setup_interface(dev, adapter) != 0)
 		goto err_late;
 	/*
 	 *  Print PHY ID only for copper PHY. On device which has SFP(+) cage
 	 * and a module is inserted, phy.id is not MII PHY id but SFF 8024 ID.
 	 */
 	if (hw->phy.media_type == ixgbe_media_type_copper) {
 		uint16_t id1, id2;
 		int oui, model, rev;
 		char descr[MII_MAX_DESCR_LEN];
 		id1 = hw->phy.id >> 16;
 		id2 = hw->phy.id & 0xffff;
 		oui = MII_OUI(id1, id2);
 		model = MII_MODEL(id2);
 		rev = MII_REV(id2);
 		mii_get_descr(descr, sizeof(descr), oui, model);
 		if (descr[0])
 			aprint_normal_dev(dev, "PHY: %s, rev. %d\n",
 			    descr, rev);
 		else
 			aprint_normal_dev(dev,
 			    "PHY OUI 0x%06x, model 0x%04x, rev. %d\n",
 			    oui, model, rev);
+	}
 	/* Enable EEE power saving */
 	if (adapter->feat_cap & IXGBE_FEATURE_EEE)
 		hw->mac.ops.setup_eee(hw,
 		    adapter->feat_en & IXGBE_FEATURE_EEE);
 	/* Enable power to the phy. */
 	if (!unsupported_sfp) {
 		/* Enable the optics for 82599 SFP+ fiber */
 		ixgbe_enable_tx_laser(hw);
 		/*
 		 * XXX Currently, ixgbe_set_phy_power() supports only copper
 		 * PHY, so it's not required to test with !unsupported_sfp.
 		 */
 		ixgbe_set_phy_power(hw, TRUE);
+	}
 	/* Initialize statistics */
 	ixgbe_update_stats_counters(adapter);
 	/* Check PCIE slot type/speed/width */
 	ixgbe_get_slot_info(adapter);
 	/*
 	 * Do time init and sysctl init here, but
 	 * only on the first port of a bypass adapter.
 	 */
 	ixgbe_bypass_init(adapter);
 	/* Set an initial dmac value */
 	adapter->dmac = 0;
 	/* Set initial advertised speeds (if applicable) */
 	adapter->advertise = ixgbe_get_default_advertise(adapter);
 	if (adapter->feat_cap & IXGBE_FEATURE_SRIOV)
 		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_locked;
 	if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
 		ixgbe_netmap_attach(adapter);
 	snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_cap);
 	aprint_verbose_dev(dev, "feature cap %s\n", buf);
 	snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_en);
 	aprint_verbose_dev(dev, "feature ena %s\n", buf);
 	if (pmf_device_register(dev, ixgbe_suspend, ixgbe_resume))
 		pmf_class_network_register(dev, adapter->ifp);
 	else
 		aprint_error_dev(dev, "couldn't establish power handler\n");
 	/* Init recovery mode timer and state variable */
 	if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) {
 		adapter->recovery_mode = 0;
 		/* Set up the timer callout */
 		callout_init(&adapter->recovery_mode_timer,
 		    IXGBE_CALLOUT_FLAGS);
 		snprintf(wqname, sizeof(wqname), "%s-recovery",
 		    device_xname(dev));
 		error = workqueue_create(&adapter->recovery_mode_timer_wq,
 		    wqname, ixgbe_handle_recovery_mode_timer, adapter,
 		    IXGBE_WORKQUEUE_PRI, IPL_NET, IXGBE_TASKLET_WQ_FLAGS);
 		if (error) {
 			aprint_error_dev(dev, "could not create "
 			    "recovery_mode_timer workqueue (%d)\n", error);
 			goto err_out;
+		}
 		/* Start the task */
 		callout_reset(&adapter->recovery_mode_timer, hz,
 		    ixgbe_recovery_mode_timer, adapter);
+	}
 	INIT_DEBUGOUT("ixgbe_attach: end");
 	adapter->osdep.attached = true;
 	return;
 err_late:
 	ixgbe_free_queues(adapter);
 err_out:
 	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_deferred_handlers(adapter);
 	ixgbe_free_pci_resources(adapter);
 	if (adapter->mta != NULL)
 		free(adapter->mta, M_DEVBUF);
 	mutex_destroy(&(adapter)->admin_mtx); /* XXX appropriate order? */
 	IXGBE_CORE_LOCK_DESTROY(adapter);
 	return;
 } /* ixgbe_attach */
 /************************************************************************
  * ixgbe_check_wol_support
+ *
  *   Checks whether the adapter's ports are capable of
  *   Wake On LAN by reading the adapter's NVM.
+ *
  *   Sets each port's hw->wol_enabled value depending
  *   on the value read here.
  ************************************************************************/
 static void
 ixgbe_check_wol_support(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	u16		dev_caps = 0;
 	/* Find out WoL support for port */
 	adapter->wol_support = hw->wol_enabled = 0;
 	ixgbe_get_device_caps(hw, &dev_caps);
 	if ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0_1) ||
 	    ((dev_caps & IXGBE_DEVICE_CAPS_WOL_PORT0) &&
 	     hw->bus.func == 0))
 		adapter->wol_support = hw->wol_enabled = 1;
 	/* Save initial wake up filter configuration */
 	adapter->wufc = IXGBE_READ_REG(hw, IXGBE_WUFC);
 	return;
 } /* ixgbe_check_wol_support */
 /************************************************************************
  * ixgbe_setup_interface
+ *
  *   Setup networking device structure and register an interface.
  ************************************************************************/
 static int
 ixgbe_setup_interface(device_t dev, struct adapter *adapter)
+{
 	struct ethercom *ec = &adapter->osdep.ec;
 	struct ifnet   *ifp;
 	INIT_DEBUGOUT("ixgbe_setup_interface: begin");
 	ifp = adapter->ifp = &ec->ec_if;
 	strlcpy(ifp->if_xname, device_xname(dev), IFNAMSIZ);
 	ifp->if_baudrate = IF_Gbps(10);
 	ifp->if_init = ixgbe_init;
 	ifp->if_stop = ixgbe_ifstop;
 	ifp->if_softc = adapter;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 #ifdef IXGBE_MPSAFE
 	ifp->if_extflags = IFEF_MPSAFE;
 #endif
 	ifp->if_ioctl = ixgbe_ioctl;
 #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) {
 #if 0
 		ixgbe_start_locked = ixgbe_legacy_start_locked;
 #endif
 	} else {
 		ifp->if_transmit = ixgbe_mq_start;
 #if 0
 		ixgbe_start_locked = ixgbe_mq_start_locked;
 #endif
+	}
 	ifp->if_start = ixgbe_legacy_start;
 	IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 2);
 	IFQ_SET_READY(&ifp->if_snd);
 	if_initialize(ifp);
 	adapter->ipq = if_percpuq_create(&adapter->osdep.ec.ec_if);
 	ether_ifattach(ifp, adapter->hw.mac.addr);
 	aprint_normal_dev(dev, "Ethernet address %s\n",
 	    ether_sprintf(adapter->hw.mac.addr));
 	/*
 	 * We use per TX queue softint, so if_deferred_start_init() isn't
 	 * used.
 	 */
 	ether_set_ifflags_cb(ec, ixgbe_ifflags_cb);
 	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_RXCSUM
 			     |	IFCAP_TXCSUM
 			     |	IFCAP_TSOv4
 			     |	IFCAP_TSOv6;
 	ifp->if_capenable = 0;
 	ec->ec_capabilities |= ETHERCAP_VLAN_HWTAGGING
 			    |  ETHERCAP_VLAN_HWCSUM
 			    |  ETHERCAP_JUMBO_MTU
 			    |  ETHERCAP_VLAN_MTU;
 	/* Enable the above capabilities by default */
 	ec->ec_capenable = ec->ec_capabilities;
 	/*
 	 * Don't turn this on by default, if vlans are
 	 * created on another pseudo device (eg. lagg)
 	 * then vlan events are not passed thru, breaking
 	 * operation, but with HW FILTER off it works. If
 	 * using vlans directly on the ixgbe driver you can
 	 * enable this and get full hardware tag filtering.
 	 */
 	ec->ec_capabilities |= ETHERCAP_VLAN_HWFILTER;
 	/*
 	 * Specify the media types supported by this adapter and register
 	 * callbacks to update media and link information
 	 */
 	ec->ec_ifmedia = &adapter->media;
 	ifmedia_init_with_lock(&adapter->media, IFM_IMASK, ixgbe_media_change,
 	    ixgbe_media_status, &adapter->core_mtx);
 	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);
 	if_register(ifp);
 	return (0);
 } /* ixgbe_setup_interface */
 /************************************************************************
  * ixgbe_add_media_types
  ************************************************************************/
 static void
 ixgbe_add_media_types(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	u64		layer;
 	layer = adapter->phy_layer;
 #define	ADD(mm, dd)							\
 	ifmedia_add(&adapter->media, IFM_ETHER | (mm), (dd), NULL);
 	ADD(IFM_NONE, 0);
 	/* Media types with matching NetBSD media defines */
 	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_T) {
 		ADD(IFM_10G_T | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_T) {
 		ADD(IFM_1000_T | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_100BASE_TX) {
 		ADD(IFM_100_TX | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_10BASE_T) {
 		ADD(IFM_10_T | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_SFP_PLUS_CU ||
 	    layer & IXGBE_PHYSICAL_LAYER_SFP_ACTIVE_DA) {
 		ADD(IFM_10G_TWINAX | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_LR) {
 		ADD(IFM_10G_LR | IFM_FDX, 0);
 		if (hw->phy.multispeed_fiber) {
 			ADD(IFM_1000_LX | IFM_FDX, 0);
+		}
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_SR) {
 		ADD(IFM_10G_SR | IFM_FDX, 0);
 		if (hw->phy.multispeed_fiber) {
 			ADD(IFM_1000_SX | IFM_FDX, 0);
+		}
 	} else if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_SX) {
 		ADD(IFM_1000_SX | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_CX4) {
 		ADD(IFM_10G_CX4 | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KR) {
 		ADD(IFM_10G_KR | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_10GBASE_KX4) {
 		ADD(IFM_10G_KX4 | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_KX) {
 		ADD(IFM_1000_KX | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_KX) {
 		ADD(IFM_2500_KX | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_2500BASE_T) {
 		ADD(IFM_2500_T | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_5GBASE_T) {
 		ADD(IFM_5000_T | IFM_FDX, 0);
+	}
 	if (layer & IXGBE_PHYSICAL_LAYER_1000BASE_BX)
 		ADD(IFM_1000_BX10 | IFM_FDX, 0);
 	/* XXX no ifmedia_set? */
 	ADD(IFM_AUTO, 0);
 #undef ADD
 } /* ixgbe_add_media_types */
 /************************************************************************
  * ixgbe_is_sfp
  ************************************************************************/
 static inline bool
 ixgbe_is_sfp(struct ixgbe_hw *hw)
+{
 	switch (hw->mac.type) {
 	case ixgbe_mac_82598EB:
 		if (hw->phy.type == ixgbe_phy_nl)
 			return (TRUE);
 		return (FALSE);
 	case ixgbe_mac_82599EB:
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		switch (hw->mac.ops.get_media_type(hw)) {
 		case ixgbe_media_type_fiber:
 		case ixgbe_media_type_fiber_qsfp:
 			return (TRUE);
 		default:
 			return (FALSE);
+		}
 	default:
 		return (FALSE);
+	}
 } /* ixgbe_is_sfp */
 static void
 ixgbe_schedule_admin_tasklet(struct adapter *adapter)
+{
 	KASSERT(mutex_owned(&adapter->admin_mtx));
 	if (__predict_true(adapter->osdep.detaching == false)) {
 		if (adapter->admin_pending == 0)
 			workqueue_enqueue(adapter->admin_wq,
 			    &adapter->admin_wc, NULL);
 		adapter->admin_pending = 1;
+	}
+}
 /************************************************************************
  * ixgbe_config_link
  ************************************************************************/
 static void
 ixgbe_config_link(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	u32		autoneg, err = 0;
 	u32		task_requests = 0;
 	bool		sfp, negotiate = false;
 	sfp = ixgbe_is_sfp(hw);
 	if (sfp) {
 		if (hw->phy.multispeed_fiber) {
 			ixgbe_enable_tx_laser(hw);
 			task_requests |= IXGBE_REQUEST_TASK_MSF_WOI;
+		}
 		task_requests |= IXGBE_REQUEST_TASK_MOD_WOI;
 		mutex_enter(&adapter->admin_mtx);
 		adapter->task_requests |= task_requests;
 		ixgbe_schedule_admin_tasklet(adapter);
 		mutex_exit(&adapter->admin_mtx);
 	} else {
 		struct ifmedia	*ifm = &adapter->media;
 		if (hw->mac.ops.check_link)
 			err = ixgbe_check_link(hw, &adapter->link_speed,
 			    &adapter->link_up, FALSE);
 		if (err)
 			return;
 		/*
 		 * Check if it's the first call. If it's the first call,
 		 * get value for auto negotiation.
 		 */
 		autoneg = hw->phy.autoneg_advertised;
 		if ((IFM_SUBTYPE(ifm->ifm_cur->ifm_media) != IFM_NONE)
 		    && ((!autoneg) && (hw->mac.ops.get_link_capabilities)))
 			err = hw->mac.ops.get_link_capabilities(hw, &autoneg,
 			    &negotiate);
 		if (err)
 			return;
 		if (hw->mac.ops.setup_link)
 			err = hw->mac.ops.setup_link(hw, autoneg,
 			    adapter->link_up);
+	}
 } /* ixgbe_config_link */
 /************************************************************************
  * ixgbe_update_stats_counters - Update board statistics counters.
  ************************************************************************/
 static void
 ixgbe_update_stats_counters(struct adapter *adapter)
+{
 	struct ifnet	      *ifp = adapter->ifp;
 	struct ixgbe_hw	      *hw = &adapter->hw;
 	struct ixgbe_hw_stats *stats = &adapter->stats.pf;
 	u32		      missed_rx = 0, bprc, lxontxc, lxofftxc;
 	u64		      total, total_missed_rx = 0;
 	uint64_t	      crcerrs, illerrc, rlec, ruc, rfc, roc, rjc;
 	unsigned int	      queue_counters;
 	int		      i;
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_CRCERRS, crcerrs);
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_ILLERRC, illerrc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_ERRBC, errbc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_MSPDC, mspdc);
 	if (hw->mac.type >= ixgbe_mac_X550)
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_MBSDC, mbsdc);
 	/* 16 registers exist */
 	queue_counters = uimin(__arraycount(stats->qprc), adapter->num_queues);
 	for (i = 0; i < queue_counters; i++) {
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_QPRC(i), qprc[i]);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_QPTC(i), qptc[i]);
 		if (hw->mac.type >= ixgbe_mac_82599EB)
 			IXGBE_EVC_REGADD(hw, stats, IXGBE_QPRDC(i), qprdc[i]);
+	}
 	/* 8 registers exist */
 	for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) {
 		uint32_t mp;
 		/* MPC */
 		mp = IXGBE_READ_REG(hw, IXGBE_MPC(i));
 		/* global total per queue */
 		IXGBE_EVC_ADD(&stats->mpc[i], mp);
 		/* running comprehensive total for stats display */
 		total_missed_rx += mp;
 		if (hw->mac.type == ixgbe_mac_82598EB)
 			IXGBE_EVC_REGADD(hw, stats, IXGBE_RNBC(i), rnbc[i]);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_PXONTXC(i), pxontxc[i]);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_PXOFFTXC(i), pxofftxc[i]);
 		if (hw->mac.type >= ixgbe_mac_82599EB) {
 			IXGBE_EVC_REGADD(hw, stats, IXGBE_PXONRXCNT(i), pxonrxc[i]);
 			IXGBE_EVC_REGADD(hw, stats, IXGBE_PXOFFRXCNT(i), pxoffrxc[i]);
 			IXGBE_EVC_REGADD(hw, stats, IXGBE_PXON2OFFCNT(i),
 			    pxon2offc[i]);
 		} else {
 			IXGBE_EVC_REGADD(hw, stats, IXGBE_PXONRXC(i), pxonrxc[i]);
 			IXGBE_EVC_REGADD(hw, stats, IXGBE_PXOFFRXC(i), pxoffrxc[i]);
+		}
+	}
 	IXGBE_EVC_ADD(&stats->mpctotal, total_missed_rx);
 	/* Document says M[LR]FC are valid when link is up and 10Gbps */
 	if ((adapter->link_active == LINK_STATE_UP)
 	    && (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL)) {
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_MLFC, mlfc);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_MRFC, mrfc);
+	}
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_RLEC, rlec);
 	/* Hardware workaround, gprc counts missed packets */
 	IXGBE_EVC_ADD(&stats->gprc,
 	    IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx);
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_LXONTXC, lxontxc);
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_LXOFFTXC, lxofftxc);
 	total = lxontxc + lxofftxc;
 	if (hw->mac.type != ixgbe_mac_82598EB) {
 		IXGBE_EVC_ADD(&stats->gorc, IXGBE_READ_REG(hw, IXGBE_GORCL) +
 		    ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32));
 		IXGBE_EVC_ADD(&stats->gotc, IXGBE_READ_REG(hw, IXGBE_GOTCL) +
 		    ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32)
 		    - total * ETHER_MIN_LEN);
 		IXGBE_EVC_ADD(&stats->tor, IXGBE_READ_REG(hw, IXGBE_TORL) +
 		    ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32));
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_LXONRXCNT, lxonrxc);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_LXOFFRXCNT, lxoffrxc);
 	} else {
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_LXONRXC, lxonrxc);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_LXOFFRXC, lxoffrxc);
 		/* 82598 only has a counter in the high register */
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_GORCH, gorc);
 		IXGBE_EVC_ADD(&stats->gotc, IXGBE_READ_REG(hw, IXGBE_GOTCH)
 		    - total * ETHER_MIN_LEN);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_TORH, tor);
+	}
 	/*
 	 * Workaround: mprc hardware is incorrectly counting
 	 * broadcasts, so for now we subtract those.
 	 */
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_BPRC, bprc);
 	IXGBE_EVC_ADD(&stats->mprc, IXGBE_READ_REG(hw, IXGBE_MPRC)
 	    - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0));
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PRC64, prc64);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PRC127, prc127);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PRC255, prc255);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PRC511, prc511);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PRC1023, prc1023);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PRC1522, prc1522);
 	IXGBE_EVC_ADD(&stats->gptc, IXGBE_READ_REG(hw, IXGBE_GPTC) - total);
 	IXGBE_EVC_ADD(&stats->mptc, IXGBE_READ_REG(hw, IXGBE_MPTC) - total);
 	IXGBE_EVC_ADD(&stats->ptc64, IXGBE_READ_REG(hw, IXGBE_PTC64) - total);
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_RUC, ruc);
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_RFC, rfc);
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_ROC, roc);
 	IXGBE_EVC_REGADD2(hw, stats, IXGBE_RJC, rjc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_MNGPRC, mngprc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_MNGPDC, mngpdc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_MNGPTC, mngptc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_TPR, tpr);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_TPT, tpt);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PTC127, ptc127);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PTC255, ptc255);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PTC511, ptc511);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PTC1023, ptc1023);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_PTC1522, ptc1522);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_BPTC, bptc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_XEC, xec);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_FCCRC, fccrc);
 	IXGBE_EVC_REGADD(hw, stats, IXGBE_FCLAST, fclast);
 	/* Only read FCOE on 82599 */
 	if (hw->mac.type != ixgbe_mac_82598EB) {
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_FCOERPDC, fcoerpdc);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_FCOEPRC, fcoeprc);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_FCOEPTC, fcoeptc);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_FCOEDWRC, fcoedwrc);
 		IXGBE_EVC_REGADD(hw, stats, IXGBE_FCOEDWTC, fcoedwtc);
+	}
 	/*
 	 * Fill out the OS statistics structure. Only RX errors are required
 	 * here because all TX counters are incremented in the TX path and
 	 * normal RX counters are prepared in ether_input().
 	 */
 	net_stat_ref_t nsr = IF_STAT_GETREF(ifp);
 	if_statadd_ref(nsr, if_iqdrops, total_missed_rx);
 	/*
 	 * Aggregate following types of errors as RX errors:
 	 * - CRC error count,
 	 * - illegal byte error count,
 	 * - length error count,
 	 * - undersized packets count,
 	 * - fragmented packets count,
 	 * - oversized packets count,
 	 * - jabber count.
 	 */
 	if_statadd_ref(nsr, if_ierrors,
 	    crcerrs + illerrc + rlec + ruc + rfc + roc + rjc);
 	IF_STAT_PUTREF(ifp);
 } /* ixgbe_update_stats_counters */
 /************************************************************************
  * ixgbe_add_hw_stats
+ *
  *   Add sysctl variables, one per statistic, to the system.
  ************************************************************************/
 static void
 ixgbe_add_hw_stats(struct adapter *adapter)
+{
 	device_t dev = adapter->dev;
 	const struct sysctlnode *rnode, *cnode;
 	struct sysctllog **log = &adapter->sysctllog;
 	struct tx_ring *txr = adapter->tx_rings;
 	struct rx_ring *rxr = adapter->rx_rings;
 	struct ixgbe_hw *hw = &adapter->hw;
 	struct ixgbe_hw_stats *stats = &adapter->stats.pf;
 	const char *xname = device_xname(dev);
 	int i;
 	/* Driver Statistics */
 	evcnt_attach_dynamic(&adapter->efbig_tx_dma_setup, EVCNT_TYPE_MISC,
 	    NULL, xname, "Driver tx dma soft fail EFBIG");
 	evcnt_attach_dynamic(&adapter->mbuf_defrag_failed, EVCNT_TYPE_MISC,
 	    NULL, xname, "m_defrag() failed");
 	evcnt_attach_dynamic(&adapter->efbig2_tx_dma_setup, EVCNT_TYPE_MISC,
 	    NULL, xname, "Driver tx dma hard fail EFBIG");
 	evcnt_attach_dynamic(&adapter->einval_tx_dma_setup, EVCNT_TYPE_MISC,
 	    NULL, xname, "Driver tx dma hard fail EINVAL");
 	evcnt_attach_dynamic(&adapter->other_tx_dma_setup, EVCNT_TYPE_MISC,
 	    NULL, xname, "Driver tx dma hard fail other");
 	evcnt_attach_dynamic(&adapter->eagain_tx_dma_setup, EVCNT_TYPE_MISC,
 	    NULL, xname, "Driver tx dma soft fail EAGAIN");
 	evcnt_attach_dynamic(&adapter->enomem_tx_dma_setup, EVCNT_TYPE_MISC,
 	    NULL, xname, "Driver tx dma soft fail ENOMEM");
 	evcnt_attach_dynamic(&adapter->watchdog_events, EVCNT_TYPE_MISC,
 	    NULL, xname, "Watchdog timeouts");
 	evcnt_attach_dynamic(&adapter->tso_err, EVCNT_TYPE_MISC,
 	    NULL, xname, "TSO errors");
 	evcnt_attach_dynamic(&adapter->admin_irqev, EVCNT_TYPE_INTR,
 	    NULL, xname, "Admin MSI-X IRQ Handled");
 	evcnt_attach_dynamic(&adapter->link_workev, EVCNT_TYPE_INTR,
 	    NULL, xname, "Link event");
 	evcnt_attach_dynamic(&adapter->mod_workev, EVCNT_TYPE_INTR,
 	    NULL, xname, "SFP+ module event");
 	evcnt_attach_dynamic(&adapter->msf_workev, EVCNT_TYPE_INTR,
 	    NULL, xname, "Multispeed event");
 	evcnt_attach_dynamic(&adapter->phy_workev, EVCNT_TYPE_INTR,
 	    NULL, xname, "External PHY event");
 	/* Max number of traffic class is 8 */
 	KASSERT(IXGBE_DCB_MAX_TRAFFIC_CLASS == 8);
 	for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) {
 		snprintf(adapter->tcs[i].evnamebuf,
 		    sizeof(adapter->tcs[i].evnamebuf), "%s tc%d",
 		    xname, i);
 		if (i < __arraycount(stats->mpc)) {
 			evcnt_attach_dynamic(&stats->mpc[i],
 			    EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf,
 			    "RX Missed Packet Count");
 			if (hw->mac.type == ixgbe_mac_82598EB)
 				evcnt_attach_dynamic(&stats->rnbc[i],
 				    EVCNT_TYPE_MISC, NULL,
 				    adapter->tcs[i].evnamebuf,
 				    "Receive No Buffers");
+		}
 		if (i < __arraycount(stats->pxontxc)) {
 			evcnt_attach_dynamic(&stats->pxontxc[i],
 			    EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf,
 			    "pxontxc");
 			evcnt_attach_dynamic(&stats->pxonrxc[i],
 			    EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf,
 			    "pxonrxc");
 			evcnt_attach_dynamic(&stats->pxofftxc[i],
 			    EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf,
 			    "pxofftxc");
 			evcnt_attach_dynamic(&stats->pxoffrxc[i],
 			    EVCNT_TYPE_MISC, NULL, adapter->tcs[i].evnamebuf,
 			    "pxoffrxc");
 			if (hw->mac.type >= ixgbe_mac_82599EB)
 				evcnt_attach_dynamic(&stats->pxon2offc[i],
 				    EVCNT_TYPE_MISC, NULL,
 				    adapter->tcs[i].evnamebuf,
 			    "pxon2offc");
+		}
+	}
 	for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) {
 #ifdef LRO
 		struct lro_ctrl *lro = &rxr->lro;
 #endif /* LRO */
 		snprintf(adapter->queues[i].evnamebuf,
 		    sizeof(adapter->queues[i].evnamebuf), "%s q%d",
 		    xname, i);
 		snprintf(adapter->queues[i].namebuf,
 		    sizeof(adapter->queues[i].namebuf), "q%d", i);
 		if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) {
 			aprint_error_dev(dev, "could not create sysctl root\n");
 			break;
+		}
 		if (sysctl_createv(log, 0, &rnode, &rnode,
 , CTLTYPE_NODE,
 		    adapter->queues[i].namebuf, SYSCTL_DESCR("Queue Name"),
 		    NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READWRITE, CTLTYPE_INT,
 		    "interrupt_rate", SYSCTL_DESCR("Interrupt Rate"),
 		    ixgbe_sysctl_interrupt_rate_handler, 0,
 		    (void *)&adapter->queues[i], 0, CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT,
 		    "txd_head", SYSCTL_DESCR("Transmit Descriptor Head"),
 		    ixgbe_sysctl_tdh_handler, 0, (void *)txr,
 , CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT,
 		    "txd_tail", SYSCTL_DESCR("Transmit Descriptor Tail"),
 		    ixgbe_sysctl_tdt_handler, 0, (void *)txr,
 , CTL_CREATE, CTL_EOL) != 0)
 			break;
 		evcnt_attach_dynamic(&adapter->queues[i].irqs, EVCNT_TYPE_INTR,
 		    NULL, adapter->queues[i].evnamebuf, "IRQs on queue");
 		evcnt_attach_dynamic(&adapter->queues[i].handleq,
 		    EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf,
 		    "Handled queue in softint");
 		evcnt_attach_dynamic(&adapter->queues[i].req, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Requeued in softint");
 		evcnt_attach_dynamic(&txr->tso_tx, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "TSO");
 		evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "TX Queue No Descriptor Available");
 		evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Packets Transmitted");
 #ifndef IXGBE_LEGACY_TX
 		evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Packets dropped in pcq");
 #endif
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxck",
 		    SYSCTL_DESCR("Receive Descriptor next to check"),
 		    ixgbe_sysctl_next_to_check_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxrf",
 		    SYSCTL_DESCR("Receive Descriptor next to refresh"),
 		    ixgbe_sysctl_next_to_refresh_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_head",
 		    SYSCTL_DESCR("Receive Descriptor Head"),
 		    ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_tail",
 		    SYSCTL_DESCR("Receive Descriptor Tail"),
 		    ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (i < __arraycount(stats->qprc)) {
 			evcnt_attach_dynamic(&stats->qprc[i], EVCNT_TYPE_MISC,
 			    NULL, adapter->queues[i].evnamebuf, "qprc");
 			evcnt_attach_dynamic(&stats->qptc[i], EVCNT_TYPE_MISC,
 			    NULL, adapter->queues[i].evnamebuf, "qptc");
 			evcnt_attach_dynamic(&stats->qbrc[i], EVCNT_TYPE_MISC,
 			    NULL, adapter->queues[i].evnamebuf, "qbrc");
 			evcnt_attach_dynamic(&stats->qbtc[i], EVCNT_TYPE_MISC,
 			    NULL, adapter->queues[i].evnamebuf, "qbtc");
 			if (hw->mac.type >= ixgbe_mac_82599EB)
 				evcnt_attach_dynamic(&stats->qprdc[i],
 				    EVCNT_TYPE_MISC, NULL,
 				    adapter->queues[i].evnamebuf, "qprdc");
+		}
 		evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Packets Received");
 		evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Bytes Received");
 		evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Copied RX Frames");
 		evcnt_attach_dynamic(&rxr->no_mbuf, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Rx no mbuf");
 		evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Rx discarded");
 #ifdef LRO
 		SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued",
 				CTLFLAG_RD, &lro->lro_queued, 0,
 				"LRO Queued");
 		SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed",
 				CTLFLAG_RD, &lro->lro_flushed, 0,
 				"LRO Flushed");
 #endif /* LRO */
+	}
 	/* MAC stats get their own sub node */
 	snprintf(stats->namebuf,
 	    sizeof(stats->namebuf), "%s MAC Statistics", xname);
 	evcnt_attach_dynamic(&stats->ipcs, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "rx csum offload - IP");
 	evcnt_attach_dynamic(&stats->l4cs, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "rx csum offload - L4");
 	evcnt_attach_dynamic(&stats->ipcs_bad, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "rx csum offload - IP bad");
 	evcnt_attach_dynamic(&stats->l4cs_bad, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "rx csum offload - L4 bad");
 	evcnt_attach_dynamic(&stats->intzero, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Interrupt conditions zero");
 	evcnt_attach_dynamic(&stats->legint, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Legacy interrupts");
 	evcnt_attach_dynamic(&stats->crcerrs, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "CRC Errors");
 	evcnt_attach_dynamic(&stats->illerrc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Illegal Byte Errors");
 	evcnt_attach_dynamic(&stats->errbc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Byte Errors");
 	evcnt_attach_dynamic(&stats->mspdc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "MAC Short Packets Discarded");
 	if (hw->mac.type >= ixgbe_mac_X550)
 		evcnt_attach_dynamic(&stats->mbsdc, EVCNT_TYPE_MISC, NULL,
 		    stats->namebuf, "Bad SFD");
 	evcnt_attach_dynamic(&stats->mpctotal, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Total Packets Missed");
 	evcnt_attach_dynamic(&stats->mlfc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "MAC Local Faults");
 	evcnt_attach_dynamic(&stats->mrfc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "MAC Remote Faults");
 	evcnt_attach_dynamic(&stats->rlec, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Receive Length Errors");
 	evcnt_attach_dynamic(&stats->lxontxc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Link XON Transmitted");
 	evcnt_attach_dynamic(&stats->lxonrxc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Link XON Received");
 	evcnt_attach_dynamic(&stats->lxofftxc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Link XOFF Transmitted");
 	evcnt_attach_dynamic(&stats->lxoffrxc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Link XOFF Received");
 	/* Packet Reception Stats */
 	evcnt_attach_dynamic(&stats->tor, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Total Octets Received");
 	evcnt_attach_dynamic(&stats->gorc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Good Octets Received");
 	evcnt_attach_dynamic(&stats->tpr, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Total Packets Received");
 	evcnt_attach_dynamic(&stats->gprc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Good Packets Received");
 	evcnt_attach_dynamic(&stats->mprc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Multicast Packets Received");
 	evcnt_attach_dynamic(&stats->bprc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Broadcast Packets Received");
 	evcnt_attach_dynamic(&stats->prc64, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "64 byte frames received ");
 	evcnt_attach_dynamic(&stats->prc127, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "65-127 byte frames received");
 	evcnt_attach_dynamic(&stats->prc255, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "128-255 byte frames received");
 	evcnt_attach_dynamic(&stats->prc511, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "256-511 byte frames received");
 	evcnt_attach_dynamic(&stats->prc1023, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "512-1023 byte frames received");
 	evcnt_attach_dynamic(&stats->prc1522, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "1023-1522 byte frames received");
 	evcnt_attach_dynamic(&stats->ruc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Receive Undersized");
 	evcnt_attach_dynamic(&stats->rfc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Fragmented Packets Received ");
 	evcnt_attach_dynamic(&stats->roc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Oversized Packets Received");
 	evcnt_attach_dynamic(&stats->rjc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Received Jabber");
 	evcnt_attach_dynamic(&stats->mngprc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Management Packets Received");
 	evcnt_attach_dynamic(&stats->mngpdc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Management Packets Dropped");
 	evcnt_attach_dynamic(&stats->xec, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Checksum Errors");
 	/* Packet Transmission Stats */
 	evcnt_attach_dynamic(&stats->gotc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Good Octets Transmitted");
 	evcnt_attach_dynamic(&stats->tpt, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Total Packets Transmitted");
 	evcnt_attach_dynamic(&stats->gptc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Good Packets Transmitted");
 	evcnt_attach_dynamic(&stats->bptc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Broadcast Packets Transmitted");
 	evcnt_attach_dynamic(&stats->mptc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Multicast Packets Transmitted");
 	evcnt_attach_dynamic(&stats->mngptc, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "Management Packets Transmitted");
 	evcnt_attach_dynamic(&stats->ptc64, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "64 byte frames transmitted ");
 	evcnt_attach_dynamic(&stats->ptc127, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "65-127 byte frames transmitted");
 	evcnt_attach_dynamic(&stats->ptc255, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "128-255 byte frames transmitted");
 	evcnt_attach_dynamic(&stats->ptc511, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "256-511 byte frames transmitted");
 	evcnt_attach_dynamic(&stats->ptc1023, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "512-1023 byte frames transmitted");
 	evcnt_attach_dynamic(&stats->ptc1522, EVCNT_TYPE_MISC, NULL,
 	    stats->namebuf, "1024-1522 byte frames transmitted");
 } /* ixgbe_add_hw_stats */
 static void
 ixgbe_clear_evcnt(struct adapter *adapter)
+{
 	struct tx_ring *txr = adapter->tx_rings;
 	struct rx_ring *rxr = adapter->rx_rings;
 	struct ixgbe_hw *hw = &adapter->hw;
 	struct ixgbe_hw_stats *stats = &adapter->stats.pf;
 	int i;
 	IXGBE_EVC_STORE(&adapter->efbig_tx_dma_setup, 0);
 	IXGBE_EVC_STORE(&adapter->mbuf_defrag_failed, 0);
 	IXGBE_EVC_STORE(&adapter->efbig2_tx_dma_setup, 0);
 	IXGBE_EVC_STORE(&adapter->einval_tx_dma_setup, 0);
 	IXGBE_EVC_STORE(&adapter->other_tx_dma_setup, 0);
 	IXGBE_EVC_STORE(&adapter->eagain_tx_dma_setup, 0);
 	IXGBE_EVC_STORE(&adapter->enomem_tx_dma_setup, 0);
 	IXGBE_EVC_STORE(&adapter->tso_err, 0);
 	IXGBE_EVC_STORE(&adapter->watchdog_events, 0);
 	IXGBE_EVC_STORE(&adapter->admin_irqev, 0);
 	IXGBE_EVC_STORE(&adapter->link_workev, 0);
 	IXGBE_EVC_STORE(&adapter->mod_workev, 0);
 	IXGBE_EVC_STORE(&adapter->msf_workev, 0);
 	IXGBE_EVC_STORE(&adapter->phy_workev, 0);