 @@ -1,1050 +1,1050 @@
-/*	$NetBSD: if_atu.c,v 1.73 2020/08/28 19:02:19 riastradh Exp $ */
+/*	$NetBSD: if_atu.c,v 1.74 2022/03/03 06:05:38 riastradh Exp $ */
 /*	$OpenBSD: if_atu.c,v 1.48 2004/12/30 01:53:21 dlg Exp $ */
 /*
  * Copyright (c) 2003, 2004
  *	Daan Vreeken <Danovitsch@Vitsch.net>.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by Daan Vreeken.
  * 4. Neither the name of the author nor the names of any co-contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY Daan Vreeken 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 Daan Vreeken OR THE VOICES IN HIS HEAD
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Atmel AT76c503 / AT76c503a / AT76c505 / AT76c505a  USB WLAN driver
  * version 0.5 - 2004-08-03
+ *
  * Originally written by Daan Vreeken <Danovitsch @ Vitsch . net>
  *  http://vitsch.net/bsd/atuwi
+ *
  * Contributed to by :
  *  Chris Whitehouse, Alistair Phillips, Peter Pilka, Martijn van Buul,
  *  Suihong Liang, Arjan van Leeuwen, Stuart Walsh
+ *
  * Ported to OpenBSD by Theo de Raadt and David Gwynne.
  * Ported to NetBSD by Jesse Off
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_atu.c,v 1.73 2020/08/28 19:02:19 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_atu.c,v 1.74 2022/03/03 06:05:38 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/sockio.h>
 #include <sys/mbuf.h>
 #include <sys/kernel.h>
 #include <sys/socket.h>
 #include <sys/systm.h>
 #include <sys/kthread.h>
 #include <sys/queue.h>
 #include <sys/device.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/microcode/atmel/atmel_intersil_fw.h>
 #include <dev/microcode/atmel/atmel_rfmd2958-smc_fw.h>
 #include <dev/microcode/atmel/atmel_rfmd2958_fw.h>
 #include <dev/microcode/atmel/atmel_rfmd_fw.h>
 #include <net/bpf.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_media.h>
 #include <net/if_ether.h>
 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/if_ether.h>
 #endif
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_radiotap.h>
 #include <dev/usb/if_atureg.h>
 #ifdef ATU_DEBUG
 #define DPRINTF(x)	do { if (atudebug) printf x; } while (0)
 #define DPRINTFN(n,x)	do { if (atudebug>(n)) printf x; } while (0)
 int atudebug = 1;
 #else
 #define DPRINTF(x)
 #define DPRINTFN(n,x)
 #endif
 /*
  * Various supported device vendors/products/radio type.
  */
 static const struct atu_type atu_devs[] = {
 	{ USB_VENDOR_3COM,	USB_PRODUCT_3COM_3CRSHEW696,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_ABOCOM,	USB_PRODUCT_ABOCOM_BWU613,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_ACCTON,	USB_PRODUCT_ACCTON_2664W,
 	  AT76C503_rfmd_acc,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ACERP,	USB_PRODUCT_ACERP_AWL300,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ACERP,	USB_PRODUCT_ACERP_AWL400,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_ACTIONTEC,	USB_PRODUCT_ACTIONTEC_UAT1,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_ADDTRON,	USB_PRODUCT_ADDTRON_AWU120,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_AINCOMM,	USB_PRODUCT_AINCOMM_AWU2000B,
 	  RadioRFMD2958,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ASKEY,	USB_PRODUCT_ASKEY_VOYAGER1010,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ASKEY,	USB_PRODUCT_ASKEY_WLL013I,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ASKEY,	USB_PRODUCT_ASKEY_WLL013,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_AT76C503I1,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_AT76C503I2,
 	  AT76C503_i3863,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_AT76C503RFMD,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_AT76C505RFMD,
 	  AT76C505_rfmd,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_AT76C505RFMD2958,
 	  RadioRFMD2958,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_AT76C505A, /* SMC2662 V.4 */
 	  RadioRFMD2958_SMC,	ATU_QUIRK_NO_REMAP | ATU_QUIRK_FW_DELAY },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_AT76C505AS, /* quirk? */
 	  RadioRFMD2958_SMC,	ATU_QUIRK_NO_REMAP | ATU_QUIRK_FW_DELAY },
 	{ USB_VENDOR_ATMEL,	USB_PRODUCT_ATMEL_WN210,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_BELKIN,	USB_PRODUCT_BELKIN_F5D6050,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_CONCEPTRONIC, USB_PRODUCT_CONCEPTRONIC_C11U,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_CONCEPTRONIC, USB_PRODUCT_CONCEPTRONIC_WL210,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_COMPAQ,	USB_PRODUCT_COMPAQ_IPAQWLAN,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_COREGA,	USB_PRODUCT_COREGA_WLUSB_11_STICK,
 	  RadioRFMD2958,	ATU_NO_QUIRK },
 	{ USB_VENDOR_DICKSMITH,	USB_PRODUCT_DICKSMITH_CHUSB611G,
 	  RadioRFMD2958,	ATU_NO_QUIRK },
 	{ USB_VENDOR_DICKSMITH,	USB_PRODUCT_DICKSMITH_WL200U,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_DICKSMITH,	USB_PRODUCT_DICKSMITH_WL240U,
 	  RadioRFMD2958,	ATU_NO_QUIRK },
 	{ USB_VENDOR_DICKSMITH,	USB_PRODUCT_DICKSMITH_XH1153,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_DLINK,	USB_PRODUCT_DLINK_DWL120E,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_GIGABYTE,	USB_PRODUCT_GIGABYTE_GNWLBM101,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_GIGASET,	USB_PRODUCT_GIGASET_WLAN, /* quirk? */
 	  RadioRFMD2958_SMC,	ATU_QUIRK_NO_REMAP | ATU_QUIRK_FW_DELAY },
 	{ USB_VENDOR_HP,	USB_PRODUCT_HP_HN210W,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_INTEL,	USB_PRODUCT_INTEL_AP310,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_IODATA,	USB_PRODUCT_IODATA_USBWNB11A,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_LEXAR,	USB_PRODUCT_LEXAR_2662WAR,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_LINKSYS,	USB_PRODUCT_LINKSYS_WUSB11,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_LINKSYS2,	USB_PRODUCT_LINKSYS2_WUSB11,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_LINKSYS2,	USB_PRODUCT_LINKSYS2_NWU11B,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_LINKSYS3,	USB_PRODUCT_LINKSYS3_WUSB11V28,
 	  RadioRFMD2958,	ATU_NO_QUIRK },
 	{ USB_VENDOR_MSI,	USB_PRODUCT_MSI_WLAN,
 	  RadioRFMD2958,	ATU_NO_QUIRK },
 	{ USB_VENDOR_NETGEAR2,	USB_PRODUCT_NETGEAR2_MA101,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_NETGEAR2,	USB_PRODUCT_NETGEAR2_MA101B,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_OQO,	USB_PRODUCT_OQO_WIFI01,
 	  RadioRFMD2958_SMC,	ATU_QUIRK_NO_REMAP | ATU_QUIRK_FW_DELAY },
 	{ USB_VENDOR_PLANEX2,	USB_PRODUCT_PLANEX2_GW_US11S,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_SAMSUNG,	USB_PRODUCT_SAMSUNG_SWL2100W,
 	  AT76C503_i3863,	ATU_NO_QUIRK },
 	{ USB_VENDOR_SIEMENS2,	USB_PRODUCT_SIEMENS2_WLL013,
 	  RadioRFMD,		ATU_NO_QUIRK },
 	{ USB_VENDOR_SMC3,	USB_PRODUCT_SMC3_2662WV1,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_SMC3,	USB_PRODUCT_SMC3_2662WV2,
 	  AT76C503_rfmd_acc,	ATU_NO_QUIRK },
 	{ USB_VENDOR_TEKRAM,	USB_PRODUCT_TEKRAM_U300C,
 	  RadioIntersil,	ATU_NO_QUIRK },
 	{ USB_VENDOR_ZCOM,	USB_PRODUCT_ZCOM_M4Y750,
 	  RadioIntersil,	ATU_NO_QUIRK },
 };
 static const struct atu_radfirm {
 	enum	atu_radio_type atur_type;
 	unsigned char	*atur_internal;
 	size_t		atur_internal_sz;
 	unsigned char	*atur_external;
 	size_t		atur_external_sz;
 } atu_radfirm[] = {
 	{ RadioRFMD,
 	  atmel_fw_rfmd_int,		sizeof(atmel_fw_rfmd_int),
 	  atmel_fw_rfmd_ext,		sizeof(atmel_fw_rfmd_ext) },
 	{ RadioRFMD2958,
 	  atmel_fw_rfmd2958_int,	sizeof(atmel_fw_rfmd2958_int),
 	  atmel_fw_rfmd2958_ext,	sizeof(atmel_fw_rfmd2958_ext) },
 	{ RadioRFMD2958_SMC,
 	  atmel_fw_rfmd2958_smc_int,	sizeof(atmel_fw_rfmd2958_smc_int),
 	  atmel_fw_rfmd2958_smc_ext,	sizeof(atmel_fw_rfmd2958_smc_ext) },
 	{ RadioIntersil,
 	  atmel_fw_intersil_int,	sizeof(atmel_fw_intersil_int),
 	  atmel_fw_intersil_ext,	sizeof(atmel_fw_intersil_ext) }
 };
 static int	atu_newbuf(struct atu_softc *, struct atu_chain *, struct mbuf *);
 static void	atu_rxeof(struct usbd_xfer *, void *, usbd_status);
 static void	atu_txeof(struct usbd_xfer *, void *, usbd_status);
 static void	atu_start(struct ifnet *);
 static int	atu_ioctl(struct ifnet *, u_long, void *);
 static int	atu_init(struct ifnet *);
 static void	atu_stop(struct ifnet *, int);
 static void	atu_watchdog(struct ifnet *);
 static usbd_status atu_usb_request(struct atu_softc *, uint8_t,
 	    uint8_t, uint16_t, uint16_t,
 	    uint16_t, uint8_t *);
 static int	atu_send_command(struct atu_softc *, uint8_t *, int);
 static int	atu_get_cmd_status(struct atu_softc *, uint8_t,
 	    uint8_t *);
 static int	atu_wait_completion(struct atu_softc *, uint8_t,
 	    uint8_t *);
 static int	atu_send_mib(struct atu_softc *, uint8_t,
 	    uint8_t, uint8_t, void *);
 static int	atu_get_mib(struct atu_softc *, uint8_t,
 	    uint8_t, uint8_t, uint8_t *);
 #if 0
 int	atu_start_ibss(struct atu_softc *);
 #endif
 static int	atu_start_scan(struct atu_softc *);
 static int	atu_switch_radio(struct atu_softc *, int);
 static int	atu_initial_config(struct atu_softc *);
 static int	atu_join(struct atu_softc *, struct ieee80211_node *);
 static int8_t	atu_get_dfu_state(struct atu_softc *);
 static uint8_t atu_get_opmode(struct atu_softc *, uint8_t *);
 static void	atu_internal_firmware(device_t);
 static void	atu_external_firmware(device_t);
 static int	atu_get_card_config(struct atu_softc *);
 static int	atu_media_change(struct ifnet *);
 static void	atu_media_status(struct ifnet *, struct ifmediareq *);
 static int	atu_tx_list_init(struct atu_softc *);
 static int	atu_rx_list_init(struct atu_softc *);
 static void	atu_xfer_list_free(struct atu_softc *, struct atu_chain *,
 	    int);
 static void atu_task(void *);
 static int atu_newstate(struct ieee80211com *, enum ieee80211_state, int);
 static int atu_tx_start(struct atu_softc *, struct ieee80211_node *,
     struct atu_chain *, struct mbuf *);
 static void atu_complete_attach(struct atu_softc *);
 static uint8_t atu_calculate_padding(int);
 static int atu_match(device_t, cfdata_t, void *);
 static void atu_attach(device_t, device_t, void *);
 static int atu_detach(device_t, int);
 static int atu_activate(device_t, enum devact);
 CFATTACH_DECL_NEW(atu, sizeof(struct atu_softc), atu_match, atu_attach,
     atu_detach, atu_activate);
 static usbd_status
 atu_usb_request(struct atu_softc *sc, uint8_t type,
     uint8_t request, uint16_t value, uint16_t index, uint16_t length,
     uint8_t *data)
+{
 	usb_device_request_t	req;
 	struct usbd_xfer	*xfer;
 	usbd_status		err;
 	int			total_len = 0, s;
 	req.bmRequestType = type;
 	req.bRequest = request;
 	USETW(req.wValue, value);
 	USETW(req.wIndex, index);
 	USETW(req.wLength, length);
 #ifdef ATU_DEBUG
 	if (atudebug) {
 		DPRINTFN(20, ("%s: req=%02x val=%02x ind=%02x "
 		    "len=%02x\n", device_xname(sc->atu_dev), request,
 		    value, index, length));
+	}
 #endif /* ATU_DEBUG */
 	s = splnet();
 	struct usbd_pipe *pipe0 = usbd_get_pipe0(sc->atu_udev);
 	int error = usbd_create_xfer(pipe0, length, 0, 0,
 	    &xfer);
 	if (error) {
 		splx(s);
 		return USBD_IOERROR;
+	}
 	usbd_setup_default_xfer(xfer, sc->atu_udev, 0, 500000, &req, data,
 	    length, USBD_SHORT_XFER_OK, NULL);
 	err = usbd_sync_transfer(xfer);
 	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
 #ifdef ATU_DEBUG
 	if (atudebug) {
 		if (type & UT_READ) {
 			DPRINTFN(20, ("%s: transferred %#x bytes in\n",
 			    device_xname(sc->atu_dev), total_len));
 		} else {
 			if (total_len != length)
 				DPRINTF(("%s: wrote only %x bytes\n",
 				    device_xname(sc->atu_dev), total_len));
+		}
+	}
 #endif /* ATU_DEBUG */
 	usbd_destroy_xfer(xfer);
 	splx(s);
 	return err;
+}
 static int
 atu_send_command(struct atu_softc *sc, uint8_t *command, int size)
+{
 	return atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0000,
 x0000, size, command);
+}
 static int
 atu_get_cmd_status(struct atu_softc *sc, uint8_t cmd, uint8_t *status)
+{
 	/*
 	 * all other drivers (including Windoze) request 40 bytes of status
 	 * and get a short-xfer of just 6 bytes. we can save 34 bytes of
 	 * buffer if we just request those 6 bytes in the first place :)
 	 */
 	/*
 	return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x22, cmd,
 x0000, 40, status);
 	*/
 	return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x22, cmd,
 x0000, 6, status);
+}
 static int
 atu_wait_completion(struct atu_softc *sc, uint8_t cmd, uint8_t *status)
+{
 	int			idle_count = 0, err;
 	uint8_t			statusreq[6];
 	DPRINTFN(15, ("%s: wait-completion: cmd=%02x\n",
 	    device_xname(sc->atu_dev), cmd));
 	while (1) {
 		err = atu_get_cmd_status(sc, cmd, statusreq);
 		if (err)
 			return err;
 #ifdef ATU_DEBUG
 		if (atudebug) {
 			DPRINTFN(20, ("%s: status=%s cmd=%02x\n",
 			    device_xname(sc->atu_dev),
 			ether_sprintf(statusreq), cmd));
+		}
 #endif /* ATU_DEBUG */
 		/*
 		 * during normal operations waiting on STATUS_IDLE
 		 * will never happen more than once
 		 */
 		if ((statusreq[5] == STATUS_IDLE) && (idle_count++ > 20)) {
 			DPRINTF(("%s: idle_count > 20!\n",
 			    device_xname(sc->atu_dev)));
 			return 0;
+		}
 		if ((statusreq[5] != STATUS_IN_PROGRESS) &&
 		    (statusreq[5] != STATUS_IDLE)) {
 			if (status != NULL)
 				*status = statusreq[5];
 			return 0;
+		}
 		usbd_delay_ms(sc->atu_udev, 25);
+	}
+}
 static int
 atu_send_mib(struct atu_softc *sc, uint8_t type, uint8_t size,
     uint8_t index, void *data)
+{
 	int				err;
 	struct atu_cmd_set_mib		request;
 	/*
 	 * We don't construct a MIB packet first and then memcpy it into an
 	 * Atmel-command-packet, we just construct it the right way at once :)
 	 */
 	memset(&request, 0, sizeof(request));
 	request.AtCmd = CMD_SET_MIB;
 	USETW(request.AtSize, size + 4);
 	request.MIBType = type;
 	request.MIBSize = size;
 	request.MIBIndex = index;
 	request.MIBReserved = 0;
 	/*
 	 * For 1 and 2 byte requests we assume a direct value,
 	 * everything bigger than 2 bytes we assume a pointer to the data
 	 */
 	switch (size) {
 	case 0:
 		break;
 	case 1:
 		request.data[0]=(long)data & 0x000000ff;
 		break;
 	case 2:
 		request.data[0]=(long)data & 0x000000ff;
 		request.data[1]=(long)data >> 8;
 		break;
 	default:
 		memcpy(request.data, data, size);
 		break;
+	}
 	err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0000,
 x0000, size+8, (uByte *)&request);
 	if (err)
 		return err;
 	DPRINTFN(15, ("%s: sendmib : waitcompletion...\n",
 	    device_xname(sc->atu_dev)));
 	return atu_wait_completion(sc, CMD_SET_MIB, NULL);
+}
 static int
 atu_get_mib(struct atu_softc *sc, uint8_t type, uint8_t size,
     uint8_t index, uint8_t *buf)
+{
 	/* linux/at76c503.c - 478 */
 	return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x033,
 	    type << 8, index, size, buf);
+}
 #if 0
 int
 atu_start_ibss(struct atu_softc *sc)
+{
 	struct ieee80211com		*ic = &sc->sc_ic;
 	int				err;
 	struct atu_cmd_start_ibss	Request;
 	Request.Cmd = CMD_START_IBSS;
 	Request.Reserved = 0;
 	Request.Size = sizeof(Request) - 4;
 	memset(Request.BSSID, 0x00, sizeof(Request.BSSID));
 	memset(Request.SSID, 0x00, sizeof(Request.SSID));
 	memcpy(Request.SSID, ic->ic_des_ssid, ic->ic_des_ssidlen);
 	Request.SSIDSize = ic->ic_des_ssidlen;
 	if (sc->atu_desired_channel != IEEE80211_CHAN_ANY)
 		Request.Channel = (uint8_t)sc->atu_desired_channel;
 	else
 		Request.Channel = ATU_DEFAULT_CHANNEL;
 	Request.BSSType = AD_HOC_MODE;
 	memset(Request.Res, 0x00, sizeof(Request.Res));
 	/* Write config to adapter */
 	err = atu_send_command(sc, (uint8_t *)&Request, sizeof(Request));
 	if (err) {
 		DPRINTF(("%s: start ibss failed!\n",
 		    device_xname(sc->atu_dev)));
 		return err;
+	}
 	/* Wait for the adapter to do its thing */
 	err = atu_wait_completion(sc, CMD_START_IBSS, NULL);
 	if (err) {
 		DPRINTF(("%s: error waiting for start_ibss\n",
 		    device_xname(sc->atu_dev)));
 		return err;
+	}
 	/* Get the current BSSID */
 	err = atu_get_mib(sc, MIB_MAC_MGMT__CURRENT_BSSID, sc->atu_bssid);
 	if (err) {
 		DPRINTF(("%s: could not get BSSID!\n",
 		    device_xname(sc->atu_dev)));
 		return err;
+	}
 	DPRINTF(("%s: started a new IBSS (BSSID=%s)\n",
 	    device_xname(sc->atu_dev), ether_sprintf(sc->atu_bssid)));
 	return 0;
+}
 #endif
 static int
 atu_start_scan(struct atu_softc *sc)
+{
 	struct ieee80211com		*ic = &sc->sc_ic;
 	struct atu_cmd_do_scan		Scan;
 	usbd_status			err;
 	int				Cnt;
 	memset(&Scan, 0, sizeof(Scan));
 	Scan.Cmd = CMD_START_SCAN;
 	Scan.Reserved = 0;
 	USETW(Scan.Size, sizeof(Scan) - 4);
 	/* use the broadcast BSSID (in active scan) */
 	for (Cnt=0; Cnt<6; Cnt++)
 		Scan.BSSID[Cnt] = 0xff;
 	memset(Scan.SSID, 0x00, sizeof(Scan.SSID));
 	memcpy(Scan.SSID, ic->ic_des_essid, ic->ic_des_esslen);
 	Scan.SSID_Len = ic->ic_des_esslen;
 	/* default values for scan */
 	Scan.ScanType = ATU_SCAN_ACTIVE;
 	if (sc->atu_desired_channel != IEEE80211_CHAN_ANY)
 		Scan.Channel = (uint8_t)sc->atu_desired_channel;
 	else
 		Scan.Channel = sc->atu_channel;
 	ic->ic_curchan = &ic->ic_channels[Scan.Channel];
 	/* we like scans to be quick :) */
 	/* the time we wait before sending probe's */
 	USETW(Scan.ProbeDelay, 0);
 	/* the time we stay on one channel */
 	USETW(Scan.MinChannelTime, 100);
 	USETW(Scan.MaxChannelTime, 200);
 	/* whether or not we scan all channels */
 	Scan.InternationalScan = 0xc1;
 #ifdef ATU_DEBUG
 	if (atudebug) {
 		DPRINTFN(20, ("%s: scan cmd len=%02zx\n",
 		    device_xname(sc->atu_dev), sizeof(Scan)));
+	}
 #endif /* ATU_DEBUG */
 	/* Write config to adapter */
 	err = atu_send_command(sc, (uint8_t *)&Scan, sizeof(Scan));
 	if (err)
 		return err;
 	/*
 	 * We don't wait for the command to finish... the mgmt-thread will do
 	 * that for us
 	 */
 	/*
 	err = atu_wait_completion(sc, CMD_START_SCAN, NULL);
 	if (err)
 		return err;
 	*/
 	return 0;
+}
 static int
 atu_switch_radio(struct atu_softc *sc, int state)
+{
 	usbd_status		err;
 	struct atu_cmd		CmdRadio;
 	if (sc->atu_radio == RadioIntersil) {
 		/*
 		 * Intersil doesn't seem to need/support switching the radio
 		 * on/off
 		 */
 		return 0;
+	}
 	memset(&CmdRadio, 0, sizeof(CmdRadio));
 	CmdRadio.Cmd = CMD_RADIO_ON;
 	if (sc->atu_radio_on != state) {
 		if (state == 0)
 			CmdRadio.Cmd = CMD_RADIO_OFF;
 		err = atu_send_command(sc, (uint8_t *)&CmdRadio,
 		    sizeof(CmdRadio));
 		if (err)
 			return err;
 		err = atu_wait_completion(sc, CmdRadio.Cmd, NULL);
 		if (err)
 			return err;
 		DPRINTFN(10, ("%s: radio turned %s\n",
 		    device_xname(sc->atu_dev), state ? "on" : "off"));
 		sc->atu_radio_on = state;
+	}
 	return 0;
+}
 static int
 atu_initial_config(struct atu_softc *sc)
+{
 	struct ieee80211com		*ic = &sc->sc_ic;
 	uint32_t			i;
 	usbd_status			err;
 /*	uint8_t				rates[4] = {0x82, 0x84, 0x8B, 0x96};*/
 	uint8_t				rates[4] = {0x82, 0x04, 0x0B, 0x16};
 	struct atu_cmd_card_config	cmd;
 	uint8_t				reg_domain;
 	DPRINTFN(10, ("%s: sending mac-addr\n", device_xname(sc->atu_dev)));
 	err = atu_send_mib(sc, MIB_MAC_ADDR__ADDR, ic->ic_myaddr);
 	if (err) {
 		DPRINTF(("%s: error setting mac-addr\n",
 		    device_xname(sc->atu_dev)));
 		return err;
+	}
 	/*
 	DPRINTF(("%s: sending reg-domain\n", device_xname(sc->atu_dev)));
 	err = atu_send_mib(sc, MIB_PHY__REG_DOMAIN, NR(0x30));
 	if (err) {
 		DPRINTF(("%s: error setting mac-addr\n",
 		    device_xname(sc->atu_dev)));
 		return err;
+	}
 	*/
 	memset(&cmd, 0, sizeof(cmd));
 	cmd.Cmd = CMD_STARTUP;
 	cmd.Reserved = 0;
 	USETW(cmd.Size, sizeof(cmd) - 4);
 	if (sc->atu_desired_channel != IEEE80211_CHAN_ANY)
 		cmd.Channel = (uint8_t)sc->atu_desired_channel;
 	else
 		cmd.Channel = sc->atu_channel;
 	cmd.AutoRateFallback = 1;
 	memcpy(cmd.BasicRateSet, rates, 4);
 	/* ShortRetryLimit should be 7 according to 802.11 spec */
 	cmd.ShortRetryLimit = 7;
 	USETW(cmd.RTS_Threshold, 2347);
 	USETW(cmd.FragThreshold, 2346);
 	/* Doesn't seem to work, but we'll set it to 1 anyway */
 	cmd.PromiscuousMode = 1;
 	/* this goes into the beacon we transmit */
 	if (ic->ic_flags & IEEE80211_F_PRIVACY)
 		cmd.PrivacyInvoked = 1;
 	else
 		cmd.PrivacyInvoked = 0;
 	cmd.ExcludeUnencrypted = 0;
 	if (ic->ic_flags & IEEE80211_F_PRIVACY) {
 		switch (ic->ic_nw_keys[ic->ic_def_txkey].wk_keylen) {
 		case 5:
 			cmd.EncryptionType = ATU_WEP_40BITS;
 			break;
 		case 13:
 			cmd.EncryptionType = ATU_WEP_104BITS;
 			break;
 		default:
 			cmd.EncryptionType = ATU_WEP_OFF;
 			break;
+		}
 		cmd.WEP_DefaultKeyID = ic->ic_def_txkey;
 		for (i = 0; i < IEEE80211_WEP_NKID; i++) {
 			memcpy(cmd.WEP_DefaultKey[i], ic->ic_nw_keys[i].wk_key,
 			    ic->ic_nw_keys[i].wk_keylen);
+		}
+	}
 	/* Setting the SSID here doesn't seem to do anything */
 	memset(cmd.SSID, 0x00, sizeof(cmd.SSID));
 	memcpy(cmd.SSID, ic->ic_des_essid, ic->ic_des_esslen);
 	cmd.SSID_Len = ic->ic_des_esslen;
 	cmd.ShortPreamble = 0;
 	USETW(cmd.BeaconPeriod, 100);
 	/* cmd.BeaconPeriod = 65535; */
 	/*
 	 * TODO:
 	 * read reg domain MIB_PHY @ 0x17 (1 byte), (reply = 0x30)
 	 * we should do something useful with this info. right now it's just
 	 * ignored
 	 */
 	err = atu_get_mib(sc, MIB_PHY__REG_DOMAIN, &reg_domain);
 	if (err) {
 		DPRINTF(("%s: could not get regdomain!\n",
 		    device_xname(sc->atu_dev)));
 	} else {
 		DPRINTF(("%s: in reg domain %#x according to the "
 		    "adapter\n", device_xname(sc->atu_dev), reg_domain));
+	}
 #ifdef ATU_DEBUG
 	if (atudebug) {
 		DPRINTFN(20, ("%s: configlen=%02zx\n",
 			device_xname(sc->atu_dev), sizeof(cmd)));
+	}
 #endif /* ATU_DEBUG */
 	/* Windoze : driver says exclude-unencrypted=1 & encr-type=1 */
 	err = atu_send_command(sc, (uint8_t *)&cmd, sizeof(cmd));
 	if (err)
 		return err;
 	err = atu_wait_completion(sc, CMD_STARTUP, NULL);
 	if (err)
 		return err;
 	/* Turn on radio now */
 	err = atu_switch_radio(sc, 1);
 	if (err)
 		return err;
 	/* preamble type = short */
 	err = atu_send_mib(sc, MIB_LOCAL__PREAMBLE, NR(PREAMBLE_SHORT));
 	if (err)
 		return err;
 	/* frag = 1536 */
 	err = atu_send_mib(sc, MIB_MAC__FRAG, NR(2346));
 	if (err)
 		return err;
 	/* rts = 1536 */
 	err = atu_send_mib(sc, MIB_MAC__RTS, NR(2347));
 	if (err)
 		return err;
 	/* auto rate fallback = 1 */
 	err = atu_send_mib(sc, MIB_LOCAL__AUTO_RATE_FALLBACK, NR(1));
 	if (err)
 		return err;
 	/* power mode = full on, no power saving */
 	err = atu_send_mib(sc, MIB_MAC_MGMT__POWER_MODE,
 	    NR(POWER_MODE_ACTIVE));
 	if (err)
 		return err;
 	DPRINTFN(10, ("%s: completed initial config\n",
 	   device_xname(sc->atu_dev)));
 	return 0;
+}
 static int
 atu_join(struct atu_softc *sc, struct ieee80211_node *node)
+{
 	struct atu_cmd_join	join;
 	uint8_t			status = 0;	/* XXX: GCC */
 	usbd_status		err;
 	memset(&join, 0, sizeof(join));
 	join.Cmd = CMD_JOIN;
 	join.Reserved = 0x00;
 	USETW(join.Size, sizeof(join) - 4);
 	DPRINTFN(15, ("%s: pre-join sc->atu_bssid=%s\n",
 	    device_xname(sc->atu_dev), ether_sprintf(sc->atu_bssid)));
 	DPRINTFN(15, ("%s: mode=%d\n", device_xname(sc->atu_dev),
 	    sc->atu_mode));
 	memcpy(join.bssid, node->ni_bssid, IEEE80211_ADDR_LEN);
 	memset(join.essid, 0x00, 32);
 	memcpy(join.essid, node->ni_essid, node->ni_esslen);
 	join.essid_size = node->ni_esslen;
 	if (node->ni_capinfo & IEEE80211_CAPINFO_IBSS)
 		join.bss_type = AD_HOC_MODE;
 	else
 		join.bss_type = INFRASTRUCTURE_MODE;
 	join.channel = ieee80211_chan2ieee(&sc->sc_ic, node->ni_chan);
 	USETW(join.timeout, ATU_JOIN_TIMEOUT);
 	join.reserved = 0x00;
 	DPRINTFN(10, ("%s: trying to join BSSID=%s\n",
 	    device_xname(sc->atu_dev), ether_sprintf(join.bssid)));
 	err = atu_send_command(sc, (uint8_t *)&join, sizeof(join));
 	if (err) {
 		DPRINTF(("%s: ERROR trying to join IBSS\n",
 		    device_xname(sc->atu_dev)));
 		return err;
+	}
 	err = atu_wait_completion(sc, CMD_JOIN, &status);
 	if (err) {
 		DPRINTF(("%s: error joining BSS!\n",
 		    device_xname(sc->atu_dev)));
 		return err;
+	}
 	if (status != STATUS_COMPLETE) {
 		DPRINTF(("%s: error joining... [status=%02x]\n",
 		    device_xname(sc->atu_dev), status));
 		return status;
 	} else {
 		DPRINTFN(10, ("%s: joined BSS\n", device_xname(sc->atu_dev)));
+	}
 	return err;
+}
 /*
  * Get the state of the DFU unit
  */
 static int8_t
 atu_get_dfu_state(struct atu_softc *sc)
+{
 	uint8_t	state;
 	if (atu_usb_request(sc, DFU_GETSTATE, 0, 0, 1, &state))
 		return -1;
 	return state;
+}
 /*
  * Get MAC opmode
  */
 static uint8_t
 atu_get_opmode(struct atu_softc *sc, uint8_t *mode)
+{
 	return atu_usb_request(sc, UT_READ_VENDOR_INTERFACE, 0x33, 0x0001,
 x0000, 1, mode);
+}
 /*
  * Upload the internal firmware into the device
  */
 static void
 atu_internal_firmware(device_t arg)
+{
 	struct atu_softc *sc = device_private(arg);
 	u_char	state, *ptr = NULL, *firm = NULL, status[6];
 	int block_size, block = 0, err, i;
 	size_t	bytes_left = 0;
 	/*
 	 * Uploading firmware is done with the DFU (Device Firmware Upgrade)
 	 * interface. See "Universal Serial Bus - Device Class Specification
 	 * for Device Firmware Upgrade" pdf for details of the protocol.
 	 * Maybe this could be moved to a separate 'firmware driver' once more
 	 * device drivers need it... For now we'll just do it here.
+	 *
 	 * Just for your information, the Atmel's DFU descriptor looks like
 	 * this:
+	 *
 	 * 07		size
 	 * 21		type
 	 * 01		capabilities : only firmware download, need reset
 	 *		  after download
 	 * 13 05	detach timeout : max 1299ms between DFU_DETACH and
 	 *		  reset
 	 * 00 04	max bytes of firmware per transaction : 1024
 	 */
 	/* Choose the right firmware for the device */
 	for (i = 0; i < __arraycount(atu_radfirm); i++)
 		if (sc->atu_radio == atu_radfirm[i].atur_type) {
 			firm = atu_radfirm[i].atur_internal;
 			bytes_left = atu_radfirm[i].atur_internal_sz;
+		}
 	if (firm == NULL) {
 		aprint_error_dev(arg, "no firmware found\n");
 		return;
+	}
 	ptr = firm;
 	state = atu_get_dfu_state(sc);
 	while (block >= 0 && state > 0) {
 		switch (state) {
 		case DFUState_DnLoadSync:
 			/* get DFU status */
 			err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0 , 6,
 			    status);
 			if (err) {
 				DPRINTF(("%s: dfu_getstatus failed!\n",
 				    device_xname(sc->atu_dev)));
 				return;
+			}
 			/* success means state => DnLoadIdle */
 			state = DFUState_DnLoadIdle;
 			continue;
 			break;
 		case DFUState_DFUIdle:
 		case DFUState_DnLoadIdle:
 			if (bytes_left>=DFU_MaxBlockSize)
 				block_size = DFU_MaxBlockSize;
 			else
 				block_size = bytes_left;
 			DPRINTFN(15, ("%s: firmware block %d\n",
 			    device_xname(sc->atu_dev), block));
 			err = atu_usb_request(sc, DFU_DNLOAD, block++, 0,
 			    block_size, ptr);
 			if (err) {
 				DPRINTF(("%s: dfu_dnload failed\n",
 				    device_xname(sc->atu_dev)));
 				return;
+			}
 			ptr += block_size;
 			bytes_left -= block_size;
 			if (block_size == 0)
 				block = -1;
 			break;
 		default:
 			usbd_delay_ms(sc->atu_udev, 100);
 			DPRINTFN(20, ("%s: sleeping for a while\n",
 			    device_xname(sc->atu_dev)));
 			break;
+		}
 		state = atu_get_dfu_state(sc);
+	}
 	if (state != DFUState_ManifestSync) {
 		DPRINTF(("%s: state != manifestsync... eek!\n",
 		    device_xname(sc->atu_dev)));
+	}
 	err = atu_usb_request(sc, DFU_GETSTATUS, 0, 0, 6, status);
 	if (err) {
 		DPRINTF(("%s: dfu_getstatus failed!\n",
 		    device_xname(sc->atu_dev)));
 		return;
+	}
 	DPRINTFN(15, ("%s: sending remap\n", device_xname(sc->atu_dev)));
 	err = atu_usb_request(sc, DFU_REMAP, 0, 0, 0, NULL);
 	if ((err) && !(sc->atu_quirk & ATU_QUIRK_NO_REMAP)) {
 		DPRINTF(("%s: remap failed!\n", device_xname(sc->atu_dev)));
 		return;
+	}
 	/* after a lot of trying and measuring I found out the device needs
 	 * about 56 miliseconds after sending the remap command before
 	 * it's ready to communicate again. So we'll wait just a little bit
 	 * longer than that to be sure...
 	 */
 	usbd_delay_ms(sc->atu_udev, 56+100);
 	aprint_error_dev(arg, "reattaching after firmware upload\n");
 	usb_needs_reattach(sc->atu_udev);
+}
 static void
 atu_external_firmware(device_t arg)
+{
 	struct atu_softc *sc = device_private(arg);
 	u_char	*ptr = NULL, *firm = NULL;
 	int	block_size, block = 0, err, i;
 	size_t	bytes_left = 0;
 	for (i = 0; i < __arraycount(atu_radfirm); i++)
 		if (sc->atu_radio == atu_radfirm[i].atur_type) {
 			firm = atu_radfirm[i].atur_external;
 			bytes_left = atu_radfirm[i].atur_external_sz;
+		}
 	if (firm == NULL) {
 		aprint_error_dev(arg, "no firmware found\n");
 		return;
+	}
 	ptr = firm;
 	while (bytes_left) {
 		if (bytes_left > 1024)
 			block_size = 1024;
 		else
 			block_size = bytes_left;
 		DPRINTFN(15, ("%s: block:%d size:%d\n",
 		    device_xname(sc->atu_dev), block, block_size));
 		err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e,
 x0802, block, block_size, ptr);
 		if (err) {
 			DPRINTF(("%s: could not load external firmware "
 			    "block\n", device_xname(sc->atu_dev)));
 			return;
+		}
 		ptr += block_size;
 		block++;
 		bytes_left -= block_size;
+	}
 	err = atu_usb_request(sc, UT_WRITE_VENDOR_DEVICE, 0x0e, 0x0802,
 	    block, 0, NULL);
 	if (err) {
 		DPRINTF(("%s: could not load last zero-length firmware "
 		    "block\n", device_xname(sc->atu_dev)));
 		return;
+	}
 	/*
 	 * The SMC2662w V.4 seems to require some time to do its thing with
 	 * the external firmware... 20 ms isn't enough, but 21 ms works 100
 	 * times out of 100 tries. We'll wait a bit longer just to be sure
 	 */
 	if (sc->atu_quirk & ATU_QUIRK_FW_DELAY)
 		usbd_delay_ms(sc->atu_udev, 21 + 100);
 	DPRINTFN(10, ("%s: external firmware upload done\n",
 	    device_xname(sc->atu_dev)));
 	/* complete configuration after the firmwares have been uploaded */
 	atu_complete_attach(sc);
+}
 static int
 atu_get_card_config(struct atu_softc *sc)
+{
 	struct ieee80211com		*ic = &sc->sc_ic;
 	struct atu_rfmd_conf		rfmd_conf;
 	struct atu_intersil_conf	intersil_conf;
 	int				err;
 @@ -1239,1043 +1239,1035 @@ atu_attach(device_t parent, device_t sel
 	usbd_status		err;
 	struct usbd_device	*dev = uaa->uaa_device;
 	uint8_t			mode, channel;
 	int i;
 	sc->atu_dev = self;
 	sc->sc_state = ATU_S_UNCONFIG;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(dev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	err = usbd_set_config_no(dev, ATU_CONFIG_NO, 1);
 	if (err) {
 		aprint_error_dev(self, "failed to set configuration"
 		    ", err=%s\n", usbd_errstr(err));
 		return;
+	}
 	err = usbd_device2interface_handle(dev, ATU_IFACE_IDX, &sc->atu_iface);
 	if (err) {
 		aprint_error_dev(self, "getting interface handle failed\n");
 		return;
+	}
 	sc->atu_unit = device_unit(self);
 	sc->atu_udev = dev;
 	/*
 	 * look up the radio_type for the device
 	 * basically does the same as atu_match
 	 */
 	for (i = 0; i < __arraycount(atu_devs); i++) {
 		const struct atu_type *t = &atu_devs[i];
 		if (uaa->uaa_vendor == t->atu_vid &&
 		    uaa->uaa_product == t->atu_pid) {
 			sc->atu_radio = t->atu_radio;
 			sc->atu_quirk = t->atu_quirk;
+		}
+	}
 	/*
 	 * Check in the interface descriptor if we're in DFU mode
 	 * If we're in DFU mode, we upload the external firmware
 	 * If we're not, the PC must have rebooted without power-cycling
 	 * the device.. I've tried this out, a reboot only requeres the
 	 * external firmware to be reloaded :)
+	 *
 	 * Hmm. The at76c505a doesn't report a DFU descriptor when it's
 	 * in DFU mode... Let's just try to get the opmode
 	 */
 	err = atu_get_opmode(sc, &mode);
 	DPRINTFN(20, ("%s: opmode: %d\n", device_xname(sc->atu_dev), mode));
 	if (err || (mode != MODE_NETCARD && mode != MODE_NOFLASHNETCARD)) {
 		DPRINTF(("%s: starting internal firmware download\n",
 		    device_xname(sc->atu_dev)));
 		atu_internal_firmware(sc->atu_dev);
 		/*
 		 * atu_internal_firmware will cause a reset of the device
 		 * so we don't want to do any more configuration after this
 		 * point.
 		 */
 		return;
+	}
 	if (mode != MODE_NETCARD) {
 		DPRINTFN(15, ("%s: device needs external firmware\n",
 		    device_xname(sc->atu_dev)));
 		if (mode != MODE_NOFLASHNETCARD) {
 			DPRINTF(("%s: unexpected opmode=%d\n",
 			    device_xname(sc->atu_dev), mode));
+		}
 		/*
 		 * There is no difference in opmode before and after external
 		 * firmware upload with the SMC2662 V.4 . So instead we'll try
 		 * to read the channel number. If we succeed, external
 		 * firmwaremust have been already uploaded...
 		 */
 		if (sc->atu_radio != RadioIntersil) {
 			err = atu_get_mib(sc, MIB_PHY__CHANNEL, &channel);
 			if (!err) {
 				DPRINTF(("%s: external firmware has already"
 				    " been downloaded\n",
 				    device_xname(sc->atu_dev)));
 				atu_complete_attach(sc);
 				return;
+			}
+		}
 		atu_external_firmware(sc->atu_dev);
 		/*
 		 * atu_external_firmware will call atu_complete_attach after
 		 * it's finished so we can just return.
 		 */
 	} else {
 		/* all the firmwares are in place, so complete the attach */
 		atu_complete_attach(sc);
+	}
 	return;
+}
 static void
 atu_complete_attach(struct atu_softc *sc)
+{
 	struct ieee80211com		*ic = &sc->sc_ic;
 	struct ifnet			*ifp = &sc->sc_if;
 	usb_interface_descriptor_t	*id;
 	usb_endpoint_descriptor_t	*ed;
 	usbd_status			err;
 	int				i;
 #ifdef ATU_DEBUG
 	struct atu_fw			fw;
 #endif
 	id = usbd_get_interface_descriptor(sc->atu_iface);
 	/* Find endpoints. */
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(sc->atu_iface, i);
 		if (!ed) {
 			DPRINTF(("%s: num_endp:%d\n", device_xname(sc->atu_dev),
 			    sc->atu_iface->ui_idesc->bNumEndpoints));
 			DPRINTF(("%s: couldn't get ep %d\n",
 			    device_xname(sc->atu_dev), i));
 			return;
+		}
 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			sc->atu_ed[ATU_ENDPT_RX] = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			sc->atu_ed[ATU_ENDPT_TX] = ed->bEndpointAddress;
+		}
+	}
 	/* read device config & get MAC address */
 	err = atu_get_card_config(sc);
 	if (err) {
 		aprint_error("\n%s: could not get card cfg!\n",
 		    device_xname(sc->atu_dev));
 		return;
+	}
 #ifdef ATU_DEBUG
 	/* DEBUG : try to get firmware version */
 	err = atu_get_mib(sc, MIB_FW_VERSION, sizeof(fw), 0, (uint8_t *)&fw);
 	if (!err) {
 		DPRINTFN(15, ("%s: firmware: maj:%d min:%d patch:%d "
 		    "build:%d\n", device_xname(sc->atu_dev), fw.major,
 			fw.minor, fw.patch, fw.build));
 	} else {
 		DPRINTF(("%s: get firmware version failed\n",
 		    device_xname(sc->atu_dev)));
+	}
 #endif /* ATU_DEBUG */
 	/* Show the world our MAC address */
 	aprint_normal_dev(sc->atu_dev, "MAC address %s\n",
 	    ether_sprintf(ic->ic_myaddr));
 	sc->atu_cdata.atu_tx_inuse = 0;
 	sc->atu_encrypt = ATU_WEP_OFF;
 	sc->atu_wepkeylen = ATU_WEP_104BITS;
 	sc->atu_wepkey = 0;
 	memset(sc->atu_bssid, 0, ETHER_ADDR_LEN);
 	sc->atu_channel = ATU_DEFAULT_CHANNEL;
 	sc->atu_desired_channel = IEEE80211_CHAN_ANY;
 	sc->atu_mode = INFRASTRUCTURE_MODE;
 	ic->ic_ifp = ifp;
 	ic->ic_phytype = IEEE80211_T_DS;
 	ic->ic_opmode = IEEE80211_M_STA;
 	ic->ic_state = IEEE80211_S_INIT;
 #ifdef FIXME
 	ic->ic_caps = IEEE80211_C_IBSS | IEEE80211_C_WEP | IEEE80211_C_SCANALL;
 #else
 	ic->ic_caps = IEEE80211_C_IBSS | IEEE80211_C_WEP;
 #endif
 	i = 0;
 	ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
 	for (i = 1; i <= 14; i++) {
 		ic->ic_channels[i].ic_flags = IEEE80211_CHAN_B |
 		    IEEE80211_CHAN_PASSIVE;
 		ic->ic_channels[i].ic_freq = ieee80211_ieee2mhz(i,
 		    ic->ic_channels[i].ic_flags);
+	}
 	ic->ic_ibss_chan = &ic->ic_channels[0];
 	ifp->if_softc = sc;
 	memcpy(ifp->if_xname, device_xname(sc->atu_dev), IFNAMSIZ);
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 	ifp->if_init = atu_init;
 	ifp->if_stop = atu_stop;
 	ifp->if_start = atu_start;
 	ifp->if_ioctl = atu_ioctl;
 	ifp->if_watchdog = atu_watchdog;
 	ifp->if_mtu = ATU_DEFAULT_MTU;
 	IFQ_SET_READY(&ifp->if_snd);
 	/* Call MI attach routine. */
 	if_attach(ifp);
 	ieee80211_ifattach(ic);
 	sc->sc_newstate = ic->ic_newstate;
 	ic->ic_newstate = atu_newstate;
 	/* setup ifmedia interface */
 	/* XXX media locking needs revisiting */
 	mutex_init(&sc->sc_media_mtx, MUTEX_DEFAULT, IPL_SOFTUSB);
 	ieee80211_media_init_with_lock(ic,
 	    atu_media_change, atu_media_status, &sc->sc_media_mtx);
 	usb_init_task(&sc->sc_task, atu_task, sc, 0);
 	sc->sc_state = ATU_S_OK;
+}
 static int
 atu_detach(device_t self, int flags)
+{
 	struct atu_softc *sc = device_private(self);
 	struct ifnet		*ifp = &sc->sc_if;
 	DPRINTFN(10, ("%s: atu_detach state=%d\n", device_xname(sc->atu_dev),
 	    sc->sc_state));
 	if (sc->sc_state != ATU_S_UNCONFIG) {
 		atu_stop(ifp, 1);
 		ieee80211_ifdetach(&sc->sc_ic);
 		if_detach(ifp);
+	}
 	return 0;
+}
 static int
 atu_activate(device_t self, enum devact act)
+{
 	struct atu_softc *sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		if (sc->sc_state != ATU_S_UNCONFIG) {
 			if_deactivate(&sc->atu_ec.ec_if);
 			sc->sc_state = ATU_S_DEAD;
+		}
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 /*
  * Initialize an RX descriptor and attach an MBUF cluster.
  */
 static int
 atu_newbuf(struct atu_softc *sc, struct atu_chain *c, struct mbuf *m)
+{
 	struct mbuf		*m_new = NULL;
 	if (m == NULL) {
 		MGETHDR(m_new, M_DONTWAIT, MT_DATA);
 		if (m_new == NULL) {
 			DPRINTF(("%s: no memory for rx list\n",
 			    device_xname(sc->atu_dev)));
 			return ENOBUFS;
+		}
 		MCLGET(m_new, M_DONTWAIT);
 		if (!(m_new->m_flags & M_EXT)) {
 			DPRINTF(("%s: no memory for rx list\n",
 			    device_xname(sc->atu_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;
+	}
 	c->atu_mbuf = m_new;
 	return 0;
+}
 static int
 atu_rx_list_init(struct atu_softc *sc)
+{
 	struct atu_cdata	*cd = &sc->atu_cdata;
 	struct atu_chain	*c;
 	int			i;
 	DPRINTFN(15, ("%s: atu_rx_list_init: enter\n",
 	    device_xname(sc->atu_dev)));
 	for (i = 0; i < ATU_RX_LIST_CNT; i++) {
 		c = &cd->atu_rx_chain[i];
 		c->atu_sc = sc;
 		c->atu_idx = i;
 		if (c->atu_xfer == NULL) {
 			int err = usbd_create_xfer(sc->atu_ep[ATU_ENDPT_RX],
 			    ATU_RX_BUFSZ, 0, 0, &c->atu_xfer);
 			if (err)
 				return err;
 			c->atu_buf = usbd_get_buffer(c->atu_xfer);
 			if (atu_newbuf(sc, c, NULL) == ENOBUFS) /* XXX free? */
 				return ENOBUFS;
+		}
+	}
 	return 0;
+}
 static int
 atu_tx_list_init(struct atu_softc *sc)
+{
 	struct atu_cdata	*cd = &sc->atu_cdata;
 	struct atu_chain	*c;
 	int			i;
 	DPRINTFN(15, ("%s: atu_tx_list_init\n",
 	    device_xname(sc->atu_dev)));
 	SLIST_INIT(&cd->atu_tx_free);
 	sc->atu_cdata.atu_tx_inuse = 0;
 	for (i = 0; i < ATU_TX_LIST_CNT; i++) {
 		c = &cd->atu_tx_chain[i];
 		c->atu_sc = sc;
 		c->atu_idx = i;
 		if (c->atu_xfer == NULL) {
 			int err = usbd_create_xfer(sc->atu_ep[ATU_ENDPT_TX],
 			    ATU_TX_BUFSZ, 0, 0, &c->atu_xfer);
 			if (err) {
 				return err;
+			}
 			c->atu_buf = usbd_get_buffer(c->atu_xfer);
 			SLIST_INSERT_HEAD(&cd->atu_tx_free, c, atu_list);
+		}
+	}
 	return 0;
+}
 static void
 atu_xfer_list_free(struct atu_softc *sc, struct atu_chain *ch, int listlen)
+{
 	int			i;
 	/* Free resources. */
 	for (i = 0; i < listlen; i++) {
 		if (ch[i].atu_buf != NULL)
 			ch[i].atu_buf = NULL;
 		if (ch[i].atu_mbuf != NULL) {
 			m_freem(ch[i].atu_mbuf);
 			ch[i].atu_mbuf = NULL;
+		}
 		if (ch[i].atu_xfer != NULL) {
 			usbd_destroy_xfer(ch[i].atu_xfer);
 			ch[i].atu_xfer = NULL;
+		}
+	}
+}
 /*
  * A frame has been uploaded: pass the resulting mbuf chain up to
  * the higher level protocols.
  */
 static void
 atu_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	struct atu_chain	*c = (struct atu_chain *)priv;
 	struct atu_softc	*sc = c->atu_sc;
 	struct ieee80211com	*ic = &sc->sc_ic;
 	struct ifnet		*ifp = &sc->sc_if;
 	struct atu_rx_hdr	*h;
 	struct ieee80211_frame_min	*wh;
 	struct ieee80211_node	*ni;
 	struct mbuf		*m;
 	uint32_t		len;
 	int			s;
 	DPRINTFN(25, ("%s: atu_rxeof\n", device_xname(sc->atu_dev)));
 	if (sc->sc_state != ATU_S_OK)
 		return;
 	if ((ifp->if_flags & (IFF_RUNNING|IFF_UP)) != (IFF_RUNNING|IFF_UP))
 		goto done;
 	if (status != USBD_NORMAL_COMPLETION) {
 		DPRINTF(("%s: status != USBD_NORMAL_COMPLETION\n",
 		    device_xname(sc->atu_dev)));
 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 			return;
+		}
 #if 0
 		if (status == USBD_IOERROR) {
 			DPRINTF(("%s: rx: EEK! lost device?\n",
 			    device_xname(sc->atu_dev)));
 			/*
 			 * My experience with USBD_IOERROR is that trying to
 			 * restart the transfer will always fail and we'll
 			 * keep on looping restarting transfers untill someone
 			 * pulls the plug of the device.
 			 * So we don't restart the transfer, but just let it
 			 * die... If someone knows of a situation where we can
 			 * recover from USBD_IOERROR, let me know.
 			 */
 			splx(s);
 			return;
+		}
 #endif /* 0 */
 		if (usbd_ratecheck(&sc->atu_rx_notice)) {
 			DPRINTF(("%s: usb error on rx: %s\n",
 			    device_xname(sc->atu_dev), usbd_errstr(status)));
+		}
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(
 			    sc->atu_ep[ATU_ENDPT_RX]);
 		goto done;
+	}
 	usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
 	if (len <= 1) {
 		DPRINTF(("%s: atu_rxeof: too short\n",
 		    device_xname(sc->atu_dev)));
 		goto done;
 	} else if (len > MCLBYTES) {
 		DPRINTF(("%s: atu_rxeof: too long\n",
 		    device_xname(sc->atu_dev)));
 		goto done;
+	}
 	h = (struct atu_rx_hdr *)c->atu_buf;
 	len = UGETW(h->length) - 4; /* XXX magic number */
 	m = c->atu_mbuf;
 	memcpy(mtod(m, char *), c->atu_buf + ATU_RX_HDRLEN, len);
 	m_set_rcvif(m, ifp);
 	m->m_pkthdr.len = m->m_len = len;
 	wh = mtod(m, struct ieee80211_frame_min *);
 	ni = ieee80211_find_rxnode(ic, wh);
 	if_statinc(ifp, if_ipackets);
 	s = splnet();
 	if (atu_newbuf(sc, c, NULL) == ENOBUFS) {
 		if_statinc(ifp, if_ierrors);
 		goto done1; /* XXX if we can't allocate, why restart it? */
+	}
 	if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
 		/*
 		 * WEP is decrypted by hardware. Clear WEP bit
 		 * header for ieee80211_input().
 		 */
 		wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
+	}
 	ieee80211_input(ic, m, ni, h->rssi, UGETDW(h->rx_time));
 	ieee80211_free_node(ni);
 done1:
 	splx(s);
 done:
 	/* Setup new transfer. */
 	usbd_setup_xfer(c->atu_xfer, c, c->atu_buf, ATU_RX_BUFSZ,
 	    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, atu_rxeof);
 	usbd_transfer(c->atu_xfer);
+}
 /*
  * A frame was downloaded to the chip. It's safe for us to clean up
  * the list buffers.
  */
 static void
 atu_txeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	struct atu_chain	*c = (struct atu_chain *)priv;
 	struct atu_softc	*sc = c->atu_sc;
 	struct ifnet		*ifp = &sc->sc_if;
 	usbd_status		err;
 	int			s;
 	DPRINTFN(25, ("%s: atu_txeof status=%d\n", device_xname(sc->atu_dev),
 	    status));
 	if (c->atu_mbuf) {
 		m_freem(c->atu_mbuf);
 		c->atu_mbuf = NULL;
+	}
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
 			return;
 		DPRINTF(("%s: usb error on tx: %s\n",
 			device_xname(sc->atu_dev), usbd_errstr(status)));
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(
 				sc->atu_ep[ATU_ENDPT_TX]);
 		return;
+	}
 	usbd_get_xfer_status(c->atu_xfer, NULL, NULL, NULL, &err);
 	if (err)
 		if_statinc(ifp, if_oerrors);
 	else
 		if_statinc(ifp, if_opackets);
 	s = splnet();
 	SLIST_INSERT_HEAD(&sc->atu_cdata.atu_tx_free, c, atu_list);
 	sc->atu_cdata.atu_tx_inuse--;
 	if (sc->atu_cdata.atu_tx_inuse == 0)
 		ifp->if_timer = 0;
 	ifp->if_flags &= ~IFF_OACTIVE;
 	splx(s);
 	atu_start(ifp);
+}
 static uint8_t
 atu_calculate_padding(int size)
+{
 	size %= 64;
 	if (size < 50)
 		return 50 - size;
 	if (size >=61)
 		return 64 + 50 - size;
 	return 0;
+}
 static int
 atu_tx_start(struct atu_softc *sc, struct ieee80211_node *ni,
     struct atu_chain *c, struct mbuf *m)
+{
 	int			len;
 	struct atu_tx_hdr	*h;
 	usbd_status		err;
 	uint8_t			pad;
 	DPRINTFN(25, ("%s: atu_tx_start\n", device_xname(sc->atu_dev)));
 	/* Don't try to send when we're shutting down the driver */
 	if (sc->sc_state != ATU_S_OK) {
 		m_freem(m);
 		return EIO;
+	}
 	/*
 	 * Copy the mbuf data into a contiguous buffer, leaving
 	 * enough room for the atmel headers
 	 */
 	len = m->m_pkthdr.len;
 	m_copydata(m, 0, m->m_pkthdr.len, c->atu_buf + ATU_TX_HDRLEN);
 	h = (struct atu_tx_hdr *)c->atu_buf;
 	memset(h, 0, ATU_TX_HDRLEN);
 	USETW(h->length, len);
 	h->tx_rate = 4; /* XXX rate = auto */
 	len += ATU_TX_HDRLEN;
 	pad = atu_calculate_padding(len);
 	len += pad;
 	h->padding = pad;
 	c->atu_length = len;
 	c->atu_mbuf = m;
 	usbd_setup_xfer(c->atu_xfer, c, c->atu_buf, c->atu_length, 0,
 	    ATU_TX_TIMEOUT, atu_txeof);
 	/* Let's get this thing into the air! */
 	c->atu_in_xfer = 1;
 	err = usbd_transfer(c->atu_xfer);
 	if (err != USBD_IN_PROGRESS) {
 		DPRINTFN(25, ("%s: atu_tx_start, err=%d",
 		    device_xname(sc->atu_dev), err));
 		c->atu_mbuf = NULL;
 		m_freem(m);
 		return EIO;
+	}
 	return 0;
+}
 static void
 atu_start(struct ifnet *ifp)
+{
 	struct atu_softc	*sc = ifp->if_softc;
 	struct ieee80211com	*ic = &sc->sc_ic;
 	struct atu_cdata	*cd = &sc->atu_cdata;
 	struct ieee80211_node	*ni;
 	struct atu_chain	*c;
 	struct mbuf		*m = NULL;
 	int			s;
 	DPRINTFN(25, ("%s: atu_start: enter\n", device_xname(sc->atu_dev)));
 	if ((ifp->if_flags & IFF_RUNNING) == 0) {
 		return;
+	}
 	if (ifp->if_flags & IFF_OACTIVE) {
 		DPRINTFN(30, ("%s: atu_start: IFF_OACTIVE\n",
 		    device_xname(sc->atu_dev)));
 		return;
+	}
 	for (;;) {
 		/* grab a TX buffer */
 		s = splnet();
 		c = SLIST_FIRST(&cd->atu_tx_free);
 		if (c != NULL) {
 			SLIST_REMOVE_HEAD(&cd->atu_tx_free, atu_list);
 			cd->atu_tx_inuse++;
 			if (cd->atu_tx_inuse == ATU_TX_LIST_CNT)
 				ifp->if_flags |= IFF_OACTIVE;
+		}
 		splx(s);
 		if (c == NULL) {
 			DPRINTFN(10, ("%s: out of tx xfers\n",
 			    device_xname(sc->atu_dev)));
 			ifp->if_flags |= IFF_OACTIVE;
 			break;
+		}
 		/*
 		 * Poll the management queue for frames, it has priority over
 		 * normal data frames.
 		 */
 		IF_DEQUEUE(&ic->ic_mgtq, m);
 		if (m == NULL) {
 			DPRINTFN(10, ("%s: atu_start: data packet\n",
 			    device_xname(sc->atu_dev)));
 			if (ic->ic_state != IEEE80211_S_RUN) {
 				DPRINTFN(25, ("%s: no data till running\n",
 				    device_xname(sc->atu_dev)));
 				/* put the xfer back on the list */
 				s = splnet();
 				SLIST_INSERT_HEAD(&cd->atu_tx_free, c,
 				    atu_list);
 				cd->atu_tx_inuse--;
 				splx(s);
 				break;
+			}
 			IFQ_DEQUEUE(&ifp->if_snd, m);
 			if (m == NULL) {
 				DPRINTFN(25, ("%s: nothing to send\n",
 				    device_xname(sc->atu_dev)));
 				s = splnet();
 				SLIST_INSERT_HEAD(&cd->atu_tx_free, c,
 				    atu_list);
 				cd->atu_tx_inuse--;
 				splx(s);
 				break;
+			}
 			bpf_mtap(ifp, m, BPF_D_OUT);
 			ni = ieee80211_find_txnode(ic,
 			    mtod(m, struct ether_header *)->ether_dhost);
 			if (ni == NULL) {
 				m_freem(m);
 				goto bad;
+			}
 			m = ieee80211_encap(ic, m, ni);
 			if (m == NULL)
 				goto bad;
 		} else {
 			DPRINTFN(25, ("%s: atu_start: mgmt packet\n",
 			    device_xname(sc->atu_dev)));
 			/*
 			 * Hack!  The referenced node pointer is in the
 			 * rcvif field of the packet header.  This is
 			 * placed there by ieee80211_mgmt_output because
 			 * we need to hold the reference with the frame
 			 * and there's no other way (other than packet
 			 * tags which we consider too expensive to use)
 			 * to pass it along.
 			 */
 			ni = M_GETCTX(m, struct ieee80211_node *);
 			M_CLEARCTX(m);
 			/* sc->sc_stats.ast_tx_mgmt++; */
+		}
 		bpf_mtap3(ic->ic_rawbpf, m, BPF_D_OUT);
 		if (atu_tx_start(sc, ni, c, m)) {
 bad:
 			s = splnet();
 			SLIST_INSERT_HEAD(&cd->atu_tx_free, c,
 			    atu_list);
 			cd->atu_tx_inuse--;
 			splx(s);
 			/* if_statinc(ifp, if_oerrors); */
 			if (ni != NULL)
 				ieee80211_free_node(ni);
 			continue;
+		}
 		ifp->if_timer = 5;
+	}
+}
 static int
 atu_init(struct ifnet *ifp)
+{
 	struct atu_softc	*sc = ifp->if_softc;
 	struct ieee80211com	*ic = &sc->sc_ic;
 	struct atu_chain	*c;
 	usbd_status		err;
 	int			i, s;
 	s = splnet();
 	DPRINTFN(10, ("%s: atu_init\n", device_xname(sc->atu_dev)));
 	if (ifp->if_flags & IFF_RUNNING) {
 		splx(s);
 		return 0;
+	}
 	/* Load the multicast filter. */
 	/*atu_setmulti(sc); */
 	/* Open RX and TX pipes. */
 	err = usbd_open_pipe(sc->atu_iface, sc->atu_ed[ATU_ENDPT_RX],
 	    USBD_EXCLUSIVE_USE, &sc->atu_ep[ATU_ENDPT_RX]);
 	if (err) {
 		DPRINTF(("%s: open rx pipe failed: %s\n",
 		    device_xname(sc->atu_dev), usbd_errstr(err)));
 		splx(s);
 		return EIO;
+	}
 	err = usbd_open_pipe(sc->atu_iface, sc->atu_ed[ATU_ENDPT_TX],
 	    USBD_EXCLUSIVE_USE, &sc->atu_ep[ATU_ENDPT_TX]);
 	if (err) {
 		DPRINTF(("%s: open tx pipe failed: %s\n",
 		    device_xname(sc->atu_dev), usbd_errstr(err)));
 		splx(s);
 		return EIO;
+	}
 	/* Init TX ring */
 	if (atu_tx_list_init(sc))
 		printf("%s: tx list init failed\n", device_xname(sc->atu_dev));
 	/* Init RX ring */
 	if (atu_rx_list_init(sc))
 		printf("%s: rx list init failed\n", device_xname(sc->atu_dev));
 	/* Start up the receive pipe. */
 	for (i = 0; i < ATU_RX_LIST_CNT; i++) {
 		c = &sc->atu_cdata.atu_rx_chain[i];
 		usbd_setup_xfer(c->atu_xfer, c, c->atu_buf, ATU_RX_BUFSZ,
 		    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, atu_rxeof);
 		usbd_transfer(c->atu_xfer);
+	}
 	DPRINTFN(10, ("%s: starting up using MAC=%s\n",
 	    device_xname(sc->atu_dev), ether_sprintf(ic->ic_myaddr)));
 	/* Do initial setup */
 	err = atu_initial_config(sc);
 	if (err) {
 		DPRINTF(("%s: initial config failed!\n",
 		    device_xname(sc->atu_dev)));
 		splx(s);
 		return EIO;
+	}
 	DPRINTFN(10, ("%s: initialised transceiver\n",
 	    device_xname(sc->atu_dev)));
 	/* sc->atu_rxfilt = ATU_RXFILT_UNICAST|ATU_RXFILT_BROADCAST; */
 	/* If we want promiscuous mode, set the allframes bit. */
 	/*
 	if (ifp->if_flags & IFF_PROMISC)
 		sc->atu_rxfilt |= ATU_RXFILT_PROMISC;
 	*/
 	ifp->if_flags |= IFF_RUNNING;
 	ifp->if_flags &= ~IFF_OACTIVE;
 	splx(s);
 	/* XXX the following HAS to be replaced */
 	s = splnet();
 	err = ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
 	if (err) {
 		DPRINTFN(1, ("%s: atu_init: error calling "
 		    "ieee80211_net_state", device_xname(sc->atu_dev)));
+	}
 	splx(s);
 	return 0;
+}
 #if 0 && defined(ATU_DEBUG) /* XXX XXX XXX UNUSED */
 static void	atu_debug_print(struct atu_softc *);
 static void
 atu_debug_print(struct atu_softc *sc)
+{
 	usbd_status		err;
 	uint8_t			tmp[32];
 	/* DEBUG */
 	if ((err = atu_get_mib(sc, MIB_MAC_MGMT__CURRENT_BSSID, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: current BSSID=%s\n", device_xname(sc->atu_dev),
 	    ether_sprintf(tmp)));
 	if ((err = atu_get_mib(sc, MIB_MAC_MGMT__BEACON_PERIOD, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: beacon period=%d\n", device_xname(sc->atu_dev),
 	    tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_MAC_WEP__PRIVACY_INVOKED, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: privacy invoked=%d\n", device_xname(sc->atu_dev),
 	    tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_MAC_WEP__ENCR_LEVEL, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: encr_level=%d\n", device_xname(sc->atu_dev),
 	    tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_MAC_WEP__ICV_ERROR_COUNT, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: icv error count=%d\n", device_xname(sc->atu_dev),
 	    *(short *)tmp));
 	if ((err = atu_get_mib(sc, MIB_MAC_WEP__EXCLUDED_COUNT, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: wep excluded count=%d\n",
 	    device_xname(sc->atu_dev), *(short *)tmp));
 	if ((err = atu_get_mib(sc, MIB_MAC_MGMT__POWER_MODE, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: power mode=%d\n", device_xname(sc->atu_dev),
 	    tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_PHY__CHANNEL, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: channel=%d\n", device_xname(sc->atu_dev), tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_PHY__REG_DOMAIN, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: reg domain=%d\n", device_xname(sc->atu_dev),
 	    tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_LOCAL__SSID_SIZE, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: ssid size=%d\n", device_xname(sc->atu_dev),
 	    tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_LOCAL__BEACON_ENABLE, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: beacon enable=%d\n", device_xname(sc->atu_dev),
 	    tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_LOCAL__AUTO_RATE_FALLBACK, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: auto rate fallback=%d\n",
 	    device_xname(sc->atu_dev), tmp[0]));
 	if ((err = atu_get_mib(sc, MIB_MAC_ADDR__ADDR, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: mac addr=%s\n", device_xname(sc->atu_dev),
 	    ether_sprintf(tmp)));
 	if ((err = atu_get_mib(sc, MIB_MAC__DESIRED_SSID, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: desired ssid=%s\n", device_xname(sc->atu_dev),
 	    tmp));
 	if ((err = atu_get_mib(sc, MIB_MAC_MGMT__CURRENT_ESSID, tmp)))
 		return;
 	DPRINTF(("%s: DEBUG: current ESSID=%s\n", device_xname(sc->atu_dev),
 	    tmp));
+}
 #endif /* ATU_DEBUG */
 static int
 atu_ioctl(struct ifnet *ifp, u_long command, void *data)
+{
 	struct atu_softc	*sc = ifp->if_softc;
 	struct ieee80211com	*ic = &sc->sc_ic;
 	int			err = 0, s;
 	s = splnet();
 	switch (command) {
 	default:
 		DPRINTFN(15, ("%s: ieee80211_ioctl (%lu)\n",
 		    device_xname(sc->atu_dev), command));
 		err = ieee80211_ioctl(ic, command, data);
 		break;
+	}
 	if (err == ENETRESET) {
 		if ((ifp->if_flags & (IFF_RUNNING|IFF_UP)) ==
 		    (IFF_RUNNING|IFF_UP)) {
 			DPRINTF(("%s: atu_ioctl(): netreset %lu\n",
 			    device_xname(sc->atu_dev), command));
 			ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
 			atu_initial_config(sc);
 			ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
+		}
 		err = 0;
+	}
 	splx(s);
 	return err;
+}
 static void
 atu_watchdog(struct ifnet *ifp)
+{
 	struct atu_softc	*sc = ifp->if_softc;
 	struct atu_chain	*c;
 	usbd_status		stat;
 	int			cnt, s;
 	DPRINTF(("%s: atu_watchdog\n", device_xname(sc->atu_dev)));
 	ifp->if_timer = 0;
 	if (sc->sc_state != ATU_S_OK || (ifp->if_flags & IFF_RUNNING) == 0)
 		return;
 	sc = ifp->if_softc;
 	s = splnet();
 	if_statinc(ifp, if_oerrors);
 	DPRINTF(("%s: watchdog timeout\n", device_xname(sc->atu_dev)));
 	/*
 	 * TODO:
 	 * we should change this since we have multiple TX tranfers...
 	 */
 	for (cnt = 0; cnt < ATU_TX_LIST_CNT; cnt++) {
 		c = &sc->atu_cdata.atu_tx_chain[cnt];
 		if (c->atu_in_xfer) {
 			usbd_get_xfer_status(c->atu_xfer, NULL, NULL, NULL,
 			    &stat);
 			atu_txeof(c->atu_xfer, c, stat);
+		}
+	}
 	if (!IFQ_IS_EMPTY(&ifp->if_snd))
 		atu_start(ifp);
 	splx(s);
 	ieee80211_watchdog(&sc->sc_ic);
+}
 /*
  * Stop the adapter and free any mbufs allocated to the
  * RX and TX lists.
  */
 static void
 atu_stop(struct ifnet *ifp, int disable)
+{
 	struct atu_softc	*sc = ifp->if_softc;
 	struct ieee80211com	*ic = &sc->sc_ic;
 	struct atu_cdata	*cd;
 	usbd_status		err;
 	int s;
 	s = splnet();
 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 	ifp->if_timer = 0;
 	usb_rem_task_wait(sc->atu_udev, &sc->sc_task, USB_TASKQ_DRIVER, NULL);
 	ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
 	/* Stop transfers. */
 	if (sc->atu_ep[ATU_ENDPT_RX] != NULL) {
-		err = usbd_abort_pipe(sc->atu_ep[ATU_ENDPT_RX]);
+		usbd_abort_pipe(sc->atu_ep[ATU_ENDPT_RX]);
 		if (err) {
 			DPRINTF(("%s: abort rx pipe failed: %s\n",
 			    device_xname(sc->atu_dev), usbd_errstr(err)));
+	}
 	if (sc->atu_ep[ATU_ENDPT_TX] != NULL) {
-		err = usbd_abort_pipe(sc->atu_ep[ATU_ENDPT_TX]);
+		usbd_abort_pipe(sc->atu_ep[ATU_ENDPT_TX]);
 		if (err) {
 			DPRINTF(("%s: abort tx pipe failed: %s\n",
 			    device_xname(sc->atu_dev), usbd_errstr(err)));
+	}
 	/* Free RX/TX/MGMT list resources. */
 	cd = &sc->atu_cdata;
 	atu_xfer_list_free(sc, cd->atu_rx_chain, ATU_RX_LIST_CNT);
 	atu_xfer_list_free(sc, cd->atu_tx_chain, ATU_TX_LIST_CNT);
 	/* Close pipes */
 	if (sc->atu_ep[ATU_ENDPT_RX] != NULL) {
 		err = usbd_close_pipe(sc->atu_ep[ATU_ENDPT_RX]);
 		if (err) {
 			DPRINTF(("%s: close rx pipe failed: %s\n",
 			    device_xname(sc->atu_dev), usbd_errstr(err)));
+		}
 		sc->atu_ep[ATU_ENDPT_RX] = NULL;
+	}
 	if (sc->atu_ep[ATU_ENDPT_TX] != NULL) {
 		err = usbd_close_pipe(sc->atu_ep[ATU_ENDPT_TX]);
 		if (err) {
 			DPRINTF(("%s: close tx pipe failed: %s\n",
 			    device_xname(sc->atu_dev), usbd_errstr(err)));
+		}
 		sc->atu_ep[ATU_ENDPT_TX] = NULL;
+	}
 	/* Let's be nice and turn off the radio before we leave */
 	atu_switch_radio(sc, 0);
 	splx(s);
+}

 @@ -1,1842 +1,1839 @@
-/*	$NetBSD: usbdi.c,v 1.223 2022/03/03 06:04:31 riastradh Exp $	*/
+/*	$NetBSD: usbdi.c,v 1.224 2022/03/03 06:05:38 riastradh Exp $	*/
 /*
  * Copyright (c) 1998, 2012, 2015 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (lennart@augustsson.net) at
  * Carlstedt Research & Technology, Matthew R. Green (mrg@eterna.com.au),
  * and Nick Hudson.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: usbdi.c,v 1.223 2022/03/03 06:04:31 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: usbdi.c,v 1.224 2022/03/03 06:05:38 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #include "opt_compat_netbsd.h"
 #include "usb_dma.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/bus.h>
 #include <sys/cpu.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/usb_mem.h>
 #include <dev/usb/usb_quirks.h>
 #include <dev/usb/usb_sdt.h>
 #include <dev/usb/usbhist.h>
 /* UTF-8 encoding stuff */
 #include <fs/unicode.h>
 SDT_PROBE_DEFINE5(usb, device, pipe, open,
     "struct usbd_interface *"/*iface*/,
     "uint8_t"/*address*/,
     "uint8_t"/*flags*/,
     "int"/*ival*/,
     "struct usbd_pipe *"/*pipe*/);
 SDT_PROBE_DEFINE7(usb, device, pipe, open__intr,
     "struct usbd_interface *"/*iface*/,
     "uint8_t"/*address*/,
     "uint8_t"/*flags*/,
     "int"/*ival*/,
     "usbd_callback"/*cb*/,
     "void *"/*cookie*/,
     "struct usbd_pipe *"/*pipe*/);
 SDT_PROBE_DEFINE2(usb, device, pipe, transfer__start,
     "struct usbd_pipe *"/*pipe*/,
     "struct usbd_xfer *"/*xfer*/);
 SDT_PROBE_DEFINE3(usb, device, pipe, transfer__done,
     "struct usbd_pipe *"/*pipe*/,
     "struct usbd_xfer *"/*xfer*/,
     "usbd_status"/*err*/);
 SDT_PROBE_DEFINE2(usb, device, pipe, start,
     "struct usbd_pipe *"/*pipe*/,
     "struct usbd_xfer *"/*xfer*/);
 SDT_PROBE_DEFINE1(usb, device, pipe, close,  "struct usbd_pipe *"/*pipe*/);
 SDT_PROBE_DEFINE1(usb, device, pipe, abort__start,
     "struct usbd_pipe *"/*pipe*/);
 SDT_PROBE_DEFINE1(usb, device, pipe, abort__done,
     "struct usbd_pipe *"/*pipe*/);
 SDT_PROBE_DEFINE1(usb, device, pipe, clear__endpoint__stall,
     "struct usbd_pipe *"/*pipe*/);
 SDT_PROBE_DEFINE1(usb, device, pipe, clear__endpoint__toggle,
     "struct usbd_pipe *"/*pipe*/);
 SDT_PROBE_DEFINE5(usb, device, xfer, create,
     "struct usbd_xfer *"/*xfer*/,
     "struct usbd_pipe *"/*pipe*/,
     "size_t"/*len*/,
     "unsigned int"/*flags*/,
     "unsigned int"/*nframes*/);
 SDT_PROBE_DEFINE1(usb, device, xfer, start,  "struct usbd_xfer *"/*xfer*/);
 SDT_PROBE_DEFINE1(usb, device, xfer, preabort,  "struct usbd_xfer *"/*xfer*/);
 SDT_PROBE_DEFINE1(usb, device, xfer, abort,  "struct usbd_xfer *"/*xfer*/);
 SDT_PROBE_DEFINE1(usb, device, xfer, timeout,  "struct usbd_xfer *"/*xfer*/);
 SDT_PROBE_DEFINE2(usb, device, xfer, done,
     "struct usbd_xfer *"/*xfer*/,
     "usbd_status"/*status*/);
 SDT_PROBE_DEFINE1(usb, device, xfer, destroy,  "struct usbd_xfer *"/*xfer*/);
-Static usbd_status usbd_ar_pipe(struct usbd_pipe *);
+Static void usbd_ar_pipe(struct usbd_pipe *);
 static usbd_status usb_insert_transfer(struct usbd_xfer *);
 Static void usbd_start_next(struct usbd_pipe *);
 Static usbd_status usbd_open_pipe_ival
 	(struct usbd_interface *, uint8_t, uint8_t, struct usbd_pipe **, int);
 static void *usbd_alloc_buffer(struct usbd_xfer *, uint32_t);
 static void usbd_free_buffer(struct usbd_xfer *);
 static struct usbd_xfer *usbd_alloc_xfer(struct usbd_device *, unsigned int);
 static usbd_status usbd_free_xfer(struct usbd_xfer *);
 static void usbd_request_async_cb(struct usbd_xfer *, void *, usbd_status);
 static void usbd_xfer_timeout(void *);
 static void usbd_xfer_timeout_task(void *);
 static bool usbd_xfer_probe_timeout(struct usbd_xfer *);
 static void usbd_xfer_cancel_timeout_async(struct usbd_xfer *);
 #if defined(USB_DEBUG)
 void
 usbd_dump_iface(struct usbd_interface *iface)
+{
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "iface %#jx", (uintptr_t)iface, 0, 0, 0);
 	if (iface == NULL)
 		return;
 	USBHIST_LOG(usbdebug, "     device = %#jx idesc = %#jx index = %jd",
 	    (uintptr_t)iface->ui_dev, (uintptr_t)iface->ui_idesc,
 	    iface->ui_index, 0);
 	USBHIST_LOG(usbdebug, "     altindex=%jd",
 	    iface->ui_altindex, 0, 0, 0);
+}
 void
 usbd_dump_device(struct usbd_device *dev)
+{
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "dev = %#jx", (uintptr_t)dev, 0, 0, 0);
 	if (dev == NULL)
 		return;
 	USBHIST_LOG(usbdebug, "     bus = %#jx default_pipe = %#jx",
 	    (uintptr_t)dev->ud_bus, (uintptr_t)dev->ud_pipe0, 0, 0);
 	USBHIST_LOG(usbdebug, "     address = %jd config = %jd depth = %jd ",
 	    dev->ud_addr, dev->ud_config, dev->ud_depth, 0);
 	USBHIST_LOG(usbdebug, "     speed = %jd self_powered = %jd "
 	    "power = %jd langid = %jd",
 	    dev->ud_speed, dev->ud_selfpowered, dev->ud_power, dev->ud_langid);
+}
 void
 usbd_dump_endpoint(struct usbd_endpoint *endp)
+{
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "endp = %#jx", (uintptr_t)endp, 0, 0, 0);
 	if (endp == NULL)
 		return;
 	USBHIST_LOG(usbdebug, "    edesc = %#jx refcnt = %jd",
 	    (uintptr_t)endp->ue_edesc, endp->ue_refcnt, 0, 0);
 	if (endp->ue_edesc)
 		USBHIST_LOG(usbdebug, "     bEndpointAddress=0x%02jx",
 		    endp->ue_edesc->bEndpointAddress, 0, 0, 0);
+}
 void
 usbd_dump_queue(struct usbd_pipe *pipe)
+{
 	struct usbd_xfer *xfer;
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "pipe = %#jx", (uintptr_t)pipe, 0, 0, 0);
 	SIMPLEQ_FOREACH(xfer, &pipe->up_queue, ux_next) {
 		USBHIST_LOG(usbdebug, "     xfer = %#jx", (uintptr_t)xfer,
 , 0, 0);
+	}
+}
 void
 usbd_dump_pipe(struct usbd_pipe *pipe)
+{
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "pipe = %#jx", (uintptr_t)pipe, 0, 0, 0);
 	if (pipe == NULL)
 		return;
 	usbd_dump_iface(pipe->up_iface);
 	usbd_dump_device(pipe->up_dev);
 	usbd_dump_endpoint(pipe->up_endpoint);
 	USBHIST_LOG(usbdebug, "(usbd_dump_pipe)", 0, 0, 0, 0);
 	USBHIST_LOG(usbdebug, "     running = %jd aborting = %jd",
 	    pipe->up_running, pipe->up_aborting, 0, 0);
 	USBHIST_LOG(usbdebug, "     intrxfer = %#jx, repeat = %jd, "
 	    "interval = %jd", (uintptr_t)pipe->up_intrxfer, pipe->up_repeat,
 	    pipe->up_interval, 0);
+}
 #endif
 usbd_status
 usbd_open_pipe(struct usbd_interface *iface, uint8_t address,
 	       uint8_t flags, struct usbd_pipe **pipe)
+{
 	return (usbd_open_pipe_ival(iface, address, flags, pipe,
 				    USBD_DEFAULT_INTERVAL));
+}
 usbd_status
 usbd_open_pipe_ival(struct usbd_interface *iface, uint8_t address,
 		    uint8_t flags, struct usbd_pipe **pipe, int ival)
+{
 	struct usbd_pipe *p = NULL;
 	struct usbd_endpoint *ep = NULL /* XXXGCC */;
 	bool piperef = false;
 	usbd_status err;
 	int i;
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "iface = %#jx address = %#jx flags = %#jx",
 	    (uintptr_t)iface, address, flags, 0);
 	/*
 	 * Block usbd_set_interface so we have a snapshot of the
 	 * interface endpoints.  They will remain stable until we drop
 	 * the reference in usbd_close_pipe (or on failure here).
 	 */
 	err = usbd_iface_piperef(iface);
 	if (err)
 		goto out;
 	piperef = true;
 	/* Find the endpoint at this address.  */
 	for (i = 0; i < iface->ui_idesc->bNumEndpoints; i++) {
 		ep = &iface->ui_endpoints[i];
 		if (ep->ue_edesc == NULL) {
 			err = USBD_IOERROR;
 			goto out;
+		}
 		if (ep->ue_edesc->bEndpointAddress == address)
 			break;
+	}
 	if (i == iface->ui_idesc->bNumEndpoints) {
 		err = USBD_BAD_ADDRESS;
 		goto out;
+	}
 	/* Set up the pipe with this endpoint.  */
 	err = usbd_setup_pipe_flags(iface->ui_dev, iface, ep, ival, &p, flags);
 	if (err)
 		goto out;
 	/* Success! */
 	*pipe = p;
 	p = NULL;		/* handed off to caller */
 	piperef = false;	/* handed off to pipe */
 	SDT_PROBE5(usb, device, pipe, open,
 	    iface, address, flags, ival, p);
 	err = USBD_NORMAL_COMPLETION;
 out:	if (p)
 		usbd_close_pipe(p);
 	if (piperef)
 		usbd_iface_pipeunref(iface);
 	return err;
+}
 usbd_status
 usbd_open_pipe_intr(struct usbd_interface *iface, uint8_t address,
 		    uint8_t flags, struct usbd_pipe **pipe,
 		    void *priv, void *buffer, uint32_t len,
 		    usbd_callback cb, int ival)
+{
 	usbd_status err;
 	struct usbd_xfer *xfer;
 	struct usbd_pipe *ipipe;
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "address = %#jx flags = %#jx len = %jd",
 	    address, flags, len, 0);
 	err = usbd_open_pipe_ival(iface, address,
 				  USBD_EXCLUSIVE_USE | (flags & USBD_MPSAFE),
 				  &ipipe, ival);
 	if (err)
 		return err;
 	err = usbd_create_xfer(ipipe, len, flags, 0, &xfer);
 	if (err)
 		goto bad1;
 	usbd_setup_xfer(xfer, priv, buffer, len, flags, USBD_NO_TIMEOUT, cb);
 	ipipe->up_intrxfer = xfer;
 	ipipe->up_repeat = 1;
 	err = usbd_transfer(xfer);
 	*pipe = ipipe;
 	if (err != USBD_IN_PROGRESS)
 		goto bad3;
 	SDT_PROBE7(usb, device, pipe, open__intr,
 	    iface, address, flags, ival, cb, priv, ipipe);
 	return USBD_NORMAL_COMPLETION;
  bad3:
 	ipipe->up_intrxfer = NULL;
 	ipipe->up_repeat = 0;
 	usbd_destroy_xfer(xfer);
  bad1:
 	usbd_close_pipe(ipipe);
 	return err;
+}
 usbd_status
 usbd_close_pipe(struct usbd_pipe *pipe)
+{
 	USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
 	KASSERT(pipe != NULL);
 	usbd_lock_pipe(pipe);
 	SDT_PROBE1(usb, device, pipe, close,  pipe);
 	if (!SIMPLEQ_EMPTY(&pipe->up_queue)) {
 		printf("WARNING: pipe closed with active xfers on addr %d\n",
 		    pipe->up_dev->ud_addr);
 		usbd_ar_pipe(pipe);
+	}
 	KASSERT(SIMPLEQ_EMPTY(&pipe->up_queue));
 	pipe->up_methods->upm_close(pipe);
 	usbd_unlock_pipe(pipe);
 	cv_destroy(&pipe->up_callingcv);
 	if (pipe->up_intrxfer)
 		usbd_destroy_xfer(pipe->up_intrxfer);
 	usb_rem_task_wait(pipe->up_dev, &pipe->up_async_task, USB_TASKQ_DRIVER,
 	    NULL);
 	usbd_endpoint_release(pipe->up_dev, pipe->up_endpoint);
 	if (pipe->up_iface)
 		usbd_iface_pipeunref(pipe->up_iface);
 	kmem_free(pipe, pipe->up_dev->ud_bus->ub_pipesize);
 	return USBD_NORMAL_COMPLETION;
+}
 usbd_status
 usbd_transfer(struct usbd_xfer *xfer)
+{
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	usbd_status err;
 	unsigned int size, flags;
 	USBHIST_FUNC(); USBHIST_CALLARGS(usbdebug,
 	    "xfer = %#jx, flags = %#jx, pipe = %#jx, running = %jd",
 	    (uintptr_t)xfer, xfer->ux_flags, (uintptr_t)pipe, pipe->up_running);
 	KASSERT(xfer->ux_status == USBD_NOT_STARTED);
 	SDT_PROBE1(usb, device, xfer, start,  xfer);
 #ifdef USB_DEBUG
 	if (usbdebug > 5)
 		usbd_dump_queue(pipe);
 #endif
 	xfer->ux_done = 0;
 	if (pipe->up_aborting) {
 		USBHIST_LOG(usbdebug, "<- done xfer %#jx, aborting",
 		    (uintptr_t)xfer, 0, 0, 0);
 		SDT_PROBE2(usb, device, xfer, done,  xfer, USBD_CANCELLED);
 		return USBD_CANCELLED;
+	}
 	KASSERT(xfer->ux_length == 0 || xfer->ux_buf != NULL);
 	size = xfer->ux_length;
 	flags = xfer->ux_flags;
 	if (size != 0) {
 		/*
 		 * Use the xfer buffer if none specified in transfer setup.
 		 * isoc transfers always use the xfer buffer, i.e.
 		 * ux_buffer is always NULL for isoc.
 		 */
 		if (xfer->ux_buffer == NULL) {
 			xfer->ux_buffer = xfer->ux_buf;
+		}
 		/*
 		 * If not using the xfer buffer copy data to the
 		 * xfer buffer for OUT transfers of >0 length
 		 */
 		if (xfer->ux_buffer != xfer->ux_buf) {
 			KASSERT(xfer->ux_buf);
 			if (!usbd_xfer_isread(xfer)) {
 				memcpy(xfer->ux_buf, xfer->ux_buffer, size);
+			}
+		}
+	}
 	/* xfer is not valid after the transfer method unless synchronous */
 	SDT_PROBE2(usb, device, pipe, transfer__start,  pipe, xfer);
 	do {
 		usbd_lock_pipe(pipe);
 		err = usb_insert_transfer(xfer);
 		usbd_unlock_pipe(pipe);
 		if (err)
 			break;
 		err = pipe->up_methods->upm_transfer(xfer);
 	} while (0);
 	SDT_PROBE3(usb, device, pipe, transfer__done,  pipe, xfer, err);
 	if (err != USBD_IN_PROGRESS && err) {
 		/*
 		 * The transfer made it onto the pipe queue, but didn't get
 		 * accepted by the HCD for some reason.  It needs removing
 		 * from the pipe queue.
 		 */
 		USBHIST_LOG(usbdebug, "xfer failed: %jd, reinserting",
 		    err, 0, 0, 0);
 		usbd_lock_pipe(pipe);
 		SDT_PROBE1(usb, device, xfer, preabort,  xfer);
 #ifdef DIAGNOSTIC
 		xfer->ux_state = XFER_BUSY;
 #endif
 		SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next);
 		if (pipe->up_serialise)
 			usbd_start_next(pipe);
 		usbd_unlock_pipe(pipe);
+	}
 	if (!(flags & USBD_SYNCHRONOUS)) {
 		USBHIST_LOG(usbdebug, "<- done xfer %#jx, not sync (err %jd)",
 		    (uintptr_t)xfer, err, 0, 0);
 		if (err != USBD_IN_PROGRESS) /* XXX Possible?  */
 			SDT_PROBE2(usb, device, xfer, done,  xfer, err);
 		return err;
+	}
 	if (err != USBD_IN_PROGRESS) {
 		USBHIST_LOG(usbdebug, "<- done xfer %#jx, sync (err %jd)",
 		    (uintptr_t)xfer, err, 0, 0);
 		SDT_PROBE2(usb, device, xfer, done,  xfer, err);
 		return err;
+	}
 	/* Sync transfer, wait for completion. */
 	usbd_lock_pipe(pipe);
 	while (!xfer->ux_done) {
 		if (pipe->up_dev->ud_bus->ub_usepolling)
 			panic("usbd_transfer: not done");
 		USBHIST_LOG(usbdebug, "<- sleeping on xfer %#jx",
 		    (uintptr_t)xfer, 0, 0, 0);
 		err = 0;
 		if ((flags & USBD_SYNCHRONOUS_SIG) != 0) {
 			err = cv_wait_sig(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock);
 		} else {
 			cv_wait(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock);
+		}
 		if (err) {
 			if (!xfer->ux_done) {
 				SDT_PROBE1(usb, device, xfer, abort,  xfer);
 				pipe->up_methods->upm_abort(xfer);
+			}
 			break;
+		}
+	}
 	SDT_PROBE2(usb, device, xfer, done,  xfer, xfer->ux_status);
 	/* XXX Race to read xfer->ux_status?  */
 	usbd_unlock_pipe(pipe);
 	return xfer->ux_status;
+}
 /* Like usbd_transfer(), but waits for completion. */
 usbd_status
 usbd_sync_transfer(struct usbd_xfer *xfer)
+{
 	xfer->ux_flags |= USBD_SYNCHRONOUS;
 	return usbd_transfer(xfer);
+}
 /* Like usbd_transfer(), but waits for completion and listens for signals. */
 usbd_status
 usbd_sync_transfer_sig(struct usbd_xfer *xfer)
+{
 	xfer->ux_flags |= USBD_SYNCHRONOUS | USBD_SYNCHRONOUS_SIG;
 	return usbd_transfer(xfer);
+}
 static void *
 usbd_alloc_buffer(struct usbd_xfer *xfer, uint32_t size)
+{
 	KASSERT(xfer->ux_buf == NULL);
 	KASSERT(size != 0);
 	xfer->ux_bufsize = 0;
 #if NUSB_DMA > 0
 	struct usbd_bus *bus = xfer->ux_bus;
 	if (bus->ub_usedma) {
 		usb_dma_t *dmap = &xfer->ux_dmabuf;
 		KASSERT((bus->ub_dmaflags & USBMALLOC_COHERENT) == 0);
 		int err = usb_allocmem(bus->ub_dmatag, size, 0, bus->ub_dmaflags, dmap);
 		if (err) {
 			return NULL;
+		}
 		xfer->ux_buf = KERNADDR(&xfer->ux_dmabuf, 0);
 		xfer->ux_bufsize = size;
 		return xfer->ux_buf;
+	}
 #endif
 	KASSERT(xfer->ux_bus->ub_usedma == false);
 	xfer->ux_buf = kmem_alloc(size, KM_SLEEP);
 	xfer->ux_bufsize = size;
 	return xfer->ux_buf;
+}
 static void
 usbd_free_buffer(struct usbd_xfer *xfer)
+{
 	KASSERT(xfer->ux_buf != NULL);
 	KASSERT(xfer->ux_bufsize != 0);
 	void *buf = xfer->ux_buf;
 	uint32_t size = xfer->ux_bufsize;
 	xfer->ux_buf = NULL;
 	xfer->ux_bufsize = 0;
 #if NUSB_DMA > 0
 	struct usbd_bus *bus = xfer->ux_bus;
 	if (bus->ub_usedma) {
 		usb_dma_t *dmap = &xfer->ux_dmabuf;
 		usb_freemem(dmap);
 		return;
+	}
 #endif
 	KASSERT(xfer->ux_bus->ub_usedma == false);
 	kmem_free(buf, size);
+}
 void *
 usbd_get_buffer(struct usbd_xfer *xfer)
+{
 	return xfer->ux_buf;
+}
 struct usbd_pipe *
 usbd_get_pipe0(struct usbd_device *dev)
+{
 	return dev->ud_pipe0;
+}
 static struct usbd_xfer *
 usbd_alloc_xfer(struct usbd_device *dev, unsigned int nframes)
+{
 	struct usbd_xfer *xfer;
 	USBHIST_FUNC();
 	ASSERT_SLEEPABLE();
 	xfer = dev->ud_bus->ub_methods->ubm_allocx(dev->ud_bus, nframes);
 	if (xfer == NULL)
 		goto out;
 	xfer->ux_bus = dev->ud_bus;
 	callout_init(&xfer->ux_callout, CALLOUT_MPSAFE);
 	callout_setfunc(&xfer->ux_callout, usbd_xfer_timeout, xfer);
 	cv_init(&xfer->ux_cv, "usbxfer");
 	usb_init_task(&xfer->ux_aborttask, usbd_xfer_timeout_task, xfer,
 	    USB_TASKQ_MPSAFE);
 out:
 	USBHIST_CALLARGS(usbdebug, "returns %#jx", (uintptr_t)xfer, 0, 0, 0);
 	return xfer;
+}
 static usbd_status
 usbd_free_xfer(struct usbd_xfer *xfer)
+{
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "%#jx", (uintptr_t)xfer, 0, 0, 0);
 	if (xfer->ux_buf) {
 		usbd_free_buffer(xfer);
+	}
 	/* Wait for any straggling timeout to complete. */
 	mutex_enter(xfer->ux_bus->ub_lock);
 	xfer->ux_timeout_reset = false; /* do not resuscitate */
 	callout_halt(&xfer->ux_callout, xfer->ux_bus->ub_lock);
 	usb_rem_task_wait(xfer->ux_pipe->up_dev, &xfer->ux_aborttask,
 	    USB_TASKQ_HC, xfer->ux_bus->ub_lock);
 	mutex_exit(xfer->ux_bus->ub_lock);
 	cv_destroy(&xfer->ux_cv);
 	xfer->ux_bus->ub_methods->ubm_freex(xfer->ux_bus, xfer);
 	return USBD_NORMAL_COMPLETION;
+}
 int
 usbd_create_xfer(struct usbd_pipe *pipe, size_t len, unsigned int flags,
     unsigned int nframes, struct usbd_xfer **xp)
+{
 	KASSERT(xp != NULL);
 	void *buf = NULL;
 	struct usbd_xfer *xfer = usbd_alloc_xfer(pipe->up_dev, nframes);
 	if (xfer == NULL)
 		return ENOMEM;
 	xfer->ux_pipe = pipe;
 	xfer->ux_flags = flags;
 	xfer->ux_nframes = nframes;
 	xfer->ux_methods = pipe->up_methods;
 	if (len) {
 		buf = usbd_alloc_buffer(xfer, len);
 		if (!buf) {
 			usbd_free_xfer(xfer);
 			return ENOMEM;
+		}
+	}
 	if (xfer->ux_methods->upm_init) {
 		int err = xfer->ux_methods->upm_init(xfer);
 		if (err) {
 			usbd_free_xfer(xfer);
 			return err;
+		}
+	}
 	*xp = xfer;
 	SDT_PROBE5(usb, device, xfer, create,
 	    xfer, pipe, len, flags, nframes);
 	return 0;
+}
 void
 usbd_destroy_xfer(struct usbd_xfer *xfer)
+{
 	SDT_PROBE1(usb, device, xfer, destroy,  xfer);
 	if (xfer->ux_methods->upm_fini)
 		xfer->ux_methods->upm_fini(xfer);
 	usbd_free_xfer(xfer);
+}
 void
 usbd_setup_xfer(struct usbd_xfer *xfer, void *priv, void *buffer,
     uint32_t length, uint16_t flags, uint32_t timeout, usbd_callback callback)
+{
 	KASSERT(xfer->ux_pipe);
 	xfer->ux_priv = priv;
 	xfer->ux_buffer = buffer;
 	xfer->ux_length = length;
 	xfer->ux_actlen = 0;
 	xfer->ux_flags = flags;
 	xfer->ux_timeout = timeout;
 	xfer->ux_status = USBD_NOT_STARTED;
 	xfer->ux_callback = callback;
 	xfer->ux_rqflags &= ~URQ_REQUEST;
 	xfer->ux_nframes = 0;
+}
 void
 usbd_setup_default_xfer(struct usbd_xfer *xfer, struct usbd_device *dev,
     void *priv, uint32_t timeout, usb_device_request_t *req, void *buffer,
     uint32_t length, uint16_t flags, usbd_callback callback)
+{
 	KASSERT(xfer->ux_pipe == dev->ud_pipe0);
 	xfer->ux_priv = priv;
 	xfer->ux_buffer = buffer;
 	xfer->ux_length = length;
 	xfer->ux_actlen = 0;
 	xfer->ux_flags = flags;
 	xfer->ux_timeout = timeout;
 	xfer->ux_status = USBD_NOT_STARTED;
 	xfer->ux_callback = callback;
 	xfer->ux_request = *req;
 	xfer->ux_rqflags |= URQ_REQUEST;
 	xfer->ux_nframes = 0;
+}
 void
 usbd_setup_isoc_xfer(struct usbd_xfer *xfer, void *priv, uint16_t *frlengths,
     uint32_t nframes, uint16_t flags, usbd_callback callback)
+{
 	xfer->ux_priv = priv;
 	xfer->ux_buffer = NULL;
 	xfer->ux_length = 0;
 	xfer->ux_actlen = 0;
 	xfer->ux_flags = flags;
 	xfer->ux_timeout = USBD_NO_TIMEOUT;
 	xfer->ux_status = USBD_NOT_STARTED;
 	xfer->ux_callback = callback;
 	xfer->ux_rqflags &= ~URQ_REQUEST;
 	xfer->ux_frlengths = frlengths;
 	xfer->ux_nframes = nframes;
 	for (size_t i = 0; i < xfer->ux_nframes; i++)
 		xfer->ux_length += xfer->ux_frlengths[i];
+}
 void
 usbd_get_xfer_status(struct usbd_xfer *xfer, void **priv,
 		     void **buffer, uint32_t *count, usbd_status *status)
+{
 	if (priv != NULL)
 		*priv = xfer->ux_priv;
 	if (buffer != NULL)
 		*buffer = xfer->ux_buffer;
 	if (count != NULL)
 		*count = xfer->ux_actlen;
 	if (status != NULL)
 		*status = xfer->ux_status;
+}
 usb_config_descriptor_t *
 usbd_get_config_descriptor(struct usbd_device *dev)
+{
 	KASSERT(dev != NULL);
 	return dev->ud_cdesc;
+}
 usb_interface_descriptor_t *
 usbd_get_interface_descriptor(struct usbd_interface *iface)
+{
 	KASSERT(iface != NULL);
 	return iface->ui_idesc;
+}
 usb_device_descriptor_t *
 usbd_get_device_descriptor(struct usbd_device *dev)
+{
 	KASSERT(dev != NULL);
 	return &dev->ud_ddesc;
+}
 usb_endpoint_descriptor_t *
 usbd_interface2endpoint_descriptor(struct usbd_interface *iface, uint8_t index)
+{
 	if (index >= iface->ui_idesc->bNumEndpoints)
 		return NULL;
 	return iface->ui_endpoints[index].ue_edesc;
+}
 /* Some drivers may wish to abort requests on the default pipe, *
  * but there is no mechanism for getting a handle on it.        */
-usbd_status
+void
 usbd_abort_default_pipe(struct usbd_device *device)
+{
-	return usbd_abort_pipe(device->ud_pipe0);
+	usbd_abort_pipe(device->ud_pipe0);
+}
-usbd_status
+void
 usbd_abort_pipe(struct usbd_pipe *pipe)
+{
 	usbd_status err;
 	KASSERT(pipe != NULL);
 	usbd_lock_pipe(pipe);
-	err = usbd_ar_pipe(pipe);
+	usbd_ar_pipe(pipe);
 	usbd_unlock_pipe(pipe);
 	return err;
+}
 usbd_status
 usbd_clear_endpoint_stall(struct usbd_pipe *pipe)
+{
 	struct usbd_device *dev = pipe->up_dev;
 	usbd_status err;
 	USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
 	SDT_PROBE1(usb, device, pipe, clear__endpoint__stall,  pipe);
 	/*
 	 * Clearing en endpoint stall resets the endpoint toggle, so
 	 * do the same to the HC toggle.
 	 */
 	SDT_PROBE1(usb, device, pipe, clear__endpoint__toggle,  pipe);
 	pipe->up_methods->upm_cleartoggle(pipe);
 	err = usbd_clear_endpoint_feature(dev,
 	    pipe->up_endpoint->ue_edesc->bEndpointAddress, UF_ENDPOINT_HALT);
 #if 0
 XXX should we do this?
 	if (!err) {
 		pipe->state = USBD_PIPE_ACTIVE;
 		/* XXX activate pipe */
+	}
 #endif
 	return err;
+}
 void
 usbd_clear_endpoint_stall_task(void *arg)
+{
 	struct usbd_pipe *pipe = arg;
 	struct usbd_device *dev = pipe->up_dev;
 	SDT_PROBE1(usb, device, pipe, clear__endpoint__stall,  pipe);
 	SDT_PROBE1(usb, device, pipe, clear__endpoint__toggle,  pipe);
 	pipe->up_methods->upm_cleartoggle(pipe);
 	(void)usbd_clear_endpoint_feature(dev,
 	    pipe->up_endpoint->ue_edesc->bEndpointAddress, UF_ENDPOINT_HALT);
+}
 void
 usbd_clear_endpoint_stall_async(struct usbd_pipe *pipe)
+{
 	usb_add_task(pipe->up_dev, &pipe->up_async_task, USB_TASKQ_DRIVER);
+}
 void
 usbd_clear_endpoint_toggle(struct usbd_pipe *pipe)
+{
 	SDT_PROBE1(usb, device, pipe, clear__endpoint__toggle,  pipe);
 	pipe->up_methods->upm_cleartoggle(pipe);
+}
 usbd_status
 usbd_endpoint_count(struct usbd_interface *iface, uint8_t *count)
+{
 	KASSERT(iface != NULL);
 	KASSERT(iface->ui_idesc != NULL);
 	*count = iface->ui_idesc->bNumEndpoints;
 	return USBD_NORMAL_COMPLETION;
+}
 usbd_status
 usbd_interface_count(struct usbd_device *dev, uint8_t *count)
+{
 	if (dev->ud_cdesc == NULL)
 		return USBD_NOT_CONFIGURED;
 	*count = dev->ud_cdesc->bNumInterface;
 	return USBD_NORMAL_COMPLETION;
+}
 void
 usbd_interface2device_handle(struct usbd_interface *iface,
 			     struct usbd_device **dev)
+{
 	*dev = iface->ui_dev;
+}
 usbd_status
 usbd_device2interface_handle(struct usbd_device *dev,
 			     uint8_t ifaceno, struct usbd_interface **iface)
+{
 	if (dev->ud_cdesc == NULL)
 		return USBD_NOT_CONFIGURED;
 	if (ifaceno >= dev->ud_cdesc->bNumInterface)
 		return USBD_INVAL;
 	*iface = &dev->ud_ifaces[ifaceno];
 	return USBD_NORMAL_COMPLETION;
+}
 struct usbd_device *
 usbd_pipe2device_handle(struct usbd_pipe *pipe)
+{
 	KASSERT(pipe != NULL);
 	return pipe->up_dev;
+}
 /* XXXX use altno */
 usbd_status
 usbd_set_interface(struct usbd_interface *iface, int altidx)
+{
 	bool locked = false;
 	usb_device_request_t req;
 	usbd_status err;
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "iface %#jx", (uintptr_t)iface, 0, 0, 0);
 	err = usbd_iface_lock(iface);
 	if (err)
 		goto out;
 	locked = true;
 	err = usbd_fill_iface_data(iface->ui_dev, iface->ui_index, altidx);
 	if (err)
 		goto out;
 	req.bmRequestType = UT_WRITE_INTERFACE;
 	req.bRequest = UR_SET_INTERFACE;
 	USETW(req.wValue, iface->ui_idesc->bAlternateSetting);
 	USETW(req.wIndex, iface->ui_idesc->bInterfaceNumber);
 	USETW(req.wLength, 0);
 	err = usbd_do_request(iface->ui_dev, &req, 0);
 out:	/* XXX back out iface data?  */
 	if (locked)
 		usbd_iface_unlock(iface);
 	return err;
+}
 int
 usbd_get_no_alts(usb_config_descriptor_t *cdesc, int ifaceno)
+{
 	char *p = (char *)cdesc;
 	char *end = p + UGETW(cdesc->wTotalLength);
 	usb_interface_descriptor_t *d;
 	int n;
 	for (n = 0; p < end; p += d->bLength) {
 		d = (usb_interface_descriptor_t *)p;
 		if (p + d->bLength <= end &&
 		    d->bDescriptorType == UDESC_INTERFACE &&
 		    d->bInterfaceNumber == ifaceno)
 			n++;
+	}
 	return n;
+}
 int
 usbd_get_interface_altindex(struct usbd_interface *iface)
+{
 	return iface->ui_altindex;
+}
 usbd_status
 usbd_get_interface(struct usbd_interface *iface, uint8_t *aiface)
+{
 	usb_device_request_t req;
 	req.bmRequestType = UT_READ_INTERFACE;
 	req.bRequest = UR_GET_INTERFACE;
 	USETW(req.wValue, 0);
 	USETW(req.wIndex, iface->ui_idesc->bInterfaceNumber);
 	USETW(req.wLength, 1);
 	return usbd_do_request(iface->ui_dev, &req, aiface);
+}
 /*** Internal routines ***/
 /* Dequeue all pipe operations, called with bus lock held. */
-Static usbd_status
+Static void
 usbd_ar_pipe(struct usbd_pipe *pipe)
+{
 	struct usbd_xfer *xfer;
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "pipe = %#jx", (uintptr_t)pipe, 0, 0, 0);
 	SDT_PROBE1(usb, device, pipe, abort__start,  pipe);
 	KASSERT(mutex_owned(pipe->up_dev->ud_bus->ub_lock));
 #ifdef USB_DEBUG
 	if (usbdebug > 5)
 		usbd_dump_queue(pipe);
 #endif
 	pipe->up_repeat = 0;
 	pipe->up_running = 0;
 	pipe->up_aborting = 1;
 	while ((xfer = SIMPLEQ_FIRST(&pipe->up_queue)) != NULL) {
 		USBHIST_LOG(usbdebug, "pipe = %#jx xfer = %#jx "
 		    "(methods = %#jx)", (uintptr_t)pipe, (uintptr_t)xfer,
 		    (uintptr_t)pipe->up_methods, 0);
 		if (xfer->ux_status == USBD_NOT_STARTED) {
 			SDT_PROBE1(usb, device, xfer, preabort,  xfer);
 #ifdef DIAGNOSTIC
 			xfer->ux_state = XFER_BUSY;
 #endif
 			SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next);
 		} else {
 			/* Make the HC abort it (and invoke the callback). */
 			SDT_PROBE1(usb, device, xfer, abort,  xfer);
 			pipe->up_methods->upm_abort(xfer);
 			while (pipe->up_callingxfer == xfer) {
 				USBHIST_LOG(usbdebug, "wait for callback"
 				    "pipe = %#jx xfer = %#jx",
 				    (uintptr_t)pipe, (uintptr_t)xfer, 0, 0);
 				cv_wait(&pipe->up_callingcv,
 				    pipe->up_dev->ud_bus->ub_lock);
+			}
 			/* XXX only for non-0 usbd_clear_endpoint_stall(pipe); */
+		}
+	}
 	pipe->up_aborting = 0;
 	SDT_PROBE1(usb, device, pipe, abort__done,  pipe);
 	return USBD_NORMAL_COMPLETION;
+}
 /* Called with USB lock held. */
 void
 usb_transfer_complete(struct usbd_xfer *xfer)
+{
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	struct usbd_bus *bus = pipe->up_dev->ud_bus;
 	int sync = xfer->ux_flags & USBD_SYNCHRONOUS;
 	int erred;
 	int polling = bus->ub_usepolling;
 	int repeat = pipe->up_repeat;
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "pipe = %#jx xfer = %#jx status = %jd "
 	    "actlen = %jd", (uintptr_t)pipe, (uintptr_t)xfer, xfer->ux_status,
 	    xfer->ux_actlen);
 	KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
 	KASSERTMSG(xfer->ux_state == XFER_ONQU, "xfer %p state is %x", xfer,
 	    xfer->ux_state);
 	KASSERT(pipe != NULL);
 	/*
 	 * If device is known to miss out ack, then pretend that
 	 * output timeout is a success. Userland should handle
 	 * the logic to verify that the operation succeeded.
 	 */
 	if (pipe->up_dev->ud_quirks &&
 	    pipe->up_dev->ud_quirks->uq_flags & UQ_MISS_OUT_ACK &&
 	    xfer->ux_status == USBD_TIMEOUT &&
 	    !usbd_xfer_isread(xfer)) {
 		USBHIST_LOG(usbdebug, "Possible output ack miss for xfer %#jx: "
 		    "hiding write timeout to %jd.%jd for %ju bytes written",
 		    (uintptr_t)xfer, curlwp->l_proc->p_pid, curlwp->l_lid,
 		    xfer->ux_length);
 		xfer->ux_status = USBD_NORMAL_COMPLETION;
 		xfer->ux_actlen = xfer->ux_length;
+	}
 	erred = xfer->ux_status == USBD_CANCELLED ||
 	        xfer->ux_status == USBD_TIMEOUT;
 	if (!repeat) {
 		/* Remove request from queue. */
 		KASSERTMSG(!SIMPLEQ_EMPTY(&pipe->up_queue),
 		    "pipe %p is empty, but xfer %p wants to complete", pipe,
 		     xfer);
 		KASSERTMSG(xfer == SIMPLEQ_FIRST(&pipe->up_queue),
 		    "xfer %p is not start of queue (%p is at start)", xfer,
 		   SIMPLEQ_FIRST(&pipe->up_queue));
 #ifdef DIAGNOSTIC
 		xfer->ux_state = XFER_BUSY;
 #endif
 		SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next);
+	}
 	USBHIST_LOG(usbdebug, "xfer %#jx: repeat %jd new head = %#jx",
 	    (uintptr_t)xfer, repeat, (uintptr_t)SIMPLEQ_FIRST(&pipe->up_queue),
 );
 	/* Count completed transfers. */
 	++pipe->up_dev->ud_bus->ub_stats.uds_requests
 		[pipe->up_endpoint->ue_edesc->bmAttributes & UE_XFERTYPE];
 	xfer->ux_done = 1;
 	if (!xfer->ux_status && xfer->ux_actlen < xfer->ux_length &&
 	    !(xfer->ux_flags & USBD_SHORT_XFER_OK)) {
 		USBHIST_LOG(usbdebug, "short transfer %jd < %jd",
 		    xfer->ux_actlen, xfer->ux_length, 0, 0);
 		xfer->ux_status = USBD_SHORT_XFER;
+	}
 	USBHIST_LOG(usbdebug, "xfer %#jx doing done %#jx", (uintptr_t)xfer,
 	    (uintptr_t)pipe->up_methods->upm_done, 0, 0);
 	SDT_PROBE2(usb, device, xfer, done,  xfer, xfer->ux_status);
 	pipe->up_methods->upm_done(xfer);
 	if (xfer->ux_length != 0 && xfer->ux_buffer != xfer->ux_buf) {
 		KDASSERTMSG(xfer->ux_actlen <= xfer->ux_length,
 		    "actlen %d length %d",xfer->ux_actlen, xfer->ux_length);
 		/* Only if IN transfer */
 		if (usbd_xfer_isread(xfer)) {
 			memcpy(xfer->ux_buffer, xfer->ux_buf, xfer->ux_actlen);
+		}
+	}
 	USBHIST_LOG(usbdebug, "xfer %#jx doing callback %#jx status %jd",
 	    (uintptr_t)xfer, (uintptr_t)xfer->ux_callback, xfer->ux_status, 0);
 	if (xfer->ux_callback) {
 		if (!polling) {
 			KASSERT(pipe->up_callingxfer == NULL);
 			pipe->up_callingxfer = xfer;
 			mutex_exit(pipe->up_dev->ud_bus->ub_lock);
 			if (!(pipe->up_flags & USBD_MPSAFE))
 				KERNEL_LOCK(1, curlwp);
+		}
 		xfer->ux_callback(xfer, xfer->ux_priv, xfer->ux_status);
 		if (!polling) {
 			if (!(pipe->up_flags & USBD_MPSAFE))
 				KERNEL_UNLOCK_ONE(curlwp);
 			mutex_enter(pipe->up_dev->ud_bus->ub_lock);
 			KASSERT(pipe->up_callingxfer == xfer);
 			pipe->up_callingxfer = NULL;
 			cv_broadcast(&pipe->up_callingcv);
+		}
+	}
 	if (sync && !polling) {
 		USBHIST_LOG(usbdebug, "<- done xfer %#jx, wakeup",
 		    (uintptr_t)xfer, 0, 0, 0);
 		cv_broadcast(&xfer->ux_cv);
+	}
 	if (repeat) {
 		xfer->ux_actlen = 0;
 		xfer->ux_status = USBD_NOT_STARTED;
 	} else {
 		/* XXX should we stop the queue on all errors? */
 		if (erred && pipe->up_iface != NULL)	/* not control pipe */
 			pipe->up_running = 0;
+	}
 	if (pipe->up_running && pipe->up_serialise)
 		usbd_start_next(pipe);
+}
 /* Called with USB lock held. */
 static usbd_status
 usb_insert_transfer(struct usbd_xfer *xfer)
+{
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	usbd_status err;
 	USBHIST_FUNC(); USBHIST_CALLARGS(usbdebug,
 	    "xfer = %#jx pipe = %#jx running = %jd timeout = %jd",
 	    (uintptr_t)xfer, (uintptr_t)pipe,
 	    pipe->up_running, xfer->ux_timeout);
 	KASSERT(mutex_owned(pipe->up_dev->ud_bus->ub_lock));
 	KASSERTMSG(xfer->ux_state == XFER_BUSY, "xfer %p state is %x", xfer,
 	    xfer->ux_state);
 #ifdef DIAGNOSTIC
 	xfer->ux_state = XFER_ONQU;
 #endif
 	SIMPLEQ_INSERT_TAIL(&pipe->up_queue, xfer, ux_next);
 	if (pipe->up_running && pipe->up_serialise)
 		err = USBD_IN_PROGRESS;
 	else {
 		pipe->up_running = 1;
 		err = USBD_NORMAL_COMPLETION;
+	}
 	USBHIST_LOG(usbdebug, "<- done xfer %#jx, err %jd", (uintptr_t)xfer,
 	    err, 0, 0);
 	return err;
+}
 /* Called with USB lock held. */
 void
 usbd_start_next(struct usbd_pipe *pipe)
+{
 	struct usbd_xfer *xfer;
 	usbd_status err;
 	USBHIST_FUNC();
 	KASSERT(pipe != NULL);
 	KASSERT(pipe->up_methods != NULL);
 	KASSERT(pipe->up_methods->upm_start != NULL);
 	KASSERT(pipe->up_serialise == true);
 	int polling = pipe->up_dev->ud_bus->ub_usepolling;
 	KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
 	/* Get next request in queue. */
 	xfer = SIMPLEQ_FIRST(&pipe->up_queue);
 	USBHIST_CALLARGS(usbdebug, "pipe = %#jx, xfer = %#jx", (uintptr_t)pipe,
 	    (uintptr_t)xfer, 0, 0);
 	if (xfer == NULL) {
 		pipe->up_running = 0;
 	} else {
 		if (!polling)
 			mutex_exit(pipe->up_dev->ud_bus->ub_lock);
 		SDT_PROBE2(usb, device, pipe, start,  pipe, xfer);
 		err = pipe->up_methods->upm_start(xfer);
 		if (!polling)
 			mutex_enter(pipe->up_dev->ud_bus->ub_lock);
 		if (err != USBD_IN_PROGRESS) {
 			USBHIST_LOG(usbdebug, "error = %jd", err, 0, 0, 0);
 			pipe->up_running = 0;
 			/* XXX do what? */
+		}
+	}
 	KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock));
+}
 usbd_status
 usbd_do_request(struct usbd_device *dev, usb_device_request_t *req, void *data)
+{
 	return usbd_do_request_flags(dev, req, data, 0, 0,
 	    USBD_DEFAULT_TIMEOUT);
+}
 usbd_status
 usbd_do_request_flags(struct usbd_device *dev, usb_device_request_t *req,
     void *data, uint16_t flags, int *actlen, uint32_t timeout)
+{
 	size_t len = UGETW(req->wLength);
 	return usbd_do_request_len(dev, req, len, data, flags, actlen, timeout);
+}
 usbd_status
 usbd_do_request_len(struct usbd_device *dev, usb_device_request_t *req,
     size_t len, void *data, uint16_t flags, int *actlen, uint32_t timeout)
+{
 	struct usbd_xfer *xfer;
 	usbd_status err;
 	KASSERT(len >= UGETW(req->wLength));
 	USBHIST_FUNC();
 	USBHIST_CALLARGS(usbdebug, "dev=%#jx req=%jx flags=%jx len=%jx",
 	    (uintptr_t)dev, (uintptr_t)req, flags, len);
 	ASSERT_SLEEPABLE();
 	int error = usbd_create_xfer(dev->ud_pipe0, len, 0, 0, &xfer);
 	if (error)
 		return USBD_NOMEM;
 	usbd_setup_default_xfer(xfer, dev, 0, timeout, req, data,
 	    UGETW(req->wLength), flags, NULL);
 	KASSERT(xfer->ux_pipe == dev->ud_pipe0);
 	err = usbd_sync_transfer(xfer);
 #if defined(USB_DEBUG) || defined(DIAGNOSTIC)
 	if (xfer->ux_actlen > xfer->ux_length) {
 		USBHIST_LOG(usbdebug, "overrun addr = %jd type = 0x%02jx",
 		    dev->ud_addr, xfer->ux_request.bmRequestType, 0, 0);
 		USBHIST_LOG(usbdebug, "     req = 0x%02jx val = %jd "
 		    "index = %jd",
 		    xfer->ux_request.bRequest, UGETW(xfer->ux_request.wValue),
 		    UGETW(xfer->ux_request.wIndex), 0);
 		USBHIST_LOG(usbdebug, "     rlen = %jd length = %jd "
 		    "actlen = %jd",
 		    UGETW(xfer->ux_request.wLength),
 		    xfer->ux_length, xfer->ux_actlen, 0);
+	}
 #endif
 	if (actlen != NULL)
 		*actlen = xfer->ux_actlen;
 	usbd_destroy_xfer(xfer);
 	if (err) {
 		USBHIST_LOG(usbdebug, "returning err = %jd", err, 0, 0, 0);
+	}
 	return err;
+}
 static void
 usbd_request_async_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	usbd_destroy_xfer(xfer);
+}
 /*
  * Execute a request without waiting for completion.
  * Can be used from interrupt context.
  */
 usbd_status
 usbd_request_async(struct usbd_device *dev, struct usbd_xfer *xfer,
     usb_device_request_t *req, void *priv, usbd_callback callback)
+{
 	usbd_status err;
 	if (callback == NULL)
 		callback = usbd_request_async_cb;
 	usbd_setup_default_xfer(xfer, dev, priv,
 	    USBD_DEFAULT_TIMEOUT, req, NULL, UGETW(req->wLength), 0,
 	    callback);
 	err = usbd_transfer(xfer);
 	if (err != USBD_IN_PROGRESS) {
 		usbd_destroy_xfer(xfer);
 		return (err);
+	}
 	return (USBD_NORMAL_COMPLETION);
+}
 const struct usbd_quirks *
 usbd_get_quirks(struct usbd_device *dev)
+{
 #ifdef DIAGNOSTIC
 	if (dev == NULL) {
 		printf("usbd_get_quirks: dev == NULL\n");
 		return 0;
+	}
 #endif
 	return dev->ud_quirks;
+}
 /* XXX do periodic free() of free list */
 /*
  * Called from keyboard driver when in polling mode.
  */
 void
 usbd_dopoll(struct usbd_interface *iface)
+{
 	iface->ui_dev->ud_bus->ub_methods->ubm_dopoll(iface->ui_dev->ud_bus);
+}
 /*
  * This is for keyboard driver as well, which only operates in polling
  * mode from the ask root, etc., prompt and from DDB.
  */
 void
 usbd_set_polling(struct usbd_device *dev, int on)
+{
 	if (on)
 		dev->ud_bus->ub_usepolling++;
 	else
 		dev->ud_bus->ub_usepolling--;
 	/* Kick the host controller when switching modes */
 	mutex_enter(dev->ud_bus->ub_lock);
 	dev->ud_bus->ub_methods->ubm_softint(dev->ud_bus);
 	mutex_exit(dev->ud_bus->ub_lock);
+}
 usb_endpoint_descriptor_t *
 usbd_get_endpoint_descriptor(struct usbd_interface *iface, uint8_t address)
+{
 	struct usbd_endpoint *ep;
 	int i;
 	for (i = 0; i < iface->ui_idesc->bNumEndpoints; i++) {
 		ep = &iface->ui_endpoints[i];
 		if (ep->ue_edesc->bEndpointAddress == address)
 			return iface->ui_endpoints[i].ue_edesc;
+	}
 	return NULL;
+}
 /*
  * usbd_ratecheck() can limit the number of error messages that occurs.
  * When a device is unplugged it may take up to 0.25s for the hub driver
  * to notice it.  If the driver continuously tries to do I/O operations
  * this can generate a large number of messages.
  */
 int
 usbd_ratecheck(struct timeval *last)
+{
 	static struct timeval errinterval = { 0, 250000 }; /* 0.25 s*/
 	return ratecheck(last, &errinterval);
+}
 /*
  * Search for a vendor/product pair in an array.  The item size is
  * given as an argument.
  */
 const struct usb_devno *
 usb_match_device(const struct usb_devno *tbl, u_int nentries, u_int sz,
 		 uint16_t vendor, uint16_t product)
+{
 	while (nentries-- > 0) {
 		uint16_t tproduct = tbl->ud_product;
 		if (tbl->ud_vendor == vendor &&
 		    (tproduct == product || tproduct == USB_PRODUCT_ANY))
 			return tbl;
 		tbl = (const struct usb_devno *)((const char *)tbl + sz);
+	}
 	return NULL;
+}
 usbd_status
 usbd_get_string(struct usbd_device *dev, int si, char *buf)
+{
 	return usbd_get_string0(dev, si, buf, 1);
+}
 usbd_status
 usbd_get_string0(struct usbd_device *dev, int si, char *buf, int unicode)
+{
 	int swap = dev->ud_quirks->uq_flags & UQ_SWAP_UNICODE;
 	usb_string_descriptor_t us;
 	char *s;
 	int i, n;
 	uint16_t c;
 	usbd_status err;
 	int size;
 	USBHIST_FUNC(); USBHIST_CALLED(usbdebug);
 	buf[0] = '\0';
 	if (si == 0)
 		return USBD_INVAL;
 	if (dev->ud_quirks->uq_flags & UQ_NO_STRINGS)
 		return USBD_STALLED;
 	if (dev->ud_langid == USBD_NOLANG) {
 		/* Set up default language */
 		err = usbd_get_string_desc(dev, USB_LANGUAGE_TABLE, 0, &us,
 		    &size);
 		if (err || size < 4) {
 			USBHIST_LOG(usbdebug, "getting lang failed, using 0",
 , 0, 0, 0);
 			dev->ud_langid = 0; /* Well, just pick something then */
 		} else {
 			/* Pick the first language as the default. */
 			dev->ud_langid = UGETW(us.bString[0]);
+		}
+	}
 	err = usbd_get_string_desc(dev, si, dev->ud_langid, &us, &size);
 	if (err)
 		return err;
 	s = buf;
 	n = size / 2 - 1;
 	if (unicode) {
 		for (i = 0; i < n; i++) {
 			c = UGETW(us.bString[i]);
 			if (swap)
 				c = (c >> 8) | (c << 8);
 			s += wput_utf8(s, 3, c);
+		}
 		*s++ = 0;
+	}
 #ifdef COMPAT_30
 	else {
 		for (i = 0; i < n; i++) {
 			c = UGETW(us.bString[i]);
 			if (swap)
 				c = (c >> 8) | (c << 8);
 			*s++ = (c < 0x80) ? c : '?';
+		}
 		*s++ = 0;
+	}
 #endif
 	return USBD_NORMAL_COMPLETION;
+}
 /*
  * usbd_xfer_trycomplete(xfer)
+ *
  *	Try to claim xfer for completion.  Return true if successful,
  *	false if the xfer has been synchronously aborted or has timed
  *	out.
+ *
  *	If this returns true, caller is responsible for setting
  *	xfer->ux_status and calling usb_transfer_complete.  To be used
  *	in a host controller interrupt handler.
+ *
  *	Caller must either hold the bus lock or have the bus in polling
  *	mode.
  */
 bool
 usbd_xfer_trycomplete(struct usbd_xfer *xfer)
+{
 	struct usbd_bus *bus __diagused = xfer->ux_bus;
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	/*
 	 * If software has completed it, either by synchronous abort or
 	 * by timeout, too late.
 	 */
 	if (xfer->ux_status != USBD_IN_PROGRESS)
 		return false;
 	/*
 	 * We are completing the xfer.  Cancel the timeout if we can,
 	 * but only asynchronously.  See usbd_xfer_cancel_timeout_async
 	 * for why we need not wait for the callout or task here.
 	 */
 	usbd_xfer_cancel_timeout_async(xfer);
 	/* Success!  Note: Caller must set xfer->ux_status afterwar.  */
 	return true;
+}
 /*
  * usbd_xfer_abort(xfer)
+ *
  *	Try to claim xfer to abort.  If successful, mark it completed
  *	with USBD_CANCELLED and call the bus-specific method to abort
  *	at the hardware level.
+ *
  *	To be called in thread context from struct
  *	usbd_pipe_methods::upm_abort.
+ *
  *	Caller must hold the bus lock.
  */
 void
 usbd_xfer_abort(struct usbd_xfer *xfer)
+{
 	struct usbd_bus *bus = xfer->ux_bus;
 	KASSERT(mutex_owned(bus->ub_lock));
 	/*
 	 * If host controller interrupt or timer interrupt has
 	 * completed it, too late.  But the xfer cannot be
 	 * cancelled already -- only one caller can synchronously
 	 * abort.
 	 */
 	KASSERT(xfer->ux_status != USBD_CANCELLED);
 	if (xfer->ux_status != USBD_IN_PROGRESS)
 		return;
 	/*
 	 * Cancel the timeout if we can, but only asynchronously; see
 	 * usbd_xfer_cancel_timeout_async for why we need not wait for
 	 * the callout or task here.
 	 */
 	usbd_xfer_cancel_timeout_async(xfer);
 	/*
 	 * We beat everyone else.  Claim the status as cancelled and do
 	 * the bus-specific dance to abort the hardware.
 	 */
 	xfer->ux_status = USBD_CANCELLED;
 	bus->ub_methods->ubm_abortx(xfer);
+}
 /*
  * usbd_xfer_timeout(xfer)
+ *
  *	Called at IPL_SOFTCLOCK when too much time has elapsed waiting
  *	for xfer to complete.  Since we can't abort the xfer at
  *	IPL_SOFTCLOCK, defer to a usb_task to run it in thread context,
  *	unless the xfer has completed or aborted concurrently -- and if
  *	the xfer has also been resubmitted, take care of rescheduling
  *	the callout.
  */
 static void
 usbd_xfer_timeout(void *cookie)
+{
 	struct usbd_xfer *xfer = cookie;
 	struct usbd_bus *bus = xfer->ux_bus;
 	struct usbd_device *dev = xfer->ux_pipe->up_dev;
 	/* Acquire the lock so we can transition the timeout state.  */
 	mutex_enter(bus->ub_lock);
 	/*
 	 * Use usbd_xfer_probe_timeout to check whether the timeout is
 	 * still valid, or to reschedule the callout if necessary.  If
 	 * it is still valid, schedule the task.
 	 */
 	if (usbd_xfer_probe_timeout(xfer))
 		usb_add_task(dev, &xfer->ux_aborttask, USB_TASKQ_HC);
 	/*
 	 * Notify usbd_xfer_cancel_timeout_async that we may have
 	 * scheduled the task.  This causes callout_invoking to return
 	 * false in usbd_xfer_cancel_timeout_async so that it can tell
 	 * which stage in the callout->task->abort process we're at.
 	 */
 	callout_ack(&xfer->ux_callout);
 	/* All done -- release the lock.  */
 	mutex_exit(bus->ub_lock);
+}
 /*
  * usbd_xfer_timeout_task(xfer)
+ *
  *	Called in thread context when too much time has elapsed waiting
  *	for xfer to complete.  Abort the xfer with USBD_TIMEOUT, unless
  *	it has completed or aborted concurrently -- and if the xfer has
  *	also been resubmitted, take care of rescheduling the callout.
  */
 static void
 usbd_xfer_timeout_task(void *cookie)
+{
 	struct usbd_xfer *xfer = cookie;
 	struct usbd_bus *bus = xfer->ux_bus;
 	/* Acquire the lock so we can transition the timeout state.  */
 	mutex_enter(bus->ub_lock);
 	/*
 	 * Use usbd_xfer_probe_timeout to check whether the timeout is
 	 * still valid, or to reschedule the callout if necessary.  If
 	 * it is not valid -- the timeout has been asynchronously
 	 * cancelled, or the xfer has already been resubmitted -- then
 	 * we're done here.
 	 */
 	if (!usbd_xfer_probe_timeout(xfer))
 		goto out;
 	/*
 	 * May have completed or been aborted, but we're the only one
 	 * who can time it out.  If it has completed or been aborted,
 	 * no need to timeout.
 	 */
 	KASSERT(xfer->ux_status != USBD_TIMEOUT);
 	if (xfer->ux_status != USBD_IN_PROGRESS)
 		goto out;
 	/*
 	 * We beat everyone else.  Claim the status as timed out and do
 	 * the bus-specific dance to abort the hardware.
 	 */
 	xfer->ux_status = USBD_TIMEOUT;
 	bus->ub_methods->ubm_abortx(xfer);
 out:	/* All done -- release the lock.  */
 	mutex_exit(bus->ub_lock);
+}
 /*
  * usbd_xfer_probe_timeout(xfer)
+ *
  *	Probe the status of xfer's timeout.  Acknowledge and process a
  *	request to reschedule.  Return true if the timeout is still
  *	valid and the caller should take further action (queueing a
  *	task or aborting the xfer), false if it must stop here.
  */
 static bool
 usbd_xfer_probe_timeout(struct usbd_xfer *xfer)
+{
 	struct usbd_bus *bus = xfer->ux_bus;
 	bool valid;
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	/* The timeout must be set.  */
 	KASSERT(xfer->ux_timeout_set);
 	/*
 	 * Neither callout nor task may be pending; they execute
 	 * alternately in lock step.
 	 */
 	KASSERT(!callout_pending(&xfer->ux_callout));
 	KASSERT(!usb_task_pending(xfer->ux_pipe->up_dev, &xfer->ux_aborttask));
 	/* There are a few cases... */
 	if (bus->ub_methods->ubm_dying(bus)) {
 		/* Host controller dying.  Drop it all on the floor.  */
 		xfer->ux_timeout_set = false;
 		xfer->ux_timeout_reset = false;
 		valid = false;
 	} else if (xfer->ux_timeout_reset) {
 		/*
 		 * The xfer completed _and_ got resubmitted while we
 		 * waited for the lock.  Acknowledge the request to
 		 * reschedule, and reschedule it if there is a timeout
 		 * and the bus is not polling.
 		 */
 		xfer->ux_timeout_reset = false;
 		if (xfer->ux_timeout && !bus->ub_usepolling) {
 			KASSERT(xfer->ux_timeout_set);
 			callout_schedule(&xfer->ux_callout,
 			    mstohz(xfer->ux_timeout));
 		} else {
 			/* No more callout or task scheduled.  */
 			xfer->ux_timeout_set = false;
+		}
 		valid = false;
 	} else if (xfer->ux_status != USBD_IN_PROGRESS) {
 		/*
 		 * The xfer has completed by hardware completion or by
 		 * software abort, and has not been resubmitted, so the
 		 * timeout must be unset, and is no longer valid for
 		 * the caller.
 		 */
 		xfer->ux_timeout_set = false;
 		valid = false;
 	} else {
 		/*
 		 * The xfer has not yet completed, so the timeout is
 		 * valid.
 		 */
 		valid = true;
+	}
 	/* Any reset must have been processed.  */
 	KASSERT(!xfer->ux_timeout_reset);
 	/*
 	 * Either we claim the timeout is set, or the callout is idle.
 	 * If the timeout is still set, we may be handing off to the
 	 * task instead, so this is an if but not an iff.
 	 */
 	KASSERT(xfer->ux_timeout_set || !callout_pending(&xfer->ux_callout));
 	/*
 	 * The task must be idle now.
+	 *
 	 * - If the caller is the callout, _and_ the timeout is still
 	 *   valid, the caller will schedule it, but it hasn't been
 	 *   scheduled yet.  (If the timeout is not valid, the task
 	 *   should not be scheduled.)
+	 *
 	 * - If the caller is the task, it cannot be scheduled again
 	 *   until the callout runs again, which won't happen until we
 	 *   next release the lock.
 	 */
 	KASSERT(!usb_task_pending(xfer->ux_pipe->up_dev, &xfer->ux_aborttask));
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	return valid;
+}
 /*
  * usbd_xfer_schedule_timeout(xfer)
+ *
  *	Ensure that xfer has a timeout.  If the callout is already
  *	queued or the task is already running, request that they
  *	reschedule the callout.  If not, and if we're not polling,
  *	schedule the callout anew.
+ *
  *	To be called in thread context from struct
  *	usbd_pipe_methods::upm_start.
  */
 void
 usbd_xfer_schedule_timeout(struct usbd_xfer *xfer)
+{
 	struct usbd_bus *bus = xfer->ux_bus;
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	if (xfer->ux_timeout_set) {
 		/*
 		 * Callout or task has fired from a prior completed
 		 * xfer but has not yet noticed that the xfer is done.
 		 * Ask it to reschedule itself to ux_timeout.
 		 */
 		xfer->ux_timeout_reset = true;
 	} else if (xfer->ux_timeout && !bus->ub_usepolling) {
 		/* Callout is not scheduled.  Schedule it.  */
 		KASSERT(!callout_pending(&xfer->ux_callout));
 		callout_schedule(&xfer->ux_callout, mstohz(xfer->ux_timeout));
 		xfer->ux_timeout_set = true;
+	}
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
+}
 /*
  * usbd_xfer_cancel_timeout_async(xfer)
+ *
  *	Cancel the callout and the task of xfer, which have not yet run
  *	to completion, but don't wait for the callout or task to finish
  *	running.
+ *
  *	If they have already fired, at worst they are waiting for the
  *	bus lock.  They will see that the xfer is no longer in progress
  *	and give up, or they will see that the xfer has been
  *	resubmitted with a new timeout and reschedule the callout.
+ *
  *	If a resubmitted request completed so fast that the callout
  *	didn't have time to process a timer reset, just cancel the
  *	timer reset.
  */
 static void
 usbd_xfer_cancel_timeout_async(struct usbd_xfer *xfer)
+{
 	struct usbd_bus *bus __diagused = xfer->ux_bus;
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
 	/*
 	 * If the timer wasn't running anyway, forget about it.  This
 	 * can happen if we are completing an isochronous transfer
 	 * which doesn't use the same timeout logic.
 	 */
 	if (!xfer->ux_timeout_set)
 		return;
 	xfer->ux_timeout_reset = false;
 	if (!callout_stop(&xfer->ux_callout)) {
 		/*
 		 * We stopped the callout before it ran.  The timeout
 		 * is no longer set.
 		 */
 		xfer->ux_timeout_set = false;
 	} else if (callout_invoking(&xfer->ux_callout)) {
 		/*
 		 * The callout has begun to run but it has not yet
 		 * acquired the lock and called callout_ack.  The task
 		 * cannot be queued yet, and the callout cannot have
 		 * been rescheduled yet.
+		 *
 		 * By the time the callout acquires the lock, we will
 		 * have transitioned from USBD_IN_PROGRESS to a
 		 * completed status, and possibly also resubmitted the
 		 * xfer and set xfer->ux_timeout_reset = true.  In both
 		 * cases, the callout will DTRT, so no further action
 		 * is needed here.
 		 */
 	} else if (usb_rem_task(xfer->ux_pipe->up_dev, &xfer->ux_aborttask)) {
 		/*
 		 * The callout had fired and scheduled the task, but we
 		 * stopped the task before it could run.  The timeout
 		 * is therefore no longer set -- the next resubmission
 		 * of the xfer must schedule a new timeout.
+		 *
 		 * The callout should not be pending at this point:
 		 * it is scheduled only under the lock, and only when
 		 * xfer->ux_timeout_set is false, or by the callout or
 		 * task itself when xfer->ux_timeout_reset is true.
 		 */
 		xfer->ux_timeout_set = false;
+	}
 	/*
 	 * The callout cannot be scheduled and the task cannot be
 	 * queued at this point.  Either we cancelled them, or they are
 	 * already running and waiting for the bus lock.
 	 */
 	KASSERT(!callout_pending(&xfer->ux_callout));
 	KASSERT(!usb_task_pending(xfer->ux_pipe->up_dev, &xfer->ux_aborttask));
 	KASSERT(bus->ub_usepolling || mutex_owned(bus->ub_lock));
+}

 @@ -1,1646 +1,1637 @@
-/*	$NetBSD: usbnet.c,v 1.91 2022/03/03 05:56:44 riastradh Exp $	*/
+/*	$NetBSD: usbnet.c,v 1.92 2022/03/03 06:05:38 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.91 2022/03/03 05:56:44 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: usbnet.c,v 1.92 2022/03/03 06:05:38 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
+	 *
 	 * the lock ordering is:
 	 *	ifnet lock -> unp_core_lock -> unp_rxlock -> unp_txlock
 	 *				    -> unp_mcastlock
 	 * - 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;
 	kmutex_t		unp_mcastlock;
 	bool			unp_mcastactive;
 	struct usbnet_cdata	unp_cdata;
 	struct ethercom		unp_ec;
 	struct mii_data		unp_mii;
 	struct usb_task		unp_ticktask;
 	struct callout		unp_stat_ch;
 	struct usbd_pipe	*unp_ep[USBNET_ENDPT_MAX];
 	volatile bool		unp_dying;
 	bool			unp_stopping;
 	bool			unp_attached;
 	bool			unp_ifp_attached;
 	bool			unp_link;
 	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 void usbnet_isowned_rx(struct usbnet *);
 static void usbnet_isowned_tx(struct usbnet *);
 static kmutex_t *
 usbnet_mutex_core(struct usbnet *un)
+{
 	return &un->un_pri->unp_core_lock;
+}
 static __inline__ void
 usbnet_isowned_core(struct usbnet *un)
+{
 	KASSERT(mutex_owned(usbnet_mutex_core(un)));
+}
 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)
+{
 	KASSERTMSG(cmd != SIOCADDMULTI, "%s", ifp->if_xname);
 	KASSERTMSG(cmd != SIOCDELMULTI, "%s", ifp->if_xname);
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	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)
+{
 	switch (cmd) {
 	case SIOCADDMULTI:
 	case SIOCDELMULTI:
 		break;
 	default:
 		KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
+	}
 	return (*un->un_ops->uno_override_ioctl)(ifp, cmd, data);
+}
 static int
 uno_init(struct usbnet *un, struct ifnet *ifp)
+{
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	return un->un_ops->uno_init ? (*un->un_ops->uno_init)(ifp) : 0;
+}
 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 (usbnet_isdying(un) || 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 (usbnet_isdying(un) || 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 || usbnet_isdying(un)) {
 		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 || usbnet_isdying(un) || 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,
 		    (usbnet_isdying(un) << 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
+static void
 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]);
+		usbd_abort_pipe(unp->unp_ep[i]);
 		if (err == USBD_NORMAL_COMPLETION && err2)
 			err = err2;
+	}
 	return err;
+}
 static 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 (usbnet_isdying(un)) {
 		return EIO;
+	}
 	/* 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. */
 	/* XXX urndis calls usbnet_init_rx_tx before usbnet_attach_ifp.  */
 	KASSERTMSG(!unp->unp_ifp_attached || IFNET_LOCKED(ifp),
 	    "%s", ifp->if_xname);
 	ifp->if_flags |= IFF_RUNNING;
 	/*
 	 * If the hardware has a multicast filter, program it and then
 	 * allow updates to it while we're running.
 	 */
 	if (un->un_ops->uno_mcast) {
 		mutex_enter(&unp->unp_mcastlock);
 		(*un->un_ops->uno_mcast)(ifp);
 		unp->unp_mcastactive = true;
 		mutex_exit(&unp->unp_mcastlock);
+	}
 	/* 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);
+	}
 	/*
 	 * For devices without any media autodetection, treat success
 	 * here as an active link.
 	 */
 	if (un->un_ops->uno_statchg == NULL)
 		usbnet_set_link(un, error == 0);
 	usbnet_isowned_core(un);
 	return error;
+}
 /* MII management. */
 static int
 usbnet_mii_readreg(device_t dev, int phy, int reg, uint16_t *val)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = device_private(dev);
 	int err;
 	/* MII layer ensures core_lock is held. */
 	usbnet_isowned_core(un);
 	if (usbnet_isdying(un)) {
 		return EIO;
+	}
 	err = uno_read_reg(un, phy, reg, val);
 	if (err) {
 		USBNETHIST_CALLARGS("%jd: read PHY failed: %jd",
 		    un->un_pri->unp_number, err, 0, 0);
 		return err;
+	}
 	return 0;
+}
 static int
 usbnet_mii_writereg(device_t dev, int phy, int reg, uint16_t val)
+{
 	USBNETHIST_FUNC();
 	struct usbnet * const un = device_private(dev);
 	int err;
 	/* MII layer ensures core_lock is held. */
 	usbnet_isowned_core(un);
 	if (usbnet_isdying(un)) {
 		return EIO;
+	}
 	err = uno_write_reg(un, phy, reg, val);
 	if (err) {
 		USBNETHIST_CALLARGS("%jd: write PHY failed: %jd",
 		    un->un_pri->unp_number, err, 0, 0);
 		return err;
+	}
 	return 0;
+}
 static 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);
 	uno_mii_statchg(un, ifp);
+}
 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);
 	/* ifmedia changes only with IFNET_LOCK held.  */
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	if (usbnet_isdying(un))
 		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);
 	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;
+	}
 	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:
 			/*
 			 * If there's a hardware multicast filter, and
 			 * it has been programmed by usbnet_init_rx_tx
 			 * and is active, update it now.  Otherwise,
 			 * drop the update on the floor -- it will be
 			 * observed by usbnet_init_rx_tx next time we
 			 * bring the interface up.
 			 */
 			if (un->un_ops->uno_mcast) {
 				mutex_enter(&unp->unp_mcastlock);
 				if (unp->unp_mcastactive)
 					(*un->un_ops->uno_mcast)(ifp);
 				mutex_exit(&unp->unp_mcastlock);
+			}
 			error = 0;
 			break;
 		default:
 			error = uno_ioctl(un, ifp, cmd, data);
+		}
+	}
 	return error;
+}
 /*
  * 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_if_stop() is for the if_stop handler.
  */
 static 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);
 	/*
 	 * For drivers with hardware multicast filter update callbacks:
 	 * Prevent concurrent access to the hardware registers by
 	 * multicast filter updates, which happens without IFNET_LOCK
 	 * or the usbnet core lock.
 	 */
 	if (un->un_ops->uno_mcast) {
 		mutex_enter(&unp->unp_mcastlock);
 		unp->unp_mcastactive = false;
 		mutex_exit(&unp->unp_mcastlock);
+	}
 	/*
 	 * Prevent new activity (rescheduling ticks, xfers, &c.) and
 	 * clear the watchdog timer.
 	 */
 	mutex_enter(&unp->unp_rxlock);
 	mutex_enter(&unp->unp_txlock);
 	unp->unp_stopping = true;
 	unp->unp_timer = 0;
 	mutex_exit(&unp->unp_txlock);
 	mutex_exit(&unp->unp_rxlock);
 	/*
 	 * Stop the timer first, then the task -- if the timer was
 	 * already firing, we stop the task or wait for it complete
 	 * only after if last fired.  Setting unp_stopping prevents the
 	 * timer task from being scheduled again.
 	 */
 	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);
 	/*
 	 * Now that the software is quiescent, ask the driver to stop
 	 * the hardware.  The driver's uno_stop routine now has
 	 * exclusive access to any registers that might previously have
 	 * been used by to ifmedia, mii, or ioctl callbacks.
+	 *
 	 * Don't bother if the device is being detached, though -- if
 	 * it's been unplugged then there's no point in trying to touch
 	 * the registers.
 	 */
 	if (!usbnet_isdying(un))
 		uno_stop(un, ifp, disable);
 	/* 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;
+}
 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);
 	/*
 	 * If we're already stopped, nothing to do.
+	 *
 	 * XXX This should be an assertion, but it may require some
 	 * analysis -- and possibly some tweaking -- of sys/net to
 	 * ensure.
 	 */
 	if ((ifp->if_flags & IFF_RUNNING) == 0)
 		return;
 	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);
 	/* 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]);
+		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;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct mii_data * const mii = usbnet_mii(un);
 	USBNETHIST_CALLARGSN(8, "%jd: enter", unp->unp_number, 0, 0, 0);
 	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);
 	if (!unp->unp_stopping && !usbnet_isdying(un))
 		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;
 	int error;
 	KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
 	/*
 	 * Prevent anyone from bringing the interface back up once
 	 * we're detaching.
 	 */
 	if (usbnet_isdying(un))
 		return EIO;
 	/*
 	 * If we're already running, nothing to do.
+	 *
 	 * XXX This should be an assertion, but it may require some
 	 * analysis -- and possibly some tweaking -- of sys/net to
 	 * ensure.
 	 */
 	if (ifp->if_flags & IFF_RUNNING)
 		return 0;
 	mutex_enter(&un->un_pri->unp_core_lock);
 	error = uno_init(un, ifp);
 	if (error)
 		goto out;
 	error = usbnet_init_rx_tx(un);
 	if (error)
 		goto out;
 out:	mutex_exit(&un->un_pri->unp_core_lock);
 	return error;
+}
 /* Various accessors. */
 void
 usbnet_set_link(struct usbnet *un, bool link)
+{
 	un->un_pri->unp_link = 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 atomic_load_relaxed(&un->un_pri->unp_dying);
+}
 /* Locking. */
 static void
 usbnet_isowned_rx(struct usbnet *un)
+{
 	KASSERT(mutex_owned(&un->un_pri->unp_rxlock));
+}
 static void
 usbnet_isowned_tx(struct usbnet *un)
+{
 	KASSERT(mutex_owned(&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)
+{
 	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_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);
 	mutex_init(&unp->unp_mcastlock, MUTEX_DEFAULT, IPL_SOFTCLOCK);
 	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);
 	/*
 	 * Prevent new activity.  After we stop the interface, it
 	 * cannot be brought back up.
 	 */
 	atomic_store_relaxed(&unp->unp_dying, true);
 	/*
 	 * If we're still running on the network, stop and wait for all
 	 * asynchronous activity to finish.
+	 *
 	 * If usbnet_attach_ifp never ran, IFNET_LOCK won't work, but
 	 * no activity is possible, so just skip this part.
 	 */
 	if (unp->unp_ifp_attached) {
 		IFNET_LOCK(ifp);
 		if (ifp->if_flags & IFF_RUNNING) {
 			usbnet_if_stop(ifp, 1);
+		}
 		IFNET_UNLOCK(ifp);
+	}
 	/*
 	 * The callout and tick task can't be scheduled anew at this
 	 * point, and usbnet_if_stop has waited for them to complete.
 	 */
 	KASSERT(!callout_pending(&unp->unp_stat_ch));
 	KASSERT(!usb_task_pending(un->un_udev, &unp->unp_ticktask));
 	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;
 	usbnet_rx_list_free(un);
 	usbnet_tx_list_free(un);
 	rnd_detach_source(&unp->unp_rndsrc);
 	mutex_destroy(&unp->unp_mcastlock);
 	mutex_destroy(&unp->unp_core_lock);
 	mutex_destroy(&unp->unp_rxlock);
 	mutex_destroy(&unp->unp_txlock);
 	callout_destroy(&unp->unp_stat_ch);
 	pmf_device_deregister(un->un_dev);
 	/*
 	 * Notify userland that we're going away, if we arrived in the
 	 * first place.
 	 */
 	if (unp->unp_ifp_attached) {
 		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);
 		atomic_store_relaxed(&unp->unp_dying, true);
 		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,1865 +1,1862 @@
-/*	$NetBSD: utoppy.c,v 1.35 2020/03/14 02:35:34 christos Exp $	*/
+/*	$NetBSD: utoppy.c,v 1.36 2022/03/03 06:05:38 riastradh Exp $	*/
 /*-
  * Copyright (c) 2006 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Steve C. Woodford.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: utoppy.c,v 1.35 2020/03/14 02:35:34 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: utoppy.c,v 1.36 2022/03/03 06:05:38 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/fcntl.h>
 #include <sys/device.h>
 #include <sys/ioctl.h>
 #include <sys/uio.h>
 #include <sys/conf.h>
 #include <sys/vnode.h>
 #include <sys/bus.h>
 #include <lib/libkern/crc16.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>
 #include <dev/usb/usb_quirks.h>
 #include <dev/usb/utoppy.h>
 #include "ioconf.h"
 #undef UTOPPY_DEBUG
 #ifdef UTOPPY_DEBUG
 #define	UTOPPY_DBG_OPEN		0x0001
 #define	UTOPPY_DBG_CLOSE	0x0002
 #define	UTOPPY_DBG_READ		0x0004
 #define	UTOPPY_DBG_WRITE	0x0008
 #define	UTOPPY_DBG_IOCTL	0x0010
 #define	UTOPPY_DBG_SEND_PACKET	0x0020
 #define	UTOPPY_DBG_RECV_PACKET	0x0040
 #define	UTOPPY_DBG_ADDPATH	0x0080
 #define	UTOPPY_DBG_READDIR	0x0100
 #define	UTOPPY_DBG_DUMP		0x0200
 #define	DPRINTF(l, m)				\
 		do {				\
 			if (utoppy_debug & l)	\
 				printf m;	\
 		} while (/*CONSTCOND*/0)
 static int utoppy_debug = 0;
 static void utoppy_dump_packet(const void *, size_t);
 #define	DDUMP_PACKET(p, l)					\
 		do {						\
 			if (utoppy_debug & UTOPPY_DBG_DUMP)	\
 				utoppy_dump_packet((p), (l));	\
 		} while (/*CONSTCOND*/0)
 #else
 #define	DPRINTF(l, m)		/* nothing */
 #define	DDUMP_PACKET(p, l)	/* nothing */
 #endif
 #define	UTOPPY_CONFIG_NO	1
 #define	UTOPPY_NUMENDPOINTS	2
 #define	UTOPPY_BSIZE		0xffff
 #define	UTOPPY_FRAG_SIZE	0x1000
 #define	UTOPPY_HEADER_SIZE	8
 #define	UTOPPY_SHORT_TIMEOUT	(500)		/* 0.5 seconds */
 #define	UTOPPY_LONG_TIMEOUT	(10 * 1000)	/* 10 seconds */
 /* Protocol Commands and Responses */
 #define	UTOPPY_RESP_ERROR		0x0001
 #define	UTOPPY_CMD_ACK			0x0002
 #define	 UTOPPY_RESP_SUCCESS		UTOPPY_CMD_ACK
 #define	UTOPPY_CMD_CANCEL		0x0003
 #define	UTOPPY_CMD_READY		0x0100
 #define	UTOPPY_CMD_RESET		0x0101
 #define	UTOPPY_CMD_TURBO		0x0102
 #define	UTOPPY_CMD_STATS		0x1000
 #define  UTOPPY_RESP_STATS_DATA		0x1001
 #define	UTOPPY_CMD_READDIR		0x1002
 #define	 UTOPPY_RESP_READDIR_DATA	0x1003
 #define	 UTOPPY_RESP_READDIR_END	0x1004
 #define	UTOPPY_CMD_DELETE		0x1005
 #define	UTOPPY_CMD_RENAME		0x1006
 #define	UTOPPY_CMD_MKDIR		0x1007
 #define	UTOPPY_CMD_FILE			0x1008
 #define  UTOPPY_FILE_WRITE		0
 #define  UTOPPY_FILE_READ		1
 #define	 UTOPPY_RESP_FILE_HEADER	0x1009
 #define	 UTOPPY_RESP_FILE_DATA		0x100a
 #define	 UTOPPY_RESP_FILE_END		0x100b
 enum utoppy_state {
 	UTOPPY_STATE_CLOSED,
 	UTOPPY_STATE_OPENING,
 	UTOPPY_STATE_IDLE,
 	UTOPPY_STATE_READDIR,
 	UTOPPY_STATE_READFILE,
 	UTOPPY_STATE_WRITEFILE
 };
 struct utoppy_softc {
 	device_t sc_dev;
 	struct usbd_device *sc_udev;	/* device */
 	struct usbd_interface *sc_iface;	/* interface */
 	int sc_dying;
 	int sc_refcnt;
 	enum utoppy_state sc_state;
 	u_int sc_turbo_mode;
 	int sc_out;
 	struct usbd_pipe *sc_out_pipe;	/* bulk out pipe */
 	struct usbd_xfer *sc_out_xfer;
 	void *sc_out_buf;
 	void *sc_out_data;
 	uint64_t sc_wr_offset;
 	uint64_t sc_wr_size;
 	int sc_in;
 	struct usbd_pipe *sc_in_pipe;	/* bulk in pipe */
 	struct usbd_xfer *sc_in_xfer;
 	void *sc_in_buf;
 	void *sc_in_data;
 	size_t sc_in_len;
 	u_int sc_in_offset;
 };
 struct utoppy_header {
 	uint16_t h_len;
 	uint16_t h_crc;
 	uint16_t h_cmd2;
 	uint16_t h_cmd;
 	uint8_t h_data[0];
 };
 #define	UTOPPY_OUT_INIT(sc)					\
 	do {							\
 		struct utoppy_header *_h = sc->sc_out_data;	\
 		_h->h_len = 0;					\
 	} while (/*CONSTCOND*/0)
 #define	UTOPPY_MJD_1970 40587u	/* MJD value for Jan 1 00:00:00 1970 */
 #define	UTOPPY_FTYPE_DIR	1
 #define	UTOPPY_FTYPE_FILE	2
 #define	UTOPPY_IN_DATA(sc)	\
  ((void*)&(((uint8_t*)(sc)->sc_in_data)[(sc)->sc_in_offset+UTOPPY_HEADER_SIZE]))
 static dev_type_open(utoppyopen);
 static dev_type_close(utoppyclose);
 static dev_type_read(utoppyread);
 static dev_type_write(utoppywrite);
 static dev_type_ioctl(utoppyioctl);
 const struct cdevsw utoppy_cdevsw = {
 	.d_open = utoppyopen,
 	.d_close = utoppyclose,
 	.d_read = utoppyread,
 	.d_write = utoppywrite,
 	.d_ioctl = utoppyioctl,
 	.d_stop = nostop,
 	.d_tty = notty,
 	.d_poll = nopoll,
 	.d_mmap = nommap,
 	.d_kqfilter = nokqfilter,
 	.d_discard = nodiscard,
 	.d_flag = D_OTHER
 };
 #define	UTOPPYUNIT(n)	(minor(n))
 static int	utoppy_match(device_t, cfdata_t, void *);
 static void	utoppy_attach(device_t, device_t, void *);
 static int	utoppy_detach(device_t, int);
 static int	utoppy_activate(device_t, enum devact);
 CFATTACH_DECL_NEW(utoppy, sizeof(struct utoppy_softc), utoppy_match,
     utoppy_attach, utoppy_detach, utoppy_activate);
 static int
 utoppy_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	if (uaa->uaa_vendor == USB_VENDOR_TOPFIELD &&
 	    uaa->uaa_product == USB_PRODUCT_TOPFIELD_TF5000PVR)
 		return UMATCH_VENDOR_PRODUCT;
 	return UMATCH_NONE;
+}
 static void
 utoppy_attach(device_t parent, device_t self, void *aux)
+{
 	struct utoppy_softc *sc = device_private(self);
 	struct usb_attach_arg *uaa = aux;
 	struct usbd_device *dev = uaa->uaa_device;
 	struct usbd_interface *iface;
 	usb_endpoint_descriptor_t *ed;
 	char *devinfop;
 	uint8_t epcount;
 	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);
 	sc->sc_dying = 0;
 	sc->sc_refcnt = 0;
 	sc->sc_udev = dev;
 	if (usbd_set_config_index(dev, 0, 1)
 	    || usbd_device2interface_handle(dev, 0, &iface)) {
 		aprint_error_dev(self, "Configuration failed\n");
 		return;
+	}
 	epcount = 0;
 	(void) usbd_endpoint_count(iface, &epcount);
 	if (epcount != UTOPPY_NUMENDPOINTS) {
 		aprint_error_dev(self, "Expected %d endpoints, got %d\n",
 		    UTOPPY_NUMENDPOINTS, epcount);
 		return;
+	}
 	sc->sc_in = -1;
 	sc->sc_out = -1;
 	for (i = 0; i < epcount; i++) {
 		ed = usbd_interface2endpoint_descriptor(iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self, "couldn't get ep %d\n", i);
 			return;
+		}
 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			sc->sc_in = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 			sc->sc_out = ed->bEndpointAddress;
+		}
+	}
 	if (sc->sc_out == -1 || sc->sc_in == -1) {
 		aprint_error_dev(self,
 		    "could not find bulk in/out endpoints\n");
 		sc->sc_dying = 1;
 		return;
+	}
 	sc->sc_iface = iface;
 	sc->sc_udev = dev;
 	sc->sc_out_pipe = NULL;
 	sc->sc_in_pipe = NULL;
 	if (usbd_open_pipe(sc->sc_iface, sc->sc_out, 0, &sc->sc_out_pipe)) {
 		DPRINTF(UTOPPY_DBG_OPEN, ("%s: usbd_open_pipe(OUT) failed\n",
 		    device_xname(sc->sc_dev)));
 		aprint_error_dev(self, "could not open OUT pipe\n");
 		sc->sc_dying = 1;
 		return;
+	}
 	if (usbd_open_pipe(sc->sc_iface, sc->sc_in, 0, &sc->sc_in_pipe)) {
 		DPRINTF(UTOPPY_DBG_OPEN, ("%s: usbd_open_pipe(IN) failed\n",
 		    device_xname(sc->sc_dev)));
 		aprint_error_dev(self, "could not open IN pipe\n");
 		usbd_close_pipe(sc->sc_out_pipe);
 		sc->sc_out_pipe = NULL;
 		sc->sc_dying = 1;
 		return;
+	}
 	int error;
 	error = usbd_create_xfer(sc->sc_out_pipe, UTOPPY_FRAG_SIZE, 0, 0,
 	    &sc->sc_out_xfer);
 	if (error) {
 		aprint_error_dev(self, "could not allocate bulk out xfer\n");
 		goto fail0;
+	}
 	error = usbd_create_xfer(sc->sc_in_pipe, UTOPPY_FRAG_SIZE,
 , 0, &sc->sc_in_xfer);
 	if (error) {
 		aprint_error_dev(self, "could not allocate bulk in xfer\n");
 		goto fail1;
+	}
 	sc->sc_out_buf = usbd_get_buffer(sc->sc_out_xfer);
 	sc->sc_in_buf = usbd_get_buffer(sc->sc_in_xfer);
 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
 	return;
  fail1:	usbd_destroy_xfer(sc->sc_out_xfer);
 	sc->sc_out_xfer = NULL;
  fail0:	sc->sc_dying = 1;
 	return;
+}
 static int
 utoppy_activate(device_t self, enum devact act)
+{
 	struct utoppy_softc *sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		sc->sc_dying = 1;
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 static int
 utoppy_detach(device_t self, int flags)
+{
 	struct utoppy_softc *sc = device_private(self);
 	int maj, mn;
 	int s;
 	sc->sc_dying = 1;
 	if (sc->sc_out_pipe != NULL)
 		usbd_abort_pipe(sc->sc_out_pipe);
 	if (sc->sc_in_pipe != NULL)
 		usbd_abort_pipe(sc->sc_in_pipe);
 	if (sc->sc_in_xfer != NULL)
 		usbd_destroy_xfer(sc->sc_in_xfer);
 	if (sc->sc_out_xfer != NULL)
 		usbd_destroy_xfer(sc->sc_out_xfer);
 	if (sc->sc_out_pipe != NULL)
 		usbd_close_pipe(sc->sc_out_pipe);
 	if (sc->sc_in_pipe != NULL)
 		usbd_close_pipe(sc->sc_in_pipe);
 	s = splusb();
 	if (--sc->sc_refcnt >= 0)
 		usb_detach_waitold(sc->sc_dev);
 	splx(s);
 	/* locate the major number */
 	maj = cdevsw_lookup_major(&utoppy_cdevsw);
 	/* Nuke the vnodes for any open instances (calls close). */
 	mn = device_unit(self);
 	vdevgone(maj, mn, mn, VCHR);
 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
 	return 0;
+}
 #define	UTOPPY_CRC16(ccrc,b)	crc16_byte((ccrc), (b)) /* from crc16.h */
 static const int utoppy_usbdstatus_lookup[] = {
 ,		/* USBD_NORMAL_COMPLETION */
 	EINPROGRESS,	/* USBD_IN_PROGRESS */
 	EALREADY,	/* USBD_PENDING_REQUESTS */
 	EAGAIN,		/* USBD_NOT_STARTED */
 	EINVAL,		/* USBD_INVAL */
 	ENOMEM,		/* USBD_NOMEM */
 	ECONNRESET,	/* USBD_CANCELLED */
 	EFAULT,		/* USBD_BAD_ADDRESS */
 	EBUSY,		/* USBD_IN_USE */
 	EADDRNOTAVAIL,	/* USBD_NO_ADDR */
 	ENETDOWN,	/* USBD_SET_ADDR_FAILED */
 	EIO,		/* USBD_NO_POWER */
 	EMLINK,		/* USBD_TOO_DEEP */
 	EIO,		/* USBD_IOERROR */
 	ENXIO,		/* USBD_NOT_CONFIGURED */
 	ETIMEDOUT,	/* USBD_TIMEOUT */
 	EBADMSG,	/* USBD_SHORT_XFER */
 	EHOSTDOWN,	/* USBD_STALLED */
 	EINTR		/* USBD_INTERRUPTED */
 };
 static __inline int
 utoppy_usbd_status2errno(usbd_status err)
+{
 	if (err >= USBD_ERROR_MAX)
 		return EFAULT;
 	return utoppy_usbdstatus_lookup[err];
+}
 #ifdef UTOPPY_DEBUG
 static const char *
 utoppy_state_string(enum utoppy_state state)
+{
 	const char *str;
 	switch (state) {
 	case UTOPPY_STATE_CLOSED:
 		str = "CLOSED";
 		break;
 	case UTOPPY_STATE_OPENING:
 		str = "OPENING";
 		break;
 	case UTOPPY_STATE_IDLE:
 		str = "IDLE";
 		break;
 	case UTOPPY_STATE_READDIR:
 		str = "READ DIRECTORY";
 		break;
 	case UTOPPY_STATE_READFILE:
 		str = "READ FILE";
 		break;
 	case UTOPPY_STATE_WRITEFILE:
 		str = "WRITE FILE";
 		break;
 	default:
 		str = "INVALID!";
 		break;
+	}
 	return str;
+}
 static void
 utoppy_dump_packet(const void *b, size_t len)
+{
 	const uint8_t *buf = b, *l;
 	uint8_t c;
 	size_t i, j;
 	if (len == 0)
 		return;
 	len = uimin(len, 256);
 	printf("00: ");
 	for (i = 0, l = buf; i < len; i++) {
 		printf("%02x ", *buf++);
 		if ((i % 16) == 15) {
 			for (j = 0; j < 16; j++) {
 				c = *l++;
 				if (c < ' ' || c > 0x7e)
 					c = '.';
 				printf("%c", c);
+			}
 			printf("\n");
 			l = buf;
 			if ((i + 1) < len)
 				printf("%02x: ", (u_int)i + 1);
+		}
+	}
 	while ((i++ % 16) != 0)
 		printf("   ");
 	if (l < buf) {
 		while (l < buf) {
 			c = *l++;
 			if (c < ' ' || c > 0x7e)
 				c = '.';
 			printf("%c", c);
+		}
 		printf("\n");
+	}
+}
 #endif
 static usbd_status
 utoppy_bulk_transfer(struct usbd_xfer *xfer, struct usbd_pipe *pipe,
     uint16_t flags, uint32_t timeout, void *buf, uint32_t *size)
+{
 	usbd_status err;
 	usbd_setup_xfer(xfer, 0, buf, *size, flags, timeout, NULL);
 	err = usbd_sync_transfer_sig(xfer);
 	usbd_get_xfer_status(xfer, NULL, NULL, size, NULL);
 	return err;
+}
 static int
 utoppy_send_packet(struct utoppy_softc *sc, uint16_t cmd, uint32_t timeout)
+{
 	struct utoppy_header *h;
 	usbd_status err;
 	uint32_t len;
 	uint16_t dlen, crc;
 	uint8_t *data, *e, t1, t2;
 	h = sc->sc_out_data;
 	DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: cmd 0x%04x, "
 	    "len %d\n", device_xname(sc->sc_dev), (u_int)cmd, h->h_len));
 	dlen = h->h_len;
 	len = dlen + UTOPPY_HEADER_SIZE;
 	if (len & 1)
 		len++;
 	if ((len % 64) == 0)
 		len += 2;
 	if (len >= UTOPPY_BSIZE) {
 		DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: "
 		    "packet too big (%d)\n", device_xname(sc->sc_dev),
 		    (int)len));
 		return EINVAL;
+	}
 	h->h_len = htole16(dlen + UTOPPY_HEADER_SIZE);
 	h->h_cmd2 = 0;
 	h->h_cmd = htole16(cmd);
 	/* The command word is part of the CRC */
 	crc = UTOPPY_CRC16(0,   0);
 	crc = UTOPPY_CRC16(crc, 0);
 	crc = UTOPPY_CRC16(crc, cmd >> 8);
 	crc = UTOPPY_CRC16(crc, cmd);
 	/*
 	 * If there is data following the header, calculate the CRC and
 	 * byte-swap as we go.
 	 */
 	if (dlen) {
 		data = h->h_data;
 		e = data + (dlen & ~1);
 		do {
 			t1 = data[0];
 			t2 = data[1];
 			crc = UTOPPY_CRC16(crc, t1);
 			crc = UTOPPY_CRC16(crc, t2);
 			*data++ = t2;
 			*data++ = t1;
 		} while (data < e);
 		if (dlen & 1) {
 			t1 = data[0];
 			crc = UTOPPY_CRC16(crc, t1);
 			data[1] = t1;
+		}
+	}
 	h->h_crc = htole16(crc);
 	data = sc->sc_out_data;
 	DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: total len "
 	    "%d...\n", device_xname(sc->sc_dev), (int)len));
 	DDUMP_PACKET(data, len);
 	do {
 		uint32_t thislen;
 		thislen = uimin(len, UTOPPY_FRAG_SIZE);
 		memcpy(sc->sc_out_buf, data, thislen);
 		err = utoppy_bulk_transfer(sc->sc_out_xfer, sc->sc_out_pipe,
 , timeout, sc->sc_out_buf, &thislen);
 		if (thislen != uimin(len, UTOPPY_FRAG_SIZE)) {
 			DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: "
 			    "utoppy_send_packet: sent %ld, err %d\n",
 			    device_xname(sc->sc_dev), (u_long)thislen, err));
+		}
 		if (err == 0) {
 			len -= thislen;
 			data += thislen;
+		}
 	} while (err == 0 && len);
 	DPRINTF(UTOPPY_DBG_SEND_PACKET, ("%s: utoppy_send_packet: "
 	    "usbd_bulk_transfer() returned %d.\n",
 	    device_xname(sc->sc_dev),err));
 	return err ? utoppy_usbd_status2errno(err) : 0;
+}
 static int
 utoppy_recv_packet(struct utoppy_softc *sc, uint16_t *respp, uint32_t timeout)
+{
 	struct utoppy_header *h;
 	usbd_status err;
 	uint32_t len, thislen, requested, bytesleft;
 	uint16_t crc;
 	uint8_t *data, *e, t1, t2;
 	data = sc->sc_in_data;
 	len = 0;
 	bytesleft = UTOPPY_BSIZE;
 	DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: ...\n",
 	    device_xname(sc->sc_dev)));
 	do {
 		requested = thislen = uimin(bytesleft, UTOPPY_FRAG_SIZE);
 		err = utoppy_bulk_transfer(sc->sc_in_xfer, sc->sc_in_pipe,
 		    USBD_SHORT_XFER_OK, timeout, sc->sc_in_buf,
 		    &thislen);
 		DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: "
 		    "usbd_bulk_transfer() returned %d, thislen %d, data %p\n",
 		    device_xname(sc->sc_dev), err, (u_int)thislen, data));
 		if (err == 0) {
 			memcpy(data, sc->sc_in_buf, thislen);
 			DDUMP_PACKET(data, thislen);
 			len += thislen;
 			bytesleft -= thislen;
 			data += thislen;
+		}
 	} while (err == 0 && bytesleft && thislen == requested);
 	if (err)
 		return utoppy_usbd_status2errno(err);
 	h = sc->sc_in_data;
 	DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: received %d "
 	    "bytes in total to %p\n", device_xname(sc->sc_dev), (u_int)len, h));
 	DDUMP_PACKET(h, len);
 	if (len < UTOPPY_HEADER_SIZE || len < (uint32_t)le16toh(h->h_len)) {
 		DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: bad "
 		    " length (len %d, h_len %d)\n", device_xname(sc->sc_dev),
 		    (int)len, le16toh(h->h_len)));
 		return EIO;
+	}
 	len = h->h_len = le16toh(h->h_len);
 	h->h_crc = le16toh(h->h_crc);
 	*respp = h->h_cmd = le16toh(h->h_cmd);
 	h->h_cmd2 = le16toh(h->h_cmd2);
 	/*
 	 * To maximise data throughput when transferring files, acknowledge
 	 * data blocks as soon as we receive them. If we detect an error
 	 * later on, we can always cancel.
 	 */
 	if (*respp == UTOPPY_RESP_FILE_DATA) {
 		DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: "
 		    "ACKing file data\n", device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_send_packet(sc, UTOPPY_CMD_ACK,
 		    UTOPPY_SHORT_TIMEOUT);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: "
 			    "utoppy_recv_packet: failed to ACK file data: %d\n",
 			    device_xname(sc->sc_dev), err));
 			return err;
+		}
+	}
 	/* The command word is part of the CRC */
 	crc = UTOPPY_CRC16(0,   h->h_cmd2 >> 8);
 	crc = UTOPPY_CRC16(crc, h->h_cmd2);
 	crc = UTOPPY_CRC16(crc, h->h_cmd >> 8);
 	crc = UTOPPY_CRC16(crc, h->h_cmd);
 	/*
 	 * Extract any payload, byte-swapping and calculating the CRC16
 	 * as we go.
 	 */
 	if (len > UTOPPY_HEADER_SIZE) {
 		data = h->h_data;
 		e = data + ((len & ~1) - UTOPPY_HEADER_SIZE);
 		while (data < e) {
 			t1 = data[0];
 			t2 = data[1];
 			crc = UTOPPY_CRC16(crc, t2);
 			crc = UTOPPY_CRC16(crc, t1);
 			*data++ = t2;
 			*data++ = t1;
+		}
 		if (len & 1) {
 			t1 = data[1];
 			crc = UTOPPY_CRC16(crc, t1);
 			*data = t1;
+		}
+	}
 	sc->sc_in_len = (size_t) len - UTOPPY_HEADER_SIZE;
 	sc->sc_in_offset = 0;
 	DPRINTF(UTOPPY_DBG_RECV_PACKET, ("%s: utoppy_recv_packet: len %d, "
 	    "crc 0x%04x, hdrcrc 0x%04x\n", device_xname(sc->sc_dev),
 	    (int)len, crc, h->h_crc));
 	DDUMP_PACKET(h, len);
 	return (crc == h->h_crc) ? 0 : EBADMSG;
+}
 static __inline void *
 utoppy_current_ptr(void *b)
+{
 	struct utoppy_header *h = b;
 	return &h->h_data[h->h_len];
+}
 static __inline void
 utoppy_advance_ptr(void *b, size_t len)
+{
 	struct utoppy_header *h = b;
 	h->h_len += len;
+}
 static __inline void
 utoppy_add_8(struct utoppy_softc *sc, uint8_t v)
+{
 	struct utoppy_header *h = sc->sc_out_data;
 	uint8_t *p;
 	p = utoppy_current_ptr(h);
 	*p = v;
 	utoppy_advance_ptr(h, sizeof(v));
+}
 static __inline void
 utoppy_add_16(struct utoppy_softc *sc, uint16_t v)
+{
 	struct utoppy_header *h = sc->sc_out_data;
 	uint8_t *p;
 	p = utoppy_current_ptr(h);
 	*p++ = (uint8_t)(v >> 8);
 	*p = (uint8_t)v;
 	utoppy_advance_ptr(h, sizeof(v));
+}
 static __inline void
 utoppy_add_32(struct utoppy_softc *sc, uint32_t v)
+{
 	struct utoppy_header *h = sc->sc_out_data;
 	uint8_t *p;
 	p = utoppy_current_ptr(h);
 	*p++ = (uint8_t)(v >> 24);
 	*p++ = (uint8_t)(v >> 16);
 	*p++ = (uint8_t)(v >> 8);
 	*p = (uint8_t)v;
 	utoppy_advance_ptr(h, sizeof(v));
+}
 static __inline void
 utoppy_add_64(struct utoppy_softc *sc, uint64_t v)
+{
 	struct utoppy_header *h = sc->sc_out_data;
 	uint8_t *p;
 	p = utoppy_current_ptr(h);
 	*p++ = (uint8_t)(v >> 56);
 	*p++ = (uint8_t)(v >> 48);
 	*p++ = (uint8_t)(v >> 40);
 	*p++ = (uint8_t)(v >> 32);
 	*p++ = (uint8_t)(v >> 24);
 	*p++ = (uint8_t)(v >> 16);
 	*p++ = (uint8_t)(v >> 8);
 	*p = (uint8_t)v;
 	utoppy_advance_ptr(h, sizeof(v));
+}
 static __inline void
 utoppy_add_string(struct utoppy_softc *sc, const char *str, size_t len)
+{
 	struct utoppy_header *h = sc->sc_out_data;
 	char *p;
 	p = utoppy_current_ptr(h);
 	memset(p, 0, len);
 	strncpy(p, str, len);
 	utoppy_advance_ptr(h, len);
+}
 static int
 utoppy_add_path(struct utoppy_softc *sc, const char *path, int putlen)
+{
 	struct utoppy_header *h = sc->sc_out_data;
 	uint8_t *p, *str, *s;
 	size_t len;
 	int err;
 	p = utoppy_current_ptr(h);
 	str = putlen ? (p + sizeof(uint16_t)) : p;
 	err = copyinstr(path, str, UTOPPY_MAX_FILENAME_LEN, &len);
 	DPRINTF(UTOPPY_DBG_ADDPATH, ("utoppy_add_path: err %d, len %d\n",
 	    err, (int)len));
 	if (err)
 		return err;
 	if (len < 2)
 		return EINVAL;
 	/*
 	 * copyinstr(9) has already copied the terminating NUL character,
 	 * but we append another one in case we have to pad the length
 	 * later on.
 	 */
 	str[len] = '\0';
 	/*
 	 * The Toppy uses backslash as the directory separator, so convert
 	 * all forward slashes.
 	 */
 	for (s = &str[len - 2]; s >= str; s--)
 		if (*s == '/')
 			*s = '\\';
 	if ((len + h->h_len) & 1)
 		len++;
 	if (putlen)
 		utoppy_add_16(sc, len);
 	utoppy_advance_ptr(h, len);
 	DPRINTF(UTOPPY_DBG_ADDPATH, ("utoppy_add_path: final len %d\n",
 	    (u_int)len));
 	return 0;
+}
 static __inline int
 utoppy_get_8(struct utoppy_softc *sc, uint8_t *vp)
+{
 	uint8_t *p;
 	if (sc->sc_in_len < sizeof(*vp))
 		return 1;
 	p = UTOPPY_IN_DATA(sc);
 	*vp = *p;
 	sc->sc_in_offset += sizeof(*vp);
 	sc->sc_in_len -= sizeof(*vp);
 	return 0;
+}
 static __inline int
 utoppy_get_16(struct utoppy_softc *sc, uint16_t *vp)
+{
 	uint16_t v;
 	uint8_t *p;
 	if (sc->sc_in_len < sizeof(v))
 		return 1;
 	p = UTOPPY_IN_DATA(sc);
 	v = *p++;
 	v = (v << 8) | *p;
 	*vp = v;
 	sc->sc_in_offset += sizeof(v);
 	sc->sc_in_len -= sizeof(v);
 	return 0;
+}
 static __inline int
 utoppy_get_32(struct utoppy_softc *sc, uint32_t *vp)
+{
 	uint32_t v;
 	uint8_t *p;
 	if (sc->sc_in_len < sizeof(v))
 		return 1;
 	p = UTOPPY_IN_DATA(sc);
 	v = *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p;
 	*vp = v;
 	sc->sc_in_offset += sizeof(v);
 	sc->sc_in_len -= sizeof(v);
 	return 0;
+}
 static __inline int
 utoppy_get_64(struct utoppy_softc *sc, uint64_t *vp)
+{
 	uint64_t v;
 	uint8_t *p;
 	if (sc->sc_in_len < sizeof(v))
 		return 1;
 	p = UTOPPY_IN_DATA(sc);
 	v = *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p++;
 	v = (v << 8) | *p;
 	*vp = v;
 	sc->sc_in_offset += sizeof(v);
 	sc->sc_in_len -= sizeof(v);
 	return 0;
+}
 static __inline int
 utoppy_get_string(struct utoppy_softc *sc, char *str, size_t len)
+{
 	char *p;
 	if (sc->sc_in_len < len)
 		return 1;
 	memset(str, 0, len);
 	p = UTOPPY_IN_DATA(sc);
 	strncpy(str, p, len);
 	sc->sc_in_offset += len;
 	sc->sc_in_len -= len;
 	return 0;
+}
 static int
 utoppy_command(struct utoppy_softc *sc, uint16_t cmd, int timeout,
     uint16_t *presp)
+{
 	int err;
 	err = utoppy_send_packet(sc, cmd, timeout);
 	if (err)
 		return err;
 	err = utoppy_recv_packet(sc, presp, timeout);
 	if (err == EBADMSG) {
 		UTOPPY_OUT_INIT(sc);
 		utoppy_send_packet(sc, UTOPPY_RESP_ERROR, timeout);
+	}
 	return err;
+}
 static int
 utoppy_timestamp_decode(struct utoppy_softc *sc, time_t *tp)
+{
 	uint16_t mjd;
 	uint8_t hour, minute, sec;
 	uint32_t rv;
 	if (utoppy_get_16(sc, &mjd) || utoppy_get_8(sc, &hour) ||
 	    utoppy_get_8(sc, &minute) || utoppy_get_8(sc, &sec))
 		return 1;
 	if (mjd == 0xffffu && hour == 0xffu && minute == 0xffu && sec == 0xffu){
 		*tp = 0;
 		return 0;
+	}
 	rv = (mjd < UTOPPY_MJD_1970) ? UTOPPY_MJD_1970 : (uint32_t) mjd;
 	/* Calculate seconds since 1970 */
 	rv = (rv - UTOPPY_MJD_1970) * 60 * 60 * 24;
 	/* Add in the hours, minutes, and seconds */
 	rv += (uint32_t)hour * 60 * 60;
 	rv += (uint32_t)minute * 60;
 	rv += sec;
 	*tp = (time_t)rv;
 	return 0;
+}
 static void
 utoppy_timestamp_encode(struct utoppy_softc *sc, time_t t)
+{
 	u_int mjd, hour, minute;
 	mjd = t / (60 * 60 * 24);
 	t -= mjd * 60 * 60 * 24;
 	hour = t / (60 * 60);
 	t -= hour * 60 * 60;
 	minute = t / 60;
 	t -= minute * 60;
 	utoppy_add_16(sc, mjd + UTOPPY_MJD_1970);
 	utoppy_add_8(sc, hour);
 	utoppy_add_8(sc, minute);
 	utoppy_add_8(sc, t);
+}
 static int
 utoppy_turbo_mode(struct utoppy_softc *sc, int state)
+{
 	uint16_t r;
 	int err;
 	UTOPPY_OUT_INIT(sc);
 	utoppy_add_32(sc, state);
 	err = utoppy_command(sc, UTOPPY_CMD_TURBO, UTOPPY_SHORT_TIMEOUT, &r);
 	if (err)
 		return err;
 	return (r == UTOPPY_RESP_SUCCESS) ? 0 : EIO;
+}
 static int
 utoppy_check_ready(struct utoppy_softc *sc)
+{
 	uint16_t r;
 	int err;
 	UTOPPY_OUT_INIT(sc);
 	err = utoppy_command(sc, UTOPPY_CMD_READY, UTOPPY_LONG_TIMEOUT, &r);
 	if (err)
 		return err;
 	return (r == UTOPPY_RESP_SUCCESS) ? 0 : EIO;
+}
 static int
 utoppy_cancel(struct utoppy_softc *sc)
+{
 	uint16_t r;
 	int err, i;
 	/*
 	 * Issue the cancel command serveral times. the Toppy doesn't
 	 * always respond to the first.
 	 */
 	for (i = 0; i < 3; i++) {
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_command(sc, UTOPPY_CMD_CANCEL,
 		    UTOPPY_SHORT_TIMEOUT, &r);
 		if (err == 0 && r == UTOPPY_RESP_SUCCESS)
 			break;
 		err = ETIMEDOUT;
+	}
 	if (err)
 		return err;
 	/*
 	 * Make sure turbo mode is off, otherwise the Toppy will not
 	 * respond to remote control input.
 	 */
 	(void) utoppy_turbo_mode(sc, 0);
 	sc->sc_state = UTOPPY_STATE_IDLE;
 	return 0;
+}
 static int
 utoppy_stats(struct utoppy_softc *sc, struct utoppy_stats *us)
+{
 	uint32_t hsize, hfree;
 	uint16_t r;
 	int err;
 	UTOPPY_OUT_INIT(sc);
 	err = utoppy_command(sc, UTOPPY_CMD_STATS, UTOPPY_LONG_TIMEOUT, &r);
 	if (err)
 		return err;
 	if (r != UTOPPY_RESP_STATS_DATA)
 		return EIO;
 	if (utoppy_get_32(sc, &hsize) || utoppy_get_32(sc, &hfree))
 		return EIO;
 	us->us_hdd_size = hsize;
 	us->us_hdd_size *= 1024;
 	us->us_hdd_free = hfree;
 	us->us_hdd_free *= 1024;
 	return 0;
+}
 static int
 utoppy_readdir_next(struct utoppy_softc *sc)
+{
 	uint16_t resp;
 	int err;
 	DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: running...\n",
 	    device_xname(sc->sc_dev)));
 	/*
 	 * Fetch the next READDIR response
 	 */
 	err = utoppy_recv_packet(sc, &resp, UTOPPY_LONG_TIMEOUT);
 	if (err) {
 		DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: "
 		    "utoppy_recv_packet() returned %d\n",
 		    device_xname(sc->sc_dev), err));
 		if (err == EBADMSG) {
 			UTOPPY_OUT_INIT(sc);
 			utoppy_send_packet(sc, UTOPPY_RESP_ERROR,
 			    UTOPPY_LONG_TIMEOUT);
+		}
 		utoppy_cancel(sc);
 		return err;
+	}
 	DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: "
 	    "utoppy_recv_packet() returned %d, len %ld\n",
 	    device_xname(sc->sc_dev), err, (u_long)sc->sc_in_len));
 	switch (resp) {
 	case UTOPPY_RESP_READDIR_DATA:
 		DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: "
 		    "UTOPPY_RESP_READDIR_DATA\n", device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_send_packet(sc, UTOPPY_CMD_ACK,
 		    UTOPPY_LONG_TIMEOUT);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: "
 			    "utoppy_send_packet(ACK) returned %d\n",
 			    device_xname(sc->sc_dev), err));
 			utoppy_cancel(sc);
 			return err;
+		}
 		sc->sc_state = UTOPPY_STATE_READDIR;
 		sc->sc_in_offset = 0;
 		break;
 	case UTOPPY_RESP_READDIR_END:
 		DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: "
 		    "UTOPPY_RESP_READDIR_END\n", device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		utoppy_send_packet(sc, UTOPPY_CMD_ACK, UTOPPY_SHORT_TIMEOUT);
 		sc->sc_state = UTOPPY_STATE_IDLE;
 		sc->sc_in_len = 0;
 		break;
 	default:
 		DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_next: "
 		    "bad response: %#x\n", device_xname(sc->sc_dev), resp));
 		sc->sc_state = UTOPPY_STATE_IDLE;
 		sc->sc_in_len = 0;
 		return EIO;
+	}
 	return 0;
+}
 static size_t
 utoppy_readdir_decode(struct utoppy_softc *sc, struct utoppy_dirent *ud)
+{
 	uint8_t ftype;
 	DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_decode: bytes left"
 	    " %d\n", device_xname(sc->sc_dev), (int)sc->sc_in_len));
 	if (utoppy_timestamp_decode(sc, &ud->ud_mtime) ||
 	    utoppy_get_8(sc, &ftype) || utoppy_get_64(sc, &ud->ud_size) ||
 	    utoppy_get_string(sc, ud->ud_path, UTOPPY_MAX_FILENAME_LEN + 1) ||
 	    utoppy_get_32(sc, &ud->ud_attributes)) {
 		DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_decode: no "
 		    "more to decode\n", device_xname(sc->sc_dev)));
 		return 0;
+	}
 	switch (ftype) {
 	case UTOPPY_FTYPE_DIR:
 		ud->ud_type = UTOPPY_DIRENT_DIRECTORY;
 		break;
 	case UTOPPY_FTYPE_FILE:
 		ud->ud_type = UTOPPY_DIRENT_FILE;
 		break;
 	default:
 		ud->ud_type = UTOPPY_DIRENT_UNKNOWN;
 		break;
+	}
 	DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppy_readdir_decode: %s '%s', "
 	    "size %lld, time 0x%08lx, attr 0x%08x\n", device_xname(sc->sc_dev),
 	    (ftype == UTOPPY_FTYPE_DIR) ? "DIR" :
 	    ((ftype == UTOPPY_FTYPE_FILE) ? "FILE" : "UNKNOWN"), ud->ud_path,
 	    ud->ud_size, (u_long)ud->ud_mtime, ud->ud_attributes));
 	return 1;
+}
 static int
 utoppy_readfile_next(struct utoppy_softc *sc)
+{
 	uint64_t off;
 	uint16_t resp;
 	int err;
 	err = utoppy_recv_packet(sc, &resp, UTOPPY_LONG_TIMEOUT);
 	if (err) {
 		DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: "
 		    "utoppy_recv_packet() returned %d\n",
 		    device_xname(sc->sc_dev), err));
 		utoppy_cancel(sc);
 		return err;
+	}
 	switch (resp) {
 	case UTOPPY_RESP_FILE_HEADER:
 		/* ACK it */
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_send_packet(sc, UTOPPY_CMD_ACK,
 		    UTOPPY_LONG_TIMEOUT);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: "
 			    "utoppy_send_packet(UTOPPY_CMD_ACK) returned %d\n",
 			    device_xname(sc->sc_dev), err));
 			utoppy_cancel(sc);
 			return err;
+		}
 		sc->sc_in_len = 0;
 		DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: "
 		    "FILE_HEADER done\n", device_xname(sc->sc_dev)));
 		break;
 	case UTOPPY_RESP_FILE_DATA:
 		/* Already ACK'd */
 		if (utoppy_get_64(sc, &off)) {
 			DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: "
 			    "UTOPPY_RESP_FILE_DATA did not provide offset\n",
 			    device_xname(sc->sc_dev)));
 			utoppy_cancel(sc);
 			return EBADMSG;
+		}
 		DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: "
 		    "UTOPPY_RESP_FILE_DATA: offset %lld, bytes left %ld\n",
 		    device_xname(sc->sc_dev), off, (u_long)sc->sc_in_len));
 		break;
 	case UTOPPY_RESP_FILE_END:
 		DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: "
 		    "UTOPPY_RESP_FILE_END: sending ACK\n",
 		    device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		utoppy_send_packet(sc, UTOPPY_CMD_ACK, UTOPPY_SHORT_TIMEOUT);
 		/*FALLTHROUGH*/
 	case UTOPPY_RESP_SUCCESS:
 		sc->sc_state = UTOPPY_STATE_IDLE;
 		(void) utoppy_turbo_mode(sc, 0);
 		DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: all "
 		    "done\n", device_xname(sc->sc_dev)));
 		break;
 	case UTOPPY_RESP_ERROR:
 	default:
 		DPRINTF(UTOPPY_DBG_READ, ("%s: utoppy_readfile_next: bad "
 		    "response code 0x%0x\n", device_xname(sc->sc_dev), resp));
 		utoppy_cancel(sc);
 		return EIO;
+	}
 	return 0;
+}
 static int
 utoppyopen(dev_t dev, int flag, int mode,
     struct lwp *l)
+{
 	struct utoppy_softc *sc;
 	int error = 0;
 	sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev));
 	if (sc == NULL)
 		return ENXIO;
 	if (sc == NULL || sc->sc_iface == NULL || sc->sc_dying)
 		return ENXIO;
 	if (sc->sc_state != UTOPPY_STATE_CLOSED) {
 		DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: already open\n",
 		    device_xname(sc->sc_dev)));
 		return EBUSY;
+	}
 	DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: opening...\n",
 	    device_xname(sc->sc_dev)));
 	sc->sc_refcnt++;
 	sc->sc_state = UTOPPY_STATE_OPENING;
 	sc->sc_turbo_mode = 0;
 	sc->sc_out_data = kmem_alloc(UTOPPY_BSIZE + 1, KM_SLEEP);
 	sc->sc_in_data = kmem_alloc(UTOPPY_BSIZE + 1, KM_SLEEP);
 	if ((error = utoppy_cancel(sc)) != 0)
 		goto error;
 	if ((error = utoppy_check_ready(sc)) != 0) {
 		DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: utoppy_check_ready()"
 		    " returned %d\n", device_xname(sc->sc_dev), error));
+	}
  error:
 	sc->sc_state = error ? UTOPPY_STATE_CLOSED : UTOPPY_STATE_IDLE;
 	DPRINTF(UTOPPY_DBG_OPEN, ("%s: utoppyopen: done. error %d, new state "
 	    "'%s'\n", device_xname(sc->sc_dev), error,
 	    utoppy_state_string(sc->sc_state)));
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	return error;
+}
 static int
 utoppyclose(dev_t dev, int flag, int mode, struct lwp *l)
+{
 	struct utoppy_softc *sc;
 	usbd_status err;
 	sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev));
 	DPRINTF(UTOPPY_DBG_CLOSE, ("%s: utoppyclose: closing...\n",
 	    device_xname(sc->sc_dev)));
 	if (sc->sc_state < UTOPPY_STATE_IDLE) {
 		/* We are being forced to close before the open completed. */
 		DPRINTF(UTOPPY_DBG_CLOSE, ("%s: utoppyclose: not properly "
 		    "open: %s\n", device_xname(sc->sc_dev),
 		    utoppy_state_string(sc->sc_state)));
 		return 0;
+	}
 	if (sc->sc_out_data)
 		(void) utoppy_cancel(sc);
 	if (sc->sc_out_pipe != NULL) {
-		if ((err = usbd_abort_pipe(sc->sc_out_pipe)) != 0)
+		usbd_abort_pipe(sc->sc_out_pipe);
 			printf("usbd_abort_pipe(OUT) returned %d\n", err);
 		sc->sc_out_pipe = NULL;
+	}
 	if (sc->sc_in_pipe != NULL) {
-		if ((err = usbd_abort_pipe(sc->sc_in_pipe)) != 0)
+		usbd_abort_pipe(sc->sc_in_pipe);
 			printf("usbd_abort_pipe(IN) returned %d\n", err);
 		sc->sc_in_pipe = NULL;
+	}
 	if (sc->sc_out_data) {
 		kmem_free(sc->sc_out_data, UTOPPY_BSIZE + 1);
 		sc->sc_out_data = NULL;
+	}
 	if (sc->sc_in_data) {
 		kmem_free(sc->sc_in_data, UTOPPY_BSIZE + 1);
 		sc->sc_in_data = NULL;
+	}
 	sc->sc_state = UTOPPY_STATE_CLOSED;
 	DPRINTF(UTOPPY_DBG_CLOSE, ("%s: utoppyclose: done.\n",
 	    device_xname(sc->sc_dev)));
 	return 0;
+}
 static int
 utoppyread(dev_t dev, struct uio *uio, int flags)
+{
 	struct utoppy_softc *sc;
 	struct utoppy_dirent ud;
 	size_t len;
 	int err;
 	sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev));
 	if (sc->sc_dying)
 		return EIO;
 	sc->sc_refcnt++;
 	DPRINTF(UTOPPY_DBG_READ, ("%s: utoppyread: reading: state '%s'\n",
 	    device_xname(sc->sc_dev), utoppy_state_string(sc->sc_state)));
 	switch (sc->sc_state) {
 	case UTOPPY_STATE_READDIR:
 		err = 0;
 		while (err == 0 && uio->uio_resid >= sizeof(ud) &&
 		    sc->sc_state != UTOPPY_STATE_IDLE) {
 			if (utoppy_readdir_decode(sc, &ud) == 0)
 				err = utoppy_readdir_next(sc);
 			else
 			if ((err = uiomove(&ud, sizeof(ud), uio)) != 0)
 				utoppy_cancel(sc);
+		}
 		break;
 	case UTOPPY_STATE_READFILE:
 		err = 0;
 		while (err == 0 && uio->uio_resid > 0 &&
 		    sc->sc_state != UTOPPY_STATE_IDLE) {
 			DPRINTF(UTOPPY_DBG_READ, ("%s: utoppyread: READFILE: "
 			    "resid %ld, bytes_left %ld\n",
 			    device_xname(sc->sc_dev), (u_long)uio->uio_resid,
 			    (u_long)sc->sc_in_len));
 			if (sc->sc_in_len == 0 &&
 			    (err = utoppy_readfile_next(sc)) != 0) {
 				DPRINTF(UTOPPY_DBG_READ, ("%s: utoppyread: "
 				    "READFILE: utoppy_readfile_next returned "
 				    "%d\n", device_xname(sc->sc_dev), err));
 				break;
+			}
 			len = uimin(uio->uio_resid, sc->sc_in_len);
 			if (len) {
 				err = uiomove(UTOPPY_IN_DATA(sc), len, uio);
 				if (err == 0) {
 					sc->sc_in_offset += len;
 					sc->sc_in_len -= len;
+				}
+			}
+		}
 		break;
 	case UTOPPY_STATE_IDLE:
 		err = 0;
 		break;
 	case UTOPPY_STATE_WRITEFILE:
 		err = EBUSY;
 		break;
 	default:
 		err = EIO;
 		break;
+	}
 	DPRINTF(UTOPPY_DBG_READ, ("%s: utoppyread: done. err %d, state '%s'\n",
 	    device_xname(sc->sc_dev), err, utoppy_state_string(sc->sc_state)));
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	return err;
+}
 static int
 utoppywrite(dev_t dev, struct uio *uio, int flags)
+{
 	struct utoppy_softc *sc;
 	uint16_t resp;
 	size_t len;
 	int err;
 	sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev));
 	if (sc->sc_dying)
 		return EIO;
 	switch(sc->sc_state) {
 	case UTOPPY_STATE_WRITEFILE:
 		break;
 	case UTOPPY_STATE_IDLE:
 		return 0;
 	default:
 		return EIO;
+	}
 	sc->sc_refcnt++;
 	err = 0;
 	DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: PRE-WRITEFILE: resid "
 	    "%ld, wr_size %lld, wr_offset %lld\n", device_xname(sc->sc_dev),
 	    (u_long)uio->uio_resid, sc->sc_wr_size, sc->sc_wr_offset));
 	while (sc->sc_state == UTOPPY_STATE_WRITEFILE &&
 	    (len = uimin(uio->uio_resid, sc->sc_wr_size)) != 0) {
 		len = uimin(len, UTOPPY_BSIZE - (UTOPPY_HEADER_SIZE +
 		    sizeof(uint64_t) + 3));
 		DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: uiomove(%ld)\n",
 		    device_xname(sc->sc_dev), (u_long)len));
 		UTOPPY_OUT_INIT(sc);
 		utoppy_add_64(sc, sc->sc_wr_offset);
 		err = uiomove(utoppy_current_ptr(sc->sc_out_data), len, uio);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: uiomove()"
 			    " returned %d\n", device_xname(sc->sc_dev), err));
 			break;
+		}
 		utoppy_advance_ptr(sc->sc_out_data, len);
 		err = utoppy_command(sc, UTOPPY_RESP_FILE_DATA,
 		    UTOPPY_LONG_TIMEOUT, &resp);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: "
 			    "utoppy_command(UTOPPY_RESP_FILE_DATA) "
 			    "returned %d\n", device_xname(sc->sc_dev), err));
 			break;
+		}
 		if (resp != UTOPPY_RESP_SUCCESS) {
 			DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: "
 			    "utoppy_command(UTOPPY_RESP_FILE_DATA) returned "
 			    "bad response %#x\n", device_xname(sc->sc_dev),
 			    resp));
 			utoppy_cancel(sc);
 			err = EIO;
 			break;
+		}
 		sc->sc_wr_offset += len;
 		sc->sc_wr_size -= len;
+	}
 	DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: POST-WRITEFILE: resid "
 	    "%ld, wr_size %lld, wr_offset %lld, err %d\n",
 	    device_xname(sc->sc_dev), (u_long)uio->uio_resid, sc->sc_wr_size,
 	    sc->sc_wr_offset, err));
 	if (err == 0 && sc->sc_wr_size == 0) {
 		DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: sending "
 		    "FILE_END...\n", device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_command(sc, UTOPPY_RESP_FILE_END,
 		    UTOPPY_LONG_TIMEOUT, &resp);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: "
 			    "utoppy_command(UTOPPY_RESP_FILE_END) returned "
 			    "%d\n", device_xname(sc->sc_dev), err));
 			utoppy_cancel(sc);
+		}
 		sc->sc_state = UTOPPY_STATE_IDLE;
 		DPRINTF(UTOPPY_DBG_WRITE, ("%s: utoppywrite: state %s\n",
 		    device_xname(sc->sc_dev),
 		    utoppy_state_string(sc->sc_state)));
+	}
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	return err;
+}
 static int
 utoppyioctl(dev_t dev, u_long cmd, void *data, int flag,
     struct lwp *l)
+{
 	struct utoppy_softc *sc;
 	struct utoppy_rename *ur;
 	struct utoppy_readfile *urf;
 	struct utoppy_writefile *uw;
 	char uwf[UTOPPY_MAX_FILENAME_LEN + 1], *uwfp;
 	uint16_t resp;
 	int err;
 	sc = device_lookup_private(&utoppy_cd, UTOPPYUNIT(dev));
 	if (sc->sc_dying)
 		return EIO;
 	DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: cmd 0x%08lx, state '%s'\n",
 	    device_xname(sc->sc_dev), cmd, utoppy_state_string(sc->sc_state)));
 	if (sc->sc_state != UTOPPY_STATE_IDLE && cmd != UTOPPYIOCANCEL) {
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: still busy.\n",
 		    device_xname(sc->sc_dev)));
 		return EBUSY;
+	}
 	sc->sc_refcnt++;
 	switch (cmd) {
 	case UTOPPYIOTURBO:
 		err = 0;
 		sc->sc_turbo_mode = *((int *)data) ? 1 : 0;
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIOTURBO: "
 		    "%s\n", device_xname(sc->sc_dev),
 		    sc->sc_turbo_mode ? "On" : "Off"));
 		break;
 	case UTOPPYIOCANCEL:
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIOCANCEL\n",
 		    device_xname(sc->sc_dev)));
 		err = utoppy_cancel(sc);
 		break;
 	case UTOPPYIOREBOOT:
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIOREBOOT\n",
 		    device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_command(sc, UTOPPY_CMD_RESET, UTOPPY_LONG_TIMEOUT,
 		    &resp);
 		if (err)
 			break;
 		if (resp != UTOPPY_RESP_SUCCESS)
 			err = EIO;
 		break;
 	case UTOPPYIOSTATS:
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIOSTATS\n",
 		    device_xname(sc->sc_dev)));
 		err = utoppy_stats(sc, (struct utoppy_stats *)data);
 		break;
 	case UTOPPYIORENAME:
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIORENAME\n",
 		    device_xname(sc->sc_dev)));
 		ur = (struct utoppy_rename *)data;
 		UTOPPY_OUT_INIT(sc);
 		if ((err = utoppy_add_path(sc, ur->ur_old_path, 1)) != 0)
 			break;
 		if ((err = utoppy_add_path(sc, ur->ur_new_path, 1)) != 0)
 			break;
 		err = utoppy_command(sc, UTOPPY_CMD_RENAME,
 		    UTOPPY_LONG_TIMEOUT, &resp);
 		if (err)
 			break;
 		if (resp != UTOPPY_RESP_SUCCESS)
 			err = EIO;
 		break;
 	case UTOPPYIOMKDIR:
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIOMKDIR\n",
 		    device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_add_path(sc, *((const char **)data), 1);
 		if (err)
 			break;
 		err = utoppy_command(sc, UTOPPY_CMD_MKDIR, UTOPPY_LONG_TIMEOUT,
 		    &resp);
 		if (err)
 			break;
 		if (resp != UTOPPY_RESP_SUCCESS)
 			err = EIO;
 		break;
 	case UTOPPYIODELETE:
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIODELETE\n",
 		    device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_add_path(sc, *((const char **)data), 0);
 		if (err)
 			break;
 		err = utoppy_command(sc, UTOPPY_CMD_DELETE, UTOPPY_LONG_TIMEOUT,
 		    &resp);
 		if (err)
 			break;
 		if (resp != UTOPPY_RESP_SUCCESS)
 			err = EIO;
 		break;
 	case UTOPPYIOREADDIR:
 		DPRINTF(UTOPPY_DBG_IOCTL, ("%s: utoppyioctl: UTOPPYIOREADDIR\n",
 		    device_xname(sc->sc_dev)));
 		UTOPPY_OUT_INIT(sc);
 		err = utoppy_add_path(sc, *((const char **)data), 0);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppyioctl: "
 			    "utoppy_add_path() returned %d\n",
 			    device_xname(sc->sc_dev), err));
 			break;
+		}
 		err = utoppy_send_packet(sc, UTOPPY_CMD_READDIR,
 		    UTOPPY_LONG_TIMEOUT);
 		if (err != 0) {
 			DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppyioctl: "
 			    "UTOPPY_CMD_READDIR returned %d\n",
 			    device_xname(sc->sc_dev), err));
 			break;
+		}
 		err = utoppy_readdir_next(sc);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_READDIR, ("%s: utoppyioctl: "
 			    "utoppy_readdir_next() returned %d\n",
 			    device_xname(sc->sc_dev), err));
+		}
 		break;
 	case UTOPPYIOREADFILE:
 		urf = (struct utoppy_readfile *)data;
 		DPRINTF(UTOPPY_DBG_IOCTL,("%s: utoppyioctl: UTOPPYIOREADFILE "
 		    "%s, offset %lld\n", device_xname(sc->sc_dev),
 		    urf->ur_path, urf->ur_offset));
 		if ((err = utoppy_turbo_mode(sc, sc->sc_turbo_mode)) != 0)
 			break;
 		UTOPPY_OUT_INIT(sc);
 		utoppy_add_8(sc, UTOPPY_FILE_READ);
 		if ((err = utoppy_add_path(sc, urf->ur_path, 1)) != 0)
 			break;
 		utoppy_add_64(sc, urf->ur_offset);
 		sc->sc_state = UTOPPY_STATE_READFILE;
 		sc->sc_in_offset = 0;
 		err = utoppy_send_packet(sc, UTOPPY_CMD_FILE,
 		    UTOPPY_LONG_TIMEOUT);
 		if (err == 0)
 			err = utoppy_readfile_next(sc);
 		break;
 	case UTOPPYIOWRITEFILE:
 		uw = (struct utoppy_writefile *)data;
 		DPRINTF(UTOPPY_DBG_IOCTL,("%s: utoppyioctl: UTOPPYIOWRITEFILE "
 		    "%s, size %lld, offset %lld\n", device_xname(sc->sc_dev),
 		    uw->uw_path, uw->uw_size, uw->uw_offset));
 		if ((err = utoppy_turbo_mode(sc, sc->sc_turbo_mode)) != 0)
 			break;
 		UTOPPY_OUT_INIT(sc);
 		utoppy_add_8(sc, UTOPPY_FILE_WRITE);
 		uwfp = utoppy_current_ptr(sc->sc_out_data);
 		if ((err = utoppy_add_path(sc, uw->uw_path, 1)) != 0) {
 			DPRINTF(UTOPPY_DBG_WRITE,("%s: utoppyioctl: add_path()"
 			    " returned %d\n", device_xname(sc->sc_dev), err));
 			break;
+		}
 		strncpy(uwf, &uwfp[2], sizeof(uwf));
 		utoppy_add_64(sc, uw->uw_offset);
 		err = utoppy_command(sc, UTOPPY_CMD_FILE, UTOPPY_LONG_TIMEOUT,
 		    &resp);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_WRITE,("%s: utoppyioctl: "
 			    "utoppy_command(UTOPPY_CMD_FILE) returned "
 			    "%d\n", device_xname(sc->sc_dev), err));
 			break;
+		}
 		if (resp != UTOPPY_RESP_SUCCESS) {
 			DPRINTF(UTOPPY_DBG_WRITE,("%s: utoppyioctl: "
 			    "utoppy_command(UTOPPY_CMD_FILE) returned "
 			    "bad response %#x\n", device_xname(sc->sc_dev),
 			    resp));
 			err = EIO;
 			break;
+		}
 		UTOPPY_OUT_INIT(sc);
 		utoppy_timestamp_encode(sc, uw->uw_mtime);
 		utoppy_add_8(sc, UTOPPY_FTYPE_FILE);
 		utoppy_add_64(sc, uw->uw_size);
 		utoppy_add_string(sc, uwf, sizeof(uwf));
 		utoppy_add_32(sc, 0);
 		err = utoppy_command(sc, UTOPPY_RESP_FILE_HEADER,
 		    UTOPPY_LONG_TIMEOUT, &resp);
 		if (err) {
 			DPRINTF(UTOPPY_DBG_WRITE,("%s: utoppyioctl: "
 			    "utoppy_command(UTOPPY_RESP_FILE_HEADER) "
 			    "returned %d\n", device_xname(sc->sc_dev), err));
 			break;
+		}
 		if (resp != UTOPPY_RESP_SUCCESS) {
 			DPRINTF(UTOPPY_DBG_WRITE,("%s: utoppyioctl: "
 			    "utoppy_command(UTOPPY_RESP_FILE_HEADER) "
 			    "returned bad response %#x\n",
 			    device_xname(sc->sc_dev), resp));
 			err = EIO;
 			break;
+		}
 		sc->sc_wr_offset = uw->uw_offset;
 		sc->sc_wr_size = uw->uw_size;
 		sc->sc_state = UTOPPY_STATE_WRITEFILE;
 		DPRINTF(UTOPPY_DBG_WRITE,("%s: utoppyioctl: Changing state to "
 		    "%s. wr_offset %lld, wr_size %lld\n",
 		    device_xname(sc->sc_dev), utoppy_state_string(sc->sc_state),
 		    sc->sc_wr_offset, sc->sc_wr_size));
 		break;
 	default:
 		DPRINTF(UTOPPY_DBG_IOCTL,("%s: utoppyioctl: Invalid cmd\n",
 		    device_xname(sc->sc_dev)));
 		err = ENODEV;
 		break;
+	}
 	DPRINTF(UTOPPY_DBG_IOCTL,("%s: utoppyioctl: done. err %d, state '%s'\n",
 	    device_xname(sc->sc_dev), err, utoppy_state_string(sc->sc_state)));
 	if (err)
 		utoppy_cancel(sc);
 	if (--sc->sc_refcnt < 0)
 		usb_detach_wakeupold(sc->sc_dev);
 	return err;
+}