 @@ -1,1000 +1,996 @@
-/*	$NetBSD: if_aue.c,v 1.187 2022/03/03 05:55:01 riastradh Exp $	*/
+/*	$NetBSD: if_aue.c,v 1.188 2022/03/03 05:55:19 riastradh Exp $	*/
 /*
  * Copyright (c) 1997, 1998, 1999, 2000
  *	Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by Bill Paul.
  * 4. Neither the name of the author nor the names of any co-contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY Bill Paul 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 Bill Paul OR THE VOICES IN HIS HEAD
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
+ *
  * $FreeBSD: src/sys/dev/usb/if_aue.c,v 1.11 2000/01/14 01:36:14 wpaul Exp $
  */
 /*
  * ADMtek AN986 Pegasus and AN8511 Pegasus II USB to ethernet driver.
  * Datasheet is available from http://www.admtek.com.tw.
+ *
  * Written by Bill Paul <wpaul@ee.columbia.edu>
  * Electrical Engineering Department
  * Columbia University, New York City
  */
 /*
  * The Pegasus chip uses four USB "endpoints" to provide 10/100 ethernet
  * support: the control endpoint for reading/writing registers, burst
  * read endpoint for packet reception, burst write for packet transmission
  * and one for "interrupts." The chip uses the same RX filter scheme
  * as the other ADMtek ethernet parts: one perfect filter entry for the
  * the station address and a 64-bit multicast hash table. The chip supports
  * both MII and HomePNA attachments.
+ *
  * Since the maximum data transfer speed of USB is supposed to be 12Mbps,
  * you're never really going to get 100Mbps speeds from this device. I
  * think the idea is to allow the device to connect to 10 or 100Mbps
  * networks, not necessarily to provide 100Mbps performance. Also, since
  * the controller uses an external PHY chip, it's possible that board
  * designers might simply choose a 10Mbps PHY.
+ *
  * Registers are accessed using usbd_do_request(). Packet transfers are
  * done using usbd_transfer() and friends.
  */
 /*
  * Ported to NetBSD and somewhat rewritten by Lennart Augustsson.
  */
 /*
  * TODO:
  * better error messages from rxstat
  * more error checks
  * investigate short rx problem
  * proper cleanup on errors
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_aue.c,v 1.187 2022/03/03 05:55:01 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_aue.c,v 1.188 2022/03/03 05:55:19 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/usbhist.h>
 #include <dev/usb/if_auereg.h>
 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/if_inarp.h>
 #endif
 #ifdef USB_DEBUG
 #ifndef AUE_DEBUG
 #define auedebug 0
 #else
 static int auedebug = 10;
 SYSCTL_SETUP(sysctl_hw_aue_setup, "sysctl hw.aue setup")
+{
 	int err;
 	const struct sysctlnode *rnode;
 	const struct sysctlnode *cnode;
 	err = sysctl_createv(clog, 0, NULL, &rnode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "aue",
 	    SYSCTL_DESCR("aue global controls"),
 	    NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL);
 	if (err)
 		goto fail;
 	/* control debugging printfs */
 	err = sysctl_createv(clog, 0, &rnode, &cnode,
 	    CTLFLAG_PERMANENT | CTLFLAG_READWRITE, CTLTYPE_INT,
 	    "debug", SYSCTL_DESCR("Enable debugging output"),
 	    NULL, 0, &auedebug, sizeof(auedebug), CTL_CREATE, CTL_EOL);
 	if (err)
 		goto fail;
 	return;
 fail:
 	aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
+}
 #endif /* AUE_DEBUG */
 #endif /* USB_DEBUG */
 #define DPRINTF(FMT,A,B,C,D)	USBHIST_LOGN(auedebug,1,FMT,A,B,C,D)
 #define DPRINTFN(N,FMT,A,B,C,D)	USBHIST_LOGN(auedebug,N,FMT,A,B,C,D)
 #define AUEHIST_FUNC()		USBHIST_FUNC()
 #define AUEHIST_CALLED(name)	USBHIST_CALLED(auedebug)
 #define AUEHIST_CALLARGS(FMT,A,B,C,D) \
 				USBHIST_CALLARGS(auedebug,FMT,A,B,C,D)
 #define AUEHIST_CALLARGSN(N,FMT,A,B,C,D) \
 				USBHIST_CALLARGSN(auedebug,N,FMT,A,B,C,D)
 #define AUE_TX_LIST_CNT		1
 #define AUE_RX_LIST_CNT		1
 struct aue_softc {
 	struct usbnet		aue_un;
 	struct usbnet_intr	aue_intr;
 	struct aue_intrpkt	aue_ibuf;
 };
 #define AUE_TIMEOUT		1000
 #define AUE_BUFSZ		1536
 #define AUE_MIN_FRAMELEN	60
 #define AUE_TX_TIMEOUT		10000 /* ms */
 #define AUE_INTR_INTERVAL	100 /* ms */
 /*
  * Various supported device vendors/products.
  */
 struct aue_type {
 	struct usb_devno	aue_dev;
 	uint16_t		aue_flags;
 #define LSYS	0x0001		/* use Linksys reset */
 #define PNA	0x0002		/* has Home PNA */
 #define PII	0x0004		/* Pegasus II chip */
 };
 static const struct aue_type aue_devs[] = {
  {{ USB_VENDOR_3COM,		USB_PRODUCT_3COM_3C460B},	  PII },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX1},	  PNA | PII },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX2},	  PII },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_UFE1000},	  LSYS },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX4},	  PNA },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX5},	  PNA },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX6},	  PII },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX7},	  PII },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX8},	  PII },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX9},	  PNA },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_XX10},	  0 },
  {{ USB_VENDOR_ABOCOM,		USB_PRODUCT_ABOCOM_DSB650TX_PNA}, 0 },
  {{ USB_VENDOR_ACCTON,		USB_PRODUCT_ACCTON_USB320_EC},	  0 },
  {{ USB_VENDOR_ACCTON,		USB_PRODUCT_ACCTON_SS1001},	  PII },
  {{ USB_VENDOR_ADMTEK,		USB_PRODUCT_ADMTEK_PEGASUS},	  PNA },
  {{ USB_VENDOR_ADMTEK,		USB_PRODUCT_ADMTEK_PEGASUSII},	  PII },
  {{ USB_VENDOR_ADMTEK,		USB_PRODUCT_ADMTEK_PEGASUSII_2},  PII },
  {{ USB_VENDOR_ADMTEK,		USB_PRODUCT_ADMTEK_PEGASUSII_3},  PII },
  {{ USB_VENDOR_AEI,		USB_PRODUCT_AEI_USBTOLAN},	  PII },
  {{ USB_VENDOR_BELKIN,		USB_PRODUCT_BELKIN_USB2LAN},	  PII },
  {{ USB_VENDOR_BILLIONTON,	USB_PRODUCT_BILLIONTON_USB100},	  0 },
  {{ USB_VENDOR_BILLIONTON,	USB_PRODUCT_BILLIONTON_USBLP100}, PNA },
  {{ USB_VENDOR_BILLIONTON,	USB_PRODUCT_BILLIONTON_USBEL100}, 0 },
  {{ USB_VENDOR_BILLIONTON,	USB_PRODUCT_BILLIONTON_USBE100},  PII },
  {{ USB_VENDOR_COMPAQ,		USB_PRODUCT_COMPAQ_HNE200},	  PII },
  {{ USB_VENDOR_COREGA,		USB_PRODUCT_COREGA_FETHER_USB_TX}, 0 },
  {{ USB_VENDOR_COREGA,		USB_PRODUCT_COREGA_FETHER_USB_TXS},PII },
  {{ USB_VENDOR_DLINK,		USB_PRODUCT_DLINK_DSB650TX4},	  LSYS | PII },
  {{ USB_VENDOR_DLINK,		USB_PRODUCT_DLINK_DSB650TX1},	  LSYS },
  {{ USB_VENDOR_DLINK,		USB_PRODUCT_DLINK_DSB650TX},	  LSYS },
  {{ USB_VENDOR_DLINK,		USB_PRODUCT_DLINK_DSB650TX_PNA},  PNA },
  {{ USB_VENDOR_DLINK,		USB_PRODUCT_DLINK_DSB650TX3},	  LSYS | PII },
  {{ USB_VENDOR_DLINK,		USB_PRODUCT_DLINK_DSB650TX2},	  LSYS | PII },
  {{ USB_VENDOR_DLINK,		USB_PRODUCT_DLINK_DSB650},	  0 },
  {{ USB_VENDOR_ELECOM,		USB_PRODUCT_ELECOM_LDUSBTX0},	  0 },
  {{ USB_VENDOR_ELECOM,		USB_PRODUCT_ELECOM_LDUSBTX1},	  LSYS },
  {{ USB_VENDOR_ELECOM,		USB_PRODUCT_ELECOM_LDUSBTX2},	  0 },
  {{ USB_VENDOR_ELECOM,		USB_PRODUCT_ELECOM_LDUSBTX3},	  LSYS },
  {{ USB_VENDOR_ELECOM,		USB_PRODUCT_ELECOM_LDUSBLTX},	  PII },
  {{ USB_VENDOR_ELSA,		USB_PRODUCT_ELSA_USB2ETHERNET},	  0 },
  {{ USB_VENDOR_HAWKING,		USB_PRODUCT_HAWKING_UF100},	  PII },
  {{ USB_VENDOR_HP,		USB_PRODUCT_HP_HN210E},		  PII },
  {{ USB_VENDOR_IODATA,		USB_PRODUCT_IODATA_USBETTX},	  0 },
  {{ USB_VENDOR_IODATA,		USB_PRODUCT_IODATA_USBETTXS},	  PII },
  {{ USB_VENDOR_IODATA,		USB_PRODUCT_IODATA_ETXUS2},	  PII },
  {{ USB_VENDOR_KINGSTON,	USB_PRODUCT_KINGSTON_KNU101TX},	  0 },
  {{ USB_VENDOR_LINKSYS,		USB_PRODUCT_LINKSYS_USB10TX1},	  LSYS | PII },
  {{ USB_VENDOR_LINKSYS,		USB_PRODUCT_LINKSYS_USB10T},	  LSYS },
  {{ USB_VENDOR_LINKSYS,		USB_PRODUCT_LINKSYS_USB100TX},	  LSYS },
  {{ USB_VENDOR_LINKSYS,		USB_PRODUCT_LINKSYS_USB100H1},	  LSYS | PNA },
  {{ USB_VENDOR_LINKSYS,		USB_PRODUCT_LINKSYS_USB10TA},	  LSYS },
  {{ USB_VENDOR_LINKSYS,		USB_PRODUCT_LINKSYS_USB10TX2},	  LSYS | PII },
  {{ USB_VENDOR_MELCO,		USB_PRODUCT_MELCO_LUATX1},	  0 },
  {{ USB_VENDOR_MELCO,		USB_PRODUCT_MELCO_LUATX5},	  0 },
  {{ USB_VENDOR_MELCO,		USB_PRODUCT_MELCO_LUA2TX5},	  PII },
  {{ USB_VENDOR_MICROSOFT,	USB_PRODUCT_MICROSOFT_MN110},	  PII },
  {{ USB_VENDOR_NETGEAR,		USB_PRODUCT_NETGEAR_FA101},	  PII },
  {{ USB_VENDOR_SIEMENS,		USB_PRODUCT_SIEMENS_SPEEDSTREAM}, PII },
  {{ USB_VENDOR_SMARTBRIDGES,	USB_PRODUCT_SMARTBRIDGES_SMARTNIC},PII },
  {{ USB_VENDOR_SMC,		USB_PRODUCT_SMC_2202USB},	  0 },
  {{ USB_VENDOR_SMC,		USB_PRODUCT_SMC_2206USB},	  PII },
  {{ USB_VENDOR_SOHOWARE,	USB_PRODUCT_SOHOWARE_NUB100},	  0 },
 };
 #define aue_lookup(v, p) ((const struct aue_type *)usb_lookup(aue_devs, v, p))
 static int aue_match(device_t, cfdata_t, void *);
 static void aue_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(aue, sizeof(struct aue_softc), aue_match, aue_attach,
     usbnet_detach, usbnet_activate);
 static void aue_reset_pegasus_II(struct aue_softc *);
 static void aue_uno_stop(struct ifnet *, int);
 static void aue_uno_mcast(struct ifnet *);
 static int aue_uno_mii_read_reg(struct usbnet *, int, int, uint16_t *);
 static int aue_uno_mii_write_reg(struct usbnet *, int, int, uint16_t);
 static void aue_uno_mii_statchg(struct ifnet *);
 static unsigned aue_uno_tx_prepare(struct usbnet *, struct mbuf *,
 				   struct usbnet_chain *);
 static void aue_uno_rx_loop(struct usbnet *, struct usbnet_chain *, uint32_t);
 static int aue_uno_init(struct ifnet *);
 static void aue_uno_intr(struct usbnet *, usbd_status);
 static const struct usbnet_ops aue_ops = {
 	.uno_stop = aue_uno_stop,
 	.uno_mcast = aue_uno_mcast,
 	.uno_read_reg = aue_uno_mii_read_reg,
 	.uno_write_reg = aue_uno_mii_write_reg,
 	.uno_statchg = aue_uno_mii_statchg,
 	.uno_tx_prepare = aue_uno_tx_prepare,
 	.uno_rx_loop = aue_uno_rx_loop,
 	.uno_init = aue_uno_init,
 	.uno_intr = aue_uno_intr,
 };
 static uint32_t aue_crc(void *);
 static void aue_reset(struct aue_softc *);
 static int aue_csr_read_1(struct aue_softc *, int);
 static int aue_csr_write_1(struct aue_softc *, int, int);
 static int aue_csr_read_2(struct aue_softc *, int);
 static int aue_csr_write_2(struct aue_softc *, int, int);
 #define AUE_SETBIT(sc, reg, x)				\
 	aue_csr_write_1(sc, reg, aue_csr_read_1(sc, reg) | (x))
 #define AUE_CLRBIT(sc, reg, x)				\
 	aue_csr_write_1(sc, reg, aue_csr_read_1(sc, reg) & ~(x))
 static int
 aue_csr_read_1(struct aue_softc *sc, int reg)
+{
 	struct usbnet * const	un = &sc->aue_un;
 	usb_device_request_t	req;
 	usbd_status		err;
 	uByte			val = 0;
 	if (usbnet_isdying(un))
 		return 0;
 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	req.bRequest = AUE_UR_READREG;
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 1);
 	err = usbd_do_request(un->un_udev, &req, &val);
 	if (err) {
 		AUEHIST_FUNC();
 		AUEHIST_CALLARGS("aue%jd: reg=%#jx err=%jd",
 		    device_unit(un->un_dev), reg, err, 0);
 		return 0;
+	}
 	return val;
+}
 static int
 aue_csr_read_2(struct aue_softc *sc, int reg)
+{
 	struct usbnet * const	un = &sc->aue_un;
 	usb_device_request_t	req;
 	usbd_status		err;
 	uWord			val;
 	if (usbnet_isdying(un))
 		return 0;
 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	req.bRequest = AUE_UR_READREG;
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 2);
 	err = usbd_do_request(un->un_udev, &req, &val);
 	if (err) {
 		AUEHIST_FUNC();
 		AUEHIST_CALLARGS("aue%jd: reg=%#jx err=%jd",
 		    device_unit(un->un_dev), reg, err, 0);
 		return 0;
+	}
 	return UGETW(val);
+}
 static int
 aue_csr_write_1(struct aue_softc *sc, int reg, int aval)
+{
 	struct usbnet * const	un = &sc->aue_un;
 	usb_device_request_t	req;
 	usbd_status		err;
 	uByte			val;
 	if (usbnet_isdying(un))
 		return 0;
 	val = aval;
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = AUE_UR_WRITEREG;
 	USETW(req.wValue, val);
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 1);
 	err = usbd_do_request(un->un_udev, &req, &val);
 	if (err) {
 		AUEHIST_FUNC();
 		AUEHIST_CALLARGS("aue%jd: reg=%#jx err=%jd",
 		    device_unit(un->un_dev), reg, err, 0);
 		return -1;
+	}
 	return 0;
+}
 static int
 aue_csr_write_2(struct aue_softc *sc, int reg, int aval)
+{
 	struct usbnet * const	un = &sc->aue_un;
 	usb_device_request_t	req;
 	usbd_status		err;
 	uWord			val;
 	if (usbnet_isdying(un))
 		return 0;
 	USETW(val, aval);
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = AUE_UR_WRITEREG;
 	USETW(req.wValue, aval);
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 2);
 	err = usbd_do_request(un->un_udev, &req, &val);
 	if (err) {
 		AUEHIST_FUNC();
 		AUEHIST_CALLARGS("aue%jd: reg=%#jx err=%jd",
 		    device_unit(un->un_dev), reg, err, 0);
 		return -1;
+	}
 	return 0;
+}
 /*
  * Read a word of data stored in the EEPROM at address 'addr.'
  */
 static int
 aue_eeprom_getword(struct aue_softc *sc, int addr)
+{
 	struct usbnet * const	un = &sc->aue_un;
 	int			i;
 	AUEHIST_FUNC(); AUEHIST_CALLED();
 	aue_csr_write_1(sc, AUE_EE_REG, addr);
 	aue_csr_write_1(sc, AUE_EE_CTL, AUE_EECTL_READ);
 	for (i = 0; i < AUE_TIMEOUT; i++) {
 		if (aue_csr_read_1(sc, AUE_EE_CTL) & AUE_EECTL_DONE)
 			break;
+	}
 	if (i == AUE_TIMEOUT) {
 		printf("%s: EEPROM read timed out\n",
 		    device_xname(un->un_dev));
+	}
 	return aue_csr_read_2(sc, AUE_EE_DATA);
+}
 /*
  * Read the MAC from the EEPROM.  It's at offset 0.
  */
 static void
 aue_read_mac(struct usbnet *un)
+{
 	struct aue_softc	*sc = usbnet_softc(un);
 	int			i;
 	int			off = 0;
 	int			word;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGS("aue%jd: enter",
 	    device_unit(un->un_dev), 0, 0, 0);
 	for (i = 0; i < 3; i++) {
 		word = aue_eeprom_getword(sc, off + i);
 		un->un_eaddr[2 * i] =     (u_char)word;
 		un->un_eaddr[2 * i + 1] = (u_char)(word >> 8);
+	}
+}
 static int
 aue_uno_mii_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
+{
 	struct aue_softc	*sc = usbnet_softc(un);
 	int			i;
 	AUEHIST_FUNC();
 #if 0
 	/*
 	 * The Am79C901 HomePNA PHY actually contains
 	 * two transceivers: a 1Mbps HomePNA PHY and a
 	 * 10Mbps full/half duplex ethernet PHY with
 	 * NWAY autoneg. However in the ADMtek adapter,
 	 * only the 1Mbps PHY is actually connected to
 	 * anything, so we ignore the 10Mbps one. It
 	 * happens to be configured for MII address 3,
 	 * so we filter that out.
 	 */
 	if (sc->aue_vendor == USB_VENDOR_ADMTEK &&
 	    sc->aue_product == USB_PRODUCT_ADMTEK_PEGASUS) {
 		if (phy == 3) {
 			*val = 0;
 			return EINVAL;
+		}
+	}
 #endif
 	aue_csr_write_1(sc, AUE_PHY_ADDR, phy);
 	aue_csr_write_1(sc, AUE_PHY_CTL, reg | AUE_PHYCTL_READ);
 	for (i = 0; i < AUE_TIMEOUT; i++) {
 		if (usbnet_isdying(un)) {
 			*val = 0;
 			return ENXIO;
+		}
 		if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
 			break;
+	}
 	if (i == AUE_TIMEOUT) {
 		AUEHIST_CALLARGS("aue%jd: phy=%#jx reg=%#jx read timed out",
 		    device_unit(un->un_dev), phy, reg, 0);
 		*val = 0;
 		return ETIMEDOUT;
+	}
 	*val = aue_csr_read_2(sc, AUE_PHY_DATA);
 	AUEHIST_CALLARGSN(11, "aue%jd: phy=%#jx reg=%#jx => 0x%04jx",
 	    device_unit(un->un_dev), phy, reg, *val);
 	return 0;
+}
 static int
 aue_uno_mii_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
+{
 	struct aue_softc	*sc = usbnet_softc(un);
 	int			i;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(11, "aue%jd: phy=%jd reg=%jd data=0x%04jx",
 	    device_unit(un->un_dev), phy, reg, val);
 #if 0
 	if (sc->aue_vendor == USB_VENDOR_ADMTEK &&
 	    sc->aue_product == USB_PRODUCT_ADMTEK_PEGASUS) {
 		if (phy == 3)
 			return EINVAL;
+	}
 #endif
 	aue_csr_write_2(sc, AUE_PHY_DATA, val);
 	aue_csr_write_1(sc, AUE_PHY_ADDR, phy);
 	aue_csr_write_1(sc, AUE_PHY_CTL, reg | AUE_PHYCTL_WRITE);
 	for (i = 0; i < AUE_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return ENXIO;
 		if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
 			break;
+	}
 	if (i == AUE_TIMEOUT) {
 		DPRINTF("aue%jd: phy=%#jx reg=%#jx val=%#jx write timed out",
 		    device_unit(un->un_dev), phy, reg, val);
 		return ETIMEDOUT;
+	}
 	return 0;
+}
 static void
 aue_uno_mii_statchg(struct ifnet *ifp)
+{
 	struct usbnet *un = ifp->if_softc;
 	struct aue_softc *sc = usbnet_softc(un);
 	struct mii_data	*mii = usbnet_mii(un);
 	const bool hadlink __diagused = usbnet_havelink(un);
 	AUEHIST_FUNC(); AUEHIST_CALLED();
 	AUEHIST_CALLARGSN(5, "aue%jd: ifp=%#jx link=%jd",
 	    device_unit(un->un_dev), (uintptr_t)ifp, hadlink, 0);
 	AUE_CLRBIT(sc, AUE_CTL0, AUE_CTL0_RX_ENB | AUE_CTL0_TX_ENB);
 	if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) {
 		AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_SPEEDSEL);
 	} else {
 		AUE_CLRBIT(sc, AUE_CTL1, AUE_CTL1_SPEEDSEL);
+	}
 	if ((mii->mii_media_active & IFM_FDX) != 0)
 		AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_DUPLEX);
 	else
 		AUE_CLRBIT(sc, AUE_CTL1, AUE_CTL1_DUPLEX);
 	AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_RX_ENB | AUE_CTL0_TX_ENB);
 	if (mii->mii_media_status & IFM_ACTIVE &&
 	    IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
 		usbnet_set_link(un, true);
+	}
 	/*
 	 * Set the LED modes on the LinkSys adapter.
 	 * This turns on the 'dual link LED' bin in the auxmode
 	 * register of the Broadcom PHY.
 	 */
 	if (!usbnet_isdying(un) && (un->un_flags & LSYS)) {
 		uint16_t auxmode;
 		aue_uno_mii_read_reg(un, 0, 0x1b, &auxmode);
 		aue_uno_mii_write_reg(un, 0, 0x1b, auxmode | 0x04);
+	}
 	if (usbnet_havelink(un) != hadlink) {
 		DPRINTFN(5, "aue%jd: exit link %jd",
 		    device_unit(un->un_dev), usbnet_havelink(un), 0, 0);
+	}
+}
 #define AUE_POLY	0xEDB88320
 #define AUE_BITS	6
 static uint32_t
 aue_crc(void *addrv)
+{
 	uint32_t		idx, bit, data, crc;
 	char *addr = addrv;
 	/* Compute CRC for the address value. */
 	crc = 0xFFFFFFFF; /* initial value */
 	for (idx = 0; idx < 6; idx++) {
 		for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1)
 			crc = (crc >> 1) ^ (((crc ^ data) & 1) ? AUE_POLY : 0);
+	}
 	return crc & ((1 << AUE_BITS) - 1);
+}
 static void
 aue_uno_mcast(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct aue_softc * const sc = usbnet_softc(un);
 	struct ethercom *	ec = usbnet_ec(un);
 	struct ether_multi	*enm;
 	struct ether_multistep	step;
 	uint32_t		h = 0, i;
 	uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(5, "aue%jd: enter", device_unit(un->un_dev), 0, 0, 0);
 	if (ifp->if_flags & IFF_PROMISC) {
 		ETHER_LOCK(ec);
 allmulti:
 		ec->ec_flags |= ETHER_F_ALLMULTI;
 		ETHER_UNLOCK(ec);
 		AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_ALLMULTI);
 		return;
+	}
 	/* now program new ones */
 	ETHER_LOCK(ec);
 	ETHER_FIRST_MULTI(step, ec, enm);
 	while (enm != NULL) {
 		if (memcmp(enm->enm_addrlo,
 		    enm->enm_addrhi, ETHER_ADDR_LEN) != 0) {
 			goto allmulti;
+		}
 		h = aue_crc(enm->enm_addrlo);
 		hashtbl[h >> 3] |= 1 << (h & 0x7);
 		ETHER_NEXT_MULTI(step, enm);
+	}
 	ec->ec_flags &= ~ETHER_F_ALLMULTI;
 	ETHER_UNLOCK(ec);
 	AUE_CLRBIT(sc, AUE_CTL0, AUE_CTL0_ALLMULTI);
 	/* write the hashtable */
 	for (i = 0; i < 8; i++)
 		aue_csr_write_1(sc, AUE_MAR0 + i, hashtbl[i]);
+}
 static void
 aue_reset_pegasus_II(struct aue_softc *sc)
+{
 	/* Magic constants taken from Linux driver. */
 	aue_csr_write_1(sc, AUE_REG_1D, 0);
 	aue_csr_write_1(sc, AUE_REG_7B, 2);
 #if 0
 	if ((un->un_flags & PNA) && mii_mode)
 		aue_csr_write_1(sc, AUE_REG_81, 6);
 	else
 #endif
 		aue_csr_write_1(sc, AUE_REG_81, 2);
+}
 static void
 aue_reset(struct aue_softc *sc)
+{
 	struct usbnet * const un = &sc->aue_un;
 	int		i;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(2, "aue%jd: enter", device_unit(un->un_dev), 0, 0, 0);
 	AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_RESETMAC);
 	for (i = 0; i < AUE_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return;
 		if (!(aue_csr_read_1(sc, AUE_CTL1) & AUE_CTL1_RESETMAC))
 			break;
+	}
 	if (i == AUE_TIMEOUT)
 		printf("%s: reset failed\n", device_xname(un->un_dev));
 #if 0
 	/* XXX what is mii_mode supposed to be */
 	if (sc->sc_mii_mode && (un->un_flags & PNA))
 		aue_csr_write_1(sc, AUE_GPIO1, 0x34);
 	else
 		aue_csr_write_1(sc, AUE_GPIO1, 0x26);
 #endif
 	/*
 	 * The PHY(s) attached to the Pegasus chip may be held
 	 * in reset until we flip on the GPIO outputs. Make sure
 	 * to set the GPIO pins high so that the PHY(s) will
 	 * be enabled.
+	 *
 	 * Note: We force all of the GPIO pins low first, *then*
 	 * enable the ones we want.
 	 */
 	if (un->un_flags & LSYS) {
 		/* Grrr. LinkSys has to be different from everyone else. */
 		aue_csr_write_1(sc, AUE_GPIO0,
 		    AUE_GPIO_SEL0 | AUE_GPIO_SEL1);
 	} else {
 		aue_csr_write_1(sc, AUE_GPIO0,
 		    AUE_GPIO_OUT0 | AUE_GPIO_SEL0);
+	}
 	aue_csr_write_1(sc, AUE_GPIO0,
 	    AUE_GPIO_OUT0 | AUE_GPIO_SEL0 | AUE_GPIO_SEL1);
 	if (un->un_flags & PII)
 		aue_reset_pegasus_II(sc);
 	/* Wait a little while for the chip to get its brains in order. */
 	delay(10000);	/* XXX */
 	//usbd_delay_ms(un->un_udev, 10);	/* XXX */
 	DPRINTFN(2, "aue%jd: exit", device_unit(un->un_dev), 0, 0, 0);
+}
 /*
  * Probe for a Pegasus chip.
  */
 static int
 aue_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	/*
 	 * Some manufacturers use the same vendor and product id for
 	 * different devices. We need to sanity check the DeviceClass
 	 * in this case
 	 * Currently known guilty products:
 	 * 0x050d/0x0121 Belkin Bluetooth and USB2LAN
+	 *
 	 * If this turns out to be more common, we could use a quirk
 	 * table.
 	 */
 	if (uaa->uaa_vendor == USB_VENDOR_BELKIN &&
 		uaa->uaa_product == USB_PRODUCT_BELKIN_USB2LAN) {
 		usb_device_descriptor_t *dd;
 		dd = usbd_get_device_descriptor(uaa->uaa_device);
 		if (dd != NULL &&
 			dd->bDeviceClass != UDCLASS_IN_INTERFACE)
 			return UMATCH_NONE;
+	}
 	return aue_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
 		UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 /*
  * Attach the interface. Allocate softc structures, do ifmedia
  * setup and ethernet/BPF attach.
  */
 static void
 aue_attach(device_t parent, device_t self, void *aux)
+{
 	USBNET_MII_DECL_DEFAULT(unm);
 	struct aue_softc * const sc = device_private(self);
 	struct usbnet * const un = &sc->aue_un;
 	struct usb_attach_arg *uaa = aux;
 	char			*devinfop;
 	struct usbd_device	*dev = uaa->uaa_device;
 	usbd_status		err;
 	usb_interface_descriptor_t	*id;
 	usb_endpoint_descriptor_t	*ed;
 	int			i;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(2, "aue%jd: enter sc=%#jx",
 	    device_unit(self), (uintptr_t)sc, 0, 0);
 	KASSERT((void *)sc == un);
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(uaa->uaa_device, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	un->un_dev = self;
 	un->un_udev = dev;
 	un->un_sc = sc;
 	un->un_ops = &aue_ops;
 	un->un_intr = &sc->aue_intr;
 	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
 	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
 	un->un_rx_list_cnt = AUE_RX_LIST_CNT;
 	un->un_tx_list_cnt = AUE_RX_LIST_CNT;
 	un->un_rx_bufsz = AUE_BUFSZ;
 	un->un_tx_bufsz = AUE_BUFSZ;
 	sc->aue_intr.uni_buf = &sc->aue_ibuf;
 	sc->aue_intr.uni_bufsz = sizeof(sc->aue_ibuf);
 	sc->aue_intr.uni_interval = AUE_INTR_INTERVAL;
 	err = usbd_set_config_no(dev, AUE_CONFIG_NO, 1);
 	if (err) {
 		aprint_error_dev(self, "failed to set configuration"
 		    ", err=%s\n", usbd_errstr(err));
 		return;
+	}
 	err = usbd_device2interface_handle(dev, AUE_IFACE_IDX, &un->un_iface);
 	if (err) {
 		aprint_error_dev(self, "getting interface handle failed\n");
 		return;
+	}
 	un->un_flags = aue_lookup(uaa->uaa_vendor, uaa->uaa_product)->aue_flags;
 	id = usbd_get_interface_descriptor(un->un_iface);
 	/* Find endpoints. */
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(un->un_iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self,
 			    "couldn't get endpoint descriptor %d\n", i);
 			return;
+		}
 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
 			un->un_ed[USBNET_ENDPT_INTR] = ed->bEndpointAddress;
+		}
+	}
 	if (un->un_ed[USBNET_ENDPT_RX] == 0 ||
 	    un->un_ed[USBNET_ENDPT_TX] == 0 ||
 	    un->un_ed[USBNET_ENDPT_INTR] == 0) {
 		aprint_error_dev(self, "missing endpoint\n");
 		return;
+	}
 	/* First level attach. */
 	usbnet_attach(un, "auedet");
 	/* Reset the adapter and get station address from the EEPROM.  */
 	aue_reset(sc);
 	aue_read_mac(un);
 	usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
 , &unm);
+}
 static void
 aue_uno_intr(struct usbnet *un, usbd_status status)
+{
 	struct ifnet		*ifp = usbnet_ifp(un);
 	struct aue_softc	*sc = usbnet_softc(un);
 	struct aue_intrpkt	*p = &sc->aue_ibuf;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(20, "aue%jd: enter txstat0 %#jx\n",
 	    device_unit(un->un_dev), p->aue_txstat0, 0, 0);
 	if (p->aue_txstat0)
 		if_statinc(ifp, if_oerrors);
 	if (p->aue_txstat0 & (AUE_TXSTAT0_LATECOLL | AUE_TXSTAT0_EXCESSCOLL))
 		if_statinc(ifp, if_collisions);
+}
 static void
 aue_uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len)
+{
 	struct ifnet		*ifp = usbnet_ifp(un);
 	uint8_t			*buf = c->unc_buf;
 	struct aue_rxpkt	r;
 	uint32_t		pktlen;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(10, "aue%jd: enter len %ju",
 	    device_unit(un->un_dev), total_len, 0, 0);
 	if (total_len <= 4 + ETHER_CRC_LEN) {
 		if_statinc(ifp, if_ierrors);
 		return;
+	}
 	memcpy(&r, buf + total_len - 4, sizeof(r));
 	/* Turn off all the non-error bits in the rx status word. */
 	r.aue_rxstat &= AUE_RXSTAT_MASK;
 	if (r.aue_rxstat) {
 		if_statinc(ifp, if_ierrors);
 		return;
+	}
 	/* No errors; receive the packet. */
 	pktlen = total_len - ETHER_CRC_LEN - 4;
 	usbnet_enqueue(un, buf, pktlen, 0, 0, 0);
+}
 static unsigned
 aue_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	uint8_t			*buf = c->unc_buf;
 	int			total_len;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(10, "aue%jd: enter pktlen=%jd",
 	    device_unit(un->un_dev), m->m_pkthdr.len, 0, 0);
 	if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz - 2)
 		return 0;
 	/*
 	 * Copy the mbuf data into a contiguous buffer, leaving two
 	 * bytes at the beginning to hold the frame length.
 	 */
 	m_copydata(m, 0, m->m_pkthdr.len, buf + 2);
 	/*
 	 * The ADMtek documentation says that the packet length is
 	 * supposed to be specified in the first two bytes of the
 	 * transfer, however it actually seems to ignore this info
 	 * and base the frame size on the bulk transfer length.
 	 */
 	buf[0] = (uint8_t)m->m_pkthdr.len;
 	buf[1] = (uint8_t)(m->m_pkthdr.len >> 8);
 	total_len = m->m_pkthdr.len + 2;
 	DPRINTFN(5, "aue%jd: send %jd bytes",
 	    device_unit(un->un_dev), total_len, 0, 0);
 	return total_len;
+}
 static int
 aue_uno_init(struct ifnet *ifp)
+{
 	struct usbnet * const	un = ifp->if_softc;
 	struct aue_softc	*sc = usbnet_softc(un);
 	int			i;
 	const u_char		*eaddr;
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(5, "aue%jd: enter link=%jd",
 	    device_unit(un->un_dev), usbnet_havelink(un), 0, 0);
 	/* Cancel pending I/O */
 	if (ifp->if_flags & IFF_RUNNING)
 		return 0;
 	/* Reset the interface. */
 	aue_reset(sc);
 	eaddr = CLLADDR(ifp->if_sadl);
 	for (i = 0; i < ETHER_ADDR_LEN; i++)
 		aue_csr_write_1(sc, AUE_PAR0 + i, eaddr[i]);
 	 /* If we want promiscuous mode, set the allframes bit. */
 	if (ifp->if_flags & IFF_PROMISC)
 		AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
 	else
 		AUE_CLRBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
 	/* Enable RX and TX */
 	aue_csr_write_1(sc, AUE_CTL0, AUE_CTL0_RXSTAT_APPEND | AUE_CTL0_RX_ENB);
 	AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_TX_ENB);
 	AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_EP3_CLR);
 	return usbnet_init_rx_tx(un);
+}
 static void
 aue_uno_stop(struct ifnet *ifp, int disable)
+{
 	struct usbnet * const	un = ifp->if_softc;
 	struct aue_softc * const sc = usbnet_softc(un);
 	AUEHIST_FUNC();
 	AUEHIST_CALLARGSN(5, "aue%jd: enter", device_unit(un->un_dev), 0, 0, 0);
 	aue_csr_write_1(sc, AUE_CTL0, 0);
 	aue_csr_write_1(sc, AUE_CTL1, 0);
 	aue_reset(sc);
+}
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 USBNET_MODULE(aue)

 @@ -1,1297 +1,1293 @@
-/*	$NetBSD: if_mue.c,v 1.78 2022/03/03 05:55:01 riastradh Exp $	*/
+/*	$NetBSD: if_mue.c,v 1.79 2022/03/03 05:55:19 riastradh Exp $	*/
 /*	$OpenBSD: if_mue.c,v 1.3 2018/08/04 16:42:46 jsg Exp $	*/
 /*
  * Copyright (c) 2018 Kevin Lo <kevlo@openbsd.org>
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 /* Driver for Microchip LAN7500/LAN7800 chipsets. */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_mue.c,v 1.78 2022/03/03 05:55:01 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_mue.c,v 1.79 2022/03/03 05:55:19 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/if_muereg.h>
 #include <dev/usb/if_muevar.h>
 #define MUE_PRINTF(un, fmt, args...)					\
 	device_printf((un)->un_dev, "%s: " fmt, __func__, ##args);
 #ifdef USB_DEBUG
 int muedebug = 0;
 #define DPRINTF(un, fmt, args...)					\
 	do {								\
 		if (muedebug)						\
 			MUE_PRINTF(un, fmt, ##args);			\
 	} while (0 /* CONSTCOND */)
 #else
 #define DPRINTF(un, fmt, args...)	__nothing
 #endif
 /*
  * Various supported device vendors/products.
  */
 struct mue_type {
 	struct usb_devno	mue_dev;
 	uint16_t		mue_flags;
 #define LAN7500		0x0001	/* LAN7500 */
 #define LAN7800		0x0002	/* LAN7800 */
 #define LAN7801		0x0004	/* LAN7801 */
 #define LAN7850		0x0008	/* LAN7850 */
 };
 static const struct mue_type mue_devs[] = {
 	{ { USB_VENDOR_SMSC, USB_PRODUCT_SMSC_LAN7500 }, LAN7500 },
 	{ { USB_VENDOR_SMSC, USB_PRODUCT_SMSC_LAN7505 }, LAN7500 },
 	{ { USB_VENDOR_SMSC, USB_PRODUCT_SMSC_LAN7800 }, LAN7800 },
 	{ { USB_VENDOR_SMSC, USB_PRODUCT_SMSC_LAN7801 }, LAN7801 },
 	{ { USB_VENDOR_SMSC, USB_PRODUCT_SMSC_LAN7850 }, LAN7850 }
 };
 #define MUE_LOOKUP(uaa)	((const struct mue_type *)usb_lookup(mue_devs, \
     uaa->uaa_vendor, uaa->uaa_product))
 #define MUE_ENADDR_LO(enaddr) \
     ((enaddr[3] << 24) | (enaddr[2] << 16) | (enaddr[1] << 8) | enaddr[0])
 #define MUE_ENADDR_HI(enaddr) \
     ((enaddr[5] << 8) | enaddr[4])
 static int	mue_match(device_t, cfdata_t, void *);
 static void	mue_attach(device_t, device_t, void *);
 static uint32_t	mue_csr_read(struct usbnet *, uint32_t);
 static int	mue_csr_write(struct usbnet *, uint32_t, uint32_t);
 static int	mue_wait_for_bits(struct usbnet *, uint32_t, uint32_t,
 		    uint32_t, uint32_t);
 static uint8_t	mue_eeprom_getbyte(struct usbnet *, int, uint8_t *);
 static bool	mue_eeprom_present(struct usbnet *);
 static void	mue_dataport_write(struct usbnet *, uint32_t, uint32_t,
 		    uint32_t, uint32_t *);
 static void	mue_init_ltm(struct usbnet *);
 static int	mue_chip_init(struct usbnet *);
 static void	mue_set_macaddr(struct usbnet *);
 static int	mue_get_macaddr(struct usbnet *, prop_dictionary_t);
 static int	mue_prepare_tso(struct usbnet *, struct mbuf *);
 static void	mue_uno_mcast(struct ifnet *);
 static void	mue_sethwcsum_locked(struct usbnet *);
 static void	mue_setmtu_locked(struct usbnet *);
 static void	mue_reset(struct usbnet *);
 static void	mue_uno_stop(struct ifnet *, int);
 static int	mue_uno_ioctl(struct ifnet *, u_long, void *);
 static int	mue_uno_mii_read_reg(struct usbnet *, int, int, uint16_t *);
 static int	mue_uno_mii_write_reg(struct usbnet *, int, int, uint16_t);
 static void	mue_uno_mii_statchg(struct ifnet *);
 static void	mue_uno_rx_loop(struct usbnet *, struct usbnet_chain *,
 				uint32_t);
 static unsigned	mue_uno_tx_prepare(struct usbnet *, struct mbuf *,
 				   struct usbnet_chain *);
 static int	mue_uno_init(struct ifnet *);
 static const struct usbnet_ops mue_ops = {
 	.uno_stop = mue_uno_stop,
 	.uno_ioctl = mue_uno_ioctl,
 	.uno_mcast = mue_uno_mcast,
 	.uno_read_reg = mue_uno_mii_read_reg,
 	.uno_write_reg = mue_uno_mii_write_reg,
 	.uno_statchg = mue_uno_mii_statchg,
 	.uno_tx_prepare = mue_uno_tx_prepare,
 	.uno_rx_loop = mue_uno_rx_loop,
 	.uno_init = mue_uno_init,
 };
 #define MUE_SETBIT(un, reg, x)	\
 	mue_csr_write(un, reg, mue_csr_read(un, reg) | (x))
 #define MUE_CLRBIT(un, reg, x)	\
 	mue_csr_write(un, reg, mue_csr_read(un, reg) & ~(x))
 #define MUE_WAIT_SET(un, reg, set, fail)	\
 	mue_wait_for_bits(un, reg, set, ~0, fail)
 #define MUE_WAIT_CLR(un, reg, clear, fail)	\
 	mue_wait_for_bits(un, reg, 0, clear, fail)
 #define ETHER_IS_VALID(addr) \
 	(!ETHER_IS_MULTICAST(addr) && !ETHER_IS_ZERO(addr))
 #define ETHER_IS_ZERO(addr) \
 	(!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]))
 CFATTACH_DECL_NEW(mue, sizeof(struct usbnet), mue_match, mue_attach,
     usbnet_detach, usbnet_activate);
 static uint32_t
 mue_csr_read(struct usbnet *un, uint32_t reg)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	uDWord val;
 	if (usbnet_isdying(un))
 		return 0;
 	USETDW(val, 0);
 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	req.bRequest = MUE_UR_READREG;
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 4);
 	err = usbd_do_request(un->un_udev, &req, &val);
 	if (err) {
 		MUE_PRINTF(un, "reg = %#x: %s\n", reg, usbd_errstr(err));
 		return 0;
+	}
 	return UGETDW(val);
+}
 static int
 mue_csr_write(struct usbnet *un, uint32_t reg, uint32_t aval)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	uDWord val;
 	if (usbnet_isdying(un))
 		return 0;
 	USETDW(val, aval);
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = MUE_UR_WRITEREG;
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, reg);
 	USETW(req.wLength, 4);
 	err = usbd_do_request(un->un_udev, &req, &val);
 	if (err) {
 		MUE_PRINTF(un, "reg = %#x: %s\n", reg, usbd_errstr(err));
 		return -1;
+	}
 	return 0;
+}
 static int
 mue_wait_for_bits(struct usbnet *un, uint32_t reg,
     uint32_t set, uint32_t clear, uint32_t fail)
+{
 	uint32_t val;
 	int ntries;
 	for (ntries = 0; ntries < 1000; ntries++) {
 		if (usbnet_isdying(un))
 			return 1;
 		val = mue_csr_read(un, reg);
 		if ((val & set) || !(val & clear))
 			return 0;
 		if (val & fail)
 			return 1;
 		usbd_delay_ms(un->un_udev, 1);
+	}
 	return 1;
+}
 static int
 mue_uno_mii_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
+{
 	uint32_t data;
 	if (un->un_phyno != phy) {
 		*val = 0;
 		return EINVAL;
+	}
 	if (MUE_WAIT_CLR(un, MUE_MII_ACCESS, MUE_MII_ACCESS_BUSY, 0)) {
 		MUE_PRINTF(un, "not ready\n");
 		*val = 0;
 		return EBUSY;
+	}
 	mue_csr_write(un, MUE_MII_ACCESS, MUE_MII_ACCESS_READ |
 	    MUE_MII_ACCESS_BUSY | MUE_MII_ACCESS_REGADDR(reg) |
 	    MUE_MII_ACCESS_PHYADDR(phy));
 	if (MUE_WAIT_CLR(un, MUE_MII_ACCESS, MUE_MII_ACCESS_BUSY, 0)) {
 		MUE_PRINTF(un, "timed out\n");
 		*val = 0;
 		return ETIMEDOUT;
+	}
 	data = mue_csr_read(un, MUE_MII_DATA);
 	*val = data & 0xffff;
 	return 0;
+}
 static int
 mue_uno_mii_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
+{
 	if (un->un_phyno != phy)
 		return EINVAL;
 	if (MUE_WAIT_CLR(un, MUE_MII_ACCESS, MUE_MII_ACCESS_BUSY, 0)) {
 		MUE_PRINTF(un, "not ready\n");
 		return EBUSY;
+	}
 	mue_csr_write(un, MUE_MII_DATA, val);
 	mue_csr_write(un, MUE_MII_ACCESS, MUE_MII_ACCESS_WRITE |
 	    MUE_MII_ACCESS_BUSY | MUE_MII_ACCESS_REGADDR(reg) |
 	    MUE_MII_ACCESS_PHYADDR(phy));
 	if (MUE_WAIT_CLR(un, MUE_MII_ACCESS, MUE_MII_ACCESS_BUSY, 0)) {
 		MUE_PRINTF(un, "timed out\n");
 		return ETIMEDOUT;
+	}
 	return 0;
+}
 static void
 mue_uno_mii_statchg(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct mii_data * const mii = usbnet_mii(un);
 	uint32_t flow, threshold;
 	if (usbnet_isdying(un))
 		return;
 	if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
 	    (IFM_ACTIVE | IFM_AVALID)) {
 		switch (IFM_SUBTYPE(mii->mii_media_active)) {
 		case IFM_10_T:
 		case IFM_100_TX:
 		case IFM_1000_T:
 			usbnet_set_link(un, true);
 			break;
 		default:
 			break;
+		}
+	}
 	/* Lost link, do nothing. */
 	if (!usbnet_havelink(un)) {
 		DPRINTF(un, "mii_media_status = %#x\n", mii->mii_media_status);
 		return;
+	}
 	if (!(un->un_flags & LAN7500)) {
 		if (un->un_udev->ud_speed == USB_SPEED_SUPER) {
 			if (IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T) {
 				/* Disable U2 and enable U1. */
 				MUE_CLRBIT(un, MUE_USB_CFG1,
 				    MUE_USB_CFG1_DEV_U2_INIT_EN);
 				MUE_SETBIT(un, MUE_USB_CFG1,
 				    MUE_USB_CFG1_DEV_U1_INIT_EN);
 			} else {
 				/* Enable U1 and U2. */
 				MUE_SETBIT(un, MUE_USB_CFG1,
 				    MUE_USB_CFG1_DEV_U1_INIT_EN |
 				    MUE_USB_CFG1_DEV_U2_INIT_EN);
+			}
+		}
+	}
 	flow = 0;
 	/* XXX Linux does not check IFM_FDX flag for 7800. */
 	if (IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) {
 		if (IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE)
 			flow |= MUE_FLOW_TX_FCEN | MUE_FLOW_PAUSE_TIME;
 		if (IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE)
 			flow |= MUE_FLOW_RX_FCEN;
+	}
 	/* XXX Magic numbers taken from Linux driver. */
 	if (un->un_flags & LAN7500)
 		threshold = 0x820;
 	else
 		switch (un->un_udev->ud_speed) {
 		case USB_SPEED_SUPER:
 			threshold = 0x817;
 			break;
 		case USB_SPEED_HIGH:
 			threshold = 0x211;
 			break;
 		default:
 			threshold = 0;
 			break;
+		}
 	/* Threshold value should be set before enabling flow. */
 	mue_csr_write(un, (un->un_flags & LAN7500) ?
 	    MUE_7500_FCT_FLOW : MUE_7800_FCT_FLOW, threshold);
 	mue_csr_write(un, MUE_FLOW, flow);
 	DPRINTF(un, "done\n");
+}
 static uint8_t
 mue_eeprom_getbyte(struct usbnet *un, int off, uint8_t *dest)
+{
 	uint32_t val;
 	if (MUE_WAIT_CLR(un, MUE_E2P_CMD, MUE_E2P_CMD_BUSY, 0)) {
 		MUE_PRINTF(un, "not ready\n");
 		return ETIMEDOUT;
+	}
 	KASSERT((off & ~MUE_E2P_CMD_ADDR_MASK) == 0);
 	mue_csr_write(un, MUE_E2P_CMD, MUE_E2P_CMD_READ | MUE_E2P_CMD_BUSY |
 	    off);
 	if (MUE_WAIT_CLR(un, MUE_E2P_CMD, MUE_E2P_CMD_BUSY,
 	    MUE_E2P_CMD_TIMEOUT)) {
 		MUE_PRINTF(un, "timed out\n");
 		return ETIMEDOUT;
+	}
 	val = mue_csr_read(un, MUE_E2P_DATA);
 	*dest = val & 0xff;
 	return 0;
+}
 static int
 mue_read_eeprom(struct usbnet *un, uint8_t *dest, int off, int cnt)
+{
 	uint32_t val = 0; /* XXX gcc */
 	uint8_t byte;
 	int i, err = 0;
 	/*
 	 * EEPROM pins are muxed with the LED function on LAN7800 device.
 	 */
 	if (un->un_flags & LAN7800) {
 		val = mue_csr_read(un, MUE_HW_CFG);
 		mue_csr_write(un, MUE_HW_CFG,
 		    val & ~(MUE_HW_CFG_LED0_EN | MUE_HW_CFG_LED1_EN));
+	}
 	for (i = 0; i < cnt; i++) {
 		err = mue_eeprom_getbyte(un, off + i, &byte);
 		if (err)
 			break;
 		*(dest + i) = byte;
+	}
 	if (un->un_flags & LAN7800)
 		mue_csr_write(un, MUE_HW_CFG, val);
 	return err ? 1 : 0;
+}
 static bool
 mue_eeprom_present(struct usbnet *un)
+{
 	uint32_t val;
 	uint8_t sig;
 	int ret;
 	if (un->un_flags & LAN7500) {
 		val = mue_csr_read(un, MUE_E2P_CMD);
 		return val & MUE_E2P_CMD_LOADED;
 	} else {
 		ret = mue_read_eeprom(un, &sig, MUE_E2P_IND_OFFSET, 1);
 		return (ret == 0) && (sig == MUE_E2P_IND);
+	}
+}
 static int
 mue_read_otp_raw(struct usbnet *un, uint8_t *dest, int off, int cnt)
+{
 	uint32_t val;
 	int i, err;
 	val = mue_csr_read(un, MUE_OTP_PWR_DN);
 	/* Checking if bit is set. */
 	if (val & MUE_OTP_PWR_DN_PWRDN_N) {
 		/* Clear it, then wait for it to be cleared. */
 		mue_csr_write(un, MUE_OTP_PWR_DN, 0);
 		err = MUE_WAIT_CLR(un, MUE_OTP_PWR_DN, MUE_OTP_PWR_DN_PWRDN_N,
 );
 		if (err) {
 			MUE_PRINTF(un, "not ready\n");
 			return 1;
+		}
+	}
 	/* Start reading the bytes, one at a time. */
 	for (i = 0; i < cnt; i++) {
 		mue_csr_write(un, MUE_OTP_ADDR1,
 		    ((off + i) >> 8) & MUE_OTP_ADDR1_MASK);
 		mue_csr_write(un, MUE_OTP_ADDR2,
 		    ((off + i) & MUE_OTP_ADDR2_MASK));
 		mue_csr_write(un, MUE_OTP_FUNC_CMD, MUE_OTP_FUNC_CMD_READ);
 		mue_csr_write(un, MUE_OTP_CMD_GO, MUE_OTP_CMD_GO_GO);
 		err = MUE_WAIT_CLR(un, MUE_OTP_STATUS, MUE_OTP_STATUS_BUSY, 0);
 		if (err) {
 			MUE_PRINTF(un, "timed out\n");
 			return 1;
+		}
 		val = mue_csr_read(un, MUE_OTP_RD_DATA);
 		*(dest + i) = (uint8_t)(val & 0xff);
+	}
 	return 0;
+}
 static int
 mue_read_otp(struct usbnet *un, uint8_t *dest, int off, int cnt)
+{
 	uint8_t sig;
 	int err;
 	if (un->un_flags & LAN7500)
 		return 1;
 	err = mue_read_otp_raw(un, &sig, MUE_OTP_IND_OFFSET, 1);
 	if (err)
 		return 1;
 	switch (sig) {
 	case MUE_OTP_IND_1:
 		break;
 	case MUE_OTP_IND_2:
 		off += 0x100;
 		break;
 	default:
 		DPRINTF(un, "OTP not found\n");
 		return 1;
+	}
 	err = mue_read_otp_raw(un, dest, off, cnt);
 	return err;
+}
 static void
 mue_dataport_write(struct usbnet *un, uint32_t sel, uint32_t addr,
     uint32_t cnt, uint32_t *data)
+{
 	uint32_t i;
 	if (MUE_WAIT_SET(un, MUE_DP_SEL, MUE_DP_SEL_DPRDY, 0)) {
 		MUE_PRINTF(un, "not ready\n");
 		return;
+	}
 	mue_csr_write(un, MUE_DP_SEL,
 	    (mue_csr_read(un, MUE_DP_SEL) & ~MUE_DP_SEL_RSEL_MASK) | sel);
 	for (i = 0; i < cnt; i++) {
 		mue_csr_write(un, MUE_DP_ADDR, addr + i);
 		mue_csr_write(un, MUE_DP_DATA, data[i]);
 		mue_csr_write(un, MUE_DP_CMD, MUE_DP_CMD_WRITE);
 		if (MUE_WAIT_SET(un, MUE_DP_SEL, MUE_DP_SEL_DPRDY, 0)) {
 			MUE_PRINTF(un, "timed out\n");
 			return;
+		}
+	}
+}
 static void
 mue_init_ltm(struct usbnet *un)
+{
 	uint32_t idx[MUE_NUM_LTM_INDEX] = { 0, 0, 0, 0, 0, 0 };
 	uint8_t temp[2];
 	size_t i;
 	if (mue_csr_read(un, MUE_USB_CFG1) & MUE_USB_CFG1_LTM_ENABLE) {
 		if (mue_eeprom_present(un) &&
 		    (mue_read_eeprom(un, temp, MUE_E2P_LTM_OFFSET, 2) == 0)) {
 			if (temp[0] != sizeof(idx)) {
 				DPRINTF(un, "EEPROM: unexpected size\n");
 				goto done;
+			}
 			if (mue_read_eeprom(un, (uint8_t *)idx, temp[1] << 1,
 				sizeof(idx))) {
 				DPRINTF(un, "EEPROM: failed to read\n");
 				goto done;
+			}
 			DPRINTF(un, "success\n");
 		} else if (mue_read_otp(un, temp, MUE_E2P_LTM_OFFSET, 2) == 0) {
 			if (temp[0] != sizeof(idx)) {
 				DPRINTF(un, "OTP: unexpected size\n");
 				goto done;
+			}
 			if (mue_read_otp(un, (uint8_t *)idx, temp[1] << 1,
 				sizeof(idx))) {
 				DPRINTF(un, "OTP: failed to read\n");
 				goto done;
+			}
 			DPRINTF(un, "success\n");
 		} else
 			DPRINTF(un, "nothing to do\n");
 	} else
 		DPRINTF(un, "nothing to do\n");
 done:
 	for (i = 0; i < __arraycount(idx); i++)
 		mue_csr_write(un, MUE_LTM_INDEX(i), idx[i]);
+}
 static int
 mue_chip_init(struct usbnet *un)
+{
 	uint32_t val;
 	if ((un->un_flags & LAN7500) &&
 	    MUE_WAIT_SET(un, MUE_PMT_CTL, MUE_PMT_CTL_READY, 0)) {
 		MUE_PRINTF(un, "not ready\n");
 			return ETIMEDOUT;
+	}
 	MUE_SETBIT(un, MUE_HW_CFG, MUE_HW_CFG_LRST);
 	if (MUE_WAIT_CLR(un, MUE_HW_CFG, MUE_HW_CFG_LRST, 0)) {
 		MUE_PRINTF(un, "timed out\n");
 		return ETIMEDOUT;
+	}
 	/* Respond to the IN token with a NAK. */
 	if (un->un_flags & LAN7500)
 		MUE_SETBIT(un, MUE_HW_CFG, MUE_HW_CFG_BIR);
 	else
 		MUE_SETBIT(un, MUE_USB_CFG0, MUE_USB_CFG0_BIR);
 	if (un->un_flags & LAN7500) {
 		if (un->un_udev->ud_speed == USB_SPEED_HIGH)
 			val = MUE_7500_HS_RX_BUFSIZE /
 			    MUE_HS_USB_PKT_SIZE;
 		else
 			val = MUE_7500_FS_RX_BUFSIZE /
 			    MUE_FS_USB_PKT_SIZE;
 		mue_csr_write(un, MUE_7500_BURST_CAP, val);
 		mue_csr_write(un, MUE_7500_BULKIN_DELAY,
 		    MUE_7500_DEFAULT_BULKIN_DELAY);
 		MUE_SETBIT(un, MUE_HW_CFG, MUE_HW_CFG_BCE | MUE_HW_CFG_MEF);
 		/* Set FIFO sizes. */
 		val = (MUE_7500_MAX_RX_FIFO_SIZE - 512) / 512;
 		mue_csr_write(un, MUE_7500_FCT_RX_FIFO_END, val);
 		val = (MUE_7500_MAX_TX_FIFO_SIZE - 512) / 512;
 		mue_csr_write(un, MUE_7500_FCT_TX_FIFO_END, val);
 	} else {
 		/* Init LTM. */
 		mue_init_ltm(un);
 		val = MUE_7800_RX_BUFSIZE;
 		switch (un->un_udev->ud_speed) {
 		case USB_SPEED_SUPER:
 			val /= MUE_SS_USB_PKT_SIZE;
 			break;
 		case USB_SPEED_HIGH:
 			val /= MUE_HS_USB_PKT_SIZE;
 			break;
 		default:
 			val /= MUE_FS_USB_PKT_SIZE;
 			break;
+		}
 		mue_csr_write(un, MUE_7800_BURST_CAP, val);
 		mue_csr_write(un, MUE_7800_BULKIN_DELAY,
 		    MUE_7800_DEFAULT_BULKIN_DELAY);
 		MUE_SETBIT(un, MUE_HW_CFG, MUE_HW_CFG_MEF);
 		MUE_SETBIT(un, MUE_USB_CFG0, MUE_USB_CFG0_BCE);
 		/*
 		 * Set FCL's RX and TX FIFO sizes: according to data sheet this
 		 * is already the default value. But we initialize it to the
 		 * same value anyways, as that's what the Linux driver does.
 		 */
 		val = (MUE_7800_MAX_RX_FIFO_SIZE - 512) / 512;
 		mue_csr_write(un, MUE_7800_FCT_RX_FIFO_END, val);
 		val = (MUE_7800_MAX_TX_FIFO_SIZE - 512) / 512;
 		mue_csr_write(un, MUE_7800_FCT_TX_FIFO_END, val);
+	}
 	/* Enabling interrupts. */
 	mue_csr_write(un, MUE_INT_STATUS, ~0);
 	mue_csr_write(un, (un->un_flags & LAN7500) ?
 	    MUE_7500_FCT_FLOW : MUE_7800_FCT_FLOW, 0);
 	mue_csr_write(un, MUE_FLOW, 0);
 	/* Reset PHY. */
 	MUE_SETBIT(un, MUE_PMT_CTL, MUE_PMT_CTL_PHY_RST);
 	if (MUE_WAIT_CLR(un, MUE_PMT_CTL, MUE_PMT_CTL_PHY_RST, 0)) {
 		MUE_PRINTF(un, "PHY not ready\n");
 		return ETIMEDOUT;
+	}
 	/* LAN7801 only has RGMII mode. */
 	if (un->un_flags & LAN7801)
 		MUE_CLRBIT(un, MUE_MAC_CR, MUE_MAC_CR_GMII_EN);
 	if ((un->un_flags & (LAN7500 | LAN7800)) ||
 	    !mue_eeprom_present(un)) {
 		/* Allow MAC to detect speed and duplex from PHY. */
 		MUE_SETBIT(un, MUE_MAC_CR, MUE_MAC_CR_AUTO_SPEED |
 		    MUE_MAC_CR_AUTO_DUPLEX);
+	}
 	MUE_SETBIT(un, MUE_MAC_TX, MUE_MAC_TX_TXEN);
 	MUE_SETBIT(un, (un->un_flags & LAN7500) ?
 	    MUE_7500_FCT_TX_CTL : MUE_7800_FCT_TX_CTL, MUE_FCT_TX_CTL_EN);
 	MUE_SETBIT(un, (un->un_flags & LAN7500) ?
 	    MUE_7500_FCT_RX_CTL : MUE_7800_FCT_RX_CTL, MUE_FCT_RX_CTL_EN);
 	/* Set default GPIO/LED settings only if no EEPROM is detected. */
 	if ((un->un_flags & LAN7500) && !mue_eeprom_present(un)) {
 		MUE_CLRBIT(un, MUE_LED_CFG, MUE_LED_CFG_LED10_FUN_SEL);
 		MUE_SETBIT(un, MUE_LED_CFG,
 		    MUE_LED_CFG_LEDGPIO_EN | MUE_LED_CFG_LED2_FUN_SEL);
+	}
 	/* XXX We assume two LEDs at least when EEPROM is missing. */
 	if (un->un_flags & LAN7800 &&
 	    !mue_eeprom_present(un))
 		MUE_SETBIT(un, MUE_HW_CFG,
 		    MUE_HW_CFG_LED0_EN | MUE_HW_CFG_LED1_EN);
 	return 0;
+}
 static void
 mue_set_macaddr(struct usbnet *un)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
 	uint32_t lo, hi;
 	lo = MUE_ENADDR_LO(enaddr);
 	hi = MUE_ENADDR_HI(enaddr);
 	mue_csr_write(un, MUE_RX_ADDRL, lo);
 	mue_csr_write(un, MUE_RX_ADDRH, hi);
+}
 static int
 mue_get_macaddr(struct usbnet *un, prop_dictionary_t dict)
+{
 	prop_data_t eaprop;
 	uint32_t low, high;
 	if (!(un->un_flags & LAN7500)) {
 		low  = mue_csr_read(un, MUE_RX_ADDRL);
 		high = mue_csr_read(un, MUE_RX_ADDRH);
 		un->un_eaddr[5] = (uint8_t)((high >> 8) & 0xff);
 		un->un_eaddr[4] = (uint8_t)((high) & 0xff);
 		un->un_eaddr[3] = (uint8_t)((low >> 24) & 0xff);
 		un->un_eaddr[2] = (uint8_t)((low >> 16) & 0xff);
 		un->un_eaddr[1] = (uint8_t)((low >> 8) & 0xff);
 		un->un_eaddr[0] = (uint8_t)((low) & 0xff);
 		if (ETHER_IS_VALID(un->un_eaddr))
 			return 0;
 		else
 			DPRINTF(un, "registers: %s\n",
 			    ether_sprintf(un->un_eaddr));
+	}
 	if (mue_eeprom_present(un) && !mue_read_eeprom(un, un->un_eaddr,
 	    MUE_E2P_MAC_OFFSET, ETHER_ADDR_LEN)) {
 		if (ETHER_IS_VALID(un->un_eaddr))
 			return 0;
 		else
 			DPRINTF(un, "EEPROM: %s\n",
 			    ether_sprintf(un->un_eaddr));
+	}
 	if (mue_read_otp(un, un->un_eaddr, MUE_OTP_MAC_OFFSET,
 	    ETHER_ADDR_LEN) == 0) {
 		if (ETHER_IS_VALID(un->un_eaddr))
 			return 0;
 		else
 			DPRINTF(un, "OTP: %s\n",
 			    ether_sprintf(un->un_eaddr));
+	}
 	/*
 	 * Other MD methods. This should be tried only if other methods fail.
 	 * Otherwise, MAC address for internal device can be assinged to
 	 * external devices on Raspberry Pi, for example.
 	 */
 	eaprop = prop_dictionary_get(dict, "mac-address");
 	if (eaprop != NULL) {
 		KASSERT(prop_object_type(eaprop) == PROP_TYPE_DATA);
 		KASSERT(prop_data_size(eaprop) == ETHER_ADDR_LEN);
 		memcpy(un->un_eaddr, prop_data_value(eaprop),
 		    ETHER_ADDR_LEN);
 		if (ETHER_IS_VALID(un->un_eaddr))
 			return 0;
 		else
 			DPRINTF(un, "prop_dictionary_get: %s\n",
 			    ether_sprintf(un->un_eaddr));
+	}
 	return 1;
+}
 /*
  * Probe for a Microchip chip.
  */
 static int
 mue_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	return (MUE_LOOKUP(uaa) != NULL) ?  UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 static void
 mue_attach(device_t parent, device_t self, void *aux)
+{
 	USBNET_MII_DECL_DEFAULT(unm);
 	struct usbnet * const un = device_private(self);
 	prop_dictionary_t dict = device_properties(self);
 	struct usb_attach_arg *uaa = aux;
 	struct usbd_device *dev = uaa->uaa_device;
 	usb_interface_descriptor_t *id;
 	usb_endpoint_descriptor_t *ed;
 	char *devinfop;
 	usbd_status err;
 	const char *descr;
 	uint32_t id_rev;
 	uint8_t i;
 	unsigned rx_list_cnt, tx_list_cnt;
 	unsigned rx_bufsz;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(dev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	un->un_dev = self;
 	un->un_udev = dev;
 	un->un_sc = un;
 	un->un_ops = &mue_ops;
 	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
 	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
 #define MUE_CONFIG_NO	1
 	err = usbd_set_config_no(dev, MUE_CONFIG_NO, 1);
 	if (err) {
 		aprint_error_dev(self, "failed to set configuration: %s\n",
 		    usbd_errstr(err));
 		return;
+	}
 #define MUE_IFACE_IDX	0
 	err = usbd_device2interface_handle(dev, MUE_IFACE_IDX, &un->un_iface);
 	if (err) {
 		aprint_error_dev(self, "failed to get interface handle: %s\n",
 		    usbd_errstr(err));
 		return;
+	}
 	un->un_flags = MUE_LOOKUP(uaa)->mue_flags;
 	/* Decide on what our bufsize will be. */
 	if (un->un_flags & LAN7500) {
 		rx_bufsz = (un->un_udev->ud_speed == USB_SPEED_HIGH) ?
 		    MUE_7500_HS_RX_BUFSIZE : MUE_7500_FS_RX_BUFSIZE;
 		rx_list_cnt = 1;
 		tx_list_cnt = 1;
 	} else {
 		rx_bufsz = MUE_7800_RX_BUFSIZE;
 		rx_list_cnt = MUE_RX_LIST_CNT;
 		tx_list_cnt = MUE_TX_LIST_CNT;
+	}
 	un->un_rx_list_cnt = rx_list_cnt;
 	un->un_tx_list_cnt = tx_list_cnt;
 	un->un_rx_bufsz = rx_bufsz;
 	un->un_tx_bufsz = MUE_TX_BUFSIZE;
 	/* Find endpoints. */
 	id = usbd_get_interface_descriptor(un->un_iface);
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(un->un_iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self, "failed to get ep %hhd\n", i);
 			return;
+		}
 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
 			un->un_ed[USBNET_ENDPT_INTR] = ed->bEndpointAddress;
+		}
+	}
 	if (un->un_ed[USBNET_ENDPT_RX] == 0 ||
 	    un->un_ed[USBNET_ENDPT_TX] == 0 ||
 	    un->un_ed[USBNET_ENDPT_INTR] == 0) {
 		aprint_error_dev(self, "failed to find endpoints\n");
 		return;
+	}
 	/* Set these up now for mue_cmd().  */
 	usbnet_attach(un, "muedet");
 	un->un_phyno = 1;
 	if (mue_chip_init(un)) {
 		aprint_error_dev(self, "failed to initialize chip\n");
 		return;
+	}
 	/* A Microchip chip was detected.  Inform the world. */
 	id_rev = mue_csr_read(un, MUE_ID_REV);
 	descr = (un->un_flags & LAN7500) ? "LAN7500" : "LAN7800";
 	aprint_normal_dev(self, "%s id %#x rev %#x\n", descr,
 		(unsigned)__SHIFTOUT(id_rev, MUE_ID_REV_ID),
 		(unsigned)__SHIFTOUT(id_rev, MUE_ID_REV_REV));
 	if (mue_get_macaddr(un, dict)) {
 		aprint_error_dev(self, "failed to read MAC address\n");
 		return;
+	}
 	struct ifnet *ifp = usbnet_ifp(un);
 	ifp->if_capabilities = IFCAP_TSOv4 | IFCAP_TSOv6 |
 	    IFCAP_CSUM_IPv4_Tx | IFCAP_CSUM_IPv4_Rx |
 	    IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv4_Rx |
 	    IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv4_Rx |
 	    IFCAP_CSUM_TCPv6_Tx | IFCAP_CSUM_TCPv6_Rx |
 	    IFCAP_CSUM_UDPv6_Tx | IFCAP_CSUM_UDPv6_Rx;
 	struct ethercom *ec = usbnet_ec(un);
 	ec->ec_capabilities = ETHERCAP_VLAN_MTU;
 #if 0 /* XXX not yet */
 	ec->ec_capabilities = ETHERCAP_VLAN_MTU | ETHERCAP_JUMBO_MTU;
 #endif
 	usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
 , &unm);
+}
 static unsigned
 mue_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct mue_txbuf_hdr hdr;
 	uint32_t tx_cmd_a, tx_cmd_b;
 	int csum, len, rv;
 	bool tso, ipe, tpe;
 	if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz - sizeof(hdr))
 		return 0;
 	csum = m->m_pkthdr.csum_flags;
 	tso = csum & (M_CSUM_TSOv4 | M_CSUM_TSOv6);
 	ipe = csum & M_CSUM_IPv4;
 	tpe = csum & (M_CSUM_TCPv4 | M_CSUM_UDPv4 |
 		      M_CSUM_TCPv6 | M_CSUM_UDPv6);
 	len = m->m_pkthdr.len;
 	if (__predict_false((!tso && len > (int)MUE_FRAME_LEN(ifp->if_mtu)) ||
 			    ( tso && len > MUE_TSO_FRAME_LEN))) {
 		MUE_PRINTF(un, "packet length %d\n too long", len);
 		return 0;
+	}
 	KASSERT((len & ~MUE_TX_CMD_A_LEN_MASK) == 0);
 	tx_cmd_a = len | MUE_TX_CMD_A_FCS;
 	if (tso) {
 		tx_cmd_a |= MUE_TX_CMD_A_LSO;
 		if (__predict_true(m->m_pkthdr.segsz > MUE_TX_MSS_MIN))
 			tx_cmd_b = m->m_pkthdr.segsz;
 		else
 			tx_cmd_b = MUE_TX_MSS_MIN;
 		tx_cmd_b <<= MUE_TX_CMD_B_MSS_SHIFT;
 		KASSERT((tx_cmd_b & ~MUE_TX_CMD_B_MSS_MASK) == 0);
 		rv = mue_prepare_tso(un, m);
 		if (__predict_false(rv))
 			return 0;
 	} else {
 		if (ipe)
 			tx_cmd_a |= MUE_TX_CMD_A_IPE;
 		if (tpe)
 			tx_cmd_a |= MUE_TX_CMD_A_TPE;
 		tx_cmd_b = 0;
+	}
 	hdr.tx_cmd_a = htole32(tx_cmd_a);
 	hdr.tx_cmd_b = htole32(tx_cmd_b);
 	memcpy(c->unc_buf, &hdr, sizeof(hdr));
 	m_copydata(m, 0, len, c->unc_buf + sizeof(hdr));
 	return len + sizeof(hdr);
+}
 /*
  * L3 length field should be cleared.
  */
 static int
 mue_prepare_tso(struct usbnet *un, struct mbuf *m)
+{
 	struct ether_header *eh;
 	struct ip *ip;
 	struct ip6_hdr *ip6;
 	uint16_t type, len = 0;
 	int off;
 	if (__predict_true(m->m_len >= (int)sizeof(*eh))) {
 		eh = mtod(m, struct ether_header *);
 		type = eh->ether_type;
 	} else
 		m_copydata(m, offsetof(struct ether_header, ether_type),
 		    sizeof(type), &type);
 	switch (type = htons(type)) {
 	case ETHERTYPE_IP:
 	case ETHERTYPE_IPV6:
 		off = ETHER_HDR_LEN;
 		break;
 	case ETHERTYPE_VLAN:
 		off = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
 		break;
 	default:
 		return EINVAL;
+	}
 	if (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) {
 		if (__predict_true(m->m_len >= off + (int)sizeof(*ip))) {
 			ip = (void *)(mtod(m, char *) + off);
 			ip->ip_len = 0;
 		} else
 			m_copyback(m, off + offsetof(struct ip, ip_len),
 			    sizeof(len), &len);
 	} else {
 		if (__predict_true(m->m_len >= off + (int)sizeof(*ip6))) {
 			ip6 = (void *)(mtod(m, char *) + off);
 			ip6->ip6_plen = 0;
 		} else
 			m_copyback(m, off + offsetof(struct ip6_hdr, ip6_plen),
 			    sizeof(len), &len);
+	}
 	return 0;
+}
 static void
 mue_uno_mcast(struct ifnet *ifp)
+{
 	struct usbnet *un = ifp->if_softc;
 	struct ethercom *ec = usbnet_ec(un);
 	const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
 	struct ether_multi *enm;
 	struct ether_multistep step;
 	uint32_t pfiltbl[MUE_NUM_ADDR_FILTX][2];
 	uint32_t hashtbl[MUE_DP_SEL_VHF_HASH_LEN];
 	uint32_t reg, rxfilt, h, hireg, loreg;
 	size_t i;
 	if (usbnet_isdying(un))
 		return;
 	/* Clear perfect filter and hash tables. */
 	memset(pfiltbl, 0, sizeof(pfiltbl));
 	memset(hashtbl, 0, sizeof(hashtbl));
 	reg = (un->un_flags & LAN7500) ? MUE_7500_RFE_CTL : MUE_7800_RFE_CTL;
 	rxfilt = mue_csr_read(un, reg);
 	rxfilt &= ~(MUE_RFE_CTL_PERFECT | MUE_RFE_CTL_MULTICAST_HASH |
 	    MUE_RFE_CTL_UNICAST | MUE_RFE_CTL_MULTICAST);
 	/* Always accept broadcast frames. */
 	rxfilt |= MUE_RFE_CTL_BROADCAST;
 	ETHER_LOCK(ec);
 	if (ifp->if_flags & IFF_PROMISC) {
 		rxfilt |= MUE_RFE_CTL_UNICAST;
 allmulti:	rxfilt |= MUE_RFE_CTL_MULTICAST;
 		ec->ec_flags |= ETHER_F_ALLMULTI;
 		if (ifp->if_flags & IFF_PROMISC)
 			DPRINTF(un, "promisc\n");
 		else
 			DPRINTF(un, "allmulti\n");
 	} else {
 		/* Now program new ones. */
 		pfiltbl[0][0] = MUE_ENADDR_HI(enaddr) | MUE_ADDR_FILTX_VALID;
 		pfiltbl[0][1] = MUE_ENADDR_LO(enaddr);
 		i = 1;
 		ETHER_FIRST_MULTI(step, ec, enm);
 		while (enm != NULL) {
 			if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
 			    ETHER_ADDR_LEN)) {
 				memset(pfiltbl, 0, sizeof(pfiltbl));
 				memset(hashtbl, 0, sizeof(hashtbl));
 				rxfilt &= ~MUE_RFE_CTL_MULTICAST_HASH;
 				goto allmulti;
+			}
 			if (i < MUE_NUM_ADDR_FILTX) {
 				/* Use perfect address table if possible. */
 				pfiltbl[i][0] = MUE_ENADDR_HI(enm->enm_addrlo) |
 				    MUE_ADDR_FILTX_VALID;
 				pfiltbl[i][1] = MUE_ENADDR_LO(enm->enm_addrlo);
 			} else {
 				/* Otherwise, use hash table. */
 				rxfilt |= MUE_RFE_CTL_MULTICAST_HASH;
 				h = (ether_crc32_be(enm->enm_addrlo,
 				    ETHER_ADDR_LEN) >> 23) & 0x1ff;
 				hashtbl[h / 32] |= 1 << (h % 32);
+			}
 			i++;
 			ETHER_NEXT_MULTI(step, enm);
+		}
 		ec->ec_flags &= ~ETHER_F_ALLMULTI;
 		rxfilt |= MUE_RFE_CTL_PERFECT;
 		if (rxfilt & MUE_RFE_CTL_MULTICAST_HASH)
 			DPRINTF(un, "perfect filter and hash tables\n");
 		else
 			DPRINTF(un, "perfect filter\n");
+	}
 	ETHER_UNLOCK(ec);
 	for (i = 0; i < MUE_NUM_ADDR_FILTX; i++) {
 		hireg = (un->un_flags & LAN7500) ?
 		    MUE_7500_ADDR_FILTX(i) : MUE_7800_ADDR_FILTX(i);
 		loreg = hireg + 4;
 		mue_csr_write(un, hireg, 0);
 		mue_csr_write(un, loreg, pfiltbl[i][1]);
 		mue_csr_write(un, hireg, pfiltbl[i][0]);
+	}
 	mue_dataport_write(un, MUE_DP_SEL_VHF, MUE_DP_SEL_VHF_VLAN_LEN,
 	    MUE_DP_SEL_VHF_HASH_LEN, hashtbl);
 	mue_csr_write(un, reg, rxfilt);
+}
 static void
 mue_sethwcsum_locked(struct usbnet *un)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	uint32_t reg, val;
 	KASSERT(IFNET_LOCKED(ifp));
 	reg = (un->un_flags & LAN7500) ? MUE_7500_RFE_CTL : MUE_7800_RFE_CTL;
 	val = mue_csr_read(un, reg);
 	if (ifp->if_capenable & IFCAP_CSUM_IPv4_Rx) {
 		DPRINTF(un, "RX IPv4 hwcsum enabled\n");
 		val |= MUE_RFE_CTL_IP_COE;
 	} else {
 		DPRINTF(un, "RX IPv4 hwcsum disabled\n");
 		val &= ~MUE_RFE_CTL_IP_COE;
+	}
 	if (ifp->if_capenable &
 	    (IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx |
 	     IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx)) {
 		DPRINTF(un, "RX L4 hwcsum enabled\n");
 		val |= MUE_RFE_CTL_TCPUDP_COE;
 	} else {
 		DPRINTF(un, "RX L4 hwcsum disabled\n");
 		val &= ~MUE_RFE_CTL_TCPUDP_COE;
+	}
 	val &= ~MUE_RFE_CTL_VLAN_FILTER;
 	mue_csr_write(un, reg, val);
+}
 static void
 mue_setmtu_locked(struct usbnet *un)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	uint32_t val;
 	KASSERT(IFNET_LOCKED(ifp));
 	/* Set the maximum frame size. */
 	MUE_CLRBIT(un, MUE_MAC_RX, MUE_MAC_RX_RXEN);
 	val = mue_csr_read(un, MUE_MAC_RX);
 	val &= ~MUE_MAC_RX_MAX_SIZE_MASK;
 	val |= MUE_MAC_RX_MAX_LEN(MUE_FRAME_LEN(ifp->if_mtu));
 	mue_csr_write(un, MUE_MAC_RX, val);
 	MUE_SETBIT(un, MUE_MAC_RX, MUE_MAC_RX_RXEN);
+}
 static void
 mue_uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct mue_rxbuf_hdr *hdrp;
 	uint32_t rx_cmd_a;
 	uint16_t pktlen;
 	int csum;
 	uint8_t *buf = c->unc_buf;
 	bool v6;
 	KASSERTMSG(total_len <= un->un_rx_bufsz, "%u vs %u",
 	    total_len, un->un_rx_bufsz);
 	do {
 		if (__predict_false(total_len < sizeof(*hdrp))) {
 			MUE_PRINTF(un, "packet length %u too short\n", total_len);
 			if_statinc(ifp, if_ierrors);
 			return;
+		}
 		hdrp = (struct mue_rxbuf_hdr *)buf;
 		rx_cmd_a = le32toh(hdrp->rx_cmd_a);
 		if (__predict_false(rx_cmd_a & MUE_RX_CMD_A_ERRORS)) {
 			/*
 			 * We cannot use MUE_RX_CMD_A_RED bit here;
 			 * it is turned on in the cases of L3/L4
 			 * checksum errors which we handle below.
 			 */
 			MUE_PRINTF(un, "rx_cmd_a: %#x\n", rx_cmd_a);
 			if_statinc(ifp, if_ierrors);
 			return;
+		}
 		pktlen = (uint16_t)(rx_cmd_a & MUE_RX_CMD_A_LEN_MASK);
 		if (un->un_flags & LAN7500)
 			pktlen -= 2;
 		if (__predict_false(pktlen < ETHER_HDR_LEN + ETHER_CRC_LEN ||
 		    pktlen > MCLBYTES - ETHER_ALIGN || /* XXX */
 		    pktlen + sizeof(*hdrp) > total_len)) {
 			MUE_PRINTF(un, "invalid packet length %d\n", pktlen);
 			if_statinc(ifp, if_ierrors);
 			return;
+		}
 		if (__predict_false(rx_cmd_a & MUE_RX_CMD_A_ICSM)) {
 			csum = 0;
 		} else {
 			v6 = rx_cmd_a & MUE_RX_CMD_A_IPV;
 			switch (rx_cmd_a & MUE_RX_CMD_A_PID) {
 			case MUE_RX_CMD_A_PID_TCP:
 				csum = v6 ?
 				    M_CSUM_TCPv6 : M_CSUM_IPv4 | M_CSUM_TCPv4;
 				break;
 			case MUE_RX_CMD_A_PID_UDP:
 				csum = v6 ?
 				    M_CSUM_UDPv6 : M_CSUM_IPv4 | M_CSUM_UDPv4;
 				break;
 			case MUE_RX_CMD_A_PID_IP:
 				csum = v6 ? 0 : M_CSUM_IPv4;
 				break;
 			default:
 				csum = 0;
 				break;
+			}
 			csum &= ifp->if_csum_flags_rx;
 			if (__predict_false((csum & M_CSUM_IPv4) &&
 			    (rx_cmd_a & MUE_RX_CMD_A_ICE)))
 				csum |= M_CSUM_IPv4_BAD;
 			if (__predict_false((csum & ~M_CSUM_IPv4) &&
 			    (rx_cmd_a & MUE_RX_CMD_A_TCE)))
 				csum |= M_CSUM_TCP_UDP_BAD;
+		}
 		usbnet_enqueue(un, buf + sizeof(*hdrp), pktlen, csum,
 , M_HASFCS);
 		/* Attention: sizeof(hdr) = 10 */
 		pktlen = roundup(pktlen + sizeof(*hdrp), 4);
 		if (pktlen > total_len)
 			pktlen = total_len;
 		total_len -= pktlen;
 		buf += pktlen;
 	} while (total_len > 0);
+}
 static int
 mue_uno_init(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	/* Cancel pending I/O and free all TX/RX buffers. */
 	if (ifp->if_flags & IFF_RUNNING)
 		usbnet_stop(un, ifp, 1);
 	mue_reset(un);
 	/* Set MAC address. */
 	mue_set_macaddr(un);
 	/* TCP/UDP checksum offload engines. */
 	mue_sethwcsum_locked(un);
 	/* Set MTU. */
 	mue_setmtu_locked(un);
 	return usbnet_init_rx_tx(un);
+}
 static int
 mue_uno_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct usbnet * const un = ifp->if_softc;
 	switch (cmd) {
 	case SIOCSIFCAP:
 		mue_sethwcsum_locked(un);
 		break;
 	case SIOCSIFMTU:
 		mue_setmtu_locked(un);
 		break;
 	default:
 		break;
+	}
 	return 0;
+}
 static void
 mue_reset(struct usbnet *un)
+{
 	if (usbnet_isdying(un))
 		return;
 	/* Wait a little while for the chip to get its brains in order. */
 	usbd_delay_ms(un->un_udev, 1);
 //	mue_chip_init(un); /* XXX */
+}
 static void
 mue_uno_stop(struct ifnet *ifp, int disable)
+{
 	struct usbnet * const un = ifp->if_softc;
 	mue_reset(un);
+}
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 USBNET_MODULE(mue)

 @@ -1,827 +1,823 @@
-/*	$NetBSD: if_udav.c,v 1.93 2022/03/03 05:55:01 riastradh Exp $	*/
+/*	$NetBSD: if_udav.c,v 1.94 2022/03/03 05:55:19 riastradh Exp $	*/
 /*	$nabe: if_udav.c,v 1.3 2003/08/21 16:57:19 nabe Exp $	*/
 /*
  * Copyright (c) 2003
  *     Shingo WATANABE <nabe@nabechan.org>.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the author nor the names of any co-contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ *
  */
 /*
  * DM9601(DAVICOM USB to Ethernet MAC Controller with Integrated 10/100 PHY)
  * The spec can be found at the following url.
  *   http://www.davicom.com.tw/big5/download/Data%20Sheet/DM9601-DS-F01-062202s.pdf
  */
 /*
  * TODO:
  *	Interrupt Endpoint support
  *	External PHYs
  *	powerhook() support?
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_udav.c,v 1.93 2022/03/03 05:55:01 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_udav.c,v 1.94 2022/03/03 05:55:19 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/if_udavreg.h>
 /* Function declarations */
 static int	udav_match(device_t, cfdata_t, void *);
 static void	udav_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(udav, sizeof(struct usbnet), udav_match, udav_attach,
     usbnet_detach, usbnet_activate);
 static void udav_chip_init(struct usbnet *);
 static unsigned udav_uno_tx_prepare(struct usbnet *, struct mbuf *,
 				    struct usbnet_chain *);
 static void udav_uno_rx_loop(struct usbnet *, struct usbnet_chain *, uint32_t);
 static void udav_uno_stop(struct ifnet *, int);
 static void udav_uno_mcast(struct ifnet *);
 static int udav_uno_mii_read_reg(struct usbnet *, int, int, uint16_t *);
 static int udav_uno_mii_write_reg(struct usbnet *, int, int, uint16_t);
 static void udav_uno_mii_statchg(struct ifnet *);
 static int udav_uno_init(struct ifnet *);
 static void udav_reset(struct usbnet *);
 static int udav_csr_read(struct usbnet *, int, void *, int);
 static int udav_csr_write(struct usbnet *, int, void *, int);
 static int udav_csr_read1(struct usbnet *, int);
 static int udav_csr_write1(struct usbnet *, int, unsigned char);
 #if 0
 static int udav_mem_read(struct usbnet *, int, void *, int);
 static int udav_mem_write(struct usbnet *, int, void *, int);
 static int udav_mem_write1(struct usbnet *, int, unsigned char);
 #endif
 /* Macros */
 #ifdef UDAV_DEBUG
 #define DPRINTF(x)	if (udavdebug) printf x
 #define DPRINTFN(n, x)	if (udavdebug >= (n)) printf x
 int udavdebug = 0;
 #else
 #define DPRINTF(x)
 #define DPRINTFN(n, x)
 #endif
 #define	UDAV_SETBIT(un, reg, x)	\
 	udav_csr_write1(un, reg, udav_csr_read1(un, reg) | (x))
 #define	UDAV_CLRBIT(un, reg, x)	\
 	udav_csr_write1(un, reg, udav_csr_read1(un, reg) & ~(x))
 static const struct udav_type {
 	struct usb_devno udav_dev;
 	uint16_t udav_flags;
 #define UDAV_EXT_PHY	0x0001
 #define UDAV_NO_PHY	0x0002
 } udav_devs [] = {
 	/* Corega USB-TXC */
 	{{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB_TXC }, 0},
 	/* ShanTou ST268 USB NIC */
 	{{ USB_VENDOR_SHANTOU, USB_PRODUCT_SHANTOU_ST268_USB_NIC }, 0},
 	/* ShanTou ADM8515 */
 	{{ USB_VENDOR_SHANTOU, USB_PRODUCT_SHANTOU_ADM8515 }, 0},
 	/* SUNRISING SR9600 */
 	{{ USB_VENDOR_SUNRISING, USB_PRODUCT_SUNRISING_SR9600 }, 0 },
 	/* SUNRISING QF9700 */
 	{{ USB_VENDOR_SUNRISING, USB_PRODUCT_SUNRISING_QF9700 }, UDAV_NO_PHY },
 	/* QUAN DM9601 */
 	{{USB_VENDOR_QUAN, USB_PRODUCT_QUAN_DM9601 }, 0},
 #if 0
 	/* DAVICOM DM9601 Generic? */
 	/*  XXX: The following ids was obtained from the data sheet. */
 	{{ 0x0a46, 0x9601 }, 0},
 #endif
 };
 #define udav_lookup(v, p) ((const struct udav_type *)usb_lookup(udav_devs, v, p))
 static const struct usbnet_ops udav_ops = {
 	.uno_stop = udav_uno_stop,
 	.uno_mcast = udav_uno_mcast,
 	.uno_read_reg = udav_uno_mii_read_reg,
 	.uno_write_reg = udav_uno_mii_write_reg,
 	.uno_statchg = udav_uno_mii_statchg,
 	.uno_tx_prepare = udav_uno_tx_prepare,
 	.uno_rx_loop = udav_uno_rx_loop,
 	.uno_init = udav_uno_init,
 };
 /* Probe */
 static int
 udav_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	return udav_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
 		UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 /* Attach */
 static void
 udav_attach(device_t parent, device_t self, void *aux)
+{
 	USBNET_MII_DECL_DEFAULT(unm);
 	struct usbnet_mii *unmp;
 	struct usbnet * const un = device_private(self);
 	struct usb_attach_arg *uaa = aux;
 	struct usbd_device *dev = uaa->uaa_device;
 	struct usbd_interface *iface;
 	usbd_status err;
 	usb_interface_descriptor_t *id;
 	usb_endpoint_descriptor_t *ed;
 	char *devinfop;
 	int i;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(dev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	un->un_dev = self;
 	un->un_udev = dev;
 	un->un_sc = un;
 	un->un_ops = &udav_ops;
 	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
 	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
 	un->un_rx_list_cnt = UDAV_RX_LIST_CNT;
 	un->un_tx_list_cnt = UDAV_TX_LIST_CNT;
 	un->un_rx_bufsz = UDAV_BUFSZ;
 	un->un_tx_bufsz = UDAV_BUFSZ;
 	/* Move the device into the configured state. */
 	err = usbd_set_config_no(dev, UDAV_CONFIG_NO, 1); /* idx 0 */
 	if (err) {
 		aprint_error_dev(self, "failed to set configuration"
 		    ", err=%s\n", usbd_errstr(err));
 		return;
+	}
 	/* get control interface */
 	err = usbd_device2interface_handle(dev, UDAV_IFACE_INDEX, &iface);
 	if (err) {
 		aprint_error_dev(self, "failed to get interface, err=%s\n",
 		       usbd_errstr(err));
 		return;
+	}
 	un->un_iface = iface;
 	un->un_flags = udav_lookup(uaa->uaa_vendor,
 	    uaa->uaa_product)->udav_flags;
 	/* get interface descriptor */
 	id = usbd_get_interface_descriptor(un->un_iface);
 	/* find endpoints */
 	un->un_ed[USBNET_ENDPT_RX] = un->un_ed[USBNET_ENDPT_TX] =
 	    un->un_ed[USBNET_ENDPT_INTR] = -1;
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(un->un_iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self, "couldn't get endpoint %d\n", i);
 			return;
+		}
 		if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
 		    UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
 			un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
 		else if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
 			 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT)
 			un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
 		else if ((ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT &&
 			 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
 			un->un_ed[USBNET_ENDPT_INTR] = ed->bEndpointAddress;
+	}
 	if (un->un_ed[USBNET_ENDPT_RX] == 0 ||
 	    un->un_ed[USBNET_ENDPT_TX] == 0 ||
 	    un->un_ed[USBNET_ENDPT_INTR] == 0) {
 		aprint_error_dev(self, "missing endpoint\n");
 		return;
+	}
 	/* Not supported yet. */
 	un->un_ed[USBNET_ENDPT_INTR] = 0;
 	usbnet_attach(un, "udavdet");
 // 	/* reset the adapter */
 // 	udav_reset(un);
 	/* Get Ethernet Address */
 	err = udav_csr_read(un, UDAV_PAR, un->un_eaddr, ETHER_ADDR_LEN);
 	if (err) {
 		aprint_error_dev(self, "read MAC address failed\n");
 		return;
+	}
 	if (ISSET(un->un_flags, UDAV_NO_PHY))
 		unmp = NULL;
 	else
 		unmp = &unm;
 	/* initialize interface information */
 	usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
 , unmp);
 	return;
+}
 #if 0
 /* read memory */
 static int
 udav_mem_read(struct usbnet *un, int offset, void *buf, int len)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if (usbnet_isdying(un))
 		return 0;
 	offset &= 0xffff;
 	len &= 0xff;
 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	req.bRequest = UDAV_REQ_MEM_READ;
 	USETW(req.wValue, 0x0000);
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 	err = usbd_do_request(un->un_udev, &req, buf);
 	if (err) {
 		DPRINTF(("%s: %s: read failed. off=%04x, err=%d\n",
 			 device_xname(un->un_dev), __func__, offset, err));
+	}
 	return err;
+}
 /* write memory */
 static int
 udav_mem_write(struct usbnet *un, int offset, void *buf, int len)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if (usbnet_isdying(un))
 		return 0;
 	offset &= 0xffff;
 	len &= 0xff;
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = UDAV_REQ_MEM_WRITE;
 	USETW(req.wValue, 0x0000);
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 	err = usbd_do_request(un->un_udev, &req, buf);
 	if (err) {
 		DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 			 device_xname(un->un_dev), __func__, offset, err));
+	}
 	return err;
+}
 /* write memory */
 static int
 udav_mem_write1(struct usbnet *un, int offset, unsigned char ch)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if (usbnet_isdying(un))
 		return 0;
 	offset &= 0xffff;
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = UDAV_REQ_MEM_WRITE1;
 	USETW(req.wValue, ch);
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, 0x0000);
 	err = usbd_do_request(un->un_udev, &req, NULL);
 	if (err) {
 		DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 			 device_xname(un->un_dev), __func__, offset, err));
+	}
 	return err;
+}
 #endif
 /* read register(s) */
 static int
 udav_csr_read(struct usbnet *un, int offset, void *buf, int len)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	if (usbnet_isdying(un))
 		return USBD_IOERROR;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	offset &= 0xff;
 	len &= 0xff;
 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	req.bRequest = UDAV_REQ_REG_READ;
 	USETW(req.wValue, 0x0000);
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 	err = usbd_do_request(un->un_udev, &req, buf);
 	if (err) {
 		DPRINTF(("%s: %s: read failed. off=%04x, err=%d\n",
 			 device_xname(un->un_dev), __func__, offset, err));
 		memset(buf, 0, len);
+	}
 	return err;
+}
 /* write register(s) */
 static int
 udav_csr_write(struct usbnet *un, int offset, void *buf, int len)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	if (usbnet_isdying(un))
 		return USBD_IOERROR;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	offset &= 0xff;
 	len &= 0xff;
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = UDAV_REQ_REG_WRITE;
 	USETW(req.wValue, 0x0000);
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, len);
 	err = usbd_do_request(un->un_udev, &req, buf);
 	if (err) {
 		DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 			 device_xname(un->un_dev), __func__, offset, err));
+	}
 	return err;
+}
 static int
 udav_csr_read1(struct usbnet *un, int offset)
+{
 	uint8_t val = 0;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if (usbnet_isdying(un))
 		return 0;
 	return udav_csr_read(un, offset, &val, 1) ? 0 : val;
+}
 /* write a register */
 static int
 udav_csr_write1(struct usbnet *un, int offset, unsigned char ch)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	if (usbnet_isdying(un))
 		return USBD_IOERROR;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	offset &= 0xff;
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = UDAV_REQ_REG_WRITE1;
 	USETW(req.wValue, ch);
 	USETW(req.wIndex, offset);
 	USETW(req.wLength, 0x0000);
 	err = usbd_do_request(un->un_udev, &req, NULL);
 	if (err) {
 		DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 			 device_xname(un->un_dev), __func__, offset, err));
+	}
 	return err;
+}
 static int
 udav_uno_init(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct mii_data * const mii = usbnet_mii(un);
 	uint8_t eaddr[ETHER_ADDR_LEN];
 	int rc = 0;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	/* Cancel pending I/O and free all TX/RX buffers */
 	if (ifp->if_flags & IFF_RUNNING)
 		usbnet_stop(un, ifp, 1);
 	memcpy(eaddr, CLLADDR(ifp->if_sadl), sizeof(eaddr));
 	udav_csr_write(un, UDAV_PAR, eaddr, ETHER_ADDR_LEN);
 	/* Initialize network control register */
 	/*  Disable loopback  */
 	UDAV_CLRBIT(un, UDAV_NCR, UDAV_NCR_LBK0 | UDAV_NCR_LBK1);
 	/* Initialize RX control register */
 	UDAV_SETBIT(un, UDAV_RCR, UDAV_RCR_DIS_LONG | UDAV_RCR_DIS_CRC);
 	/* If we want promiscuous mode, accept all physical frames. */
 	if (ifp->if_flags & IFF_PROMISC)
 		UDAV_SETBIT(un, UDAV_RCR, UDAV_RCR_ALL | UDAV_RCR_PRMSC);
 	else
 		UDAV_CLRBIT(un, UDAV_RCR, UDAV_RCR_ALL | UDAV_RCR_PRMSC);
 	/* Enable RX */
 	UDAV_SETBIT(un, UDAV_RCR, UDAV_RCR_RXEN);
 	/* clear POWER_DOWN state of internal PHY */
 	UDAV_SETBIT(un, UDAV_GPCR, UDAV_GPCR_GEP_CNTL0);
 	UDAV_CLRBIT(un, UDAV_GPR, UDAV_GPR_GEPIO0);
 	if (mii && (rc = mii_mediachg(mii)) == ENXIO)
 		rc = 0;
 	if (rc != 0) {
 		return rc;
+	}
 	if (usbnet_isdying(un))
 		rc = EIO;
 	else
 		rc = usbnet_init_rx_tx(un);
 	return rc;
+}
 static void
 udav_reset(struct usbnet *un)
+{
 	if (usbnet_isdying(un))
 		return;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	udav_chip_init(un);
+}
 static void
 udav_chip_init(struct usbnet *un)
+{
 	/* Select PHY */
 #if 1
 	/*
 	 * XXX: force select internal phy.
 	 *	external phy routines are not tested.
 	 */
 	UDAV_CLRBIT(un, UDAV_NCR, UDAV_NCR_EXT_PHY);
 #else
 	if (un->un_flags & UDAV_EXT_PHY) {
 		UDAV_SETBIT(un, UDAV_NCR, UDAV_NCR_EXT_PHY);
 	} else {
 		UDAV_CLRBIT(un, UDAV_NCR, UDAV_NCR_EXT_PHY);
+	}
 #endif
 	UDAV_SETBIT(un, UDAV_NCR, UDAV_NCR_RST);
 	for (int i = 0; i < UDAV_TX_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return;
 		if (!(udav_csr_read1(un, UDAV_NCR) & UDAV_NCR_RST))
 			break;
 		delay(10);	/* XXX */
+	}
 	delay(10000);		/* XXX */
+}
 #define UDAV_BITS	6
 #define UDAV_CALCHASH(addr) \
 	(ether_crc32_le((addr), ETHER_ADDR_LEN) & ((1 << UDAV_BITS) - 1))
 static void
 udav_uno_mcast(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct ethercom *ec = usbnet_ec(un);
 	struct ether_multi *enm;
 	struct ether_multistep step;
 	uint8_t hashes[8];
 	int h = 0;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if (usbnet_isdying(un))
 		return;
 	if (ISSET(un->un_flags, UDAV_NO_PHY)) {
 		UDAV_SETBIT(un, UDAV_RCR, UDAV_RCR_ALL);
 		UDAV_SETBIT(un, UDAV_RCR, UDAV_RCR_PRMSC);
 		return;
+	}
 	if (ifp->if_flags & IFF_PROMISC) {
 		ETHER_LOCK(ec);
 		ec->ec_flags |= ETHER_F_ALLMULTI;
 		ETHER_UNLOCK(ec);
 		UDAV_SETBIT(un, UDAV_RCR, UDAV_RCR_ALL | UDAV_RCR_PRMSC);
 		return;
 	} else if (ifp->if_flags & IFF_ALLMULTI) { /* XXX ??? Can't happen? */
 		ETHER_LOCK(ec);
 allmulti:
 		ec->ec_flags |= ETHER_F_ALLMULTI;
 		ETHER_UNLOCK(ec);
 		UDAV_SETBIT(un, UDAV_RCR, UDAV_RCR_ALL);
 		UDAV_CLRBIT(un, UDAV_RCR, UDAV_RCR_PRMSC);
 		return;
+	}
 	/* first, zot all the existing hash bits */
 	memset(hashes, 0x00, sizeof(hashes));
 	hashes[7] |= 0x80;	/* broadcast address */
 	udav_csr_write(un, UDAV_MAR, hashes, sizeof(hashes));
 	/* now program new ones */
 	ETHER_LOCK(ec);
 	ETHER_FIRST_MULTI(step, ec, enm);
 	while (enm != NULL) {
 		if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
 		    ETHER_ADDR_LEN) != 0) {
 			goto allmulti;
+		}
 		h = UDAV_CALCHASH(enm->enm_addrlo);
 		hashes[h>>3] |= 1 << (h & 0x7);
 		ETHER_NEXT_MULTI(step, enm);
+	}
 	ec->ec_flags &= ~ETHER_F_ALLMULTI;
 	ETHER_UNLOCK(ec);
 	/* disable all multicast */
 	UDAV_CLRBIT(un, UDAV_RCR, UDAV_RCR_ALL);
 	/* write hash value to the register */
 	udav_csr_write(un, UDAV_MAR, hashes, sizeof(hashes));
+}
 static unsigned
 udav_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	int total_len;
 	uint8_t *buf = c->unc_buf;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz - 2)
 		return 0;
 	/* Copy the mbuf data into a contiguous buffer */
 	m_copydata(m, 0, m->m_pkthdr.len, buf + 2);
 	total_len = m->m_pkthdr.len;
 	if (total_len < UDAV_MIN_FRAME_LEN) {
 		memset(buf + 2 + total_len, 0,
 		    UDAV_MIN_FRAME_LEN - total_len);
 		total_len = UDAV_MIN_FRAME_LEN;
+	}
 	/* Frame length is specified in the first 2bytes of the buffer */
 	buf[0] = (uint8_t)total_len;
 	buf[1] = (uint8_t)(total_len >> 8);
 	total_len += 2;
 	DPRINTF(("%s: %s: send %d bytes\n", device_xname(un->un_dev),
 	    __func__, total_len));
 	return total_len;
+}
 static void
 udav_uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len)
+{
 	struct ifnet *ifp = usbnet_ifp(un);
 	uint8_t *buf = c->unc_buf;
 	uint16_t pkt_len;
 	uint8_t pktstat;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	/* first byte in received data */
 	pktstat = *buf;
 	total_len -= sizeof(pktstat);
 	buf += sizeof(pktstat);
 	DPRINTF(("%s: RX Status: 0x%02x\n", device_xname(un->un_dev), pktstat));
 	pkt_len = UGETW(buf);
  	total_len -= sizeof(pkt_len);
 	buf += sizeof(pkt_len);
 	DPRINTF(("%s: RX Length: 0x%02x\n", device_xname(un->un_dev), pkt_len));
 	if (pktstat & UDAV_RSR_LCS) {
 		if_statinc(ifp, if_collisions);
 		return;
+	}
 	if (pkt_len < sizeof(struct ether_header) ||
 	    pkt_len > total_len ||
 	    (pktstat & UDAV_RSR_ERR)) {
 		if_statinc(ifp, if_ierrors);
 		return;
+	}
 	pkt_len -= ETHER_CRC_LEN;
 	DPRINTF(("%s: Rx deliver: 0x%02x\n", device_xname(un->un_dev), pkt_len));
 	usbnet_enqueue(un, buf, pkt_len, 0, 0, 0);
+}
 /* Stop the adapter and free any mbufs allocated to the RX and TX lists. */
 static void
 udav_uno_stop(struct ifnet *ifp, int disable)
+{
 	struct usbnet * const un = ifp->if_softc;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	udav_reset(un);
+}
 static int
 udav_uno_mii_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
+{
 	uint8_t data[2];
 	DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x\n",
 		 device_xname(un->un_dev), __func__, phy, reg));
 	if (usbnet_isdying(un)) {
 #ifdef DIAGNOSTIC
 		printf("%s: %s: dying\n", device_xname(un->un_dev),
 		       __func__);
 #endif
 		*val = 0;
 		return EINVAL;
+	}
 	/* XXX: one PHY only for the internal PHY */
 	if (phy != 0) {
 		DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
 			 device_xname(un->un_dev), __func__, phy));
 		*val = 0;
 		return EINVAL;
+	}
 	/* select internal PHY and set PHY register address */
 	udav_csr_write1(un, UDAV_EPAR,
 			UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK));
 	/* select PHY operation and start read command */
 	udav_csr_write1(un, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRR);
 	/* XXX: should be wait? */
 	/* end read command */
 	UDAV_CLRBIT(un, UDAV_EPCR, UDAV_EPCR_ERPRR);
 	/* retrieve the result from data registers */
 	udav_csr_read(un, UDAV_EPDRL, data, 2);
 	*val = data[0] | (data[1] << 8);
 	DPRINTFN(0xff, ("%s: %s: phy=%d reg=0x%04x => 0x%04hx\n",
 		device_xname(un->un_dev), __func__, phy, reg, *val));
 	return 0;
+}
 static int
 udav_uno_mii_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
+{
 	uint8_t data[2];
 	DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x val=0x%04hx\n",
 		 device_xname(un->un_dev), __func__, phy, reg, val));
 	if (usbnet_isdying(un)) {
 #ifdef DIAGNOSTIC
 		printf("%s: %s: dying\n", device_xname(un->un_dev),
 		       __func__);
 #endif
 		return EIO;
+	}
 	/* XXX: one PHY only for the internal PHY */
 	if (phy != 0) {
 		DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
 			 device_xname(un->un_dev), __func__, phy));
 		return EIO;
+	}
 	/* select internal PHY and set PHY register address */
 	udav_csr_write1(un, UDAV_EPAR,
 			UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK));
 	/* put the value to the data registers */
 	data[0] = val & 0xff;
 	data[1] = (val >> 8) & 0xff;
 	udav_csr_write(un, UDAV_EPDRL, data, 2);
 	/* select PHY operation and start write command */
 	udav_csr_write1(un, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRW);
 	/* XXX: should be wait? */
 	/* end write command */
 	UDAV_CLRBIT(un, UDAV_EPCR, UDAV_EPCR_ERPRW);
 	return 0;
+}
 static void
 udav_uno_mii_statchg(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct mii_data * const mii = usbnet_mii(un);
 	DPRINTF(("%s: %s: enter\n", ifp->if_xname, __func__));
 	if (usbnet_isdying(un))
 		return;
 	if ((mii->mii_media_status & IFM_ACTIVE) &&
 	    IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
 		DPRINTF(("%s: %s: got link\n",
 			 device_xname(un->un_dev), __func__));
 		usbnet_set_link(un, true);
+	}
+}
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 USBNET_MODULE(udav)

 @@ -1,1128 +1,1124 @@
-/*	$NetBSD: if_ure.c,v 1.53 2022/03/03 05:55:01 riastradh Exp $	*/
+/*	$NetBSD: if_ure.c,v 1.54 2022/03/03 05:55:19 riastradh Exp $	*/
 /*	$OpenBSD: if_ure.c,v 1.10 2018/11/02 21:32:30 jcs Exp $	*/
 /*-
  * Copyright (c) 2015-2016 Kevin Lo <kevlo@FreeBSD.org>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
  */
 /* RealTek RTL8152/RTL8153 10/100/Gigabit USB Ethernet device */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_ure.c,v 1.53 2022/03/03 05:55:01 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_ure.c,v 1.54 2022/03/03 05:55:19 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <sys/cprng.h>
 #include <net/route.h>
 #include <dev/usb/usbnet.h>
 #include <netinet/in_offload.h>		/* XXX for in_undefer_cksum() */
 #ifdef INET6
 #include <netinet/in.h>
 #include <netinet6/in6_offload.h>	/* XXX for in6_undefer_cksum() */
 #endif
 #include <dev/ic/rtl81x9reg.h>		/* XXX for RTK_GMEDIASTAT */
 #include <dev/usb/if_urereg.h>
 #include <dev/usb/if_urevar.h>
 #define URE_PRINTF(un, fmt, args...) \
 	device_printf((un)->un_dev, "%s: " fmt, __func__, ##args);
 #define URE_DEBUG
 #ifdef URE_DEBUG
 #define DPRINTF(x)	do { if (uredebug) printf x; } while (0)
 #define DPRINTFN(n, x)	do { if (uredebug >= (n)) printf x; } while (0)
 int	uredebug = 0;
 #else
 #define DPRINTF(x)
 #define DPRINTFN(n, x)
 #endif
 #define ETHER_IS_ZERO(addr) \
 	(!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]))
 static const struct usb_devno ure_devs[] = {
 	{ USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8152 },
 	{ USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8153 }
 };
 #define URE_BUFSZ	(16 * 1024)
 static void	ure_reset(struct usbnet *);
 static uint32_t	ure_txcsum(struct mbuf *);
 static int	ure_rxcsum(struct ifnet *, struct ure_rxpkt *);
 static void	ure_rtl8152_init(struct usbnet *);
 static void	ure_rtl8153_init(struct usbnet *);
 static void	ure_disable_teredo(struct usbnet *);
 static void	ure_init_fifo(struct usbnet *);
 static void	ure_uno_stop(struct ifnet *, int);
 static void	ure_uno_mcast(struct ifnet *);
 static int	ure_uno_mii_read_reg(struct usbnet *, int, int, uint16_t *);
 static int	ure_uno_mii_write_reg(struct usbnet *, int, int, uint16_t);
 static void	ure_uno_miibus_statchg(struct ifnet *);
 static unsigned ure_uno_tx_prepare(struct usbnet *, struct mbuf *,
 				   struct usbnet_chain *);
 static void	ure_uno_rx_loop(struct usbnet *, struct usbnet_chain *,
 				uint32_t);
 static int	ure_uno_init(struct ifnet *);
 static int	ure_match(device_t, cfdata_t, void *);
 static void	ure_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(ure, sizeof(struct usbnet), ure_match, ure_attach,
     usbnet_detach, usbnet_activate);
 static const struct usbnet_ops ure_ops = {
 	.uno_stop = ure_uno_stop,
 	.uno_mcast = ure_uno_mcast,
 	.uno_read_reg = ure_uno_mii_read_reg,
 	.uno_write_reg = ure_uno_mii_write_reg,
 	.uno_statchg = ure_uno_miibus_statchg,
 	.uno_tx_prepare = ure_uno_tx_prepare,
 	.uno_rx_loop = ure_uno_rx_loop,
 	.uno_init = ure_uno_init,
 };
 static int
 ure_ctl(struct usbnet *un, uint8_t rw, uint16_t val, uint16_t index,
     void *buf, int len)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	if (usbnet_isdying(un))
 		return 0;
 	if (rw == URE_CTL_WRITE)
 		req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	else
 		req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	req.bRequest = UR_SET_ADDRESS;
 	USETW(req.wValue, val);
 	USETW(req.wIndex, index);
 	USETW(req.wLength, len);
 	DPRINTFN(5, ("ure_ctl: rw %d, val %04hu, index %04hu, len %d\n",
 	    rw, val, index, len));
 	err = usbd_do_request(un->un_udev, &req, buf);
 	if (err) {
 		DPRINTF(("ure_ctl: error %d\n", err));
 		if (rw == URE_CTL_READ)
 			memset(buf, 0, len);
 		return -1;
+	}
 	return 0;
+}
 static int
 ure_read_mem(struct usbnet *un, uint16_t addr, uint16_t index,
     void *buf, int len)
+{
 	return ure_ctl(un, URE_CTL_READ, addr, index, buf, len);
+}
 static int
 ure_write_mem(struct usbnet *un, uint16_t addr, uint16_t index,
     void *buf, int len)
+{
 	return ure_ctl(un, URE_CTL_WRITE, addr, index, buf, len);
+}
 static uint8_t
 ure_read_1(struct usbnet *un, uint16_t reg, uint16_t index)
+{
 	uint32_t val;
 	uint8_t temp[4];
 	uint8_t shift;
 	shift = (reg & 3) << 3;
 	reg &= ~3;
 	ure_read_mem(un, reg, index, &temp, 4);
 	val = UGETDW(temp);
 	val >>= shift;
 	return val & 0xff;
+}
 static uint16_t
 ure_read_2(struct usbnet *un, uint16_t reg, uint16_t index)
+{
 	uint32_t val;
 	uint8_t temp[4];
 	uint8_t shift;
 	shift = (reg & 2) << 3;
 	reg &= ~3;
 	ure_read_mem(un, reg, index, &temp, 4);
 	val = UGETDW(temp);
 	val >>= shift;
 	return val & 0xffff;
+}
 static uint32_t
 ure_read_4(struct usbnet *un, uint16_t reg, uint16_t index)
+{
 	uint8_t temp[4];
 	ure_read_mem(un, reg, index, &temp, 4);
 	return UGETDW(temp);
+}
 static int
 ure_write_1(struct usbnet *un, uint16_t reg, uint16_t index, uint32_t val)
+{
 	uint16_t byen;
 	uint8_t temp[4];
 	uint8_t shift;
 	byen = URE_BYTE_EN_BYTE;
 	shift = reg & 3;
 	val &= 0xff;
 	if (reg & 3) {
 		byen <<= shift;
 		val <<= (shift << 3);
 		reg &= ~3;
+	}
 	USETDW(temp, val);
 	return ure_write_mem(un, reg, index | byen, &temp, 4);
+}
 static int
 ure_write_2(struct usbnet *un, uint16_t reg, uint16_t index, uint32_t val)
+{
 	uint16_t byen;
 	uint8_t temp[4];
 	uint8_t shift;
 	byen = URE_BYTE_EN_WORD;
 	shift = reg & 2;
 	val &= 0xffff;
 	if (reg & 2) {
 		byen <<= shift;
 		val <<= (shift << 3);
 		reg &= ~3;
+	}
 	USETDW(temp, val);
 	return ure_write_mem(un, reg, index | byen, &temp, 4);
+}
 static int
 ure_write_4(struct usbnet *un, uint16_t reg, uint16_t index, uint32_t val)
+{
 	uint8_t temp[4];
 	USETDW(temp, val);
 	return ure_write_mem(un, reg, index | URE_BYTE_EN_DWORD, &temp, 4);
+}
 static uint16_t
 ure_ocp_reg_read(struct usbnet *un, uint16_t addr)
+{
 	uint16_t reg;
 	ure_write_2(un, URE_PLA_OCP_GPHY_BASE, URE_MCU_TYPE_PLA, addr & 0xf000);
 	reg = (addr & 0x0fff) | 0xb000;
 	return ure_read_2(un, reg, URE_MCU_TYPE_PLA);
+}
 static void
 ure_ocp_reg_write(struct usbnet *un, uint16_t addr, uint16_t data)
+{
 	uint16_t reg;
 	ure_write_2(un, URE_PLA_OCP_GPHY_BASE, URE_MCU_TYPE_PLA, addr & 0xf000);
 	reg = (addr & 0x0fff) | 0xb000;
 	ure_write_2(un, reg, URE_MCU_TYPE_PLA, data);
+}
 static int
 ure_uno_mii_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
+{
 	if (un->un_phyno != phy) {
 		*val = 0;
 		return EINVAL;
+	}
 	/* Let the rgephy driver read the URE_PLA_PHYSTATUS register. */
 	if (reg == RTK_GMEDIASTAT) {
 		*val = ure_read_1(un, URE_PLA_PHYSTATUS, URE_MCU_TYPE_PLA);
 		return USBD_NORMAL_COMPLETION;
+	}
 	*val = ure_ocp_reg_read(un, URE_OCP_BASE_MII + reg * 2);
 	return 0;
+}
 static int
 ure_uno_mii_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
+{
 	if (un->un_phyno != phy)
 		return EINVAL;
 	ure_ocp_reg_write(un, URE_OCP_BASE_MII + reg * 2, val);
 	return 0;
+}
 static void
 ure_uno_miibus_statchg(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct mii_data * const mii = usbnet_mii(un);
 	if (usbnet_isdying(un))
 		return;
 	if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
 	    (IFM_ACTIVE | IFM_AVALID)) {
 		switch (IFM_SUBTYPE(mii->mii_media_active)) {
 		case IFM_10_T:
 		case IFM_100_TX:
 			usbnet_set_link(un, true);
 			break;
 		case IFM_1000_T:
 			if ((un->un_flags & URE_FLAG_8152) != 0)
 				break;
 			usbnet_set_link(un, true);
 			break;
 		default:
 			break;
+		}
+	}
+}
 static void
 ure_uno_mcast(struct ifnet *ifp)
+{
 	struct usbnet *un = ifp->if_softc;
 	struct ethercom *ec = usbnet_ec(un);
 	struct ether_multi *enm;
 	struct ether_multistep step;
 	uint32_t mchash[2] = { 0, 0 };
 	uint32_t h = 0, rxmode;
 	if (usbnet_isdying(un))
 		return;
 	rxmode = ure_read_4(un, URE_PLA_RCR, URE_MCU_TYPE_PLA);
 	rxmode &= ~(URE_RCR_AAP | URE_RCR_AM);
 	/* continue to accept my own DA and bcast frames */
 	ETHER_LOCK(ec);
 	if (ifp->if_flags & IFF_PROMISC) {
 		ec->ec_flags |= ETHER_F_ALLMULTI;
 		ETHER_UNLOCK(ec);
 		/* run promisc. mode */
 		rxmode |= URE_RCR_AM;	/* ??? */
 		rxmode |= URE_RCR_AAP;
 		goto update;
+	}
 	ec->ec_flags &= ~ETHER_F_ALLMULTI;
 	ETHER_FIRST_MULTI(step, ec, enm);
 	while (enm != NULL) {
 		if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
 			ec->ec_flags |= ETHER_F_ALLMULTI;
 			ETHER_UNLOCK(ec);
 			/* accept all mcast frames */
 			rxmode |= URE_RCR_AM;
 			mchash[0] = mchash[1] = ~0U; /* necessary ?? */
 			goto update;
+		}
 		h = ether_crc32_be(enm->enm_addrlo, ETHER_ADDR_LEN);
 		mchash[h >> 31] |= 1 << ((h >> 26) & 0x1f);
 		ETHER_NEXT_MULTI(step, enm);
+	}
 	ETHER_UNLOCK(ec);
 	if (h != 0) {
 		rxmode |= URE_RCR_AM;	/* activate mcast hash filter */
 		h = bswap32(mchash[0]);
 		mchash[0] = bswap32(mchash[1]);
 		mchash[1] = h;
+	}
  update:
 	ure_write_4(un, URE_PLA_MAR0, URE_MCU_TYPE_PLA, mchash[0]);
 	ure_write_4(un, URE_PLA_MAR4, URE_MCU_TYPE_PLA, mchash[1]);
 	ure_write_4(un, URE_PLA_RCR, URE_MCU_TYPE_PLA, rxmode);
+}
 static void
 ure_reset(struct usbnet *un)
+{
 	int i;
 	ure_write_1(un, URE_PLA_CR, URE_MCU_TYPE_PLA, URE_CR_RST);
 	for (i = 0; i < URE_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return;
 		if (!(ure_read_1(un, URE_PLA_CR, URE_MCU_TYPE_PLA) &
 		    URE_CR_RST))
 			break;
 		usbd_delay_ms(un->un_udev, 10);
+	}
 	if (i == URE_TIMEOUT)
 		URE_PRINTF(un, "reset never completed\n");
+}
 static int
 ure_uno_init(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	uint8_t eaddr[8];
 	/* Cancel pending I/O. */
 	if (ifp->if_flags & IFF_RUNNING)
 		usbnet_stop(un, ifp, 1);
 	/* Set MAC address. */
 	memset(eaddr, 0, sizeof(eaddr));
 	memcpy(eaddr, CLLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
 	ure_write_1(un, URE_PLA_CRWECR, URE_MCU_TYPE_PLA, URE_CRWECR_CONFIG);
 	ure_write_mem(un, URE_PLA_IDR, URE_MCU_TYPE_PLA | URE_BYTE_EN_SIX_BYTES,
 	    eaddr, 8);
 	ure_write_1(un, URE_PLA_CRWECR, URE_MCU_TYPE_PLA, URE_CRWECR_NORAML);
 	/* Reset the packet filter. */
 	ure_write_2(un, URE_PLA_FMC, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_FMC, URE_MCU_TYPE_PLA) &
 	    ~URE_FMC_FCR_MCU_EN);
 	ure_write_2(un, URE_PLA_FMC, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_FMC, URE_MCU_TYPE_PLA) |
 	    URE_FMC_FCR_MCU_EN);
 	/* Enable transmit and receive. */
 	ure_write_1(un, URE_PLA_CR, URE_MCU_TYPE_PLA,
 	    ure_read_1(un, URE_PLA_CR, URE_MCU_TYPE_PLA) | URE_CR_RE |
 	    URE_CR_TE);
 	ure_write_2(un, URE_PLA_MISC_1, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_MISC_1, URE_MCU_TYPE_PLA) &
 	    ~URE_RXDY_GATED_EN);
 	return usbnet_init_rx_tx(un);
+}
 static void
 ure_uno_stop(struct ifnet *ifp, int disable __unused)
+{
 	struct usbnet * const un = ifp->if_softc;
 	ure_reset(un);
+}
 static void
 ure_rtl8152_init(struct usbnet *un)
+{
 	uint32_t pwrctrl;
 	/* Disable ALDPS. */
 	ure_ocp_reg_write(un, URE_OCP_ALDPS_CONFIG, URE_ENPDNPS | URE_LINKENA |
 	    URE_DIS_SDSAVE);
 	usbd_delay_ms(un->un_udev, 20);
 	if (un->un_flags & URE_FLAG_VER_4C00) {
 		ure_write_2(un, URE_PLA_LED_FEATURE, URE_MCU_TYPE_PLA,
 		    ure_read_2(un, URE_PLA_LED_FEATURE, URE_MCU_TYPE_PLA) &
 		    ~URE_LED_MODE_MASK);
+	}
 	ure_write_2(un, URE_USB_UPS_CTRL, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_UPS_CTRL, URE_MCU_TYPE_USB) &
 	    ~URE_POWER_CUT);
 	ure_write_2(un, URE_USB_PM_CTRL_STATUS, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_PM_CTRL_STATUS, URE_MCU_TYPE_USB) &
 	    ~URE_RESUME_INDICATE);
 	ure_write_2(un, URE_PLA_PHY_PWR, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_PHY_PWR, URE_MCU_TYPE_PLA) |
 	    URE_TX_10M_IDLE_EN | URE_PFM_PWM_SWITCH);
 	pwrctrl = ure_read_4(un, URE_PLA_MAC_PWR_CTRL, URE_MCU_TYPE_PLA);
 	pwrctrl &= ~URE_MCU_CLK_RATIO_MASK;
 	pwrctrl |= URE_MCU_CLK_RATIO | URE_D3_CLK_GATED_EN;
 	ure_write_4(un, URE_PLA_MAC_PWR_CTRL, URE_MCU_TYPE_PLA, pwrctrl);
 	ure_write_2(un, URE_PLA_GPHY_INTR_IMR, URE_MCU_TYPE_PLA,
 	    URE_GPHY_STS_MSK | URE_SPEED_DOWN_MSK | URE_SPDWN_RXDV_MSK |
 	    URE_SPDWN_LINKCHG_MSK);
 	/* Enable Rx aggregation. */
 	ure_write_2(un, URE_USB_USB_CTRL, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_USB_CTRL, URE_MCU_TYPE_USB) &
 	    ~URE_RX_AGG_DISABLE);
 	/* Disable ALDPS. */
 	ure_ocp_reg_write(un, URE_OCP_ALDPS_CONFIG, URE_ENPDNPS | URE_LINKENA |
 	    URE_DIS_SDSAVE);
 	usbd_delay_ms(un->un_udev, 20);
 	ure_init_fifo(un);
 	ure_write_1(un, URE_USB_TX_AGG, URE_MCU_TYPE_USB,
 	    URE_TX_AGG_MAX_THRESHOLD);
 	ure_write_4(un, URE_USB_RX_BUF_TH, URE_MCU_TYPE_USB, URE_RX_THR_HIGH);
 	ure_write_4(un, URE_USB_TX_DMA, URE_MCU_TYPE_USB,
 	    URE_TEST_MODE_DISABLE | URE_TX_SIZE_ADJUST1);
+}
 static void
 ure_rtl8153_init(struct usbnet *un)
+{
 	uint16_t val;
 	uint8_t u1u2[8];
 	int i;
 	/* Disable ALDPS. */
 	ure_ocp_reg_write(un, URE_OCP_POWER_CFG,
 	    ure_ocp_reg_read(un, URE_OCP_POWER_CFG) & ~URE_EN_ALDPS);
 	usbd_delay_ms(un->un_udev, 20);
 	memset(u1u2, 0x00, sizeof(u1u2));
 	ure_write_mem(un, URE_USB_TOLERANCE,
 	    URE_MCU_TYPE_USB | URE_BYTE_EN_SIX_BYTES, u1u2, sizeof(u1u2));
 	for (i = 0; i < URE_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return;
 		if (ure_read_2(un, URE_PLA_BOOT_CTRL, URE_MCU_TYPE_PLA) &
 		    URE_AUTOLOAD_DONE)
 			break;
 		usbd_delay_ms(un->un_udev, 10);
+	}
 	if (i == URE_TIMEOUT)
 		URE_PRINTF(un, "timeout waiting for chip autoload\n");
 	for (i = 0; i < URE_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return;
 		val = ure_ocp_reg_read(un, URE_OCP_PHY_STATUS) &
 		    URE_PHY_STAT_MASK;
 		if (val == URE_PHY_STAT_LAN_ON || val == URE_PHY_STAT_PWRDN)
 			break;
 		usbd_delay_ms(un->un_udev, 10);
+	}
 	if (i == URE_TIMEOUT)
 		URE_PRINTF(un, "timeout waiting for phy to stabilize\n");
 	ure_write_2(un, URE_USB_U2P3_CTRL, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_U2P3_CTRL, URE_MCU_TYPE_USB) &
 	    ~URE_U2P3_ENABLE);
 	if (un->un_flags & URE_FLAG_VER_5C10) {
 		val = ure_read_2(un, URE_USB_SSPHYLINK2, URE_MCU_TYPE_USB);
 		val &= ~URE_PWD_DN_SCALE_MASK;
 		val |= URE_PWD_DN_SCALE(96);
 		ure_write_2(un, URE_USB_SSPHYLINK2, URE_MCU_TYPE_USB, val);
 		ure_write_1(un, URE_USB_USB2PHY, URE_MCU_TYPE_USB,
 		    ure_read_1(un, URE_USB_USB2PHY, URE_MCU_TYPE_USB) |
 		    URE_USB2PHY_L1 | URE_USB2PHY_SUSPEND);
 	} else if (un->un_flags & URE_FLAG_VER_5C20) {
 		ure_write_1(un, URE_PLA_DMY_REG0, URE_MCU_TYPE_PLA,
 		    ure_read_1(un, URE_PLA_DMY_REG0, URE_MCU_TYPE_PLA) &
 		    ~URE_ECM_ALDPS);
+	}
 	if (un->un_flags & (URE_FLAG_VER_5C20 | URE_FLAG_VER_5C30)) {
 		val = ure_read_1(un, URE_USB_CSR_DUMMY1, URE_MCU_TYPE_USB);
 		if (ure_read_2(un, URE_USB_BURST_SIZE, URE_MCU_TYPE_USB) ==
 )
 			val &= ~URE_DYNAMIC_BURST;
 		else
 			val |= URE_DYNAMIC_BURST;
 		ure_write_1(un, URE_USB_CSR_DUMMY1, URE_MCU_TYPE_USB, val);
+	}
 	ure_write_1(un, URE_USB_CSR_DUMMY2, URE_MCU_TYPE_USB,
 	    ure_read_1(un, URE_USB_CSR_DUMMY2, URE_MCU_TYPE_USB) |
 	    URE_EP4_FULL_FC);
 	ure_write_2(un, URE_USB_WDT11_CTRL, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_WDT11_CTRL, URE_MCU_TYPE_USB) &
 	    ~URE_TIMER11_EN);
 	ure_write_2(un, URE_PLA_LED_FEATURE, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_LED_FEATURE, URE_MCU_TYPE_PLA) &
 	    ~URE_LED_MODE_MASK);
 	if ((un->un_flags & URE_FLAG_VER_5C10) &&
 	    un->un_udev->ud_speed != USB_SPEED_SUPER)
 		val = URE_LPM_TIMER_500MS;
 	else
 		val = URE_LPM_TIMER_500US;
 	ure_write_1(un, URE_USB_LPM_CTRL, URE_MCU_TYPE_USB,
 	    val | URE_FIFO_EMPTY_1FB | URE_ROK_EXIT_LPM);
 	val = ure_read_2(un, URE_USB_AFE_CTRL2, URE_MCU_TYPE_USB);
 	val &= ~URE_SEN_VAL_MASK;
 	val |= URE_SEN_VAL_NORMAL | URE_SEL_RXIDLE;
 	ure_write_2(un, URE_USB_AFE_CTRL2, URE_MCU_TYPE_USB, val);
 	ure_write_2(un, URE_USB_CONNECT_TIMER, URE_MCU_TYPE_USB, 0x0001);
 	ure_write_2(un, URE_USB_POWER_CUT, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_POWER_CUT, URE_MCU_TYPE_USB) &
 	    ~(URE_PWR_EN | URE_PHASE2_EN));
 	ure_write_2(un, URE_USB_MISC_0, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_MISC_0, URE_MCU_TYPE_USB) &
 	    ~URE_PCUT_STATUS);
 	memset(u1u2, 0xff, sizeof(u1u2));
 	ure_write_mem(un, URE_USB_TOLERANCE,
 	    URE_MCU_TYPE_USB | URE_BYTE_EN_SIX_BYTES, u1u2, sizeof(u1u2));
 	ure_write_2(un, URE_PLA_MAC_PWR_CTRL, URE_MCU_TYPE_PLA,
 	    URE_ALDPS_SPDWN_RATIO);
 	ure_write_2(un, URE_PLA_MAC_PWR_CTRL2, URE_MCU_TYPE_PLA,
 	    URE_EEE_SPDWN_RATIO);
 	ure_write_2(un, URE_PLA_MAC_PWR_CTRL3, URE_MCU_TYPE_PLA,
 	    URE_PKT_AVAIL_SPDWN_EN | URE_SUSPEND_SPDWN_EN |
 	    URE_U1U2_SPDWN_EN | URE_L1_SPDWN_EN);
 	ure_write_2(un, URE_PLA_MAC_PWR_CTRL4, URE_MCU_TYPE_PLA,
 	    URE_PWRSAVE_SPDWN_EN | URE_RXDV_SPDWN_EN | URE_TX10MIDLE_EN |
 	    URE_TP100_SPDWN_EN | URE_TP500_SPDWN_EN | URE_TP1000_SPDWN_EN |
 	    URE_EEE_SPDWN_EN);
 	val = ure_read_2(un, URE_USB_U2P3_CTRL, URE_MCU_TYPE_USB);
 	if (!(un->un_flags & (URE_FLAG_VER_5C00 | URE_FLAG_VER_5C10)))
 		val |= URE_U2P3_ENABLE;
 	else
 		val &= ~URE_U2P3_ENABLE;
 	ure_write_2(un, URE_USB_U2P3_CTRL, URE_MCU_TYPE_USB, val);
 	memset(u1u2, 0x00, sizeof(u1u2));
 	ure_write_mem(un, URE_USB_TOLERANCE,
 	    URE_MCU_TYPE_USB | URE_BYTE_EN_SIX_BYTES, u1u2, sizeof(u1u2));
 	/* Disable ALDPS. */
 	ure_ocp_reg_write(un, URE_OCP_POWER_CFG,
 	    ure_ocp_reg_read(un, URE_OCP_POWER_CFG) & ~URE_EN_ALDPS);
 	usbd_delay_ms(un->un_udev, 20);
 	ure_init_fifo(un);
 	/* Enable Rx aggregation. */
 	ure_write_2(un, URE_USB_USB_CTRL, URE_MCU_TYPE_USB,
 	    ure_read_2(un, URE_USB_USB_CTRL, URE_MCU_TYPE_USB) &
 	    ~URE_RX_AGG_DISABLE);
 	val = ure_read_2(un, URE_USB_U2P3_CTRL, URE_MCU_TYPE_USB);
 	if (!(un->un_flags & (URE_FLAG_VER_5C00 | URE_FLAG_VER_5C10)))
 		val |= URE_U2P3_ENABLE;
 	else
 		val &= ~URE_U2P3_ENABLE;
 	ure_write_2(un, URE_USB_U2P3_CTRL, URE_MCU_TYPE_USB, val);
 	memset(u1u2, 0xff, sizeof(u1u2));
 	ure_write_mem(un, URE_USB_TOLERANCE,
 	    URE_MCU_TYPE_USB | URE_BYTE_EN_SIX_BYTES, u1u2, sizeof(u1u2));
+}
 static void
 ure_disable_teredo(struct usbnet *un)
+{
 	ure_write_4(un, URE_PLA_TEREDO_CFG, URE_MCU_TYPE_PLA,
 	    ure_read_4(un, URE_PLA_TEREDO_CFG, URE_MCU_TYPE_PLA) &
 	    ~(URE_TEREDO_SEL | URE_TEREDO_RS_EVENT_MASK | URE_OOB_TEREDO_EN));
 	ure_write_2(un, URE_PLA_WDT6_CTRL, URE_MCU_TYPE_PLA,
 	    URE_WDT6_SET_MODE);
 	ure_write_2(un, URE_PLA_REALWOW_TIMER, URE_MCU_TYPE_PLA, 0);
 	ure_write_4(un, URE_PLA_TEREDO_TIMER, URE_MCU_TYPE_PLA, 0);
+}
 static void
 ure_init_fifo(struct usbnet *un)
+{
 	uint32_t rxmode, rx_fifo1, rx_fifo2;
 	int i;
 	ure_write_2(un, URE_PLA_MISC_1, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_MISC_1, URE_MCU_TYPE_PLA) |
 	    URE_RXDY_GATED_EN);
 	ure_disable_teredo(un);
 	rxmode = ure_read_4(un, URE_PLA_RCR, URE_MCU_TYPE_PLA);
 	rxmode &= ~URE_RCR_ACPT_ALL;
 	rxmode |= URE_RCR_APM | URE_RCR_AB; /* accept my own DA and bcast */
 	ure_write_4(un, URE_PLA_RCR, URE_MCU_TYPE_PLA, rxmode);
 	if (!(un->un_flags & URE_FLAG_8152)) {
 		if (un->un_flags & (URE_FLAG_VER_5C00 | URE_FLAG_VER_5C10 |
 		    URE_FLAG_VER_5C20))
 			ure_ocp_reg_write(un, URE_OCP_ADC_CFG,
 			    URE_CKADSEL_L | URE_ADC_EN | URE_EN_EMI_L);
 		if (un->un_flags & URE_FLAG_VER_5C00)
 			ure_ocp_reg_write(un, URE_OCP_EEE_CFG,
 			    ure_ocp_reg_read(un, URE_OCP_EEE_CFG) &
 			    ~URE_CTAP_SHORT_EN);
 		ure_ocp_reg_write(un, URE_OCP_POWER_CFG,
 		    ure_ocp_reg_read(un, URE_OCP_POWER_CFG) |
 		    URE_EEE_CLKDIV_EN);
 		ure_ocp_reg_write(un, URE_OCP_DOWN_SPEED,
 		    ure_ocp_reg_read(un, URE_OCP_DOWN_SPEED) |
 		    URE_EN_10M_BGOFF);
 		ure_ocp_reg_write(un, URE_OCP_POWER_CFG,
 		    ure_ocp_reg_read(un, URE_OCP_POWER_CFG) |
 		    URE_EN_10M_PLLOFF);
 		ure_ocp_reg_write(un, URE_OCP_SRAM_ADDR, URE_SRAM_IMPEDANCE);
 		ure_ocp_reg_write(un, URE_OCP_SRAM_DATA, 0x0b13);
 		ure_write_2(un, URE_PLA_PHY_PWR, URE_MCU_TYPE_PLA,
 		    ure_read_2(un, URE_PLA_PHY_PWR, URE_MCU_TYPE_PLA) |
 		    URE_PFM_PWM_SWITCH);
 		/* Enable LPF corner auto tune. */
 		ure_ocp_reg_write(un, URE_OCP_SRAM_ADDR, URE_SRAM_LPF_CFG);
 		ure_ocp_reg_write(un, URE_OCP_SRAM_DATA, 0xf70f);
 		/* Adjust 10M amplitude. */
 		ure_ocp_reg_write(un, URE_OCP_SRAM_ADDR, URE_SRAM_10M_AMP1);
 		ure_ocp_reg_write(un, URE_OCP_SRAM_DATA, 0x00af);
 		ure_ocp_reg_write(un, URE_OCP_SRAM_ADDR, URE_SRAM_10M_AMP2);
 		ure_ocp_reg_write(un, URE_OCP_SRAM_DATA, 0x0208);
+	}
 	ure_reset(un);
 	ure_write_1(un, URE_PLA_CR, URE_MCU_TYPE_PLA, 0);
 	ure_write_1(un, URE_PLA_OOB_CTRL, URE_MCU_TYPE_PLA,
 	    ure_read_1(un, URE_PLA_OOB_CTRL, URE_MCU_TYPE_PLA) &
 	    ~URE_NOW_IS_OOB);
 	ure_write_2(un, URE_PLA_SFF_STS_7, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_SFF_STS_7, URE_MCU_TYPE_PLA) &
 	    ~URE_MCU_BORW_EN);
 	for (i = 0; i < URE_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return;
 		if (ure_read_1(un, URE_PLA_OOB_CTRL, URE_MCU_TYPE_PLA) &
 		    URE_LINK_LIST_READY)
 			break;
 		usbd_delay_ms(un->un_udev, 10);
+	}
 	if (i == URE_TIMEOUT)
 		URE_PRINTF(un, "timeout waiting for OOB control\n");
 	ure_write_2(un, URE_PLA_SFF_STS_7, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_SFF_STS_7, URE_MCU_TYPE_PLA) |
 	    URE_RE_INIT_LL);
 	for (i = 0; i < URE_TIMEOUT; i++) {
 		if (usbnet_isdying(un))
 			return;
 		if (ure_read_1(un, URE_PLA_OOB_CTRL, URE_MCU_TYPE_PLA) &
 		    URE_LINK_LIST_READY)
 			break;
 		usbd_delay_ms(un->un_udev, 10);
+	}
 	if (i == URE_TIMEOUT)
 		URE_PRINTF(un, "timeout waiting for OOB control\n");
 	ure_write_2(un, URE_PLA_CPCR, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_CPCR, URE_MCU_TYPE_PLA) &
 	    ~URE_CPCR_RX_VLAN);
 	ure_write_2(un, URE_PLA_TCR0, URE_MCU_TYPE_PLA,
 	    ure_read_2(un, URE_PLA_TCR0, URE_MCU_TYPE_PLA) |
 	    URE_TCR0_AUTO_FIFO);
 	/* Configure Rx FIFO threshold and coalescing. */
 	ure_write_4(un, URE_PLA_RXFIFO_CTRL0, URE_MCU_TYPE_PLA,
 	    URE_RXFIFO_THR1_NORMAL);
 	if (un->un_udev->ud_speed == USB_SPEED_FULL) {
 		rx_fifo1 = URE_RXFIFO_THR2_FULL;
 		rx_fifo2 = URE_RXFIFO_THR3_FULL;
 	} else {
 		rx_fifo1 = URE_RXFIFO_THR2_HIGH;
 		rx_fifo2 = URE_RXFIFO_THR3_HIGH;
+	}
 	ure_write_4(un, URE_PLA_RXFIFO_CTRL1, URE_MCU_TYPE_PLA, rx_fifo1);
 	ure_write_4(un, URE_PLA_RXFIFO_CTRL2, URE_MCU_TYPE_PLA, rx_fifo2);
 	/* Configure Tx FIFO threshold. */
 	ure_write_4(un, URE_PLA_TXFIFO_CTRL, URE_MCU_TYPE_PLA,
 	    URE_TXFIFO_THR_NORMAL);
+}
 static int
 ure_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	return usb_lookup(ure_devs, uaa->uaa_vendor, uaa->uaa_product) != NULL ?
 	    UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 static void
 ure_attach(device_t parent, device_t self, void *aux)
+{
 	USBNET_MII_DECL_DEFAULT(unm);
 	struct usbnet * const un = device_private(self);
 	struct usb_attach_arg *uaa = aux;
 	struct usbd_device *dev = uaa->uaa_device;
 	usb_interface_descriptor_t *id;
 	usb_endpoint_descriptor_t *ed;
 	int error, i;
 	uint16_t ver;
 	uint8_t eaddr[8]; /* 2byte padded */
 	char *devinfop;
 	uint32_t maclo, machi;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(dev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	un->un_dev = self;
 	un->un_udev = dev;
 	un->un_sc = un;
 	un->un_ops = &ure_ops;
 	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
 	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
 	un->un_rx_list_cnt = URE_RX_LIST_CNT;
 	un->un_tx_list_cnt = URE_TX_LIST_CNT;
 	un->un_rx_bufsz = URE_BUFSZ;
 	un->un_tx_bufsz = URE_BUFSZ;
 #define URE_CONFIG_NO	1 /* XXX */
 	error = usbd_set_config_no(dev, URE_CONFIG_NO, 1);
 	if (error) {
 		aprint_error_dev(self, "failed to set configuration: %s\n",
 		    usbd_errstr(error));
 		return; /* XXX */
+	}
 	if (uaa->uaa_product == USB_PRODUCT_REALTEK_RTL8152)
 		un->un_flags |= URE_FLAG_8152;
 #define URE_IFACE_IDX  0 /* XXX */
 	error = usbd_device2interface_handle(dev, URE_IFACE_IDX, &un->un_iface);
 	if (error) {
 		aprint_error_dev(self, "failed to get interface handle: %s\n",
 		    usbd_errstr(error));
 		return; /* XXX */
+	}
 	id = usbd_get_interface_descriptor(un->un_iface);
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(un->un_iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self, "couldn't get ep %d\n", i);
 			return; /* XXX */
+		}
 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
+		}
+	}
 	/* Set these up now for ure_ctl().  */
 	usbnet_attach(un, "uredet");
 	un->un_phyno = 0;
 	ver = ure_read_2(un, URE_PLA_TCR1, URE_MCU_TYPE_PLA) & URE_VERSION_MASK;
 	switch (ver) {
 	case 0x4c00:
 		un->un_flags |= URE_FLAG_VER_4C00;
 		break;
 	case 0x4c10:
 		un->un_flags |= URE_FLAG_VER_4C10;
 		break;
 	case 0x5c00:
 		un->un_flags |= URE_FLAG_VER_5C00;
 		break;
 	case 0x5c10:
 		un->un_flags |= URE_FLAG_VER_5C10;
 		break;
 	case 0x5c20:
 		un->un_flags |= URE_FLAG_VER_5C20;
 		break;
 	case 0x5c30:
 		un->un_flags |= URE_FLAG_VER_5C30;
 		break;
 	default:
 		/* fake addr?  or just fail? */
 		break;
+	}
 	aprint_normal_dev(self, "RTL%d %sver %04x\n",
 	    (un->un_flags & URE_FLAG_8152) ? 8152 : 8153,
 	    (un->un_flags != 0) ? "" : "unknown ",
 	    ver);
 	if (un->un_flags & URE_FLAG_8152)
 		ure_rtl8152_init(un);
 	else
 		ure_rtl8153_init(un);
 	if ((un->un_flags & URE_FLAG_VER_4C00) ||
 	    (un->un_flags & URE_FLAG_VER_4C10))
 		ure_read_mem(un, URE_PLA_IDR, URE_MCU_TYPE_PLA, eaddr,
 		    sizeof(eaddr));
 	else
 		ure_read_mem(un, URE_PLA_BACKUP, URE_MCU_TYPE_PLA, eaddr,
 		    sizeof(eaddr));
 	if (ETHER_IS_ZERO(eaddr)) {
 		maclo = 0x00f2 | (cprng_strong32() & 0xffff0000);
 		machi = cprng_strong32() & 0xffff;
 		eaddr[0] = maclo & 0xff;
 		eaddr[1] = (maclo >> 8) & 0xff;
 		eaddr[2] = (maclo >> 16) & 0xff;
 		eaddr[3] = (maclo >> 24) & 0xff;
 		eaddr[4] = machi & 0xff;
 		eaddr[5] = (machi >> 8) & 0xff;
+	}
 	memcpy(un->un_eaddr, eaddr, sizeof(un->un_eaddr));
 	struct ifnet *ifp = usbnet_ifp(un);
 	/*
 	 * We don't support TSOv4 and v6 for now, that are required to
 	 * be handled in software for some cases.
 	 */
 	ifp->if_capabilities = IFCAP_CSUM_IPv4_Tx |
 	    IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_UDPv4_Tx;
 #ifdef INET6
 	ifp->if_capabilities |= IFCAP_CSUM_TCPv6_Tx | IFCAP_CSUM_UDPv6_Tx;
 #endif
 	if (un->un_flags & ~URE_FLAG_VER_4C00) {
 		ifp->if_capabilities |= IFCAP_CSUM_IPv4_Rx |
 		    IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_UDPv4_Rx |
 		    IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_UDPv6_Rx;
+	}
 	struct ethercom *ec = usbnet_ec(un);
 	ec->ec_capabilities = ETHERCAP_VLAN_MTU;
 #ifdef notyet
 	ec->ec_capabilities |= ETHERCAP_JUMBO_MTU;
 #endif
 	unm.un_mii_phyloc = un->un_phyno;
 	usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
 , &unm);
+}
 static void
 ure_uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len)
+{
 	struct ifnet *ifp = usbnet_ifp(un);
 	uint8_t *buf = c->unc_buf;
 	uint16_t pkt_len = 0;
 	uint16_t pkt_count = 0;
 	struct ure_rxpkt rxhdr;
 	do {
 		if (total_len < sizeof(rxhdr)) {
 			DPRINTF(("too few bytes left for a packet header\n"));
 			if_statinc(ifp, if_ierrors);
 			return;
+		}
 		buf += roundup(pkt_len, 8);
 		memcpy(&rxhdr, buf, sizeof(rxhdr));
 		total_len -= sizeof(rxhdr);
 		pkt_len = le32toh(rxhdr.ure_pktlen) & URE_RXPKT_LEN_MASK;
 		DPRINTFN(4, ("next packet is %d bytes\n", pkt_len));
 		if (pkt_len > total_len) {
 			DPRINTF(("not enough bytes left for next packet\n"));
 			if_statinc(ifp, if_ierrors);
 			return;
+		}
 		total_len -= roundup(pkt_len, 8);
 		buf += sizeof(rxhdr);
 		usbnet_enqueue(un, buf, pkt_len - ETHER_CRC_LEN,
 			       ure_rxcsum(ifp, &rxhdr), 0, 0);
 		pkt_count++;
 	} while (total_len > 0);
 	if (pkt_count)
 		rnd_add_uint32(usbnet_rndsrc(un), pkt_count);
+}
 static int
 ure_rxcsum(struct ifnet *ifp, struct ure_rxpkt *rp)
+{
 	int enabled = ifp->if_csum_flags_rx, flags = 0;
 	uint32_t csum, misc;
 	if (enabled == 0)
 		return 0;
 	csum = le32toh(rp->ure_csum);
 	misc = le32toh(rp->ure_misc);
 	if (csum & URE_RXPKT_IPV4_CS) {
 		flags |= M_CSUM_IPv4;
 		if (csum & URE_RXPKT_TCP_CS)
 			flags |= M_CSUM_TCPv4;
 		if (csum & URE_RXPKT_UDP_CS)
 			flags |= M_CSUM_UDPv4;
 	} else if (csum & URE_RXPKT_IPV6_CS) {
 		flags = 0;
 		if (csum & URE_RXPKT_TCP_CS)
 			flags |= M_CSUM_TCPv6;
 		if (csum & URE_RXPKT_UDP_CS)
 			flags |= M_CSUM_UDPv6;
+	}
 	flags &= enabled;
 	if (__predict_false((flags & M_CSUM_IPv4) &&
 	    (misc & URE_RXPKT_IP_F)))
 		flags |= M_CSUM_IPv4_BAD;
 	if (__predict_false(
 	   ((flags & (M_CSUM_TCPv4 | M_CSUM_TCPv6)) && (misc & URE_RXPKT_TCP_F))
 	|| ((flags & (M_CSUM_UDPv4 | M_CSUM_UDPv6)) && (misc & URE_RXPKT_UDP_F))
 	))
 		flags |= M_CSUM_TCP_UDP_BAD;
 	return flags;
+}
 static unsigned
 ure_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	struct ure_txpkt txhdr;
 	uint32_t frm_len = 0;
 	uint8_t *buf = c->unc_buf;
 	if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz - sizeof(txhdr))
 		return 0;
 	/* header */
 	txhdr.ure_pktlen = htole32(m->m_pkthdr.len | URE_TXPKT_TX_FS |
 	    URE_TXPKT_TX_LS);
 	txhdr.ure_csum = htole32(ure_txcsum(m));
 	memcpy(buf, &txhdr, sizeof(txhdr));
 	buf += sizeof(txhdr);
 	frm_len = sizeof(txhdr);
 	/* packet */
 	m_copydata(m, 0, m->m_pkthdr.len, buf);
 	frm_len += m->m_pkthdr.len;
 	DPRINTFN(2, ("tx %d bytes\n", frm_len));
 	return frm_len;
+}
 /*
  * We need to calculate L4 checksum in software, if the offset of
  * L4 header is larger than 0x7ff = 2047.
  */
 static uint32_t
 ure_txcsum(struct mbuf *m)
+{
 	struct ether_header *eh;
 	int flags = m->m_pkthdr.csum_flags;
 	uint32_t data = m->m_pkthdr.csum_data;
 	uint32_t reg = 0;
 	int l3off, l4off;
 	uint16_t type;
 	if (flags == 0)
 		return 0;
 	if (__predict_true(m->m_len >= (int)sizeof(*eh))) {
 		eh = mtod(m, struct ether_header *);
 		type = eh->ether_type;
 	} else
 		m_copydata(m, offsetof(struct ether_header, ether_type),
 		    sizeof(type), &type);
 	switch (type = htons(type)) {
 	case ETHERTYPE_IP:
 	case ETHERTYPE_IPV6:
 		l3off = ETHER_HDR_LEN;
 		break;
 	case ETHERTYPE_VLAN:
 		l3off = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
 		break;
 	default:
 		return 0;
+	}
 	if (flags & (M_CSUM_TCPv4 | M_CSUM_UDPv4)) {
 		l4off = l3off + M_CSUM_DATA_IPv4_IPHL(data);
 		if (__predict_false(l4off > URE_L4_OFFSET_MAX)) {
 			in_undefer_cksum(m, l3off, flags);
 			return 0;
+		}
 		reg |= URE_TXPKT_IPV4_CS;
 		if (flags & M_CSUM_TCPv4)
 			reg |= URE_TXPKT_TCP_CS;
 		else
 			reg |= URE_TXPKT_UDP_CS;
 		reg |= l4off << URE_L4_OFFSET_SHIFT;
+	}
 #ifdef INET6
 	else if (flags & (M_CSUM_TCPv6 | M_CSUM_UDPv6)) {
 		l4off = l3off + M_CSUM_DATA_IPv6_IPHL(data);
 		if (__predict_false(l4off > URE_L4_OFFSET_MAX)) {
 			in6_undefer_cksum(m, l3off, flags);
 			return 0;
+		}
 		reg |= URE_TXPKT_IPV6_CS;
 		if (flags & M_CSUM_TCPv6)
 			reg |= URE_TXPKT_TCP_CS;
 		else
 			reg |= URE_TXPKT_UDP_CS;
 		reg |= l4off << URE_L4_OFFSET_SHIFT;
+	}
 #endif
 	else if (flags & M_CSUM_IPv4)
 		reg |= URE_TXPKT_IPV4_CS;
 	return reg;
+}
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 USBNET_MODULE(ure)

 @@ -1,1090 +1,1087 @@
-/*	$NetBSD: if_urndis.c,v 1.41 2022/03/03 05:54:45 riastradh Exp $ */
+/*	$NetBSD: if_urndis.c,v 1.42 2022/03/03 05:55:19 riastradh Exp $ */
 /*	$OpenBSD: if_urndis.c,v 1.31 2011/07/03 15:47:17 matthew Exp $ */
 /*
  * Copyright (c) 2010 Jonathan Armani <armani@openbsd.org>
  * Copyright (c) 2010 Fabien Romano <fabien@openbsd.org>
  * Copyright (c) 2010 Michael Knudsen <mk@openbsd.org>
  * All rights reserved.
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_urndis.c,v 1.41 2022/03/03 05:54:45 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_urndis.c,v 1.42 2022/03/03 05:55:19 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/kmem.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/usbcdc.h>
 #include <dev/ic/rndisreg.h>
 #define RNDIS_RX_LIST_CNT	1
 #define RNDIS_TX_LIST_CNT	1
 #define RNDIS_BUFSZ		1562
 struct urndis_softc {
 	struct usbnet			sc_un;
 	int				sc_ifaceno_ctl;
 	/* RNDIS device info */
 	uint32_t			sc_filter;
 	uint32_t			sc_maxppt;
 	uint32_t			sc_maxtsz;
 	uint32_t			sc_palign;
 };
 #ifdef URNDIS_DEBUG
 #define DPRINTF(x)      do { printf x; } while (0)
 #else
 #define DPRINTF(x)
 #endif
 #define DEVNAME(un)	(device_xname(un->un_dev))
 #define URNDIS_RESPONSE_LEN 0x400
 #if 0
 static void urndis_watchdog(struct ifnet *);
 #endif
 static int urndis_uno_init(struct ifnet *);
 static void urndis_uno_rx_loop(struct usbnet *, struct usbnet_chain *,
 			       uint32_t);
 static unsigned urndis_uno_tx_prepare(struct usbnet *, struct mbuf *,
 				      struct usbnet_chain *);
 static int urndis_init_un(struct ifnet *, struct usbnet *);
 static uint32_t urndis_ctrl_handle_init(struct usbnet *,
     const struct rndis_comp_hdr *);
 static uint32_t urndis_ctrl_handle_query(struct usbnet *,
     const struct rndis_comp_hdr *, void **, size_t *);
 static uint32_t urndis_ctrl_handle_reset(struct usbnet *,
     const struct rndis_comp_hdr *);
 static uint32_t urndis_ctrl_handle_status(struct usbnet *,
     const struct rndis_comp_hdr *);
 static uint32_t urndis_ctrl_set(struct usbnet *, uint32_t, void *,
     size_t);
 static int urndis_match(device_t, cfdata_t, void *);
 static void urndis_attach(device_t, device_t, void *);
 static const struct usbnet_ops urndis_ops = {
 	.uno_init = urndis_uno_init,
 	.uno_tx_prepare = urndis_uno_tx_prepare,
 	.uno_rx_loop = urndis_uno_rx_loop,
 };
 CFATTACH_DECL_NEW(urndis, sizeof(struct urndis_softc),
     urndis_match, urndis_attach, usbnet_detach, usbnet_activate);
 /*
  * Supported devices that we can't match by class IDs.
  */
 static const struct usb_devno urndis_devs[] = {
 	{ USB_VENDOR_HTC,	USB_PRODUCT_HTC_ANDROID },
 	{ USB_VENDOR_SAMSUNG,	USB_PRODUCT_SAMSUNG_ANDROID2 },
 	{ USB_VENDOR_SAMSUNG,	USB_PRODUCT_SAMSUNG_ANDROID },
 };
 static usbd_status
 urndis_ctrl_msg(struct usbnet *un, uint8_t rt, uint8_t r,
     uint16_t index, uint16_t value, void *buf, size_t buflen)
+{
 	usb_device_request_t req;
 	req.bmRequestType = rt;
 	req.bRequest = r;
 	USETW(req.wValue, value);
 	USETW(req.wIndex, index);
 	USETW(req.wLength, buflen);
 	return usbd_do_request(un->un_udev, &req, buf);
+}
 static usbd_status
 urndis_ctrl_send(struct usbnet *un, void *buf, size_t len)
+{
 	struct urndis_softc	*sc = usbnet_softc(un);
 	usbd_status err;
 	if (usbnet_isdying(un))
 		return(0);
 	err = urndis_ctrl_msg(un, UT_WRITE_CLASS_INTERFACE, UR_GET_STATUS,
 	    sc->sc_ifaceno_ctl, 0, buf, len);
 	if (err != USBD_NORMAL_COMPLETION)
 		printf("%s: %s\n", DEVNAME(un), usbd_errstr(err));
 	return err;
+}
 static struct rndis_comp_hdr *
 urndis_ctrl_recv(struct usbnet *un)
+{
 	struct urndis_softc	*sc = usbnet_softc(un);
 	struct rndis_comp_hdr	*hdr;
 	char			*buf;
 	usbd_status		 err;
 	if (usbnet_isdying(un))
 		return(0);
 	buf = kmem_alloc(URNDIS_RESPONSE_LEN, KM_SLEEP);
 	err = urndis_ctrl_msg(un, UT_READ_CLASS_INTERFACE, UR_CLEAR_FEATURE,
 	    sc->sc_ifaceno_ctl, 0, buf, URNDIS_RESPONSE_LEN);
 	if (err != USBD_NORMAL_COMPLETION && err != USBD_SHORT_XFER) {
 		printf("%s: %s\n", DEVNAME(un), usbd_errstr(err));
 		kmem_free(buf, URNDIS_RESPONSE_LEN);
 		return NULL;
+	}
 	hdr = (struct rndis_comp_hdr *)buf;
 	DPRINTF(("%s: urndis_ctrl_recv: type %#x len %u\n",
 	    DEVNAME(un),
 	    le32toh(hdr->rm_type),
 	    le32toh(hdr->rm_len)));
 	if (le32toh(hdr->rm_len) > URNDIS_RESPONSE_LEN) {
 		printf("%s: ctrl message error: wrong size %u > %u\n",
 		    DEVNAME(un),
 		    le32toh(hdr->rm_len),
 		    URNDIS_RESPONSE_LEN);
 		kmem_free(buf, URNDIS_RESPONSE_LEN);
 		return NULL;
+	}
 	return hdr;
+}
 static uint32_t
 urndis_ctrl_handle(struct usbnet *un, struct rndis_comp_hdr *hdr,
     void **buf, size_t *bufsz)
+{
 	uint32_t rval;
 	DPRINTF(("%s: urndis_ctrl_handle\n", DEVNAME(un)));
 	if (buf && bufsz) {
 		*buf = NULL;
 		*bufsz = 0;
+	}
 	switch (le32toh(hdr->rm_type)) {
 		case REMOTE_NDIS_INITIALIZE_CMPLT:
 			rval = urndis_ctrl_handle_init(un, hdr);
 			break;
 		case REMOTE_NDIS_QUERY_CMPLT:
 			rval = urndis_ctrl_handle_query(un, hdr, buf, bufsz);
 			break;
 		case REMOTE_NDIS_RESET_CMPLT:
 			rval = urndis_ctrl_handle_reset(un, hdr);
 			break;
 		case REMOTE_NDIS_KEEPALIVE_CMPLT:
 		case REMOTE_NDIS_SET_CMPLT:
 			rval = le32toh(hdr->rm_status);
 			break;
 		case REMOTE_NDIS_INDICATE_STATUS_MSG:
 			rval = urndis_ctrl_handle_status(un, hdr);
 			break;
 		default:
 			printf("%s: ctrl message error: unknown event %#x\n",
 			    DEVNAME(un), le32toh(hdr->rm_type));
 			rval = RNDIS_STATUS_FAILURE;
+	}
 	kmem_free(hdr, URNDIS_RESPONSE_LEN);
 	return rval;
+}
 static uint32_t
 urndis_ctrl_handle_init(struct usbnet *un, const struct rndis_comp_hdr *hdr)
+{
 	struct urndis_softc		*sc = usbnet_softc(un);
 	const struct rndis_init_comp	*msg;
 	msg = (const struct rndis_init_comp *) hdr;
 	DPRINTF(("%s: urndis_ctrl_handle_init: len %u rid %u status %#x "
 	    "ver_major %u ver_minor %u devflags %#x medium %#x pktmaxcnt %u "
 	    "pktmaxsz %u align %u aflistoffset %u aflistsz %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_rid),
 	    le32toh(msg->rm_status),
 	    le32toh(msg->rm_ver_major),
 	    le32toh(msg->rm_ver_minor),
 	    le32toh(msg->rm_devflags),
 	    le32toh(msg->rm_medium),
 	    le32toh(msg->rm_pktmaxcnt),
 	    le32toh(msg->rm_pktmaxsz),
 	    le32toh(msg->rm_align),
 	    le32toh(msg->rm_aflistoffset),
 	    le32toh(msg->rm_aflistsz)));
 	if (le32toh(msg->rm_status) != RNDIS_STATUS_SUCCESS) {
 		printf("%s: init failed %#x\n",
 		    DEVNAME(un),
 		    le32toh(msg->rm_status));
 		return le32toh(msg->rm_status);
+	}
 	if (le32toh(msg->rm_devflags) != RNDIS_DF_CONNECTIONLESS) {
 		printf("%s: wrong device type (current type: %#x)\n",
 		    DEVNAME(un),
 		    le32toh(msg->rm_devflags));
 		return RNDIS_STATUS_FAILURE;
+	}
 	if (le32toh(msg->rm_medium) != RNDIS_MEDIUM_802_3) {
 		printf("%s: medium not 802.3 (current medium: %#x)\n",
 		    DEVNAME(un), le32toh(msg->rm_medium));
 		return RNDIS_STATUS_FAILURE;
+	}
 	if (le32toh(msg->rm_ver_major) != RNDIS_MAJOR_VERSION ||
 	    le32toh(msg->rm_ver_minor) != RNDIS_MINOR_VERSION) {
 		printf("%s: version not %u.%u (current version: %u.%u)\n",
 		    DEVNAME(un), RNDIS_MAJOR_VERSION, RNDIS_MINOR_VERSION,
 		    le32toh(msg->rm_ver_major), le32toh(msg->rm_ver_minor));
 		return RNDIS_STATUS_FAILURE;
+	}
 	sc->sc_maxppt = le32toh(msg->rm_pktmaxcnt);
 	sc->sc_maxtsz = le32toh(msg->rm_pktmaxsz);
 	sc->sc_palign = 1U << le32toh(msg->rm_align);
 	return le32toh(msg->rm_status);
+}
 static uint32_t
 urndis_ctrl_handle_query(struct usbnet *un,
     const struct rndis_comp_hdr *hdr, void **buf, size_t *bufsz)
+{
 	const struct rndis_query_comp	*msg;
 	msg = (const struct rndis_query_comp *) hdr;
 	DPRINTF(("%s: urndis_ctrl_handle_query: len %u rid %u status %#x "
 	    "buflen %u bufoff %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_rid),
 	    le32toh(msg->rm_status),
 	    le32toh(msg->rm_infobuflen),
 	    le32toh(msg->rm_infobufoffset)));
 	if (buf && bufsz) {
 		*buf = NULL;
 		*bufsz = 0;
+	}
 	if (le32toh(msg->rm_status) != RNDIS_STATUS_SUCCESS) {
 		printf("%s: query failed %#x\n",
 		    DEVNAME(un),
 		    le32toh(msg->rm_status));
 		return le32toh(msg->rm_status);
+	}
 	if (le32toh(msg->rm_infobuflen) + le32toh(msg->rm_infobufoffset) +
 	    RNDIS_HEADER_OFFSET > le32toh(msg->rm_len)) {
 		printf("%s: ctrl message error: invalid query info "
 		    "len/offset/end_position(%u/%u/%u) -> "
 		    "go out of buffer limit %u\n",
 		    DEVNAME(un),
 		    le32toh(msg->rm_infobuflen),
 		    le32toh(msg->rm_infobufoffset),
 		    le32toh(msg->rm_infobuflen) +
 		    le32toh(msg->rm_infobufoffset) + (uint32_t)RNDIS_HEADER_OFFSET,
 		    le32toh(msg->rm_len));
 		return RNDIS_STATUS_FAILURE;
+	}
 	if (buf && bufsz) {
 		const char *p;
 		*buf = kmem_alloc(le32toh(msg->rm_infobuflen), KM_SLEEP);
 		*bufsz = le32toh(msg->rm_infobuflen);
 		p = (const char *)&msg->rm_rid;
 		p += le32toh(msg->rm_infobufoffset);
 		memcpy(*buf, p, le32toh(msg->rm_infobuflen));
+	}
 	return le32toh(msg->rm_status);
+}
 static uint32_t
 urndis_ctrl_handle_reset(struct usbnet *un, const struct rndis_comp_hdr *hdr)
+{
 	struct urndis_softc		*sc = usbnet_softc(un);
 	const struct rndis_reset_comp	*msg;
 	uint32_t			 rval;
 	msg = (const struct rndis_reset_comp *) hdr;
 	rval = le32toh(msg->rm_status);
 	DPRINTF(("%s: urndis_ctrl_handle_reset: len %u status %#x "
 	    "adrreset %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_len),
 	    rval,
 	    le32toh(msg->rm_adrreset)));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: reset failed %#x\n", DEVNAME(un), rval);
 		return rval;
+	}
 	if (le32toh(msg->rm_adrreset) != 0) {
 		uint32_t filter;
 		filter = htole32(sc->sc_filter);
 		rval = urndis_ctrl_set(un, OID_GEN_CURRENT_PACKET_FILTER,
 		    &filter, sizeof(filter));
 		if (rval != RNDIS_STATUS_SUCCESS) {
 			printf("%s: unable to reset data filters\n",
 			    DEVNAME(un));
 			return rval;
+		}
+	}
 	return rval;
+}
 static uint32_t
 urndis_ctrl_handle_status(struct usbnet *un,
     const struct rndis_comp_hdr *hdr)
+{
 	const struct rndis_status_msg	*msg;
 	uint32_t			rval;
 	msg = (const struct rndis_status_msg *)hdr;
 	rval = le32toh(msg->rm_status);
 	DPRINTF(("%s: urndis_ctrl_handle_status: len %u status %#x "
 	    "stbuflen %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_len),
 	    rval,
 	    le32toh(msg->rm_stbuflen)));
 	switch (rval) {
 		case RNDIS_STATUS_MEDIA_CONNECT:
 		case RNDIS_STATUS_MEDIA_DISCONNECT:
 		case RNDIS_STATUS_OFFLOAD_CURRENT_CONFIG:
 			rval = RNDIS_STATUS_SUCCESS;
 			break;
 		default:
 		        printf("%s: status %#x\n", DEVNAME(un), rval);
+	}
 	return rval;
+}
 static uint32_t
 urndis_ctrl_init(struct usbnet *un)
+{
 	struct rndis_init_req	*msg;
 	uint32_t		 rval;
 	struct rndis_comp_hdr	*hdr;
 	msg = kmem_alloc(sizeof(*msg), KM_SLEEP);
 	msg->rm_type = htole32(REMOTE_NDIS_INITIALIZE_MSG);
 	msg->rm_len = htole32(sizeof(*msg));
 	msg->rm_rid = htole32(0);
 	msg->rm_ver_major = htole32(RNDIS_MAJOR_VERSION);
 	msg->rm_ver_minor = htole32(RNDIS_MINOR_VERSION);
 	msg->rm_max_xfersz = htole32(RNDIS_BUFSZ);
 	DPRINTF(("%s: urndis_ctrl_init send: type %u len %u rid %u ver_major %u "
 	    "ver_minor %u max_xfersz %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_type),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_rid),
 	    le32toh(msg->rm_ver_major),
 	    le32toh(msg->rm_ver_minor),
 	    le32toh(msg->rm_max_xfersz)));
 	rval = urndis_ctrl_send(un, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: init failed\n", DEVNAME(un));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(un)) == NULL) {
 		printf("%s: unable to get init response\n", DEVNAME(un));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(un, hdr, NULL, NULL);
 	return rval;
+}
 #if 0
 static uint32_t
 urndis_ctrl_halt(struct usbnet *un)
+{
 	struct rndis_halt_req	*msg;
 	uint32_t		 rval;
 	msg = kmem_alloc(sizeof(*msg), KM_SLEEP);
 	msg->rm_type = htole32(REMOTE_NDIS_HALT_MSG);
 	msg->rm_len = htole32(sizeof(*msg));
 	msg->rm_rid = 0;
 	DPRINTF(("%s: urndis_ctrl_halt send: type %u len %u rid %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_type),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_rid)));
 	rval = urndis_ctrl_send(un, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg));
 	if (rval != RNDIS_STATUS_SUCCESS)
 		printf("%s: halt failed\n", DEVNAME(un));
 	return rval;
+}
 #endif
 static uint32_t
 urndis_ctrl_query(struct usbnet *un, uint32_t oid,
     void *qbuf, size_t qlen,
     void **rbuf, size_t *rbufsz)
+{
 	struct rndis_query_req	*msg;
 	uint32_t		 rval;
 	struct rndis_comp_hdr	*hdr;
 	msg = kmem_alloc(sizeof(*msg) + qlen, KM_SLEEP);
 	msg->rm_type = htole32(REMOTE_NDIS_QUERY_MSG);
 	msg->rm_len = htole32(sizeof(*msg) + qlen);
 	msg->rm_rid = 0; /* XXX */
 	msg->rm_oid = htole32(oid);
 	msg->rm_infobuflen = htole32(qlen);
 	if (qlen != 0) {
 		msg->rm_infobufoffset = htole32(20);
 		memcpy((char*)msg + 20, qbuf, qlen);
 	} else
 		msg->rm_infobufoffset = 0;
 	msg->rm_devicevchdl = 0;
 	DPRINTF(("%s: urndis_ctrl_query send: type %u len %u rid %u oid %#x "
 	    "infobuflen %u infobufoffset %u devicevchdl %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_type),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_rid),
 	    le32toh(msg->rm_oid),
 	    le32toh(msg->rm_infobuflen),
 	    le32toh(msg->rm_infobufoffset),
 	    le32toh(msg->rm_devicevchdl)));
 	rval = urndis_ctrl_send(un, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg) + qlen);
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: query failed\n", DEVNAME(un));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(un)) == NULL) {
 		printf("%s: unable to get query response\n", DEVNAME(un));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(un, hdr, rbuf, rbufsz);
 	return rval;
+}
 static uint32_t
 urndis_ctrl_set(struct usbnet *un, uint32_t oid, void *buf, size_t len)
+{
 	struct rndis_set_req	*msg;
 	uint32_t		 rval;
 	struct rndis_comp_hdr	*hdr;
 	msg = kmem_alloc(sizeof(*msg) + len, KM_SLEEP);
 	msg->rm_type = htole32(REMOTE_NDIS_SET_MSG);
 	msg->rm_len = htole32(sizeof(*msg) + len);
 	msg->rm_rid = 0; /* XXX */
 	msg->rm_oid = htole32(oid);
 	msg->rm_infobuflen = htole32(len);
 	if (len != 0) {
 		msg->rm_infobufoffset = htole32(20);
 		memcpy((char*)msg + 20, buf, len);
 	} else
 		msg->rm_infobufoffset = 0;
 	msg->rm_devicevchdl = 0;
 	DPRINTF(("%s: urndis_ctrl_set send: type %u len %u rid %u oid %#x "
 	    "infobuflen %u infobufoffset %u devicevchdl %u\n",
 	    DEVNAME(un),
 	    le32toh(msg->rm_type),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_rid),
 	    le32toh(msg->rm_oid),
 	    le32toh(msg->rm_infobuflen),
 	    le32toh(msg->rm_infobufoffset),
 	    le32toh(msg->rm_devicevchdl)));
 	rval = urndis_ctrl_send(un, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg) + len);
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: set failed\n", DEVNAME(un));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(un)) == NULL) {
 		printf("%s: unable to get set response\n", DEVNAME(un));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(un, hdr, NULL, NULL);
 	if (rval != RNDIS_STATUS_SUCCESS)
 		printf("%s: set failed %#x\n", DEVNAME(un), rval);
 	return rval;
+}
 #if 0
 static uint32_t
 urndis_ctrl_set_param(struct urndis_softc *un,
     const char *name,
     uint32_t type,
     void *buf,
     size_t len)
+{
 	struct rndis_set_parameter	*param;
 	uint32_t			 rval;
 	size_t				 namelen, tlen;
 	if (name)
 		namelen = strlen(name);
 	else
 		namelen = 0;
 	tlen = sizeof(*param) + len + namelen;
 	param = kmem_alloc(tlen, KM_SLEEP);
 	param->rm_namelen = htole32(namelen);
 	param->rm_valuelen = htole32(len);
 	param->rm_type = htole32(type);
 	if (namelen != 0) {
 		param->rm_nameoffset = htole32(20);
 		memcpy(param + 20, name, namelen);
 	} else
 		param->rm_nameoffset = 0;
 	if (len != 0) {
 		param->rm_valueoffset = htole32(20 + namelen);
 		memcpy(param + 20 + namelen, buf, len);
 	} else
 		param->rm_valueoffset = 0;
 	DPRINTF(("%s: urndis_ctrl_set_param send: nameoffset %u namelen %u "
 	    "type %#x valueoffset %u valuelen %u\n",
 	    DEVNAME(un),
 	    le32toh(param->rm_nameoffset),
 	    le32toh(param->rm_namelen),
 	    le32toh(param->rm_type),
 	    le32toh(param->rm_valueoffset),
 	    le32toh(param->rm_valuelen)));
 	rval = urndis_ctrl_set(un, OID_GEN_RNDIS_CONFIG_PARAMETER, param, tlen);
 	kmem_free(param, tlen);
 	if (rval != RNDIS_STATUS_SUCCESS)
 		printf("%s: set param failed %#x\n", DEVNAME(un), rval);
 	return rval;
+}
 /* XXX : adrreset, get it from response */
 static uint32_t
 urndis_ctrl_reset(struct usbnet *un)
+{
 	struct rndis_reset_req		*reset;
 	uint32_t			 rval;
 	struct rndis_comp_hdr		*hdr;
 	reset = kmem_alloc(sizeof(*reset), KM_SLEEP);
 	reset->rm_type = htole32(REMOTE_NDIS_RESET_MSG);
 	reset->rm_len = htole32(sizeof(*reset));
 	reset->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */
 	DPRINTF(("%s: urndis_ctrl_reset send: type %u len %u rid %u\n",
 	    DEVNAME(un),
 	    le32toh(reset->rm_type),
 	    le32toh(reset->rm_len),
 	    le32toh(reset->rm_rid)));
 	rval = urndis_ctrl_send(un, reset, sizeof(*reset));
 	kmem_free(reset, sizeof(*reset));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: reset failed\n", DEVNAME(un));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(un)) == NULL) {
 		printf("%s: unable to get reset response\n", DEVNAME(un));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(un, hdr, NULL, NULL);
 	return rval;
+}
 static uint32_t
 urndis_ctrl_keepalive(struct usbnet *un)
+{
 	struct rndis_keepalive_req	*keep;
 	uint32_t			 rval;
 	struct rndis_comp_hdr		*hdr;
 	keep = kmem_alloc(sizeof(*keep), KM_SLEEP);
 	keep->rm_type = htole32(REMOTE_NDIS_KEEPALIVE_MSG);
 	keep->rm_len = htole32(sizeof(*keep));
 	keep->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */
 	DPRINTF(("%s: urndis_ctrl_keepalive: type %u len %u rid %u\n",
 	    DEVNAME(un),
 	    le32toh(keep->rm_type),
 	    le32toh(keep->rm_len),
 	    le32toh(keep->rm_rid)));
 	rval = urndis_ctrl_send(un, keep, sizeof(*keep));
 	kmem_free(keep, sizeof(*keep));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: keepalive failed\n", DEVNAME(un));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(un)) == NULL) {
 		printf("%s: unable to get keepalive response\n", DEVNAME(un));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(un, hdr, NULL, NULL);
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: keepalive failed %#x\n", DEVNAME(un), rval);
 		urndis_ctrl_reset(un);
+	}
 	return rval;
+}
 #endif
 static unsigned
 urndis_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	struct rndis_packet_msg		*msg;
 	if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz - sizeof(*msg))
 		return 0;
 	msg = (struct rndis_packet_msg *)c->unc_buf;
 	memset(msg, 0, sizeof(*msg));
 	msg->rm_type = htole32(REMOTE_NDIS_PACKET_MSG);
 	msg->rm_len = htole32(sizeof(*msg) + m->m_pkthdr.len);
 	msg->rm_dataoffset = htole32(RNDIS_DATA_OFFSET);
 	msg->rm_datalen = htole32(m->m_pkthdr.len);
 	m_copydata(m, 0, m->m_pkthdr.len,
 	    ((char*)msg + RNDIS_DATA_OFFSET + RNDIS_HEADER_OFFSET));
 	DPRINTF(("%s: %s type %#x len %u data(off %u len %u)\n",
 	    __func__,
 	    DEVNAME(un),
 	    le32toh(msg->rm_type),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_dataoffset),
 	    le32toh(msg->rm_datalen)));
 	return le32toh(msg->rm_len);
+}
 static void
 urndis_uno_rx_loop(struct usbnet * un, struct usbnet_chain *c,
 		   uint32_t total_len)
+{
 	struct rndis_packet_msg	*msg;
 	struct ifnet		*ifp = usbnet_ifp(un);
 	int			 offset;
 	offset = 0;
 	while (total_len > 1) {
 		msg = (struct rndis_packet_msg *)((char*)c->unc_buf + offset);
 		DPRINTF(("%s: %s buffer size left %u\n", DEVNAME(un), __func__,
 		    total_len));
 		if (total_len < sizeof(*msg)) {
 			printf("%s: urndis_decap invalid buffer total_len %u < "
 			    "minimum header %zu\n",
 			    DEVNAME(un),
 			    total_len,
 			    sizeof(*msg));
 			return;
+		}
 		DPRINTF(("%s: urndis_decap total_len %u data(off:%u len:%u) "
 		    "oobdata(off:%u len:%u nb:%u) perpacket(off:%u len:%u)\n",
 		    DEVNAME(un),
 		    le32toh(msg->rm_len),
 		    le32toh(msg->rm_dataoffset),
 		    le32toh(msg->rm_datalen),
 		    le32toh(msg->rm_oobdataoffset),
 		    le32toh(msg->rm_oobdatalen),
 		    le32toh(msg->rm_oobdataelements),
 		    le32toh(msg->rm_pktinfooffset),
 		    le32toh(msg->rm_pktinfooffset)));
 		if (le32toh(msg->rm_type) != REMOTE_NDIS_PACKET_MSG) {
 			printf("%s: urndis_decap invalid type %#x != %#x\n",
 			    DEVNAME(un),
 			    le32toh(msg->rm_type),
 			    REMOTE_NDIS_PACKET_MSG);
 			return;
+		}
 		if (le32toh(msg->rm_len) < sizeof(*msg)) {
 			printf("%s: urndis_decap invalid msg len %u < %zu\n",
 			    DEVNAME(un),
 			    le32toh(msg->rm_len),
 			    sizeof(*msg));
 			return;
+		}
 		if (le32toh(msg->rm_len) > total_len) {
 			printf("%s: urndis_decap invalid msg len %u > buffer "
 			    "total_len %u\n",
 			    DEVNAME(un),
 			    le32toh(msg->rm_len),
 			    total_len);
 			return;
+		}
 		if (le32toh(msg->rm_dataoffset) +
 		    le32toh(msg->rm_datalen) + RNDIS_HEADER_OFFSET
 		        > le32toh(msg->rm_len)) {
 			printf("%s: urndis_decap invalid data "
 			    "len/offset/end_position(%u/%u/%u) -> "
 			    "go out of receive buffer limit %u\n",
 			    DEVNAME(un),
 			    le32toh(msg->rm_datalen),
 			    le32toh(msg->rm_dataoffset),
 			    le32toh(msg->rm_dataoffset) +
 			    le32toh(msg->rm_datalen) + (uint32_t)RNDIS_HEADER_OFFSET,
 			    le32toh(msg->rm_len));
 			return;
+		}
 		if (le32toh(msg->rm_datalen) < sizeof(struct ether_header)) {
 			if_statinc(ifp, if_ierrors);
 			printf("%s: urndis_decap invalid ethernet size "
 			    "%d < %zu\n",
 			    DEVNAME(un),
 			    le32toh(msg->rm_datalen),
 			    sizeof(struct ether_header));
 			return;
+		}
 		usbnet_enqueue(un,
 		    ((char*)&msg->rm_dataoffset + le32toh(msg->rm_dataoffset)),
 		    le32toh(msg->rm_datalen), 0, 0, 0);
 		offset += le32toh(msg->rm_len);
 		total_len -= le32toh(msg->rm_len);
+	}
+}
 #if 0
 static void
 urndis_watchdog(struct ifnet *ifp)
+{
 	struct urndis_softc	*sc = usbnet_softc(un);
 	if (un->un_dying)
 		return;
 	if_statinc(ifp, if_oerrors);
 	printf("%s: watchdog timeout\n", DEVNAME(un));
 	urndis_ctrl_keepalive(un);
+}
 #endif
 static int
 urndis_init_un(struct ifnet *ifp, struct usbnet *un)
+{
 	int 			 err;
 	if (ifp->if_flags & IFF_RUNNING)
 		return 0;
 	err = urndis_ctrl_init(un);
 	if (err != RNDIS_STATUS_SUCCESS)
 		return EIO;
 	return err;
+}
 static int
 urndis_uno_init(struct ifnet *ifp)
+{
 	struct usbnet *un = ifp->if_softc;
 	int error;
 	KASSERT(IFNET_LOCKED(ifp));
 	error = urndis_init_un(ifp, un);
 	if (error)
 		return EIO;	/* XXX */
 	error = usbnet_init_rx_tx(un);
 	usbnet_set_link(un, error == 0);
 	return error;
+}
 static int
 urndis_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usbif_attach_arg		*uiaa = aux;
 	usb_interface_descriptor_t	*id;
 	if (!uiaa->uiaa_iface)
 		return UMATCH_NONE;
 	id = usbd_get_interface_descriptor(uiaa->uiaa_iface);
 	if (id == NULL)
 		return UMATCH_NONE;
 	if (id->bInterfaceClass == UICLASS_WIRELESS &&
 	    id->bInterfaceSubClass == UISUBCLASS_RF &&
 	    id->bInterfaceProtocol == UIPROTO_RNDIS)
 		return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
 	return usb_lookup(urndis_devs, uiaa->uiaa_vendor, uiaa->uiaa_product) != NULL ?
 	    UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 static void
 urndis_attach(device_t parent, device_t self, void *aux)
+{
 	struct urndis_softc		*sc = device_private(self);
 	struct usbnet * const		 un = &sc->sc_un;
 	struct usbif_attach_arg		*uiaa = aux;
 	struct usbd_device	        *dev = uiaa->uiaa_device;
 	usb_interface_descriptor_t	*id;
 	usb_endpoint_descriptor_t	*ed;
 	usb_config_descriptor_t		*cd;
 	struct usbd_interface		*iface_ctl;
 	const usb_cdc_union_descriptor_t *ud;
 	const usb_cdc_header_descriptor_t *desc;
 	usbd_desc_iter_t		 iter;
 	int				 if_ctl, if_data;
 	int				 i, j, altcnt;
 	void				*buf;
 	size_t				 bufsz;
 	uint32_t			 filter;
 	char				*devinfop;
 	KASSERT((void *)sc == un);
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(dev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	un->un_dev = self;
 	un->un_udev = dev;
 	un->un_sc = sc;
 	un->un_ops = &urndis_ops;
 	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
 	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
 	un->un_rx_list_cnt = RNDIS_RX_LIST_CNT;
 	un->un_tx_list_cnt = RNDIS_TX_LIST_CNT;
 	un->un_rx_bufsz = RNDIS_BUFSZ;
 	un->un_tx_bufsz = RNDIS_BUFSZ;
 	iface_ctl = uiaa->uiaa_iface;
 	un->un_iface = uiaa->uiaa_iface;
 	id = usbd_get_interface_descriptor(iface_ctl);
 	if_ctl = id->bInterfaceNumber;
 	sc->sc_ifaceno_ctl = if_ctl;
 	if_data = -1;
 	usb_desc_iter_init(un->un_udev, &iter);
 	while ((desc = (const void *)usb_desc_iter_next(&iter)) != NULL) {
 		if (desc->bDescriptorType != UDESC_CS_INTERFACE) {
 			continue;
+		}
 		switch (desc->bDescriptorSubtype) {
 		case UDESCSUB_CDC_UNION:
 			/* XXX bail out when found first? */
 			ud = (const usb_cdc_union_descriptor_t *)desc;
 			if (if_data == -1)
 				if_data = ud->bSlaveInterface[0];
 			break;
+		}
+	}
 	if (if_data == -1) {
 		DPRINTF(("urndis_attach: no union interface\n"));
 		un->un_iface = iface_ctl;
 	} else {
 		DPRINTF(("urndis_attach: union interface: ctl %u, data %u\n",
 		    if_ctl, if_data));
 		for (i = 0; i < uiaa->uiaa_nifaces; i++) {
 			if (uiaa->uiaa_ifaces[i] != NULL) {
 				id = usbd_get_interface_descriptor(
 				    uiaa->uiaa_ifaces[i]);
 				if (id != NULL && id->bInterfaceNumber ==
 				    if_data) {
 					un->un_iface = uiaa->uiaa_ifaces[i];
 					uiaa->uiaa_ifaces[i] = NULL;
+				}
+			}
+		}
+	}
 	if (un->un_iface == NULL) {
 		aprint_error("%s: no data interface\n", DEVNAME(un));
 		return;
+	}
 	id = usbd_get_interface_descriptor(un->un_iface);
 	cd = usbd_get_config_descriptor(un->un_udev);
 	altcnt = usbd_get_no_alts(cd, id->bInterfaceNumber);
 	for (j = 0; j < altcnt; j++) {
 		if (usbd_set_interface(un->un_iface, j)) {
 			aprint_error("%s: interface alternate setting %u "
 			    "failed\n", DEVNAME(un), j);
 			return;
+		}
 		/* Find endpoints. */
 		id = usbd_get_interface_descriptor(un->un_iface);
 		un->un_ed[USBNET_ENDPT_RX] = un->un_ed[USBNET_ENDPT_TX] = 0;
 		for (i = 0; i < id->bNumEndpoints; i++) {
 			ed = usbd_interface2endpoint_descriptor(
 			    un->un_iface, i);
 			if (!ed) {
 				aprint_error("%s: no descriptor for bulk "
 				    "endpoint %u\n", DEVNAME(un), i);
 				return;
+			}
 			if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 			    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 				un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
+			}
 			else if (
 			    UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 			    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 				un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
+			}
+		}
 		if (un->un_ed[USBNET_ENDPT_RX] != 0 && un->un_ed[USBNET_ENDPT_TX] != 0) {
 			DPRINTF(("%s: in=%#x, out=%#x\n",
 			    DEVNAME(un),
 			    un->un_ed[USBNET_ENDPT_RX],
 			    un->un_ed[USBNET_ENDPT_TX]));
 			break;
+		}
+	}
 	if (un->un_ed[USBNET_ENDPT_RX] == 0)
 		aprint_error("%s: could not find data bulk in\n", DEVNAME(un));
 	if (un->un_ed[USBNET_ENDPT_TX] == 0)
 		aprint_error("%s: could not find data bulk out\n",DEVNAME(un));
 	if (un->un_ed[USBNET_ENDPT_RX] == 0 || un->un_ed[USBNET_ENDPT_TX] == 0)
 		return;
 #if 0
 	ifp->if_watchdog = urndis_watchdog;
 #endif
 	usbnet_attach(un, "urndisdet");
 	struct ifnet *ifp = usbnet_ifp(un);
 	urndis_init_un(ifp, un);
 	if (urndis_ctrl_query(un, OID_802_3_PERMANENT_ADDRESS, NULL, 0,
 	    &buf, &bufsz) != RNDIS_STATUS_SUCCESS) {
 		aprint_error("%s: unable to get hardware address\n",
 		    DEVNAME(un));
 		return;
+	}
 	if (bufsz == ETHER_ADDR_LEN) {
 		memcpy(un->un_eaddr, buf, ETHER_ADDR_LEN);
 		kmem_free(buf, bufsz);
 	} else {
 		aprint_error("%s: invalid address\n", DEVNAME(un));
 		if (buf && bufsz)
 			kmem_free(buf, bufsz);
 		return;
+	}
 	/* Initialize packet filter */
 	sc->sc_filter = RNDIS_PACKET_TYPE_BROADCAST;
 	sc->sc_filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
 	filter = htole32(sc->sc_filter);
 	if (urndis_ctrl_set(un, OID_GEN_CURRENT_PACKET_FILTER, &filter,
 	    sizeof(filter)) != RNDIS_STATUS_SUCCESS) {
 		aprint_error("%s: unable to set data filters\n", DEVNAME(un));
 		return;
+	}
 	usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
 , NULL);
+}
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 USBNET_MODULE(urndis)