 @@ -1,14 +1,14 @@
-/*	$NetBSD: tulip.c,v 1.164 2008/11/07 00:20:03 dyoung Exp $	*/
+/*	$NetBSD: tulip.c,v 1.165 2009/04/17 08:04:49 cegger 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
 @@ -26,27 +26,27 @@
  * 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.164 2008/11/07 00:20:03 dyoung Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tulip.c,v 1.165 2009/04/17 08:04:49 cegger Exp $");
 #include "bpfilter.h"
 #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>
 @@ -102,65 +102,65 @@ static int	tlp_srom_size(struct tulip_so
 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 device *);
+static void	tlp_mii_statchg(device_t);
-static void	tlp_winb_mii_statchg(struct device *);
+static void	tlp_winb_mii_statchg(device_t);
-static void	tlp_dm9102_mii_statchg(struct device *);
+static void	tlp_dm9102_mii_statchg(device_t);
 static void	tlp_mii_getmedia(struct tulip_softc *, struct ifmediareq *);
 static int	tlp_mii_setmedia(struct tulip_softc *);
-static int	tlp_bitbang_mii_readreg(struct device *, int, int);
+static int	tlp_bitbang_mii_readreg(device_t, int, int);
-static void	tlp_bitbang_mii_writereg(struct device *, int, int, int);
+static void	tlp_bitbang_mii_writereg(device_t, int, int, int);
-static int	tlp_pnic_mii_readreg(struct device *, int, int);
+static int	tlp_pnic_mii_readreg(device_t, int, int);
-static void	tlp_pnic_mii_writereg(struct device *, int, int, int);
+static void	tlp_pnic_mii_writereg(device_t, int, int, int);
-static int	tlp_al981_mii_readreg(struct device *, int, int);
+static int	tlp_al981_mii_readreg(device_t, int, int);
-static void	tlp_al981_mii_writereg(struct device *, int, int, int);
+static void	tlp_al981_mii_writereg(device_t, int, int, int);
 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 u_int32_t tlp_sio_mii_bitbang_read(struct device *);
+static uint32_t tlp_sio_mii_bitbang_read(device_t);
-static void	tlp_sio_mii_bitbang_write(struct device *, u_int32_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 */
+	}
 };
 @@ -177,27 +177,27 @@ static void	tlp_print_stats(struct tulip
 /*
  * 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.
  */
 void
-tlp_attach(struct tulip_softc *sc, const u_int8_t *enaddr)
+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!
 	 */
 	/*
 @@ -563,27 +563,27 @@ tlp_attach(struct tulip_softc *sc, const
 	    sizeof(struct tulip_control_data));
  fail_1:
 	bus_dmamem_free(sc->sc_dmat, &sc->sc_cdseg, sc->sc_cdnseg);
  fail_0:
 	return;
+}
 /*
  * tlp_activate:
+ *
  *	Handle device activation/deactivation requests.
  */
 int
-tlp_activate(struct device *self, enum devact act)
+tlp_activate(device_t self, enum devact act)
+{
 	struct tulip_softc *sc = (void *) self;
 	int s, error = 0;
 	s = splnet();
 	switch (act) {
 	case DVACT_ACTIVATE:
 		error = EOPNOTSUPP;
 		break;
 	case DVACT_DEACTIVATE:
 		if (sc->sc_flags & TULIPF_HAS_MII)
 			mii_activate(&sc->sc_mii, act, MII_PHY_ANY,
 @@ -1021,27 +1021,27 @@ tlp_ioctl(struct ifnet *ifp, u_long cmd,
 	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;
-	u_int32_t status, rxstatus, txstatus;
+	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.
 	 */
 @@ -1215,27 +1215,27 @@ tlp_intr(void *arg)
 /*
  * 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;
-	u_int32_t rxstat, errors;
+	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.
 @@ -1419,27 +1419,27 @@ tlp_rxintr(struct tulip_softc *sc)
 	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;
-	u_int32_t txstat;
+	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,
 @@ -1890,46 +1890,46 @@ tlp_init(struct ifnet *ifp)
 		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:
+	    {
-		u_int32_t reg;
+		uint32_t reg;
-		const u_int8_t *enaddr = CLLADDR(ifp->if_sadl);
+		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:
+	    {
-		u_int32_t reg;
+		uint32_t reg;
-		const u_int8_t *enaddr = CLLADDR(ifp->if_sadl);
+		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;
+	    }
 @@ -2098,27 +2098,27 @@ tlp_stop(struct ifnet *ifp, int disable)
 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)
+{
-	u_int32_t miirom;
+	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);
 @@ -2134,27 +2134,27 @@ tlp_srom_idle(struct tulip_softc *sc)
 	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)
+{
-	u_int32_t miirom;
+	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);
 @@ -2197,28 +2197,28 @@ tlp_srom_size(struct tulip_softc *sc)
 		return (x);
+	}
+}
 /*
  * tlp_read_srom:
+ *
  *	Read the Tulip SROM.
  */
 int
 tlp_read_srom(struct tulip_softc *sc)
+{
 	int size;
-	u_int32_t miirom;
+	uint32_t miirom;
-	u_int16_t datain;
+	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_NOWAIT);
 	/* Select the SROM. */
 	miirom = MIIROM_SR;
 	SROM_EMIT(sc, miirom);
 @@ -2332,56 +2332,56 @@ tlp_add_rxbuf(struct tulip_softc *sc, in
 	    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 u_int8_t *romdata)
+tlp_srom_crcok(const uint8_t *romdata)
+{
-	u_int32_t crc;
+	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 u_int8_t *romdata)
+tlp_isv_srom(const uint8_t *romdata)
+{
 	int i;
-	u_int16_t cksum;
+	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
 @@ -2397,27 +2397,27 @@ tlp_isv_srom(const u_int8_t *romdata)
 			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, u_int8_t *enaddr)
+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;
 @@ -2431,32 +2431,32 @@ tlp_isv_srom_enaddr(struct tulip_softc *
 	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, u_int8_t *enaddr)
+tlp_parse_old_srom(struct tulip_softc *sc, uint8_t *enaddr)
+{
-	static const u_int8_t testpat[] =
+	static const uint8_t testpat[] =
 	    { 0xff, 0, 0x55, 0xaa, 0xff, 0, 0x55, 0xaa };
 	int i;
-	u_int32_t cksum;
+	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) {
 @@ -2528,66 +2528,66 @@ tlp_parse_old_srom(struct tulip_softc *s
 	 * Standard DEC Address ROM test.
 	 */
 	if (memcmp(&sc->sc_srom[24], testpat, 8) != 0)
 		return (0);
 	for (i = 0; i < 8; i++) {
 		if (sc->sc_srom[i] != sc->sc_srom[15 - i])
 			return (0);
+	}
 	memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN);
-	cksum = *(u_int16_t *) &enaddr[0];
+	cksum = *(uint16_t *) &enaddr[0];
 	cksum <<= 1;
 	if (cksum > 0xffff)
 		cksum -= 0xffff;
-	cksum += *(u_int16_t *) &enaddr[2];
+	cksum += *(uint16_t *) &enaddr[2];
 	if (cksum > 0xffff)
 		cksum -= 0xffff;
 	cksum <<= 1;
 	if (cksum > 0xffff)
 		cksum -= 0xffff;
-	cksum += *(u_int16_t *) &enaddr[4];
+	cksum += *(uint16_t *) &enaddr[4];
 	if (cksum >= 0xffff)
 		cksum -= 0xffff;
-	if (cksum != *(u_int16_t *) &sc->sc_srom[6])
+	if (cksum != *(uint16_t *) &sc->sc_srom[6])
 		return (0);
 	return (1);
+}
 /*
  * tlp_filter_setup:
+ *
  *	Set the Tulip's receive filter.
  */
 static void
 tlp_filter_setup(struct tulip_softc *sc)
+{
 	struct ethercom *ec = &sc->sc_ethercom;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct ether_multi *enm;
 	struct ether_multistep step;
-	volatile u_int32_t *sp;
+	volatile uint32_t *sp;
 	struct tulip_txsoft *txs;
-	u_int8_t enaddr[ETHER_ADDR_LEN];
+	uint8_t enaddr[ETHER_ADDR_LEN];
-	u_int32_t hash, hashsize;
+	uint32_t hash, hashsize;
 	int cnt, nexttx;
 	DPRINTF(sc, ("%s: tlp_filter_setup: sc_flags 0x%08x\n",
 	    device_xname(&sc->sc_dev), sc->sc_flags));
 	memcpy(enaddr, CLLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
 	/*
 	 * If there are transmissions pending, wait until they have
 	 * completed.
 	 */
 	if (! SIMPLEQ_EMPTY(&sc->sc_txdirtyq) ||
 	    (sc->sc_flags & TULIPF_DOING_SETUP) != 0) {
 @@ -2832,27 +2832,27 @@ tlp_filter_setup(struct tulip_softc *sc)
 /*
  * tlp_winb_filter_setup:
+ *
  *	Set the Winbond 89C840F's receive filter.
  */
 static void
 tlp_winb_filter_setup(struct tulip_softc *sc)
+{
 	struct ethercom *ec = &sc->sc_ethercom;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct ether_multi *enm;
 	struct ether_multistep step;
-	u_int32_t hash, mchash[2];
+	uint32_t hash, mchash[2];
 	DPRINTF(sc, ("%s: tlp_winb_filter_setup: sc_flags 0x%08x\n",
 	    device_xname(&sc->sc_dev), sc->sc_flags));
 	sc->sc_opmode &= ~(OPMODE_WINB_APP|OPMODE_WINB_AMP|OPMODE_WINB_ABP);
 	if (ifp->if_flags & IFF_MULTICAST)
 		sc->sc_opmode |= OPMODE_WINB_AMP;
 	if (ifp->if_flags & IFF_BROADCAST)
 		sc->sc_opmode |= OPMODE_WINB_ABP;
 	if (ifp->if_flags & IFF_PROMISC) {
 @@ -2903,27 +2903,27 @@ tlp_winb_filter_setup(struct tulip_softc
 /*
  * tlp_al981_filter_setup:
+ *
  *	Set the ADMtek AL981's receive filter.
  */
 static void
 tlp_al981_filter_setup(struct tulip_softc *sc)
+{
 	struct ethercom *ec = &sc->sc_ethercom;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct ether_multi *enm;
 	struct ether_multistep step;
-	u_int32_t hash, mchash[2];
+	uint32_t hash, mchash[2];
 	/*
 	 * If the chip is running, we need to reset the interface,
 	 * and will revisit here (with IFF_RUNNING) clear.  The
 	 * chip seems to really not like to have its multicast
 	 * filter programmed without a reset.
 	 */
 	if (ifp->if_flags & IFF_RUNNING) {
 		(void) tlp_init(ifp);
 		return;
+	}
 	DPRINTF(sc, ("%s: tlp_al981_filter_setup: sc_flags 0x%08x\n",
 @@ -2973,27 +2973,27 @@ tlp_al981_filter_setup(struct tulip_soft
 /*
  * tlp_asix_filter_setup:
+ *
  * 	Set the ASIX AX8814x recieve filter.
  */
 static void
 tlp_asix_filter_setup(struct tulip_softc *sc)
+{
 	struct ethercom *ec = &sc->sc_ethercom;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct ether_multi *enm;
 	struct ether_multistep step;
-	u_int32_t hash, mchash[2];
+	uint32_t hash, mchash[2];
 	DPRINTF(sc, ("%s: tlp_asix_filter_setup: sc_flags 0x%08x\n",
 		device_xname(&sc->sc_dev), sc->sc_flags));
 	sc->sc_opmode &= ~(OPMODE_PM|OPMODE_AX_RB|OPMODE_PR);
 	if (ifp->if_flags & IFF_MULTICAST)
 		sc->sc_opmode |= OPMODE_PM;
 	if (ifp->if_flags & IFF_BROADCAST)
 		sc->sc_opmode |= OPMODE_AX_RB;
 	if (ifp->if_flags & IFF_PROMISC) {
 @@ -3038,27 +3038,27 @@ setit:
 	TULIP_WRITE(sc, CSR_AX_FILTDATA, mchash[1]);
 	TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
 	DPRINTF(sc, ("%s: tlp_asix_filter_setup: returning\n",
 		device_xname(&sc->sc_dev)));
+}
 /*
  * tlp_idle:
+ *
  *	Cause the transmit and/or receive processes to go idle.
  */
 void
-tlp_idle(struct tulip_softc *sc, u_int32_t bits)
+tlp_idle(struct tulip_softc *sc, uint32_t bits)
+{
 	static const char * const tlp_tx_state_names[] = {
 		"STOPPED",
 		"RUNNING - FETCH",
 		"RUNNING - WAIT",
 		"RUNNING - READING",
 		"-- RESERVED --",
 		"RUNNING - SETUP",
 		"SUSPENDED",
 		"RUNNING - CLOSE",
 	};
 	static const char * const tlp_rx_state_names[] = {
 		"STOPPED",
 @@ -3082,27 +3082,27 @@ tlp_idle(struct tulip_softc *sc, u_int32
 	};
 	static const char * const dm9102_rx_state_names[] = {
 		"STOPPED",
 		"RUNNING - FETCH",
 		"RUNNING - WAIT",
 		"RUNNING - QUEUE",
 		"RUNNING - CLOSE - CLEAR OWNER",
 		"RUNNING - CLOSE - WRITE STATUS",
 		"SUSPENDED",
 		"RUNNING - FLUSH",
 	};
 	const char * const *tx_state_names, * const *rx_state_names;
-	u_int32_t csr, ackmask = 0;
+	uint32_t csr, ackmask = 0;
 	int i;
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_DM9102:
 	case TULIP_CHIP_DM9102A:
 		tx_state_names = dm9102_tx_state_names;
 		rx_state_names = dm9102_rx_state_names;
 		break;
 	default:
 		tx_state_names = tlp_tx_state_names;
 		rx_state_names = tlp_rx_state_names;
 		break;
 @@ -3219,27 +3219,27 @@ tlp_mii_tick(void *arg)
 	s = splnet();
 	mii_tick(&sc->sc_mii);
 	splx(s);
 	callout_reset(&sc->sc_tick_callout, hz, sc->sc_tick, sc);
+}
 /*
  * tlp_mii_statchg:	[mii interface function]
+ *
  *	Callback from PHY when media changes.
  */
 static void
-tlp_mii_statchg(struct device *self)
+tlp_mii_statchg(device_t self)
+{
 	struct tulip_softc *sc = (struct tulip_softc *)self;
 	/* Idle the transmit and receive processes. */
 	tlp_idle(sc, OPMODE_ST|OPMODE_SR);
 	sc->sc_opmode &= ~(OPMODE_TTM|OPMODE_FD|OPMODE_HBD);
 	if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) == IFM_10_T)
 		sc->sc_opmode |= OPMODE_TTM;
 	else
 		sc->sc_opmode |= OPMODE_HBD;
 @@ -3250,27 +3250,27 @@ tlp_mii_statchg(struct device *self)
 	 * Write new OPMODE bits.  This also restarts the transmit
 	 * and receive processes.
 	 */
 	TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
+}
 /*
  * tlp_winb_mii_statchg: [mii interface function]
+ *
  *	Callback from PHY when media changes.  This version is
  *	for the Winbond 89C840F, which has different OPMODE bits.
  */
 static void
-tlp_winb_mii_statchg(struct device *self)
+tlp_winb_mii_statchg(device_t self)
+{
 	struct tulip_softc *sc = (struct tulip_softc *)self;
 	/* Idle the transmit and receive processes. */
 	tlp_idle(sc, OPMODE_ST|OPMODE_SR);
 	sc->sc_opmode &= ~(OPMODE_WINB_FES|OPMODE_FD);
 	if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) == IFM_100_TX)
 		sc->sc_opmode |= OPMODE_WINB_FES;
 	if (sc->sc_mii.mii_media_active & IFM_FDX)
 		sc->sc_opmode |= OPMODE_FD;
 @@ -3279,27 +3279,27 @@ tlp_winb_mii_statchg(struct device *self
 	 * Write new OPMODE bits.  This also restarts the transmit
 	 * and receive processes.
 	 */
 	TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
+}
 /*
  * tlp_dm9102_mii_statchg: [mii interface function]
+ *
  *	Callback from PHY when media changes.  This version is
  *	for the DM9102.
  */
 static void
-tlp_dm9102_mii_statchg(struct device *self)
+tlp_dm9102_mii_statchg(device_t self)
+{
 	struct tulip_softc *sc = (struct tulip_softc *)self;
 	/*
 	 * Don't idle the transmit and receive processes, here.  It
 	 * seems to fail, and just causes excess noise.
 	 */
 	sc->sc_opmode &= ~(OPMODE_TTM|OPMODE_FD);
 	if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) != IFM_100_TX)
 		sc->sc_opmode |= OPMODE_TTM;
 	if (sc->sc_mii.mii_media_active & IFM_FDX)
 @@ -3350,82 +3350,82 @@ tlp_mii_setmedia(struct tulip_softc *sc)
 		break;
+	}
 	if ((rc = mii_mediachg(&sc->sc_mii)) == ENXIO)
 		return 0;
 	return rc;
+}
 /*
  * tlp_bitbang_mii_readreg:
+ *
  *	Read a PHY register via bit-bang'ing the MII.
  */
 static int
-tlp_bitbang_mii_readreg(struct device *self, int phy, int reg)
+tlp_bitbang_mii_readreg(device_t self, int phy, int reg)
+{
 	struct tulip_softc *sc = (void *) self;
 	return (mii_bitbang_readreg(self, sc->sc_bitbang_ops, phy, reg));
+}
 /*
  * tlp_bitbang_mii_writereg:
+ *
  *	Write a PHY register via bit-bang'ing the MII.
  */
 static void
-tlp_bitbang_mii_writereg(struct device *self, int phy, int reg, int val)
+tlp_bitbang_mii_writereg(device_t self, int phy, int reg, int val)
+{
 	struct tulip_softc *sc = (void *) self;
 	mii_bitbang_writereg(self, sc->sc_bitbang_ops, phy, reg, val);
+}
 /*
  * tlp_sio_mii_bitbang_read:
+ *
  *	Read the MII serial port for the MII bit-bang module.
  */
-static u_int32_t
+static uint32_t
-tlp_sio_mii_bitbang_read(struct device *self)
+tlp_sio_mii_bitbang_read(device_t self)
+{
 	struct tulip_softc *sc = (void *) self;
 	return (TULIP_READ(sc, CSR_MIIROM));
+}
 /*
  * tlp_sio_mii_bitbang_write:
+ *
  *	Write the MII serial port for the MII bit-bang module.
  */
 static void
-tlp_sio_mii_bitbang_write(struct device *self, u_int32_t val)
+tlp_sio_mii_bitbang_write(device_t self, uint32_t val)
+{
 	struct tulip_softc *sc = (void *) self;
 	TULIP_WRITE(sc, CSR_MIIROM, val);
+}
 /*
  * tlp_pnic_mii_readreg:
+ *
  *	Read a PHY register on the Lite-On PNIC.
  */
 static int
-tlp_pnic_mii_readreg(struct device *self, int phy, int reg)
+tlp_pnic_mii_readreg(device_t self, int phy, int reg)
+{
 	struct tulip_softc *sc = (void *) self;
-	u_int32_t val;
+	uint32_t val;
 	int i;
 	TULIP_WRITE(sc, CSR_PNIC_MII,
 	    PNIC_MII_MBO | PNIC_MII_RESERVED |
 	    PNIC_MII_READ | (phy << PNIC_MII_PHYSHIFT) |
 	    (reg << PNIC_MII_REGSHIFT));
 	for (i = 0; i < 1000; i++) {
 		delay(10);
 		val = TULIP_READ(sc, CSR_PNIC_MII);
 		if ((val & PNIC_MII_BUSY) == 0) {
 			if ((val & PNIC_MII_DATA) == PNIC_MII_DATA)
 				return (0);
 @@ -3433,27 +3433,27 @@ tlp_pnic_mii_readreg(struct device *self
 				return (val & PNIC_MII_DATA);
+		}
+	}
 	printf("%s: MII read timed out\n", device_xname(&sc->sc_dev));
 	return (0);
+}
 /*
  * tlp_pnic_mii_writereg:
+ *
  *	Write a PHY register on the Lite-On PNIC.
  */
 static void
-tlp_pnic_mii_writereg(struct device *self, int phy, int reg, int val)
+tlp_pnic_mii_writereg(device_t self, int phy, int reg, int val)
+{
 	struct tulip_softc *sc = (void *) self;
 	int i;
 	TULIP_WRITE(sc, CSR_PNIC_MII,
 	    PNIC_MII_MBO | PNIC_MII_RESERVED |
 	    PNIC_MII_WRITE | (phy << PNIC_MII_PHYSHIFT) |
 	    (reg << PNIC_MII_REGSHIFT) | val);
 	for (i = 0; i < 1000; i++) {
 		delay(10);
 		if (TULIP_ISSET(sc, CSR_PNIC_MII, PNIC_MII_BUSY) == 0)
 			return;
 @@ -3474,48 +3474,48 @@ static const bus_addr_t tlp_al981_phy_re
 	CSR_ADM_XCIIS,
 	CSR_ADM_XIE,
 	CSR_ADM_100CTR,
 };
 static const int tlp_al981_phy_regmap_size = sizeof(tlp_al981_phy_regmap) /
     sizeof(tlp_al981_phy_regmap[0]);
 /*
  * tlp_al981_mii_readreg:
+ *
  *	Read a PHY register on the ADMtek AL981.
  */
 static int
-tlp_al981_mii_readreg(struct device *self, int phy, int reg)
+tlp_al981_mii_readreg(device_t self, int phy, int reg)
+{
 	struct tulip_softc *sc = (struct tulip_softc *)self;
 	/* AL981 only has an internal PHY. */
 	if (phy != 0)
 		return (0);
 	if (reg >= tlp_al981_phy_regmap_size)
 		return (0);
 	return (bus_space_read_4(sc->sc_st, sc->sc_sh,
 	    tlp_al981_phy_regmap[reg]) & 0xffff);
+}
 /*
  * tlp_al981_mii_writereg:
+ *
  *	Write a PHY register on the ADMtek AL981.
  */
 static void
-tlp_al981_mii_writereg(struct device *self, int phy, int reg, int val)
+tlp_al981_mii_writereg(device_t self, int phy, int reg, int val)
+{
 	struct tulip_softc *sc = (struct tulip_softc *)self;
 	/* AL981 only has an internal PHY. */
 	if (phy != 0)
 		return;
 	if (reg >= tlp_al981_phy_regmap_size)
 		return;
 	bus_space_write_4(sc->sc_st, sc->sc_sh,
 	    tlp_al981_phy_regmap[reg], val);
+}
 @@ -3675,27 +3675,27 @@ tlp_21140_reset(struct tulip_softc *sc)
+	}
+}
 /*
  * tlp_21142_reset:
+ *
  *	Issue a reset sequence on the 21142 via the GPIO facility.
  */
 static void
 tlp_21142_reset(struct tulip_softc *sc)
+{
 	struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
 	struct tulip_21x4x_media *tm = ife->ifm_aux;
-	const u_int8_t *cp;
+	const uint8_t *cp;
 	int i;
 	cp = &sc->sc_srom[tm->tm_reset_offset];
 	for (i = 0; i < tm->tm_reset_length; i++, cp += 2) {
 		delay(10);
 		TULIP_WRITE(sc, CSR_SIAGEN, TULIP_ROM_GETW(cp, 0) << 16);
+	}
 	cp = &sc->sc_srom[tm->tm_gp_offset];
 	for (i = 0; i < tm->tm_gp_length; i++, cp += 2) {
 		delay(10);
 		TULIP_WRITE(sc, CSR_SIAGEN, TULIP_ROM_GETW(cp, 0) << 16);
+	}
 @@ -3925,39 +3925,39 @@ static const struct tulip_srom_to_ifmedi
 	  { 0,
 ,
 },
 	  { 0,
 ,
 },
 	  { 0,
 ,
 } },
 };
-static const struct tulip_srom_to_ifmedia *tlp_srom_to_ifmedia(u_int8_t);
+static const struct tulip_srom_to_ifmedia *tlp_srom_to_ifmedia(uint8_t);
 static void	tlp_srom_media_info(struct tulip_softc *,
 		    const struct tulip_srom_to_ifmedia *,
 		    struct tulip_21x4x_media *);
 static void	tlp_add_srom_media(struct tulip_softc *, int,
 		    void (*)(struct tulip_softc *, struct ifmediareq *),
-		    int (*)(struct tulip_softc *), const u_int8_t *, int);
+		    int (*)(struct tulip_softc *), const uint8_t *, int);
 static void	tlp_print_media(struct tulip_softc *);
 static void	tlp_nway_activate(struct tulip_softc *, int);
 static void	tlp_get_minst(struct tulip_softc *);
 static const struct tulip_srom_to_ifmedia *
-tlp_srom_to_ifmedia(u_int8_t sm)
+tlp_srom_to_ifmedia(uint8_t sm)
+{
 	const struct tulip_srom_to_ifmedia *tsti;
 	for (tsti = tulip_srom_to_ifmedia_table;
 	     tsti->tsti_name != NULL; tsti++) {
 		if (tsti->tsti_srom == sm)
 			return (tsti);
+	}
 	return (NULL);
+}
 static void
 @@ -3989,27 +3989,27 @@ tlp_srom_media_info(struct tulip_softc *
 	case TULIP_CHIP_MX98725:
 		tm->tm_sia = tsti->tsti_21142;	/* struct assignment */
 		break;
 	default:
 		/* Nothing. */
 		break;
+	}
+}
 static void
 tlp_add_srom_media(struct tulip_softc *sc, int type,
     void (*get)(struct tulip_softc *, struct ifmediareq *),
-    int (*set)(struct tulip_softc *), const u_int8_t *list,
+    int (*set)(struct tulip_softc *), const uint8_t *list,
     int cnt)
+{
 	struct tulip_21x4x_media *tm;
 	const struct tulip_srom_to_ifmedia *tsti;
 	int i;
 	for (i = 0; i < cnt; i++) {
 		tsti = tlp_srom_to_ifmedia(list[i]);
 		tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
 		tlp_srom_media_info(sc, tsti, tm);
 		tm->tm_type = type;
 		tm->tm_get = get;
 		tm->tm_set = set;
 @@ -4084,27 +4084,27 @@ tlp_get_minst(struct tulip_softc *sc)
  * SIA Utility functions.
  */
 static void	tlp_sia_update_link(struct tulip_softc *);
 static void	tlp_sia_get(struct tulip_softc *, struct ifmediareq *);
 static int	tlp_sia_set(struct tulip_softc *);
 static int	tlp_sia_media(struct tulip_softc *, struct ifmedia_entry *);
 static void	tlp_sia_fixup(struct tulip_softc *);
 static void
 tlp_sia_update_link(struct tulip_softc *sc)
+{
 	struct ifmedia_entry *ife;
 	struct tulip_21x4x_media *tm;
-	u_int32_t siastat;
+	uint32_t siastat;
 	ife = TULIP_CURRENT_MEDIA(sc);
 	tm = ife->ifm_aux;
 	sc->sc_flags &= ~(TULIPF_LINK_UP|TULIPF_LINK_VALID);
 	siastat = TULIP_READ(sc, CSR_SIASTAT);
 	/*
 	 * Note that when we do SIA link tests, we are assuming that
 	 * the chip is really in the mode that the current media setting
 	 * reflects.  If we're not, then the link tests will not be
 	 * accurate!
 @@ -4179,27 +4179,27 @@ tlp_sia_get(struct tulip_softc *sc, stru
 	if (sc->sc_flags & TULIPF_LINK_VALID)
 		ifmr->ifm_status |= IFM_AVALID;
 	if (sc->sc_flags & TULIPF_LINK_UP)
 		ifmr->ifm_status |= IFM_ACTIVE;
 	ifmr->ifm_active = ife->ifm_media;
+}
 static void
 tlp_sia_fixup(struct tulip_softc *sc)
+{
 	struct ifmedia_entry *ife;
 	struct tulip_21x4x_media *tm;
-	u_int32_t siaconn, siatxrx, siagen;
+	uint32_t siaconn, siatxrx, siagen;
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_82C115:
 	case TULIP_CHIP_MX98713A:
 	case TULIP_CHIP_MX98715:
 	case TULIP_CHIP_MX98715A:
 	case TULIP_CHIP_MX98715AEC_X:
 	case TULIP_CHIP_MX98725:
 		siaconn = PMAC_SIACONN_MASK;
 		siatxrx = PMAC_SIATXRX_MASK;
 		siagen  = PMAC_SIAGEN_MASK;
 		break;
 @@ -4366,27 +4366,27 @@ const struct tulip_mediasw tlp_21040_tp_
 };
 const struct tulip_mediasw tlp_21040_auibnc_mediasw = {
 	tlp_21040_auibnc_tmsw_init, tlp_sia_get, tlp_sia_set
 };
 const struct tulip_mediasw tlp_21041_mediasw = {
 	tlp_21041_tmsw_init, tlp_sia_get, tlp_sia_set
 };
 static void
 tlp_21040_tmsw_init(struct tulip_softc *sc)
+{
-	static const u_int8_t media[] = {
+	static const uint8_t media[] = {
 		TULIP_ROM_MB_MEDIA_TP,
 		TULIP_ROM_MB_MEDIA_TP_FDX,
 		TULIP_ROM_MB_MEDIA_AUI,
 	};
 	struct tulip_21x4x_media *tm;
 	ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
 	    tlp_mediastatus);
 	tlp_add_srom_media(sc, 0, NULL, NULL, media, 3);
 	/*
 	 * No SROM type for External SIA.
 @@ -4403,72 +4403,72 @@ tlp_21040_tmsw_init(struct tulip_softc *
 	/*
 	 * XXX Autosense not yet supported.
 	 */
 	/* XXX This should be auto-sense. */
 	ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_T);
 	tlp_print_media(sc);
+}
 static void
 tlp_21040_tp_tmsw_init(struct tulip_softc *sc)
+{
-	static const u_int8_t media[] = {
+	static const uint8_t media[] = {
 		TULIP_ROM_MB_MEDIA_TP,
 		TULIP_ROM_MB_MEDIA_TP_FDX,
 	};
 	ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
 	    tlp_mediastatus);
 	tlp_add_srom_media(sc, 0, NULL, NULL, media, 2);
 	ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_T);
 	tlp_print_media(sc);
+}
 static void
 tlp_21040_auibnc_tmsw_init(struct tulip_softc *sc)
+{
-	static const u_int8_t media[] = {
+	static const uint8_t media[] = {
 		TULIP_ROM_MB_MEDIA_AUI,
 	};
 	ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
 	    tlp_mediastatus);
 	tlp_add_srom_media(sc, 0, NULL, NULL, media, 1);
 	ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_5);
 	tlp_print_media(sc);
+}
 static void
 tlp_21041_tmsw_init(struct tulip_softc *sc)
+{
-	static const u_int8_t media[] = {
+	static const uint8_t media[] = {
 		TULIP_ROM_MB_MEDIA_TP,
 		TULIP_ROM_MB_MEDIA_TP_FDX,
 		TULIP_ROM_MB_MEDIA_BNC,
 		TULIP_ROM_MB_MEDIA_AUI,
 	};
 	int i, defmedia, devcnt, leaf_offset, mb_offset, m_cnt;
 	const struct tulip_srom_to_ifmedia *tsti;
 	struct tulip_21x4x_media *tm;
-	u_int16_t romdef;
+	uint16_t romdef;
-	u_int8_t mb;
+	uint8_t mb;
 	ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
 	    tlp_mediastatus);
 	if (tlp_isv_srom(sc->sc_srom) == 0) {
  not_isv_srom:
 		/*
 		 * If we have a board without the standard 21041 SROM format,
 		 * we just assume all media are present and try and pick a
 		 * reasonable default.
 		 */
 		tlp_add_srom_media(sc, 0, NULL, NULL, media, 4);
 @@ -4591,43 +4591,43 @@ tlp_21041_tmsw_init(struct tulip_softc *
  */
 static void	tlp_2114x_isv_tmsw_init(struct tulip_softc *);
 static void	tlp_2114x_isv_tmsw_get(struct tulip_softc *,
 		    struct ifmediareq *);
 static int	tlp_2114x_isv_tmsw_set(struct tulip_softc *);
 const struct tulip_mediasw tlp_2114x_isv_mediasw = {
 	tlp_2114x_isv_tmsw_init, tlp_2114x_isv_tmsw_get, tlp_2114x_isv_tmsw_set
 };
 static void	tlp_2114x_nway_get(struct tulip_softc *, struct ifmediareq *);
 static int	tlp_2114x_nway_set(struct tulip_softc *);
-static void	tlp_2114x_nway_statchg(struct device *);
+static void	tlp_2114x_nway_statchg(device_t);
 static int	tlp_2114x_nway_service(struct tulip_softc *, int);
 static void	tlp_2114x_nway_auto(struct tulip_softc *);
 static void	tlp_2114x_nway_status(struct tulip_softc *);
 static void
 tlp_2114x_isv_tmsw_init(struct tulip_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct ifmedia_entry *ife;
 	struct mii_softc *phy;
 	struct tulip_21x4x_media *tm;
 	const struct tulip_srom_to_ifmedia *tsti;
 	int i, devcnt, leaf_offset, m_cnt, type, length;
 	int defmedia, miidef;
-	u_int16_t word;
+	uint16_t word;
-	u_int8_t *cp, *ncp;
+	uint8_t *cp, *ncp;
 	defmedia = miidef = 0;
 	sc->sc_mii.mii_ifp = ifp;
 	sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
 	sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
 	sc->sc_mii.mii_statchg = sc->sc_statchg;
 	/*
 	 * Ignore `instance'; we may get a mixture of SIA and MII
 	 * media, and `instance' is used to isolate or select the
 	 * PHY on the MII as appropriate.  Note that duplicate media
 	 * are disallowed, so ignoring `instance' is safe.
 @@ -5154,27 +5154,27 @@ tlp_2114x_nway_get(struct tulip_softc *s
 	(void) tlp_2114x_nway_service(sc, MII_POLLSTAT);
 	ifmr->ifm_status = sc->sc_mii.mii_media_status;
 	ifmr->ifm_active = sc->sc_mii.mii_media_active;
+}
 static int
 tlp_2114x_nway_set(struct tulip_softc *sc)
+{
 	return (tlp_2114x_nway_service(sc, MII_MEDIACHG));
+}
 static void
-tlp_2114x_nway_statchg(struct device *self)
+tlp_2114x_nway_statchg(device_t self)
+{
 	struct tulip_softc *sc = (struct tulip_softc *)self;
 	struct mii_data *mii = &sc->sc_mii;
 	struct ifmedia_entry *ife;
 	if (IFM_SUBTYPE(mii->mii_media_active) == IFM_NONE)
 		return;
 	if ((ife = ifmedia_match(&mii->mii_media, mii->mii_media_active,
 	    mii->mii_media.ifm_mask)) == NULL) {
 		printf("tlp_2114x_nway_statchg: no match for media 0x%x/0x%x\n",
 		    mii->mii_media_active, ~mii->mii_media.ifm_mask);
 		panic("tlp_2114x_nway_statchg");
 @@ -5466,27 +5466,27 @@ tlp_sio_mii_tmsw_init(struct tulip_softc
+}
 /*
  * Lite-On PNIC media switch.  Must handle MII or internal NWAY.
  */
 static void	tlp_pnic_tmsw_init(struct tulip_softc *);
 static void	tlp_pnic_tmsw_get(struct tulip_softc *, struct ifmediareq *);
 static int	tlp_pnic_tmsw_set(struct tulip_softc *);
 const struct tulip_mediasw tlp_pnic_mediasw = {
 	tlp_pnic_tmsw_init, tlp_pnic_tmsw_get, tlp_pnic_tmsw_set
 };
-static void	tlp_pnic_nway_statchg(struct device *);
+static void	tlp_pnic_nway_statchg(device_t);
 static void	tlp_pnic_nway_tick(void *);
 static int	tlp_pnic_nway_service(struct tulip_softc *, int);
 static void	tlp_pnic_nway_reset(struct tulip_softc *);
 static int	tlp_pnic_nway_auto(struct tulip_softc *, int);
 static void	tlp_pnic_nway_auto_timeout(void *);
 static void	tlp_pnic_nway_status(struct tulip_softc *);
 static void	tlp_pnic_nway_acomp(struct tulip_softc *);
 static void
 tlp_pnic_tmsw_init(struct tulip_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	const char *sep = "";
 @@ -5577,27 +5577,27 @@ tlp_pnic_tmsw_set(struct tulip_softc *sc
 		return (tlp_mii_setmedia(sc));
+	}
 	if (ifp->if_flags & IFF_UP) {
 		mii->mii_media_status = 0;
 		mii->mii_media_active = IFM_NONE;
 		return (tlp_pnic_nway_service(sc, MII_MEDIACHG));
+	}
 	return (0);
+}
 static void
-tlp_pnic_nway_statchg(struct device *self)
+tlp_pnic_nway_statchg(device_t self)
+{
 	struct tulip_softc *sc = (struct tulip_softc *)self;
 	/* Idle the transmit and receive processes. */
 	tlp_idle(sc, OPMODE_ST|OPMODE_SR);
 	sc->sc_opmode &= ~(OPMODE_TTM|OPMODE_FD|OPMODE_PS|OPMODE_PCS|
 	    OPMODE_SCR|OPMODE_HBD);
 	if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) == IFM_10_T) {
 		sc->sc_opmode |= OPMODE_TTM;
 		TULIP_WRITE(sc, CSR_GPP,
 		    GPP_PNIC_OUT(GPP_PNIC_PIN_SPEED_RLY, 0) |
 @@ -5716,27 +5716,27 @@ static void
 tlp_pnic_nway_reset(struct tulip_softc *sc)
+{
 	TULIP_WRITE(sc, CSR_PNIC_NWAY, PNIC_NWAY_RS);
 	delay(100);
 	TULIP_WRITE(sc, CSR_PNIC_NWAY, 0);
+}
 static int
 tlp_pnic_nway_auto(struct tulip_softc *sc, int waitfor)
+{
 	struct mii_data *mii = &sc->sc_mii;
 	struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
-	u_int32_t reg;
+	uint32_t reg;
 	int i;
 	if ((sc->sc_flags & TULIPF_DOINGAUTO) == 0)
 		TULIP_WRITE(sc, CSR_PNIC_NWAY, ife->ifm_data);
 	if (waitfor) {
 		/* Wait 500ms for it to complete. */
 		for (i = 0; i < 500; i++) {
 			reg = TULIP_READ(sc, CSR_PNIC_NWAY);
 			if (reg & PNIC_NWAY_LPAR_MASK) {
 				tlp_pnic_nway_acomp(sc);
 				return (0);
+			}
 @@ -5762,49 +5762,49 @@ tlp_pnic_nway_auto(struct tulip_softc *s
 	 */
 	if ((sc->sc_flags & TULIPF_DOINGAUTO) == 0) {
 		sc->sc_flags |= TULIPF_DOINGAUTO;
 		callout_reset(&sc->sc_nway_callout, hz >> 1,
 		    tlp_pnic_nway_auto_timeout, sc);
+	}
 	return (EJUSTRETURN);
+}
 static void
 tlp_pnic_nway_auto_timeout(void *arg)
+{
 	struct tulip_softc *sc = arg;
-	u_int32_t reg;
+	uint32_t reg;
 	int s;
 	s = splnet();
 	sc->sc_flags &= ~TULIPF_DOINGAUTO;
 	reg = TULIP_READ(sc, CSR_PNIC_NWAY);
 #if 0
 	if ((reg & PNIC_NWAY_LPAR_MASK) == 0)
 		aprint_error_dev(&sc->sc_dev, "autonegotiation failed to complete\n");
 #endif
 	tlp_pnic_nway_acomp(sc);
 	/* Update the media status. */
 	(void) tlp_pnic_nway_service(sc, MII_POLLSTAT);
 	splx(s);
+}
 static void
 tlp_pnic_nway_status(struct tulip_softc *sc)
+{
 	struct mii_data *mii = &sc->sc_mii;
-	u_int32_t reg;
+	uint32_t reg;
 	mii->mii_media_status = IFM_AVALID;
 	mii->mii_media_active = IFM_ETHER;
 	reg = TULIP_READ(sc, CSR_PNIC_NWAY);
 	if (sc->sc_flags & TULIPF_LINK_UP)
 		mii->mii_media_status |= IFM_ACTIVE;
 	if (reg & PNIC_NWAY_NW) {
 		if ((reg & PNIC_NWAY_LPAR_MASK) == 0) {
 			/* Erg, still trying, I guess... */
 			mii->mii_media_active |= IFM_NONE;
 @@ -5829,27 +5829,27 @@ tlp_pnic_nway_status(struct tulip_softc
 	} else {
 		if (reg & PNIC_NWAY_100)
 			mii->mii_media_active |= IFM_100_TX;
 		else
 			mii->mii_media_active |= IFM_10_T;
 		if (reg & PNIC_NWAY_FD)
 			mii->mii_media_active |= IFM_FDX;
+	}
+}
 static void
 tlp_pnic_nway_acomp(struct tulip_softc *sc)
+{
-	u_int32_t reg;
+	uint32_t reg;
 	reg = TULIP_READ(sc, CSR_PNIC_NWAY);
 	reg &= ~(PNIC_NWAY_FD|PNIC_NWAY_100|PNIC_NWAY_RN);
 	if (reg & (PNIC_NWAY_LPAR100TXFDX|PNIC_NWAY_LPAR100TX))
 		reg |= PNIC_NWAY_100;
 	if (reg & (PNIC_NWAY_LPAR10TFDX|PNIC_NWAY_LPAR100TXFDX))
 		reg |= PNIC_NWAY_FD;
 	TULIP_WRITE(sc, CSR_PNIC_NWAY, reg);
+}
 /*
 @@ -5869,27 +5869,27 @@ tlp_pnic_nway_acomp(struct tulip_softc *
 static void	tlp_pmac_tmsw_init(struct tulip_softc *);
 const struct tulip_mediasw tlp_pmac_mediasw = {
 	tlp_pmac_tmsw_init, tlp_2114x_isv_tmsw_get, tlp_2114x_isv_tmsw_set
 };
 const struct tulip_mediasw tlp_pmac_mii_mediasw = {
 	tlp_pmac_tmsw_init, tlp_mii_getmedia, tlp_mii_setmedia
 };
 static void
 tlp_pmac_tmsw_init(struct tulip_softc *sc)
+{
-	static const u_int8_t media[] = {
+	static const uint8_t media[] = {
 		TULIP_ROM_MB_MEDIA_TP,
 		TULIP_ROM_MB_MEDIA_TP_FDX,
 		TULIP_ROM_MB_MEDIA_100TX,
 		TULIP_ROM_MB_MEDIA_100TX_FDX,
 	};
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	struct tulip_21x4x_media *tm;
 	sc->sc_mii.mii_ifp = ifp;
 	sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
 	sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
 	sc->sc_mii.mii_statchg = sc->sc_statchg;
 	ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
 @@ -6023,27 +6023,27 @@ static void	tlp_dm9102_tmsw_init(struct
 static void	tlp_dm9102_tmsw_getmedia(struct tulip_softc *,
 		    struct ifmediareq *);
 static int	tlp_dm9102_tmsw_setmedia(struct tulip_softc *);
 const struct tulip_mediasw tlp_dm9102_mediasw = {
 	tlp_dm9102_tmsw_init, tlp_dm9102_tmsw_getmedia,
 	    tlp_dm9102_tmsw_setmedia
 };
 static void
 tlp_dm9102_tmsw_init(struct tulip_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
-	u_int32_t opmode;
+	uint32_t opmode;
 	sc->sc_mii.mii_ifp = ifp;
 	sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
 	sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
 	sc->sc_mii.mii_statchg = sc->sc_statchg;
 	ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
 	    tlp_mediastatus);
 	/* PHY block already reset via tlp_reset(). */
 	/*
 	 * Configure OPMODE properly for the internal MII interface.
 	 */
 @@ -6106,27 +6106,27 @@ static void	tlp_asix_tmsw_init(struct tu
 static void	tlp_asix_tmsw_getmedia(struct tulip_softc *,
 		    struct ifmediareq *);
 static int	tlp_asix_tmsw_setmedia(struct tulip_softc *);
 const struct tulip_mediasw tlp_asix_mediasw = {
 	tlp_asix_tmsw_init, tlp_asix_tmsw_getmedia,
 	tlp_asix_tmsw_setmedia
 };
 static void
 tlp_asix_tmsw_init(struct tulip_softc *sc)
+{
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
-	u_int32_t opmode;
+	uint32_t opmode;
 	sc->sc_mii.mii_ifp = ifp;
         sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
         sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
 	sc->sc_mii.mii_statchg = sc->sc_statchg;
 	ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
             tlp_mediastatus);
 	/*
 	 * Configure OPMODE properly for the internal MII interface.
 	 */
 	switch (sc->sc_chip) {
 	case TULIP_CHIP_AX88140: