 @@ -1,14 +1,14 @@
-/*	$NetBSD: umass.c,v 1.179 2020/02/19 16:02:50 riastradh Exp $	*/
+/*	$NetBSD: umass.c,v 1.180 2020/02/19 16:04:01 riastradh Exp $	*/
 /*
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -114,59 +114,110 @@
 /*
  * The SCSI related part of this driver has been derived from the
  * dev/ppbus/vpo.c driver, by Nicolas Souchu (nsouch@freebsd.org).
+ *
  * The CAM layer uses so called actions which are messages sent to the host
  * adapter for completion. The actions come in through umass_cam_action. The
  * appropriate block of routines is called depending on the transport protocol
  * in use. When the transfer has finished, these routines call
  * umass_cam_cb again to complete the CAM command.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: umass.c,v 1.179 2020/02/19 16:02:50 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: umass.c,v 1.180 2020/02/19 16:04:01 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include "atapibus.h"
 #include "scsibus.h"
 #include "wd.h"
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usb_sdt.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/usbhist.h>
 #include <dev/usb/umassvar.h>
 #include <dev/usb/umass_quirks.h>
 #include <dev/usb/umass_scsipi.h>
 #include <dev/usb/umass_isdata.h>
 #include <dev/scsipi/scsipi_all.h>
 #include <dev/scsipi/scsipiconf.h>
 SDT_PROBE_DEFINE1(usb, umass, device, attach__start,
     "struct umass_softc *"/*sc*/);
 SDT_PROBE_DEFINE2(usb, umass, device, attach__done,
     "struct umass_softc *"/*sc*/, "usbd_status"/*err*/);
 SDT_PROBE_DEFINE1(usb, umass, device, detach__start,
     "struct umass_softc *"/*sc*/);
 SDT_PROBE_DEFINE2(usb, umass, device, detach__done,
     "struct umass_softc *"/*sc*/, "int"/*error*/);
 SDT_PROBE_DEFINE7(usb, umass, transfer, start__bbb,
     "struct umass_softc *"/*sc*/,
     "transfer_cb_f"/*cb*/,
     "void *"/*priv*/,
     "void *"/*data*/,
     "int"/*datalen*/,
     "int"/*dir*/,
     "int"/*timeout*/);
 SDT_PROBE_DEFINE7(usb, umass, transfer, start__cbi,
     "struct umass_softc *"/*sc*/,
     "transfer_cb_f"/*cb*/,
     "void *"/*priv*/,
     "void *"/*data*/,
     "int"/*datalen*/,
     "int"/*dir*/,
     "int"/*timeout*/);
 SDT_PROBE_DEFINE7(usb, umass, transfer, done,
     "struct umass_softc *"/*sc*/,
     "transfer_cb_f"/*cb*/,
     "void *"/*priv*/,
     "void *"/*data*/,
     "int"/*datalen*/,
     "int"/*resid*/,
     "int"/*status*/);	/* STATUS_* */
 SDT_PROBE_DEFINE3(usb, umass, bbb, state,
     "struct umass_softc *"/*sc*/,
     "struct usbd_xfer *"/*xfer*/,
     "usbd_status"/*err*/);
 SDT_PROBE_DEFINE2(usb, umass, bbb, reset,
     "struct umass_softc *"/*sc*/,
     "int"/*status*/);
 SDT_PROBE_DEFINE3(usb, umass, cbi, state,
     "struct umass_softc *"/*sc*/,
     "struct usbd_xfer *"/*xfer*/,
     "usbd_status"/*err*/);
 SDT_PROBE_DEFINE2(usb, umass, cbi, reset,
     "struct umass_softc *"/*sc*/,
     "int"/*status*/);
 #ifdef USB_DEBUG
 #ifdef UMASS_DEBUG
 int umassdebug = 0;
 SYSCTL_SETUP(sysctl_hw_umass_setup, "sysctl hw.umass setup")
+{
 	int err;
 	const struct sysctlnode *rnode;
 	const struct sysctlnode *cnode;
 	err = sysctl_createv(clog, 0, NULL, &rnode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "umass",
 	    SYSCTL_DESCR("umass global controls"),
 @@ -325,26 +376,28 @@ static void
 umass_attach(device_t parent, device_t self, void *aux)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	struct umass_softc *sc = device_private(self);
 	struct usbif_attach_arg *uiaa = aux;
 	const struct umass_quirk *quirk;
 	usb_interface_descriptor_t *id;
 	usb_endpoint_descriptor_t *ed;
 	const char *sWire, *sCommand;
 	char *devinfop;
 	usbd_status err;
 	int i, error;
 	SDT_PROBE1(usb, umass, device, attach__start,  sc);
 	sc->sc_dev = self;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	cv_init(&sc->sc_detach_cv, "umassdet");
 	devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	sc->sc_udev = uiaa->uiaa_device;
 @@ -372,49 +425,53 @@ umass_attach(device_t parent, device_t s
 		case UIPROTO_MASS_CBI:
 			sc->sc_wire = UMASS_WPROTO_CBI;
 			break;
 		case UIPROTO_MASS_CBI_I:
 			sc->sc_wire = UMASS_WPROTO_CBI_I;
 			break;
 		case UIPROTO_MASS_BBB:
 		case UIPROTO_MASS_BBB_OLD:
 			sc->sc_wire = UMASS_WPROTO_BBB;
 			break;
 		default:
 			DPRINTFM(UDMASS_GEN, "Unsupported wire protocol %ju",
 			    uiaa->uiaa_proto, 0, 0, 0);
 			SDT_PROBE2(usb, umass, device, attach__done,
 			    sc, USBD_IOERROR);
 			return;
+		}
+	}
 	if (sc->sc_cmd == UMASS_CPROTO_UNSPEC) {
 		switch (uiaa->uiaa_subclass) {
 		case UISUBCLASS_SCSI:
 			sc->sc_cmd = UMASS_CPROTO_SCSI;
 			break;
 		case UISUBCLASS_UFI:
 			sc->sc_cmd = UMASS_CPROTO_UFI;
 			break;
 		case UISUBCLASS_SFF8020I:
 		case UISUBCLASS_SFF8070I:
 		case UISUBCLASS_QIC157:
 			sc->sc_cmd = UMASS_CPROTO_ATAPI;
 			break;
 		case UISUBCLASS_RBC:
 			sc->sc_cmd = UMASS_CPROTO_RBC;
 			break;
 		default:
 			DPRINTFM(UDMASS_GEN, "Unsupported command protocol %ju",
 			    uiaa->uiaa_subclass, 0, 0, 0);
 			SDT_PROBE2(usb, umass, device, attach__done,
 			    sc, USBD_IOERROR);
 			return;
+		}
+	}
 	switch (sc->sc_wire) {
 	case UMASS_WPROTO_CBI:
 		sWire = "CBI";
 		break;
 	case UMASS_WPROTO_CBI_I:
 		sWire = "CBI with CCI";
 		break;
 	case UMASS_WPROTO_BBB:
 		sWire = "Bulk-Only";
 @@ -441,48 +498,51 @@ umass_attach(device_t parent, device_t s
 		sCommand = "ISD-ATA";
 		break;
 	default:
 		sCommand = "unknown";
 		break;
+	}
 	aprint_verbose_dev(self, "using %s over %s\n", sCommand, sWire);
 	if (quirk != NULL && quirk->uq_init != NULL) {
 		err = (*quirk->uq_init)(sc);
 		if (err) {
 			aprint_error_dev(self, "quirk init failed\n");
 			SDT_PROBE2(usb, umass, device, attach__done,  sc, err);
 			umass_disco(sc);
 			return;
+		}
+	}
 	/*
 	 * In addition to the Control endpoint the following endpoints
 	 * are required:
 	 * a) bulk-in endpoint.
 	 * b) bulk-out endpoint.
 	 * and for Control/Bulk/Interrupt with CCI (CBI_I)
 	 * c) intr-in
+	 *
 	 * The endpoint addresses are not fixed, so we have to read them
 	 * from the device descriptors of the current interface.
 	 */
 	id = usbd_get_interface_descriptor(sc->sc_iface);
 	for (i = 0 ; i < id->bNumEndpoints ; i++) {
 		ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self,
 			    "could not read endpoint descriptor\n");
 			SDT_PROBE2(usb, umass, device, attach__done,
 			    sc, USBD_IOERROR);
 			return;
+		}
 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
 		    && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
 			sc->sc_epaddr[UMASS_BULKIN] = ed->bEndpointAddress;
 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT
 		    && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
 			sc->sc_epaddr[UMASS_BULKOUT] = ed->bEndpointAddress;
 		} else if (sc->sc_wire == UMASS_WPROTO_CBI_I
 		    && UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
 		    && (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
 			sc->sc_epaddr[UMASS_INTRIN] = ed->bEndpointAddress;
 #ifdef UMASS_DEBUG
 @@ -505,79 +565,83 @@ umass_attach(device_t parent, device_t s
 		       sc->sc_epaddr[UMASS_INTRIN]);
 		return;
+	}
 	/*
 	 * Get the maximum LUN supported by the device.
 	 */
 	if (sc->sc_wire == UMASS_WPROTO_BBB &&
 	    (sc->sc_quirks & UMASS_QUIRK_NOGETMAXLUN) == 0) {
 		err = umass_bbb_get_max_lun(sc, &sc->maxlun);
 		if (err) {
 			aprint_error_dev(self, "unable to get Max Lun: %s\n",
 			    usbd_errstr(err));
 			SDT_PROBE2(usb, umass, device, attach__done,  sc, err);
 			return;
+		}
 		if (sc->maxlun > 0)
 			sc->sc_busquirks |= PQUIRK_FORCELUNS;
 	} else {
 		sc->maxlun = 0;
+	}
 	/* Open the bulk-in and -out pipe */
 	DPRINTFM(UDMASS_USB, "sc %#jx: opening iface %#jx epaddr %jd for "
 	    "BULKOUT", (uintptr_t)sc, (uintptr_t)sc->sc_iface,
 	    sc->sc_epaddr[UMASS_BULKOUT], 0);
 	err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_BULKOUT],
 	    USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_pipe[UMASS_BULKOUT]);
 	if (err) {
 		aprint_error_dev(self, "cannot open %u-out pipe (bulk)\n",
 		    sc->sc_epaddr[UMASS_BULKOUT]);
 		SDT_PROBE2(usb, umass, device, attach__done,  sc, err);
 		umass_disco(sc);
 		return;
+	}
 	DPRINTFM(UDMASS_USB, "sc %#jx: opening iface %#jx epaddr %jd for "
 	    "BULKIN", (uintptr_t)sc, (uintptr_t)sc->sc_iface,
 	    sc->sc_epaddr[UMASS_BULKIN], 0);
 	err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_BULKIN],
 	    USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_pipe[UMASS_BULKIN]);
 	if (err) {
 		aprint_error_dev(self, "could not open %u-in pipe (bulk)\n",
 		    sc->sc_epaddr[UMASS_BULKIN]);
 		SDT_PROBE2(usb, umass, device, attach__done,  sc, err);
 		umass_disco(sc);
 		return;
+	}
 	/*
 	 * Open the intr-in pipe if the protocol is CBI with CCI.
 	 * Note: early versions of the Zip drive do have an interrupt pipe, but
 	 * this pipe is unused
+	 *
 	 * We do not open the interrupt pipe as an interrupt pipe, but as a
 	 * normal bulk endpoint. We send an IN transfer down the wire at the
 	 * appropriate time, because we know exactly when to expect data on
 	 * that endpoint. This saves bandwidth, but more important, makes the
 	 * code for handling the data on that endpoint simpler. No data
 	 * arriving concurrently.
 	 */
 	if (sc->sc_wire == UMASS_WPROTO_CBI_I) {
 		DPRINTFM(UDMASS_USB,
 		    "sc %#jx: opening iface %#jx epaddr %jd for INTRIN",
 		    (uintptr_t)sc, (uintptr_t)sc->sc_iface,
 		    sc->sc_epaddr[UMASS_INTRIN], 0);
 		err = usbd_open_pipe(sc->sc_iface, sc->sc_epaddr[UMASS_INTRIN],
 		    USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_pipe[UMASS_INTRIN]);
 		if (err) {
 			aprint_error_dev(self, "couldn't open %u-in (intr)\n",
 			    sc->sc_epaddr[UMASS_INTRIN]);
 			SDT_PROBE2(usb, umass, device, attach__done,  sc, err);
 			umass_disco(sc);
 			return;
+		}
+	}
 	/* initialisation of generic part */
 	sc->transfer_state = TSTATE_IDLE;
 	for (i = 0; i < XFER_NR; i++) {
 		sc->transfer_xfer[i] = NULL;
+	}
 	/*
 @@ -667,26 +731,27 @@ umass_attach(device_t parent, device_t s
 			goto fail_create;
 		err = usbd_create_xfer(pipe0, sizeof(sc->cbl), 0, 0,
 		    &sc->transfer_xfer[XFER_CBI_RESET2]);
 		if (err)
 			goto fail_create;
 		err = usbd_create_xfer(pipe0, sizeof(sc->cbl), 0, 0,
 		    &sc->transfer_xfer[XFER_CBI_RESET3]);
 		if (err)
 			goto fail_create;
 		break;
 	default:
 	fail_create:
 		aprint_error_dev(self, "failed to create xfers\n");
 		SDT_PROBE2(usb, umass, device, attach__done,  sc, err);
 		umass_disco(sc);
 		return;
+	}
 	/*
 	 * Record buffer pointers for data transfer (it's huge), command and
 	 * status data here
 	 */
 	switch (sc->sc_wire) {
 	case UMASS_WPROTO_BBB:
 		sc->datain_buffer =
 		    usbd_get_buffer(sc->transfer_xfer[XFER_BBB_DATAIN]);
 		sc->dataout_buffer =
 @@ -755,60 +820,64 @@ umass_attach(device_t parent, device_t s
 #else
 		aprint_error_dev(self, "isdata not configured\n");
 #endif
 		break;
 	default:
 		aprint_error_dev(self, "command protocol=0x%x not supported\n",
 		    sc->sc_cmd);
 		umass_disco(sc);
 		return;
+	}
 	if (error) {
 		aprint_error_dev(self, "bus attach failed\n");
 		SDT_PROBE2(usb, umass, device, attach__done,
 		    sc, USBD_IOERROR);
 		umass_disco(sc);
 		return;
+	}
 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
 	if (!pmf_device_register(self, NULL, NULL))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	DPRINTFM(UDMASS_GEN, "sc %#jx: Attach finished", (uintptr_t)sc,
 , 0, 0);
 	SDT_PROBE2(usb, umass, device, attach__done,  sc, 0);
 	return;
+}
 static void
 umass_childdet(device_t self, device_t child)
+{
 	struct umass_softc *sc = device_private(self);
 	KASSERTMSG(child == sc->bus->sc_child,
 		   "assertion child == sc->bus->sc_child failed\n");
 	sc->bus->sc_child = NULL;
+}
 static int
 umass_detach(device_t self, int flags)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	struct umass_softc *sc = device_private(self);
 	struct umassbus_softc *scbus;
 	int rv = 0, i;
 	DPRINTFM(UDMASS_USB, "sc %#jx detached", (uintptr_t)sc, 0, 0, 0);
 	SDT_PROBE1(usb, umass, device, detach__start,  sc);
 	mutex_enter(&sc->sc_lock);
 	sc->sc_dying = true;
 	mutex_exit(&sc->sc_lock);
 	pmf_device_deregister(self);
 	/* Abort the pipes to wake up any waiting processes. */
 	for (i = 0 ; i < UMASS_NEP ; i++) {
 		if (sc->sc_pipe[i] != NULL)
 			usbd_abort_pipe(sc->sc_pipe[i]);
+	}
 	usbd_abort_default_pipe(sc->sc_udev);
 @@ -856,36 +925,37 @@ umass_detach(device_t self, int flags)
 			aprint_error_dev(self, "isdata not configured\n");
 #endif
 			break;
 		default:
 			/* nothing to do */
 			break;
+		}
 		/* protocol detach is expected to free sc->bus */
 		KASSERT(sc->bus == NULL);
+	}
-	if (rv != 0)
+	if (rv)
-		return rv;
+		goto out;
 	umass_disco(sc);
 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
 	mutex_destroy(&sc->sc_lock);
 	cv_destroy(&sc->sc_detach_cv);
 out:	SDT_PROBE2(usb, umass, device, detach__done,  sc, rv);
 	return rv;
+}
 static int
 umass_activate(device_t dev, enum devact act)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	struct umass_softc *sc = device_private(dev);
 	DPRINTFM(UDMASS_USB, "sc %#jx act %jd", (uintptr_t)sc, act, 0, 0);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 @@ -1012,60 +1082,78 @@ umass_clear_endpoint_stall(struct umass_
 	USETW(sc->sc_req.wIndex, sc->sc_epaddr[endpt]);
 	USETW(sc->sc_req.wLength, 0);
 	if (umass_setup_ctrl_transfer(sc, &sc->sc_req, NULL, 0, 0, xfer))
 		umass_transfer_done(sc, sc->transfer_datalen,
 		    STATUS_WIRE_FAILED);
+}
 Static void
 umass_transfer_done(struct umass_softc *sc, int residue, int status)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	sc->transfer_state = TSTATE_IDLE;
 	SDT_PROBE7(usb, umass, transfer, done,
 	    sc,
 	    sc->transfer_cb,
 	    sc->transfer_priv,
 	    sc->transfer_data,
 	    sc->transfer_datalen,
 	    residue,
 	    status);
 	sc->transfer_cb(sc, sc->transfer_priv, residue, status);
+}
 Static void
 umass_transfer_reset(struct umass_softc *sc)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	sc->transfer_state = TSTATE_IDLE;
-	if (sc->transfer_priv)
+	if (sc->transfer_priv) {
 		SDT_PROBE7(usb, umass, transfer, done,
 		    sc,
 		    sc->transfer_cb,
 		    sc->transfer_priv,
 		    sc->transfer_data,
 		    sc->transfer_datalen,
 		    sc->transfer_datalen,
 		    sc->transfer_status);
 		sc->transfer_cb(sc, sc->transfer_priv, sc->transfer_datalen,
 		    sc->transfer_status);
+	}
+}
 #if 0
 Static void
 umass_reset(struct umass_softc *sc, transfer_cb_f cb, void *priv)
+{
 	sc->transfer_cb = cb;
 	sc->transfer_priv = priv;
 	/* The reset is a forced reset, so no error (yet) */
 	sc->reset(sc, STATUS_CMD_OK);
+}
 #endif
 /*
  * Bulk protocol specific functions
  */
 Static void
 umass_bbb_reset(struct umass_softc *sc, int status)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	SDT_PROBE2(usb, umass, bbb, reset,  sc, status);
 	KASSERTMSG(sc->sc_wire & UMASS_WPROTO_BBB,
 		   "sc->sc_wire == 0x%02x wrong for umass_bbb_reset\n",
 		   sc->sc_wire);
 	if (sc->sc_dying) {
 		umass_transfer_done(sc, sc->transfer_datalen, status);
 		return;
+	}
 	/*
 	 * Reset recovery (5.3.4 in Universal Serial Bus Mass Storage Class)
+	 *
 	 * For Reset Recovery the host shall issue in the following order:
 @@ -1093,36 +1181,40 @@ umass_bbb_reset(struct umass_softc *sc,
 	USETW(sc->sc_req.wIndex, sc->sc_ifaceno);
 	USETW(sc->sc_req.wLength, 0);
 	if (umass_setup_ctrl_transfer(sc, &sc->sc_req, NULL, 0, 0,
 		sc->transfer_xfer[XFER_BBB_RESET1]))
 		umass_transfer_done(sc, sc->transfer_datalen, status);
+}
 Static void
 umass_bbb_transfer(struct umass_softc *sc, int lun, void *cmd, int cmdlen,
 		   void *data, int datalen, int dir, u_int timeout,
 		   int flags, umass_callback cb, void *priv)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	SDT_PROBE7(usb, umass, transfer, start__bbb,
 	    sc, cb, priv, data, datalen, dir, timeout);
 	static int dCBWtag = 42;	/* unique for CBW of transfer */
 	DPRINTFM(UDMASS_BBB, "sc %#jx cmd=0x%02jx", (uintptr_t)sc,
 	    *(u_char *)cmd, 0, 0);
 	KASSERTMSG(sc->sc_wire & UMASS_WPROTO_BBB,
 		   "sc->sc_wire == 0x%02x wrong for umass_bbb_transfer\n",
 		   sc->sc_wire);
 	if (sc->sc_dying) {
 		SDT_PROBE7(usb, umass, transfer, done,
 		    sc, cb, priv, data, datalen, datalen, STATUS_WIRE_FAILED);
 		cb(sc, priv, datalen, STATUS_WIRE_FAILED);
 		return;
+	}
 	/* Be a little generous. */
 	sc->timeout = timeout + USBD_DEFAULT_TIMEOUT;
 	/*
 	 * Do a Bulk-Only transfer with cmdlen bytes from cmd, possibly
 	 * a data phase of datalen bytes from/to the device and finally a
 	 * csw read phase.
 	 * If the data direction was inbound a maximum of datalen bytes
 	 * is stored in the buffer pointed to by data.
 @@ -1216,26 +1308,28 @@ umass_bbb_transfer(struct umass_softc *s
+	}
+}
 Static void
 umass_bbb_state(struct usbd_xfer *xfer, void *priv,
 		usbd_status err)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	struct umass_softc *sc = (struct umass_softc *) priv;
 	struct usbd_xfer *next_xfer;
 	int residue;
 	SDT_PROBE3(usb, umass, bbb, state,  sc, xfer, err);
 	KASSERTMSG(sc->sc_wire & UMASS_WPROTO_BBB,
 		   "sc->sc_wire == 0x%02x wrong for umass_bbb_state\n",
 		   sc->sc_wire);
 	/*
 	 * State handling for BBB transfers.
+	 *
 	 * The subroutine is rather long. It steps through the states given in
 	 * Annex A of the Bulk-Only specification.
 	 * Each state first does the error handling of the previous transfer
 	 * and then prepares the next transfer.
 	 * Each transfer is done asynchroneously so after the request/transfer
 	 * has been submitted you will find a 'return;'.
 @@ -1557,26 +1651,27 @@ umass_cbi_adsc(struct umass_softc *sc, c
 	sc->sc_req.bRequest = UR_CBI_ADSC;
 	USETW(sc->sc_req.wValue, 0);
 	USETW(sc->sc_req.wIndex, sc->sc_ifaceno);
 	USETW(sc->sc_req.wLength, buflen);
 	return umass_setup_ctrl_transfer(sc, &sc->sc_req, buffer,
 					 buflen, flags, xfer);
+}
 Static void
 umass_cbi_reset(struct umass_softc *sc, int status)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	SDT_PROBE2(usb, umass, bbb, reset,  sc, status);
 	int i;
 #	define SEND_DIAGNOSTIC_CMDLEN	12
 	KASSERTMSG(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
 		   "sc->sc_wire == 0x%02x wrong for umass_cbi_reset\n",
 		   sc->sc_wire);
 	if (sc->sc_dying) {
 		umass_transfer_done(sc, sc->transfer_datalen, status);
 		return;
+	}
 	/*
 @@ -1615,35 +1710,39 @@ umass_cbi_reset(struct umass_softc *sc,
 	if (umass_cbi_adsc(sc, sc->cbl, SEND_DIAGNOSTIC_CMDLEN, 0,
 		sc->transfer_xfer[XFER_CBI_RESET1]))
 		umass_transfer_done(sc, sc->transfer_datalen, status);
 	/* XXX if the command fails we should reset the port on the bub */
+}
 Static void
 umass_cbi_transfer(struct umass_softc *sc, int lun,
 		   void *cmd, int cmdlen, void *data, int datalen, int dir,
 		   u_int timeout, int flags, umass_callback cb, void *priv)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	SDT_PROBE7(usb, umass, transfer, start__cbi,
 	    sc, cb, priv, data, datalen, dir, timeout);
 	DPRINTFM(UDMASS_CBI, "sc %#jx: cmd=0x%02jx, len=%jd",
 	     (uintptr_t)sc, *(u_char *)cmd, datalen, 0);
 	KASSERTMSG(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
 		   "sc->sc_wire == 0x%02x wrong for umass_cbi_transfer\n",
 		   sc->sc_wire);
 	if (sc->sc_dying) {
 		SDT_PROBE7(usb, umass, transfer, done,
 		    sc, cb, priv, data, datalen, datalen, STATUS_WIRE_FAILED);
 		cb(sc, priv, datalen, STATUS_WIRE_FAILED);
 		return;
+	}
 	/* Be a little generous. */
 	sc->timeout = timeout + USBD_DEFAULT_TIMEOUT;
 	/*
 	 * Do a CBI transfer with cmdlen bytes from cmd, possibly
 	 * a data phase of datalen bytes from/to the device and finally a
 	 * csw read phase.
 	 * If the data direction was inbound a maximum of datalen bytes
 	 * is stored in the buffer pointed to by data.
 @@ -1680,26 +1779,28 @@ umass_cbi_transfer(struct umass_softc *s
 	/* Send the Command Block from host to device via control endpoint. */
 	if (umass_cbi_adsc(sc, cmd, cmdlen, flags,
 	    sc->transfer_xfer[XFER_CBI_CB]))
 		umass_cbi_reset(sc, STATUS_WIRE_FAILED);
+}
 Static void
 umass_cbi_state(struct usbd_xfer *xfer, void *priv,
 		usbd_status err)
+{
 	UMASSHIST_FUNC(); UMASSHIST_CALLED();
 	struct umass_softc *sc = (struct umass_softc *) priv;
 	SDT_PROBE3(usb, umass, bbb, state,  sc, xfer, err);
 	KASSERTMSG(sc->sc_wire & (UMASS_WPROTO_CBI|UMASS_WPROTO_CBI_I),
 		   "sc->sc_wire == 0x%02x wrong for umass_cbi_state\n",
 		   sc->sc_wire);
 	if (err == USBD_CANCELLED) {
 		DPRINTFM(UDMASS_BBB, "sc %#jx xfer %#jx cancelled",
 			(uintptr_t)sc, (uintptr_t)xfer, 0, 0);
 		umass_transfer_done(sc, 0, STATUS_TIMEOUT);
 		return;
+	}
 	if (sc->sc_dying) {
 		umass_transfer_done(sc, sc->transfer_datalen,