 @@ -1,782 +1,776 @@
-/*	$NetBSD: if_url.c,v 1.77 2020/04/02 04:09:36 nisimura Exp $	*/
+/*	$NetBSD: if_url.c,v 1.78 2022/03/03 05:48:14 riastradh Exp $	*/
 /*
  * Copyright (c) 2001, 2002
  *     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.
+ *
  */
 /*
  * The RTL8150L(Realtek USB to fast ethernet controller) spec can be found at
  *   ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/8150v14.pdf
  *   ftp://152.104.125.40/lancard/data_sheet/8150/8150v14.pdf
  */
 /*
  * TODO:
  *	Interrupt Endpoint support
  *	External PHYs
  *	powerhook() support?
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_url.c,v 1.77 2020/04/02 04:09:36 nisimura Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_url.c,v 1.78 2022/03/03 05:48:14 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <net/if_ether.h>
 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/if_inarp.h>
 #endif
 #include <dev/mii/urlphyreg.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/if_urlreg.h>
 /* Function declarations */
 static int	url_match(device_t, cfdata_t, void *);
 static void	url_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(url, sizeof(struct usbnet), url_match, url_attach,
     usbnet_detach, usbnet_activate);
 static unsigned	url_uno_tx_prepare(struct usbnet *, struct mbuf *,
 				   struct usbnet_chain *);
 static void url_uno_rx_loop(struct usbnet *, struct usbnet_chain *, uint32_t);
 static int url_uno_mii_read_reg(struct usbnet *, int, int, uint16_t *);
 static int url_uno_mii_write_reg(struct usbnet *, int, int, uint16_t);
 static int url_uno_ioctl(struct ifnet *, u_long, void *);
 static void url_uno_stop(struct ifnet *, int);
 static void url_uno_mii_statchg(struct ifnet *);
 static int url_uno_init(struct ifnet *);
 static void url_rcvfilt_locked(struct usbnet *);
 static void url_reset(struct usbnet *);
 static int url_csr_read_1(struct usbnet *, int);
 static int url_csr_read_2(struct usbnet *, int);
 static int url_csr_write_1(struct usbnet *, int, int);
 static int url_csr_write_2(struct usbnet *, int, int);
 static int url_csr_write_4(struct usbnet *, int, int);
 static int url_mem(struct usbnet *, int, int, void *, int);
 static const struct usbnet_ops url_ops = {
 	.uno_stop = url_uno_stop,
 	.uno_ioctl = url_uno_ioctl,
 	.uno_read_reg = url_uno_mii_read_reg,
 	.uno_write_reg = url_uno_mii_write_reg,
 	.uno_statchg = url_uno_mii_statchg,
 	.uno_tx_prepare = url_uno_tx_prepare,
 	.uno_rx_loop = url_uno_rx_loop,
 	.uno_init = url_uno_init,
 };
 /* Macros */
 #ifdef URL_DEBUG
 #define DPRINTF(x)	if (urldebug) printf x
 #define DPRINTFN(n, x)	if (urldebug >= (n)) printf x
 int urldebug = 0;
 #else
 #define DPRINTF(x)
 #define DPRINTFN(n, x)
 #endif
 #define	URL_SETBIT(un, reg, x)	\
 	url_csr_write_1(un, reg, url_csr_read_1(un, reg) | (x))
 #define	URL_SETBIT2(un, reg, x)	\
 	url_csr_write_2(un, reg, url_csr_read_2(un, reg) | (x))
 #define	URL_CLRBIT(un, reg, x)	\
 	url_csr_write_1(un, reg, url_csr_read_1(un, reg) & ~(x))
 #define	URL_CLRBIT2(un, reg, x)	\
 	url_csr_write_2(un, reg, url_csr_read_2(un, reg) & ~(x))
 static const struct url_type {
 	struct usb_devno url_dev;
 	uint16_t url_flags;
 #define URL_EXT_PHY	0x0001
 } url_devs [] = {
 	/* MELCO LUA-KTX */
 	{{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAKTX }, 0},
 	/* Realtek RTL8150L Generic (GREEN HOUSE USBKR100) */
 	{{ USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8150L}, 0},
 	/* Longshine LCS-8138TX */
 	{{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_LCS8138TX}, 0},
 	/* Micronet SP128AR */
 	{{ USB_VENDOR_MICRONET, USB_PRODUCT_MICRONET_SP128AR}, 0},
 	/* OQO model 01 */
 	{{ USB_VENDOR_OQO, USB_PRODUCT_OQO_ETHER01}, 0},
 };
 #define url_lookup(v, p) ((const struct url_type *)usb_lookup(url_devs, v, p))
 /* Probe */
 static int
 url_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	return url_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
 		UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 /* Attach */
 static void
 url_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;
 	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 = &url_ops;
 	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
 	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
 	un->un_rx_list_cnt = URL_RX_LIST_CNT;
 	un->un_tx_list_cnt = URL_TX_LIST_CNT;
 	un->un_rx_bufsz = URL_BUFSZ;
 	un->un_tx_bufsz = URL_BUFSZ;
 	/* Move the device into the configured state. */
 	err = usbd_set_config_no(dev, URL_CONFIG_NO, 1);
 	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, URL_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 = url_lookup(uaa->uaa_vendor, uaa->uaa_product)->url_flags;
 #if 0
 	if (un->un_flags & URL_EXT_PHY) {
 		un->un_read_reg_cb = url_ext_mii_read_reg;
 		un->un_write_reg_cb = url_ext_mii_write_reg;
+	}
 #endif
 	/* 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] = 0;
 	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;
+	}
 	/* Set these up now for url_mem().  */
 	usbnet_attach(un, "urldet");
 	usbnet_lock_core(un);
 	usbnet_busy(un);
 	/* reset the adapter */
 	url_reset(un);
 	/* Get Ethernet Address */
 	err = url_mem(un, URL_CMD_READMEM, URL_IDR0, (void *)un->un_eaddr,
 		      ETHER_ADDR_LEN);
 	usbnet_unbusy(un);
 	usbnet_unlock_core(un);
 	if (err) {
 		aprint_error_dev(self, "read MAC address failed\n");
-		goto bad;
+		return;
+	}
 	/* initialize interface information */
 	usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
 , &unm);
 	return;
  bad:
 	usbnet_set_dying(un, true);
 	return;
+}
 /* read/write memory */
 static int
 url_mem(struct usbnet *un, int cmd, int offset, void *buf, int len)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	usbnet_isowned_core(un);
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if (usbnet_isdying(un))
 		return 0;
 	if (cmd == URL_CMD_READMEM)
 		req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	else
 		req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = URL_REQ_MEM;
 	USETW(req.wValue, offset);
 	USETW(req.wIndex, 0x0000);
 	USETW(req.wLength, len);
 	err = usbd_do_request(un->un_udev, &req, buf);
 	if (err) {
 		DPRINTF(("%s: url_mem(): %s failed. off=%04x, err=%d\n",
 			 device_xname(un->un_dev),
 			 cmd == URL_CMD_READMEM ? "read" : "write",
 			 offset, err));
+	}
 	return err;
+}
 /* read 1byte from register */
 static int
 url_csr_read_1(struct usbnet *un, int reg)
+{
 	uint8_t val = 0;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	return url_mem(un, URL_CMD_READMEM, reg, &val, 1) ? 0 : val;
+}
 /* read 2bytes from register */
 static int
 url_csr_read_2(struct usbnet *un, int reg)
+{
 	uWord val;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	USETW(val, 0);
 	return url_mem(un, URL_CMD_READMEM, reg, &val, 2) ? 0 : UGETW(val);
+}
 /* write 1byte to register */
 static int
 url_csr_write_1(struct usbnet *un, int reg, int aval)
+{
 	uint8_t val = aval;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	return url_mem(un, URL_CMD_WRITEMEM, reg, &val, 1) ? -1 : 0;
+}
 /* write 2bytes to register */
 static int
 url_csr_write_2(struct usbnet *un, int reg, int aval)
+{
 	uWord val;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	USETW(val, aval);
 	return url_mem(un, URL_CMD_WRITEMEM, reg, &val, 2) ? -1 : 0;
+}
 /* write 4bytes to register */
 static int
 url_csr_write_4(struct usbnet *un, int reg, int aval)
+{
 	uDWord val;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	USETDW(val, aval);
 	return url_mem(un, URL_CMD_WRITEMEM, reg, &val, 4) ? -1 : 0;
+}
 static int
 url_init_locked(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	const u_char *eaddr;
 	int i;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	usbnet_isowned_core(un);
 	if (usbnet_isdying(un))
 		return EIO;
 	/* Cancel pending I/O and free all TX/RX buffers */
 	usbnet_stop(un, ifp, 1);
 	eaddr = CLLADDR(ifp->if_sadl);
 	for (i = 0; i < ETHER_ADDR_LEN; i++)
 		url_csr_write_1(un, URL_IDR0 + i, eaddr[i]);
 	/* Init transmission control register */
 	URL_CLRBIT(un, URL_TCR,
 		   URL_TCR_TXRR1 | URL_TCR_TXRR0 |
 		   URL_TCR_IFG1 | URL_TCR_IFG0 |
 		   URL_TCR_NOCRC);
 	/* Init receive control register */
 	URL_SETBIT2(un, URL_RCR, URL_RCR_TAIL | URL_RCR_AD | URL_RCR_AB);
 	/* Accept multicast frame or run promisc. mode */
 	url_rcvfilt_locked(un);
 	/* Enable RX and TX */
 	URL_SETBIT(un, URL_CR, URL_CR_TE | URL_CR_RE);
 	return usbnet_init_rx_tx(un);
+}
 static int
 url_uno_init(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	usbnet_lock_core(un);
 	usbnet_busy(un);
 	int ret = url_init_locked(ifp);
 	usbnet_unbusy(un);
 	usbnet_unlock_core(un);
 	return ret;
+}
 static void
 url_reset(struct usbnet *un)
+{
 	int i;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	if (usbnet_isdying(un))
 		return;
 	URL_SETBIT(un, URL_CR, URL_CR_SOFT_RST);
 	for (i = 0; i < URL_TX_TIMEOUT; i++) {
 		if (!(url_csr_read_1(un, URL_CR) & URL_CR_SOFT_RST))
 			break;
 		delay(10);	/* XXX */
+	}
 	delay(10000);		/* XXX */
+}
 static void
 url_rcvfilt_locked(struct usbnet *un)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct ethercom *ec = usbnet_ec(un);
 	struct ether_multi *enm;
 	struct ether_multistep step;
 	uint32_t mchash[2] = { 0, 0 };
 	int h = 0, rcr;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev), __func__));
 	usbnet_isowned_core(un);
 	if (usbnet_isdying(un))
 		return;
 	rcr = url_csr_read_2(un, URL_RCR);
 	rcr &= ~(URL_RCR_AAP | URL_RCR_AAM | URL_RCR_AM);
 	ETHER_LOCK(ec);
 	if (ifp->if_flags & IFF_PROMISC) {
 		ec->ec_flags |= ETHER_F_ALLMULTI;
 		ETHER_UNLOCK(ec);
 		/* run promisc. mode */
 		rcr |= URL_RCR_AAM; /* ??? */
 		rcr |= URL_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 multicast frames */
 			rcr |= URL_RCR_AAM;
 			goto update;
+		}
 		h = ether_crc32_be(enm->enm_addrlo, ETHER_ADDR_LEN);
 		/* 1(31) and 5(30:26) bit sampling */
 		mchash[h >> 31] |= 1 << ((h >> 26) & 0x1f);
 		ETHER_NEXT_MULTI(step, enm);
+	}
 	ETHER_UNLOCK(ec);
 	if (h != 0)
 		rcr |= URL_RCR_AM;	/* activate mcast hash filter */
 	url_csr_write_4(un, URL_MAR0, mchash[0]);
 	url_csr_write_4(un, URL_MAR4, mchash[1]);
  update:
 	url_csr_write_2(un, URL_RCR, rcr);
+}
 static unsigned
 url_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	int total_len;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev),__func__));
 	KASSERT(un->un_tx_bufsz >= URL_MIN_FRAME_LEN);
 	if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz)
 		return 0;
 	/* Copy the mbuf data into a contiguous buffer */
 	m_copydata(m, 0, m->m_pkthdr.len, c->unc_buf);
 	total_len = m->m_pkthdr.len;
 	if (total_len < URL_MIN_FRAME_LEN) {
 		memset(c->unc_buf + total_len, 0,
 		    URL_MIN_FRAME_LEN - total_len);
 		total_len = URL_MIN_FRAME_LEN;
+	}
 	DPRINTF(("%s: %s: send %d bytes\n", device_xname(un->un_dev),
 		 __func__, total_len));
 	return total_len;
+}
 static void
 url_uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len)
+{
 	struct ifnet *ifp = usbnet_ifp(un);
 	url_rxhdr_t rxhdr;
 	DPRINTF(("%s: %s: enter\n", device_xname(un->un_dev),__func__));
 	if (total_len <= ETHER_CRC_LEN || total_len <= sizeof(rxhdr)) {
 		if_statinc(ifp, if_ierrors);
 		return;
+	}
 	memcpy(&rxhdr, c->unc_buf + total_len - ETHER_CRC_LEN, sizeof(rxhdr));
 	DPRINTF(("%s: RX Status: %dbytes%s%s%s%s packets\n",
 		 device_xname(un->un_dev),
 		 UGETW(rxhdr) & URL_RXHDR_BYTEC_MASK,
 		 UGETW(rxhdr) & URL_RXHDR_VALID_MASK ? ", Valid" : "",
 		 UGETW(rxhdr) & URL_RXHDR_RUNTPKT_MASK ? ", Runt" : "",
 		 UGETW(rxhdr) & URL_RXHDR_PHYPKT_MASK ? ", Physical match" : "",
 		 UGETW(rxhdr) & URL_RXHDR_MCASTPKT_MASK ? ", Multicast" : ""));
 	if ((UGETW(rxhdr) & URL_RXHDR_VALID_MASK) == 0) {
 		if_statinc(ifp, if_ierrors);
 		return;
+	}
 	total_len -= ETHER_CRC_LEN;
 	DPRINTF(("%s: %s: deliver %d\n", device_xname(un->un_dev),
 		 __func__, total_len));
 	usbnet_enqueue(un, c->unc_buf, total_len, 0, 0, 0);
+}
 #if 0
 static void url_intr(void)
+{
+}
 #endif
 static int
 url_uno_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct usbnet * const un = ifp->if_softc;
 	usbnet_lock_core(un);
 	usbnet_busy(un);
 	switch (cmd) {
 	case SIOCADDMULTI:
 	case SIOCDELMULTI:
 		url_rcvfilt_locked(un);
 		break;
 	default:
 		break;
+	}
 	usbnet_unbusy(un);
 	usbnet_unlock_core(un);
 	return 0;
+}
 /* Stop the adapter and free any mbufs allocated to the RX and TX lists. */
 static void
 url_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__));
 	url_reset(un);
+}
 static int
 url_uno_mii_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
+{
 	uint16_t data;
 	usbd_status err = USBD_NORMAL_COMPLETION;
 	DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x\n",
 		 device_xname(un->un_dev), __func__, phy, reg));
 	/* XXX: one PHY only for the RTL8150 internal PHY */
 	if (phy != 0) {
 		DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
 			 device_xname(un->un_dev), __func__, phy));
 		return EINVAL;
+	}
 	switch (reg) {
 	case MII_BMCR:		/* Control Register */
 		reg = URL_BMCR;
 		break;
 	case MII_BMSR:		/* Status Register */
 		reg = URL_BMSR;
 		break;
 	case MII_PHYIDR1:
 	case MII_PHYIDR2:
 		*val = 0;
 		goto R_DONE;
 		break;
 	case MII_ANAR:		/* Autonegotiation advertisement */
 		reg = URL_ANAR;
 		break;
 	case MII_ANLPAR:	/* Autonegotiation link partner abilities */
 		reg = URL_ANLP;
 		break;
 	case URLPHY_MSR:	/* Media Status Register */
 		reg = URL_MSR;
 		break;
 	default:
 		printf("%s: %s: bad register %04x\n",
 		       device_xname(un->un_dev), __func__, reg);
 		return EINVAL;
+	}
 	if (reg == URL_MSR)
 		data = url_csr_read_1(un, reg);
 	else
 		data = url_csr_read_2(un, reg);
 	*val = data;
  R_DONE:
 	DPRINTFN(0xff, ("%s: %s: phy=%d reg=0x%04x => 0x%04hx\n",
 		 device_xname(un->un_dev), __func__, phy, reg, *val));
 	return err;
+}
 static int
 url_uno_mii_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
+{
 	DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x val=0x%04hx\n",
 		 device_xname(un->un_dev), __func__, phy, reg, val));
 	/* XXX: one PHY only for the RTL8150 internal PHY */
 	if (phy != 0) {
 		DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
 			 device_xname(un->un_dev), __func__, phy));
 		return EINVAL;
+	}
 	switch (reg) {
 	case MII_BMCR:		/* Control Register */
 		reg = URL_BMCR;
 		break;
 	case MII_BMSR:		/* Status Register */
 		reg = URL_BMSR;
 		break;
 	case MII_PHYIDR1:
 	case MII_PHYIDR2:
 		return 0;
 	case MII_ANAR:		/* Autonegotiation advertisement */
 		reg = URL_ANAR;
 		break;
 	case MII_ANLPAR:	/* Autonegotiation link partner abilities */
 		reg = URL_ANLP;
 		break;
 	case URLPHY_MSR:	/* Media Status Register */
 		reg = URL_MSR;
 		break;
 	default:
 		printf("%s: %s: bad register %04x\n",
 		       device_xname(un->un_dev), __func__, reg);
 		return EINVAL;
+	}
 	if (reg == URL_MSR)
 		url_csr_write_1(un, reg, val);
 	else
 		url_csr_write_2(un, reg, val);
 	return 0;
+}
 static void
 url_uno_mii_statchg(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	DPRINTF(("%s: %s: enter\n", ifp->if_xname, __func__));
 	/* XXX */
 	usbnet_set_link(un, true);
+}
 #if 0
 /*
  * external PHYs support, but not test.
  */
 static usbd_status
 url_ext_mii_read_reg(struct usbnet *un, int phy, int reg)
+{
 	uint16_t val;
 	DPRINTF(("%s: %s: enter, phy=%d reg=0x%04x\n",
 		 device_xname(un->un_dev), __func__, phy, reg));
 	url_csr_write_1(un, URL_PHYADD, phy & URL_PHYADD_MASK);
 	/*
 	 * RTL8150L will initiate a MII management data transaction
 	 * if PHYCNT_OWN bit is set 1 by software. After transaction,
 	 * this bit is auto cleared by TRL8150L.
 	 */
 	url_csr_write_1(un, URL_PHYCNT,
 			(reg | URL_PHYCNT_PHYOWN) & ~URL_PHYCNT_RWCR);
 	for (i = 0; i < URL_TIMEOUT; i++) {
 		if ((url_csr_read_1(un, URL_PHYCNT) & URL_PHYCNT_PHYOWN) == 0)
 			break;
+	}
 	if (i == URL_TIMEOUT) {
 		printf("%s: MII read timed out\n", device_xname(un->un_dev));
+	}
 	val = url_csr_read_2(un, URL_PHYDAT);
 	DPRINTF(("%s: %s: phy=%d reg=0x%04x => 0x%04x\n",
 		 device_xname(un->un_dev), __func__, phy, reg, val));
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 url_ext_mii_write_reg(struct usbnet *un, int phy, int reg, int data)
+{
 	DPRINTF(("%s: %s: enter, phy=%d reg=0x%04x data=0x%04x\n",
 		 device_xname(un->un_dev), __func__, phy, reg, data));
 	url_csr_write_2(un, URL_PHYDAT, data);
 	url_csr_write_1(un, URL_PHYADD, phy);
 	url_csr_write_1(un, URL_PHYCNT, reg | URL_PHYCNT_RWCR);	/* Write */
 	for (i=0; i < URL_TIMEOUT; i++) {
 		if (url_csr_read_1(un, URL_PHYCNT) & URL_PHYCNT_PHYOWN)
 			break;
+	}
 	if (i == URL_TIMEOUT) {
 		printf("%s: MII write timed out\n",
 		       device_xname(un->un_dev));
 		return USBD_TIMEOUT;
+	}
 	return USBD_NORMAL_COMPLETION;
+}
 #endif
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 USBNET_MODULE(url)

 @@ -1,1700 +1,1694 @@
-/*	$NetBSD: usbnet.c,v 1.54 2022/03/03 05:47:58 riastradh Exp $	*/
+/*	$NetBSD: usbnet.c,v 1.55 2022/03/03 05:48:14 riastradh Exp $	*/
 /*
  * Copyright (c) 2019 Matthew R. Green
  * 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 ``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 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.
  */
 /*
  * Common code shared between USB network drivers.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: usbnet.c,v 1.54 2022/03/03 05:47:58 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: usbnet.c,v 1.55 2022/03/03 05:48:14 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include <sys/atomic.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/usbhist.h>
 struct usbnet_cdata {
 	struct usbnet_chain	*uncd_tx_chain;
 	struct usbnet_chain	*uncd_rx_chain;
 	int			uncd_tx_prod;
 	int			uncd_tx_cnt;
 };
 struct usbnet_private {
 	/*
 	 * - unp_core_lock protects most of this structure, the public one,
 	 *   and the MII / media data.
 	 * - unp_rxlock protects the rx path and its data
 	 * - unp_txlock protects the tx path and its data
 	 * - unp_detachcv handles detach vs open references
+	 *
 	 * the lock ordering is:
 	 *	ifnet lock -> unp_core_lock -> unp_rxlock -> unp_txlock
 	 * - ifnet lock is not needed for unp_core_lock, but if ifnet lock is
 	 *   involved, it must be taken first
 	 */
 	kmutex_t		unp_core_lock;
 	kmutex_t		unp_rxlock;
 	kmutex_t		unp_txlock;
 	kcondvar_t		unp_detachcv;
 	struct usbnet_cdata	unp_cdata;
 	struct ethercom		unp_ec;
 	struct mii_data		unp_mii;
 	struct usb_task		unp_mcasttask;
 	struct usb_task		unp_ticktask;
 	struct callout		unp_stat_ch;
 	struct usbd_pipe	*unp_ep[USBNET_ENDPT_MAX];
 	bool			unp_dying;
 	bool			unp_stopping;
 	bool			unp_attached;
 	bool			unp_ifp_attached;
 	bool			unp_link;
 	int			unp_refcnt;
 	int			unp_timer;
 	unsigned short		unp_if_flags;
 	unsigned		unp_number;
 	krndsource_t		unp_rndsrc;
 	struct timeval		unp_rx_notice;
 	struct timeval		unp_tx_notice;
 	struct timeval		unp_intr_notice;
 };
 #define un_cdata(un)	(&(un)->un_pri->unp_cdata)
 volatile unsigned usbnet_number;
 static int usbnet_modcmd(modcmd_t, void *);
 #ifdef USB_DEBUG
 #ifndef USBNET_DEBUG
 #define usbnetdebug 0
 #else
 static int usbnetdebug = 0;
 SYSCTL_SETUP(sysctl_hw_usbnet_setup, "sysctl hw.usbnet setup")
+{
 	int err;
 	const struct sysctlnode *rnode;
 	const struct sysctlnode *cnode;
 	err = sysctl_createv(clog, 0, NULL, &rnode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "usbnet",
 	    SYSCTL_DESCR("usbnet 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, &usbnetdebug, sizeof(usbnetdebug), CTL_CREATE, CTL_EOL);
 	if (err)
 		goto fail;
 	return;
 fail:
 	aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
+}
 #endif /* USBNET_DEBUG */
 #endif /* USB_DEBUG */
 #define DPRINTF(FMT,A,B,C,D)	USBHIST_LOGN(usbnetdebug,1,FMT,A,B,C,D)
 #define DPRINTFN(N,FMT,A,B,C,D)	USBHIST_LOGN(usbnetdebug,N,FMT,A,B,C,D)
 #define USBNETHIST_FUNC()	USBHIST_FUNC()
 #define USBNETHIST_CALLED(name)	USBHIST_CALLED(usbnetdebug)
 #define USBNETHIST_CALLARGS(FMT,A,B,C,D) \
 				USBHIST_CALLARGS(usbnetdebug,FMT,A,B,C,D)
 #define USBNETHIST_CALLARGSN(N,FMT,A,B,C,D) \
 				USBHIST_CALLARGSN(usbnetdebug,N,FMT,A,B,C,D)
 /* Callback vectors. */
 static void
 uno_stop(struct usbnet *un, struct ifnet *ifp, int disable)
+{
 	KASSERTMSG(!un->un_pri->unp_ifp_attached || IFNET_LOCKED(ifp),
 	    "%s", ifp->if_xname);
 	usbnet_isowned_core(un);
 	if (un->un_ops->uno_stop)
 		(*un->un_ops->uno_stop)(ifp, disable);
+}
 static int
 uno_ioctl(struct usbnet *un, struct ifnet *ifp, u_long cmd, void *data)
+{
 	/*
 	 * There are cases where IFNET_LOCK will not be held when we
 	 * are called (e.g. add/delete multicast address), so we can't
 	 * assert it.
 	 */
 	if (un->un_ops->uno_ioctl)
 		return (*un->un_ops->uno_ioctl)(ifp, cmd, data);
 	return 0;
+}
 static int
 uno_override_ioctl(struct usbnet *un, struct ifnet *ifp, u_long cmd, void *data)
+{
 	/* See above. */
 	return (*un->un_ops->uno_override_ioctl)(ifp, cmd, data);
+}
 static int
 uno_init(struct usbnet *un, struct ifnet *ifp)
+{
 	KASSERT(IFNET_LOCKED(ifp));
 	return (*un->un_ops->uno_init)(ifp);
+}
 static int
 uno_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
+{
 	usbnet_isowned_core(un);
 	return (*un->un_ops->uno_read_reg)(un, phy, reg, val);
+}
 static int
 uno_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
+{
 	usbnet_isowned_core(un);
 	return (*un->un_ops->uno_write_reg)(un, phy, reg, val);
+}
 static void
 uno_mii_statchg(struct usbnet *un, struct ifnet *ifp)
+{
 	usbnet_isowned_core(un);
 	(*un->un_ops->uno_statchg)(ifp);
+}
 static unsigned
 uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	usbnet_isowned_tx(un);
 	return (*un->un_ops->uno_tx_prepare)(un, m, c);
+}
 static void
 uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len)
+{
 	usbnet_isowned_rx(un);
 	(*un->un_ops->uno_rx_loop)(un, c, total_len);
+}
 static void
 uno_tick(struct usbnet *un)
+{
 	if (un->un_ops->uno_tick)
 		(*un->un_ops->uno_tick)(un);
+}
 static void
 uno_intr(struct usbnet *un, usbd_status status)
+{
 	if (un->un_ops->uno_intr)
 		(*un->un_ops->uno_intr)(un, status);
+}
 /* Interrupt handling. */
 static struct mbuf *
 usbnet_newbuf(size_t buflen)
+{
 	struct mbuf *m;
 	if (buflen > MCLBYTES)
 		return NULL;
 	MGETHDR(m, M_DONTWAIT, MT_DATA);
 	if (m == NULL)
 		return NULL;
 	if (buflen > MHLEN - ETHER_ALIGN) {
 		MCLGET(m, M_DONTWAIT);
 		if (!(m->m_flags & M_EXT)) {
 			m_freem(m);
 			return NULL;
+		}
+	}
 	m_adj(m, ETHER_ALIGN);
 	m->m_len = m->m_pkthdr.len = buflen;
 	return m;
+}
 /*
  * usbnet_rxeof() is designed to be the done callback for rx completion.
  * it provides generic setup and finalisation, calls a different usbnet
  * rx_loop callback in the middle, which can use usbnet_enqueue() to
  * enqueue a packet for higher levels (or usbnet_input() if previously
  * using if_input() path.)
  */
 void
 usbnet_enqueue(struct usbnet * const un, uint8_t *buf, size_t buflen,
 	       int csum_flags, uint32_t csum_data, int mbuf_flags)
+{
 	USBNETHIST_FUNC();
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct usbnet_private * const unp __unused = un->un_pri;
 	struct mbuf *m;
 	USBNETHIST_CALLARGSN(5, "%jd: enter: len=%ju csf %#jx mbf %#jx",
 	    unp->unp_number, buflen, csum_flags, mbuf_flags);
 	usbnet_isowned_rx(un);
 	m = usbnet_newbuf(buflen);
 	if (m == NULL) {
 		DPRINTF("%jd: no memory", unp->unp_number, 0, 0, 0);
 		if_statinc(ifp, if_ierrors);
 		return;
+	}
 	m_set_rcvif(m, ifp);
 	m->m_pkthdr.csum_flags = csum_flags;
 	m->m_pkthdr.csum_data = csum_data;
 	m->m_flags |= mbuf_flags;
 	memcpy(mtod(m, uint8_t *), buf, buflen);
 	/* push the packet up */
 	if_percpuq_enqueue(ifp->if_percpuq, m);
+}
 void
 usbnet_input(struct usbnet * const un, uint8_t *buf, size_t buflen)
+{
 	USBNETHIST_FUNC();
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct usbnet_private * const unp __unused = un->un_pri;
 	struct mbuf *m;
 	USBNETHIST_CALLARGSN(5, "%jd: enter: buf %#jx len %ju",
 	    unp->unp_number, (uintptr_t)buf, buflen, 0);
 	usbnet_isowned_rx(un);
 	m = usbnet_newbuf(buflen);
 	if (m == NULL) {
 		if_statinc(ifp, if_ierrors);
 		return;
+	}
 	m_set_rcvif(m, ifp);
 	memcpy(mtod(m, char *), buf, buflen);
 	/* push the packet up */
 	if_input(ifp, m);
+}
 /*
  * A frame has been uploaded: pass the resulting mbuf chain up to
  * the higher level protocols.
  */
 static void
 usbnet_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	USBNETHIST_FUNC();
 	struct usbnet_chain * const c = priv;
 	struct usbnet * const un = c->unc_un;
 	struct usbnet_private * const unp = un->un_pri;
 	uint32_t total_len;
 	USBNETHIST_CALLARGSN(5, "%jd: enter: status %#jx xfer %#jx",
 	    unp->unp_number, status, (uintptr_t)xfer, 0);
 	mutex_enter(&unp->unp_rxlock);
 	if (unp->unp_dying || unp->unp_stopping ||
 	    status == USBD_INVAL || status == USBD_NOT_STARTED ||
 	    status == USBD_CANCELLED)
 		goto out;
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (usbd_ratecheck(&unp->unp_rx_notice))
 			device_printf(un->un_dev, "usb errors on rx: %s\n",
 			    usbd_errstr(status));
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(unp->unp_ep[USBNET_ENDPT_RX]);
 		goto done;
+	}
 	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
 	if (total_len > un->un_rx_bufsz) {
 		aprint_error_dev(un->un_dev,
 		    "rxeof: too large transfer (%u > %u)\n",
 		    total_len, un->un_rx_bufsz);
 		goto done;
+	}
 	uno_rx_loop(un, c, total_len);
 	usbnet_isowned_rx(un);
 done:
 	if (unp->unp_dying || unp->unp_stopping)
 		goto out;
 	mutex_exit(&unp->unp_rxlock);
 	/* Setup new transfer. */
 	usbd_setup_xfer(xfer, c, c->unc_buf, un->un_rx_bufsz,
 	    un->un_rx_xfer_flags, USBD_NO_TIMEOUT, usbnet_rxeof);
 	usbd_transfer(xfer);
 	return;
 out:
 	mutex_exit(&unp->unp_rxlock);
+}
 static void
 usbnet_txeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet_chain * const c = priv;
 	struct usbnet * const un = c->unc_un;
 	struct usbnet_cdata * const cd = un_cdata(un);
 	struct usbnet_private * const unp = un->un_pri;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	USBNETHIST_CALLARGSN(5, "%jd: enter: status %#jx xfer %#jx",
 	    unp->unp_number, status, (uintptr_t)xfer, 0);
 	mutex_enter(&unp->unp_txlock);
 	if (unp->unp_stopping || unp->unp_dying) {
 		mutex_exit(&unp->unp_txlock);
 		return;
+	}
 	KASSERT(cd->uncd_tx_cnt > 0);
 	cd->uncd_tx_cnt--;
 	unp->unp_timer = 0;
 	switch (status) {
 	case USBD_NOT_STARTED:
 	case USBD_CANCELLED:
 		break;
 	case USBD_NORMAL_COMPLETION:
 		if_statinc(ifp, if_opackets);
 		break;
 	default:
 		if_statinc(ifp, if_oerrors);
 		if (usbd_ratecheck(&unp->unp_tx_notice))
 			device_printf(un->un_dev, "usb error on tx: %s\n",
 			    usbd_errstr(status));
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(unp->unp_ep[USBNET_ENDPT_TX]);
 		break;
+	}
 	mutex_exit(&unp->unp_txlock);
 	if (status == USBD_NORMAL_COMPLETION && !IFQ_IS_EMPTY(&ifp->if_snd))
 		(*ifp->if_start)(ifp);
+}
 static void
 usbnet_pipe_intr(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = priv;
 	struct usbnet_private * const unp = un->un_pri;
 	struct usbnet_intr * const uni = un->un_intr;
 	if (uni == NULL || unp->unp_dying || unp->unp_stopping ||
 	    status == USBD_INVAL || status == USBD_NOT_STARTED ||
 	    status == USBD_CANCELLED) {
 		USBNETHIST_CALLARGS("%jd: uni %#jx d/s %#jx status %#jx",
 		    unp->unp_number, (uintptr_t)uni,
 		    (unp->unp_dying << 8) | unp->unp_stopping, status);
 		return;
+	}
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (usbd_ratecheck(&unp->unp_intr_notice)) {
 			aprint_error_dev(un->un_dev, "usb error on intr: %s\n",
 			    usbd_errstr(status));
+		}
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(unp->unp_ep[USBNET_ENDPT_INTR]);
 		USBNETHIST_CALLARGS("%jd: not normal status %#jx",
 		    unp->unp_number, status, 0, 0);
 		return;
+	}
 	uno_intr(un, status);
+}
 static void
 usbnet_start_locked(struct ifnet *ifp)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_cdata * const cd = un_cdata(un);
 	struct usbnet_private * const unp = un->un_pri;
 	struct mbuf *m;
 	unsigned length;
 	bool done_transmit = false;
 	int idx, count;
 	USBNETHIST_CALLARGS("%jd: tx_cnt %jd list_cnt %jd link %jd",
 	    unp->unp_number, cd->uncd_tx_cnt, un->un_tx_list_cnt,
 	    unp->unp_link);
 	usbnet_isowned_tx(un);
 	KASSERT(cd->uncd_tx_cnt <= un->un_tx_list_cnt);
 	if (!unp->unp_link || (ifp->if_flags & IFF_RUNNING) == 0) {
 		DPRINTF("start called no link (%jx) or running (flags %jx)",
 		    unp->unp_link, ifp->if_flags, 0, 0);
 		return;
+	}
 	if (cd->uncd_tx_cnt == un->un_tx_list_cnt) {
 		DPRINTF("start called, tx busy (%#jx == %#jx)",
 		    cd->uncd_tx_cnt, un->un_tx_list_cnt, 0, 0);
 		return;
+	}
 	idx = cd->uncd_tx_prod;
 	count = 0;
 	while (cd->uncd_tx_cnt < un->un_tx_list_cnt) {
 		IFQ_POLL(&ifp->if_snd, m);
 		if (m == NULL) {
 			DPRINTF("start called, queue empty", 0, 0, 0, 0);
 			break;
+		}
 		KASSERT(m->m_pkthdr.len <= un->un_tx_bufsz);
 		struct usbnet_chain *c = &cd->uncd_tx_chain[idx];
 		length = uno_tx_prepare(un, m, c);
 		if (length == 0) {
 			DPRINTF("uno_tx_prepare gave zero length", 0, 0, 0, 0);
 			if_statinc(ifp, if_oerrors);
 			break;
+		}
 		if (__predict_false(c->unc_xfer == NULL)) {
 			DPRINTF("unc_xfer is NULL", 0, 0, 0, 0);
 			if_statinc(ifp, if_oerrors);
 			break;
+		}
 		usbd_setup_xfer(c->unc_xfer, c, c->unc_buf, length,
 		    un->un_tx_xfer_flags, 10000, usbnet_txeof);
 		/* Transmit */
 		usbd_status err = usbd_transfer(c->unc_xfer);
 		if (err != USBD_IN_PROGRESS) {
 			DPRINTF("usbd_transfer on %#jx for %ju bytes: %jd",
 			    (uintptr_t)c->unc_buf, length, err, 0);
 			if_statinc(ifp, if_oerrors);
 			break;
+		}
 		done_transmit = true;
 		IFQ_DEQUEUE(&ifp->if_snd, m);
 		/*
 		 * If there's a BPF listener, bounce a copy of this frame
 		 * to him.
 		 */
 		bpf_mtap(ifp, m, BPF_D_OUT);
 		m_freem(m);
 		idx = (idx + 1) % un->un_tx_list_cnt;
 		cd->uncd_tx_cnt++;
 		count++;
+	}
 	cd->uncd_tx_prod = idx;
 	DPRINTF("finished with start; tx_cnt %jd list_cnt %jd link %jd",
 	    cd->uncd_tx_cnt, un->un_tx_list_cnt, unp->unp_link, 0);
 	/*
 	 * Set a timeout in case the chip goes out to lunch.
 	 */
 	if (done_transmit)
 		unp->unp_timer = 5;
 	if (count != 0)
 		rnd_add_uint32(&unp->unp_rndsrc, count);
+}
 static void
 usbnet_if_start(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_private * const unp = un->un_pri;
 	USBNETHIST_FUNC();
 	USBNETHIST_CALLARGS("%jd: stopping %jd",
 	    unp->unp_number, unp->unp_stopping, 0, 0);
 	mutex_enter(&unp->unp_txlock);
 	if (!unp->unp_stopping)
 		usbnet_start_locked(ifp);
 	mutex_exit(&unp->unp_txlock);
+}
 /*
  * Chain management.
+ *
  * RX and TX are identical. Keep them that way.
  */
 /* Start of common RX functions */
 static size_t
 usbnet_rx_list_size(struct usbnet_cdata * const cd, struct usbnet * const un)
+{
 	return sizeof(*cd->uncd_rx_chain) * un->un_rx_list_cnt;
+}
 static void
 usbnet_rx_list_alloc(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	cd->uncd_rx_chain = kmem_zalloc(usbnet_rx_list_size(cd, un), KM_SLEEP);
+}
 static void
 usbnet_rx_list_free(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	if (cd->uncd_rx_chain) {
 		kmem_free(cd->uncd_rx_chain, usbnet_rx_list_size(cd, un));
 		cd->uncd_rx_chain = NULL;
+	}
+}
 static int
 usbnet_rx_list_init(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	struct usbnet_private * const unp = un->un_pri;
 	for (size_t i = 0; i < un->un_rx_list_cnt; i++) {
 		struct usbnet_chain *c = &cd->uncd_rx_chain[i];
 		c->unc_un = un;
 		if (c->unc_xfer == NULL) {
 			int err = usbd_create_xfer(unp->unp_ep[USBNET_ENDPT_RX],
 			    un->un_rx_bufsz, un->un_rx_xfer_flags, 0,
 			    &c->unc_xfer);
 			if (err)
 				return err;
 			c->unc_buf = usbd_get_buffer(c->unc_xfer);
+		}
+	}
 	return 0;
+}
 static void
 usbnet_rx_list_fini(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	for (size_t i = 0; i < un->un_rx_list_cnt; i++) {
 		struct usbnet_chain *c = &cd->uncd_rx_chain[i];
 		if (c->unc_xfer != NULL) {
 			usbd_destroy_xfer(c->unc_xfer);
 			c->unc_xfer = NULL;
 			c->unc_buf = NULL;
+		}
+	}
+}
 /* End of common RX functions */
 static void
 usbnet_rx_start_pipes(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	struct usbnet_private * const unp = un->un_pri;
 	mutex_enter(&unp->unp_rxlock);
 	mutex_enter(&unp->unp_txlock);
 	unp->unp_stopping = false;
 	for (size_t i = 0; i < un->un_rx_list_cnt; i++) {
 		struct usbnet_chain *c = &cd->uncd_rx_chain[i];
 		usbd_setup_xfer(c->unc_xfer, c, c->unc_buf, un->un_rx_bufsz,
 		    un->un_rx_xfer_flags, USBD_NO_TIMEOUT, usbnet_rxeof);
 		usbd_transfer(c->unc_xfer);
+	}
 	mutex_exit(&unp->unp_txlock);
 	mutex_exit(&unp->unp_rxlock);
+}
 /* Start of common TX functions */
 static size_t
 usbnet_tx_list_size(struct usbnet_cdata * const cd, struct usbnet * const un)
+{
 	return sizeof(*cd->uncd_tx_chain) * un->un_tx_list_cnt;
+}
 static void
 usbnet_tx_list_alloc(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	cd->uncd_tx_chain = kmem_zalloc(usbnet_tx_list_size(cd, un), KM_SLEEP);
+}
 static void
 usbnet_tx_list_free(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	if (cd->uncd_tx_chain) {
 		kmem_free(cd->uncd_tx_chain, usbnet_tx_list_size(cd, un));
 		cd->uncd_tx_chain = NULL;
+	}
+}
 static int
 usbnet_tx_list_init(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	struct usbnet_private * const unp = un->un_pri;
 	for (size_t i = 0; i < un->un_tx_list_cnt; i++) {
 		struct usbnet_chain *c = &cd->uncd_tx_chain[i];
 		c->unc_un = un;
 		if (c->unc_xfer == NULL) {
 			int err = usbd_create_xfer(unp->unp_ep[USBNET_ENDPT_TX],
 			    un->un_tx_bufsz, un->un_tx_xfer_flags, 0,
 			    &c->unc_xfer);
 			if (err)
 				return err;
 			c->unc_buf = usbd_get_buffer(c->unc_xfer);
+		}
+	}
 	return 0;
+}
 static void
 usbnet_tx_list_fini(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	for (size_t i = 0; i < un->un_tx_list_cnt; i++) {
 		struct usbnet_chain *c = &cd->uncd_tx_chain[i];
 		if (c->unc_xfer != NULL) {
 			usbd_destroy_xfer(c->unc_xfer);
 			c->unc_xfer = NULL;
 			c->unc_buf = NULL;
+		}
+	}
 	cd->uncd_tx_prod = cd->uncd_tx_cnt = 0;
+}
 /* End of common TX functions */
 /* Endpoint pipe management. */
 static void
 usbnet_ep_close_pipes(struct usbnet * const un)
+{
 	struct usbnet_private * const unp = un->un_pri;
 	for (size_t i = 0; i < __arraycount(unp->unp_ep); i++) {
 		if (unp->unp_ep[i] == NULL)
 			continue;
 		usbd_status err = usbd_close_pipe(unp->unp_ep[i]);
 		if (err)
 			aprint_error_dev(un->un_dev, "close pipe %zu: %s\n", i,
 			    usbd_errstr(err));
 		unp->unp_ep[i] = NULL;
+	}
+}
 static usbd_status
 usbnet_ep_open_pipes(struct usbnet * const un)
+{
 	struct usbnet_intr * const uni = un->un_intr;
 	struct usbnet_private * const unp = un->un_pri;
 	for (size_t i = 0; i < __arraycount(unp->unp_ep); i++) {
 		usbd_status err;
 		if (un->un_ed[i] == 0)
 			continue;
 		if (i == USBNET_ENDPT_INTR && uni) {
 			err = usbd_open_pipe_intr(un->un_iface, un->un_ed[i],
 			    USBD_EXCLUSIVE_USE | USBD_MPSAFE, &unp->unp_ep[i], un,
 			    uni->uni_buf, uni->uni_bufsz, usbnet_pipe_intr,
 			    uni->uni_interval);
 		} else {
 			err = usbd_open_pipe(un->un_iface, un->un_ed[i],
 			    USBD_EXCLUSIVE_USE | USBD_MPSAFE, &unp->unp_ep[i]);
+		}
 		if (err) {
 			usbnet_ep_close_pipes(un);
 			return err;
+		}
+	}
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 usbnet_ep_stop_pipes(struct usbnet * const un)
+{
 	struct usbnet_private * const unp = un->un_pri;
 	usbd_status err = USBD_NORMAL_COMPLETION;
 	for (size_t i = 0; i < __arraycount(unp->unp_ep); i++) {
 		if (unp->unp_ep[i] == NULL)
 			continue;
 		usbd_status err2 = usbd_abort_pipe(unp->unp_ep[i]);
 		if (err == USBD_NORMAL_COMPLETION && err2)
 			err = err2;
+	}
 	return err;
+}
 int
 usbnet_init_rx_tx(struct usbnet * const un)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet_private * const unp = un->un_pri;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	usbd_status err;
 	int error = 0;
 	KASSERTMSG(!unp->unp_ifp_attached || IFNET_LOCKED(ifp),
 	    "%s", ifp->if_xname);
 	usbnet_isowned_core(un);
 	if (unp->unp_dying) {
 		return EIO;
+	}
 	usbnet_busy(un);
 	/* Open RX and TX pipes. */
 	err = usbnet_ep_open_pipes(un);
 	if (err) {
 		aprint_error_dev(un->un_dev, "open rx/tx pipes failed: %s\n",
 		    usbd_errstr(err));
 		error = EIO;
 		goto out;
+	}
 	/* Init RX ring. */
 	if (usbnet_rx_list_init(un)) {
 		aprint_error_dev(un->un_dev, "rx list init failed\n");
 		error = ENOBUFS;
 		goto out;
+	}
 	/* Init TX ring. */
 	if (usbnet_tx_list_init(un)) {
 		aprint_error_dev(un->un_dev, "tx list init failed\n");
 		error = ENOBUFS;
 		goto out;
+	}
 	/* Indicate we are up and running. */
 #if 0
 	/* XXX if_mcast_op() can call this without ifnet locked */
 	KASSERT(ifp->if_softc == NULL || IFNET_LOCKED(ifp));
 #endif
 	ifp->if_flags |= IFF_RUNNING;
 	/* Start up the receive pipe(s). */
 	usbnet_rx_start_pipes(un);
 	callout_schedule(&unp->unp_stat_ch, hz);
 out:
 	if (error) {
 		usbnet_rx_list_fini(un);
 		usbnet_tx_list_fini(un);
 		usbnet_ep_close_pipes(un);
+	}
 	usbnet_unbusy(un);
 	usbnet_isowned_core(un);
 	return error;
+}
 void
 usbnet_busy(struct usbnet *un)
+{
 	struct usbnet_private * const unp = un->un_pri;
 	usbnet_isowned_core(un);
 	unp->unp_refcnt++;
+}
 void
 usbnet_unbusy(struct usbnet *un)
+{
 	struct usbnet_private * const unp = un->un_pri;
 	usbnet_isowned_core(un);
 	if (--unp->unp_refcnt < 0)
 		cv_broadcast(&unp->unp_detachcv);
+}
 /* MII management. */
 int
 usbnet_mii_readreg(device_t dev, int phy, int reg, uint16_t *val)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = device_private(dev);
 	struct usbnet_private * const unp = un->un_pri;
 	int err;
 	/* MII layer ensures core_lock is held. */
 	usbnet_isowned_core(un);
 	if (unp->unp_dying) {
 		return EIO;
+	}
 	usbnet_busy(un);
 	err = uno_read_reg(un, phy, reg, val);
 	usbnet_unbusy(un);
 	if (err) {
 		USBNETHIST_CALLARGS("%jd: read PHY failed: %jd",
 		    unp->unp_number, err, 0, 0);
 		return err;
+	}
 	return 0;
+}
 int
 usbnet_mii_writereg(device_t dev, int phy, int reg, uint16_t val)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = device_private(dev);
 	struct usbnet_private * const unp = un->un_pri;
 	int err;
 	/* MII layer ensures core_lock is held. */
 	usbnet_isowned_core(un);
 	if (unp->unp_dying) {
 		return EIO;
+	}
 	usbnet_busy(un);
 	err = uno_write_reg(un, phy, reg, val);
 	usbnet_unbusy(un);
 	if (err) {
 		USBNETHIST_CALLARGS("%jd: write PHY failed: %jd",
 		    unp->unp_number, err, 0, 0);
 		return err;
+	}
 	return 0;
+}
 void
 usbnet_mii_statchg(struct ifnet *ifp)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = ifp->if_softc;
 	/* MII layer ensures core_lock is held. */
 	usbnet_isowned_core(un);
 	usbnet_busy(un);
 	uno_mii_statchg(un, ifp);
 	usbnet_unbusy(un);
+}
 static int
 usbnet_media_upd(struct ifnet *ifp)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_private * const unp = un->un_pri;
 	struct mii_data * const mii = usbnet_mii(un);
 	/* ifmedia layer ensures core_lock is held. */
 	usbnet_isowned_core(un);
 	if (unp->unp_dying)
 		return EIO;
 	unp->unp_link = false;
 	if (mii->mii_instance) {
 		struct mii_softc *miisc;
 		LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
 			mii_phy_reset(miisc);
+	}
 	return ether_mediachange(ifp);
+}
 /* ioctl */
 static int
 usbnet_ifflags_cb(struct ethercom *ec)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct ifnet *ifp = &ec->ec_if;
 	struct usbnet *un = ifp->if_softc;
 	struct usbnet_private * const unp = un->un_pri;
 	int rv = 0;
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	mutex_enter(&unp->unp_core_lock);
 	const u_short changed = ifp->if_flags ^ unp->unp_if_flags;
 	if ((changed & ~(IFF_CANTCHANGE | IFF_DEBUG)) == 0) {
 		unp->unp_if_flags = ifp->if_flags;
 		if ((changed & IFF_PROMISC) != 0)
 			rv = ENETRESET;
 	} else {
 		rv = ENETRESET;
+	}
 	mutex_exit(&unp->unp_core_lock);
 	return rv;
+}
 static int
 usbnet_if_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_private * const unp __unused = un->un_pri;
 	int error;
 	USBNETHIST_CALLARGSN(11, "%jd: enter %#jx data %#jx",
 	    unp->unp_number, cmd, (uintptr_t)data, 0);
 	if (un->un_ops->uno_override_ioctl)
 		return uno_override_ioctl(un, ifp, cmd, data);
 	error = ether_ioctl(ifp, cmd, data);
 	if (error == ENETRESET) {
 		switch (cmd) {
 		case SIOCADDMULTI:
 		case SIOCDELMULTI:
 			usb_add_task(un->un_udev, &unp->unp_mcasttask,
 			    USB_TASKQ_DRIVER);
 			error = 0;
 			break;
 		default:
 			error = uno_ioctl(un, ifp, cmd, data);
+		}
+	}
 	return error;
+}
 static void
 usbnet_mcast_task(void *arg)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = arg;
 	struct usbnet_private * const unp = un->un_pri;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	bool dying;
 	struct ifreq ifr;
 	USBNETHIST_CALLARGSN(10, "%jd: enter", unp->unp_number, 0, 0, 0);
 	/*
 	 * If we're detaching, we must check unp_dying _before_
 	 * touching IFNET_LOCK -- the ifnet may have been detached by
 	 * the time this task runs.  This is racy -- unp_dying may be
 	 * set immediately after we test it -- but nevertheless safe,
 	 * because usbnet_detach waits for the task to complete before
 	 * issuing if_detach, and necessary, so that we don't touch
 	 * IFNET_LOCK after if_detach.  See usbnet_detach for details.
 	 */
 	mutex_enter(&unp->unp_core_lock);
 	dying = unp->unp_dying;
 	mutex_exit(&unp->unp_core_lock);
 	if (dying)
 		return;
 	/*
 	 * Pass a bogus ifr with SIOCDELMULTI -- the goal is to just
 	 * notify the driver to reprogram any hardware multicast
 	 * filter, according to what's already stored in the ethercom.
 	 * None of the drivers actually examine this argument, so it
 	 * doesn't change the ABI as far as they can tell.
 	 */
 	IFNET_LOCK(ifp);
 	if (ifp->if_flags & IFF_RUNNING) {
 		memset(&ifr, 0, sizeof(ifr));
 		(void)uno_ioctl(un, ifp, SIOCDELMULTI, &ifr);
+	}
 	IFNET_UNLOCK(ifp);
+}
 /*
  * Generic stop network function:
  *	- mark as stopping
  *	- call DD routine to stop the device
  *	- turn off running, timer, statchg callout, link
  *	- stop transfers
  *	- free RX and TX resources
  *	- close pipes
+ *
  * usbnet_stop() is exported for drivers to use, expects lock held.
+ *
  * usbnet_if_stop() is for the if_stop handler.
  */
 void
 usbnet_stop(struct usbnet *un, struct ifnet *ifp, int disable)
+{
 	struct usbnet_private * const unp = un->un_pri;
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	KASSERTMSG(!unp->unp_ifp_attached || IFNET_LOCKED(ifp),
 	    "%s", ifp->if_xname);
 	usbnet_isowned_core(un);
 	usbnet_busy(un);
 	mutex_enter(&unp->unp_rxlock);
 	mutex_enter(&unp->unp_txlock);
 	unp->unp_stopping = true;
 	mutex_exit(&unp->unp_txlock);
 	mutex_exit(&unp->unp_rxlock);
 	uno_stop(un, ifp, disable);
 	mutex_enter(&unp->unp_txlock);
 	unp->unp_timer = 0;
 	mutex_exit(&unp->unp_txlock);
 	callout_halt(&unp->unp_stat_ch, &unp->unp_core_lock);
 	usb_rem_task_wait(un->un_udev, &unp->unp_ticktask, USB_TASKQ_DRIVER,
 	    &unp->unp_core_lock);
 	/* Stop transfers. */
 	usbnet_ep_stop_pipes(un);
 	/* Free RX/TX resources. */
 	usbnet_rx_list_fini(un);
 	usbnet_tx_list_fini(un);
 	/* Close pipes. */
 	usbnet_ep_close_pipes(un);
 	/* Everything is quesced now. */
 	KASSERTMSG(!unp->unp_ifp_attached || IFNET_LOCKED(ifp),
 	    "%s", ifp->if_xname);
 	ifp->if_flags &= ~IFF_RUNNING;
 	usbnet_unbusy(un);
+}
 static void
 usbnet_if_stop(struct ifnet *ifp, int disable)
+{
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_private * const unp = un->un_pri;
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	mutex_enter(&unp->unp_core_lock);
 	usbnet_stop(un, ifp, disable);
 	mutex_exit(&unp->unp_core_lock);
+}
 /*
  * Generic tick task function.
+ *
  * usbnet_tick() is triggered from a callout, and triggers a call to
  * usbnet_tick_task() from the usb_task subsystem.
  */
 static void
 usbnet_tick(void *arg)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = arg;
 	struct usbnet_private * const unp = un->un_pri;
 	USBNETHIST_CALLARGSN(10, "%jd: enter", unp->unp_number, 0, 0, 0);
 	if (unp != NULL && !unp->unp_stopping && !unp->unp_dying) {
 		/* Perform periodic stuff in process context */
 		usb_add_task(un->un_udev, &unp->unp_ticktask, USB_TASKQ_DRIVER);
+	}
+}
 static void
 usbnet_watchdog(struct ifnet *ifp)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_private * const unp = un->un_pri;
 	struct usbnet_cdata * const cd = un_cdata(un);
 	usbd_status err;
 	if_statinc(ifp, if_oerrors);
 	device_printf(un->un_dev, "watchdog timeout\n");
 	if (cd->uncd_tx_cnt > 0) {
 		DPRINTF("uncd_tx_cnt=%ju non zero, aborting pipe", 0, 0, 0, 0);
 		err = usbd_abort_pipe(unp->unp_ep[USBNET_ENDPT_TX]);
 		if (err)
 			device_printf(un->un_dev, "pipe abort failed: %s\n",
 			    usbd_errstr(err));
 		if (cd->uncd_tx_cnt != 0)
 			DPRINTF("uncd_tx_cnt now %ju", cd->uncd_tx_cnt, 0, 0, 0);
+	}
 	if (!IFQ_IS_EMPTY(&ifp->if_snd))
 		(*ifp->if_start)(ifp);
+}
 static void
 usbnet_tick_task(void *arg)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = arg;
 	struct usbnet_private * const unp = un->un_pri;
 	USBNETHIST_CALLARGSN(8, "%jd: enter", unp->unp_number, 0, 0, 0);
 	mutex_enter(&unp->unp_core_lock);
 	if (unp->unp_stopping || unp->unp_dying) {
 		mutex_exit(&unp->unp_core_lock);
 		return;
+	}
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct mii_data * const mii = usbnet_mii(un);
 	KASSERT(ifp != NULL);	/* embedded member */
 	usbnet_busy(un);
 	mutex_exit(&unp->unp_core_lock);
 	mutex_enter(&unp->unp_txlock);
 	const bool timeout = unp->unp_timer != 0 && --unp->unp_timer == 0;
 	mutex_exit(&unp->unp_txlock);
 	if (timeout)
 		usbnet_watchdog(ifp);
 	DPRINTFN(8, "mii %#jx ifp %#jx", (uintptr_t)mii, (uintptr_t)ifp, 0, 0);
 	if (mii) {
 		mutex_enter(&unp->unp_core_lock);
 		mii_tick(mii);
 		if (!unp->unp_link)
 			(*mii->mii_statchg)(ifp);
 		mutex_exit(&unp->unp_core_lock);
+	}
 	/* Call driver if requested. */
 	uno_tick(un);
 	mutex_enter(&unp->unp_core_lock);
 	usbnet_unbusy(un);
 	if (!unp->unp_stopping && !unp->unp_dying)
 		callout_schedule(&unp->unp_stat_ch, hz);
 	mutex_exit(&unp->unp_core_lock);
+}
 static int
 usbnet_if_init(struct ifnet *ifp)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = ifp->if_softc;
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	return uno_init(un, ifp);
+}
 /* Various accessors. */
 void
 usbnet_set_link(struct usbnet *un, bool link)
+{
 	un->un_pri->unp_link = link;
+}
 void
 usbnet_set_dying(struct usbnet *un, bool link)
 	un->un_pri->unp_dying = link;
 struct ifnet *
 usbnet_ifp(struct usbnet *un)
+{
 	return &un->un_pri->unp_ec.ec_if;
+}
 struct ethercom *
 usbnet_ec(struct usbnet *un)
+{
 	return &un->un_pri->unp_ec;
+}
 struct mii_data *
 usbnet_mii(struct usbnet *un)
+{
 	return un->un_pri->unp_ec.ec_mii;
+}
 krndsource_t *
 usbnet_rndsrc(struct usbnet *un)
+{
 	return &un->un_pri->unp_rndsrc;
+}
 void *
 usbnet_softc(struct usbnet *un)
+{
 	return un->un_sc;
+}
 bool
 usbnet_havelink(struct usbnet *un)
+{
 	return un->un_pri->unp_link;
+}
 bool
 usbnet_isdying(struct usbnet *un)
+{
 	return un->un_pri->unp_dying;
+}
 /* Locking. */
 void
 usbnet_lock_core(struct usbnet *un)
+{
 	mutex_enter(&un->un_pri->unp_core_lock);
+}
 void
 usbnet_unlock_core(struct usbnet *un)
+{
 	mutex_exit(&un->un_pri->unp_core_lock);
+}
 kmutex_t *
 usbnet_mutex_core(struct usbnet *un)
+{
 	return &un->un_pri->unp_core_lock;
+}
 void
 usbnet_lock_rx(struct usbnet *un)
+{
 	mutex_enter(&un->un_pri->unp_rxlock);
+}
 void
 usbnet_unlock_rx(struct usbnet *un)
+{
 	mutex_exit(&un->un_pri->unp_rxlock);
+}
 kmutex_t *
 usbnet_mutex_rx(struct usbnet *un)
+{
 	return &un->un_pri->unp_rxlock;
+}
 void
 usbnet_lock_tx(struct usbnet *un)
+{
 	mutex_enter(&un->un_pri->unp_txlock);
+}
 void
 usbnet_unlock_tx(struct usbnet *un)
+{
 	mutex_exit(&un->un_pri->unp_txlock);
+}
 kmutex_t *
 usbnet_mutex_tx(struct usbnet *un)
+{
 	return &un->un_pri->unp_txlock;
+}
 /* Autoconf management. */
 static bool
 usbnet_empty_eaddr(struct usbnet * const un)
+{
 	return (un->un_eaddr[0] == 0 && un->un_eaddr[1] == 0 &&
 		un->un_eaddr[2] == 0 && un->un_eaddr[3] == 0 &&
 		un->un_eaddr[4] == 0 && un->un_eaddr[5] == 0);
+}
 /*
  * usbnet_attach() and usbnet_attach_ifp() perform setup of the relevant
  * 'usbnet'.  The first is enough to enable device access (eg, endpoints
  * are connected and commands can be sent), and the second connects the
  * device to the system networking.
+ *
  * Always call usbnet_detach(), even if usbnet_attach_ifp() is skippped.
  * Also usable as driver detach directly.
+ *
  * To skip ethernet configuration (eg, point-to-point), make sure that
  * the un_eaddr[] is fully zero.
  */
 void
 usbnet_attach(struct usbnet *un,
 	      const char *detname)	/* detach cv name */
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	/* Required inputs.  */
 	KASSERT(un->un_ops->uno_tx_prepare);
 	KASSERT(un->un_ops->uno_rx_loop);
 	KASSERT(un->un_ops->uno_init);
 	KASSERT(un->un_rx_bufsz);
 	KASSERT(un->un_tx_bufsz);
 	KASSERT(un->un_rx_list_cnt);
 	KASSERT(un->un_tx_list_cnt);
 	/* Unfortunate fact.  */
 	KASSERT(un == device_private(un->un_dev));
 	un->un_pri = kmem_zalloc(sizeof(*un->un_pri), KM_SLEEP);
 	struct usbnet_private * const unp = un->un_pri;
 	usb_init_task(&unp->unp_mcasttask, usbnet_mcast_task, un,
 	    USB_TASKQ_MPSAFE);
 	usb_init_task(&unp->unp_ticktask, usbnet_tick_task, un,
 	    USB_TASKQ_MPSAFE);
 	callout_init(&unp->unp_stat_ch, CALLOUT_MPSAFE);
 	callout_setfunc(&unp->unp_stat_ch, usbnet_tick, un);
 	mutex_init(&unp->unp_txlock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	mutex_init(&unp->unp_rxlock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	mutex_init(&unp->unp_core_lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&unp->unp_detachcv, detname);
 	rnd_attach_source(&unp->unp_rndsrc, device_xname(un->un_dev),
 	    RND_TYPE_NET, RND_FLAG_DEFAULT);
 	usbnet_rx_list_alloc(un);
 	usbnet_tx_list_alloc(un);
 	unp->unp_number = atomic_inc_uint_nv(&usbnet_number);
 	unp->unp_attached = true;
+}
 static void
 usbnet_attach_mii(struct usbnet *un, const struct usbnet_mii *unm)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet_private * const unp = un->un_pri;
 	struct mii_data * const mii = &unp->unp_mii;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	KASSERT(un->un_ops->uno_read_reg);
 	KASSERT(un->un_ops->uno_write_reg);
 	KASSERT(un->un_ops->uno_statchg);
 	mii->mii_ifp = ifp;
 	mii->mii_readreg = usbnet_mii_readreg;
 	mii->mii_writereg = usbnet_mii_writereg;
 	mii->mii_statchg = usbnet_mii_statchg;
 	mii->mii_flags = MIIF_AUTOTSLEEP;
 	usbnet_ec(un)->ec_mii = mii;
 	ifmedia_init_with_lock(&mii->mii_media, 0,
 	    usbnet_media_upd, ether_mediastatus, usbnet_mutex_core(un));
 	mii_attach(un->un_dev, mii, unm->un_mii_capmask, unm->un_mii_phyloc,
 		   unm->un_mii_offset, unm->un_mii_flags);
 	if (LIST_FIRST(&mii->mii_phys) == NULL) {
 		ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
 		ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
 	} else
 		ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
+}
 void
 usbnet_attach_ifp(struct usbnet *un,
 		  unsigned if_flags,		/* additional if_flags */
 		  unsigned if_extflags,		/* additional if_extflags */
 		  const struct usbnet_mii *unm)	/* additional mii_attach flags */
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet_private * const unp = un->un_pri;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	KASSERT(unp->unp_attached);
 	KASSERT(!unp->unp_ifp_attached);
 	ifp->if_softc = un;
 	strlcpy(ifp->if_xname, device_xname(un->un_dev), IFNAMSIZ);
 	ifp->if_flags = if_flags;
 	ifp->if_extflags = IFEF_MPSAFE | if_extflags;
 	ifp->if_ioctl = usbnet_if_ioctl;
 	ifp->if_start = usbnet_if_start;
 	ifp->if_init = usbnet_if_init;
 	ifp->if_stop = usbnet_if_stop;
 	if (unm)
 		usbnet_attach_mii(un, unm);
 	else
 		unp->unp_link = true;
 	/* Attach the interface. */
 	if_initialize(ifp);
 	if (ifp->_if_input == NULL)
 		ifp->if_percpuq = if_percpuq_create(ifp);
 	if_register(ifp);
 	unp->unp_ifp_attached = true;
 	/*
 	 * If ethernet address is all zero, skip ether_ifattach() and
 	 * instead attach bpf here..
 	 */
 	if (!usbnet_empty_eaddr(un)) {
 		ether_set_ifflags_cb(&unp->unp_ec, usbnet_ifflags_cb);
 		aprint_normal_dev(un->un_dev, "Ethernet address %s\n",
 		    ether_sprintf(un->un_eaddr));
 		ether_ifattach(ifp, un->un_eaddr);
 	} else {
 		if_alloc_sadl(ifp);
 		bpf_attach(ifp, DLT_RAW, 0);
+	}
 	/* Now ready, and attached. */
 	IFQ_SET_READY(&ifp->if_snd);
 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, un->un_udev, un->un_dev);
 	if (!pmf_device_register(un->un_dev, NULL, NULL))
 		aprint_error_dev(un->un_dev, "couldn't establish power handler\n");
+}
 int
 usbnet_detach(device_t self, int flags)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = device_private(self);
 	struct usbnet_private * const unp = un->un_pri;
 	/* Detached before attached finished, so just bail out. */
 	if (unp == NULL || !unp->unp_attached)
 		return 0;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct mii_data * const mii = usbnet_mii(un);
 	mutex_enter(&unp->unp_core_lock);
 	unp->unp_dying = true;
 	mutex_exit(&unp->unp_core_lock);
 	IFNET_LOCK(ifp);
 	if (ifp->if_flags & IFF_RUNNING) {
 		usbnet_if_stop(ifp, 1);
+	}
 	IFNET_UNLOCK(ifp);
 	callout_halt(&unp->unp_stat_ch, NULL);
 	usb_rem_task_wait(un->un_udev, &unp->unp_ticktask, USB_TASKQ_DRIVER,
 	    NULL);
 	usb_rem_task_wait(un->un_udev, &unp->unp_mcasttask, USB_TASKQ_DRIVER,
 	    NULL);
 	mutex_enter(&unp->unp_core_lock);
 	unp->unp_refcnt--;
 	while (unp->unp_refcnt >= 0) {
 		/* Wait for processes to go away */
 		cv_wait(&unp->unp_detachcv, &unp->unp_core_lock);
+	}
 	mutex_exit(&unp->unp_core_lock);
 	usbnet_rx_list_free(un);
 	usbnet_tx_list_free(un);
 	callout_destroy(&unp->unp_stat_ch);
 	rnd_detach_source(&unp->unp_rndsrc);
 	if (mii) {
 		mii_detach(mii, MII_PHY_ANY, MII_OFFSET_ANY);
 		ifmedia_fini(&mii->mii_media);
+	}
 	if (unp->unp_ifp_attached) {
 		if (!usbnet_empty_eaddr(un))
 			ether_ifdetach(ifp);
 		else
 			bpf_detach(ifp);
 		if_detach(ifp);
+	}
 	usbnet_ec(un)->ec_mii = NULL;
 	/*
 	 * We have already waited for the multicast task to complete.
 	 * Unfortunately, until if_detach, nothing has prevented it
 	 * from running again -- another thread might issue if_mcast_op
 	 * between the time of our first usb_rem_task_wait and the time
 	 * we actually get around to if_detach.
+	 *
 	 * Fortunately, the first usb_rem_task_wait ensures that if the
 	 * task is scheduled again, it will witness our setting of
 	 * unp_dying to true[*].  So after that point, if the task is
 	 * scheduled again, it will decline to touch IFNET_LOCK and do
 	 * nothing.  But we still need to wait for it to complete.
+	 *
 	 * It would be nice if we could write
+	 *
 	 *	if_pleasestopissuingmcastopsthanks(ifp);
 	 *	usb_rem_task_wait(..., &unp->unp_mcasttask, ...);
 	 *	if_detach(ifp);
+	 *
 	 * and then we would need only one usb_rem_task_wait.
+	 *
 	 * Unfortunately, there is no such operation available in
 	 * sys/net at the moment, and it would require a bit of
 	 * coordination with if_mcast_op and doifioctl probably under a
 	 * new lock.  So we'll use this kludge until that mechanism is
 	 * invented.
+	 *
 	 * [*] This is not exactly a documented property of the API,
 	 * but it is implied by the single lock in the task queue
 	 * serializing changes to the task state.
 	 */
 	usb_rem_task_wait(un->un_udev, &unp->unp_mcasttask, USB_TASKQ_DRIVER,
 	    NULL);
 	cv_destroy(&unp->unp_detachcv);
 	mutex_destroy(&unp->unp_core_lock);
 	mutex_destroy(&unp->unp_rxlock);
 	mutex_destroy(&unp->unp_txlock);
 	pmf_device_deregister(un->un_dev);
 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, un->un_udev, un->un_dev);
 	kmem_free(unp, sizeof(*unp));
 	un->un_pri = NULL;
 	return 0;
+}
 int
 usbnet_activate(device_t self, devact_t act)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = device_private(self);
 	struct usbnet_private * const unp = un->un_pri;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		if_deactivate(ifp);
 		mutex_enter(&unp->unp_core_lock);
 		unp->unp_dying = true;
 		mutex_exit(&unp->unp_core_lock);
 		mutex_enter(&unp->unp_rxlock);
 		mutex_enter(&unp->unp_txlock);
 		unp->unp_stopping = true;
 		mutex_exit(&unp->unp_txlock);
 		mutex_exit(&unp->unp_rxlock);
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 MODULE(MODULE_CLASS_MISC, usbnet, NULL);
 static int
 usbnet_modcmd(modcmd_t cmd, void *arg)
+{
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		return 0;
 	case MODULE_CMD_FINI:
 		return 0;
 	case MODULE_CMD_STAT:
 	case MODULE_CMD_AUTOUNLOAD:
 	default:
 		return ENOTTY;
+	}
+}

 @@ -1,403 +1,402 @@
-/*	$NetBSD: usbnet.h,v 1.22 2021/12/11 19:24:21 mrg Exp $	*/
+/*	$NetBSD: usbnet.h,v 1.23 2022/03/03 05:48:14 riastradh Exp $	*/
 /*
  * Copyright (c) 2019 Matthew R. Green
  * 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 ``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 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.
  */
 #ifndef _DEV_USB_USBNET_H
 #define _DEV_USB_USBNET_H
 /*
  * Common code/data shared by all USB ethernet drivers (using these routines.)
+ *
  * This framework provides the following features for USB ethernet drivers:
+ *
  * - USB endpoint pipe handling
  * - rx and tx chain handling
  * - generic handlers or support for several struct ifnet callbacks
  * - MII bus locking
  * - interrupt handling
  * - partial autoconf handling
+ *
  * Consumers of this interface need to:
+ *
  * - replace most softc members with "struct usbnet" usage, in particular
  *   use usbnet pointer for ifp->if_softc, and device_private (real softc
  *   can be stored in un_sc member)
  * - use MII bus lock / access methods
  * - usbnet_attach() to initialise and allocate rx/tx chains
  * - usbnet_attach_ifp() to attach the interface, and either ether_ifattach()
  *   for ethernet devices, or if_alloc_sadl()/bpf_attach() pair otherwise.
  * - usbnet_detach() to clean them up
  * - usbnet_activate() for autoconf
  * - interface ioctl and start have direct frontends with callbacks for
  *   device specific handling:
  *   - ioctl can use either a device-specific override (useful for special
  *     cases), but provides a normal handler with callback to handle
  *     ENETRESET conditions that should be sufficient for most users
  *   - start uses usbnet transmit prepare callback (uno_tx_prepare)
  * - interface init and stop have helper functions
  *   - device specific init should use usbnet_init_rx_tx() to open pipes
  *     to the device and setup the rx/tx chains for use after any device
  *     specific setup
  *   - usbnet_stop() must be called with the un_lock held, and will
  *     call the device-specific usbnet stop callback, which enables the
  *     standard init calls stop idiom.
  * - interrupt handling:
  *   - for rx, usbnet_init_rx_tx() will enable the receive pipes and
  *     call the rx_loop callback to handle device specific processing of
  *     packets, which can use usbnet_enqueue() to provide data to the
  *     higher layers
  *   - for tx, usbnet_start (if_start) will pull entries out of the
  *     transmit queue and use the transmit prepare callback (uno_tx_prepare)
  *     for the given mbuf.  the usb callback will use usbnet_txeof() for
  *     the transmit completion function (internal to usbnet)
  *   - there is special interrupt pipe handling
  * - timer/tick:
  *   - the uno_tick callback will be called once a second if present.
  */
 #include <sys/device.h>
 #include <sys/mbuf.h>
 #include <sys/rndsource.h>
 #include <sys/mutex.h>
 #include <sys/module.h>
 #include <net/bpf.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <net/if_dl.h>
 #include <net/if_ether.h>
 #include <net/if_media.h>
 #include <dev/mii/mii.h>
 #include <dev/mii/miivar.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdivar.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/usb/usbdevs.h>
 /*
  * Per-transfer data.
+ *
  * Front-end must set un_rx_list_cnt and un_tx_list_cnt before
  * calling usbnet_attach(), and then call usbnet_rx_tx_init()
  * which will allocate the chain arrays, and must be NULL to
  * indicate the first call.
  */
 struct usbnet;
 struct usbnet_chain {
 	struct usbnet		*unc_un;
 	struct usbd_xfer	*unc_xfer;
 	uint8_t			*unc_buf;
 };
 /*
  * Extend this as necessary.  axe(4) claims to want 6 total, but
  * does not implement them.
  */
 enum usbnet_ep {
 	USBNET_ENDPT_RX,
 	USBNET_ENDPT_TX,
 	USBNET_ENDPT_INTR,
 	USBNET_ENDPT_MAX,
 };
 /* Interface stop callback. */
 typedef void (*usbnet_stop_cb)(struct ifnet *, int);
 /* Interface ioctl callback. */
 typedef int (*usbnet_ioctl_cb)(struct ifnet *, u_long, void *);
 /* Initialise device callback. */
 typedef int (*usbnet_init_cb)(struct ifnet *);
 /* MII read register callback. */
 typedef int (*usbnet_mii_read_reg_cb)(struct usbnet *, int reg,
 				      int phy, uint16_t *val);
 /* MII write register callback. */
 typedef int (*usbnet_mii_write_reg_cb)(struct usbnet *, int reg,
 				       int phy, uint16_t val);
 /* MII status change callback. */
 typedef void (*usbnet_mii_statchg_cb)(struct ifnet *);
 /* Prepare packet to send callback, returns length. */
 typedef unsigned (*usbnet_tx_prepare_cb)(struct usbnet *, struct mbuf *,
 					 struct usbnet_chain *);
 /* Receive some packets callback. */
 typedef void (*usbnet_rx_loop_cb)(struct usbnet *, struct usbnet_chain *,
 				  uint32_t);
 /* Tick callback. */
 typedef void (*usbnet_tick_cb)(struct usbnet *);
 /* Interrupt pipe callback. */
 typedef void (*usbnet_intr_cb)(struct usbnet *, usbd_status);
 /*
  * LOCKING
  * =======
+ *
  * The following annotations indicate which locks are held when
  * usbnet_ops functions are invoked:
+ *
  * I -> IFNET_LOCK (if_ioctl_lock)
  * C -> CORE_LOCK (usbnet core_lock)
  * T -> TX_LOCK (usbnet tx_lock)
  * R -> RX_LOCK (usbnet rx_lock)
  * n -> no locks held
+ *
  * Note that when CORE_LOCK is held, IFNET_LOCK may or may not also
  * be held.
+ *
  * Note that the IFNET_LOCK **may not be held** for some ioctl
  * operations (add/delete multicast addresses, for example).
+ *
  * Busy reference counts are maintained across calls to: uno_stop,
  * uno_read_reg, uno_write_reg, uno_statchg, and uno_tick.
  */
 struct usbnet_ops {
 	usbnet_stop_cb		uno_stop;		/* C */
 	usbnet_ioctl_cb		uno_ioctl;		/* I (maybe) */
 	usbnet_ioctl_cb		uno_override_ioctl;	/* I (maybe) */
 	usbnet_init_cb		uno_init;		/* I */
 	usbnet_mii_read_reg_cb	uno_read_reg;		/* C */
 	usbnet_mii_write_reg_cb uno_write_reg;		/* C */
 	usbnet_mii_statchg_cb	uno_statchg;		/* C */
 	usbnet_tx_prepare_cb	uno_tx_prepare;		/* T */
 	usbnet_rx_loop_cb	uno_rx_loop;		/* R */
 	usbnet_tick_cb		uno_tick;		/* n */
 	usbnet_intr_cb		uno_intr;		/* n */
 };
 /*
  * USB interrupt pipe support.  Use this if usbd_open_pipe_intr() should
  * be used for the interrupt pipe.
  */
 struct usbnet_intr {
 	/*
 	 * Point un_intr to this structure to use usbd_open_pipe_intr() not
 	 * usbd_open_pipe() for USBNET_ENDPT_INTR, with this buffer, size,
 	 * and interval.
 	 */
 	void			*uni_buf;
 	unsigned		uni_bufsz;
 	unsigned		uni_interval;
 };
 /*
  * Structure to setup MII.  Use the USBNET_MII_DECL_DEFAULT() macro for
  * sane default.  Pass a copy to usbnet_attach_ifp().  Not used
  * after the usbnet_attach_ifp() function returns.
  */
 struct usbnet_mii {
 	int			un_mii_flags;
 	int			un_mii_capmask;
 	int			un_mii_phyloc;
 	int			un_mii_offset;
 };
 #define USBNET_MII_DECL(name, capmask, loc, off, flags)	\
 	struct usbnet_mii name = {			\
 		.un_mii_capmask = capmask,		\
 		.un_mii_phyloc = loc,			\
 		.un_mii_offset = off,			\
 		.un_mii_flags = flags,			\
+	}
 #define USBNET_MII_DECL_DEFAULT(name)				\
 	USBNET_MII_DECL(name, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0)
 /*
  * Generic USB ethernet structure.  Use this as ifp->if_softc and set as
  * device_private() in attach unless already using struct usbnet here.
+ *
  * Devices without MII should call usbnet_attach_ifp() with have_mii set
  * to true, and should ensure that the un_statchg_cb callback sets the
  * un_link member.  Devices without MII have this forced to true.
  */
 struct usbnet_private;
 struct usbnet {
 	/*
 	 * This section should be filled in before calling
 	 * usbnet_attach().
 	 */
 	void			*un_sc;			/* real softc */
 	device_t		un_dev;
 	struct usbd_interface	*un_iface;
 	struct usbd_device	*un_udev;
 	const struct usbnet_ops	*un_ops;
 	struct usbnet_intr	*un_intr;
 	/* Inputs for rx/tx chain control. */
 	unsigned		un_rx_bufsz;
 	unsigned		un_tx_bufsz;
 	unsigned		un_rx_list_cnt;
 	unsigned		un_tx_list_cnt;
 	int			un_rx_xfer_flags;
 	int			un_tx_xfer_flags;
 	/*
 	 * This section should be filled in before calling
 	 * usbnet_attach_ifp().
+	 *
 	 * XXX This should be of type "uByte".  enum usbnet_ep
 	 * is the index.  Fix this in a kernel version bump.
 	 */
 	enum usbnet_ep		un_ed[USBNET_ENDPT_MAX];
 	/* MII specific. Not used without MII. */
 	int			un_phyno;
 	/* Ethernet specific. All zeroes indicates non-Ethernet. */
 	uint8_t			un_eaddr[ETHER_ADDR_LEN];
 	/*
 	 * This section is for driver to use, not touched by usbnet.
 	 */
 	unsigned		un_flags;
 	/*
 	 * This section is private to usbnet. Don't touch.
 	 */
 	struct usbnet_private	*un_pri;
 };
 /* Various accessors. */
 void usbnet_set_link(struct usbnet *, bool);
 void usbnet_set_dying(struct usbnet *, bool);
 struct ifnet *usbnet_ifp(struct usbnet *);
 struct ethercom *usbnet_ec(struct usbnet *);
 struct mii_data *usbnet_mii(struct usbnet *);
 krndsource_t *usbnet_rndsrc(struct usbnet *);
 void *usbnet_softc(struct usbnet *);
 bool usbnet_havelink(struct usbnet *);
 bool usbnet_isdying(struct usbnet *);
 /*
  * Locking.  Note that the isowned() are implemented here so that
  * empty-KASSERT() causes them to be elided for non-DIAG builds.
  */
 void	usbnet_lock_core(struct usbnet *);
 void	usbnet_unlock_core(struct usbnet *);
 kmutex_t *usbnet_mutex_core(struct usbnet *);
 static __inline__ void
 usbnet_isowned_core(struct usbnet *un)
+{
 	KASSERT(mutex_owned(usbnet_mutex_core(un)));
+}
 void	usbnet_busy(struct usbnet *);
 void	usbnet_unbusy(struct usbnet *);
 void	usbnet_lock_rx(struct usbnet *);
 void	usbnet_unlock_rx(struct usbnet *);
 kmutex_t *usbnet_mutex_rx(struct usbnet *);
 static __inline__ void
 usbnet_isowned_rx(struct usbnet *un)
+{
 	KASSERT(mutex_owned(usbnet_mutex_rx(un)));
+}
 void	usbnet_lock_tx(struct usbnet *);
 void	usbnet_unlock_tx(struct usbnet *);
 kmutex_t *usbnet_mutex_tx(struct usbnet *);
 static __inline__ void
 usbnet_isowned_tx(struct usbnet *un)
+{
 	KASSERT(mutex_owned(usbnet_mutex_tx(un)));
+}
 /*
  * Endpoint / rx/tx chain management:
+ *
  * usbnet_attach() initialises usbnet and allocates rx and tx chains
  * usbnet_init_rx_tx() open pipes, initialises the rx/tx chains for use
  * usbnet_stop() stops pipes, cleans (not frees) rx/tx chains, locked
  *               version assumes un_lock is held
  * usbnet_detach() frees the rx/tx chains
+ *
  * Setup un_ed[] with valid end points before calling usbnet_attach().
  * Call usbnet_init_rx_tx() to initialise pipes, which will be open
  * upon success.
  */
 int	usbnet_init_rx_tx(struct usbnet * const);
 /* MII. */
 int	usbnet_mii_readreg(device_t, int, int, uint16_t *);
 int	usbnet_mii_writereg(device_t, int, int, uint16_t);
 void	usbnet_mii_statchg(struct ifnet *);
 /* interrupt handling */
 void	usbnet_enqueue(struct usbnet * const, uint8_t *, size_t, int,
 		       uint32_t, int);
 void	usbnet_input(struct usbnet * const, uint8_t *, size_t);
 /* autoconf */
 void	usbnet_attach(struct usbnet *un, const char *);
 void	usbnet_attach_ifp(struct usbnet *, unsigned, unsigned,
 			  const struct usbnet_mii *);
 int	usbnet_detach(device_t, int);
 int	usbnet_activate(device_t, devact_t);
 /* stop backend */
 void	usbnet_stop(struct usbnet *, struct ifnet *, int);
 /* module hook up */
 #ifdef _MODULE
 #define USBNET_INIT(name)						\
 	error = config_init_component(cfdriver_ioconf_##name,		\
 	    cfattach_ioconf_##name, cfdata_ioconf_##name);
 #define USBNET_FINI(name)						\
 	error = config_fini_component(cfdriver_ioconf_##name,		\
 	    cfattach_ioconf_##name, cfdata_ioconf_##name);
 #else
 #define USBNET_INIT(name)
 #define USBNET_FINI(name)
 #endif
 #define USBNET_MODULE(name)						\
+									\
 MODULE(MODULE_CLASS_DRIVER, if_##name, "usbnet");			\
+									\
 static int								\
 if_##name##_modcmd(modcmd_t cmd, void *aux)				\
 {									\
 	int error = 0;							\
+									\
 	switch (cmd) {							\
 	case MODULE_CMD_INIT:						\
 		USBNET_INIT(name)					\
 		return error;						\
 	case MODULE_CMD_FINI:						\
 		USBNET_FINI(name)					\
 		return error;						\
 	default:							\
 		return ENOTTY;						\
 	}								\
+}
 #endif /* _DEV_USB_USBNET_H */