 @@ -1,14 +1,14 @@
-#	$NetBSD: files.pci,v 1.388.4.5 2021/03/11 16:04:24 martin Exp $
+#	$NetBSD: files.pci,v 1.388.4.6 2021/09/15 16:38:00 martin Exp $
+#
 # Config file and device description for machine-independent PCI code.
 # Included by ports that need it.  Requires that the SCSI files be
 # defined first.
 defflag	opt_pci.h	PCIVERBOSE PCI_CONFIG_DUMP PCI_NETBSD_CONFIGURE
 defparam opt_pci.h	PCI_NETBSD_ENABLE_IDE
 defflag	opt_bktr.h	BKTR_430_FX_MODE BKTR_GPIO_ACCESS BKTR_NO_MSP_RESET
 			BKTR_REVERSE_MUTE BKTR_SIS_VIA_MODE BKTR_USE_PLL
 defparam opt_bktr.h	BKTR_OVERRIDE_CARD BKTR_OVERRIDE_TUNER BKTR_OVERRIDE_DBX
 			BKTR_OVERRIDE_MSP BKTR_SYSTEM_DEFAULT
 @@ -677,27 +677,26 @@ file	dev/pci/ixgbe/ix_txrx.c		ixg | ixv
 file	dev/pci/ixgbe/ixgbe_netbsd.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_82598.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_82599.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_x540.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_x550.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_api.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_common.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_mbx.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_osdep.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_phy.c	ixg | ixv
 file	dev/pci/ixgbe/ixgbe_vf.c	ixg | ixv
 file	dev/pci/ixgbe/if_bypass.c	ixg | ixv
 file	dev/pci/ixgbe/if_fdir.c		ixg | ixv
 defparam opt_ixgbe.h	IXGBE_JCLNUM_MULTI
 # This appears to be the driver for virtual instances of i82599.
 device	ixv: ether, ifnet, arp, mii, mii_phy
 attach	ixv at pci
 file	dev/pci/ixgbe/ixv.c		ixv
 # Intel i8254x Gigabit Ethernet
 device	wm: ether, ifnet, arp, mii, mii_bitbang
 attach	wm at pci
 file	dev/pci/if_wm.c			wm
 defflag	opt_if_wm.h	WM_EVENT_COUNTERS
 defparam opt_if_wm.h	WM_RX_PROCESS_LIMIT_DEFAULT
 			WM_RX_INTR_PROCESS_LIMIT_DEFAULT

 @@ -1,13 +1,14 @@
 /* $NetBSD: if_bypass.c,v 1.2.4.7 2021/09/15 16:38:00 martin 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
 @@ -22,26 +23,28 @@
   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_bypass.c 327031 2017-12-20 18:15:06Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: if_bypass.c,v 1.2.4.7 2021/09/15 16:38:00 martin Exp $");
 #include "ixgbe.h"
 /************************************************************************
  * ixgbe_bypass_mutex_enter
+ *
  *   Mutex support for the bypass feature. Using a dual lock
  *   to facilitate a privileged access to the watchdog update
  *   over other threads.
  ************************************************************************/
 static void
 ixgbe_bypass_mutex_enter(struct adapter *adapter)
+{
 @@ -659,27 +662,27 @@ ixgbe_bp_log(SYSCTLFN_ARGS)
 		u32 time = eeprom[count].logs & BYPASS_LOG_TIME_M;
 		u32 event = (eeprom[count].logs & BYPASS_LOG_EVENT_M) >>
 		    BYPASS_LOG_EVENT_SHIFT;
 		u8 action =  eeprom[count].actions & BYPASS_LOG_ACTION_M;
 		u16 day_mon[2][13] = {
 		  {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
 		  {0, 31, 59, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
 		};
 		const char *event_str[] = {"unknown", "main on", "aux on",
 		    "main off", "aux off", "WDT", "user" };
 		const char *action_str[] = {"ignore", "normal", "bypass",
 					    "isolate",};
-		/* verify vaild data  1 - 6 */
+		/* verify valid data  1 - 6 */
 		if (event < BYPASS_EVENT_MAIN_ON || event > BYPASS_EVENT_USR)
 			event = 0;
 		/*
 		 * time is in sec's this year, so convert to something
 		 * printable.
 		 */
 		ixgbe_get_bypass_time(&year, &sec);
 		days = time / SEC_PER_DAY;
 		for (i = 11; days < day_mon[LEAP_YR(year)][i]; i--)
 			continue;
 		mon = i + 1;    /* display month as 1-12 */
 		time -= (day_mon[LEAP_YR(year)][i] * SEC_PER_DAY);

 @@ -1,13 +1,14 @@
 /* $NetBSD: if_fdir.c,v 1.1.4.4 2021/09/15 16:38:00 martin 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
 @@ -22,26 +23,29 @@
   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_fdir.c 327031 2017-12-20 18:15:06Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: if_fdir.c,v 1.1.4.4 2021/09/15 16:38:00 martin Exp $");
 #include "ixgbe.h"
 #ifdef IXGBE_FDIR
 void
 ixgbe_init_fdir(struct adapter *adapter)
+{
 	u32 hdrm = 32 << fdir_pballoc;
 	if (!(adapter->feat_en & IXGBE_FEATURE_FDIR))
 		return;
 	adapter->hw.mac.ops.setup_rxpba(&adapter->hw, 0, hdrm,

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_fdir.h,v 1.1.4.4 2021/09/15 16:38:01 martin 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

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_features.h,v 1.1.4.4 2021/09/15 16:38:01 martin 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

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_netmap.c,v 1.1.4.4 2021/09/15 16:38:01 martin 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
 @@ -59,26 +60,29 @@
 /*
  * $FreeBSD: head/sys/dev/ixgbe/ixgbe_netmap.c 320688 2017-07-05 17:27:03Z erj $
+ *
  * netmap support for: ixgbe
+ *
  * This file is meant to be a reference on how to implement
  * netmap support for a network driver.
  * This file contains code but only static or inline functions used
  * by a single driver. To avoid replication of code we just #include
  * it near the beginning of the standard driver.
  */
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_netmap.c,v 1.1.4.4 2021/09/15 16:38:01 martin Exp $");
 #ifdef DEV_NETMAP
 /*
  * Some drivers may need the following headers. Others
  * already include them by default
 #include <vm/vm.h>
 #include <vm/pmap.h>
  */
 #include "ixgbe.h"
 /*
  * device-specific sysctl variables:

 @@ -1,13 +1,14 @@
 /* $NetBSD: if_sriov.c,v 1.1.4.6 2021/09/15 16:38:00 martin 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
 @@ -22,26 +23,29 @@
   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_sriov.c 327031 2017-12-20 18:15:06Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: if_sriov.c,v 1.1.4.6 2021/09/15 16:38:00 martin Exp $");
 #include "ixgbe.h"
 #include "ixgbe_sriov.h"
 #ifdef PCI_IOV
 MALLOC_DEFINE(M_IXGBE_SRIOV, "ix_sriov", "ix SR-IOV allocations");
 /************************************************************************
  * ixgbe_pci_iov_detach
  ************************************************************************/
 int
 ixgbe_pci_iov_detach(device_t dev)
+{

 @@ -1,14 +1,14 @@
-/* $NetBSD: ix_txrx.c,v 1.24.2.21 2021/03/11 16:04:25 martin Exp $ */
+/* $NetBSD: ix_txrx.c,v 1.24.2.22 2021/09/15 16:38:00 martin 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
 @@ -53,26 +53,29 @@
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ix_txrx.c,v 1.24.2.22 2021/09/15 16:38:00 martin Exp $");
 #include "opt_inet.h"
 #include "opt_inet6.h"
 #include "ixgbe.h"
 /*
  * HW RSC control:
  *  this feature only works with
  *  IPv4, and only on 82599 and later.
  *  Also this will cause IP forwarding to
  *  fail and that can't be controlled by
  *  the stack as LRO can. For all these
  *  reasons I've deemed it best to leave
 @@ -83,26 +86,30 @@
 static bool ixgbe_rsc_enable = FALSE;
 /*
  * For Flow Director: this is the
  * number of TX packets we sample
  * for the filter pool, this means
  * every 20th packet will be probed.
+ *
  * This feature can be disabled by
  * setting this to 0.
  */
 static int atr_sample_rate = 20;
 #define IXGBE_M_ADJ(adapter, rxr, mp)					\
 	if (adapter->max_frame_size <= (rxr->mbuf_sz - ETHER_ALIGN))	\
 		m_adj(mp, ETHER_ALIGN)
 /************************************************************************
  *  Local Function prototypes
  ************************************************************************/
 static void          ixgbe_setup_transmit_ring(struct tx_ring *);
 static void          ixgbe_free_transmit_buffers(struct tx_ring *);
 static int           ixgbe_setup_receive_ring(struct rx_ring *);
 static void          ixgbe_free_receive_buffers(struct rx_ring *);
 static void          ixgbe_rx_checksum(u32, struct mbuf *, u32,
                                        struct ixgbe_hw_stats *);
 static void          ixgbe_refresh_mbufs(struct rx_ring *, int);
 static void          ixgbe_drain(struct ifnet *, struct tx_ring *);
 static int           ixgbe_xmit(struct tx_ring *, struct mbuf *);
 static int           ixgbe_tx_ctx_setup(struct tx_ring *,
 @@ -192,27 +199,27 @@ ixgbe_legacy_start(struct ifnet *ifp)
+	}
 } /* ixgbe_legacy_start */
 /************************************************************************
  * ixgbe_mq_start - Multiqueue Transmit Entry Point
+ *
  *   (if_transmit function)
  ************************************************************************/
 int
 ixgbe_mq_start(struct ifnet *ifp, struct mbuf *m)
+{
 	struct adapter	*adapter = ifp->if_softc;
 	struct tx_ring	*txr;
-	int 		i;
+	int		i;
 #ifdef RSS
 	uint32_t bucket_id;
 #endif
 	/*
 	 * When doing RSS, map it to the same outbound queue
 	 * as the incoming flow would be mapped to.
+	 *
 	 * If everything is setup correctly, it should be the
 	 * same bucket that the current CPU we're on is.
 	 */
 #ifdef RSS
 	if (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) {
 @@ -472,41 +479,43 @@ retry:
 		ixgbe_dmamap_unload(txr->txtag, txbuf->map);
 		return EAGAIN;
+	}
 	/*
 	 * Set up the appropriate offload context
 	 * this will consume the first descriptor
 	 */
 	error = ixgbe_tx_ctx_setup(txr, m_head, &cmd_type_len, &olinfo_status);
 	if (__predict_false(error)) {
 		return (error);
+	}
 #ifdef IXGBE_FDIR
 	/* Do the flow director magic */
 	if ((adapter->feat_en & IXGBE_FEATURE_FDIR) &&
 	    (txr->atr_sample) && (!adapter->fdir_reinit)) {
 		++txr->atr_count;
 		if (txr->atr_count >= atr_sample_rate) {
 			ixgbe_atr(txr, m_head);
 			txr->atr_count = 0;
+		}
+	}
 #endif
 	olinfo_status |= IXGBE_ADVTXD_CC;
 	i = txr->next_avail_desc;
 	for (j = 0; j < map->dm_nsegs; j++) {
 		bus_size_t seglen;
-		bus_addr_t segaddr;
+		uint64_t segaddr;
 		txbuf = &txr->tx_buffers[i];
 		txd = &txr->tx_base[i];
 		seglen = map->dm_segs[j].ds_len;
 		segaddr = htole64(map->dm_segs[j].ds_addr);
 		txd->read.buffer_addr = segaddr;
 		txd->read.cmd_type_len = htole32(cmd_type_len | seglen);
 		txd->read.olinfo_status = htole32(olinfo_status);
 		if (++i == txr->num_desc)
 			i = 0;
+	}
 @@ -1117,52 +1126,52 @@ ixgbe_txeof(struct tx_ring *txr)
 		 * of the client thread. Interrupt handlers only wake up
 		 * clients, which may be sleeping on individual rings
 		 * or on a global resource for all rings.
 		 * To implement tx interrupt mitigation, we wake up the client
 		 * thread roughly every half ring, even if the NIC interrupts
 		 * more frequently. This is implemented as follows:
 		 * - ixgbe_txsync() sets kring->nr_kflags with the index of
 		 *   the slot that should wake up the thread (nkr_num_slots
 		 *   means the user thread should not be woken up);
 		 * - the driver ignores tx interrupts unless netmap_mitigate=0
 		 *   or the slot has the DD bit set.
 		 */
 		if (kring->nr_kflags < kring->nkr_num_slots &&
-		    txd[kring->nr_kflags].wb.status & IXGBE_TXD_STAT_DD) {
+		    le32toh(txd[kring->nr_kflags].wb.status) & IXGBE_TXD_STAT_DD) {
 			netmap_tx_irq(ifp, txr->me);
+		}
 		return false;
+	}
 #endif /* DEV_NETMAP */
 	if (txr->tx_avail == txr->num_desc) {
 		txr->busy = 0;
 		return false;
+	}
 	/* Get work starting point */
 	work = txr->next_to_clean;
 	buf = &txr->tx_buffers[work];
 	txd = &txr->tx_base[work];
 	work -= txr->num_desc; /* The distance to ring end */
 	ixgbe_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
 	    BUS_DMASYNC_POSTREAD);
 	do {
 		union ixgbe_adv_tx_desc *eop = buf->eop;
 		if (eop == NULL) /* No work */
 			break;
-		if ((eop->wb.status & IXGBE_TXD_STAT_DD) == 0)
+		if ((le32toh(eop->wb.status) & IXGBE_TXD_STAT_DD) == 0)
 			break;	/* I/O not complete */
 		if (buf->m_head) {
 			txr->bytes += buf->m_head->m_pkthdr.len;
 			bus_dmamap_sync(txr->txtag->dt_dmat, buf->map,
 , buf->m_head->m_pkthdr.len,
 			    BUS_DMASYNC_POSTWRITE);
 			ixgbe_dmamap_unload(txr->txtag, buf->map);
 			m_freem(buf->m_head);
 			buf->m_head = NULL;
+		}
 		buf->eop = NULL;
 		txr->txr_no_space = false;
 @@ -1318,92 +1327,88 @@ ixgbe_setup_hw_rsc(struct rx_ring *rxr)
 	rxr->hw_rsc = TRUE;
 } /* ixgbe_setup_hw_rsc */
 /************************************************************************
  * ixgbe_refresh_mbufs
+ *
  *   Refresh mbuf buffers for RX descriptor rings
  *    - now keeps its own state so discards due to resource
  *      exhaustion are unnecessary, if an mbuf cannot be obtained
  *      it just returns, keeping its placeholder, thus it can simply
  *      be recalled to try again.
+ *
  *   XXX NetBSD TODO:
- *    - The ixgbe_rxeof() function always preallocates mbuf cluster (jcl),
+ *    - The ixgbe_rxeof() function always preallocates mbuf cluster,
  *      so the ixgbe_refresh_mbufs() function can be simplified.
+ *
  ************************************************************************/
 static void
 ixgbe_refresh_mbufs(struct rx_ring *rxr, int limit)
+{
 	struct adapter      *adapter = rxr->adapter;
 	struct ixgbe_rx_buf *rxbuf;
 	struct mbuf         *mp;
-	int                 i, j, error;
+	int                 i, error;
 	bool                refreshed = false;
-	i = j = rxr->next_to_refresh;
+	i = rxr->next_to_refresh;
-	/* Control the loop with one beyond */
+	/* next_to_refresh points to the previous one */
-	if (++j == rxr->num_desc)
+	if (++i == rxr->num_desc)
-		j = 0;
+		i = 0;
-	while (j != limit) {
+	while (i != limit) {
 		rxbuf = &rxr->rx_buffers[i];
-		if (rxbuf->buf == NULL) {
+		if (__predict_false(rxbuf->buf == NULL)) {
-			mp = ixgbe_getjcl(&rxr->jcl_head, M_NOWAIT,
+			mp = ixgbe_getcl();
 			    MT_DATA, M_PKTHDR, rxr->mbuf_sz);
 			if (mp == NULL) {
-				rxr->no_jmbuf.ev_count++;
+				rxr->no_mbuf.ev_count++;
 				goto update;
+			}
-			if (adapter->max_frame_size <= (MCLBYTES - ETHER_ALIGN))
+			mp->m_pkthdr.len = mp->m_len = rxr->mbuf_sz;
-				m_adj(mp, ETHER_ALIGN);
+			IXGBE_M_ADJ(adapter, rxr, mp);
 		} else
 			mp = rxbuf->buf;
 		mp->m_pkthdr.len = mp->m_len = rxr->mbuf_sz;
 		/* If we're dealing with an mbuf that was copied rather
 		 * than replaced, there's no need to go through busdma.
 		 */
 		if ((rxbuf->flags & IXGBE_RX_COPY) == 0) {
 			/* Get the memory mapping */
 			ixgbe_dmamap_unload(rxr->ptag, rxbuf->pmap);
 			error = bus_dmamap_load_mbuf(rxr->ptag->dt_dmat,
 			    rxbuf->pmap, mp, BUS_DMA_NOWAIT);
-			if (error != 0) {
+			if (__predict_false(error != 0)) {
 				device_printf(adapter->dev, "Refresh mbufs: "
 				    "payload dmamap load failure - %d\n",
 				    error);
 				m_free(mp);
 				rxbuf->buf = NULL;
 				goto update;
+			}
 			rxbuf->buf = mp;
 			bus_dmamap_sync(rxr->ptag->dt_dmat, rxbuf->pmap,
 , mp->m_pkthdr.len, BUS_DMASYNC_PREREAD);
 			rxbuf->addr = rxr->rx_base[i].read.pkt_addr =
 			    htole64(rxbuf->pmap->dm_segs[0].ds_addr);
 		} else {
 			rxr->rx_base[i].read.pkt_addr = rxbuf->addr;
 			rxbuf->flags &= ~IXGBE_RX_COPY;
+		}
 		refreshed = true;
-		/* Next is precalculated */
+		/* next_to_refresh points to the previous one */
 		i = j;
 		rxr->next_to_refresh = i;
-		if (++j == rxr->num_desc)
+		if (++i == rxr->num_desc)
-			j = 0;
+			i = 0;
+	}
 update:
 	if (refreshed) /* Update hardware tail index */
 		IXGBE_WRITE_REG(&adapter->hw, rxr->tail, rxr->next_to_refresh);
 	return;
 } /* ixgbe_refresh_mbufs */
 /************************************************************************
  * ixgbe_allocate_receive_buffers
+ *
  *   Allocate memory for rx_buffer structures. Since we use one
 @@ -1503,37 +1508,26 @@ ixgbe_setup_receive_ring(struct rx_ring
 	if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
 		slot = netmap_reset(na, NR_RX, rxr->me, 0);
 #endif /* DEV_NETMAP */
 	rsize = roundup2(adapter->num_rx_desc *
 	    sizeof(union ixgbe_adv_rx_desc), DBA_ALIGN);
 	bzero((void *)rxr->rx_base, rsize);
 	/* Cache the size */
 	rxr->mbuf_sz = adapter->rx_mbuf_sz;
 	/* Free current RX buffer structs and their mbufs */
 	ixgbe_free_receive_ring(rxr);
 	IXGBE_RX_UNLOCK(rxr);
 	/*
 	 * Now reinitialize our supply of jumbo mbufs.  The number
 	 * or size of jumbo mbufs may have changed.
 	 * Assume all of rxr->ptag are the same.
 	 */
 	ixgbe_jcl_reinit(adapter, rxr->ptag->dt_dmat, rxr,
 	    adapter->num_jcl, adapter->rx_mbuf_sz);
 	IXGBE_RX_LOCK(rxr);
 	/* Now replenish the mbufs */
 	for (int j = 0; j != rxr->num_desc; ++j) {
 		struct mbuf *mp;
 		rxbuf = &rxr->rx_buffers[j];
 #ifdef DEV_NETMAP
 		/*
 		 * In netmap mode, fill the map and set the buffer
 		 * address in the NIC ring, considering the offset
 		 * between the netmap and NIC rings (see comment in
 		 * ixgbe_setup_transmit_ring() ). No need to allocate
 		 * an mbuf, so end the block with a continue;
 @@ -1543,51 +1537,61 @@ ixgbe_setup_receive_ring(struct rx_ring
 			uint64_t paddr;
 			void *addr;
 			addr = PNMB(na, slot + sj, &paddr);
 			netmap_load_map(na, rxr->ptag, rxbuf->pmap, addr);
 			/* Update descriptor and the cached value */
 			rxr->rx_base[j].read.pkt_addr = htole64(paddr);
 			rxbuf->addr = htole64(paddr);
 			continue;
+		}
 #endif /* DEV_NETMAP */
 		rxbuf->flags = 0;
-		rxbuf->buf = ixgbe_getjcl(&rxr->jcl_head, M_NOWAIT,
+		rxbuf->buf = ixgbe_getcl();
 		    MT_DATA, M_PKTHDR, adapter->rx_mbuf_sz);
 		if (rxbuf->buf == NULL) {
 			rxr->no_mbuf.ev_count++;
 			error = ENOBUFS;
 			goto fail;
+		}
 		mp = rxbuf->buf;
 		mp->m_pkthdr.len = mp->m_len = rxr->mbuf_sz;
 		IXGBE_M_ADJ(adapter, rxr, mp);
 		/* Get the memory mapping */
 		error = bus_dmamap_load_mbuf(rxr->ptag->dt_dmat, rxbuf->pmap,
 		    mp, BUS_DMA_NOWAIT);
-		if (error != 0)
+		if (error != 0) {
-                        goto fail;
+			/*
 			 * Clear this entry for later cleanup in
 			 * ixgbe_discard() which is called via
 			 * ixgbe_free_receive_ring().
 			 */
 			m_freem(mp);
 			rxbuf->buf = NULL;
 			goto fail;
+		}
 		bus_dmamap_sync(rxr->ptag->dt_dmat, rxbuf->pmap,
-, adapter->rx_mbuf_sz, BUS_DMASYNC_PREREAD);
+, mp->m_pkthdr.len, BUS_DMASYNC_PREREAD);
 		/* Update the descriptor and the cached value */
 		rxr->rx_base[j].read.pkt_addr =
 		    htole64(rxbuf->pmap->dm_segs[0].ds_addr);
 		rxbuf->addr = htole64(rxbuf->pmap->dm_segs[0].ds_addr);
+	}
 	/* Setup our descriptor indices */
 	rxr->next_to_check = 0;
-	rxr->next_to_refresh = 0;
+	rxr->next_to_refresh = adapter->num_rx_desc - 1; /* Fully allocated */
 	rxr->lro_enabled = FALSE;
 	rxr->discard_multidesc = false;
 	rxr->rx_copies.ev_count = 0;
 #if 0 /* NetBSD */
 	rxr->rx_bytes.ev_count = 0;
 #if 1	/* Fix inconsistency */
 	rxr->rx_packets.ev_count = 0;
 #endif
 #endif
 	rxr->vtag_strip = FALSE;
 	ixgbe_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	/*
 @@ -1689,29 +1693,26 @@ ixgbe_free_receive_buffers(struct rx_rin
 	INIT_DEBUGOUT("ixgbe_free_receive_buffers: begin");
 	/* Cleanup any existing buffers */
 	if (rxr->rx_buffers != NULL) {
 		for (int i = 0; i < adapter->num_rx_desc; i++) {
 			rxbuf = &rxr->rx_buffers[i];
 			ixgbe_rx_discard(rxr, i);
 			if (rxbuf->pmap != NULL) {
 				ixgbe_dmamap_destroy(rxr->ptag, rxbuf->pmap);
 				rxbuf->pmap = NULL;
+			}
+		}
 		/* NetBSD specific. See ixgbe_netbsd.c */
 		ixgbe_jcl_destroy(adapter, rxr);
 		if (rxr->rx_buffers != NULL) {
 			free(rxr->rx_buffers, M_DEVBUF);
 			rxr->rx_buffers = NULL;
+		}
+	}
 	if (rxr->ptag != NULL) {
 		ixgbe_dma_tag_destroy(rxr->ptag);
 		rxr->ptag = NULL;
+	}
 	return;
 } /* ixgbe_free_receive_buffers */
 @@ -1758,46 +1759,45 @@ ixgbe_rx_input(struct rx_ring *rxr, stru
 } /* ixgbe_rx_input */
 /************************************************************************
  * ixgbe_rx_discard
  ************************************************************************/
 static __inline void
 ixgbe_rx_discard(struct rx_ring *rxr, int i)
+{
 	struct ixgbe_rx_buf *rbuf;
 	rbuf = &rxr->rx_buffers[i];
 	/*
-	 * With advanced descriptors the writeback
+	 * With advanced descriptors the writeback clobbers the buffer addrs,
-	 * clobbers the buffer addrs, so its easier
+	 * so its easier to just free the existing mbufs and take the normal
-	 * to just free the existing mbufs and take
+	 * refresh path to get new buffers and mapping.
 	 * the normal refresh path to get new buffers
 	 * and mapping.
 	 */
 	if (rbuf->fmp != NULL) {/* Partial chain ? */
 		bus_dmamap_sync(rxr->ptag->dt_dmat, rbuf->pmap, 0,
 		    rbuf->buf->m_pkthdr.len, BUS_DMASYNC_POSTREAD);
 		ixgbe_dmamap_unload(rxr->ptag, rbuf->pmap);
 		m_freem(rbuf->fmp);
 		rbuf->fmp = NULL;
 		rbuf->buf = NULL; /* rbuf->buf is part of fmp's chain */
 	} else if (rbuf->buf) {
 		bus_dmamap_sync(rxr->ptag->dt_dmat, rbuf->pmap, 0,
 		    rbuf->buf->m_pkthdr.len, BUS_DMASYNC_POSTREAD);
 		ixgbe_dmamap_unload(rxr->ptag, rbuf->pmap);
 		m_free(rbuf->buf);
 		rbuf->buf = NULL;
+	}
 	ixgbe_dmamap_unload(rxr->ptag, rbuf->pmap);
 	rbuf->flags = 0;
 	return;
 } /* ixgbe_rx_discard */
 /************************************************************************
  * ixgbe_rxeof
+ *
  *   Executes in interrupt context. It replenishes the
  *   mbufs in the descriptor and sends data which has
  *   been dma'ed into host memory to upper layer.
 @@ -1807,106 +1807,123 @@ ixgbe_rx_discard(struct rx_ring *rxr, in
 bool
 ixgbe_rxeof(struct ix_queue *que)
+{
 	struct adapter		*adapter = que->adapter;
 	struct rx_ring		*rxr = que->rxr;
 	struct ifnet		*ifp = adapter->ifp;
 #ifdef LRO
 	struct lro_ctrl		*lro = &rxr->lro;
 #endif /* LRO */
 	union ixgbe_adv_rx_desc	*cur;
 	struct ixgbe_rx_buf	*rbuf, *nbuf;
 	int			i, nextp, processed = 0;
 	u32			staterr = 0;
-	u32			count = 0;
+	u32			loopcount = 0;
 	u32			limit = adapter->rx_process_limit;
-	bool			discard_multidesc = false;
+	bool			discard_multidesc = rxr->discard_multidesc;
 #ifdef RSS
 	u16			pkt_info;
 #endif
 	IXGBE_RX_LOCK(rxr);
 #ifdef DEV_NETMAP
 	if (adapter->feat_en & IXGBE_FEATURE_NETMAP) {
 		/* Same as the txeof routine: wakeup clients on intr. */
 		if (netmap_rx_irq(ifp, rxr->me, &processed)) {
 			IXGBE_RX_UNLOCK(rxr);
 			return (FALSE);
+		}
+	}
 #endif /* DEV_NETMAP */
 	/*
 	 * The max number of loop is rx_process_limit. If discard_multidesc is
 	 * true, continue processing to not to send broken packet to the upper
 	 * layer.
 	 */
 	for (i = rxr->next_to_check;
-	     (count < limit) || (discard_multidesc == true);) {
+	     (loopcount < limit) || (discard_multidesc == true);) {
 		struct mbuf *sendmp, *mp;
 		struct mbuf *newmp;
 		u32         rsc, ptype;
 		u16         len;
 		u16         vtag = 0;
 		bool        eop;
 		bool        discard = false;
 		/* Sync the ring. */
 		ixgbe_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
 		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 		cur = &rxr->rx_base[i];
 		staterr = le32toh(cur->wb.upper.status_error);
 #ifdef RSS
 		pkt_info = le16toh(cur->wb.lower.lo_dword.hs_rss.pkt_info);
 #endif
 		if ((staterr & IXGBE_RXD_STAT_DD) == 0)
 			break;
-		count++;
+		loopcount++;
-		sendmp = NULL;
+		sendmp = newmp = NULL;
 		nbuf = NULL;
 		rsc = 0;
 		cur->wb.upper.status_error = 0;
 		rbuf = &rxr->rx_buffers[i];
 		mp = rbuf->buf;
 		len = le16toh(cur->wb.upper.length);
 		ptype = le32toh(cur->wb.lower.lo_dword.data) &
 		    IXGBE_RXDADV_PKTTYPE_MASK;
 		eop = ((staterr & IXGBE_RXD_STAT_EOP) != 0);
 		/* Make sure bad packets are discarded */
 		if (eop && (staterr & IXGBE_RXDADV_ERR_FRAME_ERR_MASK) != 0) {
 #if __FreeBSD_version >= 1100036
 			if (adapter->feat_en & IXGBE_FEATURE_VF)
 				if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 #endif
 			rxr->rx_discarded.ev_count++;
 			ixgbe_rx_discard(rxr, i);
 			discard_multidesc = false;
 			goto next_desc;
+		}
-		/* pre-alloc new mbuf */
+		if (__predict_false(discard_multidesc))
-		if (!discard_multidesc)
+			discard = true;
-			newmp = ixgbe_getjcl(&rxr->jcl_head, M_NOWAIT, MT_DATA,
+		else {
-			    M_PKTHDR, rxr->mbuf_sz);
+			/* Pre-alloc new mbuf. */
 		else
-			newmp = NULL;
+			if ((rbuf->fmp == NULL) &&
-		if (newmp == NULL) {
+			    eop && (len <= adapter->rx_copy_len)) {
-			rxr->no_jmbuf.ev_count++;
+				/* For short packet. See below. */
 				sendmp = m_gethdr(M_NOWAIT, MT_DATA);
 				if (__predict_false(sendmp == NULL)) {
 					rxr->no_mbuf.ev_count++;
 					discard = true;
+				}
 			} else {
 				/* For long packet. */
 				newmp = ixgbe_getcl();
 				if (__predict_false(newmp == NULL)) {
 					rxr->no_mbuf.ev_count++;
 					discard = true;
+				}
+			}
+		}
 		if (__predict_false(discard)) {
 			/*
 			 * Descriptor initialization is already done by the
 			 * above code (cur->wb.upper.status_error = 0).
 			 * So, we can reuse current rbuf->buf for new packet.
+			 *
 			 * Rewrite the buffer addr, see comment in
 			 * ixgbe_rx_discard().
 			 */
 			cur->read.pkt_addr = rbuf->addr;
 			m_freem(rbuf->fmp);
 			rbuf->fmp = NULL;
 			if (!eop) {
 				/* Discard the entire packet. */
 @@ -1948,66 +1965,80 @@ ixgbe_rxeof(struct ix_queue *que)
 				nextp = i + 1;
 				if (nextp == adapter->num_rx_desc)
 					nextp = 0;
+			}
 			nbuf = &rxr->rx_buffers[nextp];
 			prefetch(nbuf);
+		}
 		/*
 		 * Rather than using the fmp/lmp global pointers
 		 * we now keep the head of a packet chain in the
 		 * buffer struct and pass this along from one
 		 * descriptor to the next, until we get EOP.
 		 */
 		mp->m_len = len;
 		/*
 		 * See if there is a stored head
 		 * that determines what we are
 		 */
-		sendmp = rbuf->fmp;
+		if (rbuf->fmp != NULL) {
-		if (sendmp != NULL) {  /* secondary frag */
+			/* Secondary frag */
 			sendmp = rbuf->fmp;
 			/* Update new (used in future) mbuf */
 			newmp->m_pkthdr.len = newmp->m_len = rxr->mbuf_sz;
 			IXGBE_M_ADJ(adapter, rxr, newmp);
 			rbuf->buf = newmp;
 			rbuf->fmp = NULL;
 			/* For secondary frag */
 			mp->m_len = len;
 			mp->m_flags &= ~M_PKTHDR;
 			/* For sendmp */
 			sendmp->m_pkthdr.len += mp->m_len;
 		} else {
 			/*
-			 * Optimize.  This might be a small packet,
+			 * It's the first segment of a multi descriptor
-			 * maybe just a TCP ACK.  Do a fast copy that
+			 * packet or a single segment which contains a full
-			 * is cache aligned into a new mbuf, and
+			 * packet.
 			 * leave the old mbuf+cluster for re-use.
 			 */
 			if (eop && len <= IXGBE_RX_COPY_LEN) {
 				sendmp = m_gethdr(M_NOWAIT, MT_DATA);
 				if (sendmp != NULL) {
 					sendmp->m_data += IXGBE_RX_COPY_ALIGN;
 					ixgbe_bcopy(mp->m_data, sendmp->m_data,
 					    len);
 					sendmp->m_len = len;
 					rxr->rx_copies.ev_count++;
 					rbuf->flags |= IXGBE_RX_COPY;
-					m_freem(newmp);
+			if (eop && (len <= adapter->rx_copy_len)) {
 				/*
 				 * Optimize.  This might be a small packet, may
-			if (sendmp == NULL) {
+				 * be just a TCP ACK. Copy into a new mbuf, and
 				 * Leave the old mbuf+cluster for re-use.
 				 */
 				sendmp->m_data += ETHER_ALIGN;
 				memcpy(mtod(sendmp, void *),
 				    mtod(mp, void *), len);
 				rxr->rx_copies.ev_count++;
 				rbuf->flags |= IXGBE_RX_COPY;
 			} else {
 				/* Non short packet */
 				/* Update new (used in future) mbuf */
 				newmp->m_pkthdr.len = newmp->m_len
 				    = rxr->mbuf_sz;
 				IXGBE_M_ADJ(adapter, rxr, newmp);
 				rbuf->buf = newmp;
 				rbuf->fmp = NULL;
 				/* For sendmp */
 				sendmp = mp;
+			}
 			/* first desc of a non-ps chain */
-			sendmp->m_flags |= M_PKTHDR;
+			sendmp->m_pkthdr.len = sendmp->m_len = len;
 			sendmp->m_pkthdr.len = mp->m_len;
+		}
 		++processed;
 		/* Pass the head pointer on */
 		if (eop == 0) {
 			nbuf->fmp = sendmp;
 			sendmp = NULL;
 			mp->m_next = nbuf->buf;
 		} else { /* Sending this frame */
 			m_set_rcvif(sendmp, ifp);
 			++rxr->packets;
 			rxr->rx_packets.ev_count++;
 			/* capture data for AIM */
 @@ -2079,49 +2110,46 @@ ixgbe_rxeof(struct ix_queue *que)
 			} else {
 				sendmp->m_pkthdr.flowid = que->msix;
 				M_HASHTYPE_SET(sendmp, M_HASHTYPE_OPAQUE);
+			}
 #endif
+		}
 next_desc:
 		ixgbe_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 		/* Advance our pointers to the next descriptor. */
 		if (++i == rxr->num_desc)
 			i = 0;
 		rxr->next_to_check = i;
 		/* Now send to the stack or do LRO */
-		if (sendmp != NULL) {
+		if (sendmp != NULL)
 			rxr->next_to_check = i;
 			IXGBE_RX_UNLOCK(rxr);
 			ixgbe_rx_input(rxr, ifp, sendmp, ptype);
 			IXGBE_RX_LOCK(rxr);
 			i = rxr->next_to_check;
 		/* Every 8 descriptors we go to refresh mbufs */
 		if (processed == 8) {
 			ixgbe_refresh_mbufs(rxr, i);
 			processed = 0;
+		}
+	}
 	/* Save the current status */
 	rxr->discard_multidesc = discard_multidesc;
 	/* Refresh any remaining buf structs */
 	if (ixgbe_rx_unrefreshed(rxr))
 		ixgbe_refresh_mbufs(rxr, i);
 	rxr->next_to_check = i;
 	IXGBE_RX_UNLOCK(rxr);
 #ifdef LRO
 	/*
 	 * Flush any outstanding LRO work
 	 */
 	tcp_lro_flush_all(lro);
 #endif /* LRO */
 	/*
 	 * Still have cleaning to do?
 	 */
 	if ((staterr & IXGBE_RXD_STAT_DD) != 0)
 @@ -2202,27 +2230,27 @@ ixgbe_dma_malloc(struct adapter *adapter
 		goto fail_0;
+	}
 	r = bus_dmamem_alloc(dma->dma_tag->dt_dmat, size,
 	    dma->dma_tag->dt_alignment, dma->dma_tag->dt_boundary,
 	    &dma->dma_seg, 1, &rsegs, BUS_DMA_NOWAIT);
 	if (r != 0) {
 		aprint_error_dev(dev,
 		    "%s: bus_dmamem_alloc failed; error %d\n", __func__, r);
 		goto fail_1;
+	}
 	r = bus_dmamem_map(dma->dma_tag->dt_dmat, &dma->dma_seg, rsegs,
-	    size, &dma->dma_vaddr, BUS_DMA_NOWAIT);
+	    size, &dma->dma_vaddr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
 	if (r != 0) {
 		aprint_error_dev(dev, "%s: bus_dmamem_map failed; error %d\n",
 		    __func__, r);
 		goto fail_2;
+	}
 	r = ixgbe_dmamap_create(dma->dma_tag, 0, &dma->dma_map);
 	if (r != 0) {
 		aprint_error_dev(dev, "%s: bus_dmamem_map failed; error %d\n",
 		    __func__, r);
 		goto fail_3;
+	}

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe.c,v 1.88.2.43 2021/03/11 16:04:25 martin Exp $ */
+/* $NetBSD: ixgbe.c,v 1.88.2.44 2021/09/15 16:38:00 martin 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
 @@ -53,31 +53,33 @@
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe.c,v 1.88.2.44 2021/09/15 16:38:00 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_inet6.h"
 #include "opt_net_mpsafe.h"
 #include "opt_ixgbe.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
  ************************************************************************/
 @@ -162,27 +164,27 @@ static const char    *ixgbe_strings[] =
 static int	ixgbe_probe(device_t, cfdata_t, void *);
 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_stop_locked(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_softint(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 *);
 @@ -234,32 +236,34 @@ static int	ixgbe_get_advertise(struct ad
 static void	ixgbe_set_sysctl_value(struct adapter *, const char *,
 		     const char *, int *, int);
 static int	ixgbe_sysctl_flowcntl(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_advertise(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_interrupt_rate_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_dmac(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_phy_temp(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_phy_overtemp_occurred(SYSCTLFN_PROTO);
 #ifdef IXGBE_DEBUG
 static int	ixgbe_sysctl_power_state(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_print_rss_config(SYSCTLFN_PROTO);
 #endif
 static int	ixgbe_sysctl_next_to_check_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_next_to_refresh_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_rdh_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_rdt_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_tdt_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_tdh_handler(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_eee_state(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_debug(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_rx_copy_len(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_wol_enable(SYSCTLFN_PROTO);
 static int	ixgbe_sysctl_wufc(SYSCTLFN_PROTO);
 /* Support for pluggable optic modules */
 static bool	ixgbe_sfp_probe(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_link(void *);
 @@ -929,51 +933,53 @@ ixgbe_attach(device_t parent, device_t d
 	    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;
-	adapter->num_jcl = adapter->num_rx_desc * IXGBE_JCLNUM_MULTI;
+	/* Set default high limit of copying mbuf in rxeof */
 	adapter->rx_copy_len = IXGBE_RX_COPY_LEN_MAX;
 	/* Allocate our TX/RX Queues */
 	if (ixgbe_allocate_queues(adapter)) {
 		error = ENOMEM;
 		goto err_out;
+	}
 	hw->phy.reset_if_overtemp = TRUE;
 	error = ixgbe_reset_hw(hw);
 	hw->phy.reset_if_overtemp = FALSE;
 	if (error == IXGBE_ERR_SFP_NOT_PRESENT) {
 		/*
 		 * No optics in this port, set up
 		 * so the timer routine will probe
 		 * for later insertion.
 		 */
 		adapter->sfp_probe = TRUE;
 		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");
+		aprint_error_dev(dev,
 		    "Hardware initialization failed(error = %d)\n", error);
 		error = EIO;
 		goto err_late;
+	}
 	/* Make sure we have a good EEPROM before we read from it */
 	if (ixgbe_validate_eeprom_checksum(&adapter->hw, NULL) < 0) {
 		aprint_error_dev(dev, "The EEPROM Checksum Is Not Valid\n");
 		error = EIO;
 		goto err_late;
+	}
 	aprint_normal("%s:", device_xname(dev));
 	/* NVM Image Version */
 @@ -1195,27 +1201,27 @@ ixgbe_attach(device_t parent, device_t d
 	adapter->dmac = 0;
 	/* Set initial advertised speeds (if applicable) */
 	adapter->advertise = ixgbe_get_advertise(adapter);
 	if (adapter->feat_cap & IXGBE_FEATURE_SRIOV)
 		ixgbe_define_iov_schemas(dev, &error);
 	/* Add sysctls */
 	ixgbe_add_device_sysctls(adapter);
 	ixgbe_add_hw_stats(adapter);
 	/* For Netmap */
 	adapter->init_locked = ixgbe_init_locked;
-	adapter->stop_locked = ixgbe_stop;
+	adapter->stop_locked = ixgbe_stop_locked;
 	if (adapter->feat_en & IXGBE_FEATURE_NETMAP)
 		ixgbe_netmap_attach(adapter);
 	snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_cap);
 	aprint_verbose_dev(dev, "feature cap %s\n", buf);
 	snprintb(buf, sizeof(buf), IXGBE_FEATURE_FLAGS, adapter->feat_en);
 	aprint_verbose_dev(dev, "feature ena %s\n", buf);
 	if (pmf_device_register(dev, ixgbe_suspend, ixgbe_resume))
 		pmf_class_network_register(dev, adapter->ifp);
 	else
 		aprint_error_dev(dev, "couldn't establish power handler\n");
 @@ -1642,37 +1648,40 @@ ixgbe_update_stats_counters(struct adapt
 	/* Hardware workaround, gprc counts missed packets */
 	stats->gprc.ev_count += IXGBE_READ_REG(hw, IXGBE_GPRC) - missed_rx;
 	lxon = IXGBE_READ_REG(hw, IXGBE_LXONTXC);
 	stats->lxontxc.ev_count += lxon;
 	lxoff = IXGBE_READ_REG(hw, IXGBE_LXOFFTXC);
 	stats->lxofftxc.ev_count += lxoff;
 	total = lxon + lxoff;
 	if (hw->mac.type != ixgbe_mac_82598EB) {
 		stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCL) +
 		    ((u64)IXGBE_READ_REG(hw, IXGBE_GORCH) << 32);
 		stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCL) +
-		    ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32) - total * ETHER_MIN_LEN;
+		    ((u64)IXGBE_READ_REG(hw, IXGBE_GOTCH) << 32)
 		    - total * ETHER_MIN_LEN;
 		stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORL) +
 		    ((u64)IXGBE_READ_REG(hw, IXGBE_TORH) << 32);
 		stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXCNT);
-		stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT);
+		stats->lxoffrxc.ev_count
 		    += IXGBE_READ_REG(hw, IXGBE_LXOFFRXCNT);
 	} else {
 		stats->lxonrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXONRXC);
 		stats->lxoffrxc.ev_count += IXGBE_READ_REG(hw, IXGBE_LXOFFRXC);
 		/* 82598 only has a counter in the high register */
 		stats->gorc.ev_count += IXGBE_READ_REG(hw, IXGBE_GORCH);
-		stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH) - total * ETHER_MIN_LEN;
+		stats->gotc.ev_count += IXGBE_READ_REG(hw, IXGBE_GOTCH)
 		    - total * ETHER_MIN_LEN;
 		stats->tor.ev_count += IXGBE_READ_REG(hw, IXGBE_TORH);
+	}
 	/*
 	 * Workaround: mprc hardware is incorrectly counting
 	 * broadcasts, so for now we subtract those.
 	 */
 	bprc = IXGBE_READ_REG(hw, IXGBE_BPRC);
 	stats->bprc.ev_count += bprc;
 	stats->mprc.ev_count += IXGBE_READ_REG(hw, IXGBE_MPRC)
 	    - ((hw->mac.type == ixgbe_mac_82598EB) ? bprc : 0);
 	stats->prc64.ev_count += IXGBE_READ_REG(hw, IXGBE_PRC64);
 @@ -1866,76 +1875,78 @@ ixgbe_add_hw_stats(struct adapter *adapt
 		evcnt_attach_dynamic(&txr->no_desc_avail, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "TX Queue No Descriptor Available");
 		evcnt_attach_dynamic(&txr->total_packets, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Packets Transmitted");
 #ifndef IXGBE_LEGACY_TX
 		evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Packets dropped in pcq");
 #endif
 		if (sysctl_createv(log, 0, &rnode, &cnode,
-		    CTLFLAG_READONLY,
+		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxck",
-		    CTLTYPE_INT,
+		    SYSCTL_DESCR("Receive Descriptor next to check"),
-		    "rxd_nxck", SYSCTL_DESCR("Receive Descriptor next to check"),
+		    ixgbe_sysctl_next_to_check_handler, 0, (void *)rxr, 0,
-			ixgbe_sysctl_next_to_check_handler, 0, (void *)rxr, 0,
+		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxrf",
 		    SYSCTL_DESCR("Receive Descriptor next to refresh"),
 		    ixgbe_sysctl_next_to_refresh_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
-		    CTLFLAG_READONLY,
+		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_head",
-		    CTLTYPE_INT,
+		    SYSCTL_DESCR("Receive Descriptor Head"),
 		    "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"),
 		    ixgbe_sysctl_rdh_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
-		    CTLFLAG_READONLY,
+		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_tail",
-		    CTLTYPE_INT,
+		    SYSCTL_DESCR("Receive Descriptor Tail"),
 		    "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"),
 		    ixgbe_sysctl_rdt_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (i < __arraycount(stats->qprc)) {
-			evcnt_attach_dynamic(&stats->qprc[i],
+			evcnt_attach_dynamic(&stats->qprc[i], EVCNT_TYPE_MISC,
-			    EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf,
+			    NULL, adapter->queues[i].evnamebuf, "qprc");
-			    "qprc");
+			evcnt_attach_dynamic(&stats->qptc[i], EVCNT_TYPE_MISC,
-			evcnt_attach_dynamic(&stats->qptc[i],
+			    NULL, adapter->queues[i].evnamebuf, "qptc");
-			    EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf,
+			evcnt_attach_dynamic(&stats->qbrc[i], EVCNT_TYPE_MISC,
-			    "qptc");
+			    NULL, adapter->queues[i].evnamebuf, "qbrc");
-			evcnt_attach_dynamic(&stats->qbrc[i],
+			evcnt_attach_dynamic(&stats->qbtc[i], EVCNT_TYPE_MISC,
-			    EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf,
+			    NULL, adapter->queues[i].evnamebuf, "qbtc");
 			    "qbrc");
 			evcnt_attach_dynamic(&stats->qbtc[i],
 			    EVCNT_TYPE_MISC, NULL, adapter->queues[i].evnamebuf,
 			    "qbtc");
 			if (hw->mac.type >= ixgbe_mac_82599EB)
 				evcnt_attach_dynamic(&stats->qprdc[i],
 				    EVCNT_TYPE_MISC, NULL,
 				    adapter->queues[i].evnamebuf, "qprdc");
+		}
 		evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC,
-		    NULL, adapter->queues[i].evnamebuf, "Queue Packets Received");
+		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Packets Received");
 		evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC,
-		    NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received");
+		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Bytes Received");
 		evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Copied RX Frames");
-		evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC,
+		evcnt_attach_dynamic(&rxr->no_mbuf, EVCNT_TYPE_MISC,
-		    NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf");
+		    NULL, adapter->queues[i].evnamebuf, "Rx no mbuf");
 		evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Rx discarded");
 #ifdef LRO
 		SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued",
 				CTLFLAG_RD, &lro->lro_queued, 0,
 				"LRO Queued");
 		SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed",
 				CTLFLAG_RD, &lro->lro_flushed, 0,
 				"LRO Flushed");
 #endif /* LRO */
+	}
 	/* MAC stats get their own sub node */
 @@ -2113,27 +2124,27 @@ ixgbe_clear_evcnt(struct adapter *adapte
 		if (i < __arraycount(stats->qprc)) {
 			stats->qprc[i].ev_count = 0;
 			stats->qptc[i].ev_count = 0;
 			stats->qbrc[i].ev_count = 0;
 			stats->qbtc[i].ev_count = 0;
 			if (hw->mac.type >= ixgbe_mac_82599EB)
 				stats->qprdc[i].ev_count = 0;
+		}
 		rxr->rx_packets.ev_count = 0;
 		rxr->rx_bytes.ev_count = 0;
 		rxr->rx_copies.ev_count = 0;
-		rxr->no_jmbuf.ev_count = 0;
+		rxr->no_mbuf.ev_count = 0;
 		rxr->rx_discarded.ev_count = 0;
+	}
 	stats->ipcs.ev_count = 0;
 	stats->l4cs.ev_count = 0;
 	stats->ipcs_bad.ev_count = 0;
 	stats->l4cs_bad.ev_count = 0;
 	stats->intzero.ev_count = 0;
 	stats->legint.ev_count = 0;
 	stats->crcerrs.ev_count = 0;
 	stats->illerrc.ev_count = 0;
 	stats->errbc.ev_count = 0;
 	stats->mspdc.ev_count = 0;
 	if (hw->mac.type >= ixgbe_mac_X550)
 @@ -2250,26 +2261,52 @@ ixgbe_sysctl_next_to_check_handler(SYSCT
 	if (!rxr)
 		return (0);
 	adapter = rxr->adapter;
 	if (ixgbe_fw_recovery_mode_swflag(adapter))
 		return (EPERM);
 	val = rxr->next_to_check;
 	node.sysctl_data = &val;
 	return sysctl_lookup(SYSCTLFN_CALL(&node));
 } /* ixgbe_sysctl_next_to_check_handler */
 /************************************************************************
  * ixgbe_sysctl_next_to_refresh_handler - Receive Descriptor next to check
  * handler function
+ *
  *   Retrieves the next_to_refresh value
  ************************************************************************/
 static int
 ixgbe_sysctl_next_to_refresh_handler(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data;
 	struct adapter *adapter;
 	uint32_t val;
 	if (!rxr)
 		return (0);
 	adapter = rxr->adapter;
 	if (ixgbe_fw_recovery_mode_swflag(adapter))
 		return (EPERM);
 	val = rxr->next_to_refresh;
 	node.sysctl_data = &val;
 	return sysctl_lookup(SYSCTLFN_CALL(&node));
 } /* ixgbe_sysctl_next_to_refresh_handler */
 /************************************************************************
  * ixgbe_sysctl_rdh_handler - Receive Descriptor Head handler function
+ *
  *   Retrieves the RDH value from the hardware
  ************************************************************************/
 static int
 ixgbe_sysctl_rdh_handler(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data;
 	struct adapter *adapter;
 	uint32_t val;
 	if (!rxr)
 @@ -3088,28 +3125,31 @@ ixgbe_msix_link(void *arg)
 		/* Check for over temp condition */
 		if (adapter->feat_en & IXGBE_FEATURE_TEMP_SENSOR) {
 			switch (adapter->hw.mac.type) {
 			case ixgbe_mac_X550EM_a:
 				if (!(eicr & IXGBE_EICR_GPI_SDP0_X550EM_a))
 					break;
 				IXGBE_WRITE_REG(hw, IXGBE_EIMC,
 				    IXGBE_EICR_GPI_SDP0_X550EM_a);
 				IXGBE_WRITE_REG(hw, IXGBE_EICR,
 				    IXGBE_EICR_GPI_SDP0_X550EM_a);
 				retval = hw->phy.ops.check_overtemp(hw);
 				if (retval != IXGBE_ERR_OVERTEMP)
 					break;
-				device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n");
+				device_printf(adapter->dev,
-				device_printf(adapter->dev, "System shutdown required!\n");
+				    "CRITICAL: OVER TEMP!! "
 				    "PHY IS SHUT DOWN!!\n");
 				device_printf(adapter->dev,
 				    "System shutdown required!\n");
 				break;
 			default:
 				if (!(eicr & IXGBE_EICR_TS))
 					break;
 				retval = hw->phy.ops.check_overtemp(hw);
 				if (retval != IXGBE_ERR_OVERTEMP)
 					break;
 				device_printf(adapter->dev, "CRITICAL: OVER TEMP!! PHY IS SHUT DOWN!!\n");
 				device_printf(adapter->dev, "System shutdown required!\n");
 				IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_TS);
 				break;
+			}
+		}
 @@ -3243,40 +3283,41 @@ ixgbe_add_device_sysctls(struct adapter
 	struct sysctllog **log;
 	const struct sysctlnode *rnode, *cnode;
 	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,
 	    "debug", SYSCTL_DESCR("Debug Info"),
-	    ixgbe_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0)
+	    ixgbe_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL)
 	    != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	if (sysctl_createv(log, 0, &rnode, &cnode,
-	    CTLFLAG_READONLY, CTLTYPE_INT,
+	    CTLFLAG_READWRITE, CTLTYPE_INT,
-	    "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"),
+	    "rx_copy_len", SYSCTL_DESCR("RX Copy Length"),
-	    NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0)
+	    ixgbe_sysctl_rx_copy_len, 0,
 	    (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	if (sysctl_createv(log, 0, &rnode, &cnode,
-	    CTLFLAG_READONLY, CTLTYPE_INT, "num_jcl_per_queue",
+	    CTLFLAG_READONLY, CTLTYPE_INT,
-	    SYSCTL_DESCR("Number of jumbo buffers per queue"),
+	    "num_rx_desc", SYSCTL_DESCR("Number of rx descriptors"),
-	    NULL, 0, &adapter->num_jcl, 0, CTL_CREATE,
+	    NULL, 0, &adapter->num_rx_desc, 0, CTL_CREATE, CTL_EOL) != 0)
 	    CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	if (sysctl_createv(log, 0, &rnode, &cnode,
 	    CTLFLAG_READONLY, CTLTYPE_INT,
 	    "num_queues", SYSCTL_DESCR("Number of queues"),
 	    NULL, 0, &adapter->num_queues, 0, CTL_CREATE, CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	/* Sysctls for all devices */
 	if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE,
 	    CTLTYPE_INT, "fc", SYSCTL_DESCR(IXGBE_SYSCTL_DESC_SET_FC),
 	    ixgbe_sysctl_flowcntl, 0, (void *)adapter, 0, CTL_CREATE,
 	    CTL_EOL) != 0)
 @@ -3297,28 +3338,30 @@ ixgbe_add_device_sysctls(struct adapter
 	/*
 	 * If each "que->txrx_use_workqueue" is changed in sysctl handler,
 	 * it causesflip-flopping softint/workqueue mode in one deferred
 	 * processing. Therefore, preempt_disable()/preempt_enable() are
 	 * required in ixgbe_sched_handle_que() to avoid
 	 * KASSERT(ixgbe_sched_handle_que()) in softint_schedule().
 	 * I think changing "que->txrx_use_workqueue" in interrupt handler
 	 * is lighter than doing preempt_disable()/preempt_enable() in every
 	 * ixgbe_sched_handle_que().
 	 */
 	adapter->txrx_use_workqueue = ixgbe_txrx_workqueue;
 	if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE,
-	    CTLTYPE_BOOL, "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"),
+	    CTLTYPE_BOOL, "txrx_workqueue",
-	    NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0)
+	    SYSCTL_DESCR("Use workqueue for packet processing"),
 	    NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE,
 	    CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 #ifdef IXGBE_DEBUG
 	/* testing sysctls (for all devices) */
 	if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE,
 	    CTLTYPE_INT, "power_state", SYSCTL_DESCR("PCI Power State"),
 	    ixgbe_sysctl_power_state, 0, (void *)adapter, 0, CTL_CREATE,
 	    CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READONLY,
 	    CTLTYPE_STRING, "print_rss_config",
 	    SYSCTL_DESCR("Prints RSS Configuration"),
 @@ -3361,27 +3404,28 @@ ixgbe_add_device_sysctls(struct adapter
 			aprint_error_dev(dev, "could not create sysctl\n");
 			return;
+		}
 		if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY,
 		    CTLTYPE_INT, "temp",
 		    SYSCTL_DESCR("Current External PHY Temperature (Celsius)"),
 		    ixgbe_sysctl_phy_temp, 0, (void *)adapter, 0, CTL_CREATE,
 		    CTL_EOL) != 0)
 			aprint_error_dev(dev, "could not create sysctl\n");
 		if (sysctl_createv(log, 0, &phy_node, &cnode, CTLFLAG_READONLY,
 		    CTLTYPE_INT, "overtemp_occurred",
-		    SYSCTL_DESCR("External PHY High Temperature Event Occurred"),
+		    SYSCTL_DESCR(
 			    "External PHY High Temperature Event Occurred"),
 		    ixgbe_sysctl_phy_overtemp_occurred, 0, (void *)adapter, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			aprint_error_dev(dev, "could not create sysctl\n");
+	}
 	if ((hw->mac.type == ixgbe_mac_X550EM_a)
 	    && (hw->phy.type == ixgbe_phy_fw))
 		if (sysctl_createv(log, 0, &rnode, &cnode, CTLFLAG_READWRITE,
 		    CTLTYPE_BOOL, "force_10_100_autonego",
 		    SYSCTL_DESCR("Force autonego on 10M and 100M"),
 		    NULL, 0, &hw->phy.force_10_100_autonego, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			aprint_error_dev(dev, "could not create sysctl\n");
 @@ -3519,28 +3563,29 @@ ixgbe_detach(device_t dev, int flags)
 	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);
+	}
 	/*
-	 * Stop the interface. ixgbe_setup_low_power_mode() calls ixgbe_stop(),
+	 * Stop the interface. ixgbe_setup_low_power_mode() calls
-	 * so it's not required to call ixgbe_stop() directly.
+	 * ixgbe_stop_locked(), so it's not required to call ixgbe_stop_locked()
 	 * directly.
 	 */
 	IXGBE_CORE_LOCK(adapter);
 	ixgbe_setup_low_power_mode(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 #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);
 @@ -3618,27 +3663,27 @@ ixgbe_detach(device_t dev, int flags)
 		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->no_mbuf);
 		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)
 @@ -3704,35 +3749,35 @@ 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);
+		ixgbe_stop_locked(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);
+		ixgbe_stop_locked(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
 @@ -3861,27 +3906,27 @@ ixgbe_set_if_hwassist(struct adapter *ad
 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;
+	int		i, j, error;
 	/* 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);
 	for (i = 0, que = adapter->queues; i < adapter->num_queues; i++, que++)
 		que->disabled_count = 0;
 @@ -3897,49 +3942,48 @@ ixgbe_init_locked(struct adapter *adapte
 	/* 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);
+		ixgbe_stop_locked(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 */
+	/* Use fixed buffer size, even for jumbo frames */
-	if (adapter->max_frame_size <= MCLBYTES)
+	adapter->rx_mbuf_sz = MCLBYTES;
 		adapter->rx_mbuf_sz = MCLBYTES;
 	else
 		adapter->rx_mbuf_sz = MJUMPAGESIZE;
 	/* Prepare receive descriptors and buffers */
-	if (ixgbe_setup_receive_structures(adapter)) {
+	error = ixgbe_setup_receive_structures(adapter);
-		device_printf(dev, "Could not setup receive structures\n");
+	if (error) {
-		ixgbe_stop(adapter);
+		device_printf(dev,
 		    "Could not setup receive structures (err = %d)\n", error);
 		ixgbe_stop_locked(adapter);
 		return;
+	}
 	/* Configure RX settings */
 	ixgbe_initialize_receive_units(adapter);
 	/* 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);
 @@ -4041,28 +4085,28 @@ ixgbe_init_locked(struct adapter *adapte
 	} 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);
+		error = hw->phy.ops.identify(hw);
-		if (err == IXGBE_ERR_SFP_NOT_SUPPORTED)
+		if (error == 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)
 @@ -4515,27 +4559,27 @@ watchdog:
 static void
 ixgbe_recovery_mode_timer(void *arg)
+{
 	struct adapter *adapter = arg;
 	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);
+				ixgbe_stop_locked(adapter);
+		}
 	} else
 		atomic_cas_uint(&adapter->recovery_mode, 1, 0);
 	callout_reset(&adapter->recovery_mode_timer, hz,
 	    ixgbe_recovery_mode_timer, adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 } /* ixgbe_recovery_mode_timer */
 /************************************************************************
  * ixgbe_sfp_probe
+ *
  *   Determine if a port had optics inserted.
 @@ -4685,71 +4729,71 @@ ixgbe_handle_phy(void *context)
 		    "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_ifstop(struct ifnet *ifp, int disable)
+{
 	struct adapter *adapter = ifp->if_softc;
 	IXGBE_CORE_LOCK(adapter);
-	ixgbe_stop(adapter);
+	ixgbe_stop_locked(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
+}
 /************************************************************************
- * ixgbe_stop - Stop the hardware
+ * ixgbe_stop_locked - Stop the hardware
+ *
  *   Disables all traffic on the adapter by issuing a
  *   global reset on the MAC and deallocates TX/RX buffers.
  ************************************************************************/
 static void
-ixgbe_stop(void *arg)
+ixgbe_stop_locked(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");
+	INIT_DEBUGOUT("ixgbe_stop_locked: begin\n");
 	ixgbe_disable_intr(adapter);
 	callout_stop(&adapter->timer);
 	/* 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_stop_locked */
 /************************************************************************
  * 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;
 @@ -5342,28 +5386,27 @@ ixgbe_set_advertise(struct adapter *adap
 	/* No speed changes for backplane media */
 	if (hw->phy.media_type == ixgbe_media_type_backplane)
 		return (ENODEV);
 	if (!((hw->phy.media_type == ixgbe_media_type_copper) ||
 	    (hw->phy.multispeed_fiber))) {
 		device_printf(dev,
 		    "Advertised speed can only be set on copper or "
 		    "multispeed fiber media types.\n");
 		return (EINVAL);
+	}
 	if (advertise < 0x0 || advertise > 0x3f) {
-		device_printf(dev,
+		device_printf(dev, "Invalid advertised speed; valid modes are 0x0 through 0x3f\n");
 		    "Invalid advertised speed; valid modes are 0x0 through 0x3f\n");
 		return (EINVAL);
+	}
 	if (hw->mac.ops.get_link_capabilities) {
 		err = hw->mac.ops.get_link_capabilities(hw, &link_caps,
 		    &negotiate);
 		if (err != IXGBE_SUCCESS) {
 			device_printf(dev, "Unable to determine supported advertise speeds\n");
 			return (ENODEV);
+		}
+	}
 	/* Set new value and report new advertised mode */
 @@ -5968,26 +6011,51 @@ ixgbe_sysctl_debug(SYSCTLFN_ARGS)
 	node.sysctl_data = &result;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return error;
 	if (result == 1)
 		ixgbe_print_debug_info(adapter);
 	return 0;
 } /* ixgbe_sysctl_debug */
 /************************************************************************
  * ixgbe_sysctl_rx_copy_len
  ************************************************************************/
 static int
 ixgbe_sysctl_rx_copy_len(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct adapter *adapter = (struct adapter *)node.sysctl_data;
 	int error;
 	int result = adapter->rx_copy_len;
 	node.sysctl_data = &result;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return error;
 	if ((result < 0) || (result > IXGBE_RX_COPY_LEN_MAX))
 		return EINVAL;
 	adapter->rx_copy_len = result;
 	return 0;
 } /* ixgbe_sysctl_rx_copy_len */
 /************************************************************************
  * ixgbe_init_device_features
  ************************************************************************/
 static void
 ixgbe_init_device_features(struct adapter *adapter)
+{
 	adapter->feat_cap = IXGBE_FEATURE_NETMAP
 			  | IXGBE_FEATURE_RSS
 			  | IXGBE_FEATURE_MSI
 			  | IXGBE_FEATURE_MSIX
 			  | IXGBE_FEATURE_LEGACY_IRQ
 			  | IXGBE_FEATURE_LEGACY_TX;
 	/* Set capabilities first... */
 @@ -6316,27 +6384,28 @@ ixgbe_ioctl(struct ifnet *ifp, u_long co
 /************************************************************************
  * ixgbe_check_fan_failure
  ************************************************************************/
 static void
 ixgbe_check_fan_failure(struct adapter *adapter, u32 reg, bool in_interrupt)
+{
 	u32 mask;
 	mask = (in_interrupt) ? IXGBE_EICR_GPI_SDP1_BY_MAC(&adapter->hw) :
 	    IXGBE_ESDP_SDP1;
 	if (reg & mask)
-		device_printf(adapter->dev, "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n");
+		device_printf(adapter->dev,
 		    "\nCRITICAL: FAN FAILURE!! REPLACE IMMEDIATELY!!\n");
 } /* ixgbe_check_fan_failure */
 /************************************************************************
  * ixgbe_handle_que
  ************************************************************************/
 static void
 ixgbe_handle_que(void *context)
+{
 	struct ix_queue *que = context;
 	struct adapter	*adapter = que->adapter;
 	struct tx_ring	*txr = que->txr;
 	struct ifnet	*ifp = adapter->ifp;
 	bool		more = false;
 @@ -6457,27 +6526,28 @@ alloc_retry:
 		adapter->osdep.intrs = NULL;
 		return ENXIO;
+	}
 	aprint_normal_dev(dev, "interrupting at %s\n", intrstr);
 	/*
 	 * Try allocating a fast interrupt and the associated deferred
 	 * processing contexts.
 	 */
 	if (!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)) {
 		txr->txr_si =
 		    softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS,
 			ixgbe_deferred_mq_start, txr);
-		snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev));
+		snprintf(wqname, sizeof(wqname), "%sdeferTx",
 		    device_xname(dev));
 		defertx_error = workqueue_create(&adapter->txr_wq, wqname,
 		    ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI,
 		    IPL_NET, IXGBE_WORKQUEUE_FLAGS);
 		adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int));
+	}
 	que->que_si = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS,
 	    ixgbe_handle_que, que);
 	snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev));
 	error = workqueue_create(&adapter->que_wq, wqname,
 	    ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET,
 	    IXGBE_WORKQUEUE_FLAGS);
 	if ((!(adapter->feat_en & IXGBE_FEATURE_LEGACY_TX)
 @@ -6627,27 +6697,28 @@ ixgbe_allocate_msix(struct adapter *adap
 			ixgbe_handle_que, que);
 		if (que->que_si == NULL) {
 			aprint_error_dev(dev,
 			    "couldn't establish software interrupt\n");
 			error = ENXIO;
 			goto err_out;
+		}
+	}
 	snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev));
 	error = workqueue_create(&adapter->txr_wq, wqname,
 	    ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET,
 	    IXGBE_WORKQUEUE_FLAGS);
 	if (error) {
-		aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n");
+		aprint_error_dev(dev,
 		    "couldn't create workqueue for deferred Tx\n");
 		goto err_out;
+	}
 	adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int));
 	snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev));
 	error = workqueue_create(&adapter->que_wq, wqname,
 	    ixgbe_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET,
 	    IXGBE_WORKQUEUE_FLAGS);
 	if (error) {
 		aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n");
 		goto err_out;
+	}

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe.h,v 1.24.6.21 2021/03/11 16:04:25 martin Exp $ */
+/* $NetBSD: ixgbe.h,v 1.24.6.22 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -173,30 +173,27 @@
 /* Flow control constants */
 #define IXGBE_FC_PAUSE        0xFFFF
 /*
  * Used for optimizing small rx mbufs.  Effort is made to keep the copy
  * small and aligned for the CPU L1 cache.
+ *
  * MHLEN is typically 168 bytes, giving us 8-byte alignment.  Getting
  * 32 byte alignment needed for the fast bcopy results in 8 bytes being
  * wasted.  Getting 64 byte alignment, which _should_ be ideal for
  * modern Intel CPUs, results in 40 bytes wasted and a significant drop
  * in observed efficiency of the optimization, 97.9% -> 81.8%.
  */
-#define	MPKTHSIZE		(offsetof(struct _mbuf_dummy, m_pktdat))
+#define IXGBE_RX_COPY_LEN_MAX     (MHLEN - ETHER_ALIGN)
 #define IXGBE_RX_COPY_HDR_PADDED  ((((MPKTHSIZE - 1) / 32) + 1) * 32)
 #define IXGBE_RX_COPY_LEN         (MSIZE - IXGBE_RX_COPY_HDR_PADDED)
 #define IXGBE_RX_COPY_ALIGN       (IXGBE_RX_COPY_HDR_PADDED - MPKTHSIZE)
 /* Keep older OS drivers building... */
 #if !defined(SYSCTL_ADD_UQUAD)
 #define SYSCTL_ADD_UQUAD SYSCTL_ADD_QUAD
 #endif
 /* Defines for printing debug information */
 #define DEBUG_INIT  0
 #define DEBUG_IOCTL 0
 #define DEBUG_HW    0
 #define INIT_DEBUGOUT(S)            if (DEBUG_INIT)  printf(S "\n")
 #define INIT_DEBUGOUT1(S, A)        if (DEBUG_INIT)  printf(S "\n", A)
 @@ -321,28 +318,28 @@ struct ix_queue {
 	u32              msix;           /* This queue's MSI-X vector */
 	u32              eitr_setting;
 	u32              me;
 	struct resource  *res;
 	int              busy;
 	struct tx_ring   *txr;
 	struct rx_ring   *rxr;
 	struct work      wq_cookie;
 	void             *que_si;
 	/* Per queue event conters */
 	struct evcnt     irqs;		/* Hardware interrupt */
 	struct evcnt     handleq;	/* software_interrupt */
 	struct evcnt     req;		/* deferred */
-	char             namebuf[32];
+	char             namebuf[32];	/* Name for sysctl */
-	char             evnamebuf[32];
+	char             evnamebuf[32];	/* Name for evcnt */
 	/* Lock for disabled_count and this queue's EIMS/EIMC bit */
 	kmutex_t         dc_mtx;
 	/*
 	 * disabled_count means:
 	 *     0   : this queue is enabled
 	 *     > 0 : this queue is disabled
 	 *           the value is ixgbe_disable_queue() called count
 	 */
 	int              disabled_count;
 	bool             txrx_use_workqueue;
 };
 @@ -400,48 +397,46 @@ struct tx_ring {
 struct rx_ring {
 	struct adapter		*adapter;
 	kmutex_t		rx_mtx;
 	u32			me;
 	u32			tail;
 	union ixgbe_adv_rx_desc	*rx_base;
 	struct ixgbe_dma_alloc	rxdma;
 #ifdef LRO
 	struct lro_ctrl		lro;
 #endif /* LRO */
 	bool			lro_enabled;
 	bool			hw_rsc;
 	bool			vtag_strip;
 	bool			discard_multidesc;
 	u16			next_to_refresh;
 	u16			next_to_check;
 	u16			num_desc;
 	u16			mbuf_sz;
 #if 0
 	char			mtx_name[16]; /* NetBSD has no mutex name */
 #endif
 	struct ixgbe_rx_buf	*rx_buffers;
 	ixgbe_dma_tag_t		*ptag;
 	u16			last_rx_mbuf_sz;
 	u32			last_num_rx_desc;
 	ixgbe_extmem_head_t	jcl_head;
 	u64			bytes; /* Used for AIM calc */
 	u64			packets;
 	/* Soft stats */
 	struct evcnt		rx_copies;
 	struct evcnt		rx_packets;
 	struct evcnt		rx_bytes;
 	struct evcnt		rx_discarded;
-	struct evcnt		no_jmbuf;
+	struct evcnt		no_mbuf;
 	u64			rsc_num;
 	/* Flow Director */
 	u64			flm;
 };
 struct ixgbe_vf {
 	u_int    pool;
 	u_int    rar_index;
 	u_int    max_frame_size;
 	uint32_t flags;
 	uint8_t  ether_addr[ETHER_ADDR_LEN];
 	uint16_t mc_hash[IXGBE_MAX_VF_MC];
 @@ -549,27 +544,27 @@ struct adapter {
 	 */
 	struct tx_ring		*tx_rings;
 	u32			num_tx_desc;
 	u32			tx_process_limit;
 	/*
 	 * Receive rings
 	 *      Allocated at run time, an array of rings
 	 */
 	struct rx_ring		*rx_rings;
 	u64			active_queues;
 	u32			num_rx_desc;
 	u32			rx_process_limit;
-	int			num_jcl;
+	u32			rx_copy_len;
 	/* Multicast array memory */
 	struct ixgbe_mc_addr	*mta;
 	/* SR-IOV */
 	int                     iov_mode;
 	int			num_vfs;
 	int			pool;
 	struct ixgbe_vf		*vfs;
 	/* Bypass */
 	struct ixgbe_bp_data    bypass;
 @@ -747,26 +742,22 @@ int  ixgbe_mq_start_locked(struct ifnet
 void ixgbe_deferred_mq_start(void *);
 void ixgbe_deferred_mq_start_work(struct work *, void *);
 void ixgbe_drain_all(struct adapter *);
 int  ixgbe_allocate_queues(struct adapter *);
 void ixgbe_free_queues(struct adapter *);
 int  ixgbe_setup_transmit_structures(struct adapter *);
 void ixgbe_free_transmit_structures(struct adapter *);
 int  ixgbe_setup_receive_structures(struct adapter *);
 void ixgbe_free_receive_structures(struct adapter *);
 bool ixgbe_txeof(struct tx_ring *);
 bool ixgbe_rxeof(struct ix_queue *);
 const struct sysctlnode *ixgbe_sysctl_instance(struct adapter *);
 /* For NetBSD */
-void ixgbe_jcl_reinit(struct adapter *, bus_dma_tag_t, struct rx_ring *,
+const struct sysctlnode *ixgbe_sysctl_instance(struct adapter *);
     int, size_t);
 void ixgbe_jcl_destroy(struct adapter *,  struct rx_ring *);
 #include "ixgbe_bypass.h"
 #include "ixgbe_fdir.h"
 #include "ixgbe_rss.h"
 #include "ixgbe_netmap.h"
 #endif /* _IXGBE_H_ */

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_82598.c,v 1.8.8.5 2020/09/02 12:27:54 martin Exp $ */
+/* $NetBSD: ixgbe_82598.c,v 1.8.8.6 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -25,26 +25,29 @@
   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/ixgbe_82598.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_82598.c,v 1.8.8.6 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_type.h"
 #include "ixgbe_82598.h"
 #include "ixgbe_api.h"
 #include "ixgbe_common.h"
 #include "ixgbe_phy.h"
 #define IXGBE_82598_MAX_TX_QUEUES 32
 #define IXGBE_82598_MAX_RX_QUEUES 64
 #define IXGBE_82598_RAR_ENTRIES   16
 #define IXGBE_82598_MC_TBL_SIZE  128
 #define IXGBE_82598_VFT_TBL_SIZE 128
 #define IXGBE_82598_RX_PB_SIZE   512

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_82599.c,v 1.14.8.6 2020/09/02 12:27:54 martin Exp $ */
+/* $NetBSD: ixgbe_82599.c,v 1.14.8.7 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -25,26 +25,29 @@
   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/ixgbe_82599.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_82599.c,v 1.14.8.7 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_type.h"
 #include "ixgbe_82599.h"
 #include "ixgbe_api.h"
 #include "ixgbe_common.h"
 #include "ixgbe_phy.h"
 #define IXGBE_82599_MAX_TX_QUEUES 128
 #define IXGBE_82599_MAX_RX_QUEUES 128
 #define IXGBE_82599_RAR_ENTRIES   128
 #define IXGBE_82599_MC_TBL_SIZE   128
 #define IXGBE_82599_VFT_TBL_SIZE  128
 #define IXGBE_82599_RX_PB_SIZE	  512

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_api.c,v 1.15.8.6 2020/01/24 18:37:31 martin Exp $ */
+/* $NetBSD: ixgbe_api.c,v 1.15.8.7 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -25,26 +25,29 @@
   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/ixgbe_api.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_api.c,v 1.15.8.7 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_api.h"
 #include "ixgbe_common.h"
 #define IXGBE_EMPTY_PARAM
 static const u32 ixgbe_mvals_base[IXGBE_MVALS_IDX_LIMIT] = {
 	IXGBE_MVALS_INIT(IXGBE_EMPTY_PARAM)
 };
 static const u32 ixgbe_mvals_X540[IXGBE_MVALS_IDX_LIMIT] = {
 	IXGBE_MVALS_INIT(_X540)
 };

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_bypass.h,v 1.1.4.3 2021/09/15 16:38:01 martin 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

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_netmap.h,v 1.1.4.3 2021/09/15 16:38:01 martin 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

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_common.c,v 1.13.2.10 2020/09/02 12:24:08 martin Exp $ */
+/* $NetBSD: ixgbe_common.c,v 1.13.2.11 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -25,26 +25,29 @@
   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/ixgbe_common.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_common.c,v 1.13.2.11 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_common.h"
 #include "ixgbe_phy.h"
 #include "ixgbe_dcb.h"
 #include "ixgbe_dcb_82599.h"
 #include "ixgbe_api.h"
 static s32 ixgbe_acquire_eeprom(struct ixgbe_hw *hw);
 static s32 ixgbe_get_eeprom_semaphore(struct ixgbe_hw *hw);
 static void ixgbe_release_eeprom_semaphore(struct ixgbe_hw *hw);
 static s32 ixgbe_ready_eeprom(struct ixgbe_hw *hw);
 static void ixgbe_standby_eeprom(struct ixgbe_hw *hw);
 static void ixgbe_shift_out_eeprom_bits(struct ixgbe_hw *hw, u16 data,
 					u16 count);
 @@ -1128,27 +1131,27 @@ s32 ixgbe_stop_adapter_generic(struct ix
 	 * the hardware
 	 */
 	hw->adapter_stopped = TRUE;
 	/* Disable the receive unit */
 	ixgbe_disable_rx(hw);
 	/* Clear interrupt mask to stop interrupts from being generated */
 	/*
 	 * XXX
 	 * This function is called in the state of both interrupt disabled
 	 * and interrupt enabled, e.g.
 	 * + interrupt disabled case:
-	 *   - ixgbe_stop()
+	 *   - ixgbe_stop_locked()
 	 *     - ixgbe_disable_intr() // interrupt disabled here
 	 *     - ixgbe_stop_adapter()
 	 *       - hw->mac.ops.stop_adapter()
 	 *         == this function
 	 * + interrupt enabled case:
 	 *   - ixgbe_local_timer1()
 	 *     - ixgbe_init_locked()
 	 *       - ixgbe_stop_adapter()
 	 *         - hw->mac.ops.stop_adapter()
 	 *           == this function
 	 * Therefore, it causes nest status breaking to nest the status
 	 * (that is, que->im_nest++) at all times. So, this function must
 	 * use ixgbe_ensure_disabled_intr() instead of ixgbe_disable_intr().
 @@ -5038,28 +5041,28 @@ s32 ixgbe_bypass_rw_generic(struct ixgbe
 	IXGBE_WRITE_REG(hw, IXGBE_ESDP, esdp);
 	IXGBE_WRITE_FLUSH(hw);
 	/* set the page bits to match the cmd that the status it belongs to */
 	*status = (*status & 0x3fffffff) | (cmd & 0xc0000000);
 	return IXGBE_SUCCESS;
+}
 /**
  * ixgbe_bypass_valid_rd_generic - Verify valid return from bit-bang.
+ *
  * If we send a write we can't be sure it took until we can read back
- * that same register.  It can be a problem as some of the feilds may
+ * that same register.  It can be a problem as some of the fields may
- * for valid reasons change inbetween the time wrote the register and
+ * for valid reasons change in-between the time wrote the register and
  * we read it again to verify.  So this function check everything we
  * can check and then assumes it worked.
+ *
  * @u32 in_reg - The register cmd for the bit-bang read.
  * @u32 out_reg - The register returned from a bit-bang read.
  **/
 bool ixgbe_bypass_valid_rd_generic(u32 in_reg, u32 out_reg)
+{
 	u32 mask;
 	/* Page must match for all control pages */
 	if ((in_reg & BYPASS_PAGE_M) != (out_reg & BYPASS_PAGE_M))
 		return FALSE;
 @@ -5092,27 +5095,27 @@ bool ixgbe_bypass_valid_rd_generic(u32 i
 		break;
 	case BYPASS_PAGE_CTL2:
 		/* All we can check in this page is control number
 		 * which is already done above.
 		 */
 		break;
+	}
 	/* We are as sure as we can be return TRUE */
 	return TRUE;
+}
 /**
- *  ixgbe_bypass_set_generic - Set a bypass field in the FW CTRL Regiter.
+ *  ixgbe_bypass_set_generic - Set a bypass field in the FW CTRL Register.
+ *
  *  @hw: pointer to hardware structure
  *  @cmd: The control word we are setting.
  *  @event: The event we are setting in the FW.  This also happens to
  *	    be the mask for the event we are setting (handy)
  *  @action: The action we set the event to in the FW. This is in a
  *	     bit field that happens to be what we want to put in
  *	     the event spot (also handy)
  **/
 s32 ixgbe_bypass_set_generic(struct ixgbe_hw *hw, u32 ctrl, u32 event,
 			     u32 action)
+{
 	u32 by_ctl = 0;
 @@ -5138,27 +5141,27 @@ s32 ixgbe_bypass_set_generic(struct ixgb
 			if (ixgbe_bypass_rw_generic(hw, verify, &by_ctl))
 				return IXGBE_ERR_INVALID_ARGUMENT;
 		} while (!ixgbe_bypass_valid_rd_generic(cmd, by_ctl));
 	} else {
 		/* We have give the FW time for the write to stick */
 		msec_delay(100);
+	}
 	return IXGBE_SUCCESS;
+}
 /**
- *  ixgbe_bypass_rd_eep_generic - Read the bypass FW eeprom addres.
+ *  ixgbe_bypass_rd_eep_generic - Read the bypass FW eeprom address.
+ *
  *  @hw: pointer to hardware structure
  *  @addr: The bypass eeprom address to read.
  *  @value: The 8b of data at the address above.
  **/
 s32 ixgbe_bypass_rd_eep_generic(struct ixgbe_hw *hw, u32 addr, u8 *value)
+{
 	u32 cmd;
 	u32 status;
 	/* send the request */
 	cmd = BYPASS_PAGE_CTL2 | BYPASS_WE;

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_dcb.c,v 1.4.8.3 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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
 @@ -23,26 +24,28 @@
   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/ixgbe_dcb.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_dcb.c,v 1.4.8.3 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_type.h"
 #include "ixgbe_dcb.h"
 #include "ixgbe_dcb_82598.h"
 #include "ixgbe_dcb_82599.h"
 /**
  * ixgbe_dcb_calculate_tc_credits - This calculates the ieee traffic class
  * credits from the configured bandwidth percentages. Credits
  * are the smallest unit programmable into the underlying
  * hardware. The IEEE 802.1Qaz specification do not use bandwidth
  * groups so this is much simplified from the CEE case.
  * @bw: bandwidth index by traffic class

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_dcb.h,v 1.3.8.3 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_dcb_82598.c,v 1.3.8.3 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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
 @@ -23,26 +24,28 @@
   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/ixgbe_dcb_82598.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_dcb_82598.c,v 1.3.8.3 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_type.h"
 #include "ixgbe_dcb.h"
 #include "ixgbe_dcb_82598.h"
 /**
  * ixgbe_dcb_get_tc_stats_82598 - Return status data for each traffic class
  * @hw: pointer to hardware structure
  * @stats: pointer to statistics structure
  * @tc_count:  Number of elements in bwg_array.
+ *
  * This function returns the status data for each of the Traffic Classes in use.
  */

 @@ -1,13 +1,15 @@
 /* $NetBSD: ixgbe_dcb_82598.h,v 1.3.8.3 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_dcb_82599.c,v 1.3.8.3 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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
 @@ -23,26 +24,28 @@
   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/ixgbe_dcb_82599.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_dcb_82599.c,v 1.3.8.3 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_type.h"
 #include "ixgbe_dcb.h"
 #include "ixgbe_dcb_82599.h"
 /**
  * ixgbe_dcb_get_tc_stats_82599 - Returns status for each traffic class
  * @hw: pointer to hardware structure
  * @stats: pointer to statistics structure
  * @tc_count:  Number of elements in bwg_array.
+ *
  * This function returns the status data for each of the Traffic Classes in use.
  */

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_dcb_82599.h,v 1.3.8.3 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_mbx.c,v 1.6.8.3 2019/07/22 17:53:35 martin Exp $ */
+/* $NetBSD: ixgbe_mbx.c,v 1.6.8.4 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -25,26 +25,29 @@
   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/ixgbe_mbx.c 326022 2017-11-20 19:36:21Z pfg $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_mbx.c,v 1.6.8.4 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_type.h"
 #include "ixgbe_mbx.h"
 /**
  *  ixgbe_clear_mbx - Clear Mailbox Memory
  *  @hw: pointer to the HW structure
  *  @vf_number: id of mailbox to write
+ *
  *  Set VFMBMEM of given VF to 0x0.
  **/
 s32 ixgbe_clear_mbx(struct ixgbe_hw *hw, u16 vf_number)
+{
 	struct ixgbe_mbx_info *mbx = &hw->mbx;

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_netbsd.c,v 1.6.2.6 2020/08/05 15:58:02 martin Exp $ */
+/* $NetBSD: ixgbe_netbsd.c,v 1.6.2.7 2021/09/15 16:38:01 martin Exp $ */
 /*
  * 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
 @@ -17,26 +17,30 @@
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_netbsd.c,v 1.6.2.7 2021/09/15 16:38:01 martin Exp $");
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/bus.h>
 #include <sys/condvar.h>
 #include <sys/cpu.h>
 #include <sys/kmem.h>
 #include <sys/mbuf.h>
 #include <sys/mutex.h>
 #include <sys/queue.h>
 #include <sys/workqueue.h>
 #include <dev/pci/pcivar.h>
 @@ -85,212 +89,39 @@ ixgbe_dmamap_sync(ixgbe_dma_tag_t *dt, b
 void
 ixgbe_dmamap_unload(ixgbe_dma_tag_t *dt, bus_dmamap_t dmam)
+{
 	bus_dmamap_unload(dt->dt_dmat, dmam);
+}
 int
 ixgbe_dmamap_create(ixgbe_dma_tag_t *dt, int flags, bus_dmamap_t *dmamp)
+{
 	return bus_dmamap_create(dt->dt_dmat, dt->dt_maxsize, dt->dt_nsegments,
 	    dt->dt_maxsegsize, dt->dt_boundary, flags, dmamp);
+}
 static void
 ixgbe_putext(ixgbe_extmem_t *em)
 	ixgbe_extmem_head_t *eh = em->em_head;
 	mutex_enter(&eh->eh_mtx);
 	TAILQ_INSERT_HEAD(&eh->eh_freelist, em, em_link);
 	mutex_exit(&eh->eh_mtx);
 	return;
 static ixgbe_extmem_t *
 ixgbe_getext(ixgbe_extmem_head_t *eh, size_t size)
 	ixgbe_extmem_t *em;
 	mutex_enter(&eh->eh_mtx);
 	TAILQ_FOREACH(em, &eh->eh_freelist, em_link) {
 		if (em->em_size >= size)
 			break;
 	if (em != NULL)
 		TAILQ_REMOVE(&eh->eh_freelist, em, em_link);
 	mutex_exit(&eh->eh_mtx);
 	return em;
 static ixgbe_extmem_t *
 ixgbe_newext(ixgbe_extmem_head_t *eh, bus_dma_tag_t dmat, size_t size)
 	ixgbe_extmem_t *em;
 	int nseg, rc;
 	em = kmem_zalloc(sizeof(*em), KM_SLEEP);
 	rc = bus_dmamem_alloc(dmat, size, PAGE_SIZE, 0, &em->em_seg, 1, &nseg,
 	    BUS_DMA_WAITOK);
 	if (rc != 0)
 		goto post_zalloc_err;
 	rc = bus_dmamem_map(dmat, &em->em_seg, 1, size, &em->em_vaddr,
 	    BUS_DMA_WAITOK);
 	if (rc != 0)
 		goto post_dmamem_err;
 	em->em_dmat = dmat;
 	em->em_size = size;
 	em->em_head = eh;
 	return em;
 post_dmamem_err:
 	bus_dmamem_free(dmat, &em->em_seg, 1);
 post_zalloc_err:
 	kmem_free(em, sizeof(*em));
 	return NULL;
 static void
 ixgbe_jcl_freeall(struct adapter *adapter, struct rx_ring *rxr)
 	ixgbe_extmem_head_t *eh = &rxr->jcl_head;
 	ixgbe_extmem_t *em;
 	bus_dma_tag_t dmat = rxr->ptag->dt_dmat;
 	while ((em = ixgbe_getext(eh, 0)) != NULL) {
 		KASSERT(em->em_vaddr != NULL);
 		bus_dmamem_unmap(dmat, em->em_vaddr, em->em_size);
 		bus_dmamem_free(dmat, &em->em_seg, 1);
 		memset(em, 0, sizeof(*em));
 		kmem_free(em, sizeof(*em));
 void
 ixgbe_jcl_reinit(struct adapter *adapter, bus_dma_tag_t dmat,
     struct rx_ring *rxr, int nbuf, size_t size)
 	ixgbe_extmem_head_t *eh = &rxr->jcl_head;
 	ixgbe_extmem_t *em;
 	int i;
 	if (!eh->eh_initialized) {
 		TAILQ_INIT(&eh->eh_freelist);
 		mutex_init(&eh->eh_mtx, MUTEX_DEFAULT, IPL_NET);
 		eh->eh_initialized = true;
 	/*
 	 *  Check previous parameters. If it's not required to reinit, just
 	 * return.
 	 *  Note that the num_rx_desc is currently fixed value. It's never
 	 * changed after device is attached.
 	 */
 	if ((rxr->last_rx_mbuf_sz == rxr->mbuf_sz)
 	    && (rxr->last_num_rx_desc == adapter->num_rx_desc))
 		return;
 	/* Free all dmamem */
 	ixgbe_jcl_freeall(adapter, rxr);
 	for (i = 0; i < nbuf; i++) {
 		if ((em = ixgbe_newext(eh, dmat, size)) == NULL) {
 			device_printf(adapter->dev,
 			    "%s: only %d of %d jumbo buffers allocated\n",
 			    __func__, i, nbuf);
 			break;
 		ixgbe_putext(em);
 	/* Keep current parameters */
 	rxr->last_rx_mbuf_sz = adapter->rx_mbuf_sz;
 	rxr->last_num_rx_desc = adapter->num_rx_desc;
 void
 ixgbe_jcl_destroy(struct adapter *adapter, struct rx_ring *rxr)
 	ixgbe_extmem_head_t *eh = &rxr->jcl_head;
 	if (eh->eh_initialized) {
 		/* Free all dmamem */
 		ixgbe_jcl_freeall(adapter, rxr);
 		mutex_destroy(&eh->eh_mtx);
 		eh->eh_initialized = false;
 static void
 ixgbe_jcl_free(struct mbuf *m, void *buf, size_t size, void *arg)
 	ixgbe_extmem_t *em = arg;
 	KASSERT(em->em_size == size);
 	ixgbe_putext(em);
 	/* this is an abstraction violation, but it does not lead to a
 	 * double-free
 	 */
 	if (__predict_true(m != NULL)) {
 		KASSERT(m->m_type != MT_FREE);
 		m->m_type = MT_FREE;
 		pool_cache_put(mb_cache, m);
 /* XXX need to wait for the system to finish with each jumbo mbuf and
  * free it before detaching the driver from the device.
  */
 struct mbuf *
-ixgbe_getjcl(ixgbe_extmem_head_t *eh, int nowait /* M_DONTWAIT */,
+ixgbe_getcl(void)
     int type /* MT_DATA */, int flags /* M_PKTHDR */, size_t size)
+{
 	ixgbe_extmem_t *em;
 	struct mbuf *m;
-	if ((flags & M_PKTHDR) != 0)
+	MGETHDR(m, M_DONTWAIT, MT_DATA);
 		m = m_gethdr(nowait, type);
 	else
 		m = m_get(nowait, type);
 	if (m == NULL)
 		return NULL;
-	em = ixgbe_getext(eh, size);
+	MCLGET(m, M_DONTWAIT);
 	if (em == NULL) {
 		m_freem(m);
 		return NULL;
 	MEXTADD(m, em->em_vaddr, em->em_size, M_DEVBUF, &ixgbe_jcl_free, em);
 	if ((m->m_flags & M_EXT) == 0) {
 		ixgbe_putext(em);
 		m_freem(m);
 		return NULL;
+	}
 	return m;
+}
 void
 ixgbe_pci_enable_busmaster(pci_chipset_tag_t pc, pcitag_t tag)
+{
 	pcireg_t	pci_cmd_word;
 	pci_cmd_word = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);

 @@ -1,14 +1,14 @@
-/*$NetBSD: ixgbe_netbsd.h,v 1.7.6.3 2021/03/11 16:04:25 martin Exp $*/
+/* $NetBSD: ixgbe_netbsd.h,v 1.7.6.4 2021/09/15 16:38:01 martin Exp $ */
 /*
  * 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
 @@ -31,85 +31,51 @@
 #ifndef _IXGBE_NETBSD_H
 #define _IXGBE_NETBSD_H
 #if 0 /* Enable this if you don't want to use TX multiqueue function */
 #define	IXGBE_LEGACY_TX	1
 #endif
 #define	ETHERCAP_VLAN_HWFILTER	0
 #define	ETHERCAP_VLAN_HWCSUM	0
 #define	MJUM9BYTES	(9 * 1024)
 #define	MJUM16BYTES	(16 * 1024)
 #define	MJUMPAGESIZE	PAGE_SIZE
 /*
  * Number of jcl per queue is calculated by
  * adapter->num_rx_desc * IXGBE_JCLNUM_MULTI. The lower limit is 2.
  */
 #define	IXGBE_JCLNUM_MULTI_LOWLIM	2
 #define	IXGBE_JCLNUM_MULTI_DEFAULT	3
 #if !defined(IXGBE_JCLNUM_MULTI)
 # define IXGBE_JCLNUM_MULTI IXGBE_JCLNUM_MULTI_DEFAULT
 #else
 # if (IXGBE_JCLNUM_MULTI < IXGBE_JCLNUM_MULTI_LOWLIM)
 #  error IXGBE_JCLNUM_MULTI is too low.
 # endif
 #endif
 #define IFCAP_RXCSUM	\
 	(IFCAP_CSUM_IPv4_Rx|IFCAP_CSUM_TCPv4_Rx|IFCAP_CSUM_UDPv4_Rx|\
 	IFCAP_CSUM_TCPv6_Rx|IFCAP_CSUM_UDPv6_Rx)
 #define IFCAP_TXCSUM	\
 	(IFCAP_CSUM_IPv4_Tx|IFCAP_CSUM_TCPv4_Tx|IFCAP_CSUM_UDPv4_Tx|\
 	IFCAP_CSUM_TCPv6_Tx|IFCAP_CSUM_UDPv6_Tx)
 #define IFCAP_HWCSUM	(IFCAP_RXCSUM|IFCAP_TXCSUM)
 #define	ETHER_ALIGN		2
 struct ixgbe_dma_tag {
 	bus_dma_tag_t	dt_dmat;
 	bus_size_t	dt_alignment;
 	bus_size_t	dt_boundary;
 	bus_size_t	dt_maxsize;
 	int		dt_nsegments;
 	bus_size_t	dt_maxsegsize;
 	int		dt_flags;
 };
 typedef struct ixgbe_dma_tag ixgbe_dma_tag_t;
-struct ixgbe_extmem_head;
+int ixgbe_dma_tag_create(bus_dma_tag_t, bus_size_t, bus_size_t, bus_size_t,
-typedef struct ixgbe_extmem_head ixgbe_extmem_head_t;
+    int, bus_size_t, int, ixgbe_dma_tag_t **);
 struct ixgbe_extmem {
 	ixgbe_extmem_head_t		*em_head;
 	bus_dma_tag_t			em_dmat;
 	bus_size_t			em_size;
 	bus_dma_segment_t		em_seg;
 	void				*em_vaddr;
 	TAILQ_ENTRY(ixgbe_extmem)	em_link;
 };
 typedef struct ixgbe_extmem ixgbe_extmem_t;
 struct ixgbe_extmem_head {
 	TAILQ_HEAD(, ixgbe_extmem)	eh_freelist;
 	kmutex_t			eh_mtx;
 	bool				eh_initialized;
 };
 int ixgbe_dma_tag_create(bus_dma_tag_t, bus_size_t, bus_size_t, bus_size_t, int,
     bus_size_t, int, ixgbe_dma_tag_t **);
 void ixgbe_dma_tag_destroy(ixgbe_dma_tag_t *);
 int ixgbe_dmamap_create(ixgbe_dma_tag_t *, int, bus_dmamap_t *);
 void ixgbe_dmamap_destroy(ixgbe_dma_tag_t *, bus_dmamap_t);
 void ixgbe_dmamap_sync(ixgbe_dma_tag_t *, bus_dmamap_t, int);
 void ixgbe_dmamap_unload(ixgbe_dma_tag_t *, bus_dmamap_t);
-struct mbuf *ixgbe_getjcl(ixgbe_extmem_head_t *, int, int, int, size_t);
+struct mbuf *ixgbe_getcl(void);
 void ixgbe_pci_enable_busmaster(pci_chipset_tag_t, pcitag_t);
 u_int atomic_load_acq_uint(volatile u_int *);
 #endif /* _IXGBE_NETBSD_H */

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_osdep.c,v 1.1.12.4 2020/01/24 18:37:31 martin Exp $ */
+/* $NetBSD: ixgbe_osdep.c,v 1.1.12.5 2021/09/15 16:38:01 martin 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
 @@ -24,26 +24,29 @@
   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/ixgbe_osdep.c 327031 2017-12-20 18:15:06Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_osdep.c,v 1.1.12.5 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_osdep.h"
 #include "ixgbe.h"
 inline device_t
 ixgbe_dev_from_hw(struct ixgbe_hw *hw)
+{
 	return ((struct adapter *)hw->back)->dev;
+}
 u16
 ixgbe_read_pci_cfg(struct ixgbe_hw *hw, u32 reg)
+{
 	pci_chipset_tag_t  pc = hw->back->osdep.pc;

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_osdep.h,v 1.17.6.7 2020/08/05 15:58:02 martin Exp $ */
+/* $NetBSD: ixgbe_osdep.h,v 1.17.6.8 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -169,55 +169,35 @@ typedef uint64_t	u64;
 #endif
 #endif
 #if defined(__i386__) || defined(__amd64__)
 static __inline
 void prefetch(void *x)
+{
 	__asm volatile("prefetcht0 %0" :: "m" (*(unsigned long *)x));
+}
 #else
 #define prefetch(x)
 #endif
 /*
  * Optimized bcopy thanks to Luigi Rizzo's investigative work.  Assumes
  * non-overlapping regions and 32-byte padding on both src and dst.
  */
 static __inline int
 ixgbe_bcopy(void *restrict _src, void *restrict _dst, int l)
 	uint64_t *src = _src;
 	uint64_t *dst = _dst;
 	for (; l > 0; l -= 32) {
 		*dst++ = *src++;
 		*dst++ = *src++;
 		*dst++ = *src++;
 		*dst++ = *src++;
 	return (0);
 struct ixgbe_osdep
+{
 	struct ethercom    ec;
 	pci_chipset_tag_t  pc;
 	pcitag_t           tag;
 	bus_space_tag_t    mem_bus_space_tag;
 	bus_space_handle_t mem_bus_space_handle;
 	bus_size_t         mem_size;
 	bus_dma_tag_t      dmat;
 	u16                last_rx_mbuf_sz;
 	pci_intr_handle_t  *intrs;
 	int		   nintrs;
 	void               *ihs[IXG_MAX_NINTR];
 	bool		   attached;
 };
 /* These routines need struct ixgbe_hw declared */
 struct ixgbe_hw;
 device_t ixgbe_dev_from_hw(struct ixgbe_hw *hw);
 /* These routines are needed by the shared code */
 extern u16 ixgbe_read_pci_cfg(struct ixgbe_hw *, u32);
 #define IXGBE_READ_PCIE_WORD ixgbe_read_pci_cfg

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_phy.c,v 1.11.6.7 2020/09/02 12:27:54 martin Exp $ */
+/* $NetBSD: ixgbe_phy.c,v 1.11.6.8 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -25,26 +25,29 @@
   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/ixgbe_phy.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_phy.c,v 1.11.6.8 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_api.h"
 #include "ixgbe_common.h"
 #include "ixgbe_phy.h"
 #include <dev/mii/mdio.h>
 static void ixgbe_i2c_start(struct ixgbe_hw *hw);
 static void ixgbe_i2c_stop(struct ixgbe_hw *hw);
 static s32 ixgbe_clock_in_i2c_byte(struct ixgbe_hw *hw, u8 *data);
 static s32 ixgbe_clock_out_i2c_byte(struct ixgbe_hw *hw, u8 data);
 static s32 ixgbe_get_i2c_ack(struct ixgbe_hw *hw);
 static s32 ixgbe_clock_in_i2c_bit(struct ixgbe_hw *hw, bool *data);
 static s32 ixgbe_clock_out_i2c_bit(struct ixgbe_hw *hw, bool data);

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_rss.h,v 1.2.2.5 2021/09/15 16:38:01 martin 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

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_sriov.h,v 1.1.4.5 2021/09/15 16:38:01 martin 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

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_type.h,v 1.22.2.12 2020/09/02 12:27:54 martin Exp $ */
+/* $NetBSD: ixgbe_type.h,v 1.22.2.13 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -2763,27 +2763,27 @@ enum {
 #define IXGBE_RXD_ERR_OSE	0x10 /* Oversize Error */
 #define IXGBE_RXD_ERR_USE	0x20 /* Undersize Error */
 #define IXGBE_RXD_ERR_TCPE	0x40 /* TCP/UDP Checksum Error */
 #define IXGBE_RXD_ERR_IPE	0x80 /* IP Checksum Error */
 #define IXGBE_RXDADV_ERR_MASK		0xfff00000 /* RDESC.ERRORS mask */
 #define IXGBE_RXDADV_ERR_SHIFT		20 /* RDESC.ERRORS shift */
 #define IXGBE_RXDADV_ERR_OUTERIPER	0x04000000 /* CRC IP Header error */
 #define IXGBE_RXDADV_ERR_RXE		0x20000000 /* Any MAC Error */
 #define IXGBE_RXDADV_ERR_FCEOFE		0x80000000 /* FCEOFe/IPE */
 #define IXGBE_RXDADV_ERR_FCERR		0x00700000 /* FCERR/FDIRERR */
 #define IXGBE_RXDADV_ERR_FDIR_LEN	0x00100000 /* FDIR Length error */
 #define IXGBE_RXDADV_ERR_FDIR_DROP	0x00200000 /* FDIR Drop error */
 #define IXGBE_RXDADV_ERR_FDIR_COLL	0x00400000 /* FDIR Collision error */
-#define IXGBE_RXDADV_ERR_HBO	0x00800000 /*Header Buffer Overflow */
+#define IXGBE_RXDADV_ERR_HBO	0x00800000 /* Header Buffer Overflow */
 #define IXGBE_RXDADV_ERR_CE	0x01000000 /* CRC Error */
 #define IXGBE_RXDADV_ERR_LE	0x02000000 /* Length Error */
 #define IXGBE_RXDADV_ERR_PE	0x08000000 /* Packet Error */
 #define IXGBE_RXDADV_ERR_OSE	0x10000000 /* Oversize Error */
 #define IXGBE_RXDADV_ERR_USE	0x20000000 /* Undersize Error */
 #define IXGBE_RXDADV_ERR_TCPE	0x40000000 /* TCP/UDP Checksum Error */
 #define IXGBE_RXDADV_ERR_IPE	0x80000000 /* IP Checksum Error */
 #define IXGBE_RXD_VLAN_ID_MASK	0x0FFF  /* VLAN ID is in lower 12 bits */
 #define IXGBE_RXD_PRI_MASK	0xE000  /* Priority is in upper 3 bits */
 #define IXGBE_RXD_PRI_SHIFT	13
 #define IXGBE_RXD_CFI_MASK	0x1000  /* CFI is bit 12 */
 #define IXGBE_RXD_CFI_SHIFT	12

 @@ -1,14 +1,14 @@
-/* $NetBSD: ixgbe_vf.c,v 1.12.8.6 2021/03/11 16:04:25 martin Exp $ */
+/* $NetBSD: ixgbe_vf.c,v 1.12.8.7 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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.
 @@ -25,26 +25,28 @@
   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/ixgbe_vf.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_vf.c,v 1.12.8.7 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_api.h"
 #include "ixgbe_type.h"
 #include "ixgbe_vf.h"
 #ifndef IXGBE_VFWRITE_REG
 #define IXGBE_VFWRITE_REG IXGBE_WRITE_REG
 #endif
 #ifndef IXGBE_VFREAD_REG
 #define IXGBE_VFREAD_REG IXGBE_READ_REG
 #endif
 /**

 @@ -1,13 +1,15 @@
 /* $NetBSD: ixgbe_x540.c,v 1.9.6.6 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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
 @@ -23,26 +25,29 @@
   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/ixgbe_x540.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_x540.c,v 1.9.6.6 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_x540.h"
 #include "ixgbe_type.h"
 #include "ixgbe_api.h"
 #include "ixgbe_common.h"
 #include "ixgbe_phy.h"
 #define IXGBE_X540_MAX_TX_QUEUES	128
 #define IXGBE_X540_MAX_RX_QUEUES	128
 #define IXGBE_X540_RAR_ENTRIES		128
 #define IXGBE_X540_MC_TBL_SIZE		128
 #define IXGBE_X540_VFT_TBL_SIZE		128
 #define IXGBE_X540_RX_PB_SIZE		384

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_x540.h,v 1.5.8.3 2021/09/15 16:38:01 martin Exp $ */
 /******************************************************************************
   SPDX-License-Identifier: BSD-3-Clause
   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

 @@ -1,13 +1,15 @@
 /* $NetBSD: ixgbe_x550.c,v 1.5.6.10 2021/09/15 16:38:01 martin 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
 @@ -22,26 +24,29 @@
   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/ixgbe_x550.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixgbe_x550.c,v 1.5.6.10 2021/09/15 16:38:01 martin Exp $");
 #include "ixgbe_x550.h"
 #include "ixgbe_x540.h"
 #include "ixgbe_type.h"
 #include "ixgbe_api.h"
 #include "ixgbe_common.h"
 #include "ixgbe_phy.h"
 #include <dev/mii/mii.h>
 static s32 ixgbe_setup_ixfi_x550em(struct ixgbe_hw *hw, ixgbe_link_speed *speed);
 static s32 ixgbe_setup_mac_link_sfp_x550a(struct ixgbe_hw *hw,
 				    ixgbe_link_speed speed,
 				    bool autoneg_wait_to_complete);
 static s32 ixgbe_acquire_swfw_sync_X550a(struct ixgbe_hw *, u32 mask);

 @@ -1,13 +1,14 @@
 /* $NetBSD: ixgbe_x550.h,v 1.2.12.4 2021/09/15 16:38:01 martin 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

 @@ -1,14 +1,14 @@
-/*$NetBSD: ixv.c,v 1.56.2.31 2021/03/11 16:04:25 martin Exp $*/
+/* $NetBSD: ixv.c,v 1.56.2.32 2021/09/15 16:38:01 martin 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
 @@ -24,31 +24,33 @@
   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_ixv.c 331224 2018-03-19 20:55:05Z erj $*/
 #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD: ixv.c,v 1.56.2.32 2021/09/15 16:38:01 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_inet6.h"
 #include "opt_net_mpsafe.h"
 #include "opt_ixgbe.h"
 #endif
 #include "ixgbe.h"
 #include "vlan.h"
 /************************************************************************
  * Driver version
  ************************************************************************/
 static const char ixv_driver_version[] = "2.0.1-k";
 /* XXX NetBSD: + 1.5.17 */
 /************************************************************************
  * PCI Device ID Table
 @@ -81,27 +83,27 @@ static const char *ixv_strings[] = {
  *  Function prototypes
  *********************************************************************/
 static int	ixv_probe(device_t, cfdata_t, void *);
 static void	ixv_attach(device_t, device_t, void *);
 static int	ixv_detach(device_t, int);
 #if 0
 static int	ixv_shutdown(device_t);
 #endif
 static int	ixv_ifflags_cb(struct ethercom *);
 static int	ixv_ioctl(struct ifnet *, u_long, void *);
 static int	ixv_init(struct ifnet *);
 static void	ixv_init_locked(struct adapter *);
 static void	ixv_ifstop(struct ifnet *, int);
-static void	ixv_stop(void *);
+static void	ixv_stop_locked(void *);
 static void	ixv_init_device_features(struct adapter *);
 static void	ixv_media_status(struct ifnet *, struct ifmediareq *);
 static int	ixv_media_change(struct ifnet *);
 static int	ixv_allocate_pci_resources(struct adapter *,
 		    const struct pci_attach_args *);
 static int	ixv_allocate_msix(struct adapter *,
 		    const struct pci_attach_args *);
 static int	ixv_configure_interrupts(struct adapter *);
 static void	ixv_free_pci_resources(struct adapter *);
 static void	ixv_local_timer(void *);
 static void	ixv_local_timer_locked(void *);
 static int	ixv_setup_interface(device_t, struct adapter *);
 static int	ixv_negotiate_api(struct adapter *);
 @@ -129,30 +131,32 @@ static void	ixv_unregister_vlan(void *,
 static void	ixv_add_device_sysctls(struct adapter *);
 static void	ixv_save_stats(struct adapter *);
 static void	ixv_init_stats(struct adapter *);
 static void	ixv_update_stats(struct adapter *);
 static void	ixv_add_stats_sysctls(struct adapter *);
 static void	ixv_clear_evcnt(struct adapter *);
 /* Sysctl handlers */
 static void	ixv_set_sysctl_value(struct adapter *, const char *,
 		    const char *, int *, int);
 static int	ixv_sysctl_interrupt_rate_handler(SYSCTLFN_PROTO);
 static int	ixv_sysctl_next_to_check_handler(SYSCTLFN_PROTO);
 static int	ixv_sysctl_next_to_refresh_handler(SYSCTLFN_PROTO);
 static int	ixv_sysctl_rdh_handler(SYSCTLFN_PROTO);
 static int	ixv_sysctl_rdt_handler(SYSCTLFN_PROTO);
 static int	ixv_sysctl_tdt_handler(SYSCTLFN_PROTO);
 static int	ixv_sysctl_tdh_handler(SYSCTLFN_PROTO);
 static int	ixv_sysctl_rx_copy_len(SYSCTLFN_PROTO);
 /* The MSI-X Interrupt handlers */
 static int	ixv_msix_que(void *);
 static int	ixv_msix_mbx(void *);
 /* Deferred interrupt tasklets */
 static void	ixv_handle_que(void *);
 static void	ixv_handle_link(void *);
 /* Workqueue handler for deferred work */
 static void	ixv_handle_que_work(struct work *, void *);
 const struct sysctlnode *ixv_sysctl_instance(struct adapter *);
 @@ -322,27 +326,27 @@ ixv_attach(device_t parent, device_t dev
 	/*
 	 * Make sure BUSMASTER is set, on a VM under
 	 * KVM it may not be and will break things.
 	 */
 	ixgbe_pci_enable_busmaster(pa->pa_pc, pa->pa_tag);
 	/* Allocate, clear, and link in our adapter structure */
 	adapter = device_private(dev);
 	adapter->hw.back = adapter;
 	adapter->dev = dev;
 	hw = &adapter->hw;
 	adapter->init_locked = ixv_init_locked;
-	adapter->stop_locked = ixv_stop;
+	adapter->stop_locked = ixv_stop_locked;
 	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 = ixv_lookup(pa);
 	KASSERT(ent != NULL);
 @@ -501,27 +505,28 @@ ixv_attach(device_t parent, device_t dev
 	    ixv_txd < MIN_TXD || ixv_txd > MAX_TXD) {
 		aprint_error_dev(dev, "TXD config issue, using default!\n");
 		adapter->num_tx_desc = DEFAULT_TXD;
 	} else
 		adapter->num_tx_desc = ixv_txd;
 	if (((ixv_rxd * sizeof(union ixgbe_adv_rx_desc)) % DBA_ALIGN) != 0 ||
 	    ixv_rxd < MIN_RXD || ixv_rxd > MAX_RXD) {
 		aprint_error_dev(dev, "RXD config issue, using default!\n");
 		adapter->num_rx_desc = DEFAULT_RXD;
 	} else
 		adapter->num_rx_desc = ixv_rxd;
-	adapter->num_jcl = adapter->num_rx_desc * IXGBE_JCLNUM_MULTI;
+	/* Set default high limit of copying mbuf in rxeof */
 	adapter->rx_copy_len = IXGBE_RX_COPY_LEN_MAX;
 	/* Setup MSI-X */
 	error = ixv_configure_interrupts(adapter);
 	if (error)
 		goto err_out;
 	/* Allocate our TX/RX Queues */
 	if (ixgbe_allocate_queues(adapter)) {
 		aprint_error_dev(dev, "ixgbe_allocate_queues() failed!\n");
 		error = ENOMEM;
 		goto err_out;
+	}
 @@ -661,27 +666,27 @@ ixv_detach(device_t dev, int flags)
 		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
 		evcnt_detach(&rxr->rx_packets);
 		evcnt_detach(&rxr->rx_bytes);
 		evcnt_detach(&rxr->rx_copies);
-		evcnt_detach(&rxr->no_jmbuf);
+		evcnt_detach(&rxr->no_mbuf);
 		evcnt_detach(&rxr->rx_discarded);
+	}
 	evcnt_detach(&stats->ipcs);
 	evcnt_detach(&stats->l4cs);
 	evcnt_detach(&stats->ipcs_bad);
 	evcnt_detach(&stats->l4cs_bad);
 	/* Packet Reception Stats */
 	evcnt_detach(&stats->vfgorc);
 	evcnt_detach(&stats->vfgprc);
 	evcnt_detach(&stats->vfmprc);
 	/* Packet Transmission Stats */
 @@ -735,56 +740,52 @@ ixv_init_locked(struct adapter *adapter)
 	    ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
 	/* reprogram the RAR[0] in case user changed it. */
 	hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
 	/* Get the latest mac address, User can use a LAA */
 	memcpy(hw->mac.addr, CLLADDR(ifp->if_sadl),
 	     IXGBE_ETH_LENGTH_OF_ADDRESS);
 	hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1);
 	/* Prepare transmit descriptors and buffers */
 	if (ixgbe_setup_transmit_structures(adapter)) {
 		aprint_error_dev(dev, "Could not setup transmit structures\n");
-		ixv_stop(adapter);
+		ixv_stop_locked(adapter);
 		return;
+	}
 	/* Reset VF and renegotiate mailbox API version */
 	hw->mac.ops.reset_hw(hw);
 	hw->mac.ops.start_hw(hw);
 	error = ixv_negotiate_api(adapter);
 	if (error)
 		device_printf(dev,
 		    "Mailbox API negotiation failed in init_locked!\n");
 	ixv_initialize_transmit_units(adapter);
 	/* Setup Multicast table */
 	ixv_set_rxfilter(adapter);
-	/*
+	/* Use fixed buffer size, even for jumbo frames */
-	 * Determine the correct mbuf pool
+	adapter->rx_mbuf_sz = MCLBYTES;
 	 * for doing jumbo/headersplit
 	 */
 	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)) {
+	error = ixgbe_setup_receive_structures(adapter);
-		device_printf(dev, "Could not setup receive structures\n");
+	if (error) {
-		ixv_stop(adapter);
+		device_printf(dev,
 		    "Could not setup receive structures (err = %d)\n", error);
 		ixv_stop_locked(adapter);
 		return;
+	}
 	/* Configure RX settings */
 	ixv_initialize_receive_units(adapter);
 	/* Set up VLAN offload and filter */
 	ixv_setup_vlan_support(adapter);
 	/* Set up MSI-X routing */
 	ixv_configure_ivars(adapter);
 	/* Set up auto-mask */
 @@ -1423,57 +1424,57 @@ ixv_update_link_status(struct adapter *a
 /************************************************************************
  * ixv_stop - Stop the hardware
+ *
  *   Disables all traffic on the adapter by issuing a
  *   global reset on the MAC and deallocates TX/RX buffers.
  ************************************************************************/
 static void
 ixv_ifstop(struct ifnet *ifp, int disable)
+{
 	struct adapter *adapter = ifp->if_softc;
 	IXGBE_CORE_LOCK(adapter);
-	ixv_stop(adapter);
+	ixv_stop_locked(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
+}
 static void
-ixv_stop(void *arg)
+ixv_stop_locked(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("ixv_stop: begin\n");
+	INIT_DEBUGOUT("ixv_stop_locked: begin\n");
 	ixv_disable_intr(adapter);
 	/* Tell the stack that the interface is no longer active */
 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 	hw->mac.ops.reset_hw(hw);
 	adapter->hw.adapter_stopped = FALSE;
 	hw->mac.ops.stop_adapter(hw);
 	callout_stop(&adapter->timer);
 	/* reprogram the RAR[0] in case user changed it. */
 	hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
 	return;
-} /* ixv_stop */
+} /* ixv_stop_locked */
 /************************************************************************
  * ixv_allocate_pci_resources
  ************************************************************************/
 static int
 ixv_allocate_pci_resources(struct adapter *adapter,
     const struct pci_attach_args *pa)
+{
 	pcireg_t	memtype, csr;
 	device_t	dev = adapter->dev;
 	bus_addr_t addr;
 	int flags;
 @@ -1971,26 +1972,52 @@ ixv_sysctl_next_to_check_handler(SYSCTLF
 	struct sysctlnode node = *rnode;
 	struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data;
 	uint32_t val;
 	if (!rxr)
 		return (0);
 	val = rxr->next_to_check;
 	node.sysctl_data = &val;
 	return sysctl_lookup(SYSCTLFN_CALL(&node));
 } /* ixv_sysctl_next_to_check_handler */
 /************************************************************************
  * ixv_sysctl_next_to_refresh_handler - Receive Descriptor next to refresh
  * handler function
+ *
  *   Retrieves the next_to_refresh value
  ************************************************************************/
 static int
 ixv_sysctl_next_to_refresh_handler(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data;
 	struct adapter *adapter;
 	uint32_t val;
 	if (!rxr)
 		return (0);
 	adapter = rxr->adapter;
 	if (ixgbe_fw_recovery_mode_swflag(adapter))
 		return (EPERM);
 	val = rxr->next_to_refresh;
 	node.sysctl_data = &val;
 	return sysctl_lookup(SYSCTLFN_CALL(&node));
 } /* ixv_sysctl_next_to_refresh_handler */
 /************************************************************************
  * ixv_sysctl_rdh_handler - Receive Descriptor Head handler function
+ *
  *   Retrieves the RDH value from the hardware
  ************************************************************************/
 static int
 ixv_sysctl_rdh_handler(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct rx_ring *rxr = (struct rx_ring *)node.sysctl_data;
 	uint32_t val;
 	if (!rxr)
 		return (0);
 @@ -2417,48 +2444,49 @@ ixv_add_device_sysctls(struct adapter *a
 	struct sysctllog **log;
 	const struct sysctlnode *rnode, *cnode;
 	device_t dev;
 	dev = adapter->dev;
 	log = &adapter->sysctllog;
 	if ((rnode = ixv_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,
+	    CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
-	    "debug", SYSCTL_DESCR("Debug Info"),
+	    SYSCTL_DESCR("Debug Info"),
 	    ixv_sysctl_debug, 0, (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	if (sysctl_createv(log, 0, &rnode, &cnode,
-	    CTLFLAG_READONLY, CTLTYPE_INT, "num_jcl_per_queue",
+	    CTLFLAG_READWRITE, CTLTYPE_INT,
-	    SYSCTL_DESCR("Number of jumbo buffers per queue"),
+	    "rx_copy_len", SYSCTL_DESCR("RX Copy Length"),
-	    NULL, 0, &adapter->num_jcl, 0, CTL_CREATE,
+	    ixv_sysctl_rx_copy_len, 0,
-	    CTL_EOL) != 0)
+	    (void *)adapter, 0, CTL_CREATE, CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	if (sysctl_createv(log, 0, &rnode, &cnode,
-	    CTLFLAG_READWRITE, CTLTYPE_BOOL,
+	    CTLFLAG_READWRITE, CTLTYPE_BOOL, "enable_aim",
-	    "enable_aim", SYSCTL_DESCR("Interrupt Moderation"),
+	    SYSCTL_DESCR("Interrupt Moderation"),
 	    NULL, 0, &adapter->enable_aim, 0, CTL_CREATE, CTL_EOL) != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
 	if (sysctl_createv(log, 0, &rnode, &cnode,
-	    CTLFLAG_READWRITE, CTLTYPE_BOOL,
+	    CTLFLAG_READWRITE, CTLTYPE_BOOL, "txrx_workqueue",
-	    "txrx_workqueue", SYSCTL_DESCR("Use workqueue for packet processing"),
+	    SYSCTL_DESCR("Use workqueue for packet processing"),
-		NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL) != 0)
+	    NULL, 0, &adapter->txrx_use_workqueue, 0, CTL_CREATE, CTL_EOL)
 	    != 0)
 		aprint_error_dev(dev, "could not create sysctl\n");
+}
 /************************************************************************
  * ixv_add_stats_sysctls - Add statistic sysctls for the VF.
  ************************************************************************/
 static void
 ixv_add_stats_sysctls(struct adapter *adapter)
+{
 	device_t		dev = adapter->dev;
 	struct tx_ring		*txr = adapter->tx_rings;
 	struct rx_ring		*rxr = adapter->rx_rings;
 	struct ixgbevf_hw_stats *stats = &adapter->stats.vf;
 @@ -2544,57 +2572,63 @@ ixv_add_stats_sysctls(struct adapter *ad
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Packets Transmitted");
 #ifndef IXGBE_LEGACY_TX
 		evcnt_attach_dynamic(&txr->pcq_drops, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf,
 		    "Packets dropped in pcq");
 #endif
 #ifdef LRO
 		struct lro_ctrl *lro = &rxr->lro;
 #endif /* LRO */
 		if (sysctl_createv(log, 0, &rnode, &cnode,
-		    CTLFLAG_READONLY,
+		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxck",
-		    CTLTYPE_INT,
+		    SYSCTL_DESCR("Receive Descriptor next to check"),
-		    "rxd_nxck", SYSCTL_DESCR("Receive Descriptor next to check"),
+		    ixv_sysctl_next_to_check_handler, 0, (void *)rxr, 0,
 			ixv_sysctl_next_to_check_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
-		    CTLFLAG_READONLY,
+		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_nxrf",
-		    CTLTYPE_INT,
+		    SYSCTL_DESCR("Receive Descriptor next to refresh"),
-		    "rxd_head", SYSCTL_DESCR("Receive Descriptor Head"),
+		    ixv_sysctl_next_to_refresh_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
 		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_head",
 		    SYSCTL_DESCR("Receive Descriptor Head"),
 		    ixv_sysctl_rdh_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		if (sysctl_createv(log, 0, &rnode, &cnode,
-		    CTLFLAG_READONLY,
+		    CTLFLAG_READONLY, CTLTYPE_INT, "rxd_tail",
-		    CTLTYPE_INT,
+		    SYSCTL_DESCR("Receive Descriptor Tail"),
 		    "rxd_tail", SYSCTL_DESCR("Receive Descriptor Tail"),
 		    ixv_sysctl_rdt_handler, 0, (void *)rxr, 0,
 		    CTL_CREATE, CTL_EOL) != 0)
 			break;
 		evcnt_attach_dynamic(&rxr->rx_packets, EVCNT_TYPE_MISC,
-		    NULL, adapter->queues[i].evnamebuf, "Queue Packets Received");
+		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Packets Received");
 		evcnt_attach_dynamic(&rxr->rx_bytes, EVCNT_TYPE_MISC,
-		    NULL, adapter->queues[i].evnamebuf, "Queue Bytes Received");
+		    NULL, adapter->queues[i].evnamebuf,
 		    "Queue Bytes Received");
 		evcnt_attach_dynamic(&rxr->rx_copies, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Copied RX Frames");
-		evcnt_attach_dynamic(&rxr->no_jmbuf, EVCNT_TYPE_MISC,
+		evcnt_attach_dynamic(&rxr->no_mbuf, EVCNT_TYPE_MISC,
-		    NULL, adapter->queues[i].evnamebuf, "Rx no jumbo mbuf");
+		    NULL, adapter->queues[i].evnamebuf, "Rx no mbuf");
 		evcnt_attach_dynamic(&rxr->rx_discarded, EVCNT_TYPE_MISC,
 		    NULL, adapter->queues[i].evnamebuf, "Rx discarded");
 #ifdef LRO
 		SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_queued",
 				CTLFLAG_RD, &lro->lro_queued, 0,
 				"LRO Queued");
 		SYSCTL_ADD_INT(ctx, queue_list, OID_AUTO, "lro_flushed",
 				CTLFLAG_RD, &lro->lro_flushed, 0,
 				"LRO Flushed");
 #endif /* LRO */
+	}
 	/* MAC stats get their own sub node */
 @@ -2670,27 +2704,27 @@ ixv_clear_evcnt(struct adapter *adapter)
 #endif
 		txr->q_efbig_tx_dma_setup = 0;
 		txr->q_mbuf_defrag_failed = 0;
 		txr->q_efbig2_tx_dma_setup = 0;
 		txr->q_einval_tx_dma_setup = 0;
 		txr->q_other_tx_dma_setup = 0;
 		txr->q_eagain_tx_dma_setup = 0;
 		txr->q_enomem_tx_dma_setup = 0;
 		txr->q_tso_err = 0;
 		rxr->rx_packets.ev_count = 0;
 		rxr->rx_bytes.ev_count = 0;
 		rxr->rx_copies.ev_count = 0;
-		rxr->no_jmbuf.ev_count = 0;
+		rxr->no_mbuf.ev_count = 0;
 		rxr->rx_discarded.ev_count = 0;
+	}
 	/* MAC stats get their own sub node */
 	stats->ipcs.ev_count = 0;
 	stats->l4cs.ev_count = 0;
 	stats->ipcs_bad.ev_count = 0;
 	stats->l4cs_bad.ev_count = 0;
 	/* Packet Reception Stats */
 	stats->vfgprc.ev_count = 0;
 	stats->vfgorc.ev_count = 0;
 @@ -2790,26 +2824,51 @@ ixv_sysctl_debug(SYSCTLFN_ARGS)
 	node.sysctl_data = &result;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return error;
 	if (result == 1)
 		ixv_print_debug_info(adapter);
 	return 0;
 } /* ixv_sysctl_debug */
 /************************************************************************
  * ixv_sysctl_rx_copy_len
  ************************************************************************/
 static int
 ixv_sysctl_rx_copy_len(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node = *rnode;
 	struct adapter *adapter = (struct adapter *)node.sysctl_data;
 	int error;
 	int result = adapter->rx_copy_len;
 	node.sysctl_data = &result;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return error;
 	if ((result < 0) || (result > IXGBE_RX_COPY_LEN_MAX))
 		return EINVAL;
 	adapter->rx_copy_len = result;
 	return 0;
 } /* ixgbe_sysctl_rx_copy_len */
 /************************************************************************
  * ixv_init_device_features
  ************************************************************************/
 static void
 ixv_init_device_features(struct adapter *adapter)
+{
 	adapter->feat_cap = IXGBE_FEATURE_NETMAP
 			  | IXGBE_FEATURE_VF
 			  | IXGBE_FEATURE_RSS
 			  | IXGBE_FEATURE_LEGACY_TX;
 	/* A tad short on feature flags for VFs, atm. */
 	switch (adapter->hw.mac.type) {
 	case ixgbe_mac_82599_vf:
 @@ -2845,27 +2904,27 @@ ixv_init_device_features(struct adapter
 	    ixv_enable_legacy_tx)
 		adapter->feat_en |= IXGBE_FEATURE_LEGACY_TX;
 } /* ixv_init_device_features */
 /************************************************************************
  * ixv_shutdown - Shutdown entry point
  ************************************************************************/
 #if 0 /* XXX NetBSD ought to register something like this through pmf(9) */
 static int
 ixv_shutdown(device_t dev)
+{
 	struct adapter *adapter = device_private(dev);
 	IXGBE_CORE_LOCK(adapter);
-	ixv_stop(adapter);
+	ixv_stop_locked(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	return (0);
 } /* ixv_shutdown */
 #endif
 static int
 ixv_ifflags_cb(struct ethercom *ec)
+{
 	struct ifnet *ifp = &ec->ec_if;
 	struct adapter *adapter = ifp->if_softc;
 	u_short saved_flags;
 	u_short change;
 @@ -3188,37 +3247,37 @@ ixv_allocate_msix(struct adapter *adapte
 		que->que_si
 		    = softint_establish(SOFTINT_NET | IXGBE_SOFTINT_FLAGS,
 			ixv_handle_que, que);
 		if (que->que_si == NULL) {
 			aprint_error_dev(dev,
 			    "could not establish software interrupt\n");
+		}
+	}
 	snprintf(wqname, sizeof(wqname), "%sdeferTx", device_xname(dev));
 	error = workqueue_create(&adapter->txr_wq, wqname,
 	    ixgbe_deferred_mq_start_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET,
 	    IXGBE_WORKQUEUE_FLAGS);
 	if (error) {
-		aprint_error_dev(dev, "couldn't create workqueue for deferred Tx\n");
+		aprint_error_dev(dev,
 		    "couldn't create workqueue for deferred Tx\n");
+	}
 	adapter->txr_wq_enqueued = percpu_alloc(sizeof(u_int));
 	snprintf(wqname, sizeof(wqname), "%sTxRx", device_xname(dev));
 	error = workqueue_create(&adapter->que_wq, wqname,
 	    ixv_handle_que_work, adapter, IXGBE_WORKQUEUE_PRI, IPL_NET,
 	    IXGBE_WORKQUEUE_FLAGS);
 	if (error) {
-		aprint_error_dev(dev,
+		aprint_error_dev(dev, "couldn't create workqueue for Tx/Rx\n");
 		    "couldn't create workqueue\n");
+	}
 	/* and Mailbox */
 	cpu_id++;
 	snprintf(intr_xname, sizeof(intr_xname), "%s link", device_xname(dev));
 	adapter->vector = vector;
 	intrstr = pci_intr_string(pc, adapter->osdep.intrs[vector], intrbuf,
 	    sizeof(intrbuf));
 #ifdef IXGBE_MPSAFE
 	pci_intr_setattr(pc, &adapter->osdep.intrs[vector], PCI_INTR_MPSAFE,
 	    true);
 #endif
 	/* Set the mbx handler function */

 @@ -1,14 +1,14 @@
-.\" $NetBSD: ixg.4,v 1.10.4.2 2021/03/11 16:04:25 martin Exp $
+.\" $NetBSD: ixg.4,v 1.10.4.3 2021/09/15 16:38:01 martin Exp $
 .\"
 .\" Copyright (c) 2001-2008, Intel Corporation
 .\" All rights reserved.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions are met:
 .\"
 .\" 1. Redistributions of source code must retain the above copyright notice,
 .\"    this list of conditions and the following disclaimer.
 .\"
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 @@ -23,27 +23,27 @@
 .\" 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.
 .\"
 .\" * Other names and brands may be claimed as the property of others.
 .\"
 .\" $FreeBSD: src/share/man/man4/ixgbe.4,v 1.3 2010/12/19 23:54:31 yongari Exp $
 .\"
-.Dd March 9, 2021
+.Dd August 25, 2021
 .Dt IXG 4
 .Os
 .Sh NAME
 .Nm ixg
 .Nd Intel(R) 10Gb Ethernet driver
 .Sh SYNOPSIS
 .Cd "ixg* at pci? dev ? function ?"
 .Sh DESCRIPTION
 The
 .Nm
 driver provides support for PCI 10Gb Ethernet adapters based on
 the Intel(R) 82598EB, 82599, X540 and X550 Ethernet Controllers.
 The driver supports Jumbo Frames, TCP Segmentation Offload (TSO).
 @@ -73,46 +73,26 @@ A fatal initialization error has occurre
 .It "ixg%d: watchdog timeout -- resetting"
 The device has stopped responding to the network, or there is a problem with
 the network connection (cable).
 .El
 .Sh SUPPORT
 For general information and support,
 go to the Intel support website at:
 .Lk http://www.intel.com/support/ .
 .\" .Pp
 .\" If an issue is identified with the released source code on the supported kernel
 .\" with a supported adapter, email the specific information related to the
 .\" issue to
 .\" .Aq freebsdnic@mailbox.intel.com .
 .Sh OPTIONS
 The
 .Nm
 driver doesn't use the common
 .Xr MCLGET 9
 interface and use the driver specific cluster allocation mechanism.
 If it's exhausted, the
 .Xr evcnt 9
 counter "ixgX qY Rx no jumbo mbuf" is incremented.
 If this is observed,
 the number can be changed by the following config parameter:
 .Bl -tag -width IXGBE_JCLNUM_MULTI -offset 3n
 .It Dv IXGBE_JCLNUM_MULTI
 The number of RX jumbo buffers (clusters) per queue is calculated by
 .Dv IXGBE_JCLNUM_MULTI
 * (number of rx descriptors).
 The total number of clusters per queue is available via the
 .Li hw.ixgN.num_jcl_per_queue
 .Xr sysctl 7 .
 .El
 .Sh SEE ALSO
 .Xr arp 4 ,
 .Xr ixv 4 ,
 .Xr netintro 4 ,
 .Xr vlan 4 ,
 .Xr ifconfig 8
 .Sh HISTORY
 The
 .Nm
 device driver comes from
 .Fx ,
 where it is called
 .Nm ixgbe .

 @@ -1,14 +1,14 @@
-.\"	$NetBSD: ixv.4,v 1.3.2.4 2021/03/11 16:04:25 martin Exp $
+.\"	$NetBSD: ixv.4,v 1.3.2.5 2021/09/15 16:38:01 martin Exp $
 .\"
 .\" Copyright (c) 2018 The NetBSD Foundation, Inc.
 .\" All rights reserved.
 .\"
 .\" This code is derived from software contributed to The NetBSD Foundation
 .\" by Masanobu SAITOH.
 .\"
 .\" 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
 @@ -17,62 +17,42 @@
 .\"
 .\" 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.
 .\"
-.Dd March 9, 2021
+.Dd August 25, 2021
 .Dt IXV 4
 .Os
 .Sh NAME
 .Nm ixv
 .Nd Intel 10 Gigabit Ethernet virtual function
 .Sh SYNOPSIS
 .Cd "ixv* at pci? dev ? function ?"
 .Sh DESCRIPTION
 The
 .Nm
 driver supports Intel 10 Gigabit Ethernet virtual function that 82599 and
 newer chips support.
 It can be used on a
 .Nx
 guest that the host supports SR-IOV.
 .Sh OPTIONS
 The
 .Nm
 driver doesn't use the common
 .Xr MCLGET 9
 interface and use the driver specific cluster allocation mechanism.
 If it's exhausted, the
 .Xr evcnt 9
 counter "ixgX qY Rx no jumbo mbuf" is incremented.
 If this is observed,
 the number can be changed by the following config parameter:
 .Bl -tag -width IXGBE_JCLNUM_MULTI -offset 3n
 .It Dv IXGBE_JCLNUM_MULTI
 The number of RX jumbo buffers (clusters) per queue is calculated by
 .Dv IXGBE_JCLNUM_MULTI
 * (number of rx descriptors).
 The total number of clusters per queue is available with the
 .Li hw.ixgN.num_jcl_per_queue
 .Xr sysctl 7 .
 .El
 .Sh SEE ALSO
 .Xr arp 4 ,
 .Xr ixg 4 ,
 .Xr netintro 4 ,
 .Xr vlan 4 ,
 .Xr ifconfig 8
 .Sh HISTORY
 The
 .Nm
 device driver comes from
 .Fx .
 It first appeared in
 .Nx 8.0 .