 @@ -1,1323 +1,1319 @@
-/*	$NetBSD: if_url.c,v 1.48.4.11 2016/12/05 10:55:18 skrll Exp $	*/
+/*	$NetBSD: if_url.c,v 1.48.4.12 2017/01/26 12:40:16 skrll 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.48.4.11 2016/12/05 10:55:18 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_url.c,v 1.48.4.12 2017/01/26 12:40:16 skrll Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/rwlock.h>
 #include <sys/mbuf.h>
 #include <sys/kernel.h>
 #include <sys/socket.h>
 #include <sys/device.h>
 #include <sys/rndsource.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <net/if_dl.h>
 #include <net/if_media.h>
 #include <net/bpf.h>
 #include <net/if_ether.h>
 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/if_inarp.h>
 #endif
 #include <dev/mii/mii.h>
 #include <dev/mii/miivar.h>
 #include <dev/mii/urlphyreg.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/if_urlreg.h>
 /* Function declarations */
 int	url_match(device_t, cfdata_t, void *);
 void	url_attach(device_t, device_t, void *);
 int	url_detach(device_t, int);
 int	url_activate(device_t, enum devact);
 extern struct cfdriver url_cd;
 CFATTACH_DECL_NEW(url, sizeof(struct url_softc), url_match, url_attach,
     url_detach, url_activate);
 Static int url_openpipes(struct url_softc *);
 Static int url_rx_list_init(struct url_softc *);
 Static int url_tx_list_init(struct url_softc *);
 Static int url_newbuf(struct url_softc *, struct url_chain *, struct mbuf *);
 Static void url_start(struct ifnet *);
 Static int url_send(struct url_softc *, struct mbuf *, int);
 Static void url_txeof(struct usbd_xfer *, void *, usbd_status);
 Static void url_rxeof(struct usbd_xfer *, void *, usbd_status);
 Static void url_tick(void *);
 Static void url_tick_task(void *);
 Static int url_ioctl(struct ifnet *, u_long, void *);
 Static void url_stop_task(struct url_softc *);
 Static void url_stop(struct ifnet *, int);
 Static void url_watchdog(struct ifnet *);
 Static int url_ifmedia_change(struct ifnet *);
 Static void url_ifmedia_status(struct ifnet *, struct ifmediareq *);
 Static void url_lock_mii(struct url_softc *);
 Static void url_unlock_mii(struct url_softc *);
 Static int url_int_miibus_readreg(device_t, int, int);
 Static void url_int_miibus_writereg(device_t, int, int, int);
 Static void url_miibus_statchg(struct ifnet *);
 Static int url_init(struct ifnet *);
 Static void url_setmulti(struct url_softc *);
 Static void url_reset(struct url_softc *);
 Static int url_csr_read_1(struct url_softc *, int);
 Static int url_csr_read_2(struct url_softc *, int);
 Static int url_csr_write_1(struct url_softc *, int, int);
 Static int url_csr_write_2(struct url_softc *, int, int);
 Static int url_csr_write_4(struct url_softc *, int, int);
 Static int url_mem(struct url_softc *, int, int, void *, int);
 /* 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(sc, reg, x)	\
 	url_csr_write_1(sc, reg, url_csr_read_1(sc, reg) | (x))
 #define	URL_SETBIT2(sc, reg, x)	\
 	url_csr_write_2(sc, reg, url_csr_read_2(sc, reg) | (x))
 #define	URL_CLRBIT(sc, reg, x)	\
 	url_csr_write_1(sc, reg, url_csr_read_1(sc, reg) & ~(x))
 #define	URL_CLRBIT2(sc, reg, x)	\
 	url_csr_write_2(sc, reg, url_csr_read_2(sc, 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 */
 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 */
 void
 url_attach(device_t parent, device_t self, void *aux)
+{
 	struct url_softc *sc = 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;
 	struct ifnet *ifp;
 	struct mii_data *mii;
 	u_char eaddr[ETHER_ADDR_LEN];
-	int i, s;
+	int i;
 	sc->sc_dev = self;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(dev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	/* 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));
 		goto bad;
+	}
 	usb_init_task(&sc->sc_tick_task, url_tick_task, sc, 0);
 	rw_init(&sc->sc_mii_rwlock);
 	usb_init_task(&sc->sc_stop_task, (void (*)(void *))url_stop_task, sc, 0);
 	/* 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));
 		goto bad;
+	}
 	sc->sc_udev = dev;
 	sc->sc_ctl_iface = iface;
 	sc->sc_flags = url_lookup(uaa->uaa_vendor, uaa->uaa_product)->url_flags;
 	/* get interface descriptor */
 	id = usbd_get_interface_descriptor(sc->sc_ctl_iface);
 	/* find endpoints */
 	sc->sc_bulkin_no = sc->sc_bulkout_no = sc->sc_intrin_no = -1;
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(sc->sc_ctl_iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self,
 			    "couldn't get endpoint %d\n", i);
 			goto bad;
+		}
 		if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
 		    UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
 			sc->sc_bulkin_no = ed->bEndpointAddress; /* RX */
 		else if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
 			 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT)
 			sc->sc_bulkout_no = ed->bEndpointAddress; /* TX */
 		else if ((ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT &&
 			 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
 			sc->sc_intrin_no = ed->bEndpointAddress; /* Status */
+	}
 	if (sc->sc_bulkin_no == -1 || sc->sc_bulkout_no == -1 ||
 	    sc->sc_intrin_no == -1) {
 		aprint_error_dev(self, "missing endpoint\n");
 		goto bad;
+	}
 	s = splnet();
 	/* reset the adapter */
 	url_reset(sc);
 	/* Get Ethernet Address */
 	err = url_mem(sc, URL_CMD_READMEM, URL_IDR0, (void *)eaddr,
 		      ETHER_ADDR_LEN);
 	if (err) {
 		aprint_error_dev(self, "read MAC address failed\n");
 		splx(s);
 		goto bad;
+	}
 	/* Print Ethernet Address */
 	aprint_normal_dev(self, "Ethernet address %s\n", ether_sprintf(eaddr));
 	/* initialize interface information */
 	ifp = GET_IFP(sc);
 	ifp->if_softc = sc;
 	ifp->if_mtu = ETHERMTU;
 	strncpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 	ifp->if_start = url_start;
 	ifp->if_ioctl = url_ioctl;
 	ifp->if_watchdog = url_watchdog;
 	ifp->if_init = url_init;
 	ifp->if_stop = url_stop;
 	IFQ_SET_READY(&ifp->if_snd);
 	/*
 	 * Do ifmedia setup.
 	 */
 	mii = &sc->sc_mii;
 	mii->mii_ifp = ifp;
 	mii->mii_readreg = url_int_miibus_readreg;
 	mii->mii_writereg = url_int_miibus_writereg;
 #if 0
 	if (sc->sc_flags & URL_EXT_PHY) {
 		mii->mii_readreg = url_ext_miibus_readreg;
 		mii->mii_writereg = url_ext_miibus_writereg;
+	}
 #endif
 	mii->mii_statchg = url_miibus_statchg;
 	mii->mii_flags = MIIF_AUTOTSLEEP;
 	sc->sc_ec.ec_mii = mii;
 	ifmedia_init(&mii->mii_media, 0,
 		     url_ifmedia_change, url_ifmedia_status);
 	mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
 	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);
 	/* attach the interface */
 	if_attach(ifp);
 	ether_ifattach(ifp, eaddr);
 	rnd_attach_source(&sc->rnd_source, device_xname(self),
 	    RND_TYPE_NET, RND_FLAG_DEFAULT);
 	callout_init(&sc->sc_stat_ch, 0);
 	sc->sc_attached = 1;
 	splx(s);
 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, dev, sc->sc_dev);
 	return;
  bad:
 	sc->sc_dying = 1;
 	return;
+}
 /* detach */
 int
 url_detach(device_t self, int flags)
+{
 	struct url_softc *sc = device_private(self);
 	struct ifnet *ifp = GET_IFP(sc);
 	int s;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	/* Detached before attached finished */
 	if (!sc->sc_attached)
 		return 0;
 	callout_stop(&sc->sc_stat_ch);
 	/* Remove any pending tasks */
 	usb_rem_task(sc->sc_udev, &sc->sc_tick_task);
 	usb_rem_task(sc->sc_udev, &sc->sc_stop_task);
 	s = splusb();
 	if (--sc->sc_refcnt >= 0) {
 		/* Wait for processes to go away */
 		usb_detach_waitold(sc->sc_dev);
+	}
 	if (ifp->if_flags & IFF_RUNNING)
 		url_stop(GET_IFP(sc), 1);
 	rnd_detach_source(&sc->rnd_source);
 	mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
 	ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
 	ether_ifdetach(ifp);
 	if_detach(ifp);
 #ifdef DIAGNOSTIC
 	if (sc->sc_pipe_tx != NULL)
 		aprint_debug_dev(self, "detach has active tx endpoint.\n");
 	if (sc->sc_pipe_rx != NULL)
 		aprint_debug_dev(self, "detach has active rx endpoint.\n");
 	if (sc->sc_pipe_intr != NULL)
 		aprint_debug_dev(self, "detach has active intr endpoint.\n");
 #endif
 	sc->sc_attached = 0;
 	splx(s);
 	rw_destroy(&sc->sc_mii_rwlock);
 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
 	return 0;
+}
 /* read/write memory */
 Static int
 url_mem(struct url_softc *sc, int cmd, int offset, void *buf, int len)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	if (sc == NULL)
 		return 0;
 	DPRINTFN(0x200,
 		("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		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);
 	sc->sc_refcnt++;
 	err = usbd_do_request(sc->sc_udev, &req, buf);
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	if (err) {
 		DPRINTF(("%s: url_mem(): %s failed. off=%04x, err=%d\n",
 			 device_xname(sc->sc_dev),
 			 cmd == URL_CMD_READMEM ? "read" : "write",
 			 offset, err));
+	}
 	return err;
+}
 /* read 1byte from register */
 Static int
 url_csr_read_1(struct url_softc *sc, int reg)
+{
 	uint8_t val = 0;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return 0;
 	return url_mem(sc, URL_CMD_READMEM, reg, &val, 1) ? 0 : val;
+}
 /* read 2bytes from register */
 Static int
 url_csr_read_2(struct url_softc *sc, int reg)
+{
 	uWord val;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return 0;
 	USETW(val, 0);
 	return url_mem(sc, URL_CMD_READMEM, reg, &val, 2) ? 0 : UGETW(val);
+}
 /* write 1byte to register */
 Static int
 url_csr_write_1(struct url_softc *sc, int reg, int aval)
+{
 	uint8_t val = aval;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return 0;
 	return url_mem(sc, URL_CMD_WRITEMEM, reg, &val, 1) ? -1 : 0;
+}
 /* write 2bytes to register */
 Static int
 url_csr_write_2(struct url_softc *sc, int reg, int aval)
+{
 	uWord val;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	USETW(val, aval);
 	if (sc->sc_dying)
 		return 0;
 	return url_mem(sc, URL_CMD_WRITEMEM, reg, &val, 2) ? -1 : 0;
+}
 /* write 4bytes to register */
 Static int
 url_csr_write_4(struct url_softc *sc, int reg, int aval)
+{
 	uDWord val;
 	DPRINTFN(0x100,
 		 ("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	USETDW(val, aval);
 	if (sc->sc_dying)
 		return 0;
 	return url_mem(sc, URL_CMD_WRITEMEM, reg, &val, 4) ? -1 : 0;
+}
 Static int
 url_init(struct ifnet *ifp)
+{
 	struct url_softc *sc = ifp->if_softc;
 	struct mii_data *mii = GET_MII(sc);
 	const u_char *eaddr;
 	int i, rc, s;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return EIO;
 	s = splnet();
 	/* Cancel pending I/O and free all TX/RX buffers */
 	url_stop(ifp, 1);
 	eaddr = CLLADDR(ifp->if_sadl);
 	for (i = 0; i < ETHER_ADDR_LEN; i++)
 		url_csr_write_1(sc, URL_IDR0 + i, eaddr[i]);
 	/* Init transmission control register */
 	URL_CLRBIT(sc, URL_TCR,
 		   URL_TCR_TXRR1 | URL_TCR_TXRR0 |
 		   URL_TCR_IFG1 | URL_TCR_IFG0 |
 		   URL_TCR_NOCRC);
 	/* Init receive control register */
 	URL_SETBIT2(sc, URL_RCR, URL_RCR_TAIL | URL_RCR_AD);
 	if (ifp->if_flags & IFF_BROADCAST)
 		URL_SETBIT2(sc, URL_RCR, URL_RCR_AB);
 	else
 		URL_CLRBIT2(sc, URL_RCR, URL_RCR_AB);
 	/* If we want promiscuous mode, accept all physical frames. */
 	if (ifp->if_flags & IFF_PROMISC)
 		URL_SETBIT2(sc, URL_RCR, URL_RCR_AAM|URL_RCR_AAP);
 	else
 		URL_CLRBIT2(sc, URL_RCR, URL_RCR_AAM|URL_RCR_AAP);
 	/* Load the multicast filter */
 	url_setmulti(sc);
 	/* Enable RX and TX */
 	URL_SETBIT(sc, URL_CR, URL_CR_TE | URL_CR_RE);
 	if ((rc = mii_mediachg(mii)) == ENXIO)
 		rc = 0;
 	else if (rc != 0)
 		goto out;
 	if (sc->sc_pipe_tx == NULL || sc->sc_pipe_rx == NULL) {
 		if (url_openpipes(sc)) {
 			splx(s);
 			return EIO;
+		}
+	}
 	/* Initialize transmit ring */
 	if (url_tx_list_init(sc)) {
 		printf("%s: tx list init failed\n", device_xname(sc->sc_dev));
 		splx(s);
 		return EIO;
+	}
 	/* Initialize receive ring */
 	if (url_rx_list_init(sc)) {
 		printf("%s: rx list init failed\n", device_xname(sc->sc_dev));
 		splx(s);
 		return EIO;
+	}
 	/* Start up the receive pipe. */
 	for (i = 0; i < URL_RX_LIST_CNT; i++) {
 		struct url_chain *c = &sc->sc_cdata.url_rx_chain[i];
 		usbd_setup_xfer(c->url_xfer, c, c->url_buf, URL_BUFSZ,
 		    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, url_rxeof);
 		(void)usbd_transfer(c->url_xfer);
 		DPRINTF(("%s: %s: start read\n", device_xname(sc->sc_dev),
 			 __func__));
+	}
 	ifp->if_flags |= IFF_RUNNING;
 	ifp->if_flags &= ~IFF_OACTIVE;
 	callout_reset(&sc->sc_stat_ch, hz, url_tick, sc);
 out:
 	splx(s);
 	return rc;
+}
 Static void
 url_reset(struct url_softc *sc)
+{
 	int i;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return;
 	URL_SETBIT(sc, URL_CR, URL_CR_SOFT_RST);
 	for (i = 0; i < URL_TX_TIMEOUT; i++) {
 		if (!(url_csr_read_1(sc, URL_CR) & URL_CR_SOFT_RST))
 			break;
 		delay(10);	/* XXX */
+	}
 	delay(10000);		/* XXX */
+}
 int
 url_activate(device_t self, enum devact act)
+{
 	struct url_softc *sc = device_private(self);
 	DPRINTF(("%s: %s: enter, act=%d\n", device_xname(sc->sc_dev),
 		 __func__, act));
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		if_deactivate(&sc->sc_ec.ec_if);
 		sc->sc_dying = 1;
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 #define url_calchash(addr) (ether_crc32_be((addr), ETHER_ADDR_LEN) >> 26)
 Static void
 url_setmulti(struct url_softc *sc)
+{
 	struct ifnet *ifp;
 	struct ether_multi *enm;
 	struct ether_multistep step;
 	uint32_t hashes[2] = { 0, 0 };
 	int h = 0;
 	int mcnt = 0;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return;
 	ifp = GET_IFP(sc);
 	if (ifp->if_flags & IFF_PROMISC) {
 		URL_SETBIT2(sc, URL_RCR, URL_RCR_AAM|URL_RCR_AAP);
 		return;
 	} else if (ifp->if_flags & IFF_ALLMULTI) {
 	allmulti:
 		ifp->if_flags |= IFF_ALLMULTI;
 		URL_SETBIT2(sc, URL_RCR, URL_RCR_AAM);
 		URL_CLRBIT2(sc, URL_RCR, URL_RCR_AAP);
 		return;
+	}
 	/* first, zot all the existing hash bits */
 	url_csr_write_4(sc, URL_MAR0, 0);
 	url_csr_write_4(sc, URL_MAR4, 0);
 	/* now program new ones */
 	ETHER_FIRST_MULTI(step, &sc->sc_ec, enm);
 	while (enm != NULL) {
 		if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
 			   ETHER_ADDR_LEN) != 0)
 			goto allmulti;
 		h = url_calchash(enm->enm_addrlo);
 		if (h < 32)
 			hashes[0] |= (1 << h);
 		else
 			hashes[1] |= (1 << (h -32));
 		mcnt++;
 		ETHER_NEXT_MULTI(step, enm);
+	}
 	ifp->if_flags &= ~IFF_ALLMULTI;
 	URL_CLRBIT2(sc, URL_RCR, URL_RCR_AAM|URL_RCR_AAP);
 	if (mcnt){
 		URL_SETBIT2(sc, URL_RCR, URL_RCR_AM);
 	} else {
 		URL_CLRBIT2(sc, URL_RCR, URL_RCR_AM);
+	}
 	url_csr_write_4(sc, URL_MAR0, hashes[0]);
 	url_csr_write_4(sc, URL_MAR4, hashes[1]);
+}
 Static int
 url_openpipes(struct url_softc *sc)
+{
 	usbd_status err;
 	int error = 0;
 	if (sc->sc_dying)
 		return EIO;
 	sc->sc_refcnt++;
 	/* Open RX pipe */
 	err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkin_no,
 			     USBD_EXCLUSIVE_USE, &sc->sc_pipe_rx);
 	if (err) {
 		printf("%s: open rx pipe failed: %s\n",
 		       device_xname(sc->sc_dev), usbd_errstr(err));
 		error = EIO;
 		goto done;
+	}
 	/* Open TX pipe */
 	err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkout_no,
 			     USBD_EXCLUSIVE_USE, &sc->sc_pipe_tx);
 	if (err) {
 		printf("%s: open tx pipe failed: %s\n",
 		       device_xname(sc->sc_dev), usbd_errstr(err));
 		error = EIO;
 		goto done;
+	}
 #if 0
 	/* XXX: interrupt endpoint is not yet supported */
 	/* Open Interrupt pipe */
 	err = usbd_open_pipe_intr(sc->sc_ctl_iface, sc->sc_intrin_no,
 				  USBD_EXCLUSIVE_USE, &sc->sc_pipe_intr, sc,
 				  &sc->sc_cdata.url_ibuf, URL_INTR_PKGLEN,
 				  url_intr, USBD_DEFAULT_INTERVAL);
 	if (err) {
 		printf("%s: open intr pipe failed: %s\n",
 		       device_xname(sc->sc_dev), usbd_errstr(err));
 		error = EIO;
 		goto done;
+	}
 #endif
  done:
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	return error;
+}
 Static int
 url_newbuf(struct url_softc *sc, struct url_chain *c, struct mbuf *m)
+{
 	struct mbuf *m_new = NULL;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (m == NULL) {
 		MGETHDR(m_new, M_DONTWAIT, MT_DATA);
 		if (m_new == NULL) {
 			printf("%s: no memory for rx list "
 			       "-- packet dropped!\n", device_xname(sc->sc_dev));
 			return ENOBUFS;
+		}
 		MCLGET(m_new, M_DONTWAIT);
 		if (!(m_new->m_flags & M_EXT)) {
 			printf("%s: no memory for rx list "
 			       "-- packet dropped!\n", device_xname(sc->sc_dev));
 			m_freem(m_new);
 			return ENOBUFS;
+		}
 		m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 	} else {
 		m_new = m;
 		m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 		m_new->m_data = m_new->m_ext.ext_buf;
+	}
 	m_adj(m_new, ETHER_ALIGN);
 	c->url_mbuf = m_new;
 	return 0;
+}
 Static int
 url_rx_list_init(struct url_softc *sc)
+{
 	struct url_cdata *cd;
 	struct url_chain *c;
 	int i;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	cd = &sc->sc_cdata;
 	for (i = 0; i < URL_RX_LIST_CNT; i++) {
 		c = &cd->url_rx_chain[i];
 		c->url_sc = sc;
 		c->url_idx = i;
 		if (url_newbuf(sc, c, NULL) == ENOBUFS)
 			return ENOBUFS;
 		if (c->url_xfer == NULL) {
 			int error = usbd_create_xfer(sc->sc_pipe_rx, URL_BUFSZ,
 			    USBD_SHORT_XFER_OK, 0, &c->url_xfer);
 			if (error)
 				return error;
 			c->url_buf = usbd_get_buffer(c->url_xfer);
+		}
+	}
 	return 0;
+}
 Static int
 url_tx_list_init(struct url_softc *sc)
+{
 	struct url_cdata *cd;
 	struct url_chain *c;
 	int i;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	cd = &sc->sc_cdata;
 	for (i = 0; i < URL_TX_LIST_CNT; i++) {
 		c = &cd->url_tx_chain[i];
 		c->url_sc = sc;
 		c->url_idx = i;
 		c->url_mbuf = NULL;
 		if (c->url_xfer == NULL) {
 			int error = usbd_create_xfer(sc->sc_pipe_tx, URL_BUFSZ,
 			    USBD_FORCE_SHORT_XFER, 0, &c->url_xfer);
 			if (error)
 				return error;
 			c->url_buf = usbd_get_buffer(c->url_xfer);
+		}
+	}
 	return 0;
+}
 Static void
 url_start(struct ifnet *ifp)
+{
 	struct url_softc *sc = ifp->if_softc;
 	struct mbuf *m_head = NULL;
 	DPRINTF(("%s: %s: enter, link=%d\n", device_xname(sc->sc_dev),
 		 __func__, sc->sc_link));
 	if (sc->sc_dying)
 		return;
 	if (!sc->sc_link)
 		return;
 	if (ifp->if_flags & IFF_OACTIVE)
 		return;
 	IFQ_POLL(&ifp->if_snd, m_head);
 	if (m_head == NULL)
 		return;
 	if (url_send(sc, m_head, 0)) {
 		ifp->if_flags |= IFF_OACTIVE;
 		return;
+	}
 	IFQ_DEQUEUE(&ifp->if_snd, m_head);
 	bpf_mtap(ifp, m_head);
 	ifp->if_flags |= IFF_OACTIVE;
 	/* Set a timeout in case the chip goes out to lunch. */
 	ifp->if_timer = 5;
+}
 Static int
 url_send(struct url_softc *sc, struct mbuf *m, int idx)
+{
 	int total_len;
 	struct url_chain *c;
 	usbd_status err;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev),__func__));
 	c = &sc->sc_cdata.url_tx_chain[idx];
 	/* Copy the mbuf data into a contiguous buffer */
 	m_copydata(m, 0, m->m_pkthdr.len, c->url_buf);
 	c->url_mbuf = m;
 	total_len = m->m_pkthdr.len;
 	if (total_len < URL_MIN_FRAME_LEN) {
 		memset(c->url_buf + total_len, 0,
 		    URL_MIN_FRAME_LEN - total_len);
 		total_len = URL_MIN_FRAME_LEN;
+	}
 	usbd_setup_xfer(c->url_xfer,c, c->url_buf, total_len,
 	    USBD_FORCE_SHORT_XFER, URL_TX_TIMEOUT, url_txeof);
 	/* Transmit */
 	sc->sc_refcnt++;
 	err = usbd_transfer(c->url_xfer);
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	if (err != USBD_IN_PROGRESS) {
 		printf("%s: url_send error=%s\n", device_xname(sc->sc_dev),
 		       usbd_errstr(err));
 		/* Stop the interface */
 		usb_add_task(sc->sc_udev, &sc->sc_stop_task,
 		    USB_TASKQ_DRIVER);
 		return EIO;
+	}
 	DPRINTF(("%s: %s: send %d bytes\n", device_xname(sc->sc_dev),
 		 __func__, total_len));
 	sc->sc_cdata.url_tx_cnt++;
 	return 0;
+}
 Static void
 url_txeof(struct usbd_xfer *xfer, void *priv,
     usbd_status status)
+{
 	struct url_chain *c = priv;
 	struct url_softc *sc = c->url_sc;
 	struct ifnet *ifp = GET_IFP(sc);
 	int s;
 	if (sc->sc_dying)
 		return;
 	s = splnet();
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	ifp->if_timer = 0;
 	ifp->if_flags &= ~IFF_OACTIVE;
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 			splx(s);
 			return;
+		}
 		ifp->if_oerrors++;
 		printf("%s: usb error on tx: %s\n", device_xname(sc->sc_dev),
 		       usbd_errstr(status));
 		if (status == USBD_STALLED) {
 			sc->sc_refcnt++;
 			usbd_clear_endpoint_stall_async(sc->sc_pipe_tx);
 			if (--sc->sc_refcnt < 0)
 				usb_detach_wakeupold(sc->sc_dev);
+		}
 		splx(s);
 		return;
+	}
 	ifp->if_opackets++;
 	m_freem(c->url_mbuf);
 	c->url_mbuf = NULL;
 	if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
 		url_start(ifp);
 	splx(s);
+}
 Static void
 url_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	struct url_chain *c = priv;
 	struct url_softc *sc = c->url_sc;
 	struct ifnet *ifp = GET_IFP(sc);
 	struct mbuf *m;
 	uint32_t total_len;
 	url_rxhdr_t rxhdr;
 	int s;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev),__func__));
 	if (sc->sc_dying)
 		return;
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
 			return;
 		sc->sc_rx_errs++;
 		if (usbd_ratecheck(&sc->sc_rx_notice)) {
 			printf("%s: %u usb errors on rx: %s\n",
 			       device_xname(sc->sc_dev), sc->sc_rx_errs,
 			       usbd_errstr(status));
 			sc->sc_rx_errs = 0;
+		}
 		if (status == USBD_STALLED) {
 			sc->sc_refcnt++;
 			usbd_clear_endpoint_stall_async(sc->sc_pipe_rx);
 			if (--sc->sc_refcnt < 0)
 				usb_detach_wakeupold(sc->sc_dev);
+		}
 		goto done;
+	}
 	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
 	memcpy(mtod(c->url_mbuf, char *), c->url_buf, total_len);
 	if (total_len <= ETHER_CRC_LEN) {
 		ifp->if_ierrors++;
 		goto done;
+	}
 	memcpy(&rxhdr, c->url_buf + total_len - ETHER_CRC_LEN, sizeof(rxhdr));
 	DPRINTF(("%s: RX Status: %dbytes%s%s%s%s packets\n",
 		 device_xname(sc->sc_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) {
 		ifp->if_ierrors++;
 		goto done;
+	}
 	ifp->if_ipackets++;
 	total_len -= ETHER_CRC_LEN;
 	m = c->url_mbuf;
 	m->m_pkthdr.len = m->m_len = total_len;
 	m_set_rcvif(m, ifp);
 	s = splnet();
 	if (url_newbuf(sc, c, NULL) == ENOBUFS) {
 		ifp->if_ierrors++;
 		goto done1;
+	}
 	bpf_mtap(ifp, m);
 	DPRINTF(("%s: %s: deliver %d\n", device_xname(sc->sc_dev),
 		 __func__, m->m_len));
 	if_percpuq_enqueue((ifp)->if_percpuq, (m));
  done1:
 	splx(s);
  done:
 	/* Setup new transfer */
 	usbd_setup_xfer(xfer, c, c->url_buf, URL_BUFSZ, USBD_SHORT_XFER_OK,
 	    USBD_NO_TIMEOUT, url_rxeof);
 	sc->sc_refcnt++;
 	usbd_transfer(xfer);
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	DPRINTF(("%s: %s: start rx\n", device_xname(sc->sc_dev), __func__));
+}
 #if 0
 Static void url_intr(void)
+{
+}
 #endif
 Static int
 url_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct url_softc *sc = ifp->if_softc;
 	int s, error = 0;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return EIO;
 	s = splnet();
 	error = ether_ioctl(ifp, cmd, data);
 	if (error == ENETRESET) {
 		if (ifp->if_flags & IFF_RUNNING)
 			url_setmulti(sc);
 		error = 0;
+	}
 	splx(s);
 	return error;
+}
 Static void
 url_watchdog(struct ifnet *ifp)
+{
 	struct url_softc *sc = ifp->if_softc;
 	struct url_chain *c;
 	usbd_status stat;
 	int s;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	ifp->if_oerrors++;
 	printf("%s: watchdog timeout\n", device_xname(sc->sc_dev));
 	s = splusb();
 	c = &sc->sc_cdata.url_tx_chain[0];
 	usbd_get_xfer_status(c->url_xfer, NULL, NULL, NULL, &stat);
 	url_txeof(c->url_xfer, c, stat);
 	if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
 		url_start(ifp);
 	splx(s);
+}
 Static void
 url_stop_task(struct url_softc *sc)
+{
 	url_stop(GET_IFP(sc), 1);
+}
 /* Stop the adapter and free any mbufs allocated to the RX and TX lists. */
 Static void
 url_stop(struct ifnet *ifp, int disable)
+{
 	struct url_softc *sc = ifp->if_softc;
 	usbd_status err;
 	int i;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	ifp->if_timer = 0;
 	url_reset(sc);
 	callout_stop(&sc->sc_stat_ch);
 	/* Stop transfers */
 	/* RX endpoint */
 	if (sc->sc_pipe_rx != NULL) {
 		err = usbd_abort_pipe(sc->sc_pipe_rx);
 		if (err)
 			printf("%s: abort rx pipe failed: %s\n",
 			       device_xname(sc->sc_dev), usbd_errstr(err));
+	}
 	/* TX endpoint */
 	if (sc->sc_pipe_tx != NULL) {
 		err = usbd_abort_pipe(sc->sc_pipe_tx);
 		if (err)
 			printf("%s: abort tx pipe failed: %s\n",
 			       device_xname(sc->sc_dev), usbd_errstr(err));
+	}
 #if 0
 	/* XXX: Interrupt endpoint is not yet supported!! */
 	/* Interrupt endpoint */
 	if (sc->sc_pipe_intr != NULL) {
 		err = usbd_abort_pipe(sc->sc_pipe_intr);
 		if (err)
 			printf("%s: abort intr pipe failed: %s\n",
 			       device_xname(sc->sc_dev), usbd_errstr(err));
 		err = usbd_close_pipe(sc->sc_pipe_intr);
 		if (err)
 			printf("%s: close intr pipe failed: %s\n",
 			       device_xname(sc->sc_dev), usbd_errstr(err));
 		sc->sc_pipe_intr = NULL;
+	}
 #endif
 	/* Free RX resources. */
 	for (i = 0; i < URL_RX_LIST_CNT; i++) {
 		if (sc->sc_cdata.url_rx_chain[i].url_mbuf != NULL) {
 			m_freem(sc->sc_cdata.url_rx_chain[i].url_mbuf);
 			sc->sc_cdata.url_rx_chain[i].url_mbuf = NULL;
+		}
 		if (sc->sc_cdata.url_rx_chain[i].url_xfer != NULL) {
 			usbd_destroy_xfer(sc->sc_cdata.url_rx_chain[i].url_xfer);
 			sc->sc_cdata.url_rx_chain[i].url_xfer = NULL;
+		}
+	}
 	/* Free TX resources. */
 	for (i = 0; i < URL_TX_LIST_CNT; i++) {
 		if (sc->sc_cdata.url_tx_chain[i].url_mbuf != NULL) {
 			m_freem(sc->sc_cdata.url_tx_chain[i].url_mbuf);
 			sc->sc_cdata.url_tx_chain[i].url_mbuf = NULL;
+		}
 		if (sc->sc_cdata.url_tx_chain[i].url_xfer != NULL) {
 			usbd_destroy_xfer(sc->sc_cdata.url_tx_chain[i].url_xfer);
 			sc->sc_cdata.url_tx_chain[i].url_xfer = NULL;
+		}
+	}
 	/* Close pipes */
 	/* RX endpoint */
 	if (sc->sc_pipe_rx != NULL) {
 		err = usbd_close_pipe(sc->sc_pipe_rx);
 		if (err)
 			printf("%s: close rx pipe failed: %s\n",
 			       device_xname(sc->sc_dev), usbd_errstr(err));
 		sc->sc_pipe_rx = NULL;
+	}
 	/* TX endpoint */
 	if (sc->sc_pipe_tx != NULL) {
 		err = usbd_close_pipe(sc->sc_pipe_tx);
 		if (err)
 			printf("%s: close tx pipe failed: %s\n",
 			       device_xname(sc->sc_dev), usbd_errstr(err));
 		sc->sc_pipe_tx = NULL;
+	}
 	sc->sc_link = 0;
 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
+}
 /* Set media options */
 Static int
 url_ifmedia_change(struct ifnet *ifp)
+{
 	struct url_softc *sc = ifp->if_softc;
 	struct mii_data *mii = GET_MII(sc);
 	int rc;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return 0;
 	sc->sc_link = 0;
 	if ((rc = mii_mediachg(mii)) == ENXIO)
 		return 0;
 	return rc;
+}
 /* Report current media status. */
 Static void
 url_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
+{
 	struct url_softc *sc = ifp->if_softc;
 	DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return;
 	ether_mediastatus(ifp, ifmr);
+}
 Static void
 url_tick(void *xsc)
+{
 	struct url_softc *sc = xsc;
 	if (sc == NULL)
 		return;
 	DPRINTFN(0xff, ("%s: %s: enter\n", device_xname(sc->sc_dev),
 			__func__));
 	if (sc->sc_dying)
 		return;
 	/* Perform periodic stuff in process context */
 	usb_add_task(sc->sc_udev, &sc->sc_tick_task, USB_TASKQ_DRIVER);
+}
 Static void
 url_tick_task(void *xsc)
+{
 	struct url_softc *sc = xsc;
 	struct ifnet *ifp;
 	struct mii_data *mii;
 	int s;
 	if (sc == NULL)
 		return;
 	DPRINTFN(0xff, ("%s: %s: enter\n", device_xname(sc->sc_dev),
 			__func__));
 	if (sc->sc_dying)
 		return;
 	ifp = GET_IFP(sc);
 	mii = GET_MII(sc);
 	if (mii == NULL)
 		return;
 	s = splnet();
 	mii_tick(mii);
 	if (!sc->sc_link) {
 		mii_pollstat(mii);
 		if (mii->mii_media_status & IFM_ACTIVE &&
 		    IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
 			DPRINTF(("%s: %s: got link\n",
 				 device_xname(sc->sc_dev), __func__));
 			sc->sc_link++;
 			if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
 				   url_start(ifp);
+		}
+	}
 	callout_reset(&sc->sc_stat_ch, hz, url_tick, sc);
 	splx(s);
+}
 /* Get exclusive access to the MII registers */

 @@ -1,1597 +1,1597 @@
-/*	$NetBSD: if_urndis.c,v 1.9.4.14 2016/12/29 08:04:08 skrll Exp $ */
+/*	$NetBSD: if_urndis.c,v 1.9.4.15 2017/01/26 12:40:16 skrll 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.9.4.14 2016/12/29 08:04:08 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_urndis.c,v 1.9.4.15 2017/01/26 12:40:16 skrll Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sockio.h>
 #include <sys/rwlock.h>
 #include <sys/mbuf.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/socket.h>
 #include <sys/device.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_media.h>
 #include <net/if_ether.h>
 #include <net/bpf.h>
 #include <sys/bus.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/usb/usbdivar.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/usbcdc.h>
 #include <dev/usb/if_urndisreg.h>
 #ifdef URNDIS_DEBUG
 #define DPRINTF(x)      do { printf x; } while (0)
 #else
 #define DPRINTF(x)
 #endif
 #define DEVNAME(sc)	(device_xname(sc->sc_dev))
 #define ETHER_ALIGN 2
 #define URNDIS_RESPONSE_LEN 0x400
 static int urndis_newbuf(struct urndis_softc *, struct urndis_chain *);
 static int urndis_ioctl(struct ifnet *, unsigned long, void *);
 #if 0
 static void urndis_watchdog(struct ifnet *);
 #endif
 static void urndis_start(struct ifnet *);
 static void urndis_start_locked(struct ifnet *);
 static void urndis_rxeof(struct usbd_xfer *, void *, usbd_status);
 static void urndis_txeof(struct usbd_xfer *, void *, usbd_status);
 static int urndis_rx_list_init(struct urndis_softc *);
 static void urndis_rx_list_free(struct urndis_softc *);
 static int urndis_tx_list_init(struct urndis_softc *);
 static void urndis_tx_list_free(struct urndis_softc *);
 static int urndis_init(struct ifnet *);
 static int urndis_init_locked(struct ifnet *);
 static void urndis_stop(struct ifnet *);
 static void urndis_stop_locked(struct ifnet *);
 static usbd_status urndis_ctrl_msg(struct urndis_softc *, uint8_t, uint8_t,
     uint16_t, uint16_t, void *, size_t);
 static usbd_status urndis_ctrl_send(struct urndis_softc *, void *, size_t);
 static struct urndis_comp_hdr *urndis_ctrl_recv(struct urndis_softc *);
 static uint32_t urndis_ctrl_handle(struct urndis_softc *,
     struct urndis_comp_hdr *, void **, size_t *);
 static uint32_t urndis_ctrl_handle_init(struct urndis_softc *,
     const struct urndis_comp_hdr *);
 static uint32_t urndis_ctrl_handle_query(struct urndis_softc *,
     const struct urndis_comp_hdr *, void **, size_t *);
 static uint32_t urndis_ctrl_handle_reset(struct urndis_softc *,
     const struct urndis_comp_hdr *);
 static uint32_t urndis_ctrl_init(struct urndis_softc *);
 #if 0
 static uint32_t urndis_ctrl_halt(struct urndis_softc *);
 #endif
 static uint32_t urndis_ctrl_query(struct urndis_softc *, uint32_t, void *,
     size_t, void **, size_t *);
 static uint32_t urndis_ctrl_set(struct urndis_softc *, uint32_t, void *,
     size_t);
 #if 0
 static uint32_t urndis_ctrl_set_param(struct urndis_softc *, const char *,
     uint32_t, void *, size_t);
 static uint32_t urndis_ctrl_reset(struct urndis_softc *);
 static uint32_t urndis_ctrl_keepalive(struct urndis_softc *);
 #endif
 static int urndis_encap(struct urndis_softc *, struct mbuf *, int);
 static void urndis_decap(struct urndis_softc *, struct urndis_chain *,
     uint32_t);
 static int urndis_match(device_t, cfdata_t, void *);
 static void urndis_attach(device_t, device_t, void *);
 static int urndis_detach(device_t, int);
 static int urndis_activate(device_t, enum devact);
 CFATTACH_DECL_NEW(urndis, sizeof(struct urndis_softc),
     urndis_match, urndis_attach, urndis_detach, urndis_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 },
 };
 static usbd_status
 urndis_ctrl_msg(struct urndis_softc *sc, 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(sc->sc_udev, &req, buf);
+}
 static usbd_status
 urndis_ctrl_send(struct urndis_softc *sc, void *buf, size_t len)
+{
 	usbd_status err;
 	if (sc->sc_dying)
 		return(0);
 	err = urndis_ctrl_msg(sc, UT_WRITE_CLASS_INTERFACE, UR_GET_STATUS,
 	    sc->sc_ifaceno_ctl, 0, buf, len);
 	if (err != USBD_NORMAL_COMPLETION)
 		printf("%s: %s\n", DEVNAME(sc), usbd_errstr(err));
 	return err;
+}
 static struct urndis_comp_hdr *
 urndis_ctrl_recv(struct urndis_softc *sc)
+{
 	struct urndis_comp_hdr	*hdr;
 	char			*buf;
 	usbd_status		 err;
 	buf = kmem_alloc(URNDIS_RESPONSE_LEN, KM_SLEEP);
 	if (buf == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return NULL;
+	}
 	err = urndis_ctrl_msg(sc, 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(sc), usbd_errstr(err));
 		kmem_free(buf, URNDIS_RESPONSE_LEN);
 		return NULL;
+	}
 	hdr = (struct urndis_comp_hdr *)buf;
 	DPRINTF(("%s: urndis_ctrl_recv: type 0x%x len %u\n",
 	    DEVNAME(sc),
 	    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(sc),
 		    le32toh(hdr->rm_len),
 		    URNDIS_RESPONSE_LEN);
 		kmem_free(buf, URNDIS_RESPONSE_LEN);
 		return NULL;
+	}
 	return hdr;
+}
 static uint32_t
 urndis_ctrl_handle(struct urndis_softc *sc, struct urndis_comp_hdr *hdr,
     void **buf, size_t *bufsz)
+{
 	uint32_t rval;
 	DPRINTF(("%s: urndis_ctrl_handle\n", DEVNAME(sc)));
 	if (buf && bufsz) {
 		*buf = NULL;
 		*bufsz = 0;
+	}
 	switch (le32toh(hdr->rm_type)) {
 		case REMOTE_NDIS_INITIALIZE_CMPLT:
 			rval = urndis_ctrl_handle_init(sc, hdr);
 			break;
 		case REMOTE_NDIS_QUERY_CMPLT:
 			rval = urndis_ctrl_handle_query(sc, hdr, buf, bufsz);
 			break;
 		case REMOTE_NDIS_RESET_CMPLT:
 			rval = urndis_ctrl_handle_reset(sc, hdr);
 			break;
 		case REMOTE_NDIS_KEEPALIVE_CMPLT:
 		case REMOTE_NDIS_SET_CMPLT:
 			rval = le32toh(hdr->rm_status);
 			break;
 		default:
 			printf("%s: ctrl message error: unknown event 0x%x\n",
 			    DEVNAME(sc), le32toh(hdr->rm_type));
 			rval = RNDIS_STATUS_FAILURE;
+	}
 	kmem_free(hdr, URNDIS_RESPONSE_LEN);
 	return rval;
+}
 static uint32_t
 urndis_ctrl_handle_init(struct urndis_softc *sc,
     const struct urndis_comp_hdr *hdr)
+{
 	const struct urndis_init_comp	*msg;
 	msg = (const struct urndis_init_comp *) hdr;
 	DPRINTF(("%s: urndis_ctrl_handle_init: len %u rid %u status 0x%x "
 	    "ver_major %u ver_minor %u devflags 0x%x medium 0x%x pktmaxcnt %u "
 	    "pktmaxsz %u align %u aflistoffset %u aflistsz %u\n",
 	    DEVNAME(sc),
 	    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 0x%x\n",
 		    DEVNAME(sc),
 		    le32toh(msg->rm_status));
 		return le32toh(msg->rm_status);
+	}
 	if (le32toh(msg->rm_devflags) != RNDIS_DF_CONNECTIONLESS) {
 		printf("%s: wrong device type (current type: 0x%x)\n",
 		    DEVNAME(sc),
 		    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: 0x%x)\n",
 		    DEVNAME(sc), le32toh(msg->rm_medium));
 		return RNDIS_STATUS_FAILURE;
+	}
 	sc->sc_lim_pktsz = le32toh(msg->rm_pktmaxsz);
 	return le32toh(msg->rm_status);
+}
 static uint32_t
 urndis_ctrl_handle_query(struct urndis_softc *sc,
     const struct urndis_comp_hdr *hdr, void **buf, size_t *bufsz)
+{
 	const struct urndis_query_comp	*msg;
 	msg = (const struct urndis_query_comp *) hdr;
 	DPRINTF(("%s: urndis_ctrl_handle_query: len %u rid %u status 0x%x "
 	    "buflen %u bufoff %u\n",
 	    DEVNAME(sc),
 	    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 0x%x\n",
 		    DEVNAME(sc),
 		    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(sc),
 		    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) {
 		*buf = kmem_alloc(le32toh(msg->rm_infobuflen), KM_SLEEP);
 		if (*buf == NULL) {
 			printf("%s: out of memory\n", DEVNAME(sc));
 			return RNDIS_STATUS_FAILURE;
 		} else {
 			const char *p;
 			*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 urndis_softc *sc,
     const struct urndis_comp_hdr *hdr)
+{
 	const struct urndis_reset_comp	*msg;
 	uint32_t			 rval;
 	msg = (const struct urndis_reset_comp *) hdr;
 	rval = le32toh(msg->rm_status);
 	DPRINTF(("%s: urndis_ctrl_handle_reset: len %u status 0x%x "
 	    "adrreset %u\n",
 	    DEVNAME(sc),
 	    le32toh(msg->rm_len),
 	    rval,
 	    le32toh(msg->rm_adrreset)));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: reset failed 0x%x\n", DEVNAME(sc), rval);
 		return rval;
+	}
 	if (le32toh(msg->rm_adrreset) != 0) {
 		uint32_t filter;
 		filter = htole32(sc->sc_filter);
 		rval = urndis_ctrl_set(sc, OID_GEN_CURRENT_PACKET_FILTER,
 		    &filter, sizeof(filter));
 		if (rval != RNDIS_STATUS_SUCCESS) {
 			printf("%s: unable to reset data filters\n",
 			    DEVNAME(sc));
 			return rval;
+		}
+	}
 	return rval;
+}
 static uint32_t
 urndis_ctrl_init(struct urndis_softc *sc)
+{
 	struct urndis_init_req	*msg;
 	uint32_t		 rval;
 	struct urndis_comp_hdr	*hdr;
 	msg = kmem_alloc(sizeof(*msg), KM_SLEEP);
 	if (msg == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	msg->rm_type = htole32(REMOTE_NDIS_INITIALIZE_MSG);
 	msg->rm_len = htole32(sizeof(*msg));
 	msg->rm_rid = htole32(0);
 	msg->rm_ver_major = htole32(1);
 	msg->rm_ver_minor = htole32(1);
 	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(sc),
 	    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(sc, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: init failed\n", DEVNAME(sc));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
 		printf("%s: unable to get init response\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
 	return rval;
+}
 #if 0
 static uint32_t
 urndis_ctrl_halt(struct urndis_softc *sc)
+{
 	struct urndis_halt_req	*msg;
 	uint32_t		 rval;
 	msg = kmem_alloc(sizeof(*msg), KM_SLEEP);
 	if (msg == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	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(sc),
 	    le32toh(msg->rm_type),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_rid)));
 	rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg));
 	if (rval != RNDIS_STATUS_SUCCESS)
 		printf("%s: halt failed\n", DEVNAME(sc));
 	return rval;
+}
 #endif
 static uint32_t
 urndis_ctrl_query(struct urndis_softc *sc, uint32_t oid,
     void *qbuf, size_t qlen,
     void **rbuf, size_t *rbufsz)
+{
 	struct urndis_query_req	*msg;
 	uint32_t		 rval;
 	struct urndis_comp_hdr	*hdr;
 	msg = kmem_alloc(sizeof(*msg) + qlen, KM_SLEEP);
 	if (msg == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	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 0x%x "
 	    "infobuflen %u infobufoffset %u devicevchdl %u\n",
 	    DEVNAME(sc),
 	    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(sc, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg) + qlen);
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: query failed\n", DEVNAME(sc));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
 		printf("%s: unable to get query response\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(sc, hdr, rbuf, rbufsz);
 	return rval;
+}
 static uint32_t
 urndis_ctrl_set(struct urndis_softc *sc, uint32_t oid, void *buf, size_t len)
+{
 	struct urndis_set_req	*msg;
 	uint32_t		 rval;
 	struct urndis_comp_hdr	*hdr;
 	msg = kmem_alloc(sizeof(*msg) + len, KM_SLEEP);
 	if (msg == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	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 0x%x "
 	    "infobuflen %u infobufoffset %u devicevchdl %u\n",
 	    DEVNAME(sc),
 	    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(sc, msg, sizeof(*msg));
 	kmem_free(msg, sizeof(*msg) + len);
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: set failed\n", DEVNAME(sc));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
 		printf("%s: unable to get set response\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
 	if (rval != RNDIS_STATUS_SUCCESS)
 		printf("%s: set failed 0x%x\n", DEVNAME(sc), rval);
 	return rval;
+}
 #if 0
 static uint32_t
 urndis_ctrl_set_param(struct urndis_softc *sc,
     const char *name,
     uint32_t type,
     void *buf,
     size_t len)
+{
 	struct urndis_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);
 	if (param == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	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 0x%x valueoffset %u valuelen %u\n",
 	    DEVNAME(sc),
 	    le32toh(param->rm_nameoffset),
 	    le32toh(param->rm_namelen),
 	    le32toh(param->rm_type),
 	    le32toh(param->rm_valueoffset),
 	    le32toh(param->rm_valuelen)));
 	rval = urndis_ctrl_set(sc, OID_GEN_RNDIS_CONFIG_PARAMETER, param, tlen);
 	kmem_free(param, tlen);
 	if (rval != RNDIS_STATUS_SUCCESS)
 		printf("%s: set param failed 0x%x\n", DEVNAME(sc), rval);
 	return rval;
+}
 /* XXX : adrreset, get it from response */
 static uint32_t
 urndis_ctrl_reset(struct urndis_softc *sc)
+{
 	struct urndis_reset_req		*reset;
 	uint32_t			 rval;
 	struct urndis_comp_hdr		*hdr;
 	reset = kmem_alloc(sizeof(*reset), KM_SLEEP);
 	if (reset == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	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(sc),
 	    le32toh(reset->rm_type),
 	    le32toh(reset->rm_len),
 	    le32toh(reset->rm_rid)));
 	rval = urndis_ctrl_send(sc, reset, sizeof(*reset));
 	kmem_free(reset, sizeof(*reset));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: reset failed\n", DEVNAME(sc));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
 		printf("%s: unable to get reset response\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
 	return rval;
+}
 static uint32_t
 urndis_ctrl_keepalive(struct urndis_softc *sc)
+{
 	struct urndis_keepalive_req	*keep;
 	uint32_t			 rval;
 	struct urndis_comp_hdr		*hdr;
 	keep = kmem_alloc(sizeof(*keep), KM_SLEEP);
 	if (keep == NULL) {
 		printf("%s: out of memory\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	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(sc),
 	    le32toh(keep->rm_type),
 	    le32toh(keep->rm_len),
 	    le32toh(keep->rm_rid)));
 	rval = urndis_ctrl_send(sc, keep, sizeof(*keep));
 	kmem_free(keep, sizeof(*keep));
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: keepalive failed\n", DEVNAME(sc));
 		return rval;
+	}
 	if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
 		printf("%s: unable to get keepalive response\n", DEVNAME(sc));
 		return RNDIS_STATUS_FAILURE;
+	}
 	rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
 	if (rval != RNDIS_STATUS_SUCCESS) {
 		printf("%s: keepalive failed 0x%x\n", DEVNAME(sc), rval);
 		urndis_ctrl_reset(sc);
+	}
 	return rval;
+}
 #endif
 static int
 urndis_encap(struct urndis_softc *sc, struct mbuf *m, int idx)
+{
 	struct urndis_chain		*c;
 	usbd_status			 err;
 	struct urndis_packet_msg	*msg;
 	c = &sc->sc_data.sc_tx_chain[idx];
 	msg = (struct urndis_packet_msg *)c->sc_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: urndis_encap type 0x%x len %u data(off %u len %u)\n",
 	    DEVNAME(sc),
 	    le32toh(msg->rm_type),
 	    le32toh(msg->rm_len),
 	    le32toh(msg->rm_dataoffset),
 	    le32toh(msg->rm_datalen)));
 	c->sc_mbuf = m;
 	usbd_setup_xfer(c->sc_xfer, c, c->sc_buf, le32toh(msg->rm_len),
 	    USBD_FORCE_SHORT_XFER, 10000, urndis_txeof);
 	/* Transmit */
 	err = usbd_transfer(c->sc_xfer);
 	if (err != USBD_IN_PROGRESS) {
 		urndis_stop(GET_IFP(sc));
 		return(EIO);
+	}
 	sc->sc_data.sc_tx_cnt++;
 	return(0);
+}
 static void
 urndis_decap(struct urndis_softc *sc, struct urndis_chain *c, uint32_t len)
+{
 	struct mbuf		*m;
 	struct urndis_packet_msg	*msg;
 	struct ifnet		*ifp;
 	int			 s;
 	int			 offset;
 	ifp = GET_IFP(sc);
 	offset = 0;
 	while (len > 0) {
 		msg = (struct urndis_packet_msg *)((char*)c->sc_buf + offset);
 		m = c->sc_mbuf;
 		DPRINTF(("%s: urndis_decap buffer size left %u\n", DEVNAME(sc),
 		    len));
 		if (len < sizeof(*msg)) {
 			printf("%s: urndis_decap invalid buffer len %u < "
 			    "minimum header %zu\n",
 			    DEVNAME(sc),
 			    len,
 			    sizeof(*msg));
 			return;
+		}
 		DPRINTF(("%s: urndis_decap len %u data(off:%u len:%u) "
 		    "oobdata(off:%u len:%u nb:%u) perpacket(off:%u len:%u)\n",
 		    DEVNAME(sc),
 		    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 0x%x != 0x%x\n",
 			    DEVNAME(sc),
 			    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(sc),
 			    le32toh(msg->rm_len),
 			    sizeof(*msg));
 			return;
+		}
 		if (le32toh(msg->rm_len) > len) {
 			printf("%s: urndis_decap invalid msg len %u > buffer "
 			    "len %u\n",
 			    DEVNAME(sc),
 			    le32toh(msg->rm_len),
 			    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(sc),
 			    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)) {
 			ifp->if_ierrors++;
 			printf("%s: urndis_decap invalid ethernet size "
 			    "%d < %zu\n",
 			    DEVNAME(sc),
 			    le32toh(msg->rm_datalen),
 			    sizeof(struct ether_header));
 			return;
+		}
 		memcpy(mtod(m, char*),
 		    ((char*)&msg->rm_dataoffset + le32toh(msg->rm_dataoffset)),
 		    le32toh(msg->rm_datalen));
 		m->m_pkthdr.len = m->m_len = le32toh(msg->rm_datalen);
 		ifp->if_ipackets++;
 		m_set_rcvif(m, ifp);
 		s = splnet();
 		if (urndis_newbuf(sc, c) == ENOBUFS) {
 			ifp->if_ierrors++;
 		} else {
 			bpf_mtap(ifp, m);
 			if_percpuq_enqueue(sc->urndis_ipq, m);
+		}
 		splx(s);
 		offset += le32toh(msg->rm_len);
 		len -= le32toh(msg->rm_len);
+	}
+}
 static int
 urndis_newbuf(struct urndis_softc *sc, struct urndis_chain *c)
+{
 	struct mbuf *m_new = NULL;
 	MGETHDR(m_new, M_DONTWAIT, MT_DATA);
 	if (m_new == NULL) {
 		printf("%s: no memory for rx list -- packet dropped!\n",
 		    DEVNAME(sc));
 		return ENOBUFS;
+	}
 	MCLGET(m_new, M_DONTWAIT);
 	if (!(m_new->m_flags & M_EXT)) {
 		printf("%s: no memory for rx list -- packet dropped!\n",
 		    DEVNAME(sc));
 		m_freem(m_new);
 		return ENOBUFS;
+	}
 	m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 	m_adj(m_new, ETHER_ALIGN);
 	c->sc_mbuf = m_new;
 	return 0;
+}
 static int
 urndis_rx_list_init(struct urndis_softc *sc)
+{
 	struct urndis_cdata	*cd;
 	struct urndis_chain	*c;
 	int			 i;
 	cd = &sc->sc_data;
 	for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
 		c = &cd->sc_rx_chain[i];
 		c->sc_softc = sc;
 		c->sc_idx = i;
 		if (urndis_newbuf(sc, c) == ENOBUFS)
 			return ENOBUFS;
 		if (c->sc_xfer == NULL) {
 			int err = usbd_create_xfer(sc->sc_bulkin_pipe,
 			    RNDIS_BUFSZ, USBD_SHORT_XFER_OK, 0, &c->sc_xfer);
 			if (err)
 				return err;
 			c->sc_buf = usbd_get_buffer(c->sc_xfer);
+		}
+	}
 	return 0;
+}
 static void
 urndis_rx_list_free(struct urndis_softc *sc)
+{
 	for (int i = 0; i < RNDIS_RX_LIST_CNT; i++) {
 		if (sc->sc_data.sc_rx_chain[i].sc_mbuf != NULL) {
 			m_freem(sc->sc_data.sc_rx_chain[i].sc_mbuf);
 			sc->sc_data.sc_rx_chain[i].sc_mbuf = NULL;
+		}
 		if (sc->sc_data.sc_rx_chain[i].sc_xfer != NULL) {
 			usbd_destroy_xfer(sc->sc_data.sc_rx_chain[i].sc_xfer);
 			sc->sc_data.sc_rx_chain[i].sc_xfer = NULL;
+		}
+	}
+}
 static int
 urndis_tx_list_init(struct urndis_softc *sc)
+{
 	struct urndis_cdata	*cd;
 	struct urndis_chain	*c;
 	int			 i;
 	cd = &sc->sc_data;
 	for (i = 0; i < RNDIS_TX_LIST_CNT; i++) {
 		c = &cd->sc_tx_chain[i];
 		c->sc_softc = sc;
 		c->sc_idx = i;
 		c->sc_mbuf = NULL;
 		if (c->sc_xfer == NULL) {
 			int err = usbd_create_xfer(sc->sc_bulkout_pipe,
 			    RNDIS_BUFSZ, USBD_FORCE_SHORT_XFER, 0, &c->sc_xfer);
 			if (err)
 				return err;
 			c->sc_buf = usbd_get_buffer(c->sc_xfer);
+		}
+	}
 	return 0;
+}
 static void
 urndis_tx_list_free(struct urndis_softc *sc)
+{
 	for (int i = 0; i < RNDIS_TX_LIST_CNT; i++) {
 		if (sc->sc_data.sc_tx_chain[i].sc_mbuf != NULL) {
 			m_freem(sc->sc_data.sc_tx_chain[i].sc_mbuf);
 			sc->sc_data.sc_tx_chain[i].sc_mbuf = NULL;
+		}
 		if (sc->sc_data.sc_tx_chain[i].sc_xfer != NULL) {
 			usbd_destroy_xfer(sc->sc_data.sc_tx_chain[i].sc_xfer);
 			sc->sc_data.sc_tx_chain[i].sc_xfer = NULL;
+		}
+	}
+}
 static int
 urndis_ioctl(struct ifnet *ifp, unsigned long command, void *data)
+{
 	struct urndis_softc	*sc;
 	int			 s, error;
 	sc = ifp->if_softc;
 	error = 0;
 	if (sc->sc_dying)
 		return EIO;
 	s = splnet();
 	error = ether_ioctl(ifp, command, data);
 	if (error == ENETRESET)
 		error = 0;
 	splx(s);
 	return error;
+}
 #if 0
 static void
 urndis_watchdog(struct ifnet *ifp)
+{
 	struct urndis_softc *sc;
 	sc = ifp->if_softc;
 	if (sc->sc_dying)
 		return;
 	ifp->if_oerrors++;
 	printf("%s: watchdog timeout\n", DEVNAME(sc));
 	urndis_ctrl_keepalive(sc);
+}
 #endif
 static int
 urndis_init(struct ifnet *ifp)
+{
 	struct urndis_softc *sc = ifp->if_softc;
-	mutex_enter(&sc->urndis_lock);
+	mutex_enter(&sc->sc_lock);
 	int ret = urndis_init_locked(ifp);
-	mutex_exit(&sc->urndis_lock);
+	mutex_exit(&sc->sc_lock);
 	return ret;
+}
 static int
 urndis_init_locked(struct ifnet *ifp)
+{
 	struct urndis_softc	*sc;
 	int			 i;
 	int 			 err;
 	usbd_status		 usberr;
 	sc = ifp->if_softc;
 	if (ifp->if_flags & IFF_RUNNING)
 		return 0;
 	err = urndis_ctrl_init(sc);
 	if (err != RNDIS_STATUS_SUCCESS)
 		return EIO;
 	usberr = usbd_open_pipe(sc->sc_iface_data, sc->sc_bulkin_no,
 	    USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe);
 	if (usberr) {
 		printf("%s: open rx pipe failed: %s\n", DEVNAME(sc),
 		    usbd_errstr(err));
 		goto fail;
+	}
 	usberr = usbd_open_pipe(sc->sc_iface_data, sc->sc_bulkout_no,
 	    USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
 	if (usberr) {
 		printf("%s: open tx pipe failed: %s\n", DEVNAME(sc),
 		    usbd_errstr(err));
 		goto fail2;
+	}
 	err = urndis_tx_list_init(sc);
 	if (err) {
 		printf("%s: tx list init failed\n",
 		    DEVNAME(sc));
 		goto fail3;
+	}
 	err = urndis_rx_list_init(sc);
 	if (err) {
 		printf("%s: rx list init failed\n",
 		    DEVNAME(sc));
 		goto fail4;
+	}
 	for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
 		struct urndis_chain *c;
 		c = &sc->sc_data.sc_rx_chain[i];
 		usbd_setup_xfer(c->sc_xfer, c, c->sc_buf, RNDIS_BUFSZ,
 		    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, urndis_rxeof);
 		usbd_transfer(c->sc_xfer);
+	}
 	ifp->if_flags |= IFF_RUNNING;
 	ifp->if_flags &= ~IFF_OACTIVE;
 	return 0;
 fail4:
 	urndis_tx_list_free(sc);
 fail3:
 	usbd_close_pipe(sc->sc_bulkout_pipe);
 fail2:
 	usbd_close_pipe(sc->sc_bulkin_pipe);
 fail:
 	return EIO;
+}
 static void
 urndis_stop(struct ifnet *ifp)
+{
 	struct urndis_softc *sc = ifp->if_softc;
-	mutex_enter(&sc->urndis_lock);
+	mutex_enter(&sc->sc_lock);
 	urndis_stop_locked(ifp);
-	mutex_exit(&sc->urndis_lock);
+	mutex_exit(&sc->sc_lock);
+}
 static void
 urndis_stop_locked(struct ifnet *ifp)
+{
 	struct urndis_softc	*sc;
 	usbd_status	 err;
 	sc = ifp->if_softc;
 	ifp->if_timer = 0;
 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 	if (sc->sc_bulkin_pipe != NULL) {
 		err = usbd_abort_pipe(sc->sc_bulkin_pipe);
 		if (err)
 			printf("%s: abort rx pipe failed: %s\n",
 			    DEVNAME(sc), usbd_errstr(err));
+	}
 	if (sc->sc_bulkout_pipe != NULL) {
 		err = usbd_abort_pipe(sc->sc_bulkout_pipe);
 		if (err)
 			printf("%s: abort tx pipe failed: %s\n",
 			    DEVNAME(sc), usbd_errstr(err));
+	}
 	urndis_tx_list_free(sc);
 	urndis_rx_list_free(sc);
 	/* Close pipes. */
 	if (sc->sc_bulkin_pipe != NULL) {
 		err = usbd_close_pipe(sc->sc_bulkin_pipe);
 		if (err)
 			printf("%s: close rx pipe failed: %s\n",
 			    DEVNAME(sc), usbd_errstr(err));
 		sc->sc_bulkin_pipe = NULL;
+	}
 	if (sc->sc_bulkout_pipe != NULL) {
 		err = usbd_close_pipe(sc->sc_bulkout_pipe);
 		if (err)
 			printf("%s: close tx pipe failed: %s\n",
 			    DEVNAME(sc), usbd_errstr(err));
 		sc->sc_bulkout_pipe = NULL;
+	}
+}
 static void
 urndis_start(struct ifnet *ifp)
+{
 	struct urndis_softc *sc = ifp->if_softc;
 	KASSERT(ifp->if_extflags & IFEF_START_MPSAFE);
-	mutex_enter(&sc->urndis_txlock);
+	mutex_enter(&sc->sc_txlock);
 	urndis_start_locked(ifp);
-	mutex_exit(&sc->urndis_txlock);
+	mutex_exit(&sc->sc_txlock);
+}
 static void
 urndis_start_locked(struct ifnet *ifp)
+{
 	struct urndis_softc	*sc;
 	struct mbuf		*m_head = NULL;
 	sc = ifp->if_softc;
 	if (sc->sc_dying || (ifp->if_flags & IFF_OACTIVE))
 		return;
 	IFQ_POLL(&ifp->if_snd, m_head);
 	if (m_head == NULL)
 		return;
 	if (urndis_encap(sc, m_head, 0)) {
 		ifp->if_flags |= IFF_OACTIVE;
 		return;
+	}
 	IFQ_DEQUEUE(&ifp->if_snd, m_head);
 	/*
 	 * If there's a BPF listener, bounce a copy of this frame
 	 * to him.
 	 */
 	bpf_mtap(ifp, m_head);
 	ifp->if_flags |= IFF_OACTIVE;
 	/*
 	 * Set a timeout in case the chip goes out to lunch.
 	 */
 	ifp->if_timer = 5;
 	return;
+}
 static void
 urndis_rxeof(struct usbd_xfer *xfer,
     void *priv,
     usbd_status status)
+{
 	struct urndis_chain	*c;
 	struct urndis_softc	*sc;
 	struct ifnet		*ifp;
 	uint32_t		 total_len;
 	c = priv;
 	sc = c->sc_softc;
 	ifp = GET_IFP(sc);
 	total_len = 0;
 	if (sc->sc_dying || !(ifp->if_flags & IFF_RUNNING))
 		return;
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
 			return;
 		if (usbd_ratecheck(&sc->sc_rx_notice)) {
 			printf("%s: usb errors on rx: %s\n",
 			    DEVNAME(sc), usbd_errstr(status));
+		}
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
 		goto done;
+	}
 	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
 	urndis_decap(sc, c, total_len);
 done:
 	/* Setup new transfer. */
 	usbd_setup_xfer(c->sc_xfer, c, c->sc_buf, RNDIS_BUFSZ,
 	    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, urndis_rxeof);
 	usbd_transfer(c->sc_xfer);
+}
 static void
 urndis_txeof(struct usbd_xfer *xfer,
     void *priv,
     usbd_status status)
+{
 	struct urndis_chain	*c;
 	struct urndis_softc	*sc;
 	struct ifnet		*ifp;
 	usbd_status		 err;
 	int			 s;
 	c = priv;
 	sc = c->sc_softc;
 	ifp = GET_IFP(sc);
 	DPRINTF(("%s: urndis_txeof\n", DEVNAME(sc)));
 	if (sc->sc_dying)
 		return;
 	s = splnet();
 	ifp->if_timer = 0;
 	ifp->if_flags &= ~IFF_OACTIVE;
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 			splx(s);
 			return;
+		}
 		ifp->if_oerrors++;
 		printf("%s: usb error on tx: %s\n", DEVNAME(sc),
 		    usbd_errstr(status));
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(sc->sc_bulkout_pipe);
 		splx(s);
 		return;
+	}
 	usbd_get_xfer_status(c->sc_xfer, NULL, NULL, NULL, &err);
 	if (c->sc_mbuf != NULL) {
 		m_freem(c->sc_mbuf);
 		c->sc_mbuf = NULL;
+	}
 	if (err)
 		ifp->if_oerrors++;
 	else
 		ifp->if_opackets++;
 	if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
 		urndis_start(ifp);
 	splx(s);
+}
 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;
 	struct usbif_attach_arg		*uiaa;
 	struct ifnet			*ifp;
 	usb_interface_descriptor_t	*id;
 	usb_endpoint_descriptor_t	*ed;
 	usb_config_descriptor_t		*cd;
 	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;
 	u_char				 eaddr[ETHER_ADDR_LEN];
 	void				*buf;
 	size_t				 bufsz;
 	uint32_t			 filter;
 	char				*devinfop;
 	sc = device_private(self);
 	uiaa = aux;
 	sc->sc_dev = self;
 	sc->sc_udev = uiaa->uiaa_device;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	sc->sc_iface_ctl = uiaa->uiaa_iface;
 	id = usbd_get_interface_descriptor(sc->sc_iface_ctl);
 	if_ctl = id->bInterfaceNumber;
 	sc->sc_ifaceno_ctl = if_ctl;
 	if_data = -1;
 	usb_desc_iter_init(sc->sc_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"));
 		sc->sc_iface_data = sc->sc_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) {
 					sc->sc_iface_data = uiaa->uiaa_ifaces[i];
 					uiaa->uiaa_ifaces[i] = NULL;
+				}
+			}
+		}
+	}
 	if (sc->sc_iface_data == NULL) {
 		aprint_error("%s: no data interface\n", DEVNAME(sc));
 		return;
+	}
 	id = usbd_get_interface_descriptor(sc->sc_iface_data);
 	cd = usbd_get_config_descriptor(sc->sc_udev);
 	altcnt = usbd_get_no_alts(cd, id->bInterfaceNumber);
 	for (j = 0; j < altcnt; j++) {
 		if (usbd_set_interface(sc->sc_iface_data, j)) {
 			aprint_error("%s: interface alternate setting %u "
 			    "failed\n", DEVNAME(sc), j);
 			return;
+		}
 		/* Find endpoints. */
 		id = usbd_get_interface_descriptor(sc->sc_iface_data);
 		sc->sc_bulkin_no = sc->sc_bulkout_no = -1;
 		for (i = 0; i < id->bNumEndpoints; i++) {
 			ed = usbd_interface2endpoint_descriptor(
 			    sc->sc_iface_data, i);
 			if (!ed) {
 				aprint_error("%s: no descriptor for bulk "
 				    "endpoint %u\n", DEVNAME(sc), i);
 				return;
+			}
 			if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 			    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 				sc->sc_bulkin_no = ed->bEndpointAddress;
+			}
 			else if (
 			    UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 			    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 				sc->sc_bulkout_no = ed->bEndpointAddress;
+			}
+		}
 		if (sc->sc_bulkin_no != -1 && sc->sc_bulkout_no != -1) {
 			DPRINTF(("%s: in=0x%x, out=0x%x\n",
 			    DEVNAME(sc),
 			    sc->sc_bulkin_no,
 			    sc->sc_bulkout_no));
 			goto found;
+		}
+	}
 	if (sc->sc_bulkin_no == -1)
 		aprint_error("%s: could not find data bulk in\n", DEVNAME(sc));
 	if (sc->sc_bulkout_no == -1 )
 		aprint_error("%s: could not find data bulk out\n",DEVNAME(sc));
 	return;
 found:
-	mutex_init(&sc->urndis_lock, MUTEX_DEFAULT, IPL_NONE);
+	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
-	mutex_init(&sc->urndis_txlock, MUTEX_DEFAULT, IPL_SOFTUSB);
+	mutex_init(&sc->sc_txlock, MUTEX_DEFAULT, IPL_SOFTUSB);
-	mutex_init(&sc->urndis_rxlock, MUTEX_DEFAULT, IPL_SOFTUSB);
+	mutex_init(&sc->sc_rxlock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	ifp = GET_IFP(sc);
 	ifp->if_softc = sc;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 	ifp->if_extflags = IFEF_START_MPSAFE;
 	ifp->if_start = urndis_start;
 	ifp->if_ioctl = urndis_ioctl;
 	ifp->if_init = urndis_init;
 #if 0
 	ifp->if_watchdog = urndis_watchdog;
 #endif
 	strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
 	IFQ_SET_READY(&ifp->if_snd);
 	urndis_init(ifp);
 	if (urndis_ctrl_query(sc, OID_802_3_PERMANENT_ADDRESS, NULL, 0,
 	    &buf, &bufsz) != RNDIS_STATUS_SUCCESS) {
 		aprint_error("%s: unable to get hardware address\n",
 		    DEVNAME(sc));
 		urndis_stop(ifp);
 		goto fail;
+	}
 	if (bufsz == ETHER_ADDR_LEN) {
 		memcpy(eaddr, buf, ETHER_ADDR_LEN);
 		aprint_normal("%s: address %s\n", DEVNAME(sc),
 		    ether_sprintf(eaddr));
 		kmem_free(buf, bufsz);
 	} else {
 		aprint_error("%s: invalid address\n", DEVNAME(sc));
 		kmem_free(buf, bufsz);
 		urndis_stop(ifp);
 		goto fail;
+	}
 	/* 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(sc, OID_GEN_CURRENT_PACKET_FILTER, &filter,
 	    sizeof(filter)) != RNDIS_STATUS_SUCCESS) {
 		aprint_error("%s: unable to set data filters\n", DEVNAME(sc));
 		urndis_stop(ifp);
 		goto fail;
+	}
 	if_initialize(ifp);
 	sc->urndis_ipq = if_percpuq_create(&sc->sc_ec.ec_if);
 	ether_ifattach(ifp, eaddr);
 	if_register(ifp);
 	sc->sc_attached = 1;
 	return;
 fail:
-	mutex_destroy(&sc->urndis_lock);
+	mutex_destroy(&sc->sc_lock);
-	mutex_destroy(&sc->urndis_txlock);
+	mutex_destroy(&sc->sc_txlock);
-	mutex_destroy(&sc->urndis_rxlock);
+	mutex_destroy(&sc->sc_rxlock);
+}
 static int
 urndis_detach(device_t self, int flags)
+{
 	struct urndis_softc	*sc;
 	struct ifnet		*ifp;
 	int			 s;
 	sc = device_private(self);
 	DPRINTF(("urndis_detach: %s flags %u\n", DEVNAME(sc),
 	    flags));
 	if (!sc->sc_attached)
 		return 0;
 	s = splusb();
 	ifp = GET_IFP(sc);
 	if (ifp->if_softc != NULL) {
 		ether_ifdetach(ifp);
 		if_detach(ifp);
+	}
 	urndis_stop(ifp);
-	mutex_destroy(&sc->urndis_rxlock);
+	mutex_destroy(&sc->sc_rxlock);
-	mutex_destroy(&sc->urndis_txlock);
+	mutex_destroy(&sc->sc_txlock);
-	mutex_destroy(&sc->urndis_lock);
+	mutex_destroy(&sc->sc_lock);
 	sc->sc_attached = 0;
 	splx(s);
 	return 0;
+}
 static int
 urndis_activate(device_t self, enum devact act)
+{
 	struct urndis_softc *sc;
 	sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		sc->sc_dying = 1;
 		return 0;
+	}
 	return EOPNOTSUPP;
+}

 @@ -1,313 +1,313 @@
-/*	$NetBSD: if_urndisreg.h,v 1.1.32.4 2016/12/28 08:55:20 skrll Exp $ */
+/*	$NetBSD: if_urndisreg.h,v 1.1.32.5 2017/01/26 12:40:16 skrll Exp $ */
 /*	$OpenBSD: if_urndisreg.h,v 1.14 2010/07/08 18:22:01 ckuethe 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.
  */
 #define RNDIS_RX_LIST_CNT	1
 #define RNDIS_TX_LIST_CNT	1
 #define RNDIS_BUFSZ		1562
 struct urndis_chain {
 	struct urndis_softc	*sc_softc;
 	struct usbd_xfer	*sc_xfer;
 	char			*sc_buf;
 	struct mbuf		*sc_mbuf;
 	int			 sc_idx;
 };
 struct urndis_cdata {
 	struct urndis_chain	sc_rx_chain[RNDIS_RX_LIST_CNT];
 	struct urndis_chain	sc_tx_chain[RNDIS_TX_LIST_CNT];
 	int			sc_tx_cnt;
 };
 #define GET_IFP(sc) (&(sc)->sc_ec.ec_if)
 struct urndis_softc {
 	device_t			sc_dev;
-	kmutex_t			urndis_lock;
+	kmutex_t			sc_lock;
-	kmutex_t			urndis_txlock;
+	kmutex_t			sc_txlock;
-	kmutex_t			urndis_rxlock;
+	kmutex_t			sc_rxlock;
 	char				sc_attached;
 	int				sc_dying;
 	struct ethercom			sc_ec;
 	/* RNDIS device info */
 	uint32_t			sc_lim_pktsz;
 	uint32_t			sc_filter;
 	/* USB goo */
 	struct usbd_device *		sc_udev;
 	int				sc_ifaceno_ctl;
 	struct usbd_interface *		sc_iface_ctl;
 	struct usbd_interface *		sc_iface_data;
 	struct timeval			sc_rx_notice;
 	int				sc_bulkin_no;
 	struct usbd_pipe *		sc_bulkin_pipe;
 	int				sc_bulkout_no;
 	struct usbd_pipe *		sc_bulkout_pipe;
 	struct urndis_cdata		sc_data;
 	struct if_percpuq *		urndis_ipq;
 };
 #define RNDIS_STATUS_BUFFER_OVERFLOW 	0x80000005L
 #define RNDIS_STATUS_FAILURE 		0xC0000001L
 #define RNDIS_STATUS_INVALID_DATA 	0xC0010015L
 #define RNDIS_STATUS_MEDIA_CONNECT 	0x4001000BL
 #define RNDIS_STATUS_MEDIA_DISCONNECT 	0x4001000CL
 #define RNDIS_STATUS_NOT_SUPPORTED 	0xC00000BBL
 #define RNDIS_STATUS_PENDING 		STATUS_PENDING /* XXX */
 #define RNDIS_STATUS_RESOURCES 		0xC000009AL
 #define RNDIS_STATUS_SUCCESS 		0x00000000L
 #define	OID_GEN_SUPPORTED_LIST		0x00010101
 #define	OID_GEN_HARDWARE_STATUS		0x00010102
 #define	OID_GEN_MEDIA_SUPPORTED		0x00010103
 #define	OID_GEN_MEDIA_IN_USE		0x00010104
 #define	OID_GEN_MAXIMUM_LOOKAHEAD	0x00010105
 #define	OID_GEN_MAXIMUM_FRAME_SIZE	0x00010106
 #define	OID_GEN_LINK_SPEED		0x00010107
 #define	OID_GEN_TRANSMIT_BUFFER_SPACE	0x00010108
 #define	OID_GEN_RECEIVE_BUFFER_SPACE	0x00010109
 #define	OID_GEN_TRANSMIT_BLOCK_SIZE	0x0001010A
 #define	OID_GEN_RECEIVE_BLOCK_SIZE	0x0001010B
 #define	OID_GEN_VENDOR_ID		0x0001010C
 #define	OID_GEN_VENDOR_DESCRIPTION	0x0001010D
 #define	OID_GEN_CURRENT_PACKET_FILTER	0x0001010E
 #define	OID_GEN_CURRENT_LOOKAHEAD	0x0001010F
 #define	OID_GEN_DRIVER_VERSION		0x00010110
 #define	OID_GEN_MAXIMUM_TOTAL_SIZE	0x00010111
 #define	OID_GEN_PROTOCOL_OPTIONS	0x00010112
 #define	OID_GEN_MAC_OPTIONS		0x00010113
 #define	OID_GEN_MEDIA_CONNECT_STATUS	0x00010114
 #define	OID_GEN_MAXIMUM_SEND_PACKETS	0x00010115
 #define	OID_GEN_VENDOR_DRIVER_VERSION	0x00010116
 #define	OID_GEN_SUPPORTED_GUIDS		0x00010117
 #define	OID_GEN_NETWORK_LAYER_ADDRESSES	0x00010118
 #define	OID_GEN_TRANSPORT_HEADER_OFFSET	0x00010119
 #define	OID_GEN_MACHINE_NAME		0x0001021A
 #define	OID_GEN_RNDIS_CONFIG_PARAMETER	0x0001021B
 #define	OID_GEN_VLAN_ID			0x0001021C
 #define	OID_802_3_PERMANENT_ADDRESS	0x01010101
 #define	OID_802_3_CURRENT_ADDRESS	0x01010102
 #define	OID_802_3_MULTICAST_LIST	0x01010103
 #define	OID_802_3_MAXIMUM_LIST_SIZE	0x01010104
 #define	OID_802_3_MAC_OPTIONS		0x01010105
 #define	OID_802_3_RCV_ERROR_ALIGNMENT	0x01020101
 #define	OID_802_3_XMIT_ONE_COLLISION	0x01020102
 #define	OID_802_3_XMIT_MORE_COLLISIONS	0x01020103
 #define	OID_802_3_XMIT_DEFERRED		0x01020201
 #define	OID_802_3_XMIT_MAX_COLLISIONS	0x01020202
 #define	OID_802_3_RCV_OVERRUN		0x01020203
 #define	OID_802_3_XMIT_UNDERRUN		0x01020204
 #define	OID_802_3_XMIT_HEARTBEAT_FAILURE	0x01020205
 #define	OID_802_3_XMIT_TIMES_CRS_LOST	0x01020206
 #define	OID_802_3_XMIT_LATE_COLLISIONS	0x01020207
 #define RNDIS_MEDIUM_802_3		0x00000000
 /* Device flags */
 #define RNDIS_DF_CONNECTIONLESS		0x00000001
 #define RNDIS_DF_CONNECTION_ORIENTED	0x00000002
 /*
  * RNDIS data message
  */
 #define REMOTE_NDIS_PACKET_MSG		0x00000001
 struct urndis_packet_msg {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_dataoffset;
 	uint32_t	rm_datalen;
 	uint32_t	rm_oobdataoffset;
 	uint32_t	rm_oobdatalen;
 	uint32_t	rm_oobdataelements;
 	uint32_t	rm_pktinfooffset;
 	uint32_t	rm_pktinfolen;
 	uint32_t	rm_vchandle;
 	uint32_t	rm_reserved;
 };
 /*
  * RNDIS control messages
  */
 struct urndis_comp_hdr {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_status;
 };
 /* Initialize the device. */
 #define REMOTE_NDIS_INITIALIZE_MSG	0x00000002
 #define REMOTE_NDIS_INITIALIZE_CMPLT	0x80000002
 struct urndis_init_req {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_ver_major;
 	uint32_t	rm_ver_minor;
 	uint32_t	rm_max_xfersz;
 };
 struct urndis_init_comp {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_status;
 	uint32_t	rm_ver_major;
 	uint32_t	rm_ver_minor;
 	uint32_t	rm_devflags;
 	uint32_t	rm_medium;
 	uint32_t	rm_pktmaxcnt;
 	uint32_t	rm_pktmaxsz;
 	uint32_t	rm_align;
 	uint32_t	rm_aflistoffset;
 	uint32_t	rm_aflistsz;
 };
 /* Halt the device.  No response sent. */
 #define REMOTE_NDIS_HALT_MSG		0x00000003
 struct urndis_halt_req {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 };
 /* Send a query object. */
 #define REMOTE_NDIS_QUERY_MSG		0x00000004
 #define REMOTE_NDIS_QUERY_CMPLT		0x80000004
 struct urndis_query_req {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_oid;
 	uint32_t	rm_infobuflen;
 	uint32_t	rm_infobufoffset;
 	uint32_t	rm_devicevchdl;
 };
 struct urndis_query_comp {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_status;
 	uint32_t	rm_infobuflen;
 	uint32_t	rm_infobufoffset;
 };
 /* Send a set object request. */
 #define REMOTE_NDIS_SET_MSG		0x00000005
 #define REMOTE_NDIS_SET_CMPLT		0x80000005
 struct urndis_set_req {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_oid;
 	uint32_t	rm_infobuflen;
 	uint32_t	rm_infobufoffset;
 	uint32_t	rm_devicevchdl;
 };
 struct urndis_set_comp {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_status;
 };
 #define REMOTE_NDIS_SET_PARAM_NUMERIC	0x00000000
 #define REMOTE_NDIS_SET_PARAM_STRING	0x00000002
 struct urndis_set_parameter {
 	uint32_t	rm_nameoffset;
 	uint32_t	rm_namelen;
 	uint32_t	rm_type;
 	uint32_t	rm_valueoffset;
 	uint32_t	rm_valuelen;
 };
 /* Perform a soft reset on the device. */
 #define REMOTE_NDIS_RESET_MSG		0x00000006
 #define REMOTE_NDIS_RESET_CMPLT		0x80000006
 struct urndis_reset_req {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 };
 struct urndis_reset_comp {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_status;
 	uint32_t	rm_adrreset;
 };
 /* 802.3 link-state or undefined message error. */
 #define REMOTE_NDIS_INDICATE_STATUS_MSG	0x00000007
 /* Keepalive messsage.  May be sent by device. */
 #define REMOTE_NDIS_KEEPALIVE_MSG	0x00000008
 #define REMOTE_NDIS_KEEPALIVE_CMPLT	0x80000008
 struct urndis_keepalive_req {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 };
 struct urndis_keepalive_comp {
 	uint32_t	rm_type;
 	uint32_t	rm_len;
 	uint32_t	rm_rid;
 	uint32_t	rm_status;
 };
 /* packet filter bits used by OID_GEN_CURRENT_PACKET_FILTER */
 #define RNDIS_PACKET_TYPE_DIRECTED		0x00000001
 #define RNDIS_PACKET_TYPE_MULTICAST		0x00000002
 #define RNDIS_PACKET_TYPE_ALL_MULTICAST		0x00000004
 #define RNDIS_PACKET_TYPE_BROADCAST		0x00000008
 #define RNDIS_PACKET_TYPE_SOURCE_ROUTING	0x00000010
 #define RNDIS_PACKET_TYPE_PROMISCUOUS		0x00000020
 #define RNDIS_PACKET_TYPE_SMT			0x00000040
 #define RNDIS_PACKET_TYPE_ALL_LOCAL		0x00000080
 #define RNDIS_PACKET_TYPE_GROUP			0x00001000
 #define RNDIS_PACKET_TYPE_ALL_FUNCTIONAL	0x00002000
 #define RNDIS_PACKET_TYPE_FUNCTIONAL		0x00004000
 #define RNDIS_PACKET_TYPE_MAC_FRAME		0x00008000
 /* Rndis offsets */
 #define RNDIS_HEADER_OFFSET	(sizeof(uint32_t) * 2)
 #define RNDIS_DATA_OFFSET	(sizeof(struct urndis_packet_msg) - \
 				 offsetof(struct urndis_packet_msg, \
 				 rm_dataoffset))