 @@ -1,1000 +1,1000 @@
-/* $NetBSD: ixgbe.c,v 1.246 2020/08/27 03:57:52 msaitoh Exp $ */
+/* $NetBSD: ixgbe.c,v 1.247 2020/08/27 04:49:52 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.
  */
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_inet6.h"
 #include "opt_net_mpsafe.h"
 #endif
 #include "ixgbe.h"
 #include "ixgbe_sriov.h"
 #include "vlan.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.10 */
 /************************************************************************
  * 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(void *);
 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 *,
 		    const struct pci_attach_args *);
 static void	ixgbe_free_workqueue(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_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_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_wol_enable(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_wufc(SYSCTLFN_PROTO);
 /* Support for pluggable optic modules */
 static bool	ixgbe_sfp_cage_full(struct adapter *);
 /* Legacy (single vector) interrupt handler */
 static int	ixgbe_legacy_irq(void *);
 /* The MSI/MSI-X Interrupt handlers */
 static int	ixgbe_msix_que(void *);
 static int	ixgbe_msix_admin(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 *);
 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_ isntead 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;
 	const char *vendor, *product;
 	/* Quirk for inverted logic of SFP+'s MOD_ABS */
 	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->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;
 	ent = ixgbe_lookup(pa);
 	KASSERT(ent != NULL);
 	aprint_normal(": %s, Version - %s\n",
 	    ixgbe_strings[ent->index], ixgbe_driver_version);
 	/* Set quirk flags */
 	ixgbe_quirks(adapter);
 	/* 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);
 	/*
 	 * 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);
 	if (hw->mbx.ops.init_params)
 		hw->mbx.ops.init_params(hw);
 	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;
 		adapter->num_segs = IXGBE_82599_SCATTER;
 	} else
 		adapter->num_segs = IXGBE_82598_SCATTER;
 	/* 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;
 	/* 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\n");
 		error = EIO;
 		goto err_late;
+	}
 @@ -3504,1999 +3504,1999 @@ map_err:
 	default:
 		aprint_error_dev(dev, "unexpected type on BAR0\n");
 		return ENXIO;
+	}
 	return (0);
 } /* ixgbe_allocate_pci_resources */
 static void
 ixgbe_free_workqueue(struct adapter *adapter)
+{
 	struct ix_queue *que = adapter->queues;
 	struct tx_ring *txr = adapter->tx_rings;
 	int i;
 	for (i = 0; i < adapter->num_queues; i++, que++, txr++) {
 		if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) {
 			if (txr->txr_si != NULL)
 				softint_disestablish(txr->txr_si);
+		}
 		if (que->que_si != NULL)
 			softint_disestablish(que->que_si);
+	}
 	if (adapter->txr_wq != NULL)
 		workqueue_destroy(adapter->txr_wq);
 	if (adapter->txr_wq_enqueued != NULL)
 		percpu_free(adapter->txr_wq_enqueued, sizeof(u_int));
 	if (adapter->que_wq != NULL)
 		workqueue_destroy(adapter->que_wq);
 	if (adapter->admin_wq != NULL) {
 		workqueue_destroy(adapter->admin_wq);
 		adapter->admin_wq = NULL;
+	}
 	if (adapter->timer_wq != NULL) {
 		workqueue_destroy(adapter->timer_wq);
 		adapter->timer_wq = NULL;
+	}
 	if (adapter->recovery_mode_timer_wq != NULL) {
 		/*
 		 * ixgbe_ifstop() doesn't call the workqueue_wait() for
 		 * the recovery_mode_timer workqueue, so call it here.
 		 */
 		workqueue_wait(adapter->recovery_mode_timer_wq,
 		    &adapter->recovery_mode_timer_wc);
 		atomic_store_relaxed(&adapter->recovery_mode_timer_pending, 0);
 		workqueue_destroy(adapter->recovery_mode_timer_wq);
 		adapter->recovery_mode_timer_wq = NULL;
+	}
 } /* ixgbe_free_workqueue */
 /************************************************************************
  * ixgbe_detach - Device removal routine
+ *
  *   Called when the driver is being removed.
  *   Stops the adapter and deallocates all the resources
  *   that were allocated for driver operation.
+ *
  *   return 0 on success, positive on failure
  ************************************************************************/
 static int
 ixgbe_detach(device_t dev, int flags)
+{
 	struct adapter *adapter = device_private(dev);
 	struct rx_ring *rxr = adapter->rx_rings;
 	struct tx_ring *txr = adapter->tx_rings;
 	struct ixgbe_hw *hw = &adapter->hw;
 	struct ixgbe_hw_stats *stats = &adapter->stats.pf;
 	u32	ctrl_ext;
 	int i;
 	INIT_DEBUGOUT("ixgbe_detach: begin");
 	if (adapter->osdep.attached == false)
 		return 0;
 	if (ixgbe_pci_iov_detach(dev) != 0) {
 		device_printf(dev, "SR-IOV in use; detach first.\n");
 		return (EBUSY);
+	}
 #if NVLAN > 0
 	/* Make sure VLANs are not using driver */
 	if (!VLAN_ATTACHED(&adapter->osdep.ec))
 		;	/* nothing to do: no VLANs */
 	else if ((flags & (DETACH_SHUTDOWN | DETACH_FORCE)) != 0)
 		vlan_ifdetach(adapter->ifp);
 	else {
 		aprint_error_dev(dev, "VLANs in use, detach first\n");
 		return (EBUSY);
+	}
 #endif
 	/*
 	 * Stop the interface. ixgbe_setup_low_power_mode() calls ixgbe_stop(),
 	 * so it's not required to call ixgbe_stop() directly.
 	 */
 	IXGBE_CORE_LOCK(adapter);
 	ixgbe_setup_low_power_mode(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	callout_halt(&adapter->timer, NULL);
 	if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE) {
 		callout_stop(&adapter->recovery_mode_timer);
 		callout_halt(&adapter->recovery_mode_timer, NULL);
+	}
 	workqueue_wait(adapter->admin_wq, &adapter->admin_wc);
 	atomic_store_relaxed(&adapter->admin_pending, 0);
 	workqueue_wait(adapter->timer_wq, &adapter->timer_wc);
 	atomic_store_relaxed(&adapter->timer_pending, 0);
 	pmf_device_deregister(dev);
 	ether_ifdetach(adapter->ifp);
 	ixgbe_free_workqueue(adapter);
 	/* 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);
 	if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
 		netmap_detach(adapter->ifp);
 	ixgbe_free_pci_resources(adapter);
 #if 0	/* XXX the NetBSD port is probably missing something here */
 	bus_generic_detach(dev);
 #endif
 	if_detach(adapter->ifp);
 	ifmedia_fini(&adapter->media);
 	if_percpuq_destroy(adapter->ipq);
 	sysctl_teardown(&adapter->sysctllog);
 	evcnt_detach(&adapter->efbig_tx_dma_setup);
 	evcnt_detach(&adapter->mbuf_defrag_failed);
 	evcnt_detach(&adapter->efbig2_tx_dma_setup);
 	evcnt_detach(&adapter->einval_tx_dma_setup);
 	evcnt_detach(&adapter->other_tx_dma_setup);
 	evcnt_detach(&adapter->eagain_tx_dma_setup);
 	evcnt_detach(&adapter->enomem_tx_dma_setup);
 	evcnt_detach(&adapter->watchdog_events);
 	evcnt_detach(&adapter->tso_err);
 	evcnt_detach(&adapter->admin_irqev);
 	evcnt_detach(&adapter->link_workev);
 	evcnt_detach(&adapter->mod_workev);
 	evcnt_detach(&adapter->msf_workev);
 	evcnt_detach(&adapter->phy_workev);
 	for (i = 0; i < IXGBE_TC_COUNTER_NUM; i++) {
 		if (i < __arraycount(stats->mpc)) {
 			evcnt_detach(&stats->mpc[i]);
 			if (hw->mac.type == ixgbe_mac_82598EB)
 				evcnt_detach(&stats->rnbc[i]);
+		}
 		if (i < __arraycount(stats->pxontxc)) {
 			evcnt_detach(&stats->pxontxc[i]);
 			evcnt_detach(&stats->pxonrxc[i]);
 			evcnt_detach(&stats->pxofftxc[i]);
 			evcnt_detach(&stats->pxoffrxc[i]);
 			if (hw->mac.type >= ixgbe_mac_82599EB)
 				evcnt_detach(&stats->pxon2offc[i]);
+		}
+	}
 	txr = adapter->tx_rings;
 	for (i = 0; i < adapter->num_queues; i++, rxr++, txr++) {
 		evcnt_detach(&adapter->queues[i].irqs);
 		evcnt_detach(&adapter->queues[i].handleq);
 		evcnt_detach(&adapter->queues[i].req);
 		evcnt_detach(&txr->no_desc_avail);
 		evcnt_detach(&txr->total_packets);
 		evcnt_detach(&txr->tso_tx);
 #ifndef IXGBE_LEGACY_TX
 		evcnt_detach(&txr->pcq_drops);
 #endif
 		if (i < __arraycount(stats->qprc)) {
 			evcnt_detach(&stats->qprc[i]);
 			evcnt_detach(&stats->qptc[i]);
 			evcnt_detach(&stats->qbrc[i]);
 			evcnt_detach(&stats->qbtc[i]);
 			if (hw->mac.type >= ixgbe_mac_82599EB)
 				evcnt_detach(&stats->qprdc[i]);
+		}
 		evcnt_detach(&rxr->rx_packets);
 		evcnt_detach(&rxr->rx_bytes);
 		evcnt_detach(&rxr->rx_copies);
 		evcnt_detach(&rxr->no_jmbuf);
 		evcnt_detach(&rxr->rx_discarded);
+	}
 	evcnt_detach(&stats->ipcs);
 	evcnt_detach(&stats->l4cs);
 	evcnt_detach(&stats->ipcs_bad);
 	evcnt_detach(&stats->l4cs_bad);
 	evcnt_detach(&stats->intzero);
 	evcnt_detach(&stats->legint);
 	evcnt_detach(&stats->crcerrs);
 	evcnt_detach(&stats->illerrc);
 	evcnt_detach(&stats->errbc);
 	evcnt_detach(&stats->mspdc);
 	if (hw->mac.type >= ixgbe_mac_X550)
 		evcnt_detach(&stats->mbsdc);
 	evcnt_detach(&stats->mpctotal);
 	evcnt_detach(&stats->mlfc);
 	evcnt_detach(&stats->mrfc);
 	evcnt_detach(&stats->rlec);
 	evcnt_detach(&stats->lxontxc);
 	evcnt_detach(&stats->lxonrxc);
 	evcnt_detach(&stats->lxofftxc);
 	evcnt_detach(&stats->lxoffrxc);
 	/* Packet Reception Stats */
 	evcnt_detach(&stats->tor);
 	evcnt_detach(&stats->gorc);
 	evcnt_detach(&stats->tpr);
 	evcnt_detach(&stats->gprc);
 	evcnt_detach(&stats->mprc);
 	evcnt_detach(&stats->bprc);
 	evcnt_detach(&stats->prc64);
 	evcnt_detach(&stats->prc127);
 	evcnt_detach(&stats->prc255);
 	evcnt_detach(&stats->prc511);
 	evcnt_detach(&stats->prc1023);
 	evcnt_detach(&stats->prc1522);
 	evcnt_detach(&stats->ruc);
 	evcnt_detach(&stats->rfc);
 	evcnt_detach(&stats->roc);
 	evcnt_detach(&stats->rjc);
 	evcnt_detach(&stats->mngprc);
 	evcnt_detach(&stats->mngpdc);
 	evcnt_detach(&stats->xec);
 	/* Packet Transmission Stats */
 	evcnt_detach(&stats->gotc);
 	evcnt_detach(&stats->tpt);
 	evcnt_detach(&stats->gptc);
 	evcnt_detach(&stats->bptc);
 	evcnt_detach(&stats->mptc);
 	evcnt_detach(&stats->mngptc);
 	evcnt_detach(&stats->ptc64);
 	evcnt_detach(&stats->ptc127);
 	evcnt_detach(&stats->ptc255);
 	evcnt_detach(&stats->ptc511);
 	evcnt_detach(&stats->ptc1023);
 	evcnt_detach(&stats->ptc1522);
 	ixgbe_free_queues(adapter);
 	free(adapter->mta, M_DEVBUF);
 	IXGBE_CORE_LOCK_DESTROY(adapter);
 	return (0);
 } /* ixgbe_detach */
 /************************************************************************
  * ixgbe_setup_low_power_mode - LPLU/WoL preparation
+ *
  *   Prepare the adapter/port for LPLU and/or WoL
  ************************************************************************/
 static int
 ixgbe_setup_low_power_mode(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	device_t	dev = adapter->dev;
 	s32		error = 0;
 	KASSERT(mutex_owned(&adapter->core_mtx));
 	/* Limit power management flow to X550EM baseT */
 	if (hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T &&
 	    hw->phy.ops.enter_lplu) {
 		/* X550EM baseT adapters need a special LPLU flow */
 		hw->phy.reset_disable = true;
 		ixgbe_stop(adapter);
 		error = hw->phy.ops.enter_lplu(hw);
 		if (error)
 			device_printf(dev,
 			    "Error entering LPLU: %d\n", error);
 		hw->phy.reset_disable = false;
 	} else {
 		/* Just stop for other adapters */
 		ixgbe_stop(adapter);
+	}
 	if (!hw->wol_enabled) {
 		ixgbe_set_phy_power(hw, FALSE);
 		IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0);
 		IXGBE_WRITE_REG(hw, IXGBE_WUC, 0);
 	} else {
 		/* Turn off support for APM wakeup. (Using ACPI instead) */
 		IXGBE_WRITE_REG(hw, IXGBE_GRC_BY_MAC(hw),
 		    IXGBE_READ_REG(hw, IXGBE_GRC_BY_MAC(hw)) & ~(u32)2);
 		/*
 		 * Clear Wake Up Status register to prevent any previous wakeup
 		 * events from waking us up immediately after we suspend.
 		 */
 		IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff);
 		/*
 		 * Program the Wakeup Filter Control register with user filter
 		 * settings
 		 */
 		IXGBE_WRITE_REG(hw, IXGBE_WUFC, adapter->wufc);
 		/* Enable wakeups and power management in Wakeup Control */
 		IXGBE_WRITE_REG(hw, IXGBE_WUC,
 		    IXGBE_WUC_WKEN | IXGBE_WUC_PME_EN);
+	}
 	return error;
 } /* ixgbe_setup_low_power_mode */
 /************************************************************************
  * ixgbe_shutdown - Shutdown entry point
  ************************************************************************/
 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */
 static int
 ixgbe_shutdown(device_t dev)
+{
 	struct adapter *adapter = device_private(dev);
 	int error = 0;
 	INIT_DEBUGOUT("ixgbe_shutdown: begin");
 	IXGBE_CORE_LOCK(adapter);
 	error = ixgbe_setup_low_power_mode(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	return (error);
 } /* ixgbe_shutdown */
 #endif
 /************************************************************************
  * ixgbe_suspend
+ *
  *   From D0 to D3
  ************************************************************************/
 static bool
 ixgbe_suspend(device_t dev, const pmf_qual_t *qual)
+{
 	struct adapter *adapter = device_private(dev);
 	int	       error = 0;
 	INIT_DEBUGOUT("ixgbe_suspend: begin");
 	IXGBE_CORE_LOCK(adapter);
 	error = ixgbe_setup_low_power_mode(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	return (error);
 } /* ixgbe_suspend */
 /************************************************************************
  * ixgbe_resume
+ *
  *   From D3 to D0
  ************************************************************************/
 static bool
 ixgbe_resume(device_t dev, const pmf_qual_t *qual)
+{
 	struct adapter	*adapter = device_private(dev);
 	struct ifnet	*ifp = adapter->ifp;
 	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)
 		device_printf(dev, "Woken up by (WUS): %#010x\n",
 		    IXGBE_READ_REG(hw, IXGBE_WUS));
 	IXGBE_WRITE_REG(hw, IXGBE_WUS, 0xffffffff);
 	/* And clear WUFC until next low-power transition */
 	IXGBE_WRITE_REG(hw, IXGBE_WUFC, 0);
 	/*
 	 * Required after D3->D0 transition;
 	 * will re-advertise all previous advertised speeds
 	 */
 	if (ifp->if_flags & IFF_UP)
 		ixgbe_init_locked(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	return true;
 } /* ixgbe_resume */
 /*
  * Set the various hardware offload abilities.
+ *
  * This 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.
  */
 static void
 ixgbe_set_if_hwassist(struct adapter *adapter)
+{
 	/* XXX */
+}
 /************************************************************************
  * ixgbe_init_locked - 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
  ************************************************************************/
 static void
 ixgbe_init_locked(struct adapter *adapter)
+{
 	struct ifnet   *ifp = adapter->ifp;
 	device_t	dev = adapter->dev;
 	struct ixgbe_hw *hw = &adapter->hw;
 	struct ix_queue *que;
 	struct tx_ring	*txr;
 	struct rx_ring	*rxr;
 	u32		txdctl, mhadd;
 	u32		rxdctl, rxctrl;
 	u32		ctrl_ext;
 	bool		unsupported_sfp = false;
 	int		i, j, err;
 	/* XXX check IFF_UP and IFF_RUNNING, power-saving state! */
 	KASSERT(mutex_owned(&adapter->core_mtx));
 	INIT_DEBUGOUT("ixgbe_init_locked: begin");
 	hw->need_unsupported_sfp_recovery = false;
 	hw->adapter_stopped = FALSE;
 	ixgbe_stop_adapter(hw);
 	callout_stop(&adapter->timer);
 	if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE)
 		callout_stop(&adapter->recovery_mode_timer);
 	for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++)
 		que->disabled_count = 0;
 	/* XXX I moved this here from the SIOCSIFMTU case in ixgbe_ioctl(). */
 	adapter->max_frame_size =
 		ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
 	/* Queue indices may change with IOV mode */
 	ixgbe_align_all_queue_indices(adapter);
 	/* reprogram the RAR[0] in case user changed it. */
 	ixgbe_set_rar(hw, 0, hw->mac.addr, adapter->pool, IXGBE_RAH_AV);
 	/* Get the latest mac address, User can use a LAA */
 	memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl),
 	    IXGBE_ETH_LENGTH_OF_ADDRESS);
 	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);
 	/* Setup Multicast table */
 	ixgbe_set_rxfilter(adapter);
 	/* Determine the correct mbuf pool, based on frame size */
 	if (adapter->max_frame_size <= MCLBYTES)
 		adapter->rx_mbuf_sz = MCLBYTES;
 	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);
 	/* Initialize variable holding task enqueue requests interrupts */
 	adapter->task_requests = 0;
 	/* Enable SDP & MSI-X interrupts based on adapter */
 	ixgbe_config_gpie(adapter);
 	/* Set MTU size */
 	if (ifp->if_mtu > ETHERMTU) {
 		/* aka IXGBE_MAXFRS on 82599 and newer */
 		mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD);
 		mhadd &= ~IXGBE_MHADD_MFS_MASK;
 		mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT;
 		IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd);
+	}
 	/* Now enable all the queues */
 	for (i = 0; i < adapter->num_queues; i++) {
 		txr = &adapter->tx_rings[i];
 		txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txr->me));
 		txdctl |= IXGBE_TXDCTL_ENABLE;
 		/* Set WTHRESH to 8, burst writeback */
 		txdctl |= (8 << 16);
 		/*
 		 * When the internal queue falls below PTHRESH (32),
 		 * start prefetching as long as there are at least
 		 * HTHRESH (1) buffers ready. The values are taken
 		 * from the Intel linux driver 3.8.21.
 		 * Prefetching enables tx line rate even with 1 queue.
 		 */
 		txdctl |= (32 << 0) | (1 << 8);
 		IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txr->me), txdctl);
+	}
 	for (i = 0; i < adapter->num_queues; i++) {
 		rxr = &adapter->rx_rings[i];
 		rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me));
 		if (hw->mac.type == ixgbe_mac_82598EB) {
 			/*
 			 * PTHRESH = 21
 			 * HTHRESH = 4
 			 * WTHRESH = 8
 			 */
 			rxdctl &= ~0x3FFFFF;
 			rxdctl |= 0x080420;
+		}
 		rxdctl |= IXGBE_RXDCTL_ENABLE;
 		IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxr->me), rxdctl);
 		for (j = 0; j < 10; j++) {
 			if (IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxr->me)) &
 			    IXGBE_RXDCTL_ENABLE)
 				break;
 			else
 				msec_delay(1);
+		}
 		IXGBE_WRITE_BARRIER(hw);
 		/*
 		 * 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 */
 	rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
 	if (hw->mac.type == ixgbe_mac_82598EB)
 		rxctrl |= IXGBE_RXCTRL_DMBYPS;
 	rxctrl |= IXGBE_RXCTRL_RXEN;
 	ixgbe_enable_rx_dma(hw, rxctrl);
 	callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter);
 	atomic_store_relaxed(&adapter->timer_pending, 0);
 	if (adapter->feat_en & IXGBE_FEATURE_RECOVERY_MODE)
 		callout_reset(&adapter->recovery_mode_timer, hz,
 		    ixgbe_recovery_mode_timer, adapter);
 	/* Set up MSI/MSI-X routing */
 	if (adapter->feat_en & IXGBE_FEATURE_MSIX) {
 		ixgbe_configure_ivars(adapter);
 		/* Set up auto-mask */
 		if (hw->mac.type == ixgbe_mac_82598EB)
 			IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE);
 		else {
 			IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(0), 0xFFFFFFFF);
 			IXGBE_WRITE_REG(hw, IXGBE_EIAM_EX(1), 0xFFFFFFFF);
+		}
 	} else {  /* Simple settings for Legacy/MSI */
 		ixgbe_set_ivar(adapter, 0, 0, 0);
 		ixgbe_set_ivar(adapter, 0, 0, 1);
 		IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE);
+	}
 	ixgbe_init_fdir(adapter);
 	/*
 	 * Check on any SFP devices that
 	 * need to be kick-started
 	 */
 	if (hw->phy.type == ixgbe_phy_none) {
 		err = hw->phy.ops.identify(hw);
 		if (err == IXGBE_ERR_SFP_NOT_SUPPORTED)
 			unsupported_sfp = true;
 	} else if (hw->phy.type == ixgbe_phy_sfp_unsupported)
 		unsupported_sfp = true;
 	if (unsupported_sfp)
 		device_printf(dev,
 		    "Unsupported SFP+ module type was detected.\n");
 	/* Set moderation on the Link interrupt */
 	ixgbe_eitr_write(adapter, adapter->vector, IXGBE_LINK_ITR);
 	/* 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) {
 		ixgbe_set_phy_power(hw, TRUE);
 		/* Config/Enable Link */
 		ixgbe_config_link(adapter);
+	}
 	/* Hardware Packet Buffer & Flow Control setup */
 	ixgbe_config_delay_values(adapter);
 	/* Initialize the FC settings */
 	ixgbe_start_hw(hw);
 	/* Set up VLAN support and filter */
 	ixgbe_setup_vlan_hw_support(adapter);
 	/* Setup DMA Coalescing */
 	ixgbe_config_dmac(adapter);
 	/* OK to schedule workqueues. */
 	adapter->schedule_wqs_ok = true;
 	/* And now turn on interrupts */
 	ixgbe_enable_intr(adapter);
 	/* Enable the use of the MBX by the VF's */
 	if (adapter->feat_en & IXGBE_FEATURE_SRIOV) {
 		ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT);
 		ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD;
 		IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext);
+	}
 	/* Update saved flags. See ixgbe_ifflags_cb() */
 	adapter->if_flags = ifp->if_flags;
 	adapter->ec_capenable = adapter->osdep.ec.ec_capenable;
 	/* Now inform the stack we're ready */
 	ifp->if_flags |= IFF_RUNNING;
 	return;
 } /* ixgbe_init_locked */
 /************************************************************************
  * ixgbe_init
  ************************************************************************/
 static int
 ixgbe_init(struct ifnet *ifp)
+{
 	struct adapter *adapter = ifp->if_softc;
 	IXGBE_CORE_LOCK(adapter);
 	ixgbe_init_locked(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	return 0;	/* XXX ixgbe_init_locked cannot fail?  really? */
 } /* ixgbe_init */
 /************************************************************************
  * ixgbe_set_ivar
+ *
  *   Setup the correct IVAR register for a particular MSI-X interrupt
  *     (yes this is all very magic and confusing :)
  *    - entry is the register array entry
  *    - vector is the MSI-X vector for this queue
  *    - type is RX/TX/MISC
  ************************************************************************/
 static void
 ixgbe_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	u32 ivar, index;
 	vector |= IXGBE_IVAR_ALLOC_VAL;
 	switch (hw->mac.type) {
 	case ixgbe_mac_82598EB:
 		if (type == -1)
 			entry = IXGBE_IVAR_OTHER_CAUSES_INDEX;
 		else
 			entry += (type * 64);
 		index = (entry >> 2) & 0x1F;
 		ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index));
 		ivar &= ~(0xffUL << (8 * (entry & 0x3)));
 		ivar |= ((u32)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:
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		if (type == -1) { /* MISC IVAR */
 			index = (entry & 1) * 8;
 			ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC);
 			ivar &= ~(0xffUL << index);
 			ivar |= ((u32)vector << index);
 			IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar);
 		} else {	/* RX/TX IVARS */
 			index = (16 * (entry & 1)) + (8 * type);
 			ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1));
 			ivar &= ~(0xffUL << index);
 			ivar |= ((u32)vector << index);
 			IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar);
+		}
 		break;
 	default:
 		break;
+	}
 } /* ixgbe_set_ivar */
 /************************************************************************
  * ixgbe_configure_ivars
  ************************************************************************/
 static void
 ixgbe_configure_ivars(struct adapter *adapter)
+{
 	struct ix_queue *que = adapter->queues;
 	u32		newitr;
 	if (ixgbe_max_interrupt_rate > 0)
 		newitr = (4000000 / ixgbe_max_interrupt_rate) & 0x0FF8;
 	else {
 		/*
 		 * Disable DMA coalescing if interrupt moderation is
 		 * disabled.
 		 */
 		adapter->dmac = 0;
 		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];
 		/* 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);
 		/* Set an Initial EITR value */
 		ixgbe_eitr_write(adapter, que->msix, newitr);
 		/*
 		 * To eliminate influence of the previous state.
 		 * At this point, Tx/Rx interrupt handler
 		 * (ixgbe_msix_que()) cannot be called, so  both
 		 * IXGBE_TX_LOCK and IXGBE_RX_LOCK are not required.
 		 */
 		que->eitr_setting = 0;
+	}
 	/* For the Link interrupt */
 	ixgbe_set_ivar(adapter, 1, adapter->vector, -1);
 } /* ixgbe_configure_ivars */
 /************************************************************************
  * ixgbe_config_gpie
  ************************************************************************/
 static void
 ixgbe_config_gpie(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	u32		gpie;
 	gpie = IXGBE_READ_REG(hw, IXGBE_GPIE);
 	if (adapter->feat_en & IXGBE_FEATURE_MSIX) {
 		/* Enable Enhanced MSI-X mode */
 		gpie |= IXGBE_GPIE_MSIX_MODE
 		     |	IXGBE_GPIE_EIAME
 		     |	IXGBE_GPIE_PBA_SUPPORT
 		     |	IXGBE_GPIE_OCD;
+	}
 	/* Fan Failure Interrupt */
 	if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL)
 		gpie |= IXGBE_SDP1_GPIEN;
 	/* Thermal Sensor Interrupt */
 	if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR)
 		gpie |= IXGBE_SDP0_GPIEN_X540;
 	/* Link detection */
 	switch (hw->mac.type) {
 	case ixgbe_mac_82599EB:
 		gpie |= IXGBE_SDP1_GPIEN | IXGBE_SDP2_GPIEN;
 		break;
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		gpie |= IXGBE_SDP0_GPIEN_X540;
 		break;
 	default:
 		break;
+	}
 	IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);
 } /* ixgbe_config_gpie */
 /************************************************************************
  * ixgbe_config_delay_values
+ *
  *   Requires adapter->max_frame_size to be set.
  ************************************************************************/
 static void
 ixgbe_config_delay_values(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	u32		rxpb, frame, size, tmp;
 	frame = adapter->max_frame_size;
 	/* Calculate High Water */
 	switch (hw->mac.type) {
 	case ixgbe_mac_X540:
 	case ixgbe_mac_X550:
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		tmp = IXGBE_DV_X540(frame, frame);
 		break;
 	default:
 		tmp = IXGBE_DV(frame, frame);
 		break;
+	}
 	size = IXGBE_BT2KB(tmp);
 	rxpb = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(0)) >> 10;
 	hw->fc.high_water[0] = rxpb - size;
 	/* Now calculate Low Water */
 	switch (hw->mac.type) {
 	case ixgbe_mac_X540:
 	case ixgbe_mac_X550:
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		tmp = IXGBE_LOW_DV_X540(frame);
 		break;
 	default:
 		tmp = IXGBE_LOW_DV(frame);
 		break;
+	}
 	hw->fc.low_water[0] = IXGBE_BT2KB(tmp);
 	hw->fc.pause_time = IXGBE_FC_PAUSE;
 	hw->fc.send_xon = TRUE;
 } /* ixgbe_config_delay_values */
 /************************************************************************
  * ixgbe_set_rxfilter - Multicast Update
+ *
  *   Called whenever multicast address list is updated.
  ************************************************************************/
 static void
 ixgbe_set_rxfilter(struct adapter *adapter)
+{
 	struct ixgbe_mc_addr	*mta;
 	struct ifnet		*ifp = adapter->ifp;
 	u8			*update_ptr;
 	int			mcnt = 0;
 	u32			fctrl;
 	struct ethercom		*ec = &adapter->osdep.ec;
 	struct ether_multi	*enm;
 	struct ether_multistep	step;
 	KASSERT(mutex_owned(&adapter->core_mtx));
 	IOCTL_DEBUGOUT("ixgbe_set_rxfilter: begin");
 	mta = adapter->mta;
 	bzero(mta, sizeof(*mta) * MAX_NUM_MULTICAST_ADDRESSES);
 	ETHER_LOCK(ec);
 	ec->ec_flags &= ~ETHER_F_ALLMULTI;
 	ETHER_FIRST_MULTI(step, ec, enm);
 	while (enm != NULL) {
 		if ((mcnt == MAX_NUM_MULTICAST_ADDRESSES) ||
 		    (memcmp(enm->enm_addrlo, enm->enm_addrhi,
 			ETHER_ADDR_LEN) != 0)) {
 			ec->ec_flags |= ETHER_F_ALLMULTI;
 			break;
+		}
 		bcopy(enm->enm_addrlo,
 		    mta[mcnt].addr, IXGBE_ETH_LENGTH_OF_ADDRESS);
 		mta[mcnt].vmdq = adapter->pool;
 		mcnt++;
 		ETHER_NEXT_MULTI(step, enm);
+	}
 	fctrl = IXGBE_READ_REG(&adapter->hw, IXGBE_FCTRL);
 	if (ifp->if_flags & IFF_PROMISC)
 		fctrl |= (IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
 	else if (ec->ec_flags & ETHER_F_ALLMULTI) {
 		fctrl |= IXGBE_FCTRL_MPE;
 		fctrl &= ~IXGBE_FCTRL_UPE;
 	} else
 		fctrl &= ~(IXGBE_FCTRL_UPE | IXGBE_FCTRL_MPE);
 	IXGBE_WRITE_REG(&adapter->hw, IXGBE_FCTRL, fctrl);
 	/* Update multicast filter entries only when it's not ALLMULTI */
 	if ((ec->ec_flags & ETHER_F_ALLMULTI) == 0) {
 		ETHER_UNLOCK(ec);
 		update_ptr = (u8 *)mta;
 		ixgbe_update_mc_addr_list(&adapter->hw, update_ptr, mcnt,
 		    ixgbe_mc_array_itr, TRUE);
 	} else
 		ETHER_UNLOCK(ec);
 } /* ixgbe_set_rxfilter */
 /************************************************************************
  * ixgbe_mc_array_itr
+ *
  *   An iterator function needed by the multicast shared code.
  *   It feeds the shared code routine the addresses in the
  *   array of ixgbe_set_rxfilter() one by one.
  ************************************************************************/
 static u8 *
 ixgbe_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq)
+{
 	struct ixgbe_mc_addr *mta;
 	mta = (struct ixgbe_mc_addr *)*update_ptr;
 	*vmdq = mta->vmdq;
 	*update_ptr = (u8*)(mta + 1);
 	return (mta->addr);
 } /* ixgbe_mc_array_itr */
 /************************************************************************
  * ixgbe_local_timer - Timer routine
+ *
  *   Checks for link status, updates statistics,
  *   and runs the watchdog check.
  ************************************************************************/
 static void
 ixgbe_local_timer(void *arg)
+{
 	struct adapter *adapter = arg;
 	if (adapter->schedule_wqs_ok) {
 		if (atomic_cas_uint(&adapter->timer_pending, 0, 1) == 0)
 			workqueue_enqueue(adapter->timer_wq,
 			    &adapter->timer_wc, NULL);
+	}
+}
 static void
 ixgbe_handle_timer(struct work *wk, void *context)
+{
 	struct adapter	*adapter = context;
 	struct ixgbe_hw *hw = &adapter->hw;
 	device_t	dev = adapter->dev;
 	struct ix_queue	*que = adapter->queues;
 	u64		queues = 0;
 	u64		v0, v1, v2, v3, v4, v5, v6, v7;
 	int		hung = 0;
 	int		i;
 	IXGBE_CORE_LOCK(adapter);
 	/* Check for pluggable optics */
 	if (ixgbe_is_sfp(hw)) {
 		bool was_full = hw->phy.sfp_type != ixgbe_sfp_type_not_present;
-		bool is_full = ixgbe_sfp_cage_full(hw);
+		bool is_full = ixgbe_sfp_cage_full(adapter);
 		/* do probe if cage state changed */
 		if (was_full ^ is_full) {
 			atomic_or_32(&adapter->task_requests,
 			    IXGBE_REQUEST_TASK_MOD);
 			ixgbe_schedule_admin_tasklet(adapter);
+		}
+	}
 	ixgbe_update_link_status(adapter);
 	ixgbe_update_stats_counters(adapter);
 	/* Update some event counters */
 	v0 = v1 = v2 = v3 = v4 = v5 = v6 = v7 = 0;
 	que = adapter->queues;
 	for (i = 0; i < adapter->num_queues; i++, que++) {
 		struct tx_ring	*txr = que->txr;
 		v0 += txr->q_efbig_tx_dma_setup;
 		v1 += txr->q_mbuf_defrag_failed;
 		v2 += txr->q_efbig2_tx_dma_setup;
 		v3 += txr->q_einval_tx_dma_setup;
 		v4 += txr->q_other_tx_dma_setup;
 		v5 += txr->q_eagain_tx_dma_setup;
 		v6 += txr->q_enomem_tx_dma_setup;
 		v7 += txr->q_tso_err;
+	}
 	adapter->efbig_tx_dma_setup.ev_count = v0;
 	adapter->mbuf_defrag_failed.ev_count = v1;
 	adapter->efbig2_tx_dma_setup.ev_count = v2;
 	adapter->einval_tx_dma_setup.ev_count = v3;
 	adapter->other_tx_dma_setup.ev_count = v4;
 	adapter->eagain_tx_dma_setup.ev_count = v5;
 	adapter->enomem_tx_dma_setup.ev_count = v6;
 	adapter->tso_err.ev_count = v7;
 	/*
 	 * Check the TX queues status
 	 *	- mark hung queues so we don't schedule on them
 	 *	- watchdog only if all queues show hung
 	 */
 	que = adapter->queues;
 	for (i = 0; i < adapter->num_queues; i++, que++) {
 		/* Keep track of queues with work for soft irq */
 		if (que->txr->busy)
 			queues |= 1ULL << 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 &= ~(1ULL << que->me);
 			continue;
 		} else {
 			/* Check if we've come back from hung */
 			if ((adapter->active_queues & (1ULL << que->me)) == 0)
 				adapter->active_queues |= 1ULL << 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;
 #if 0 /* XXX Avoid unexpectedly disabling interrupt forever (PR#53294) */
 	else if (queues != 0) { /* Force an IRQ on queues with work */
 		que = adapter->queues;
 		for (i = 0; i < adapter->num_queues; i++, que++) {
 			mutex_enter(&que->dc_mtx);
 			if (que->disabled_count == 0)
 				ixgbe_rearm_queues(adapter,
 				    queues & ((u64)1 << i));
 			mutex_exit(&que->dc_mtx);
+		}
+	}
 #endif
 	atomic_store_relaxed(&adapter->timer_pending, 0);
 	IXGBE_CORE_UNLOCK(adapter);
 	callout_reset(&adapter->timer, hz, ixgbe_local_timer, adapter);
 	return;
 watchdog:
 	device_printf(adapter->dev, "Watchdog timeout -- resetting\n");
 	adapter->ifp->if_flags &= ~IFF_RUNNING;
 	adapter->watchdog_events.ev_count++;
 	ixgbe_init_locked(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 } /* ixgbe_handle_timer */
 /************************************************************************
  * ixgbe_recovery_mode_timer - Recovery mode timer routine
  ************************************************************************/
 static void
 ixgbe_recovery_mode_timer(void *arg)
+{
 	struct adapter *adapter = arg;
 	if (atomic_cas_uint(&adapter->recovery_mode_timer_pending, 0, 1) == 0)
+	{
 		workqueue_enqueue(adapter->recovery_mode_timer_wq,
 		    &adapter->recovery_mode_timer_wc, NULL);
+	}
+}
 static void
 ixgbe_handle_recovery_mode_timer(struct work *wk, void *context)
+{
 	struct adapter *adapter = context;
 	struct ixgbe_hw *hw = &adapter->hw;
 	IXGBE_CORE_LOCK(adapter);
 	if (ixgbe_fw_recovery_mode(hw)) {
 		if (atomic_cas_uint(&adapter->recovery_mode, 0, 1)) {
 			/* Firmware error detected, entering recovery mode */
 			device_printf(adapter->dev, "Firmware recovery mode detected. Limiting functionality. Refer to the Intel(R) Ethernet Adapters and Devices User Guide for details on firmware recovery mode.\n");
 			if (hw->adapter_stopped == FALSE)
 				ixgbe_stop(adapter);
+		}
 	} else
 		atomic_cas_uint(&adapter->recovery_mode, 1, 0);
 	atomic_store_relaxed(&adapter->recovery_mode_timer_pending, 0);
 	callout_reset(&adapter->recovery_mode_timer, hz,
 	    ixgbe_recovery_mode_timer, adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 } /* ixgbe_handle_recovery_mode_timer */
 /************************************************************************
  * ixgbe_sfp_cage_full
+ *
  *   Determine if a port had optics inserted.
  ************************************************************************/
 static bool
 ixgbe_sfp_cage_full(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	uint32_t mask;
 	int rv;
 	if (hw->mac.type >= ixgbe_mac_X540)
 		mask = IXGBE_ESDP_SDP0;
 	else
 		mask = IXGBE_ESDP_SDP2;
 	rv = IXGBE_READ_REG(hw, IXGBE_ESDP) & mask;
 	if ((adapter->quirks & IXGBE_QUIRK_MOD_ABS_INVERT) != 0)
 		rv = !rv;
 	if (hw->mac.type == ixgbe_mac_X550EM_a) {
 		/* X550EM_a's SDP0 is inverted than others. */
 		return !rv;
+	}
 	return rv;
 } /* ixgbe_sfp_cage_full */
 /************************************************************************
  * ixgbe_handle_mod - Tasklet for SFP module interrupts
  ************************************************************************/
 static void
 ixgbe_handle_mod(void *context)
+{
 	struct adapter	*adapter = context;
 	struct ixgbe_hw *hw = &adapter->hw;
 	device_t	dev = adapter->dev;
 	u32		err, cage_full = 0;
 	++adapter->mod_workev.ev_count;
 	if (adapter->hw.need_crosstalk_fix) {
 		switch (hw->mac.type) {
 		case ixgbe_mac_82599EB:
 			cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) &
 			    IXGBE_ESDP_SDP2;
 			break;
 		case ixgbe_mac_X550EM_x:
 		case ixgbe_mac_X550EM_a:
 			/*
 			 * XXX See ixgbe_sfp_cage_full(). It seems the bit is
 			 * inverted on X550EM_a, so I think this is incorrect.
 			 */
 			cage_full = IXGBE_READ_REG(hw, IXGBE_ESDP) &
 			    IXGBE_ESDP_SDP0;
 			break;
 		default:
 			break;
+		}
 		if (!cage_full)
 			goto out;
+	}
 	err = hw->phy.ops.identify_sfp(hw);
 	if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
 		device_printf(dev,
 		    "Unsupported SFP+ module type was detected.\n");
 		goto out;
+	}
 	if (hw->need_unsupported_sfp_recovery) {
 		device_printf(dev, "Recovering from unsupported SFP\n");
 		/*
 		 *  We could recover the status by calling setup_sfp(),
 		 * setup_link() and some others. It's complex and might not
 		 * work correctly on some unknown cases. To avoid such type of
 		 * problem, call ixgbe_init_locked(). It's simple and safe
 		 * approach.
 		 */
 		ixgbe_init_locked(adapter);
 	} else {
 		if (hw->mac.type == ixgbe_mac_82598EB)
 			err = hw->phy.ops.reset(hw);
 		else {
 			err = hw->mac.ops.setup_sfp(hw);
 			hw->phy.sfp_setup_needed = FALSE;
+		}
 		if (err == IXGBE_ERR_SFP_NOT_SUPPORTED) {
 			device_printf(dev,
 			    "Setup failure - unsupported SFP+ module type.\n");
 			goto out;
+		}
+	}
 out:
 	/* get_supported_phy_layer will call hw->phy.ops.identify_sfp() */
 	adapter->phy_layer = ixgbe_get_supported_physical_layer(hw);
 	/* Adjust media types shown in ifconfig */
 	IXGBE_CORE_UNLOCK(adapter);
 	ifmedia_removeall(&adapter->media);
 	ixgbe_add_media_types(adapter);
 	ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
 	IXGBE_CORE_LOCK(adapter);
 	atomic_or_32(&adapter->task_requests, IXGBE_REQUEST_TASK_MSF);
 	/*
 	 * Don't call ixgbe_schedule_admin_tasklet() because we are on
 	 * the workqueue now.
 	 */
 } /* ixgbe_handle_mod */
 /************************************************************************
  * ixgbe_handle_msf - Tasklet for MSF (multispeed fiber) interrupts
  ************************************************************************/
 static void
 ixgbe_handle_msf(void *context)
+{
 	struct adapter	*adapter = context;
 	struct ixgbe_hw *hw = &adapter->hw;
 	u32		autoneg;
 	bool		negotiate;
 	++adapter->msf_workev.ev_count;
 	autoneg = hw->phy.autoneg_advertised;
 	if ((!autoneg) && (hw->mac.ops.get_link_capabilities))
 		hw->mac.ops.get_link_capabilities(hw, &autoneg, &negotiate);
 	if (hw->mac.ops.setup_link)
 		hw->mac.ops.setup_link(hw, autoneg, TRUE);
 } /* ixgbe_handle_msf */
 /************************************************************************
  * ixgbe_handle_phy - Tasklet for external PHY interrupts
  ************************************************************************/
 static void
 ixgbe_handle_phy(void *context)
+{
 	struct adapter	*adapter = context;
 	struct ixgbe_hw *hw = &adapter->hw;
 	int error;
 	++adapter->phy_workev.ev_count;
 	error = hw->phy.ops.handle_lasi(hw);
 	if (error == IXGBE_ERR_OVERTEMP)
 		device_printf(adapter->dev,
 		    "CRITICAL: EXTERNAL PHY OVER TEMP!! "
 		    " PHY will downshift to lower power state!\n");
 	else if (error)
 		device_printf(adapter->dev,
 		    "Error handling LASI interrupt: %d\n", error);
 } /* ixgbe_handle_phy */
 static void
 ixgbe_handle_admin(struct work *wk, void *context)
+{
 	struct adapter	*adapter = context;
 	struct ifnet	*ifp = adapter->ifp;
 	struct ixgbe_hw	*hw = &adapter->hw;
 	u32		req;
 	/*
 	 * Hold the IFNET_LOCK across this entire call.  This will
 	 * prevent additional changes to adapter->phy_layer
 	 * and serialize calls to this tasklet.  We cannot hold the
 	 * CORE_LOCK while calling into the ifmedia functions as
 	 * they call ifmedia_lock() and the lock is CORE_LOCK.
 	 */
 	IFNET_LOCK(ifp);
 	IXGBE_CORE_LOCK(adapter);
 	while ((req =
 		(adapter->task_requests & ~IXGBE_REQUEST_TASK_NEED_ACKINTR))
 	    != 0) {
 		if ((req & IXGBE_REQUEST_TASK_LSC) != 0) {
 			ixgbe_handle_link(adapter);
 			atomic_and_32(&adapter->task_requests,
 			    ~IXGBE_REQUEST_TASK_LSC);
+		}
 		if ((req & IXGBE_REQUEST_TASK_MOD) != 0) {
 			ixgbe_handle_mod(adapter);
 			atomic_and_32(&adapter->task_requests,
 			    ~IXGBE_REQUEST_TASK_MOD);
+		}
 		if ((req & IXGBE_REQUEST_TASK_MSF) != 0) {
 			ixgbe_handle_msf(adapter);
 			atomic_and_32(&adapter->task_requests,
 			    ~IXGBE_REQUEST_TASK_MSF);
+		}
 		if ((req & IXGBE_REQUEST_TASK_PHY) != 0) {
 			ixgbe_handle_phy(adapter);
 			atomic_and_32(&adapter->task_requests,
 			    ~IXGBE_REQUEST_TASK_PHY);
+		}
 		if ((req & IXGBE_REQUEST_TASK_FDIR) != 0) {
 			ixgbe_reinit_fdir(adapter);
 			atomic_and_32(&adapter->task_requests,
 			    ~IXGBE_REQUEST_TASK_FDIR);
+		}
 #if 0 /* notyet */
 		if ((req & IXGBE_REQUEST_TASK_MBX) != 0) {
 			ixgbe_handle_mbx(adapter);
 			atomic_and_32(&adapter->task_requests,
 			    ~IXGBE_REQUEST_TASK_MBX);
+		}
 #endif
+	}
 	atomic_store_relaxed(&adapter->admin_pending, 0);
 	if ((adapter->task_requests & IXGBE_REQUEST_TASK_NEED_ACKINTR) != 0) {
 		atomic_and_32(&adapter->task_requests,
 		    ~IXGBE_REQUEST_TASK_NEED_ACKINTR);
 		if ((adapter->feat_en & IXGBE_FEATURE_MSIX) != 0) {
 			/* Re-enable other interrupts */
 			IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EIMS_OTHER);
 		} else
 			ixgbe_enable_intr(adapter);
+	}
 	IXGBE_CORE_UNLOCK(adapter);
 	IFNET_UNLOCK(ifp);
 } /* ixgbe_handle_admin */
 static void
 ixgbe_ifstop(struct ifnet *ifp, int disable)
+{
 	struct adapter *adapter = ifp->if_softc;
 	IXGBE_CORE_LOCK(adapter);
 	ixgbe_stop(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	workqueue_wait(adapter->timer_wq, &adapter->timer_wc);
 	atomic_store_relaxed(&adapter->timer_pending, 0);
+}
 /************************************************************************
  * ixgbe_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)
+{
 	struct ifnet	*ifp;
 	struct adapter	*adapter = arg;
 	struct ixgbe_hw *hw = &adapter->hw;
 	ifp = adapter->ifp;
 	KASSERT(mutex_owned(&adapter->core_mtx));
 	INIT_DEBUGOUT("ixgbe_stop: begin\n");
 	ixgbe_disable_intr(adapter);
 	callout_stop(&adapter->timer);
 	/* Don't schedule workqueues. */
 	adapter->schedule_wqs_ok = false;
 	/* Let the stack know...*/
 	ifp->if_flags &= ~IFF_RUNNING;
 	ixgbe_reset_hw(hw);
 	hw->adapter_stopped = FALSE;
 	ixgbe_stop_adapter(hw);
 	if (hw->mac.type == ixgbe_mac_82599EB)
 		ixgbe_stop_mac_link_on_d3_82599(hw);
 	/* Turn off the laser - noop with no optics */
 	ixgbe_disable_tx_laser(hw);
 	/* Update the stack */
 	adapter->link_up = FALSE;
 	ixgbe_update_link_status(adapter);
 	/* 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_update_link_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
 ixgbe_update_link_status(struct adapter *adapter)
+{
 	struct ifnet	*ifp = adapter->ifp;
 	device_t	dev = adapter->dev;
 	struct ixgbe_hw *hw = &adapter->hw;
 	KASSERT(mutex_owned(&adapter->core_mtx));
 	if (adapter->link_up) {
 		if (adapter->link_active != LINK_STATE_UP) {
 			/*
 			 * To eliminate influence of the previous state
 			 * in the same way as ixgbe_init_locked().
 			 */
 			struct ix_queue	*que = adapter->queues;
 			for (int i = 0; i < adapter->num_queues; i++, que++)
 				que->eitr_setting = 0;
 			if (adapter->link_speed == IXGBE_LINK_SPEED_10GB_FULL){
 				/*
 				 *  Discard count for both MAC Local Fault and
 				 * Remote Fault because those registers are
 				 * valid only when the link speed is up and
 				 * 10Gbps.
 				 */
 				IXGBE_READ_REG(hw, IXGBE_MLFC);
 				IXGBE_READ_REG(hw, IXGBE_MRFC);
+			}
 			if (bootverbose) {
 				const char *bpsmsg;
 				switch (adapter->link_speed) {
 				case IXGBE_LINK_SPEED_10GB_FULL:
 					bpsmsg = "10 Gbps";
 					break;
 				case IXGBE_LINK_SPEED_5GB_FULL:
 					bpsmsg = "5 Gbps";
 					break;
 				case IXGBE_LINK_SPEED_2_5GB_FULL:
 					bpsmsg = "2.5 Gbps";
 					break;
 				case IXGBE_LINK_SPEED_1GB_FULL:
 					bpsmsg = "1 Gbps";
 					break;
 				case IXGBE_LINK_SPEED_100_FULL:
 					bpsmsg = "100 Mbps";
 					break;
 				case IXGBE_LINK_SPEED_10_FULL:
 					bpsmsg = "10 Mbps";
 					break;
 				default:
 					bpsmsg = "unknown speed";
 					break;
+				}
 				device_printf(dev, "Link is up %s %s \n",
 				    bpsmsg, "Full Duplex");
+			}
 			adapter->link_active = LINK_STATE_UP;
 			/* Update any Flow Control changes */
 			ixgbe_fc_enable(&adapter->hw);
 			/* Update DMA coalescing config */
 			ixgbe_config_dmac(adapter);
 			if_link_state_change(ifp, LINK_STATE_UP);
 			if (adapter->feat_en & IXGBE_FEATURE_SRIOV)
 				ixgbe_ping_all_vfs(adapter);
+		}
 	} else {
 		/*
 		 * Do it when link active changes to DOWN. i.e.
 		 * a) LINK_STATE_UNKNOWN -> LINK_STATE_DOWN
 		 * b) LINK_STATE_UP	 -> LINK_STATE_DOWN
 		 */
 		if (adapter->link_active != LINK_STATE_DOWN) {
 			if (bootverbose)
 				device_printf(dev, "Link is Down\n");
 			if_link_state_change(ifp, LINK_STATE_DOWN);
 			adapter->link_active = LINK_STATE_DOWN;
 			if (adapter->feat_en & IXGBE_FEATURE_SRIOV)
 				ixgbe_ping_all_vfs(adapter);
 			ixgbe_drain_all(adapter);
+		}
+	}
 } /* ixgbe_update_link_status */
 /************************************************************************
  * ixgbe_config_dmac - Configure DMA Coalescing
  ************************************************************************/
 static void
 ixgbe_config_dmac(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	struct ixgbe_dmac_config *dcfg = &hw->mac.dmac_config;
 	if (hw->mac.type < ixgbe_mac_X550 || !hw->mac.ops.dmac_config)
 		return;
 	if (dcfg->watchdog_timer ^ adapter->dmac ||
 	    dcfg->link_speed ^ adapter->link_speed) {
 		dcfg->watchdog_timer = adapter->dmac;
 		dcfg->fcoe_en = false;
 		dcfg->link_speed = adapter->link_speed;
 		dcfg->num_tcs = 1;
 		INIT_DEBUGOUT2("dmac settings: watchdog %d, link speed %d\n",
 		    dcfg->watchdog_timer, dcfg->link_speed);
 		hw->mac.ops.dmac_config(hw);
+	}
 } /* ixgbe_config_dmac */
 /************************************************************************
  * ixgbe_enable_intr
  ************************************************************************/
 static void
 ixgbe_enable_intr(struct adapter *adapter)
+{
 	struct ixgbe_hw	*hw = &adapter->hw;
 	struct ix_queue	*que = adapter->queues;
 	u32		mask, fwsm;
 	mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE);
 	switch (adapter->hw.mac.type) {
 	case ixgbe_mac_82599EB:
 		mask |= IXGBE_EIMS_ECC;
 		/* Temperature sensor on some adapters */
 		mask |= IXGBE_EIMS_GPI_SDP0;
 		/* SFP+ (RX_LOS_N & MOD_ABS_N) */
 		mask |= IXGBE_EIMS_GPI_SDP1;
 		mask |= IXGBE_EIMS_GPI_SDP2;
 		break;
 	case ixgbe_mac_X540:
 		/* Detect if Thermal Sensor is enabled */
 		fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM);
 		if (fwsm & IXGBE_FWSM_TS_ENABLED)
 			mask |= IXGBE_EIMS_TS;
 		mask |= IXGBE_EIMS_ECC;
 		break;
 	case ixgbe_mac_X550:
 		/* MAC thermal sensor is automatically enabled */
 		mask |= IXGBE_EIMS_TS;
 		mask |= IXGBE_EIMS_ECC;
 		break;
 	case ixgbe_mac_X550EM_x:
 	case ixgbe_mac_X550EM_a:
 		/* Some devices use SDP0 for important information */
 		if (hw->device_id == IXGBE_DEV_ID_X550EM_X_SFP ||
 		    hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP ||
 		    hw->device_id == IXGBE_DEV_ID_X550EM_A_SFP_N ||
 		    hw->device_id == IXGBE_DEV_ID_X550EM_X_10G_T)
 			mask |= IXGBE_EIMS_GPI_SDP0_BY_MAC(hw);
 		if (hw->phy.type == ixgbe_phy_x550em_ext_t)
 			mask |= IXGBE_EICR_GPI_SDP0_X540;
 		mask |= IXGBE_EIMS_ECC;
 		break;
 	default:
 		break;
+	}
 	/* Enable Fan Failure detection */
 	if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL)
 		mask |= IXGBE_EIMS_GPI_SDP1;
 	/* Enable SR-IOV */
 	if (adapter->feat_en & IXGBE_FEATURE_SRIOV)
 		mask |= IXGBE_EIMS_MAILBOX;
 	/* Enable Flow Director */
 	if (adapter->feat_en & IXGBE_FEATURE_FDIR)
 		mask |= IXGBE_EIMS_FLOW_DIR;
 	IXGBE_WRITE_REG(hw, IXGBE_EIMS, mask);
 	/* With MSI-X we use auto clear */
 	if (adapter->msix_mem) {
 		mask = IXGBE_EIMS_ENABLE_MASK;
 		/* Don't autoclear Link */
 		mask &= ~IXGBE_EIMS_OTHER;
 		mask &= ~IXGBE_EIMS_LSC;
 		if (adapter->feat_cap & IXGBE_FEATURE_SRIOV)
 			mask &= ~IXGBE_EIMS_MAILBOX;
 		IXGBE_WRITE_REG(hw, IXGBE_EIAC, mask);
+	}
 	/*
 	 * Now enable all queues, this is done separately to
 	 * 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++)
 		ixgbe_enable_queue(adapter, que->msix);
 	IXGBE_WRITE_FLUSH(hw);
 } /* ixgbe_enable_intr */
 /************************************************************************
  * ixgbe_disable_intr_internal
  ************************************************************************/
 static void
 ixgbe_disable_intr_internal(struct adapter *adapter, bool nestok)
+{
 	struct ix_queue	*que = adapter->queues;
 	/* disable interrupts other than queues */
 	IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, ~IXGBE_EIMC_RTX_QUEUE);
 	if (adapter->msix_mem)
 		IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIAC, 0);
 	for (int i = 0; i < adapter->num_queues; i++, que++)
 		ixgbe_disable_queue_internal(adapter, que->msix, nestok);
 	IXGBE_WRITE_FLUSH(&adapter->hw);
 } /* ixgbe_do_disable_intr_internal */
 /************************************************************************
  * ixgbe_disable_intr
  ************************************************************************/
 static void
 ixgbe_disable_intr(struct adapter *adapter)
+{
 	ixgbe_disable_intr_internal(adapter, true);
 } /* ixgbe_disable_intr */
 /************************************************************************
  * ixgbe_ensure_disabled_intr
  ************************************************************************/
 void
 ixgbe_ensure_disabled_intr(struct adapter *adapter)
+{
 	ixgbe_disable_intr_internal(adapter, false);
 } /* ixgbe_ensure_disabled_intr */
 /************************************************************************
  * ixgbe_legacy_irq - Legacy Interrupt Service routine
  ************************************************************************/
 static int
 ixgbe_legacy_irq(void *arg)
+{
 	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;
 	bool		reenable_intr = true;
 	u32		eicr, eicr_mask;
 	u32		task_requests = 0;
 	/* Silicon errata #26 on 82598 */
 	IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_IRQ_CLEAR_MASK);
 	eicr = IXGBE_READ_REG(hw, IXGBE_EICR);
 	adapter->stats.pf.legint.ev_count++;
 	++que->irqs.ev_count;
 	if (eicr == 0) {
 		adapter->stats.pf.intzero.ev_count++;
 		if ((ifp->if_flags & IFF_UP) != 0)
 			ixgbe_enable_intr(adapter);
 		return 0;
+	}
 	if ((ifp->if_flags & IFF_RUNNING) != 0) {
 		/*
 		 * The same as ixgbe_msix_que() about "que->txrx_use_workqueue".
 		 */
 		que->txrx_use_workqueue = adapter->txrx_use_workqueue;
 #ifdef __NetBSD__
 		/* Don't run ixgbe_rxeof in interrupt context */
 		more = true;
 #else
 		more = ixgbe_rxeof(que);
 #endif
 		IXGBE_TX_LOCK(txr);
 		ixgbe_txeof(txr);
 #ifdef notyet
 		if (!ixgbe_ring_empty(ifp, txr->br))
 			ixgbe_start_locked(ifp, txr);
 #endif
 		IXGBE_TX_UNLOCK(txr);
+	}
 	/* Check for fan failure */
 	if (adapter->feat_en & IXGBE_FEATURE_FAN_FAIL) {
 		ixgbe_check_fan_failure(adapter, eicr, true);
 		IXGBE_WRITE_REG(hw, IXGBE_EIMS, IXGBE_EICR_GPI_SDP1_BY_MAC(hw));
+	}
 	/* Link status change */
 	if (eicr & IXGBE_EICR_LSC)
 		task_requests |= IXGBE_REQUEST_TASK_LSC;
 	if (ixgbe_is_sfp(hw)) {
 		/* Pluggable optics-related interrupt */
 		if (hw->mac.type >= ixgbe_mac_X540)
 			eicr_mask = IXGBE_EICR_GPI_SDP0_X540;
 		else
 			eicr_mask = IXGBE_EICR_GPI_SDP2_BY_MAC(hw);
 		if (eicr & eicr_mask) {
 			IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask);
 			task_requests |= IXGBE_REQUEST_TASK_MOD;
+		}
 		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));
 			task_requests |= IXGBE_REQUEST_TASK_MSF;
+		}
+	}
 	/* External PHY interrupt */
 	if ((hw->phy.type == ixgbe_phy_x550em_ext_t) &&
 	    (eicr & IXGBE_EICR_GPI_SDP0_X540))
 		task_requests |= IXGBE_REQUEST_TASK_PHY;
 	if (more) {
 		que->req.ev_count++;
 		ixgbe_sched_handle_que(adapter, que);
 		reenable_intr = false;
+	}
 	if (task_requests != 0) {
 		/* Re-enabling other interrupts is done in the admin task */
 		task_requests |= IXGBE_REQUEST_TASK_NEED_ACKINTR;
 		atomic_or_32(&adapter->task_requests, task_requests);
 		ixgbe_schedule_admin_tasklet(adapter);
 		reenable_intr = false;
+	}
 	if (reenable_intr == true)
 		ixgbe_enable_intr(adapter);
 	return 1;
 } /* ixgbe_legacy_irq */
 /************************************************************************
  * ixgbe_free_pciintr_resources
  ************************************************************************/
 static void
 ixgbe_free_pciintr_resources(struct adapter *adapter)
+{
 	struct ix_queue *que = adapter->queues;
 	int		rid;
 	/*
 	 * Release all msix queue resources:
 	 */
 	for (int i = 0; i < adapter->num_queues; i++, que++) {
 		if (que->res != NULL) {
 			pci_intr_disestablish(adapter->osdep.pc,
 			    adapter->osdep.ihs[i]);
 			adapter->osdep.ihs[i] = NULL;
+		}
+	}
 	/* Clean the Legacy or Link interrupt last */
 	if (adapter->vector) /* we are doing MSIX */
 		rid = adapter->vector;
 	else
 		rid = 0;
 	if (adapter->osdep.ihs[rid] != NULL) {
 		pci_intr_disestablish(adapter->osdep.pc,
 		    adapter->osdep.ihs[rid]);
 		adapter->osdep.ihs[rid] = NULL;
+	}
 	if (adapter->osdep.intrs != NULL) {
 		pci_intr_release(adapter->osdep.pc, adapter->osdep.intrs,
 		    adapter->osdep.nintrs);
 		adapter->osdep.intrs = NULL;
+	}
 } /* ixgbe_free_pciintr_resources */
 /************************************************************************
  * ixgbe_free_pci_resources
  ************************************************************************/
 static void
 ixgbe_free_pci_resources(struct adapter *adapter)
+{
 	ixgbe_free_pciintr_resources(adapter);
 	if (adapter->osdep.mem_size != 0) {
 		bus_space_unmap(adapter->osdep.mem_bus_space_tag,
 		    adapter->osdep.mem_bus_space_handle,
 		    adapter->osdep.mem_size);
+	}
 } /* ixgbe_free_pci_resources */
 /************************************************************************
  * ixgbe_set_sysctl_value
  ************************************************************************/
 static void
 ixgbe_set_sysctl_value(struct adapter *adapter, const char *name,
     const char *description, int *limit, int value)
+{
 	device_t dev =	adapter->dev;
 	struct sysctllog **log;
 	const struct sysctlnode *rnode, *cnode;
 	/*
 	 * It's not required to check recovery mode because this function never
 	 * touches hardware.
 	 */
 	log = &adapter->sysctllog;
 	if ((rnode = ixgbe_sysctl_instance(adapter)) == NULL) {
 		aprint_error_dev(dev, "could not create sysctl root\n");
 		return;
+	}
 	if (sysctl_createv(log, 0, &rnode, &cnode,
 	    CTLFLAG_READWRITE, CTLTYPE_INT,
 	    name, SYSCTL_DESCR(description),
 		NULL, 0, limit, 0, CTL_CREATE, CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	*limit = value;
 } /* ixgbe_set_sysctl_value */
 /************************************************************************
  * ixgbe_sysctl_flowcntl
+ *
  *   SYSCTL wrapper around setting Flow Control
  ************************************************************************/
 static int
 ixgbe_sysctl_flowcntl(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct adapter *adapter = (struct adapter *)node.sysctl_data;
 	int error, fc;
 	if (ixgbe_fw_recovery_mode_swflag(adapter))
 		return (EPERM);
 	fc = adapter->hw.fc.current_mode;
 	node.sysctl_data = &fc;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error != 0 || newp == NULL)
 		return error;
 	/* Don't bother if it's not changed */
 	if (fc == adapter->hw.fc.current_mode)
 		return (0);
 	return ixgbe_set_flowcntl(adapter, fc);
 } /* ixgbe_sysctl_flowcntl */
 /************************************************************************
  * ixgbe_set_flowcntl - Set flow control
+ *
  *   Flow control values:
  *     0 - off
  *     1 - rx pause
  *     2 - tx pause
  *     3 - full
  ************************************************************************/
 static int
 ixgbe_set_flowcntl(struct adapter *adapter, int fc)
+{
 	switch (fc) {
 		case ixgbe_fc_rx_pause:
 		case ixgbe_fc_tx_pause:
 		case ixgbe_fc_full:
 			adapter->hw.fc.requested_mode = fc;
 			if (adapter->num_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)
 				ixgbe_enable_rx_drop(adapter);
 			break;
 		default:
 			return (EINVAL);
+	}
 #if 0 /* XXX NetBSD */
 	/* Don't autoneg if forcing a value */
 	adapter->hw.fc.disable_fc_autoneg = TRUE;
 #endif
 	ixgbe_fc_enable(&adapter->hw);
 	return (0);
 } /* ixgbe_set_flowcntl */
 /************************************************************************
  * ixgbe_enable_rx_drop
+ *
  *   Enable the hardware to drop packets when the buffer is
  *   full. This is useful with multiqueue, so that no single
  *   queue being full stalls the entire RX engine. We only
  *   enable this when Multiqueue is enabled AND Flow Control
  *   is disabled.
  ************************************************************************/
 static void
 ixgbe_enable_rx_drop(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	struct rx_ring	*rxr;
 	u32		srrctl;
 	for (int i = 0; i < adapter->num_queues; i++) {
 		rxr = &adapter->rx_rings[i];
 		srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me));
 		srrctl |= IXGBE_SRRCTL_DROP_EN;
 		IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl);
+	}
 	/* 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_enable_rx_drop */
 /************************************************************************
  * ixgbe_disable_rx_drop
  ************************************************************************/
 static void
 ixgbe_disable_rx_drop(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	struct rx_ring	*rxr;
 	u32		srrctl;
 	for (int i = 0; i < adapter->num_queues; i++) {
 		rxr = &adapter->rx_rings[i];
 		srrctl = IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxr->me));
 		srrctl &= ~IXGBE_SRRCTL_DROP_EN;
 		IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxr->me), srrctl);
+	}
 	/* disable 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_disable_rx_drop */
 /************************************************************************
  * ixgbe_sysctl_advertise
+ *
  *   SYSCTL wrapper around setting advertised speed
  ************************************************************************/
 static int
 ixgbe_sysctl_advertise(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct adapter *adapter = (struct adapter *)node.sysctl_data;
 	int	       error = 0, advertise;
 	if (ixgbe_fw_recovery_mode_swflag(adapter))
 		return (EPERM);
 	advertise = adapter->advertise;
 	node.sysctl_data = &advertise;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error != 0 || newp == NULL)
 		return error;
 	return ixgbe_set_advertise(adapter, advertise);
 } /* ixgbe_sysctl_advertise */