 @@ -1,2504 +1,2506 @@
-/*	$NetBSD: tulip.c,v 1.200 2019/11/10 21:16:35 chs Exp $	*/
+/*	$NetBSD: tulip.c,v 1.201 2020/01/29 14:18:54 thorpej Exp $	*/
 /*-
  * Copyright (c) 1998, 1999, 2000, 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center; and by Charles M. Hannum.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Device driver for the Digital Semiconductor ``Tulip'' (21x4x)
  * Ethernet controller family, and a variety of clone chips.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tulip.c,v 1.200 2019/11/10 21:16:35 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tulip.c,v 1.201 2020/01/29 14:18:54 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/mbuf.h>
 #include <sys/malloc.h>
 #include <sys/kernel.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/errno.h>
 #include <sys/device.h>
 #include <machine/endian.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_media.h>
 #include <net/if_ether.h>
 #include <net/bpf.h>
 #include <sys/bus.h>
 #include <sys/intr.h>
 #include <dev/mii/mii.h>
 #include <dev/mii/miivar.h>
 #include <dev/mii/mii_bitbang.h>
 #include <dev/ic/tulipreg.h>
 #include <dev/ic/tulipvar.h>
 static const char * const tlp_chip_names[] = TULIP_CHIP_NAMES;
 static const struct tulip_txthresh_tab tlp_10_txthresh_tab[] =
     TLP_TXTHRESH_TAB_10;
 static const struct tulip_txthresh_tab tlp_10_100_txthresh_tab[] =
     TLP_TXTHRESH_TAB_10_100;
 static const struct tulip_txthresh_tab tlp_dm9102_txthresh_tab[] =
     TLP_TXTHRESH_TAB_DM9102;
 static void	tlp_start(struct ifnet *);
 static void	tlp_watchdog(struct ifnet *);
 static int	tlp_ioctl(struct ifnet *, u_long, void *);
 static int	tlp_init(struct ifnet *);
 static void	tlp_stop(struct ifnet *, int);
 static int	tlp_ifflags_cb(struct ethercom *);
 static void	tlp_rxdrain(struct tulip_softc *);
 static int	tlp_add_rxbuf(struct tulip_softc *, int);
 static void	tlp_srom_idle(struct tulip_softc *);
 static int	tlp_srom_size(struct tulip_softc *);
 static int	tlp_enable(struct tulip_softc *);
 static void	tlp_disable(struct tulip_softc *);
 static void	tlp_filter_setup(struct tulip_softc *);
 static void	tlp_winb_filter_setup(struct tulip_softc *);
 static void	tlp_al981_filter_setup(struct tulip_softc *);
 static void	tlp_asix_filter_setup(struct tulip_softc *);
 static void	tlp_rxintr(struct tulip_softc *);
 static void	tlp_txintr(struct tulip_softc *);
 static void	tlp_mii_tick(void *);
 static void	tlp_mii_statchg(struct ifnet *);
 static void	tlp_winb_mii_statchg(struct ifnet *);
 static void	tlp_dm9102_mii_statchg(struct ifnet *);
 static void	tlp_mii_getmedia(struct tulip_softc *, struct ifmediareq *);
 static int	tlp_mii_setmedia(struct tulip_softc *);
 static int	tlp_bitbang_mii_readreg(device_t, int, int, uint16_t *);
 static int	tlp_bitbang_mii_writereg(device_t, int, int, uint16_t);
 static int	tlp_pnic_mii_readreg(device_t, int, int, uint16_t *);
 static int	tlp_pnic_mii_writereg(device_t, int, int, uint16_t);
 static int	tlp_al981_mii_readreg(device_t, int, int, uint16_t *);
 static int	tlp_al981_mii_writereg(device_t, int, int, uint16_t);
 static void	tlp_2114x_preinit(struct tulip_softc *);
 static void	tlp_2114x_mii_preinit(struct tulip_softc *);
 static void	tlp_pnic_preinit(struct tulip_softc *);
 static void	tlp_dm9102_preinit(struct tulip_softc *);
 static void	tlp_asix_preinit(struct tulip_softc *);
 static void	tlp_21140_reset(struct tulip_softc *);
 static void	tlp_21142_reset(struct tulip_softc *);
 static void	tlp_pmac_reset(struct tulip_softc *);
 #if 0
 static void	tlp_dm9102_reset(struct tulip_softc *);
 #endif
 static void	tlp_2114x_nway_tick(void *);
 #define	tlp_mchash(addr, sz)						\
 	(ether_crc32_le((addr), ETHER_ADDR_LEN) & ((sz) - 1))
 /*
  * MII bit-bang glue.
  */
 static uint32_t tlp_sio_mii_bitbang_read(device_t);
 static void	tlp_sio_mii_bitbang_write(device_t, uint32_t);
 static const struct mii_bitbang_ops tlp_sio_mii_bitbang_ops = {
 	tlp_sio_mii_bitbang_read,
 	tlp_sio_mii_bitbang_write,
+	{
 		MIIROM_MDO,		/* MII_BIT_MDO */
 		MIIROM_MDI,		/* MII_BIT_MDI */
 		MIIROM_MDC,		/* MII_BIT_MDC */
 ,			/* MII_BIT_DIR_HOST_PHY */
 		MIIROM_MIIDIR,		/* MII_BIT_DIR_PHY_HOST */
+	}
 };
 #ifdef TLP_DEBUG
 #define	DPRINTF(sc, x)	if ((sc)->sc_ethercom.ec_if.if_flags & IFF_DEBUG) \
 				printf x
 #else
 #define	DPRINTF(sc, x)	/* nothing */
 #endif
 #ifdef TLP_STATS
 static void	tlp_print_stats(struct tulip_softc *);
 #endif
 /*
  * Can be used to debug the SROM-related things, including contents.
  * Initialized so that it's patchable.
  */
 int	tlp_srom_debug = 0;
 /*
  * tlp_attach:
+ *
  *	Attach a Tulip interface to the system.
  */
 int
 tlp_attach(struct tulip_softc *sc, const uint8_t *enaddr)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	device_t self = sc->sc_dev;
 	int i, error;
 	callout_init(&sc->sc_nway_callout, 0);
 	callout_init(&sc->sc_tick_callout, 0);
 	/*
 	 * NOTE: WE EXPECT THE FRONT-END TO INITIALIZE sc_regshift!
 	 */
 	/*
 	 * Setup the transmit threshold table.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_DE425:
 	case TULIP_CHIP_21040:
 	case TULIP_CHIP_21041:
 		sc->sc_txth = tlp_10_txthresh_tab;
 		break;
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 		sc->sc_txth = tlp_dm9102_txthresh_tab;
 		break;
 	default:
 		sc->sc_txth = tlp_10_100_txthresh_tab;
 		break;
+	}
 	/*
 	 * Setup the filter setup function.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_WB89C840F:
 		sc->sc_filter_setup = tlp_winb_filter_setup;
 		break;
 	case TULIP_CHIP_AL981:
 	case TULIP_CHIP_AN983:
 	case TULIP_CHIP_AN985:
 		sc->sc_filter_setup = tlp_al981_filter_setup;
 		break;
 	case TULIP_CHIP_AX88140:
 	case TULIP_CHIP_AX88141:
 		sc->sc_filter_setup = tlp_asix_filter_setup;
 		break;
 	default:
 		sc->sc_filter_setup = tlp_filter_setup;
 		break;
+	}
 	/*
 	 * Set up the media status change function.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_WB89C840F:
 		sc->sc_statchg = tlp_winb_mii_statchg;
 		break;
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 		sc->sc_statchg = tlp_dm9102_mii_statchg;
 		break;
 	default:
 		/*
 		 * We may override this if we have special media
 		 * handling requirements (e.g. flipping GPIO pins).
+		 *
 		 * The pure-MII statchg function covers the basics.
 		 */
 		sc->sc_statchg = tlp_mii_statchg;
 		break;
+	}
 	/*
 	 * Default to no FS|LS in setup packet descriptors.  They're
 	 * supposed to be zero according to the 21040 and 21143
 	 * manuals, and some chips fall over badly if they're
 	 * included.  Yet, other chips seem to require them.  Sigh.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_X3201_3:
 		sc->sc_setup_fsls = TDCTL_Tx_FS | TDCTL_Tx_LS;
 		break;
 	default:
 		sc->sc_setup_fsls = 0;
+	}
 	/*
 	 * Set up various chip-specific quirks.
+	 *
 	 * Note that wherever we can, we use the "ring" option for
 	 * transmit and receive descriptors.  This is because some
 	 * clone chips apparently have problems when using chaining,
 	 * although some *only* support chaining.
+	 *
 	 * What we do is always program the "next" pointer, and then
 	 * conditionally set the TDCTL_CH and TDCTL_ER bits in the
 	 * appropriate places.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_21140:
 	case TULIP_CHIP_21140A:
 	case TULIP_CHIP_21142:
 	case TULIP_CHIP_21143:
 	case TULIP_CHIP_82C115:		/* 21143-like */
 	case TULIP_CHIP_MX98713:	/* 21140-like */
 	case TULIP_CHIP_MX98713A:	/* 21143-like */
 	case TULIP_CHIP_MX98715:	/* 21143-like */
 	case TULIP_CHIP_MX98715A:	/* 21143-like */
 	case TULIP_CHIP_MX98715AEC_X:	/* 21143-like */
 	case TULIP_CHIP_MX98725:	/* 21143-like */
 	case TULIP_CHIP_RS7112:		/* 21143-like */
 		/*
 		 * Run these chips in ring mode.
 		 */
 		sc->sc_tdctl_ch = 0;
 		sc->sc_tdctl_er = TDCTL_ER;
 		sc->sc_preinit = tlp_2114x_preinit;
 		break;
 	case TULIP_CHIP_82C168:
 	case TULIP_CHIP_82C169:
 		/*
 		 * Run these chips in ring mode.
 		 */
 		sc->sc_tdctl_ch = 0;
 		sc->sc_tdctl_er = TDCTL_ER;
 		sc->sc_preinit = tlp_pnic_preinit;
 		/*
 		 * These chips seem to have busted DMA engines; just put them
 		 * in Store-and-Forward mode from the get-go.
 		 */
 		sc->sc_txthresh = TXTH_SF;
 		break;
 	case TULIP_CHIP_WB89C840F:
 		/*
 		 * Run this chip in chained mode.
 		 */
 		sc->sc_tdctl_ch = TDCTL_CH;
 		sc->sc_tdctl_er = 0;
 		sc->sc_flags |= TULIPF_IC_FS;
 		break;
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 		/*
 		 * Run these chips in chained mode.
 		 */
 		sc->sc_tdctl_ch = TDCTL_CH;
 		sc->sc_tdctl_er = 0;
 		sc->sc_preinit = tlp_dm9102_preinit;
 		/*
 		 * These chips have a broken bus interface, so we
 		 * can't use any optimized bus commands.  For this
 		 * reason, we tend to underrun pretty quickly, so
 		 * just to Store-and-Forward mode from the get-go.
 		 */
 		sc->sc_txthresh = TXTH_DM9102_SF;
 		break;
 	case TULIP_CHIP_AX88140:
 	case TULIP_CHIP_AX88141:
 		/*
 		 * Run these chips in ring mode.
 		 */
 		sc->sc_tdctl_ch = 0;
 		sc->sc_tdctl_er = TDCTL_ER;
 		sc->sc_preinit = tlp_asix_preinit;
 		break;
 	default:
 		/*
 		 * Default to running in ring mode.
 		 */
 		sc->sc_tdctl_ch = 0;
 		sc->sc_tdctl_er = TDCTL_ER;
+	}
 	/*
 	 * Set up the MII bit-bang operations.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_WB89C840F:	/* XXX direction bit different? */
 		sc->sc_bitbang_ops = &tlp_sio_mii_bitbang_ops;
 		break;
 	default:
 		sc->sc_bitbang_ops = &tlp_sio_mii_bitbang_ops;
+	}
 	SIMPLEQ_INIT(&sc->sc_txfreeq);
 	SIMPLEQ_INIT(&sc->sc_txdirtyq);
 	/*
 	 * Allocate the control data structures, and create and load the
 	 * DMA map for it.
 	 */
 	if ((error = bus_dmamem_alloc(sc->sc_dmat,
 	    sizeof(struct tulip_control_data), PAGE_SIZE, 0, &sc->sc_cdseg,
 , &sc->sc_cdnseg, 0)) != 0) {
 		aprint_error_dev(self,
 		    "unable to allocate control data, error = %d\n", error);
 		goto fail_0;
+	}
 	if ((error = bus_dmamem_map(sc->sc_dmat, &sc->sc_cdseg, sc->sc_cdnseg,
 	    sizeof(struct tulip_control_data), (void **)&sc->sc_control_data,
 	    BUS_DMA_COHERENT)) != 0) {
 		aprint_error_dev(self,
 		    "unable to map control data, error = %d\n", error);
 		goto fail_1;
+	}
 	if ((error = bus_dmamap_create(sc->sc_dmat,
 	    sizeof(struct tulip_control_data), 1,
 	    sizeof(struct tulip_control_data), 0, 0, &sc->sc_cddmamap)) != 0) {
 		sc->sc_cddmamap = NULL;
 		aprint_error_dev(self,
 		    "unable to create control data DMA map, error = %d\n",
 		    error);
 		goto fail_2;
+	}
 	if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_cddmamap,
 	    sc->sc_control_data, sizeof(struct tulip_control_data), NULL,
 )) != 0) {
 		aprint_error_dev(self,
 		    "unable to load control data DMA map, error = %d\n",
 		    error);
 		goto fail_3;
+	}
 	/*
 	 * Create the transmit buffer DMA maps.
+	 *
 	 * Note that on the Xircom clone, transmit buffers must be
 	 * 4-byte aligned.  We're almost guaranteed to have to copy
 	 * the packet in that case, so we just limit ourselves to
 	 * one segment.
+	 *
 	 * On the DM9102, the transmit logic can only handle one
 	 * DMA segment.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_X3201_3:
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 	case TULIP_CHIP_AX88140:
 	case TULIP_CHIP_AX88141:
 		sc->sc_ntxsegs = 1;
 		break;
 	default:
 		sc->sc_ntxsegs = TULIP_NTXSEGS;
+	}
 	for (i = 0; i < TULIP_TXQUEUELEN; i++) {
 		if ((error = bus_dmamap_create(sc->sc_dmat, MCLBYTES,
 		    sc->sc_ntxsegs, MCLBYTES, 0, 0,
 		    &sc->sc_txsoft[i].txs_dmamap)) != 0) {
 			sc->sc_txsoft[i].txs_dmamap = NULL;
 			aprint_error_dev(self,
 			    "unable to create tx DMA map %d, error = %d\n", i,
 			    error);
 			goto fail_4;
+		}
+	}
 	/*
 	 * Create the receive buffer DMA maps.
 	 */
 	for (i = 0; i < TULIP_NRXDESC; i++) {
 		if ((error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
 		    MCLBYTES, 0, 0, &sc->sc_rxsoft[i].rxs_dmamap)) != 0) {
 			sc->sc_rxsoft[i].rxs_dmamap = NULL;
 			aprint_error_dev(self,
 			    "unable to create rx DMA map %d, error = %d\n", i,
 			    error);
 			goto fail_5;
+		}
 		sc->sc_rxsoft[i].rxs_mbuf = NULL;
+	}
 	/*
 	 * From this point forward, the attachment cannot fail.  A failure
 	 * before this point releases all resources that may have been
 	 * allocated.
 	 */
 	sc->sc_flags |= TULIPF_ATTACHED;
 	/*
 	 * Reset the chip to a known state.
 	 */
 	tlp_reset(sc);
 	/* Announce ourselves. */
 	aprint_normal_dev(self, "%s%sEthernet address %s\n",
 	    sc->sc_name[0] != '\0' ? sc->sc_name : "",
 	    sc->sc_name[0] != '\0' ? ", " : "",
 	    ether_sprintf(enaddr));
 	/*
 	 * Check to see if we're the simulated Ethernet on Connectix
 	 * Virtual PC.
 	 */
 	if (enaddr[0] == 0x00 && enaddr[1] == 0x03 && enaddr[2] == 0xff)
 		sc->sc_flags |= TULIPF_VPC;
 	/*
 	 * Initialize our media structures.  This may probe the MII, if
 	 * present.
 	 */
 	(*sc->sc_mediasw->tmsw_init)(sc);
 	strlcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
 	ifp->if_softc = sc;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 	sc->sc_if_flags = ifp->if_flags;
 	ifp->if_ioctl = tlp_ioctl;
 	ifp->if_start = tlp_start;
 	ifp->if_watchdog = tlp_watchdog;
 	ifp->if_init = tlp_init;
 	ifp->if_stop = tlp_stop;
 	IFQ_SET_READY(&ifp->if_snd);
 	/*
 	 * We can support 802.1Q VLAN-sized frames.
 	 */
 	sc->sc_ethercom.ec_capabilities |= ETHERCAP_VLAN_MTU;
 	/*
 	 * Attach the interface.
 	 */
 	if_attach(ifp);
 	if_deferred_start_init(ifp, NULL);
 	ether_ifattach(ifp, enaddr);
 	ether_set_ifflags_cb(&sc->sc_ethercom, tlp_ifflags_cb);
 	rnd_attach_source(&sc->sc_rnd_source, device_xname(self),
 	    RND_TYPE_NET, RND_FLAG_DEFAULT);
 	if (pmf_device_register(self, NULL, NULL))
 		pmf_class_network_register(self, ifp);
 	else
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	return 0;
 	/*
 	 * Free any resources we've allocated during the failed attach
 	 * attempt.  Do this in reverse order and fall through.
 	 */
  fail_5:
 	for (i = 0; i < TULIP_NRXDESC; i++) {
 		if (sc->sc_rxsoft[i].rxs_dmamap != NULL)
 			bus_dmamap_destroy(sc->sc_dmat,
 			    sc->sc_rxsoft[i].rxs_dmamap);
+	}
  fail_4:
 	for (i = 0; i < TULIP_TXQUEUELEN; i++) {
 		if (sc->sc_txsoft[i].txs_dmamap != NULL)
 			bus_dmamap_destroy(sc->sc_dmat,
 			    sc->sc_txsoft[i].txs_dmamap);
+	}
 	bus_dmamap_unload(sc->sc_dmat, sc->sc_cddmamap);
  fail_3:
 	bus_dmamap_destroy(sc->sc_dmat, sc->sc_cddmamap);
  fail_2:
 	bus_dmamem_unmap(sc->sc_dmat, (void *)sc->sc_control_data,
 	    sizeof(struct tulip_control_data));
  fail_1:
 	bus_dmamem_free(sc->sc_dmat, &sc->sc_cdseg, sc->sc_cdnseg);
  fail_0:
 	return error;
+}
 /*
  * tlp_activate:
+ *
  *	Handle device activation/deactivation requests.
  */
 int
 tlp_activate(device_t self, enum devact act)
+{
 	struct tulip_softc *sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		if_deactivate(&sc->sc_ethercom.ec_if);
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 /*
  * tlp_detach:
+ *
  *	Detach a Tulip interface.
  */
 int
 tlp_detach(struct tulip_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct tulip_rxsoft *rxs;
 	struct tulip_txsoft *txs;
 	device_t self = sc->sc_dev;
 	int i, s;
 	/*
 	 * Succeed now if there isn't any work to do.
 	 */
 	if ((sc->sc_flags & TULIPF_ATTACHED) == 0)
 		return 0;
 	s = splnet();
 	/* Stop the interface. Callouts are stopped in it. */
 	tlp_stop(ifp, 1);
 	splx(s);
 	/* Destroy our callouts. */
 	callout_destroy(&sc->sc_nway_callout);
 	callout_destroy(&sc->sc_tick_callout);
 	if (sc->sc_flags & TULIPF_HAS_MII) {
 		/* Detach all PHYs */
 		mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
+	}
 	/* Delete all remaining media. */
 	ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
 	rnd_detach_source(&sc->sc_rnd_source);
 	ether_ifdetach(ifp);
 	if_detach(ifp);
 	for (i = 0; i < TULIP_NRXDESC; i++) {
 		rxs = &sc->sc_rxsoft[i];
 		if (rxs->rxs_mbuf != NULL) {
 			bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
 			m_freem(rxs->rxs_mbuf);
 			rxs->rxs_mbuf = NULL;
+		}
 		bus_dmamap_destroy(sc->sc_dmat, rxs->rxs_dmamap);
+	}
 	for (i = 0; i < TULIP_TXQUEUELEN; i++) {
 		txs = &sc->sc_txsoft[i];
 		if (txs->txs_mbuf != NULL) {
 			bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);
 			m_freem(txs->txs_mbuf);
 			txs->txs_mbuf = NULL;
+		}
 		bus_dmamap_destroy(sc->sc_dmat, txs->txs_dmamap);
+	}
 	bus_dmamap_unload(sc->sc_dmat, sc->sc_cddmamap);
 	bus_dmamap_destroy(sc->sc_dmat, sc->sc_cddmamap);
 	bus_dmamem_unmap(sc->sc_dmat, (void *)sc->sc_control_data,
 	    sizeof(struct tulip_control_data));
 	bus_dmamem_free(sc->sc_dmat, &sc->sc_cdseg, sc->sc_cdnseg);
 	pmf_device_deregister(self);
 	if (sc->sc_srom)
 		free(sc->sc_srom, M_DEVBUF);
 	return 0;
+}
 /*
  * tlp_start:		[ifnet interface function]
+ *
  *	Start packet transmission on the interface.
  */
 static void
 tlp_start(struct ifnet *ifp)
+{
 	struct tulip_softc *sc = ifp->if_softc;
 	struct mbuf *m0, *m;
 	struct tulip_txsoft *txs, *last_txs = NULL;
 	bus_dmamap_t dmamap;
 	int error, firsttx, nexttx, lasttx = 1, ofree, seg;
 	struct tulip_desc *txd;
 	DPRINTF(sc, ("%s: tlp_start: sc_flags 0x%08x, if_flags 0x%08x\n",
 	    device_xname(sc->sc_dev), sc->sc_flags, ifp->if_flags));
 	/*
 	 * If we want a filter setup, it means no more descriptors were
 	 * available for the setup routine.  Let it get a chance to wedge
 	 * itself into the ring.
 	 */
 	if (sc->sc_flags & TULIPF_WANT_SETUP)
 		ifp->if_flags |= IFF_OACTIVE;
 	if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
 		return;
 	if (sc->sc_tick == tlp_2114x_nway_tick &&
 	    (sc->sc_flags & TULIPF_LINK_UP) == 0 && ifp->if_snd.ifq_len < 10)
 		return;
 	/*
 	 * Remember the previous number of free descriptors and
 	 * the first descriptor we'll use.
 	 */
 	ofree = sc->sc_txfree;
 	firsttx = sc->sc_txnext;
 	DPRINTF(sc, ("%s: tlp_start: txfree %d, txnext %d\n",
 	    device_xname(sc->sc_dev), ofree, firsttx));
 	/*
 	 * Loop through the send queue, setting up transmit descriptors
 	 * until we drain the queue, or use up all available transmit
 	 * descriptors.
 	 */
 	while ((txs = SIMPLEQ_FIRST(&sc->sc_txfreeq)) != NULL &&
 	       sc->sc_txfree != 0) {
 		/*
 		 * Grab a packet off the queue.
 		 */
 		IFQ_POLL(&ifp->if_snd, m0);
 		if (m0 == NULL)
 			break;
 		m = NULL;
 		dmamap = txs->txs_dmamap;
 		/*
 		 * Load the DMA map.  If this fails, the packet either
 		 * didn't fit in the alloted number of segments, or we were
 		 * short on resources.  In this case, we'll copy and try
 		 * again.
+		 *
 		 * Note that if we're only allowed 1 Tx segment, we
 		 * have an alignment restriction.  Do this test before
 		 * attempting to load the DMA map, because it's more
 		 * likely we'll trip the alignment test than the
 		 * more-than-one-segment test.
 		 */
 		if ((sc->sc_ntxsegs == 1 && (mtod(m0, uintptr_t) & 3) != 0) ||
 		    bus_dmamap_load_mbuf(sc->sc_dmat, dmamap, m0,
 		      BUS_DMA_WRITE | BUS_DMA_NOWAIT) != 0) {
 			MGETHDR(m, M_DONTWAIT, MT_DATA);
 			if (m == NULL) {
 				aprint_error_dev(sc->sc_dev, "unable to allocate Tx mbuf\n");
 				break;
+			}
 			MCLAIM(m, &sc->sc_ethercom.ec_tx_mowner);
 			if (m0->m_pkthdr.len > MHLEN) {
 				MCLGET(m, M_DONTWAIT);
 				if ((m->m_flags & M_EXT) == 0) {
 					aprint_error_dev(sc->sc_dev,
 					    "unable to allocate Tx cluster\n");
 					m_freem(m);
 					break;
+				}
+			}
 			m_copydata(m0, 0, m0->m_pkthdr.len, mtod(m, void *));
 			m->m_pkthdr.len = m->m_len = m0->m_pkthdr.len;
 			error = bus_dmamap_load_mbuf(sc->sc_dmat, dmamap,
 			    m, BUS_DMA_WRITE | BUS_DMA_NOWAIT);
 			if (error) {
 				aprint_error_dev(sc->sc_dev,
 				    "unable to load Tx buffer, error = %d",
 				    error);
 				break;
+			}
+		}
 		/*
 		 * Ensure we have enough descriptors free to describe
 		 * the packet.
 		 */
 		if (dmamap->dm_nsegs > sc->sc_txfree) {
 			/*
 			 * Not enough free descriptors to transmit this
 			 * packet.  We haven't committed to anything yet,
 			 * so just unload the DMA map, put the packet
 			 * back on the queue, and punt.  Notify the upper
 			 * layer that there are no more slots left.
+			 *
 			 * XXX We could allocate an mbuf and copy, but
 			 * XXX it is worth it?
 			 */
 			ifp->if_flags |= IFF_OACTIVE;
 			bus_dmamap_unload(sc->sc_dmat, dmamap);
 			if (m != NULL)
 				m_freem(m);
 			break;
+		}
 		IFQ_DEQUEUE(&ifp->if_snd, m0);
 		if (m != NULL) {
 			m_freem(m0);
 			m0 = m;
+		}
 		/*
 		 * WE ARE NOW COMMITTED TO TRANSMITTING THE PACKET.
 		 */
 		/* Sync the DMA map. */
 		bus_dmamap_sync(sc->sc_dmat, dmamap, 0, dmamap->dm_mapsize,
 		    BUS_DMASYNC_PREWRITE);
 		/*
 		 * Initialize the transmit descriptors.
 		 */
 		for (nexttx = sc->sc_txnext, seg = 0;
 		     seg < dmamap->dm_nsegs;
 		     seg++, nexttx = TULIP_NEXTTX(nexttx)) {
 			/*
 			 * If this is the first descriptor we're
 			 * enqueueing, don't set the OWN bit just
 			 * yet.  That could cause a race condition.
 			 * We'll do it below.
 			 */
 			txd = &sc->sc_txdescs[nexttx];
 			txd->td_status =
 			    (nexttx == firsttx) ? 0 : htole32(TDSTAT_OWN);
 			txd->td_bufaddr1 =
 			    htole32(dmamap->dm_segs[seg].ds_addr);
 			txd->td_ctl =
 			    htole32((dmamap->dm_segs[seg].ds_len <<
 				TDCTL_SIZE1_SHIFT) | sc->sc_tdctl_ch |
 				(nexttx == (TULIP_NTXDESC - 1) ?
 				 sc->sc_tdctl_er : 0));
 			lasttx = nexttx;
+		}
 		KASSERT(lasttx != -1);
 		/* Set `first segment' and `last segment' appropriately. */
 		sc->sc_txdescs[sc->sc_txnext].td_ctl |= htole32(TDCTL_Tx_FS);
 		sc->sc_txdescs[lasttx].td_ctl |= htole32(TDCTL_Tx_LS);
 #ifdef TLP_DEBUG
 		if (ifp->if_flags & IFF_DEBUG) {
 			printf("     txsoft %p transmit chain:\n", txs);
 			for (seg = sc->sc_txnext;; seg = TULIP_NEXTTX(seg)) {
 				txd = &sc->sc_txdescs[seg];
 				printf("     descriptor %d:\n", seg);
 				printf("       td_status:   0x%08x\n",
 				    le32toh(txd->td_status));
 				printf("       td_ctl:      0x%08x\n",
 				    le32toh(txd->td_ctl));
 				printf("       td_bufaddr1: 0x%08x\n",
 				    le32toh(txd->td_bufaddr1));
 				printf("       td_bufaddr2: 0x%08x\n",
 				    le32toh(txd->td_bufaddr2));
 				if (seg == lasttx)
 					break;
+			}
+		}
 #endif
 		/* Sync the descriptors we're using. */
 		TULIP_CDTXSYNC(sc, sc->sc_txnext, dmamap->dm_nsegs,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 		/*
 		 * Store a pointer to the packet so we can free it later,
 		 * and remember what txdirty will be once the packet is
 		 * done.
 		 */
 		txs->txs_mbuf = m0;
 		txs->txs_firstdesc = sc->sc_txnext;
 		txs->txs_lastdesc = lasttx;
 		txs->txs_ndescs = dmamap->dm_nsegs;
 		/* Advance the tx pointer. */
 		sc->sc_txfree -= dmamap->dm_nsegs;
 		sc->sc_txnext = nexttx;
 		SIMPLEQ_REMOVE_HEAD(&sc->sc_txfreeq, txs_q);
 		SIMPLEQ_INSERT_TAIL(&sc->sc_txdirtyq, txs, txs_q);
 		last_txs = txs;
 		/*
 		 * Pass the packet to any BPF listeners.
 		 */
 		bpf_mtap(ifp, m0, BPF_D_OUT);
+	}
 	if (txs == NULL || sc->sc_txfree == 0) {
 		/* No more slots left; notify upper layer. */
 		ifp->if_flags |= IFF_OACTIVE;
+	}
 	if (sc->sc_txfree != ofree) {
 		DPRINTF(sc, ("%s: packets enqueued, IC on %d, OWN on %d\n",
 		    device_xname(sc->sc_dev), lasttx, firsttx));
 		/*
 		 * Cause a transmit interrupt to happen on the
 		 * last packet we enqueued.
 		 */
 		sc->sc_txdescs[lasttx].td_ctl |= htole32(TDCTL_Tx_IC);
 		TULIP_CDTXSYNC(sc, lasttx, 1,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 		/*
 		 * Some clone chips want IC on the *first* segment in
 		 * the packet.  Appease them.
 		 */
 		KASSERT(last_txs != NULL);
 		if ((sc->sc_flags & TULIPF_IC_FS) != 0 &&
 		    last_txs->txs_firstdesc != lasttx) {
 			sc->sc_txdescs[last_txs->txs_firstdesc].td_ctl |=
 			    htole32(TDCTL_Tx_IC);
 			TULIP_CDTXSYNC(sc, last_txs->txs_firstdesc, 1,
 			    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
+		}
 		/*
 		 * The entire packet chain is set up.  Give the
 		 * first descriptor to the chip now.
 		 */
 		sc->sc_txdescs[firsttx].td_status |= htole32(TDSTAT_OWN);
 		TULIP_CDTXSYNC(sc, firsttx, 1,
 		    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 		/* Wake up the transmitter. */
 		/* XXX USE AUTOPOLLING? */
 		TULIP_WRITE(sc, CSR_TXPOLL, TXPOLL_TPD);
 		/* Set a watchdog timer in case the chip flakes out. */
 		ifp->if_timer = 5;
+	}
+}
 /*
  * tlp_watchdog:	[ifnet interface function]
+ *
  *	Watchdog timer handler.
  */
 static void
 tlp_watchdog(struct ifnet *ifp)
+{
 	struct tulip_softc *sc = ifp->if_softc;
 	int doing_setup, doing_transmit;
 	doing_setup = (sc->sc_flags & TULIPF_DOING_SETUP);
 	doing_transmit = (! SIMPLEQ_EMPTY(&sc->sc_txdirtyq));
 	if (doing_setup && doing_transmit) {
 		printf("%s: filter setup and transmit timeout\n",
 		    device_xname(sc->sc_dev));
-		ifp->if_oerrors++;
+		if_statinc(ifp, if_oerrors);
 	} else if (doing_transmit) {
 		printf("%s: transmit timeout\n", device_xname(sc->sc_dev));
-		ifp->if_oerrors++;
+		if_statinc(ifp, if_oerrors);
 	} else if (doing_setup)
 		printf("%s: filter setup timeout\n", device_xname(sc->sc_dev));
 	else
 		printf("%s: spurious watchdog timeout\n",
 		    device_xname(sc->sc_dev));
 	(void) tlp_init(ifp);
 	/* Try to get more packets going. */
 	tlp_start(ifp);
+}
 /* If the interface is up and running, only modify the receive
  * filter when setting promiscuous or debug mode.  Otherwise fall
  * through to ether_ioctl, which will reset the chip.
  */
 static int
 tlp_ifflags_cb(struct ethercom *ec)
+{
 	struct ifnet *ifp = &ec->ec_if;
 	struct tulip_softc *sc = ifp->if_softc;
 	u_short change = ifp->if_flags ^ sc->sc_if_flags;
 	if ((change & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0)
 		return ENETRESET;
 	if ((change & IFF_PROMISC) != 0)
 		(*sc->sc_filter_setup)(sc);
 	return 0;
+}
 /*
  * tlp_ioctl:		[ifnet interface function]
+ *
  *	Handle control requests from the operator.
  */
 static int
 tlp_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct tulip_softc *sc = ifp->if_softc;
 	int s, error;
 	s = splnet();
 	switch (cmd) {
 	default:
 		error = ether_ioctl(ifp, cmd, data);
 		if (error == ENETRESET) {
 			if (ifp->if_flags & IFF_RUNNING) {
 				/*
 				 * Multicast list has changed.  Set the
 				 * hardware filter accordingly.
 				 */
 				(*sc->sc_filter_setup)(sc);
+			}
 			error = 0;
+		}
 		break;
+	}
 	/* Try to get more packets going. */
 	if (TULIP_IS_ENABLED(sc))
 		tlp_start(ifp);
 	sc->sc_if_flags = ifp->if_flags;
 	splx(s);
 	return error;
+}
 /*
  * tlp_intr:
+ *
  *	Interrupt service routine.
  */
 int
 tlp_intr(void *arg)
+{
 	struct tulip_softc *sc = arg;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	uint32_t status, rxstatus, txstatus;
 	int handled = 0, txthresh;
 	DPRINTF(sc, ("%s: tlp_intr\n", device_xname(sc->sc_dev)));
 #ifdef DEBUG
 	if (TULIP_IS_ENABLED(sc) == 0)
 		panic("%s: tlp_intr: not enabled", device_xname(sc->sc_dev));
 #endif
 	/*
 	 * If the interface isn't running, the interrupt couldn't
 	 * possibly have come from us.
 	 */
 	if ((ifp->if_flags & IFF_RUNNING) == 0 ||
 	    !device_is_active(sc->sc_dev))
 		return 0;
 	/* Disable interrupts on the DM9102 (interrupt edge bug). */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 		TULIP_WRITE(sc, CSR_INTEN, 0);
 		break;
 	default:
 		/* Nothing. */
 		break;
+	}
 	for (;;) {
 		status = TULIP_READ(sc, CSR_STATUS);
 		if (status)
 			TULIP_WRITE(sc, CSR_STATUS, status);
 		if ((status & sc->sc_inten) == 0)
 			break;
 		handled = 1;
 		rxstatus = status & sc->sc_rxint_mask;
 		txstatus = status & sc->sc_txint_mask;
 		if (rxstatus) {
 			/* Grab new any new packets. */
 			tlp_rxintr(sc);
 			if (rxstatus & STATUS_RWT)
 				printf("%s: receive watchdog timeout\n",
 				    device_xname(sc->sc_dev));
 			if (rxstatus & STATUS_RU) {
 				printf("%s: receive ring overrun\n",
 				    device_xname(sc->sc_dev));
 				/* Get the receive process going again. */
 				if (sc->sc_tdctl_er != TDCTL_ER) {
 					tlp_idle(sc, OPMODE_SR);
 					TULIP_WRITE(sc, CSR_RXLIST,
 					    TULIP_CDRXADDR(sc, sc->sc_rxptr));
 					TULIP_WRITE(sc, CSR_OPMODE,
 					    sc->sc_opmode);
+				}
 				TULIP_WRITE(sc, CSR_RXPOLL, RXPOLL_RPD);
 				break;
+			}
+		}
 		if (txstatus) {
 			/* Sweep up transmit descriptors. */
 			tlp_txintr(sc);
 			if (txstatus & STATUS_TJT)
 				printf("%s: transmit jabber timeout\n",
 				    device_xname(sc->sc_dev));
 			if (txstatus & STATUS_UNF) {
 				/*
 				 * Increase our transmit threshold if
 				 * another is available.
 				 */
 				txthresh = sc->sc_txthresh + 1;
 				if (sc->sc_txth[txthresh].txth_name != NULL) {
 					/* Idle the transmit process. */
 					tlp_idle(sc, OPMODE_ST);
 					sc->sc_txthresh = txthresh;
 					sc->sc_opmode &= ~(OPMODE_TR|OPMODE_SF);
 					sc->sc_opmode |=
 					    sc->sc_txth[txthresh].txth_opmode;
 					printf("%s: transmit underrun; new "
 					    "threshold: %s\n",
 					    device_xname(sc->sc_dev),
 					    sc->sc_txth[txthresh].txth_name);
 					/*
 					 * Set the new threshold and restart
 					 * the transmit process.
 					 */
 					TULIP_WRITE(sc, CSR_OPMODE,
 					    sc->sc_opmode);
+				}
 					/*
 					 * XXX Log every Nth underrun from
 					 * XXX now on?
 					 */
+			}
+		}
 		if (status & (STATUS_TPS | STATUS_RPS)) {
 			if (status & STATUS_TPS)
 				printf("%s: transmit process stopped\n",
 				    device_xname(sc->sc_dev));
 			if (status & STATUS_RPS)
 				printf("%s: receive process stopped\n",
 				    device_xname(sc->sc_dev));
 			(void) tlp_init(ifp);
 			break;
+		}
 		if (status & STATUS_SE) {
 			const char *str;
 			switch (status & STATUS_EB) {
 			case STATUS_EB_PARITY:
 				str = "parity error";
 				break;
 			case STATUS_EB_MABT:
 				str = "master abort";
 				break;
 			case STATUS_EB_TABT:
 				str = "target abort";
 				break;
 			default:
 				str = "unknown error";
 				break;
+			}
 			aprint_error_dev(sc->sc_dev,
 			    "fatal system error: %s\n", str);
 			(void) tlp_init(ifp);
 			break;
+		}
 		/*
 		 * Not handled:
+		 *
 		 *	Transmit buffer unavailable -- normal
 		 *	condition, nothing to do, really.
+		 *
 		 *	General purpose timer experied -- we don't
 		 *	use the general purpose timer.
+		 *
 		 *	Early receive interrupt -- not available on
 		 *	all chips, we just use RI.  We also only
 		 *	use single-segment receive DMA, so this
 		 *	is mostly useless.
 		 */
+	}
 	/* Bring interrupts back up on the DM9102. */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 		TULIP_WRITE(sc, CSR_INTEN, sc->sc_inten);
 		break;
 	default:
 		/* Nothing. */
 		break;
+	}
 	/* Try to get more packets going. */
 	if_schedule_deferred_start(ifp);
 	if (handled)
 		rnd_add_uint32(&sc->sc_rnd_source, status);
 	return handled;
+}
 /*
  * tlp_rxintr:
+ *
  *	Helper; handle receive interrupts.
  */
 static void
 tlp_rxintr(struct tulip_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct ether_header *eh;
 	struct tulip_rxsoft *rxs;
 	struct mbuf *m;
 	uint32_t rxstat, errors;
 	int i, len;
 	for (i = sc->sc_rxptr;; i = TULIP_NEXTRX(i)) {
 		rxs = &sc->sc_rxsoft[i];
 		TULIP_CDRXSYNC(sc, i,
 		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 		rxstat = le32toh(sc->sc_rxdescs[i].td_status);
 		if (rxstat & TDSTAT_OWN) {
 			/*
 			 * We have processed all of the receive buffers.
 			 */
 			break;
+		}
 		/*
 		 * Make sure the packet fit in one buffer.  This should
 		 * always be the case.  But the Lite-On PNIC, rev 33
 		 * has an awful receive engine bug, which may require
 		 * a very icky work-around.
 		 */
 		if ((rxstat & (TDSTAT_Rx_FS | TDSTAT_Rx_LS)) !=
 		    (TDSTAT_Rx_FS | TDSTAT_Rx_LS)) {
 			printf("%s: incoming packet spilled, resetting\n",
 			    device_xname(sc->sc_dev));
 			(void) tlp_init(ifp);
 			return;
+		}
 		/*
 		 * If any collisions were seen on the wire, count one.
 		 */
 		if (rxstat & TDSTAT_Rx_CS)
-			ifp->if_collisions++;
+			if_statinc(ifp, if_collisions);
 		/*
 		 * If an error occurred, update stats, clear the status
 		 * word, and leave the packet buffer in place.  It will
 		 * simply be reused the next time the ring comes around.
 		 */
 		errors = TDSTAT_Rx_DE | TDSTAT_Rx_RF | TDSTAT_Rx_TL |
 		    TDSTAT_Rx_CS | TDSTAT_Rx_RE | TDSTAT_Rx_DB | TDSTAT_Rx_CE;
 		/*
 	 	 * If 802.1Q VLAN MTU is enabled, ignore the Frame Too Long
 		 * error.
 		 */
 		if ((sc->sc_ethercom.ec_capenable & ETHERCAP_VLAN_MTU) != 0)
 			errors &= ~TDSTAT_Rx_TL;
 		/*
 		 * If chip doesn't have MII, ignore the MII error bit.
 		 */
 		if ((sc->sc_flags & TULIPF_HAS_MII) == 0)
 			errors &= ~TDSTAT_Rx_RE;
 		if ((rxstat & TDSTAT_ES) != 0 &&
 		    (rxstat & errors) != 0) {
 			rxstat &= errors;
 #define	PRINTERR(bit, str)						\
 			if (rxstat & (bit))				\
 				aprint_error_dev(sc->sc_dev,		\
 				    "receive error: %s\n", str)
-			ifp->if_ierrors++;
+			if_statinc(ifp, if_ierrors);
 			PRINTERR(TDSTAT_Rx_DE, "descriptor error");
 			PRINTERR(TDSTAT_Rx_RF, "runt frame");
 			PRINTERR(TDSTAT_Rx_TL, "frame too long");
 			PRINTERR(TDSTAT_Rx_RE, "MII error");
 			PRINTERR(TDSTAT_Rx_DB, "dribbling bit");
 			PRINTERR(TDSTAT_Rx_CE, "CRC error");
 #undef PRINTERR
 			TULIP_INIT_RXDESC(sc, i);
 			continue;
+		}
 		bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
 		    rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
 		/*
 		 * No errors; receive the packet.  Note the Tulip
 		 * includes the CRC with every packet.
 		 */
 		len = TDSTAT_Rx_LENGTH(rxstat) - ETHER_CRC_LEN;
 #ifdef __NO_STRICT_ALIGNMENT
 		/*
 		 * Allocate a new mbuf cluster.  If that fails, we are
 		 * out of memory, and must drop the packet and recycle
 		 * the buffer that's already attached to this descriptor.
 		 */
 		m = rxs->rxs_mbuf;
 		if (tlp_add_rxbuf(sc, i) != 0) {
-			ifp->if_ierrors++;
+			if_statinc(ifp, if_ierrors);
 			TULIP_INIT_RXDESC(sc, i);
 			bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
 			    rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
 			continue;
+		}
 #else
 		/*
 		 * The Tulip's receive buffers must be 4-byte aligned.
 		 * But this means that the data after the Ethernet header
 		 * is misaligned.  We must allocate a new buffer and
 		 * copy the data, shifted forward 2 bytes.
 		 */
 		MGETHDR(m, M_DONTWAIT, MT_DATA);
 		if (m == NULL) {
  dropit:
-			ifp->if_ierrors++;
+			if_statinc(ifp, if_ierrors);
 			TULIP_INIT_RXDESC(sc, i);
 			bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
 			    rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
 			continue;
+		}
 		MCLAIM(m, &sc->sc_ethercom.ec_rx_mowner);
 		if (len > (MHLEN - 2)) {
 			MCLGET(m, M_DONTWAIT);
 			if ((m->m_flags & M_EXT) == 0) {
 				m_freem(m);
 				goto dropit;
+			}
+		}
 		m->m_data += 2;
 		/*
 		 * Note that we use clusters for incoming frames, so the
 		 * buffer is virtually contiguous.
 		 */
 		memcpy(mtod(m, void *), mtod(rxs->rxs_mbuf, void *), len);
 		/* Allow the receive descriptor to continue using its mbuf. */
 		TULIP_INIT_RXDESC(sc, i);
 		bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
 		    rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
 #endif /* __NO_STRICT_ALIGNMENT */
 		eh = mtod(m, struct ether_header *);
 		m_set_rcvif(m, ifp);
 		m->m_pkthdr.len = m->m_len = len;
 		/*
 		 * XXX Work-around for a weird problem with the emulated
 		 * 21041 on Connectix Virtual PC:
+		 *
 		 * When we receive a full-size TCP segment, we seem to get
 		 * a packet there the Rx status says 1522 bytes, yet we do
 		 * not get a frame-too-long error from the chip.  The extra
 		 * bytes seem to always be zeros.  Perhaps Virtual PC is
 		 * inserting 4 bytes of zeros after every packet.  In any
 		 * case, let's try and detect this condition and truncate
 		 * the length so that it will pass up the stack.
 		 */
 		if (__predict_false((sc->sc_flags & TULIPF_VPC) != 0)) {
 			uint16_t etype = ntohs(eh->ether_type);
 			if (len > ETHER_MAX_FRAME(ifp, etype, 0))
 				m->m_pkthdr.len = m->m_len = len =
 				    ETHER_MAX_FRAME(ifp, etype, 0);
+		}
 		/*
 		 * We sometimes have to run the 21140 in Hash-Only
 		 * mode.  If we're in that mode, and not in promiscuous
 		 * mode, and we have a unicast packet that isn't for
 		 * us, then drop it.
 		 */
 		if (sc->sc_filtmode == TDCTL_Tx_FT_HASHONLY &&
 		    (ifp->if_flags & IFF_PROMISC) == 0 &&
 		    ETHER_IS_MULTICAST(eh->ether_dhost) == 0 &&
 		    memcmp(CLLADDR(ifp->if_sadl), eh->ether_dhost,
 			   ETHER_ADDR_LEN) != 0) {
 			m_freem(m);
 			continue;
+		}
 		/* Pass it on. */
 		if_percpuq_enqueue(ifp->if_percpuq, m);
+	}
 	/* Update the receive pointer. */
 	sc->sc_rxptr = i;
+}
 /*
  * tlp_txintr:
+ *
  *	Helper; handle transmit interrupts.
  */
 static void
 tlp_txintr(struct tulip_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct tulip_txsoft *txs;
 	uint32_t txstat;
 	DPRINTF(sc, ("%s: tlp_txintr: sc_flags 0x%08x\n",
 	    device_xname(sc->sc_dev), sc->sc_flags));
 	ifp->if_flags &= ~IFF_OACTIVE;
 	/*
 	 * Go through our Tx list and free mbufs for those
 	 * frames that have been transmitted.
 	 */
 	while ((txs = SIMPLEQ_FIRST(&sc->sc_txdirtyq)) != NULL) {
 		TULIP_CDTXSYNC(sc, txs->txs_lastdesc, txs->txs_ndescs,
 		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 #ifdef TLP_DEBUG
 		if (ifp->if_flags & IFF_DEBUG) {
 			int i;
 			struct tulip_desc *txd;
 			printf("    txsoft %p transmit chain:\n", txs);
 			for (i = txs->txs_firstdesc;; i = TULIP_NEXTTX(i)) {
 				txd = &sc->sc_txdescs[i];
 				printf("     descriptor %d:\n", i);
 				printf("       td_status:   0x%08x\n",
 				    le32toh(txd->td_status));
 				printf("       td_ctl:      0x%08x\n",
 				    le32toh(txd->td_ctl));
 				printf("       td_bufaddr1: 0x%08x\n",
 				    le32toh(txd->td_bufaddr1));
 				printf("       td_bufaddr2: 0x%08x\n",
 				    le32toh(sc->sc_txdescs[i].td_bufaddr2));
 				if (i == txs->txs_lastdesc)
 					break;
+			}
+		}
 #endif
 		txstat = le32toh(sc->sc_txdescs[txs->txs_lastdesc].td_status);
 		if (txstat & TDSTAT_OWN)
 			break;
 		SIMPLEQ_REMOVE_HEAD(&sc->sc_txdirtyq, txs_q);
 		sc->sc_txfree += txs->txs_ndescs;
 		if (txs->txs_mbuf == NULL) {
 			/*
 			 * If we didn't have an mbuf, it was the setup
 			 * packet.
 			 */
 #ifdef DIAGNOSTIC
 			if ((sc->sc_flags & TULIPF_DOING_SETUP) == 0)
 				panic("tlp_txintr: null mbuf, not doing setup");
 #endif
 			TULIP_CDSPSYNC(sc, BUS_DMASYNC_POSTWRITE);
 			sc->sc_flags &= ~TULIPF_DOING_SETUP;
 			SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
 			continue;
+		}
 		bus_dmamap_sync(sc->sc_dmat, txs->txs_dmamap,
 , txs->txs_dmamap->dm_mapsize,
 		    BUS_DMASYNC_POSTWRITE);
 		bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);
 		m_freem(txs->txs_mbuf);
 		txs->txs_mbuf = NULL;
 		SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
 		/*
 		 * Check for errors and collisions.
 		 */
 #ifdef TLP_STATS
 		if (txstat & TDSTAT_Tx_UF)
 			sc->sc_stats.ts_tx_uf++;
 		if (txstat & TDSTAT_Tx_TO)
 			sc->sc_stats.ts_tx_to++;
 		if (txstat & TDSTAT_Tx_EC)
 			sc->sc_stats.ts_tx_ec++;
 		if (txstat & TDSTAT_Tx_LC)
 			sc->sc_stats.ts_tx_lc++;
 #endif
 		net_stat_ref_t nsr = IF_STAT_GETREF(ifp);
 		if (txstat & (TDSTAT_Tx_UF | TDSTAT_Tx_TO))
-			ifp->if_oerrors++;
+			if_statinc_ref(nsr, if_oerrors);
 		if (txstat & TDSTAT_Tx_EC)
-			ifp->if_collisions += 16;
+			if_statadd_ref(nsr, if_collisions, 16);
 		else
-			ifp->if_collisions += TDSTAT_Tx_COLLISIONS(txstat);
+			if_statadd_ref(nsr, if_collisions,
 			    TDSTAT_Tx_COLLISIONS(txstat));
 		if (txstat & TDSTAT_Tx_LC)
-			ifp->if_collisions++;
+			if_statinc_ref(nsr, if_collisions);
-		ifp->if_opackets++;
+		if_statinc_ref(nsr, if_opackets);
 		IF_STAT_PUTREF(ifp);
+	}
 	/*
 	 * If there are no more pending transmissions, cancel the watchdog
 	 * timer.
 	 */
 	if (txs == NULL && (sc->sc_flags & TULIPF_DOING_SETUP) == 0)
 		ifp->if_timer = 0;
 	/*
 	 * If we have a receive filter setup pending, do it now.
 	 */
 	if (sc->sc_flags & TULIPF_WANT_SETUP)
 		(*sc->sc_filter_setup)(sc);
+}
 #ifdef TLP_STATS
 void
 tlp_print_stats(struct tulip_softc *sc)
+{
 	printf("%s: tx_uf %lu, tx_to %lu, tx_ec %lu, tx_lc %lu\n",
 	    device_xname(sc->sc_dev),
 	    sc->sc_stats.ts_tx_uf, sc->sc_stats.ts_tx_to,
 	    sc->sc_stats.ts_tx_ec, sc->sc_stats.ts_tx_lc);
+}
 #endif
 /*
  * tlp_reset:
+ *
  *	Perform a soft reset on the Tulip.
  */
 void
 tlp_reset(struct tulip_softc *sc)
+{
 	int i;
 	TULIP_WRITE(sc, CSR_BUSMODE, BUSMODE_SWR);
 	/*
 	 * Xircom, ASIX and Conexant clones don't bring themselves
 	 * out of reset automatically.
 	 * Instead, we have to wait at least 50 PCI cycles, and then
 	 * clear SWR.
 	 */
 	switch (sc->sc_chip) {
 		case TULIP_CHIP_X3201_3:
 		case TULIP_CHIP_AX88140:
 		case TULIP_CHIP_AX88141:
 		case TULIP_CHIP_RS7112:
 			delay(10);
 			TULIP_WRITE(sc, CSR_BUSMODE, 0);
 			break;
 		default:
 			break;
+	}
 	for (i = 0; i < 1000; i++) {
 		/*
 		 * Wait at least 50 PCI cycles for the reset to
 		 * complete before peeking at the Tulip again.
 		 * 10 uSec is a bit longer than 50 PCI cycles
 		 * (at 33MHz), but it doesn't hurt have the extra
 		 * wait.
 		 */
 		delay(10);
 		if (TULIP_ISSET(sc, CSR_BUSMODE, BUSMODE_SWR) == 0)
 			break;
+	}
 	if (TULIP_ISSET(sc, CSR_BUSMODE, BUSMODE_SWR))
 		aprint_error_dev(sc->sc_dev, "reset failed to complete\n");
 	delay(1000);
 	/*
 	 * If the board has any GPIO reset sequences to issue, do them now.
 	 */
 	if (sc->sc_reset != NULL)
 		(*sc->sc_reset)(sc);
+}
 /*
  * tlp_init:		[ ifnet interface function ]
+ *
  *	Initialize the interface.  Must be called at splnet().
  */
 static int
 tlp_init(struct ifnet *ifp)
+{
 	struct tulip_softc *sc = ifp->if_softc;
 	struct tulip_txsoft *txs;
 	struct tulip_rxsoft *rxs;
 	int i, error = 0;
 	if ((error = tlp_enable(sc)) != 0)
 		goto out;
 	/*
 	 * Cancel any pending I/O.
 	 */
 	tlp_stop(ifp, 0);
 	/*
 	 * Initialize `opmode' to 0, and call the pre-init routine, if
 	 * any.  This is required because the 2114x and some of the
 	 * clones require that the media-related bits in `opmode' be
 	 * set before performing a soft-reset in order to get internal
 	 * chip pathways are correct.  Yay!
 	 */
 	sc->sc_opmode = 0;
 	if (sc->sc_preinit != NULL)
 		(*sc->sc_preinit)(sc);
 	/*
 	 * Reset the Tulip to a known state.
 	 */
 	tlp_reset(sc);
 	/*
 	 * Initialize the BUSMODE register.
 	 */
 	sc->sc_busmode = BUSMODE_BAR;
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_21140:
 	case TULIP_CHIP_21140A:
 	case TULIP_CHIP_21142:
 	case TULIP_CHIP_21143:
 	case TULIP_CHIP_82C115:
 	case TULIP_CHIP_MX98725:
 		/*
 		 * If we're allowed to do so, use Memory Read Line
 		 * and Memory Read Multiple.
+		 *
 		 * XXX Should we use Memory Write and Invalidate?
 		 */
 		if (sc->sc_flags & TULIPF_MRL)
 			sc->sc_busmode |= BUSMODE_RLE;
 		if (sc->sc_flags & TULIPF_MRM)
 			sc->sc_busmode |= BUSMODE_RME;
 #if 0
 		if (sc->sc_flags & TULIPF_MWI)
 			sc->sc_busmode |= BUSMODE_WLE;
 #endif
 		break;
 	case TULIP_CHIP_82C168:
 	case TULIP_CHIP_82C169:
 		sc->sc_busmode |= BUSMODE_PNIC_MBO;
 		if (sc->sc_maxburst == 0)
 			sc->sc_maxburst = 16;
 		break;
 	case TULIP_CHIP_AX88140:
 	case TULIP_CHIP_AX88141:
 		if (sc->sc_maxburst == 0)
 			sc->sc_maxburst = 16;
 		break;
 	default:
 		/* Nothing. */
 		break;
+	}
 	switch (sc->sc_cacheline) {
 	default:
 		/*
 		 * Note: We must *always* set these bits; a cache
 		 * alignment of 0 is RESERVED.
 		 */
 	case 8:
 		sc->sc_busmode |= BUSMODE_CAL_8LW;
 		break;
 	case 16:
 		sc->sc_busmode |= BUSMODE_CAL_16LW;
 		break;
 	case 32:
 		sc->sc_busmode |= BUSMODE_CAL_32LW;
 		break;
+	}
 	switch (sc->sc_maxburst) {
 	case 1:
 		sc->sc_busmode |= BUSMODE_PBL_1LW;
 		break;
 	case 2:
 		sc->sc_busmode |= BUSMODE_PBL_2LW;
 		break;
 	case 4:
 		sc->sc_busmode |= BUSMODE_PBL_4LW;
 		break;
 	case 8:
 		sc->sc_busmode |= BUSMODE_PBL_8LW;
 		break;
 	case 16:
 		sc->sc_busmode |= BUSMODE_PBL_16LW;
 		break;
 	case 32:
 		sc->sc_busmode |= BUSMODE_PBL_32LW;
 		break;
 	default:
 		sc->sc_busmode |= BUSMODE_PBL_DEFAULT;
 		break;
+	}
 #if BYTE_ORDER == BIG_ENDIAN
 	/*
 	 * Can't use BUSMODE_BLE or BUSMODE_DBO; not all chips
 	 * support them, and even on ones that do, it doesn't
 	 * always work.  So we always access descriptors with
 	 * little endian via htole32/le32toh.
 	 */
 #endif
 	/*
 	 * Big-endian bus requires BUSMODE_BLE anyway.
 	 * Also, BUSMODE_DBO is needed because we assume
 	 * descriptors are little endian.
 	 */
 	if (sc->sc_flags & TULIPF_BLE)
 		sc->sc_busmode |= BUSMODE_BLE;
 	if (sc->sc_flags & TULIPF_DBO)
 		sc->sc_busmode |= BUSMODE_DBO;
 	/*
 	 * Some chips have a broken bus interface.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 		sc->sc_busmode = 0;
 		break;
 	default:
 		/* Nothing. */
 		break;
+	}
 	TULIP_WRITE(sc, CSR_BUSMODE, sc->sc_busmode);
 	/*
 	 * Initialize the OPMODE register.  We don't write it until
 	 * we're ready to begin the transmit and receive processes.
+	 *
 	 * Media-related OPMODE bits are set in the media callbacks
 	 * for each specific chip/board.
 	 */
 	sc->sc_opmode |= OPMODE_SR | OPMODE_ST |
 	    sc->sc_txth[sc->sc_txthresh].txth_opmode;
 	/*
 	 * Magical mystery initialization on the Macronix chips.
 	 * The MX98713 uses its own magic value, the rest share
 	 * a common one.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_MX98713:
 		TULIP_WRITE(sc, CSR_PMAC_TOR, PMAC_TOR_98713);
 		break;
 	case TULIP_CHIP_MX98713A:
 	case TULIP_CHIP_MX98715:
 	case TULIP_CHIP_MX98715A:
 	case TULIP_CHIP_MX98715AEC_X:
 	case TULIP_CHIP_MX98725:
 		TULIP_WRITE(sc, CSR_PMAC_TOR, PMAC_TOR_98715);
 		break;
 	default:
 		/* Nothing. */
 		break;
+	}
 	/*
 	 * Initialize the transmit descriptor ring.
 	 */
 	memset(sc->sc_txdescs, 0, sizeof(sc->sc_txdescs));
 	for (i = 0; i < TULIP_NTXDESC; i++) {
 		struct tulip_desc *txd = &sc->sc_txdescs[i];
 		txd->td_ctl = htole32(sc->sc_tdctl_ch);
 		txd->td_bufaddr2 = htole32(TULIP_CDTXADDR(sc, TULIP_NEXTTX(i)));
+	}
 	sc->sc_txdescs[TULIP_NTXDESC - 1].td_ctl |= htole32(sc->sc_tdctl_er);
 	TULIP_CDTXSYNC(sc, 0, TULIP_NTXDESC,
 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	sc->sc_txfree = TULIP_NTXDESC;
 	sc->sc_txnext = 0;
 	/*
 	 * Initialize the transmit job descriptors.
 	 */
 	SIMPLEQ_INIT(&sc->sc_txfreeq);
 	SIMPLEQ_INIT(&sc->sc_txdirtyq);
 	for (i = 0; i < TULIP_TXQUEUELEN; i++) {
 		txs = &sc->sc_txsoft[i];
 		txs->txs_mbuf = NULL;
 		SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
+	}
 	/*
 	 * Initialize the receive descriptor and receive job
 	 * descriptor rings.
 	 */
 	for (i = 0; i < TULIP_NRXDESC; i++) {
 		rxs = &sc->sc_rxsoft[i];
 		if (rxs->rxs_mbuf == NULL) {
 			if ((error = tlp_add_rxbuf(sc, i)) != 0) {
 				aprint_error_dev(sc->sc_dev,
 				    "unable to allocate or map rx "
 				    "buffer %d, error = %d\n", i, error);
 				/*
 				 * XXX Should attempt to run with fewer receive
 				 * XXX buffers instead of just failing.
 				 */
 				tlp_rxdrain(sc);
 				goto out;
+			}
 		} else
 			TULIP_INIT_RXDESC(sc, i);
+	}
 	sc->sc_rxptr = 0;
 	/*
 	 * Initialize the interrupt mask and enable interrupts.
 	 */
 	/* normal interrupts */
 	sc->sc_inten = STATUS_TI | STATUS_TU | STATUS_RI | STATUS_NIS;
 	/* abnormal interrupts */
 	sc->sc_inten |= STATUS_TPS | STATUS_TJT | STATUS_UNF |
 	    STATUS_RU | STATUS_RPS | STATUS_RWT | STATUS_SE | STATUS_AIS;
 	sc->sc_rxint_mask = STATUS_RI | STATUS_RU | STATUS_RWT;
 	sc->sc_txint_mask = STATUS_TI | STATUS_UNF | STATUS_TJT;
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_WB89C840F:
 		/*
 		 * Clear bits that we don't want that happen to
 		 * overlap or don't exist.
 		 */
 		sc->sc_inten &= ~(STATUS_WINB_REI | STATUS_RWT);
 		break;
 	default:
 		/* Nothing. */
 		break;
+	}
 	sc->sc_rxint_mask &= sc->sc_inten;
 	sc->sc_txint_mask &= sc->sc_inten;
 	TULIP_WRITE(sc, CSR_INTEN, sc->sc_inten);
 	TULIP_WRITE(sc, CSR_STATUS, 0xffffffff);
 	/*
 	 * Give the transmit and receive rings to the Tulip.
 	 */
 	TULIP_WRITE(sc, CSR_TXLIST, TULIP_CDTXADDR(sc, sc->sc_txnext));
 	TULIP_WRITE(sc, CSR_RXLIST, TULIP_CDRXADDR(sc, sc->sc_rxptr));
 	/*
 	 * On chips that do this differently, set the station address.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_WB89C840F:
+	    {
 		/* XXX Do this with stream writes? */
 		bus_addr_t cpa = TULIP_CSR_OFFSET(sc, CSR_WINB_CPA0);
 		for (i = 0; i < ETHER_ADDR_LEN; i++) {
 			bus_space_write_1(sc->sc_st, sc->sc_sh,
 			    cpa + i, CLLADDR(ifp->if_sadl)[i]);
+		}
 		break;
+	    }
 	case TULIP_CHIP_AL981:
 	case TULIP_CHIP_AN983:
 	case TULIP_CHIP_AN985:
+	    {
 		uint32_t reg;
 		const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
 		reg = enaddr[0] |
 		      (enaddr[1] << 8) |
 		      (enaddr[2] << 16) |
 		      (enaddr[3] << 24);
 		bus_space_write_4(sc->sc_st, sc->sc_sh, CSR_ADM_PAR0, reg);
 		reg = enaddr[4] |
 		      (enaddr[5] << 8);
 		bus_space_write_4(sc->sc_st, sc->sc_sh, CSR_ADM_PAR1, reg);
 		break;
+	    }
 	case TULIP_CHIP_AX88140:
 	case TULIP_CHIP_AX88141:
+	    {
 		uint32_t reg;
 		const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
 		reg = enaddr[0] |
 		      (enaddr[1] << 8) |
 		      (enaddr[2] << 16) |
 		      (enaddr[3] << 24);
 		TULIP_WRITE(sc, CSR_AX_FILTIDX, AX_FILTIDX_PAR0);
 		TULIP_WRITE(sc, CSR_AX_FILTDATA, reg);
 		reg = enaddr[4] | (enaddr[5] << 8);
 		TULIP_WRITE(sc, CSR_AX_FILTIDX, AX_FILTIDX_PAR1);
 		TULIP_WRITE(sc, CSR_AX_FILTDATA, reg);
 		break;
+	    }
 	default:
 		/* Nothing. */
 		break;
+	}
 	/*
 	 * Set the receive filter.  This will start the transmit and
 	 * receive processes.
 	 */
 	(*sc->sc_filter_setup)(sc);
 	/*
 	 * Set the current media.
 	 */
 	(void)(*sc->sc_mediasw->tmsw_set)(sc);
 	/*
 	 * Start the receive process.
 	 */
 	TULIP_WRITE(sc, CSR_RXPOLL, RXPOLL_RPD);
 	if (sc->sc_tick != NULL) {
 		/* Start the one second clock. */
 		callout_reset(&sc->sc_tick_callout, hz >> 3, sc->sc_tick, sc);
+	}
 	/*
 	 * Note that the interface is now running.
 	 */
 	ifp->if_flags |= IFF_RUNNING;
 	ifp->if_flags &= ~IFF_OACTIVE;
 	sc->sc_if_flags = ifp->if_flags;
  out:
 	if (error) {
 		ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 		ifp->if_timer = 0;
 		printf("%s: interface not running\n", device_xname(sc->sc_dev));
+	}
 	return error;
+}
 /*
  * tlp_enable:
+ *
  *	Enable the Tulip chip.
  */
 static int
 tlp_enable(struct tulip_softc *sc)
+{
 	if (TULIP_IS_ENABLED(sc) == 0 && sc->sc_enable != NULL) {
 		if ((*sc->sc_enable)(sc) != 0) {
 			aprint_error_dev(sc->sc_dev, "device enable failed\n");
 			return EIO;
+		}
 		sc->sc_flags |= TULIPF_ENABLED;
+	}
 	return 0;
+}
 /*
  * tlp_disable:
+ *
  *	Disable the Tulip chip.
  */
 static void
 tlp_disable(struct tulip_softc *sc)
+{
 	if (TULIP_IS_ENABLED(sc) && sc->sc_disable != NULL) {
 		(*sc->sc_disable)(sc);
 		sc->sc_flags &= ~TULIPF_ENABLED;
+	}
+}
 /*
  * tlp_rxdrain:
+ *
  *	Drain the receive queue.
  */
 static void
 tlp_rxdrain(struct tulip_softc *sc)
+{
 	struct tulip_rxsoft *rxs;
 	int i;
 	for (i = 0; i < TULIP_NRXDESC; i++) {
 		rxs = &sc->sc_rxsoft[i];
 		if (rxs->rxs_mbuf != NULL) {
 			bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
 			m_freem(rxs->rxs_mbuf);
 			rxs->rxs_mbuf = NULL;
+		}
+	}
+}
 /*
  * tlp_stop:		[ ifnet interface function ]
+ *
  *	Stop transmission on the interface.
  */
 static void
 tlp_stop(struct ifnet *ifp, int disable)
+{
 	struct tulip_softc *sc = ifp->if_softc;
 	struct tulip_txsoft *txs;
 	if (sc->sc_tick != NULL) {
 		/* Stop the one second clock. */
 		callout_stop(&sc->sc_tick_callout);
+	}
 	if (sc->sc_flags & TULIPF_HAS_MII) {
 		/* Down the MII. */
 		mii_down(&sc->sc_mii);
+	}
 	/* Disable interrupts. */
 	TULIP_WRITE(sc, CSR_INTEN, 0);
 	/* Stop the transmit and receive processes. */
 	sc->sc_opmode = 0;
 	TULIP_WRITE(sc, CSR_OPMODE, 0);
 	TULIP_WRITE(sc, CSR_RXLIST, 0);
 	TULIP_WRITE(sc, CSR_TXLIST, 0);
 	/*
 	 * Release any queued transmit buffers.
 	 */
 	while ((txs = SIMPLEQ_FIRST(&sc->sc_txdirtyq)) != NULL) {
 		SIMPLEQ_REMOVE_HEAD(&sc->sc_txdirtyq, txs_q);
 		if (txs->txs_mbuf != NULL) {
 			bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);
 			m_freem(txs->txs_mbuf);
 			txs->txs_mbuf = NULL;
+		}
 		SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
+	}
 	sc->sc_flags &= ~(TULIPF_WANT_SETUP | TULIPF_DOING_SETUP);
 	/*
 	 * Mark the interface down and cancel the watchdog timer.
 	 */
 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 	sc->sc_if_flags = ifp->if_flags;
 	ifp->if_timer = 0;
 	/*
 	 * Reset the chip (needed on some flavors to actually disable it).
 	 */
 	tlp_reset(sc);
 	if (disable) {
 		tlp_rxdrain(sc);
 		tlp_disable(sc);
+	}
+}
 #define	SROM_EMIT(sc, x)						\
 do {									\
 	TULIP_WRITE((sc), CSR_MIIROM, (x));				\
 	delay(2);							\
 } while (0)
 /*
  * tlp_srom_idle:
+ *
  *	Put the SROM in idle state.
  */
 static void
 tlp_srom_idle(struct tulip_softc *sc)
+{
 	uint32_t miirom;
 	int i;
 	miirom = MIIROM_SR;
 	SROM_EMIT(sc, miirom);
 	miirom |= MIIROM_RD;
 	SROM_EMIT(sc, miirom);
 	miirom |= MIIROM_SROMCS;
 	SROM_EMIT(sc, miirom);
 	SROM_EMIT(sc, miirom | MIIROM_SROMSK);
 	/* Strobe the clock 32 times. */
 	for (i = 0; i < 32; i++) {
 		SROM_EMIT(sc, miirom);
 		SROM_EMIT(sc, miirom | MIIROM_SROMSK);
+	}
 	SROM_EMIT(sc, miirom);
 	miirom &= ~MIIROM_SROMCS;
 	SROM_EMIT(sc, miirom);
 	SROM_EMIT(sc, 0);
+}
 /*
  * tlp_srom_size:
+ *
  *	Determine the number of address bits in the SROM.
  */
 static int
 tlp_srom_size(struct tulip_softc *sc)
+{
 	uint32_t miirom;
 	int x;
 	/* Select the SROM. */
 	miirom = MIIROM_SR;
 	SROM_EMIT(sc, miirom);
 	miirom |= MIIROM_RD;
 	SROM_EMIT(sc, miirom);
 	/* Send CHIP SELECT for one clock tick. */
 	miirom |= MIIROM_SROMCS;
 	SROM_EMIT(sc, miirom);
 	/* Shift in the READ opcode. */
 	for (x = 3; x > 0; x--) {
 		if (TULIP_SROM_OPC_READ & (1 << (x - 1)))
 			miirom |= MIIROM_SROMDI;
 		else
 			miirom &= ~MIIROM_SROMDI;
 		SROM_EMIT(sc, miirom);
 		SROM_EMIT(sc, miirom | MIIROM_SROMSK);
 		SROM_EMIT(sc, miirom);
+	}
 	/* Shift in address and look for dummy 0 bit. */
 	for (x = 1; x <= 12; x++) {
 		miirom &= ~MIIROM_SROMDI;
 		SROM_EMIT(sc, miirom);
 		SROM_EMIT(sc, miirom | MIIROM_SROMSK);
 		if (!TULIP_ISSET(sc, CSR_MIIROM, MIIROM_SROMDO))
 			break;
 		SROM_EMIT(sc, miirom);
+	}
 	/* Clear CHIP SELECT. */
 	miirom &= ~MIIROM_SROMCS;
 	SROM_EMIT(sc, miirom);
 	/* Deselect the SROM. */
 	SROM_EMIT(sc, 0);
 	if (x < 4 || x > 12) {
 		aprint_debug_dev(sc->sc_dev, "broken MicroWire interface "
 		    "detected; setting SROM size to 1Kb\n");
 		return 6;
 	} else {
 		if (tlp_srom_debug)
 			printf("%s: SROM size is 2^%d*16 bits (%d bytes)\n",
 			    device_xname(sc->sc_dev), x, (1 << (x + 4)) >> 3);
 		return x;
+	}
+}
 /*
  * tlp_read_srom:
+ *
  *	Read the Tulip SROM.
  */
 int
 tlp_read_srom(struct tulip_softc *sc)
+{
 	int size;
 	uint32_t miirom;
 	uint16_t datain;
 	int i, x;
 	tlp_srom_idle(sc);
 	sc->sc_srom_addrbits = tlp_srom_size(sc);
 	if (sc->sc_srom_addrbits == 0)
 		return 0;
 	size = TULIP_ROM_SIZE(sc->sc_srom_addrbits);
 	sc->sc_srom = malloc(size, M_DEVBUF, M_WAITOK);
 	/* Select the SROM. */
 	miirom = MIIROM_SR;
 	SROM_EMIT(sc, miirom);
 	miirom |= MIIROM_RD;
 	SROM_EMIT(sc, miirom);
 	for (i = 0; i < size; i += 2) {
 		/* Send CHIP SELECT for one clock tick. */
 		miirom |= MIIROM_SROMCS;
 		SROM_EMIT(sc, miirom);
 		/* Shift in the READ opcode. */
 		for (x = 3; x > 0; x--) {
 			if (TULIP_SROM_OPC_READ & (1 << (x - 1)))
 				miirom |= MIIROM_SROMDI;
 			else
 				miirom &= ~MIIROM_SROMDI;
 			SROM_EMIT(sc, miirom);
 			SROM_EMIT(sc, miirom | MIIROM_SROMSK);
 			SROM_EMIT(sc, miirom);
+		}
 		/* Shift in address. */
 		for (x = sc->sc_srom_addrbits; x > 0; x--) {
 			if (i & (1 << x))
 				miirom |= MIIROM_SROMDI;
 			else
 				miirom &= ~MIIROM_SROMDI;
 			SROM_EMIT(sc, miirom);
 			SROM_EMIT(sc, miirom | MIIROM_SROMSK);
 			SROM_EMIT(sc, miirom);
+		}
 		/* Shift out data. */
 		miirom &= ~MIIROM_SROMDI;
 		datain = 0;
 		for (x = 16; x > 0; x--) {
 			SROM_EMIT(sc, miirom | MIIROM_SROMSK);
 			if (TULIP_ISSET(sc, CSR_MIIROM, MIIROM_SROMDO))
 				datain |= (1 << (x - 1));
 			SROM_EMIT(sc, miirom);
+		}
 		sc->sc_srom[i] = datain & 0xff;
 		sc->sc_srom[i + 1] = datain >> 8;
 		/* Clear CHIP SELECT. */
 		miirom &= ~MIIROM_SROMCS;
 		SROM_EMIT(sc, miirom);
+	}
 	/* Deselect the SROM. */
 	SROM_EMIT(sc, 0);
 	/* ...and idle it. */
 	tlp_srom_idle(sc);
 	if (tlp_srom_debug) {
 		printf("SROM CONTENTS:");
 		for (i = 0; i < size; i++) {
 			if ((i % 8) == 0)
 				printf("\n\t");
 			printf("0x%02x ", sc->sc_srom[i]);
+		}
 		printf("\n");
+	}
 	return 1;
+}
 #undef SROM_EMIT
 /*
  * tlp_add_rxbuf:
+ *
  *	Add a receive buffer to the indicated descriptor.
  */
 static int
 tlp_add_rxbuf(struct tulip_softc *sc, int idx)
+{
 	struct tulip_rxsoft *rxs = &sc->sc_rxsoft[idx];
 	struct mbuf *m;
 	int error;
 	MGETHDR(m, M_DONTWAIT, MT_DATA);
 	if (m == NULL)
 		return ENOBUFS;
 	MCLAIM(m, &sc->sc_ethercom.ec_rx_mowner);
 	MCLGET(m, M_DONTWAIT);
 	if ((m->m_flags & M_EXT) == 0) {
 		m_freem(m);
 		return ENOBUFS;
+	}
 	if (rxs->rxs_mbuf != NULL)
 		bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
 	rxs->rxs_mbuf = m;
 	error = bus_dmamap_load(sc->sc_dmat, rxs->rxs_dmamap,
 	    m->m_ext.ext_buf, m->m_ext.ext_size, NULL,
 	    BUS_DMA_READ | BUS_DMA_NOWAIT);
 	if (error) {
 		aprint_error_dev(sc->sc_dev,
 		    "can't load rx DMA map %d, error = %d\n", idx, error);
 		panic("tlp_add_rxbuf");	/* XXX */
+	}
 	bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
 	    rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
 	TULIP_INIT_RXDESC(sc, idx);
 	return 0;
+}
 /*
  * tlp_srom_crcok:
+ *
  *	Check the CRC of the Tulip SROM.
  */
 int
 tlp_srom_crcok(const uint8_t *romdata)
+{
 	uint32_t crc;
 	crc = ether_crc32_le(romdata, TULIP_ROM_CRC32_CHECKSUM);
 	crc = (crc & 0xffff) ^ 0xffff;
 	if (crc == TULIP_ROM_GETW(romdata, TULIP_ROM_CRC32_CHECKSUM))
 		return 1;
 	/*
 	 * Try an alternate checksum.
 	 */
 	crc = ether_crc32_le(romdata, TULIP_ROM_CRC32_CHECKSUM1);
 	crc = (crc & 0xffff) ^ 0xffff;
 	if (crc == TULIP_ROM_GETW(romdata, TULIP_ROM_CRC32_CHECKSUM1))
 		return 1;
 	return 0;
+}
 /*
  * tlp_isv_srom:
+ *
  *	Check to see if the SROM is in the new standardized format.
  */
 int
 tlp_isv_srom(const uint8_t *romdata)
+{
 	int i;
 	uint16_t cksum;
 	if (tlp_srom_crcok(romdata)) {
 		/*
 		 * SROM CRC checks out; must be in the new format.
 		 */
 		return 1;
+	}
 	cksum = TULIP_ROM_GETW(romdata, TULIP_ROM_CRC32_CHECKSUM);
 	if (cksum == 0xffff || cksum == 0) {
 		/*
 		 * No checksum present.  Check the SROM ID; 18 bytes of 0
 		 * followed by 1 (version) followed by the number of
 		 * adapters which use this SROM (should be non-zero).
 		 */
 		for (i = 0; i < TULIP_ROM_SROM_FORMAT_VERION; i++) {
 			if (romdata[i] != 0)
 				return 0;
+		}
 		if (romdata[TULIP_ROM_SROM_FORMAT_VERION] != 1)
 			return 0;
 		if (romdata[TULIP_ROM_CHIP_COUNT] == 0)
 			return 0;
 		return 1;
+	}
 	return 0;
+}
 /*
  * tlp_isv_srom_enaddr:
+ *
  *	Get the Ethernet address from an ISV SROM.
  */
 int
 tlp_isv_srom_enaddr(struct tulip_softc *sc, uint8_t *enaddr)
+{
 	int i, devcnt;
 	if (tlp_isv_srom(sc->sc_srom) == 0)
 		return 0;
 	devcnt = sc->sc_srom[TULIP_ROM_CHIP_COUNT];
 	for (i = 0; i < devcnt; i++) {
 		if (sc->sc_srom[TULIP_ROM_CHIP_COUNT] == 1)
 			break;
 		if (sc->sc_srom[TULIP_ROM_CHIPn_DEVICE_NUMBER(i)] ==
 		    sc->sc_devno)
 			break;
+	}
 	if (i == devcnt)
 		return 0;
 	memcpy(enaddr, &sc->sc_srom[TULIP_ROM_IEEE_NETWORK_ADDRESS],
 	    ETHER_ADDR_LEN);
 	enaddr[5] += i;
 	return 1;
+}
 /*
  * tlp_parse_old_srom:
+ *
  *	Parse old-format SROMs.
+ *
  *	This routine is largely lifted from Matt Thomas's `de' driver.
  */
 int
 tlp_parse_old_srom(struct tulip_softc *sc, uint8_t *enaddr)
+{
 	static const uint8_t testpat[] =
 	    { 0xff, 0, 0x55, 0xaa, 0xff, 0, 0x55, 0xaa };
 	int i;
 	uint32_t cksum;
 	if (memcmp(&sc->sc_srom[0], &sc->sc_srom[16], 8) != 0) {
 		/*
 		 * Phobos G100 interfaces have the address at
 		 * offsets 0 and 20, but each pair of bytes is
 		 * swapped.
 		 */
 		if (sc->sc_srom_addrbits == 6 &&
 		    sc->sc_srom[1] == 0x00 &&
 		    sc->sc_srom[0] == 0x60 &&
 		    sc->sc_srom[3] == 0xf5 &&
 		    memcmp(&sc->sc_srom[0], &sc->sc_srom[20], 6) == 0) {
 			for (i = 0; i < 6; i += 2) {
 				enaddr[i] = sc->sc_srom[i + 1];
 				enaddr[i + 1] = sc->sc_srom[i];
+			}
 			return 1;
+		}
 		/*
 		 * Phobos G130/G160 interfaces have the address at
 		 * offsets 20 and 84, but each pair of bytes is
 		 * swapped.
 		 */
 		if (sc->sc_srom_addrbits == 6 &&
 		    sc->sc_srom[21] == 0x00 &&
 		    sc->sc_srom[20] == 0x60 &&
 		    sc->sc_srom[23] == 0xf5 &&
 		    memcmp(&sc->sc_srom[20], &sc->sc_srom[84], 6) == 0) {
 			for (i = 0; i < 6; i += 2) {
 				enaddr[i] = sc->sc_srom[20 + i + 1];
 				enaddr[i + 1] = sc->sc_srom[20 + i];
+			}
 			return 1;
+		}
 		/*
 		 * Cobalt Networks interfaces simply have the address
 		 * in the first six bytes. The rest is zeroed out
 		 * on some models, but others contain unknown data.
 		 */
 		if (sc->sc_srom[0] == 0x00 &&
 		    sc->sc_srom[1] == 0x10 &&
 		    sc->sc_srom[2] == 0xe0) {
 			memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN);
 			return 1;
+		}
 		/*
 		 * Some vendors (e.g. ZNYX) don't use the standard
 		 * DEC Address ROM format, but rather just have an
 		 * Ethernet address in the first 6 bytes, maybe a
 		 * 2 byte checksum, and then all 0xff's.
 		 */
 		for (i = 8; i < 32; i++) {
 			if (sc->sc_srom[i] != 0xff &&
 			    sc->sc_srom[i] != 0)
 				return 0;
+		}
 		/*
 		 * Sanity check the Ethernet address:
+		 *
 		 *	- Make sure it's not multicast or locally
 		 *	  assigned
 		 *	- Make sure it has a non-0 OUI
 		 */
 		if (sc->sc_srom[0] & 3)
 			return 0;
 		if (sc->sc_srom[0] == 0 && sc->sc_srom[1] == 0 &&
 		    sc->sc_srom[2] == 0)
 			return 0;
 		memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN);