Skip site navigation (1)Skip section navigation (2)
Date:      Tue, 28 Sep 2021 16:57:35 GMT
From:      Kevin Bowling <kbowling@FreeBSD.org>
To:        src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-branches@FreeBSD.org
Subject:   git: 717bed4f6f18 - stable/13 - e1000: Rename 'struct adapter' to 'struct e1000_sc'
Message-ID:  <202109281657.18SGvZta035422@gitrepo.freebsd.org>

next in thread | raw e-mail | index | archive | help
The branch stable/13 has been updated by kbowling (ports committer):

URL: https://cgit.FreeBSD.org/src/commit/?id=717bed4f6f1808d91f8ec7a1f5952052035b8dc7

commit 717bed4f6f1808d91f8ec7a1f5952052035b8dc7
Author:     Kevin Bowling <kbowling@FreeBSD.org>
AuthorDate: 2021-09-25 00:09:43 +0000
Commit:     Kevin Bowling <kbowling@FreeBSD.org>
CommitDate: 2021-09-28 16:55:59 +0000

    e1000: Rename 'struct adapter' to 'struct e1000_sc'
    
    Rename the 'struct adapter' to 'struct e1000_sc' to avoid type ambiguity
    in things like kgdb.
    
    Reviewed by:    jhb, markj
    MFC after:      3 days
    Differential Revision:  https://reviews.freebsd.org/D32129
    
    (cherry picked from commit dc9260515449cde9a4b26b5448f7386388c55bbd)
---
 sys/dev/e1000/em_txrx.c  |   80 +--
 sys/dev/e1000/if_em.c    | 1556 +++++++++++++++++++++++-----------------------
 sys/dev/e1000/if_em.h    |  308 +++++----
 sys/dev/e1000/igb_txrx.c |   40 +-
 4 files changed, 987 insertions(+), 997 deletions(-)

diff --git a/sys/dev/e1000/em_txrx.c b/sys/dev/e1000/em_txrx.c
index cc5313a749bd..6ac66a9011f4 100644
--- a/sys/dev/e1000/em_txrx.c
+++ b/sys/dev/e1000/em_txrx.c
@@ -42,9 +42,9 @@
 /*********************************************************************
  *  Local Function prototypes
  *********************************************************************/
-static int em_tso_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_upper,
+static int em_tso_setup(struct e1000_softc *sc, if_pkt_info_t pi, u32 *txd_upper,
     u32 *txd_lower);
-static int em_transmit_checksum_setup(struct adapter *adapter, if_pkt_info_t pi,
+static int em_transmit_checksum_setup(struct e1000_softc *sc, if_pkt_info_t pi,
     u32 *txd_upper, u32 *txd_lower);
 static int em_isc_txd_encap(void *arg, if_pkt_info_t pi);
 static void em_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx);
@@ -91,9 +91,9 @@ struct if_txrx lem_txrx = {
 extern if_shared_ctx_t em_sctx;
 
 void
-em_dump_rs(struct adapter *adapter)
+em_dump_rs(struct e1000_softc *sc)
 {
-	if_softc_ctx_t scctx = adapter->shared;
+	if_softc_ctx_t scctx = sc->shared;
 	struct em_tx_queue *que;
 	struct tx_ring *txr;
 	qidx_t i, ntxd, qid, cur;
@@ -102,8 +102,8 @@ em_dump_rs(struct adapter *adapter)
 
 	printf("\n");
 	ntxd = scctx->isc_ntxd[0];
-	for (qid = 0; qid < adapter->tx_num_queues; qid++) {
-		que = &adapter->tx_queues[qid];
+	for (qid = 0; qid < sc->tx_num_queues; qid++) {
+		que = &sc->tx_queues[qid];
 		txr =  &que->txr;
 		rs_cidx = txr->tx_rs_cidx;
 		if (rs_cidx != txr->tx_rs_pidx) {
@@ -132,10 +132,10 @@ em_dump_rs(struct adapter *adapter)
  *
  **********************************************************************/
 static int
-em_tso_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_upper, u32 *txd_lower)
+em_tso_setup(struct e1000_softc *sc, if_pkt_info_t pi, u32 *txd_upper, u32 *txd_lower)
 {
-	if_softc_ctx_t scctx = adapter->shared;
-	struct em_tx_queue *que = &adapter->tx_queues[pi->ipi_qsidx];
+	if_softc_ctx_t scctx = sc->shared;
+	struct em_tx_queue *que = &sc->tx_queues[pi->ipi_qsidx];
 	struct tx_ring *txr = &que->txr;
 	struct e1000_context_desc *TXD;
 	int cur, hdr_len;
@@ -178,7 +178,7 @@ em_tso_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_upper, u32 *txd
 	TXD->tcp_seg_setup.fields.mss = htole16(pi->ipi_tso_segsz);
 	TXD->tcp_seg_setup.fields.hdr_len = hdr_len;
 
-	TXD->cmd_and_length = htole32(adapter->txd_cmd |
+	TXD->cmd_and_length = htole32(sc->txd_cmd |
 				E1000_TXD_CMD_DEXT |	/* Extended descr */
 				E1000_TXD_CMD_TSE |	/* TSE context */
 				E1000_TXD_CMD_IP |	/* Do IP csum */
@@ -189,7 +189,7 @@ em_tso_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_upper, u32 *txd
 	if (++cur == scctx->isc_ntxd[0]) {
 		cur = 0;
 	}
-	DPRINTF(iflib_get_dev(adapter->ctx), "%s: pidx: %d cur: %d\n", __FUNCTION__, pi->ipi_pidx, cur);
+	DPRINTF(iflib_get_dev(sc->ctx), "%s: pidx: %d cur: %d\n", __FUNCTION__, pi->ipi_pidx, cur);
 	return (cur);
 }
 
@@ -215,11 +215,11 @@ em_tso_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_upper, u32 *txd
  **********************************************************************/
 
 static int
-em_transmit_checksum_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_upper, u32 *txd_lower)
+em_transmit_checksum_setup(struct e1000_softc *sc, if_pkt_info_t pi, u32 *txd_upper, u32 *txd_lower)
 {
 	 struct e1000_context_desc *TXD = NULL;
-	if_softc_ctx_t scctx = adapter->shared;
-	struct em_tx_queue *que = &adapter->tx_queues[pi->ipi_qsidx];
+	if_softc_ctx_t scctx = sc->shared;
+	struct em_tx_queue *que = &sc->tx_queues[pi->ipi_qsidx];
 	struct tx_ring *txr = &que->txr;
 	int csum_flags = pi->ipi_csum_flags;
 	int cur, hdr_len;
@@ -227,7 +227,7 @@ em_transmit_checksum_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_u
 
 	cur = pi->ipi_pidx;
 	hdr_len = pi->ipi_ehdrlen + pi->ipi_ip_hlen;
-	cmd = adapter->txd_cmd;
+	cmd = sc->txd_cmd;
 
 	/*
 	 * The 82574L can only remember the *last* context used
@@ -237,7 +237,7 @@ em_transmit_checksum_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_u
 	 * second note.
 	 */
 	if (DONT_FORCE_CTX &&
-	    adapter->tx_num_queues == 1 &&
+	    sc->tx_num_queues == 1 &&
 	    txr->csum_lhlen == pi->ipi_ehdrlen &&
 	    txr->csum_iphlen == pi->ipi_ip_hlen &&
 	    txr->csum_flags == csum_flags) {
@@ -293,7 +293,7 @@ em_transmit_checksum_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_u
 	if (++cur == scctx->isc_ntxd[0]) {
 		cur = 0;
 	}
-	DPRINTF(iflib_get_dev(adapter->ctx), "checksum_setup csum_flags=%x txd_upper=%x txd_lower=%x hdr_len=%d cmd=%x\n",
+	DPRINTF(iflib_get_dev(sc->ctx), "checksum_setup csum_flags=%x txd_upper=%x txd_lower=%x hdr_len=%d cmd=%x\n",
 		      csum_flags, *txd_upper, *txd_lower, hdr_len, cmd);
 	return (cur);
 }
@@ -301,7 +301,7 @@ em_transmit_checksum_setup(struct adapter *adapter, if_pkt_info_t pi, u32 *txd_u
 static int
 em_isc_txd_encap(void *arg, if_pkt_info_t pi)
 {
-	struct adapter *sc = arg;
+	struct e1000_softc *sc = arg;
 	if_softc_ctx_t scctx = sc->shared;
 	struct em_tx_queue *que = &sc->tx_queues[pi->ipi_qsidx];
 	struct tx_ring *txr = &que->txr;
@@ -348,7 +348,7 @@ em_isc_txd_encap(void *arg, if_pkt_info_t pi)
 	}
 
 	DPRINTF(iflib_get_dev(sc->ctx), "encap: set up tx: nsegs=%d first=%d i=%d\n", nsegs, first, i);
-	/* XXX adapter->pcix_82544 -- lem_fill_descriptors */
+	/* XXX sc->pcix_82544 -- lem_fill_descriptors */
 
 	/* Set up our transmit descriptors */
 	for (j = 0; j < nsegs; j++) {
@@ -416,19 +416,19 @@ em_isc_txd_encap(void *arg, if_pkt_info_t pi)
 static void
 em_isc_txd_flush(void *arg, uint16_t txqid, qidx_t pidx)
 {
-	struct adapter *adapter = arg;
-	struct em_tx_queue *que = &adapter->tx_queues[txqid];
+	struct e1000_softc *sc = arg;
+	struct em_tx_queue *que = &sc->tx_queues[txqid];
 	struct tx_ring *txr = &que->txr;
 
-	E1000_WRITE_REG(&adapter->hw, E1000_TDT(txr->me), pidx);
+	E1000_WRITE_REG(&sc->hw, E1000_TDT(txr->me), pidx);
 }
 
 static int
 em_isc_txd_credits_update(void *arg, uint16_t txqid, bool clear)
 {
-	struct adapter *adapter = arg;
-	if_softc_ctx_t scctx = adapter->shared;
-	struct em_tx_queue *que = &adapter->tx_queues[txqid];
+	struct e1000_softc *sc = arg;
+	if_softc_ctx_t scctx = sc->shared;
+	struct em_tx_queue *que = &sc->tx_queues[txqid];
 	struct tx_ring *txr = &que->txr;
 
 	qidx_t processed = 0;
@@ -461,7 +461,7 @@ em_isc_txd_credits_update(void *arg, uint16_t txqid, bool clear)
 		if (delta < 0)
 			delta += ntxd;
 		MPASS(delta > 0);
-		DPRINTF(iflib_get_dev(adapter->ctx),
+		DPRINTF(iflib_get_dev(sc->ctx),
 			      "%s: cidx_processed=%u cur=%u clear=%d delta=%d\n",
 			      __FUNCTION__, prev, cur, clear, delta);
 
@@ -483,7 +483,7 @@ em_isc_txd_credits_update(void *arg, uint16_t txqid, bool clear)
 static void
 lem_isc_rxd_refill(void *arg, if_rxd_update_t iru)
 {
-	struct adapter *sc = arg;
+	struct e1000_softc *sc = arg;
 	if_softc_ctx_t scctx = sc->shared;
 	struct em_rx_queue *que = &sc->rx_queues[iru->iru_qsidx];
 	struct rx_ring *rxr = &que->rxr;
@@ -511,7 +511,7 @@ lem_isc_rxd_refill(void *arg, if_rxd_update_t iru)
 static void
 em_isc_rxd_refill(void *arg, if_rxd_update_t iru)
 {
-	struct adapter *sc = arg;
+	struct e1000_softc *sc = arg;
 	if_softc_ctx_t scctx = sc->shared;
 	uint16_t rxqid = iru->iru_qsidx;
 	struct em_rx_queue *que = &sc->rx_queues[rxqid];
@@ -540,7 +540,7 @@ em_isc_rxd_refill(void *arg, if_rxd_update_t iru)
 static void
 em_isc_rxd_flush(void *arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx)
 {
-	struct adapter *sc = arg;
+	struct e1000_softc *sc = arg;
 	struct em_rx_queue *que = &sc->rx_queues[rxqid];
 	struct rx_ring *rxr = &que->rxr;
 
@@ -550,7 +550,7 @@ em_isc_rxd_flush(void *arg, uint16_t rxqid, uint8_t flid __unused, qidx_t pidx)
 static int
 lem_isc_rxd_available(void *arg, uint16_t rxqid, qidx_t idx, qidx_t budget)
 {
-	struct adapter *sc = arg;
+	struct e1000_softc *sc = arg;
 	if_softc_ctx_t scctx = sc->shared;
 	struct em_rx_queue *que = &sc->rx_queues[rxqid];
 	struct rx_ring *rxr = &que->rxr;
@@ -575,7 +575,7 @@ lem_isc_rxd_available(void *arg, uint16_t rxqid, qidx_t idx, qidx_t budget)
 static int
 em_isc_rxd_available(void *arg, uint16_t rxqid, qidx_t idx, qidx_t budget)
 {
-	struct adapter *sc = arg;
+	struct e1000_softc *sc = arg;
 	if_softc_ctx_t scctx = sc->shared;
 	struct em_rx_queue *que = &sc->rx_queues[rxqid];
 	struct rx_ring *rxr = &que->rxr;
@@ -600,9 +600,9 @@ em_isc_rxd_available(void *arg, uint16_t rxqid, qidx_t idx, qidx_t budget)
 static int
 lem_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
 {
-	struct adapter *adapter = arg;
-	if_softc_ctx_t scctx = adapter->shared;
-	struct em_rx_queue *que = &adapter->rx_queues[ri->iri_qsidx];
+	struct e1000_softc *sc = arg;
+	if_softc_ctx_t scctx = sc->shared;
+	struct em_rx_queue *que = &sc->rx_queues[ri->iri_qsidx];
 	struct rx_ring *rxr = &que->rxr;
 	struct e1000_rx_desc *rxd;
 	u16 len;
@@ -628,7 +628,7 @@ lem_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
 
 		/* Make sure bad packets are discarded */
 		if (errors & E1000_RXD_ERR_FRAME_ERR_MASK) {
-			adapter->dropped_pkts++;
+			sc->dropped_pkts++;
 			/* XXX fixup if common */
 			return (EBADMSG);
 		}
@@ -645,7 +645,7 @@ lem_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
 	} while (!eop);
 
 	/* XXX add a faster way to look this up */
-	if (adapter->hw.mac.type >= e1000_82543)
+	if (sc->hw.mac.type >= e1000_82543)
 		em_receive_checksum(status, errors, ri);
 
 	if (status & E1000_RXD_STAT_VP) {
@@ -661,9 +661,9 @@ lem_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
 static int
 em_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
 {
-	struct adapter *adapter = arg;
-	if_softc_ctx_t scctx = adapter->shared;
-	struct em_rx_queue *que = &adapter->rx_queues[ri->iri_qsidx];
+	struct e1000_softc *sc = arg;
+	if_softc_ctx_t scctx = sc->shared;
+	struct em_rx_queue *que = &sc->rx_queues[ri->iri_qsidx];
 	struct rx_ring *rxr = &que->rxr;
 	union e1000_rx_desc_extended *rxd;
 
@@ -691,7 +691,7 @@ em_isc_rxd_pkt_get(void *arg, if_rxd_info_t ri)
 
 		/* Make sure bad packets are discarded */
 		if (staterr & E1000_RXDEXT_ERR_FRAME_ERR_MASK) {
-			adapter->dropped_pkts++;
+			sc->dropped_pkts++;
 			return EBADMSG;
 		}
 
diff --git a/sys/dev/e1000/if_em.c b/sys/dev/e1000/if_em.c
index 89ccb30ce922..47513c5d9e1e 100644
--- a/sys/dev/e1000/if_em.c
+++ b/sys/dev/e1000/if_em.c
@@ -294,33 +294,33 @@ static int	igb_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid);
 static void	em_if_multi_set(if_ctx_t ctx);
 static void	em_if_update_admin_status(if_ctx_t ctx);
 static void	em_if_debug(if_ctx_t ctx);
-static void	em_update_stats_counters(struct adapter *);
-static void	em_add_hw_stats(struct adapter *adapter);
+static void	em_update_stats_counters(struct e1000_softc *);
+static void	em_add_hw_stats(struct e1000_softc *);
 static int	em_if_set_promisc(if_ctx_t ctx, int flags);
-static bool	em_if_vlan_filter_capable(struct adapter *);
-static bool	em_if_vlan_filter_used(struct adapter *);
-static void	em_if_vlan_filter_enable(struct adapter *);
-static void	em_if_vlan_filter_disable(struct adapter *);
-static void	em_if_vlan_filter_write(struct adapter *);
-static void	em_setup_vlan_hw_support(struct adapter *);
+static bool	em_if_vlan_filter_capable(struct e1000_softc *);
+static bool	em_if_vlan_filter_used(struct e1000_softc *);
+static void	em_if_vlan_filter_enable(struct e1000_softc *);
+static void	em_if_vlan_filter_disable(struct e1000_softc *);
+static void	em_if_vlan_filter_write(struct e1000_softc *);
+static void	em_setup_vlan_hw_support(struct e1000_softc *);
 static int	em_sysctl_nvm_info(SYSCTL_HANDLER_ARGS);
-static void	em_print_nvm_info(struct adapter *);
+static void	em_print_nvm_info(struct e1000_softc *);
 static int	em_sysctl_debug_info(SYSCTL_HANDLER_ARGS);
 static int	em_get_rs(SYSCTL_HANDLER_ARGS);
-static void	em_print_debug_info(struct adapter *);
+static void	em_print_debug_info(struct e1000_softc *);
 static int 	em_is_valid_ether_addr(u8 *);
 static int	em_sysctl_int_delay(SYSCTL_HANDLER_ARGS);
-static void	em_add_int_delay_sysctl(struct adapter *, const char *,
+static void	em_add_int_delay_sysctl(struct e1000_softc *, const char *,
 		    const char *, struct em_int_delay_info *, int, int);
 /* Management and WOL Support */
-static void	em_init_manageability(struct adapter *);
-static void	em_release_manageability(struct adapter *);
-static void	em_get_hw_control(struct adapter *);
-static void	em_release_hw_control(struct adapter *);
+static void	em_init_manageability(struct e1000_softc *);
+static void	em_release_manageability(struct e1000_softc *);
+static void	em_get_hw_control(struct e1000_softc *);
+static void	em_release_hw_control(struct e1000_softc *);
 static void	em_get_wakeup(if_ctx_t ctx);
 static void	em_enable_wakeup(if_ctx_t ctx);
-static int	em_enable_phy_wakeup(struct adapter *);
-static void	em_disable_aspm(struct adapter *);
+static int	em_enable_phy_wakeup(struct e1000_softc *);
+static void	em_disable_aspm(struct e1000_softc *);
 
 int		em_intr(void *arg);
 
@@ -337,8 +337,8 @@ static void	em_if_led_func(if_ctx_t ctx, int onoff);
 
 static int	em_get_regs(SYSCTL_HANDLER_ARGS);
 
-static void	lem_smartspeed(struct adapter *adapter);
-static void	igb_configure_queues(struct adapter *adapter);
+static void	lem_smartspeed(struct e1000_softc *);
+static void	igb_configure_queues(struct e1000_softc *);
 
 
 /*********************************************************************
@@ -370,7 +370,7 @@ static device_method_t igb_methods[] = {
 
 
 static driver_t em_driver = {
-	"em", em_methods, sizeof(struct adapter),
+	"em", em_methods, sizeof(struct e1000_softc),
 };
 
 static devclass_t em_devclass;
@@ -383,7 +383,7 @@ MODULE_DEPEND(em, iflib, 1, 1, 1);
 IFLIB_PNP_INFO(pci, em, em_vendor_info_array);
 
 static driver_t igb_driver = {
-	"igb", igb_methods, sizeof(struct adapter),
+	"igb", igb_methods, sizeof(struct e1000_softc),
 };
 
 static devclass_t igb_devclass;
@@ -430,7 +430,7 @@ static device_method_t em_if_methods[] = {
 };
 
 static driver_t em_if_driver = {
-	"em_if", em_if_methods, sizeof(struct adapter)
+	"em_if", em_if_methods, sizeof(struct e1000_softc)
 };
 
 static device_method_t igb_if_methods[] = {
@@ -468,7 +468,7 @@ static device_method_t igb_if_methods[] = {
 };
 
 static driver_t igb_if_driver = {
-	"igb_if", igb_if_methods, sizeof(struct adapter)
+	"igb_if", igb_if_methods, sizeof(struct e1000_softc)
 };
 
 /*********************************************************************
@@ -609,8 +609,8 @@ static struct if_shared_ctx igb_sctx_init = {
 
 static int em_get_regs(SYSCTL_HANDLER_ARGS)
 {
-	struct adapter *adapter = (struct adapter *)arg1;
-	struct e1000_hw *hw = &adapter->hw;
+	struct e1000_softc *sc = (struct e1000_softc *)arg1;
+	struct e1000_hw *hw = &sc->hw;
 	struct sbuf *sb;
 	u32 *regs_buff;
 	int rc;
@@ -690,7 +690,7 @@ static int em_get_regs(SYSCTL_HANDLER_ARGS)
 
 #ifdef DUMP_DESCS
 	{
-		if_softc_ctx_t scctx = adapter->shared;
+		if_softc_ctx_t scctx = sc->shared;
 		struct rx_ring *rxr = &rx_que->rxr;
 		struct tx_ring *txr = &tx_que->txr;
 		int ntxd = scctx->isc_ntxd[0];
@@ -734,11 +734,11 @@ igb_register(device_t dev)
 static int
 em_set_num_queues(if_ctx_t ctx)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
+	struct e1000_softc *sc = iflib_get_softc(ctx);
 	int maxqueues;
 
 	/* Sanity check based on HW */
-	switch (adapter->hw.mac.type) {
+	switch (sc->hw.mac.type) {
 	case e1000_82576:
 	case e1000_82580:
 	case e1000_i350:
@@ -788,7 +788,7 @@ em_set_num_queues(if_ctx_t ctx)
 static int
 em_if_attach_pre(if_ctx_t ctx)
 {
-	struct adapter *adapter;
+	struct e1000_softc *sc;
 	if_softc_ctx_t scctx;
 	device_t dev;
 	struct e1000_hw *hw;
@@ -796,42 +796,42 @@ em_if_attach_pre(if_ctx_t ctx)
 
 	INIT_DEBUGOUT("em_if_attach_pre: begin");
 	dev = iflib_get_dev(ctx);
-	adapter = iflib_get_softc(ctx);
+	sc = iflib_get_softc(ctx);
 
-	adapter->ctx = adapter->osdep.ctx = ctx;
-	adapter->dev = adapter->osdep.dev = dev;
-	scctx = adapter->shared = iflib_get_softc_ctx(ctx);
-	adapter->media = iflib_get_media(ctx);
-	hw = &adapter->hw;
+	sc->ctx = sc->osdep.ctx = ctx;
+	sc->dev = sc->osdep.dev = dev;
+	scctx = sc->shared = iflib_get_softc_ctx(ctx);
+	sc->media = iflib_get_media(ctx);
+	hw = &sc->hw;
 
-	adapter->tx_process_limit = scctx->isc_ntxd[0];
+	sc->tx_process_limit = scctx->isc_ntxd[0];
 
 	/* SYSCTL stuff */
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 	    OID_AUTO, "nvm", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
-	    adapter, 0, em_sysctl_nvm_info, "I", "NVM Information");
+	    sc, 0, em_sysctl_nvm_info, "I", "NVM Information");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 	    OID_AUTO, "debug", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
-	    adapter, 0, em_sysctl_debug_info, "I", "Debug Information");
+	    sc, 0, em_sysctl_debug_info, "I", "Debug Information");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 	    OID_AUTO, "fc", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
-	    adapter, 0, em_set_flowcntl, "I", "Flow Control");
+	    sc, 0, em_set_flowcntl, "I", "Flow Control");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 	    OID_AUTO, "reg_dump",
-	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, adapter, 0,
+	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0,
 	    em_get_regs, "A", "Dump Registers");
 
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 	    OID_AUTO, "rs_dump",
-	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, adapter, 0,
+	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
 	    em_get_rs, "I", "Dump RS indexes");
 
 	/* Determine hardware and mac info */
@@ -938,19 +938,19 @@ em_if_attach_pre(if_ctx_t ctx)
 	    (hw->mac.type == e1000_pch2lan) ||
 	    (hw->mac.type == e1000_pch_lpt)) {
 		int rid = EM_BAR_TYPE_FLASH;
-		adapter->flash = bus_alloc_resource_any(dev,
+		sc->flash = bus_alloc_resource_any(dev,
 		    SYS_RES_MEMORY, &rid, RF_ACTIVE);
-		if (adapter->flash == NULL) {
+		if (sc->flash == NULL) {
 			device_printf(dev, "Mapping of Flash failed\n");
 			error = ENXIO;
 			goto err_pci;
 		}
 		/* This is used in the shared code */
-		hw->flash_address = (u8 *)adapter->flash;
-		adapter->osdep.flash_bus_space_tag =
-		    rman_get_bustag(adapter->flash);
-		adapter->osdep.flash_bus_space_handle =
-		    rman_get_bushandle(adapter->flash);
+		hw->flash_address = (u8 *)sc->flash;
+		sc->osdep.flash_bus_space_tag =
+		    rman_get_bustag(sc->flash);
+		sc->osdep.flash_bus_space_handle =
+		    rman_get_bushandle(sc->flash);
 	}
 	/*
 	** In the new SPT device flash is not  a
@@ -959,10 +959,10 @@ em_if_attach_pre(if_ctx_t ctx)
 	** FLASH read/write macros in the shared code.
 	*/
 	else if (hw->mac.type >= e1000_pch_spt) {
-		adapter->osdep.flash_bus_space_tag =
-		    adapter->osdep.mem_bus_space_tag;
-		adapter->osdep.flash_bus_space_handle =
-		    adapter->osdep.mem_bus_space_handle
+		sc->osdep.flash_bus_space_tag =
+		    sc->osdep.mem_bus_space_tag;
+		sc->osdep.flash_bus_space_handle =
+		    sc->osdep.mem_bus_space_handle
 		    + E1000_FLASH_BASE_ADDR;
 	}
 
@@ -979,25 +979,25 @@ em_if_attach_pre(if_ctx_t ctx)
 	e1000_get_bus_info(hw);
 
 	/* Set up some sysctls for the tunable interrupt delays */
-	em_add_int_delay_sysctl(adapter, "rx_int_delay",
-	    "receive interrupt delay in usecs", &adapter->rx_int_delay,
+	em_add_int_delay_sysctl(sc, "rx_int_delay",
+	    "receive interrupt delay in usecs", &sc->rx_int_delay,
 	    E1000_REGISTER(hw, E1000_RDTR), em_rx_int_delay_dflt);
-	em_add_int_delay_sysctl(adapter, "tx_int_delay",
-	    "transmit interrupt delay in usecs", &adapter->tx_int_delay,
+	em_add_int_delay_sysctl(sc, "tx_int_delay",
+	    "transmit interrupt delay in usecs", &sc->tx_int_delay,
 	    E1000_REGISTER(hw, E1000_TIDV), em_tx_int_delay_dflt);
-	em_add_int_delay_sysctl(adapter, "rx_abs_int_delay",
+	em_add_int_delay_sysctl(sc, "rx_abs_int_delay",
 	    "receive interrupt delay limit in usecs",
-	    &adapter->rx_abs_int_delay,
+	    &sc->rx_abs_int_delay,
 	    E1000_REGISTER(hw, E1000_RADV),
 	    em_rx_abs_int_delay_dflt);
-	em_add_int_delay_sysctl(adapter, "tx_abs_int_delay",
+	em_add_int_delay_sysctl(sc, "tx_abs_int_delay",
 	    "transmit interrupt delay limit in usecs",
-	    &adapter->tx_abs_int_delay,
+	    &sc->tx_abs_int_delay,
 	    E1000_REGISTER(hw, E1000_TADV),
 	    em_tx_abs_int_delay_dflt);
-	em_add_int_delay_sysctl(adapter, "itr",
+	em_add_int_delay_sysctl(sc, "itr",
 	    "interrupt delay limit in usecs/4",
-	    &adapter->tx_itr,
+	    &sc->tx_itr,
 	    E1000_REGISTER(hw, E1000_ITR),
 	    DEFAULT_ITR);
 
@@ -1030,9 +1030,9 @@ em_if_attach_pre(if_ctx_t ctx)
 	hw->mac.report_tx_early = 1;
 
 	/* Allocate multicast array memory. */
-	adapter->mta = malloc(sizeof(u8) * ETHER_ADDR_LEN *
+	sc->mta = malloc(sizeof(u8) * ETHER_ADDR_LEN *
 	    MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_NOWAIT);
-	if (adapter->mta == NULL) {
+	if (sc->mta == NULL) {
 		device_printf(dev, "Can not allocate multicast setup array\n");
 		error = ENOMEM;
 		goto err_late;
@@ -1049,7 +1049,7 @@ em_if_attach_pre(if_ctx_t ctx)
 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
 	    OID_AUTO, "eee_control",
 	    CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
-	    adapter, 0, em_sysctl_eee, "I",
+	    sc, 0, em_sysctl_eee, "I",
 	    "Disable Energy Efficient Ethernet");
 
 	/*
@@ -1083,7 +1083,7 @@ em_if_attach_pre(if_ctx_t ctx)
 	}
 
 	if (!em_is_valid_ether_addr(hw->mac.addr)) {
-		if (adapter->vf_ifp) {
+		if (sc->vf_ifp) {
 			ether_gen_addr(iflib_get_ifp(ctx),
 			    (struct ether_addr *)hw->mac.addr);
 		} else {
@@ -1103,7 +1103,7 @@ em_if_attach_pre(if_ctx_t ctx)
 
 	/* Enable only WOL MAGIC by default */
 	scctx->isc_capenable &= ~IFCAP_WOL;
-	if (adapter->wol != 0)
+	if (sc->wol != 0)
 		scctx->isc_capenable |= IFCAP_WOL_MAGIC;
 
 	iflib_set_mac(ctx, hw->mac.addr);
@@ -1111,10 +1111,10 @@ em_if_attach_pre(if_ctx_t ctx)
 	return (0);
 
 err_late:
-	em_release_hw_control(adapter);
+	em_release_hw_control(sc);
 err_pci:
 	em_free_pci_resources(ctx);
-	free(adapter->mta, M_DEVBUF);
+	free(sc->mta, M_DEVBUF);
 
 	return (error);
 }
@@ -1122,28 +1122,28 @@ err_pci:
 static int
 em_if_attach_post(if_ctx_t ctx)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
-	struct e1000_hw *hw = &adapter->hw;
+	struct e1000_softc *sc = iflib_get_softc(ctx);
+	struct e1000_hw *hw = &sc->hw;
 	int error = 0;
 
 	/* Setup OS specific network interface */
 	error = em_setup_interface(ctx);
 	if (error != 0) {
-		device_printf(adapter->dev, "Interface setup failed: %d\n", error);
+		device_printf(sc->dev, "Interface setup failed: %d\n", error);
 		goto err_late;
 	}
 
 	em_reset(ctx);
 
 	/* Initialize statistics */
-	em_update_stats_counters(adapter);
+	em_update_stats_counters(sc);
 	hw->mac.get_link_status = 1;
 	em_if_update_admin_status(ctx);
-	em_add_hw_stats(adapter);
+	em_add_hw_stats(sc);
 
 	/* Non-AMT based hardware can now take control from firmware */
-	if (adapter->has_manage && !adapter->has_amt)
-		em_get_hw_control(adapter);
+	if (sc->has_manage && !sc->has_amt)
+		em_get_hw_control(sc);
 
 	INIT_DEBUGOUT("em_if_attach_post: end");
 
@@ -1166,17 +1166,17 @@ err_late:
 static int
 em_if_detach(if_ctx_t ctx)
 {
-	struct adapter	*adapter = iflib_get_softc(ctx);
+	struct e1000_softc	*sc = iflib_get_softc(ctx);
 
 	INIT_DEBUGOUT("em_if_detach: begin");
 
-	e1000_phy_hw_reset(&adapter->hw);
+	e1000_phy_hw_reset(&sc->hw);
 
-	em_release_manageability(adapter);
-	em_release_hw_control(adapter);
+	em_release_manageability(sc);
+	em_release_hw_control(sc);
 	em_free_pci_resources(ctx);
-	free(adapter->mta, M_DEVBUF);
-	adapter->mta = NULL;
+	free(sc->mta, M_DEVBUF);
+	sc->mta = NULL;
 
 	return (0);
 }
@@ -1199,10 +1199,10 @@ em_if_shutdown(if_ctx_t ctx)
 static int
 em_if_suspend(if_ctx_t ctx)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
+	struct e1000_softc *sc = iflib_get_softc(ctx);
 
-	em_release_manageability(adapter);
-	em_release_hw_control(adapter);
+	em_release_manageability(sc);
+	em_release_hw_control(sc);
 	em_enable_wakeup(ctx);
 	return (0);
 }
@@ -1210,12 +1210,12 @@ em_if_suspend(if_ctx_t ctx)
 static int
 em_if_resume(if_ctx_t ctx)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
+	struct e1000_softc *sc = iflib_get_softc(ctx);
 
-	if (adapter->hw.mac.type == e1000_pch2lan)
-		e1000_resume_workarounds_pchlan(&adapter->hw);
+	if (sc->hw.mac.type == e1000_pch2lan)
+		e1000_resume_workarounds_pchlan(&sc->hw);
 	em_if_init(ctx);
-	em_init_manageability(adapter);
+	em_init_manageability(sc);
 
 	return(0);
 }
@@ -1224,12 +1224,12 @@ static int
 em_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
 {
 	int max_frame_size;
-	struct adapter *adapter = iflib_get_softc(ctx);
+	struct e1000_softc *sc = iflib_get_softc(ctx);
 	if_softc_ctx_t scctx = iflib_get_softc_ctx(ctx);
 
 	IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
 
-	switch (adapter->hw.mac.type) {
+	switch (sc->hw.mac.type) {
 	case e1000_82571:
 	case e1000_82572:
 	case e1000_ich9lan:
@@ -1256,7 +1256,7 @@ em_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
 		max_frame_size = ETHER_MAX_LEN;
 		break;
 	default:
-		if (adapter->hw.mac.type >= igb_mac_min)
+		if (sc->hw.mac.type >= igb_mac_min)
 			max_frame_size = 9234;
 		else /* lem */
 			max_frame_size = MAX_JUMBO_FRAME_SIZE;
@@ -1265,7 +1265,7 @@ em_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
 		return (EINVAL);
 	}
 
-	scctx->isc_max_frame_size = adapter->hw.mac.max_frame_size =
+	scctx->isc_max_frame_size = sc->hw.mac.max_frame_size =
 	    mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
 	return (0);
 }
@@ -1282,8 +1282,8 @@ em_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
 static void
 em_if_init(if_ctx_t ctx)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
-	if_softc_ctx_t scctx = adapter->shared;
+	struct e1000_softc *sc = iflib_get_softc(ctx);
+	if_softc_ctx_t scctx = sc->shared;
 	struct ifnet *ifp = iflib_get_ifp(ctx);
 	struct em_tx_queue *tx_que;
 	int i;
@@ -1291,11 +1291,11 @@ em_if_init(if_ctx_t ctx)
 	INIT_DEBUGOUT("em_if_init: begin");
 
 	/* Get the latest mac address, User can use a LAA */
-	bcopy(if_getlladdr(ifp), adapter->hw.mac.addr,
+	bcopy(if_getlladdr(ifp), sc->hw.mac.addr,
 	    ETHER_ADDR_LEN);
 
 	/* Put the address into the Receive Address Array */
-	e1000_rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
+	e1000_rar_set(&sc->hw, sc->hw.mac.addr, 0);
 
 	/*
 	 * With the 82571 adapter, RAR[0] may be overwritten
@@ -1303,9 +1303,9 @@ em_if_init(if_ctx_t ctx)
 	 * in RAR[14] for that eventuality, this assures
 	 * the interface continues to function.
 	 */
-	if (adapter->hw.mac.type == e1000_82571) {
-		e1000_set_laa_state_82571(&adapter->hw, true);
-		e1000_rar_set(&adapter->hw, adapter->hw.mac.addr,
+	if (sc->hw.mac.type == e1000_82571) {
+		e1000_set_laa_state_82571(&sc->hw, true);
+		e1000_rar_set(&sc->hw, sc->hw.mac.addr,
 		    E1000_RAR_ENTRIES - 1);
 	}
 
@@ -1314,7 +1314,7 @@ em_if_init(if_ctx_t ctx)
 	em_reset(ctx);
 	em_if_update_admin_status(ctx);
 
-	for (i = 0, tx_que = adapter->tx_queues; i < adapter->tx_num_queues; i++, tx_que++) {
+	for (i = 0, tx_que = sc->tx_queues; i < sc->tx_num_queues; i++, tx_que++) {
 		struct tx_ring *txr = &tx_que->txr;
 
 		txr->tx_rs_cidx = txr->tx_rs_pidx;
@@ -1328,14 +1328,14 @@ em_if_init(if_ctx_t ctx)
 	}
 
 	/* Setup VLAN support, basic and offload if available */
-	E1000_WRITE_REG(&adapter->hw, E1000_VET, ETHERTYPE_VLAN);
+	E1000_WRITE_REG(&sc->hw, E1000_VET, ETHERTYPE_VLAN);
 
 	/* Clear bad data from Rx FIFOs */
-	if (adapter->hw.mac.type >= igb_mac_min)
-		e1000_rx_fifo_flush_base(&adapter->hw);
+	if (sc->hw.mac.type >= igb_mac_min)
+		e1000_rx_fifo_flush_base(&sc->hw);
 
 	/* Configure for OS presence */
-	em_init_manageability(adapter);
+	em_init_manageability(sc);
 
 	/* Prepare transmit descriptors and buffers */
 	em_initialize_transmit_unit(ctx);
@@ -1343,42 +1343,42 @@ em_if_init(if_ctx_t ctx)
 	/* Setup Multicast table */
 	em_if_multi_set(ctx);
 
-	adapter->rx_mbuf_sz = iflib_get_rx_mbuf_sz(ctx);
+	sc->rx_mbuf_sz = iflib_get_rx_mbuf_sz(ctx);
 	em_initialize_receive_unit(ctx);
 
 	/* Set up VLAN support and filter */
-	em_setup_vlan_hw_support(adapter);
+	em_setup_vlan_hw_support(sc);
 
 	/* Don't lose promiscuous settings */
 	em_if_set_promisc(ctx, if_getflags(ifp));
-	e1000_clear_hw_cntrs_base_generic(&adapter->hw);
+	e1000_clear_hw_cntrs_base_generic(&sc->hw);
 
 	/* MSI-X configuration for 82574 */
-	if (adapter->hw.mac.type == e1000_82574) {
-		int tmp = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
+	if (sc->hw.mac.type == e1000_82574) {
+		int tmp = E1000_READ_REG(&sc->hw, E1000_CTRL_EXT);
 
 		tmp |= E1000_CTRL_EXT_PBA_CLR;
-		E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT, tmp);
+		E1000_WRITE_REG(&sc->hw, E1000_CTRL_EXT, tmp);
 		/* Set the IVAR - interrupt vector routing. */
-		E1000_WRITE_REG(&adapter->hw, E1000_IVAR, adapter->ivars);
-	} else if (adapter->intr_type == IFLIB_INTR_MSIX) /* Set up queue routing */
-		igb_configure_queues(adapter);
+		E1000_WRITE_REG(&sc->hw, E1000_IVAR, sc->ivars);
+	} else if (sc->intr_type == IFLIB_INTR_MSIX) /* Set up queue routing */
+		igb_configure_queues(sc);
 
 	/* this clears any pending interrupts */
-	E1000_READ_REG(&adapter->hw, E1000_ICR);
-	E1000_WRITE_REG(&adapter->hw, E1000_ICS, E1000_ICS_LSC);
+	E1000_READ_REG(&sc->hw, E1000_ICR);
+	E1000_WRITE_REG(&sc->hw, E1000_ICS, E1000_ICS_LSC);
 
 	/* AMT based hardware can now take control from firmware */
-	if (adapter->has_manage && adapter->has_amt)
-		em_get_hw_control(adapter);
+	if (sc->has_manage && sc->has_amt)
+		em_get_hw_control(sc);
 
 	/* Set Energy Efficient Ethernet */
-	if (adapter->hw.mac.type >= igb_mac_min &&
-	    adapter->hw.phy.media_type == e1000_media_type_copper) {
-		if (adapter->hw.mac.type == e1000_i354)
-			e1000_set_eee_i354(&adapter->hw, true, true);
+	if (sc->hw.mac.type >= igb_mac_min &&
+	    sc->hw.phy.media_type == e1000_media_type_copper) {
+		if (sc->hw.mac.type == e1000_i354)
+			e1000_set_eee_i354(&sc->hw, true, true);
 		else
-			e1000_set_eee_i350(&adapter->hw, true, true);
+			e1000_set_eee_i350(&sc->hw, true, true);
 	}
 }
 
@@ -1390,11 +1390,11 @@ em_if_init(if_ctx_t ctx)
 int
 em_intr(void *arg)
 {
-	struct adapter *adapter = arg;
-	if_ctx_t ctx = adapter->ctx;
+	struct e1000_softc *sc = arg;
+	if_ctx_t ctx = sc->ctx;
 	u32 reg_icr;
 
-	reg_icr = E1000_READ_REG(&adapter->hw, E1000_ICR);
+	reg_icr = E1000_READ_REG(&sc->hw, E1000_ICR);
 
 	/* Hot eject? */
 	if (reg_icr == 0xffffffff)
@@ -1408,7 +1408,7 @@ em_intr(void *arg)
 	 * Starting with the 82571 chip, bit 31 should be used to
 	 * determine whether the interrupt belongs to us.
 	 */
-	if (adapter->hw.mac.type >= e1000_82571 &&
+	if (sc->hw.mac.type >= e1000_82571 &&
 	    (reg_icr & E1000_ICR_INT_ASSERTED) == 0)
 		return FILTER_STRAY;
 
@@ -1425,7 +1425,7 @@ em_intr(void *arg)
 		em_handle_link(ctx);
 
 	if (reg_icr & E1000_ICR_RXO)
-		adapter->rx_overruns++;
+		sc->rx_overruns++;
 
 	return (FILTER_SCHEDULE_THREAD);
 }
@@ -1433,40 +1433,40 @@ em_intr(void *arg)
 static int
 em_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
-	struct em_rx_queue *rxq = &adapter->rx_queues[rxqid];
+	struct e1000_softc *sc = iflib_get_softc(ctx);
+	struct em_rx_queue *rxq = &sc->rx_queues[rxqid];
 
-	E1000_WRITE_REG(&adapter->hw, E1000_IMS, rxq->eims);
+	E1000_WRITE_REG(&sc->hw, E1000_IMS, rxq->eims);
 	return (0);
 }
 
 static int
 em_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
-	struct em_tx_queue *txq = &adapter->tx_queues[txqid];
+	struct e1000_softc *sc = iflib_get_softc(ctx);
+	struct em_tx_queue *txq = &sc->tx_queues[txqid];
 
-	E1000_WRITE_REG(&adapter->hw, E1000_IMS, txq->eims);
+	E1000_WRITE_REG(&sc->hw, E1000_IMS, txq->eims);
 	return (0);
 }
 
 static int
 igb_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
-	struct em_rx_queue *rxq = &adapter->rx_queues[rxqid];
+	struct e1000_softc *sc = iflib_get_softc(ctx);
+	struct em_rx_queue *rxq = &sc->rx_queues[rxqid];
 
-	E1000_WRITE_REG(&adapter->hw, E1000_EIMS, rxq->eims);
+	E1000_WRITE_REG(&sc->hw, E1000_EIMS, rxq->eims);
 	return (0);
 }
 
 static int
 igb_if_tx_queue_intr_enable(if_ctx_t ctx, uint16_t txqid)
 {
-	struct adapter *adapter = iflib_get_softc(ctx);
-	struct em_tx_queue *txq = &adapter->tx_queues[txqid];
+	struct e1000_softc *sc = iflib_get_softc(ctx);
+	struct em_tx_queue *txq = &sc->tx_queues[txqid];
 
-	E1000_WRITE_REG(&adapter->hw, E1000_EIMS, txq->eims);
+	E1000_WRITE_REG(&sc->hw, E1000_EIMS, txq->eims);
 	return (0);
 }
 
@@ -1493,29 +1493,29 @@ em_msix_que(void *arg)
 static int
 em_msix_link(void *arg)
 {
-	struct adapter *adapter = arg;
+	struct e1000_softc *sc = arg;
 	u32 reg_icr;
 	bool notlink = false;
 
-	++adapter->link_irq;
-	MPASS(adapter->hw.back != NULL);
-	reg_icr = E1000_READ_REG(&adapter->hw, E1000_ICR);
+	++sc->link_irq;
+	MPASS(sc->hw.back != NULL);
+	reg_icr = E1000_READ_REG(&sc->hw, E1000_ICR);
 
 	if (reg_icr & E1000_ICR_RXO)
-		adapter->rx_overruns++;
+		sc->rx_overruns++;
 
 	if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))
-		em_handle_link(adapter->ctx);
+		em_handle_link(sc->ctx);
 	else
 		notlink = true;
 
 	/* Re-arm for other/spurious interrupts */
-	if (notlink && adapter->hw.mac.type >= igb_mac_min) {
-		E1000_WRITE_REG(&adapter->hw, E1000_IMS, E1000_IMS_LSC);
*** 3447 LINES SKIPPED ***



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202109281657.18SGvZta035422>