 @@ -1,1515 +1,1515 @@
-/*	$NetBSD: umidi.c,v 1.63 2012/06/10 06:15:54 mrg Exp $	*/
+/*	$NetBSD: umidi.c,v 1.64 2013/01/22 21:13:39 jmcneill Exp $	*/
 /*
  * Copyright (c) 2001, 2012 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Takuya SHIOZAKI (tshiozak@NetBSD.org), (full-size transfers, extended
  * hw_if) Chapman Flack (chap@NetBSD.org), and Matthew R. Green
  * (mrg@eterna.com.au).
+ *
  * 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: umidi.c,v 1.63 2012/06/10 06:15:54 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: umidi.c,v 1.64 2013/01/22 21:13:39 jmcneill Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/device.h>
 #include <sys/ioctl.h>
 #include <sys/conf.h>
 #include <sys/file.h>
 #include <sys/select.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/poll.h>
 #include <sys/intr.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/auconv.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/uaudioreg.h>
 #include <dev/usb/umidireg.h>
 #include <dev/usb/umidivar.h>
 #include <dev/usb/umidi_quirks.h>
 #include <dev/midi_if.h>
 #ifdef UMIDI_DEBUG
 #define DPRINTF(x)	if (umididebug) printf x
 #define DPRINTFN(n,x)	if (umididebug >= (n)) printf x
 #include <sys/time.h>
 static struct timeval umidi_tv;
 int	umididebug = 0;
 #else
 #define DPRINTF(x)
 #define DPRINTFN(n,x)
 #endif
 #define UMIDI_ENDPOINT_SIZE(sc)	(sizeof(*(sc)->sc_out_ep) * \
 				 (sc->sc_out_num_endpoints + \
 				  sc->sc_in_num_endpoints))
 static int umidi_open(void *, int,
 		      void (*)(void *, int), void (*)(void *), void *);
 static void umidi_close(void *);
 static int umidi_channelmsg(void *, int, int, u_char *, int);
 static int umidi_commonmsg(void *, int, u_char *, int);
 static int umidi_sysex(void *, u_char *, int);
 static int umidi_rtmsg(void *, int);
 static void umidi_getinfo(void *, struct midi_info *);
 static void umidi_get_locks(void *, kmutex_t **, kmutex_t **);
 static usbd_status alloc_pipe(struct umidi_endpoint *);
 static void free_pipe(struct umidi_endpoint *);
 static usbd_status alloc_all_endpoints(struct umidi_softc *);
 static void free_all_endpoints(struct umidi_softc *);
 static usbd_status alloc_all_jacks(struct umidi_softc *);
 static void free_all_jacks(struct umidi_softc *);
 static usbd_status bind_jacks_to_mididev(struct umidi_softc *,
 					 struct umidi_jack *,
 					 struct umidi_jack *,
 					 struct umidi_mididev *);
 static void unbind_jacks_from_mididev(struct umidi_mididev *);
 static void unbind_all_jacks(struct umidi_softc *);
 static usbd_status assign_all_jacks_automatically(struct umidi_softc *);
 static usbd_status open_out_jack(struct umidi_jack *, void *,
 				 void (*)(void *));
 static usbd_status open_in_jack(struct umidi_jack *, void *,
 				void (*)(void *, int));
 static void close_out_jack(struct umidi_jack *);
 static void close_in_jack(struct umidi_jack *);
 static usbd_status attach_mididev(struct umidi_softc *, struct umidi_mididev *);
 static usbd_status detach_mididev(struct umidi_mididev *, int);
 static void deactivate_mididev(struct umidi_mididev *);
 static usbd_status alloc_all_mididevs(struct umidi_softc *, int);
 static void free_all_mididevs(struct umidi_softc *);
 static usbd_status attach_all_mididevs(struct umidi_softc *);
 static usbd_status detach_all_mididevs(struct umidi_softc *, int);
 static void deactivate_all_mididevs(struct umidi_softc *);
 static void describe_mididev(struct umidi_mididev *);
 #ifdef UMIDI_DEBUG
 static void dump_sc(struct umidi_softc *);
 static void dump_ep(struct umidi_endpoint *);
 static void dump_jack(struct umidi_jack *);
 #endif
 static usbd_status start_input_transfer(struct umidi_endpoint *);
 static usbd_status start_output_transfer(struct umidi_endpoint *);
 static int out_jack_output(struct umidi_jack *, u_char *, int, int);
 static void in_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
 static void out_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
 static void out_solicit(void *); /* struct umidi_endpoint* for softintr */
 static void out_solicit_locked(void *); /* pre-locked version */
 const struct midi_hw_if umidi_hw_if = {
 	.open = umidi_open,
 	.close = umidi_close,
 	.output = umidi_rtmsg,
 	.getinfo = umidi_getinfo,
 	.get_locks = umidi_get_locks,
 };
 struct midi_hw_if_ext umidi_hw_if_ext = {
 	.channel = umidi_channelmsg,
 	.common  = umidi_commonmsg,
 	.sysex   = umidi_sysex,
 };
 struct midi_hw_if_ext umidi_hw_if_mm = {
 	.channel = umidi_channelmsg,
 	.common  = umidi_commonmsg,
 	.sysex   = umidi_sysex,
 	.compress = 1,
 };
 int umidi_match(device_t, cfdata_t, void *);
 void umidi_attach(device_t, device_t, void *);
 void umidi_childdet(device_t, device_t);
 int umidi_detach(device_t, int);
 int umidi_activate(device_t, enum devact);
 extern struct cfdriver umidi_cd;
 CFATTACH_DECL2_NEW(umidi, sizeof(struct umidi_softc), umidi_match,
     umidi_attach, umidi_detach, umidi_activate, NULL, umidi_childdet);
 int
 umidi_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usbif_attach_arg *uaa = aux;
 	DPRINTFN(1,("umidi_match\n"));
 	if (umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno))
 		return UMATCH_IFACECLASS_IFACESUBCLASS;
 	if (uaa->class == UICLASS_AUDIO &&
 	    uaa->subclass == UISUBCLASS_MIDISTREAM)
 		return UMATCH_IFACECLASS_IFACESUBCLASS;
 	return UMATCH_NONE;
+}
 void
 umidi_attach(device_t parent, device_t self, void *aux)
+{
 	usbd_status     err;
 	struct umidi_softc *sc = device_private(self);
 	struct usbif_attach_arg *uaa = aux;
 	char *devinfop;
 	DPRINTFN(1,("umidi_attach\n"));
 	sc->sc_dev = self;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(uaa->device, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	sc->sc_iface = uaa->iface;
 	sc->sc_udev = uaa->device;
 	sc->sc_quirk =
 	    umidi_search_quirk(uaa->vendor, uaa->product, uaa->ifaceno);
 	aprint_normal_dev(self, "");
 	umidi_print_quirk(sc->sc_quirk);
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_USB);
 	cv_init(&sc->sc_cv, "umidopcl");
 	err = alloc_all_endpoints(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		aprint_error_dev(self,
 		    "alloc_all_endpoints failed. (err=%d)\n", err);
 		goto error;
+	}
 	err = alloc_all_jacks(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		free_all_endpoints(sc);
 		aprint_error_dev(self, "alloc_all_jacks failed. (err=%d)\n",
 		    err);
 		goto error;
+	}
 	aprint_normal_dev(self, "out=%d, in=%d\n",
 	       sc->sc_out_num_jacks, sc->sc_in_num_jacks);
 	err = assign_all_jacks_automatically(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		unbind_all_jacks(sc);
 		free_all_jacks(sc);
 		free_all_endpoints(sc);
 		aprint_error_dev(self,
 		    "assign_all_jacks_automatically failed. (err=%d)\n", err);
 		goto error;
+	}
 	err = attach_all_mididevs(sc);
 	if (err != USBD_NORMAL_COMPLETION) {
 		free_all_jacks(sc);
 		free_all_endpoints(sc);
 		aprint_error_dev(self,
 		    "attach_all_mididevs failed. (err=%d)\n", err);
+	}
 #ifdef UMIDI_DEBUG
 	dump_sc(sc);
 #endif
 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH,
 			   sc->sc_udev, sc->sc_dev);
 	return;
 error:
 	aprint_error_dev(self, "disabled.\n");
 	sc->sc_dying = 1;
 	KERNEL_UNLOCK_ONE(curlwp);
 	return;
+}
 void
 umidi_childdet(device_t self, device_t child)
+{
 	int i;
 	struct umidi_softc *sc = device_private(self);
 	KASSERT(sc->sc_mididevs != NULL);
 	for (i = 0; i < sc->sc_num_mididevs; i++) {
 		if (sc->sc_mididevs[i].mdev == child)
 			break;
+	}
 	KASSERT(i < sc->sc_num_mididevs);
 	sc->sc_mididevs[i].mdev = NULL;
+}
 int
 umidi_activate(device_t self, enum devact act)
+{
 	struct umidi_softc *sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		DPRINTFN(1,("umidi_activate (deactivate)\n"));
 		sc->sc_dying = 1;
 		deactivate_all_mididevs(sc);
 		return 0;
 	default:
 		DPRINTFN(1,("umidi_activate (%d)\n", act));
 		return EOPNOTSUPP;
+	}
+}
 int
 umidi_detach(device_t self, int flags)
+{
 	struct umidi_softc *sc = device_private(self);
 	DPRINTFN(1,("umidi_detach\n"));
 	sc->sc_dying = 1;
 	detach_all_mididevs(sc, flags);
 	free_all_mididevs(sc);
 	free_all_jacks(sc);
 	free_all_endpoints(sc);
 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
 			   sc->sc_dev);
 	mutex_destroy(&sc->sc_lock);
 	cv_destroy(&sc->sc_cv);
 	return 0;
+}
 /*
  * midi_if stuffs
  */
 int
 umidi_open(void *addr,
 	   int flags,
 	   void (*iintr)(void *, int),
 	   void (*ointr)(void *),
 	   void *arg)
+{
 	struct umidi_mididev *mididev = addr;
 	struct umidi_softc *sc = mididev->sc;
 	usbd_status err;
 	DPRINTF(("umidi_open: sc=%p\n", sc));
 	if (!sc)
 		return ENXIO;
 	if (mididev->opened)
 		return EBUSY;
 	if (sc->sc_dying)
 		return EIO;
 	mididev->opened = 1;
 	mididev->closing = 0;
 	mididev->flags = flags;
 	if ((mididev->flags & FWRITE) && mididev->out_jack) {
 		err = open_out_jack(mididev->out_jack, arg, ointr);
 		if ( err != USBD_NORMAL_COMPLETION )
 			goto bad;
+	}
 	if ((mididev->flags & FREAD) && mididev->in_jack) {
 		err = open_in_jack(mididev->in_jack, arg, iintr);
 		if ( err != USBD_NORMAL_COMPLETION
 		&&   err != USBD_IN_PROGRESS )
 			goto bad;
+	}
 	return 0;
 bad:
 	mididev->opened = 0;
 	DPRINTF(("umidi_open: usbd_status %d\n", err));
 	return USBD_IN_USE == err ? EBUSY : EIO;
+}
 void
 umidi_close(void *addr)
+{
 	struct umidi_mididev *mididev = addr;
 	mididev->closing = 1;
 	mutex_spin_exit(&mididev->sc->sc_lock);
 	if ((mididev->flags & FWRITE) && mididev->out_jack)
 		close_out_jack(mididev->out_jack);
 	if ((mididev->flags & FREAD) && mididev->in_jack)
 		close_in_jack(mididev->in_jack);
 	mutex_spin_enter(&mididev->sc->sc_lock);
 	mididev->opened = 0;
+}
 int
 umidi_channelmsg(void *addr, int status, int channel, u_char *msg,
     int len)
+{
 	struct umidi_mididev *mididev = addr;
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	return out_jack_output(mididev->out_jack, msg, len, (status>>4)&0xf);
+}
 int
 umidi_commonmsg(void *addr, int status, u_char *msg, int len)
+{
 	struct umidi_mididev *mididev = addr;
 	int cin;
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	switch ( len ) {
 	case 1: cin = 5; break;
 	case 2: cin = 2; break;
 	case 3: cin = 3; break;
 	default: return EIO; /* or gcc warns of cin uninitialized */
+	}
 	return out_jack_output(mididev->out_jack, msg, len, cin);
+}
 int
 umidi_sysex(void *addr, u_char *msg, int len)
+{
 	struct umidi_mididev *mididev = addr;
 	int cin;
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	switch ( len ) {
 	case 1: cin = 5; break;
 	case 2: cin = 6; break;
 	case 3: cin = (msg[2] == 0xf7) ? 7 : 4; break;
 	default: return EIO; /* or gcc warns of cin uninitialized */
+	}
 	return out_jack_output(mididev->out_jack, msg, len, cin);
+}
 int
 umidi_rtmsg(void *addr, int d)
+{
 	struct umidi_mididev *mididev = addr;
 	u_char msg = d;
 	if (!mididev->out_jack || !mididev->opened || mididev->closing)
 		return EIO;
 	return out_jack_output(mididev->out_jack, &msg, 1, 0xf);
+}
 void
 umidi_getinfo(void *addr, struct midi_info *mi)
+{
 	struct umidi_mididev *mididev = addr;
 	struct umidi_softc *sc = mididev->sc;
 	int mm = UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE);
 	mi->name = mididev->label;
 	mi->props = MIDI_PROP_OUT_INTR;
 	if (mididev->in_jack)
 		mi->props |= MIDI_PROP_CAN_INPUT;
 	midi_register_hw_if_ext(mm? &umidi_hw_if_mm : &umidi_hw_if_ext);
+}
 static void
 umidi_get_locks(void *addr, kmutex_t **thread, kmutex_t **intr)
+{
 	struct umidi_mididev *mididev = addr;
 	struct umidi_softc *sc = mididev->sc;
 	*intr = NULL;
 	*thread = &sc->sc_lock;
+}
 /*
  * each endpoint stuffs
  */
 /* alloc/free pipe */
 static usbd_status
 alloc_pipe(struct umidi_endpoint *ep)
+{
 	struct umidi_softc *sc = ep->sc;
 	usbd_status err;
 	usb_endpoint_descriptor_t *epd;
 	epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr);
 	/*
 	 * For output, an improvement would be to have a buffer bigger than
 	 * wMaxPacketSize by num_jacks-1 additional packet slots; that would
 	 * allow out_solicit to fill the buffer to the full packet size in
 	 * all cases. But to use usbd_alloc_buffer to get a slightly larger
 	 * buffer would not be a good way to do that, because if the addition
 	 * would make the buffer exceed USB_MEM_SMALL then a substantially
 	 * larger block may be wastefully allocated. Some flavor of double
 	 * buffering could serve the same purpose, but would increase the
 	 * code complexity, so for now I will live with the current slight
 	 * penalty of reducing max transfer size by (num_open-num_scheduled)
 	 * packet slots.
 	 */
 	ep->buffer_size = UGETW(epd->wMaxPacketSize);
 	ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE;
 	DPRINTF(("%s: alloc_pipe %p, buffer size %u\n",
 	        device_xname(sc->sc_dev), ep, ep->buffer_size));
 	ep->num_scheduled = 0;
 	ep->this_schedule = 0;
 	ep->next_schedule = 0;
 	ep->soliciting = 0;
 	ep->armed = 0;
 	ep->xfer = usbd_alloc_xfer(sc->sc_udev);
 	if (ep->xfer == NULL) {
 	    err = USBD_NOMEM;
 	    goto quit;
+	}
 	ep->buffer = usbd_alloc_buffer(ep->xfer, ep->buffer_size);
 	if (ep->buffer == NULL) {
 	    usbd_free_xfer(ep->xfer);
 	    err = USBD_NOMEM;
 	    goto quit;
+	}
 	ep->next_slot = ep->buffer;
-	err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe);
+	err = usbd_open_pipe(sc->sc_iface, ep->addr, USBD_MPSAFE, &ep->pipe);
 	if (err)
 	    usbd_free_xfer(ep->xfer);
 	ep->solicit_cookie = softint_establish(SOFTINT_CLOCK, out_solicit, ep);
 quit:
 	return err;
+}
 static void
 free_pipe(struct umidi_endpoint *ep)
+{
 	DPRINTF(("%s: free_pipe %p\n", device_xname(ep->sc->sc_dev), ep));
 	usbd_abort_pipe(ep->pipe);
 	usbd_close_pipe(ep->pipe);
 	usbd_free_xfer(ep->xfer);
 	softint_disestablish(ep->solicit_cookie);
+}
 /* alloc/free the array of endpoint structures */
 static usbd_status alloc_all_endpoints_fixed_ep(struct umidi_softc *);
 static usbd_status alloc_all_endpoints_yamaha(struct umidi_softc *);
 static usbd_status alloc_all_endpoints_genuine(struct umidi_softc *);
 static usbd_status
 alloc_all_endpoints(struct umidi_softc *sc)
+{
 	usbd_status err;
 	struct umidi_endpoint *ep;
 	int i;
 	if (UMQ_ISTYPE(sc, UMQ_TYPE_FIXED_EP)) {
 		err = alloc_all_endpoints_fixed_ep(sc);
 	} else if (UMQ_ISTYPE(sc, UMQ_TYPE_YAMAHA)) {
 		err = alloc_all_endpoints_yamaha(sc);
 	} else {
 		err = alloc_all_endpoints_genuine(sc);
+	}
 	if (err != USBD_NORMAL_COMPLETION)
 		return err;
 	ep = sc->sc_endpoints;
 	for (i = sc->sc_out_num_endpoints+sc->sc_in_num_endpoints; i > 0; i--) {
 		err = alloc_pipe(ep++);
 		if (err != USBD_NORMAL_COMPLETION) {
 			for (; ep != sc->sc_endpoints; ep--)
 				free_pipe(ep-1);
 			kmem_free(sc->sc_endpoints, sc->sc_endpoints_len);
 			sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL;
 			break;
+		}
+	}
 	return err;
+}
 static void
 free_all_endpoints(struct umidi_softc *sc)
+{
 	int i;
 	for (i=0; i<sc->sc_in_num_endpoints+sc->sc_out_num_endpoints; i++)
 		free_pipe(&sc->sc_endpoints[i]);
 	if (sc->sc_endpoints != NULL)
 		kmem_free(sc->sc_endpoints, sc->sc_endpoints_len);
 	sc->sc_endpoints = sc->sc_out_ep = sc->sc_in_ep = NULL;
+}
 static usbd_status
 alloc_all_endpoints_fixed_ep(struct umidi_softc *sc)
+{
 	usbd_status err;
 	const struct umq_fixed_ep_desc *fp;
 	struct umidi_endpoint *ep;
 	usb_endpoint_descriptor_t *epd;
 	int i;
 	fp = umidi_get_quirk_data_from_type(sc->sc_quirk,
 					    UMQ_TYPE_FIXED_EP);
 	sc->sc_out_num_jacks = 0;
 	sc->sc_in_num_jacks = 0;
 	sc->sc_out_num_endpoints = fp->num_out_ep;
 	sc->sc_in_num_endpoints = fp->num_in_ep;
 	sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc);
 	sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP);
 	if (!sc->sc_endpoints)
 		return USBD_NOMEM;
 	sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL;
 	sc->sc_in_ep =
 	    sc->sc_in_num_endpoints ?
 		sc->sc_endpoints+sc->sc_out_num_endpoints : NULL;
 	ep = &sc->sc_out_ep[0];
 	for (i = 0; i < sc->sc_out_num_endpoints; i++) {
 		epd = usbd_interface2endpoint_descriptor(
 			sc->sc_iface,
 			fp->out_ep[i].ep);
 		if (!epd) {
 			aprint_error_dev(sc->sc_dev,
 			    "cannot get endpoint descriptor(out:%d)\n",
 			     fp->out_ep[i].ep);
 			err = USBD_INVAL;
 			goto error;
+		}
 		if (UE_GET_XFERTYPE(epd->bmAttributes)!=UE_BULK ||
 		    UE_GET_DIR(epd->bEndpointAddress)!=UE_DIR_OUT) {
 			aprint_error_dev(sc->sc_dev, "illegal endpoint(out:%d)\n",
 			    fp->out_ep[i].ep);
 			err = USBD_INVAL;
 			goto error;
+		}
 		ep->sc = sc;
 		ep->addr = epd->bEndpointAddress;
 		ep->num_jacks = fp->out_ep[i].num_jacks;
 		sc->sc_out_num_jacks += fp->out_ep[i].num_jacks;
 		ep->num_open = 0;
 		ep++;
+	}
 	ep = &sc->sc_in_ep[0];
 	for (i = 0; i < sc->sc_in_num_endpoints; i++) {
 		epd = usbd_interface2endpoint_descriptor(
 			sc->sc_iface,
 			fp->in_ep[i].ep);
 		if (!epd) {
 			aprint_error_dev(sc->sc_dev,
 			    "cannot get endpoint descriptor(in:%d)\n",
 			     fp->in_ep[i].ep);
 			err = USBD_INVAL;
 			goto error;
+		}
 		/*
 		 * MIDISPORT_2X4 inputs on an interrupt rather than a bulk
 		 * endpoint.  The existing input logic in this driver seems
 		 * to work successfully if we just stop treating an interrupt
 		 * endpoint as illegal (or the in_progress status we get on
 		 * the initial transfer).  It does not seem necessary to
 		 * actually use the interrupt flavor of alloc_pipe or make
 		 * other serious rearrangements of logic.  I like that.
 		 */
 		switch ( UE_GET_XFERTYPE(epd->bmAttributes) ) {
 		case UE_BULK:
 		case UE_INTERRUPT:
 			if ( UE_DIR_IN == UE_GET_DIR(epd->bEndpointAddress) )
 				break;
 			/*FALLTHROUGH*/
 		default:
 			aprint_error_dev(sc->sc_dev,
 			    "illegal endpoint(in:%d)\n", fp->in_ep[i].ep);
 			err = USBD_INVAL;
 			goto error;
+		}
 		ep->sc = sc;
 		ep->addr = epd->bEndpointAddress;
 		ep->num_jacks = fp->in_ep[i].num_jacks;
 		sc->sc_in_num_jacks += fp->in_ep[i].num_jacks;
 		ep->num_open = 0;
 		ep++;
+	}
 	return USBD_NORMAL_COMPLETION;
 error:
 	kmem_free(sc->sc_endpoints, UMIDI_ENDPOINT_SIZE(sc));
 	sc->sc_endpoints = NULL;
 	return err;
+}
 static usbd_status
 alloc_all_endpoints_yamaha(struct umidi_softc *sc)
+{
 	/* This driver currently supports max 1in/1out bulk endpoints */
 	usb_descriptor_t *desc;
 	umidi_cs_descriptor_t *udesc;
 	usb_endpoint_descriptor_t *epd;
 	int out_addr, in_addr, i;
 	int dir;
 	size_t remain, descsize;
 	sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0;
 	out_addr = in_addr = 0;
 	/* detect endpoints */
 	desc = TO_D(usbd_get_interface_descriptor(sc->sc_iface));
 	for (i=(int)TO_IFD(desc)->bNumEndpoints-1; i>=0; i--) {
 		epd = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
 		KASSERT(epd != NULL);
 		if (UE_GET_XFERTYPE(epd->bmAttributes) == UE_BULK) {
 			dir = UE_GET_DIR(epd->bEndpointAddress);
 			if (dir==UE_DIR_OUT && !out_addr)
 				out_addr = epd->bEndpointAddress;
 			else if (dir==UE_DIR_IN && !in_addr)
 				in_addr = epd->bEndpointAddress;
+		}
+	}
 	udesc = (umidi_cs_descriptor_t *)NEXT_D(desc);
 	/* count jacks */
 	if (!(udesc->bDescriptorType==UDESC_CS_INTERFACE &&
 	      udesc->bDescriptorSubtype==UMIDI_MS_HEADER))
 		return USBD_INVAL;
 	remain = (size_t)UGETW(TO_CSIFD(udesc)->wTotalLength) -
 		(size_t)udesc->bLength;
 	udesc = (umidi_cs_descriptor_t *)NEXT_D(udesc);
 	while (remain >= sizeof(usb_descriptor_t)) {
 		descsize = udesc->bLength;
 		if (descsize>remain || descsize==0)
 			break;
 		if (udesc->bDescriptorType == UDESC_CS_INTERFACE &&
 		    remain >= UMIDI_JACK_DESCRIPTOR_SIZE) {
 			if (udesc->bDescriptorSubtype == UMIDI_OUT_JACK)
 				sc->sc_out_num_jacks++;
 			else if (udesc->bDescriptorSubtype == UMIDI_IN_JACK)
 				sc->sc_in_num_jacks++;
+		}
 		udesc = (umidi_cs_descriptor_t *)NEXT_D(udesc);
 		remain -= descsize;
+	}
 	/* validate some parameters */
 	if (sc->sc_out_num_jacks>UMIDI_MAX_EPJACKS)
 		sc->sc_out_num_jacks = UMIDI_MAX_EPJACKS;
 	if (sc->sc_in_num_jacks>UMIDI_MAX_EPJACKS)
 		sc->sc_in_num_jacks = UMIDI_MAX_EPJACKS;
 	if (sc->sc_out_num_jacks && out_addr) {
 		sc->sc_out_num_endpoints = 1;
 	} else {
 		sc->sc_out_num_endpoints = 0;
 		sc->sc_out_num_jacks = 0;
+	}
 	if (sc->sc_in_num_jacks && in_addr) {
 		sc->sc_in_num_endpoints = 1;
 	} else {
 		sc->sc_in_num_endpoints = 0;
 		sc->sc_in_num_jacks = 0;
+	}
 	sc->sc_endpoints_len = UMIDI_ENDPOINT_SIZE(sc);
 	sc->sc_endpoints = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP);
 	if (!sc->sc_endpoints)
 		return USBD_NOMEM;
 	if (sc->sc_out_num_endpoints) {
 		sc->sc_out_ep = sc->sc_endpoints;
 		sc->sc_out_ep->sc = sc;
 		sc->sc_out_ep->addr = out_addr;
 		sc->sc_out_ep->num_jacks = sc->sc_out_num_jacks;
 		sc->sc_out_ep->num_open = 0;
 	} else
 		sc->sc_out_ep = NULL;
 	if (sc->sc_in_num_endpoints) {
 		sc->sc_in_ep = sc->sc_endpoints+sc->sc_out_num_endpoints;
 		sc->sc_in_ep->sc = sc;
 		sc->sc_in_ep->addr = in_addr;
 		sc->sc_in_ep->num_jacks = sc->sc_in_num_jacks;
 		sc->sc_in_ep->num_open = 0;
 	} else
 		sc->sc_in_ep = NULL;
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 alloc_all_endpoints_genuine(struct umidi_softc *sc)
+{
 	usb_interface_descriptor_t *interface_desc;
 	usb_config_descriptor_t *config_desc;
 	usb_descriptor_t *desc;
 	int num_ep;
 	size_t remain, descsize;
 	struct umidi_endpoint *p, *q, *lowest, *endep, tmpep;
 	int epaddr;
 	interface_desc = usbd_get_interface_descriptor(sc->sc_iface);
 	num_ep = interface_desc->bNumEndpoints;
 	sc->sc_endpoints_len = sizeof(struct umidi_endpoint) * num_ep;
 	sc->sc_endpoints = p = kmem_zalloc(sc->sc_endpoints_len, KM_SLEEP);
 	if (!p)
 		return USBD_NOMEM;
 	sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0;
 	sc->sc_out_num_endpoints = sc->sc_in_num_endpoints = 0;
 	epaddr = -1;
 	/* get the list of endpoints for midi stream */
 	config_desc = usbd_get_config_descriptor(sc->sc_udev);
 	desc = (usb_descriptor_t *) config_desc;
 	remain = (size_t)UGETW(config_desc->wTotalLength);
 	while (remain>=sizeof(usb_descriptor_t)) {
 		descsize = desc->bLength;
 		if (descsize>remain || descsize==0)
 			break;
 		if (desc->bDescriptorType==UDESC_ENDPOINT &&
 		    remain>=USB_ENDPOINT_DESCRIPTOR_SIZE &&
 		    UE_GET_XFERTYPE(TO_EPD(desc)->bmAttributes) == UE_BULK) {
 			epaddr = TO_EPD(desc)->bEndpointAddress;
 		} else if (desc->bDescriptorType==UDESC_CS_ENDPOINT &&
 			   remain>=UMIDI_CS_ENDPOINT_DESCRIPTOR_SIZE &&
 			   epaddr!=-1) {
 			if (num_ep>0) {
 				num_ep--;
 				p->sc = sc;
 				p->addr = epaddr;
 				p->num_jacks = TO_CSEPD(desc)->bNumEmbMIDIJack;
 				if (UE_GET_DIR(epaddr)==UE_DIR_OUT) {
 					sc->sc_out_num_endpoints++;
 					sc->sc_out_num_jacks += p->num_jacks;
 				} else {
 					sc->sc_in_num_endpoints++;
 					sc->sc_in_num_jacks += p->num_jacks;
+				}
 				p++;
+			}
 		} else
 			epaddr = -1;
 		desc = NEXT_D(desc);
 		remain-=descsize;
+	}
 	/* sort endpoints */
 	num_ep = sc->sc_out_num_endpoints + sc->sc_in_num_endpoints;
 	p = sc->sc_endpoints;
 	endep = p + num_ep;
 	while (p<endep) {
 		lowest = p;
 		for (q=p+1; q<endep; q++) {
 			if ((UE_GET_DIR(lowest->addr)==UE_DIR_IN &&
 			     UE_GET_DIR(q->addr)==UE_DIR_OUT) ||
 			    ((UE_GET_DIR(lowest->addr)==
 			      UE_GET_DIR(q->addr)) &&
 			     (UE_GET_ADDR(lowest->addr)>
 			      UE_GET_ADDR(q->addr))))
 				lowest = q;
+		}
 		if (lowest != p) {
 			memcpy((void *)&tmpep, (void *)p, sizeof(tmpep));
 			memcpy((void *)p, (void *)lowest, sizeof(tmpep));
 			memcpy((void *)lowest, (void *)&tmpep, sizeof(tmpep));
+		}
 		p->num_open = 0;
 		p++;
+	}
 	sc->sc_out_ep = sc->sc_out_num_endpoints ? sc->sc_endpoints : NULL;
 	sc->sc_in_ep =
 	    sc->sc_in_num_endpoints ?
 		sc->sc_endpoints+sc->sc_out_num_endpoints : NULL;
 	return USBD_NORMAL_COMPLETION;
+}
 /*
  * jack stuffs
  */
 static usbd_status
 alloc_all_jacks(struct umidi_softc *sc)
+{
 	int i, j;
 	struct umidi_endpoint *ep;
 	struct umidi_jack *jack;
 	const unsigned char *cn_spec;
 	if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_PER_EP))
 		sc->cblnums_global = 0;
 	else if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_SEQ_GLOBAL))
 		sc->cblnums_global = 1;
 	else {
 		/*
 		 * I don't think this default is correct, but it preserves
 		 * the prior behavior of the code. That's why I defined two
 		 * complementary quirks. Any device for which the default
 		 * behavior is wrong can be made to work by giving it an
 		 * explicit quirk, and if a pattern ever develops (as I suspect
 		 * it will) that a lot of otherwise standard USB MIDI devices
 		 * need the CN_SEQ_PER_EP "quirk," then this default can be
 		 * changed to 0, and the only devices that will break are those
 		 * listing neither quirk, and they'll easily be fixed by giving
 		 * them the CN_SEQ_GLOBAL quirk.
 		 */
 		sc->cblnums_global = 1;
+	}
 	if (UMQ_ISTYPE(sc, UMQ_TYPE_CN_FIXED))
 		cn_spec = umidi_get_quirk_data_from_type(sc->sc_quirk,
 					    		 UMQ_TYPE_CN_FIXED);
 	else
 		cn_spec = NULL;
 	/* allocate/initialize structures */
 	sc->sc_jacks = kmem_zalloc(sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+
 						      sc->sc_out_num_jacks), KM_SLEEP);
 	if (!sc->sc_jacks)
 		return USBD_NOMEM;
 	sc->sc_out_jacks =
 	    sc->sc_out_num_jacks ? sc->sc_jacks : NULL;
 	sc->sc_in_jacks =
 	    sc->sc_in_num_jacks ? sc->sc_jacks+sc->sc_out_num_jacks : NULL;
 	jack = &sc->sc_out_jacks[0];
 	for (i = 0; i < sc->sc_out_num_jacks; i++) {
 		jack->opened = 0;
 		jack->binded = 0;
 		jack->arg = NULL;
 		jack->u.out.intr = NULL;
 		jack->midiman_ppkt = NULL;
 		if (sc->cblnums_global)
 			jack->cable_number = i;
 		jack++;
+	}
 	jack = &sc->sc_in_jacks[0];
 	for (i = 0; i < sc->sc_in_num_jacks; i++) {
 		jack->opened = 0;
 		jack->binded = 0;
 		jack->arg = NULL;
 		jack->u.in.intr = NULL;
 		if (sc->cblnums_global)
 			jack->cable_number = i;
 		jack++;
+	}
 	/* assign each jacks to each endpoints */
 	jack = &sc->sc_out_jacks[0];
 	ep = &sc->sc_out_ep[0];
 	for (i = 0; i < sc->sc_out_num_endpoints; i++) {
 		for (j = 0; j < ep->num_jacks; j++) {
 			jack->endpoint = ep;
 			if (cn_spec != NULL)
 				jack->cable_number = *cn_spec++;
 			else if (!sc->cblnums_global)
 				jack->cable_number = j;
 			ep->jacks[jack->cable_number] = jack;
 			jack++;
+		}
 		ep++;
+	}
 	jack = &sc->sc_in_jacks[0];
 	ep = &sc->sc_in_ep[0];
 	for (i = 0; i < sc->sc_in_num_endpoints; i++) {
 		for (j = 0; j < ep->num_jacks; j++) {
 			jack->endpoint = ep;
 			if (cn_spec != NULL)
 				jack->cable_number = *cn_spec++;
 			else if (!sc->cblnums_global)
 				jack->cable_number = j;
 			ep->jacks[jack->cable_number] = jack;
 			jack++;
+		}
 		ep++;
+	}
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 free_all_jacks(struct umidi_softc *sc)
+{
 	struct umidi_jack *jacks;
 	size_t len;
 	mutex_enter(&sc->sc_lock);
 	jacks = sc->sc_jacks;
 	len = sizeof(*sc->sc_out_jacks)*(sc->sc_in_num_jacks+sc->sc_out_num_jacks);
 	sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL;
 	mutex_exit(&sc->sc_lock);
 	if (jacks)
 		kmem_free(jacks, len);
+}
 static usbd_status
 bind_jacks_to_mididev(struct umidi_softc *sc,
 		      struct umidi_jack *out_jack,
 		      struct umidi_jack *in_jack,
 		      struct umidi_mididev *mididev)
+{
 	if ((out_jack && out_jack->binded) || (in_jack && in_jack->binded))
 		return USBD_IN_USE;
 	if (mididev->out_jack || mididev->in_jack)
 		return USBD_IN_USE;
 	if (out_jack)
 		out_jack->binded = 1;
 	if (in_jack)
 		in_jack->binded = 1;
 	mididev->in_jack = in_jack;
 	mididev->out_jack = out_jack;
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 unbind_jacks_from_mididev(struct umidi_mididev *mididev)
+{
 	if ((mididev->flags & FWRITE) && mididev->out_jack)
 		close_out_jack(mididev->out_jack);
 	if ((mididev->flags & FREAD) && mididev->in_jack)
 		close_in_jack(mididev->in_jack);
 	if (mididev->out_jack)
 		mididev->out_jack->binded = 0;
 	if (mididev->in_jack)
 		mididev->in_jack->binded = 0;
 	mididev->out_jack = mididev->in_jack = NULL;
+}
 static void
 unbind_all_jacks(struct umidi_softc *sc)
+{
 	int i;
 	if (sc->sc_mididevs)
 		for (i = 0; i < sc->sc_num_mididevs; i++)
 			unbind_jacks_from_mididev(&sc->sc_mididevs[i]);
+}
 static usbd_status
 assign_all_jacks_automatically(struct umidi_softc *sc)
+{
 	usbd_status err;
 	int i;
 	struct umidi_jack *out, *in;
 	const signed char *asg_spec;
 	err =
 	    alloc_all_mididevs(sc,
 			       max(sc->sc_out_num_jacks, sc->sc_in_num_jacks));
 	if (err!=USBD_NORMAL_COMPLETION)
 		return err;
 	if ( UMQ_ISTYPE(sc, UMQ_TYPE_MD_FIXED))
 		asg_spec = umidi_get_quirk_data_from_type(sc->sc_quirk,
 					    		  UMQ_TYPE_MD_FIXED);
 	else
 		asg_spec = NULL;
 	for (i = 0; i < sc->sc_num_mididevs; i++) {
 		if (asg_spec != NULL) {
 			if (*asg_spec == -1)
 				out = NULL;
 			else
 				out = &sc->sc_out_jacks[*asg_spec];
 			++ asg_spec;
 			if (*asg_spec == -1)
 				in = NULL;
 			else
 				in = &sc->sc_in_jacks[*asg_spec];
 			++ asg_spec;
 		} else {
 			out = (i<sc->sc_out_num_jacks) ? &sc->sc_out_jacks[i]
 			                               : NULL;
 			in = (i<sc->sc_in_num_jacks) ? &sc->sc_in_jacks[i]
 						     : NULL;
+		}
 		err = bind_jacks_to_mididev(sc, out, in, &sc->sc_mididevs[i]);
 		if (err!=USBD_NORMAL_COMPLETION) {
 			free_all_mididevs(sc);
 			return err;
+		}
+	}
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *))
+{
 	struct umidi_endpoint *ep = jack->endpoint;
 	struct umidi_softc *sc = ep->sc;
 	umidi_packet_bufp end;
 	int err;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	if (jack->opened)
 		return USBD_IN_USE;
 	jack->arg = arg;
 	jack->u.out.intr = intr;
 	jack->midiman_ppkt = NULL;
 	end = ep->buffer + ep->buffer_size / sizeof *ep->buffer;
 	jack->opened = 1;
 	ep->num_open++;
 	/*
 	 * out_solicit maintains an invariant that there will always be
 	 * (num_open - num_scheduled) slots free in the buffer. as we have
 	 * just incremented num_open, the buffer may be too full to satisfy
 	 * the invariant until a transfer completes, for which we must wait.
 	 */
 	while (end - ep->next_slot < ep->num_open - ep->num_scheduled) {
 		err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock,
 		     mstohz(10));
 		if (err) {
 			ep->num_open--;
 			jack->opened = 0;
 			return USBD_IOERROR;
+		}
+	}
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 open_in_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *, int))
+{
 	usbd_status err = USBD_NORMAL_COMPLETION;
 	struct umidi_endpoint *ep = jack->endpoint;
 	KASSERT(mutex_owned(&ep->sc->sc_lock));
 	if (jack->opened)
 		return USBD_IN_USE;
 	jack->arg = arg;
 	jack->u.in.intr = intr;
 	jack->opened = 1;
 	if (ep->num_open++ == 0 && UE_GET_DIR(ep->addr)==UE_DIR_IN) {
 		err = start_input_transfer(ep);
 		if (err != USBD_NORMAL_COMPLETION &&
 		    err != USBD_IN_PROGRESS) {
 			ep->num_open--;
+		}
+	}
 	return err;
+}
 static void
 close_out_jack(struct umidi_jack *jack)
+{
 	struct umidi_endpoint *ep;
 	struct umidi_softc *sc;
 	u_int16_t mask;
 	int err;
 	if (jack->opened) {
 		ep = jack->endpoint;
 		sc = ep->sc;
 		mutex_spin_enter(&sc->sc_lock);
 		mask = 1 << (jack->cable_number);
 		while (mask & (ep->this_schedule | ep->next_schedule)) {
 			err = cv_timedwait_sig(&sc->sc_cv, &sc->sc_lock,
 			     mstohz(10));
 			if (err)
 				break;
+		}
 		/*
 		 * We can re-enter this function from both close() and
 		 * detach().  Make sure only one of them does this part.
 		 */
 		if (jack->opened) {
 			jack->opened = 0;
 			jack->endpoint->num_open--;
 			ep->this_schedule &= ~mask;
 			ep->next_schedule &= ~mask;
+		}
 		mutex_spin_exit(&sc->sc_lock);
+	}
+}
 static void
 close_in_jack(struct umidi_jack *jack)
+{
 	if (jack->opened) {
 		jack->opened = 0;
 		if (--jack->endpoint->num_open == 0) {
 			usbd_abort_pipe(jack->endpoint->pipe);
+		}
+	}
+}
 static usbd_status
 attach_mididev(struct umidi_softc *sc, struct umidi_mididev *mididev)
+{
 	if (mididev->sc)
 		return USBD_IN_USE;
 	mididev->sc = sc;
 	describe_mididev(mididev);
 	mididev->mdev = midi_attach_mi(&umidi_hw_if, mididev, sc->sc_dev);
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 detach_mididev(struct umidi_mididev *mididev, int flags)
+{
 	if (!mididev->sc)
 		return USBD_NO_ADDR;
 	if (mididev->opened) {
 		umidi_close(mididev);
+	}
 	unbind_jacks_from_mididev(mididev);
 	if (mididev->mdev != NULL)
 		config_detach(mididev->mdev, flags);
 	if (NULL != mididev->label) {
 		kmem_free(mididev->label, mididev->label_len);
 		mididev->label = NULL;
+	}
 	mididev->sc = NULL;
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 deactivate_mididev(struct umidi_mididev *mididev)
+{
 	if (mididev->out_jack)
 		mididev->out_jack->binded = 0;
 	if (mididev->in_jack)
 		mididev->in_jack->binded = 0;
+}
 static usbd_status
 alloc_all_mididevs(struct umidi_softc *sc, int nmidi)
+{
 	sc->sc_num_mididevs = nmidi;
 	sc->sc_mididevs = kmem_zalloc(sizeof(*sc->sc_mididevs)*nmidi, KM_SLEEP);
 	if (!sc->sc_mididevs)
 		return USBD_NOMEM;
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 free_all_mididevs(struct umidi_softc *sc)
+{
 	if (sc->sc_mididevs)
 		kmem_free(sc->sc_mididevs,
 			  sizeof(*sc->sc_mididevs)*sc->sc_num_mididevs);
 	sc->sc_num_mididevs = 0;
+}
 static usbd_status
 attach_all_mididevs(struct umidi_softc *sc)
+{
 	usbd_status err;
 	int i;
 	if (sc->sc_mididevs)
 		for (i = 0; i < sc->sc_num_mididevs; i++) {
 			err = attach_mididev(sc, &sc->sc_mididevs[i]);
 			if (err != USBD_NORMAL_COMPLETION)
 				return err;
+		}
 	return USBD_NORMAL_COMPLETION;
+}
 static usbd_status
 detach_all_mididevs(struct umidi_softc *sc, int flags)
+{
 	usbd_status err;
 	int i;
 	if (sc->sc_mididevs)
 		for (i = 0; i < sc->sc_num_mididevs; i++) {
 			err = detach_mididev(&sc->sc_mididevs[i], flags);
 			if (err != USBD_NORMAL_COMPLETION)
 				return err;
+		}
 	return USBD_NORMAL_COMPLETION;
+}
 static void
 deactivate_all_mididevs(struct umidi_softc *sc)
+{
 	int i;
 	if (sc->sc_mididevs) {
 		for (i = 0; i < sc->sc_num_mididevs; i++)
 			deactivate_mididev(&sc->sc_mididevs[i]);
+	}
+}
 /*
  * TODO: the 0-based cable numbers will often not match the labeling of the
  * equipment. Ideally:
  *  For class-compliant devices: get the iJack string from the jack descriptor.
  *  Otherwise:
  *  - support a DISPLAY_BASE_CN quirk (add the value to each internal cable
  *    number for display)
  *  - support an array quirk explictly giving a char * for each jack.
  * For now, you get 0-based cable numbers. If there are multiple endpoints and
  * the CNs are not globally unique, each is shown with its associated endpoint
  * address in hex also. That should not be necessary when using iJack values
  * or a quirk array.
  */
 void
 describe_mididev(struct umidi_mididev *md)
+{
 	char in_label[16];
 	char out_label[16];
 	const char *unit_label;
 	char *final_label;
 	struct umidi_softc *sc;
 	int show_ep_in;
 	int show_ep_out;
 	size_t len;
 	sc = md->sc;
 	show_ep_in  = sc-> sc_in_num_endpoints > 1 && !sc->cblnums_global;
 	show_ep_out = sc->sc_out_num_endpoints > 1 && !sc->cblnums_global;
 	if ( NULL == md->in_jack )
 		in_label[0] = '\0';
 	else if ( show_ep_in )
 		snprintf(in_label, sizeof in_label, "<%d(%x) ",
 		    md->in_jack->cable_number, md->in_jack->endpoint->addr);
 	else
 		snprintf(in_label, sizeof in_label, "<%d ",
 		    md->in_jack->cable_number);
 	if ( NULL == md->out_jack )
 		out_label[0] = '\0';
 	else if ( show_ep_out )
 		snprintf(out_label, sizeof out_label, ">%d(%x) ",
 		    md->out_jack->cable_number, md->out_jack->endpoint->addr);
 	else
 		snprintf(out_label, sizeof out_label, ">%d ",
 		    md->out_jack->cable_number);
 	unit_label = device_xname(sc->sc_dev);
 	len = strlen(in_label) + strlen(out_label) + strlen(unit_label) + 4;
 	final_label = kmem_alloc(len, KM_SLEEP);
 	snprintf(final_label, len, "%s%son %s",
 	    in_label, out_label, unit_label);
 	md->label = final_label;
 	md->label_len = len;
+}
 #ifdef UMIDI_DEBUG
 static void
 dump_sc(struct umidi_softc *sc)
+{
 	int i;
 	DPRINTFN(10, ("%s: dump_sc\n", device_xname(sc->sc_dev)));
 	for (i=0; i<sc->sc_out_num_endpoints; i++) {
 		DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i]));
 		dump_ep(&sc->sc_out_ep[i]);
+	}
 	for (i=0; i<sc->sc_in_num_endpoints; i++) {
 		DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i]));
 		dump_ep(&sc->sc_in_ep[i]);
+	}
+}
 static void
 dump_ep(struct umidi_endpoint *ep)
+{
 	int i;
 	for (i=0; i<UMIDI_MAX_EPJACKS; i++) {
 		if (NULL==ep->jacks[i])
 			continue;
 		DPRINTFN(10, ("\t\tjack[%d]:%p:\n", i, ep->jacks[i]));
 		dump_jack(ep->jacks[i]);
+	}
+}
 static void
 dump_jack(struct umidi_jack *jack)
+{
 	DPRINTFN(10, ("\t\t\tep=%p\n",
 		      jack->endpoint));
+}
 #endif /* UMIDI_DEBUG */
 /*
  * MUX MIDI PACKET
  */
 static const int packet_length[16] = {
 	/*0*/	-1,
 	/*1*/	-1,
 	/*2*/	2,
 	/*3*/	3,
 	/*4*/	3,
 	/*5*/	1,
 	/*6*/	2,
 	/*7*/	3,
 	/*8*/	3,
 	/*9*/	3,
 	/*A*/	3,
 	/*B*/	3,
 	/*C*/	2,
 	/*D*/	2,
 	/*E*/	3,
 	/*F*/	1,
 };
 #define	GET_CN(p)		(((unsigned char)(p)>>4)&0x0F)
 #define GET_CIN(p)		((unsigned char)(p)&0x0F)
 #define MIX_CN_CIN(cn, cin) \
 	((unsigned char)((((unsigned char)(cn)&0x0F)<<4)| \
 			  ((unsigned char)(cin)&0x0F)))
 static usbd_status
 start_input_transfer(struct umidi_endpoint *ep)
+{
 	usbd_setup_xfer(ep->xfer, ep->pipe,
 			(usbd_private_handle)ep,
 			ep->buffer, ep->buffer_size,
 			USBD_SHORT_XFER_OK | USBD_NO_COPY,
                         USBD_NO_TIMEOUT, in_intr);
 	return usbd_transfer(ep->xfer);
+}
 static usbd_status
 start_output_transfer(struct umidi_endpoint *ep)
+{
 	usbd_status rv;
 	u_int32_t length;
 	int i;
 	length = (ep->next_slot - ep->buffer) * sizeof *ep->buffer;
 	DPRINTFN(200,("umidi out transfer: start %p end %p length %u\n",
 	    ep->buffer, ep->next_slot, length));
 	usbd_setup_xfer(ep->xfer, ep->pipe,
 			(usbd_private_handle)ep,
 			ep->buffer, length,
 			USBD_NO_COPY, USBD_NO_TIMEOUT, out_intr);
 	rv = usbd_transfer(ep->xfer);
 	/*
 	 * Once the transfer is scheduled, no more adding to partial
 	 * packets within it.
 	 */
 	if (UMQ_ISTYPE(ep->sc, UMQ_TYPE_MIDIMAN_GARBLE)) {
 		for (i=0; i<UMIDI_MAX_EPJACKS; ++i)
 			if (NULL != ep->jacks[i])
 				ep->jacks[i]->midiman_ppkt = NULL;
+	}
 	return rv;
+}
 #ifdef UMIDI_DEBUG
 #define DPR_PACKET(dir, sc, p)						\
 if ((unsigned char)(p)[1]!=0xFE)				\
 	DPRINTFN(500,							\
 		 ("%s: umidi packet(" #dir "): %02X %02X %02X %02X\n",	\
 		  device_xname(sc->sc_dev),				\
 		  (unsigned char)(p)[0],			\
 		  (unsigned char)(p)[1],			\
 		  (unsigned char)(p)[2],			\
 		  (unsigned char)(p)[3]));
 #else
 #define DPR_PACKET(dir, sc, p)
 #endif
 /*
  * A 4-byte Midiman packet superficially resembles a 4-byte USB MIDI packet
  * with the cable number and length in the last byte instead of the first,
  * but there the resemblance ends. Where a USB MIDI packet is a semantic
  * unit, a Midiman packet is just a wrapper for 1 to 3 bytes of raw MIDI
  * with a cable nybble and a length nybble (which, unlike the CIN of a
  * real USB MIDI packet, has no semantics at all besides the length).
  * A packet received from a Midiman may contain part of a MIDI message,
  * more than one MIDI message, or parts of more than one MIDI message. A
  * three-byte MIDI message may arrive in three packets of data length 1, and
  * running status may be used. Happily, the midi(4) driver above us will put
  * it all back together, so the only cost is in USB bandwidth. The device
  * has an easier time with what it receives from us: we'll pack messages in
  * and across packets, but filling the packets whenever possible and,
  * as midi(4) hands us a complete message at a time, we'll never send one
  * in a dribble of short packets.
  */
 static int
 out_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin)
+{
 	struct umidi_endpoint *ep = out_jack->endpoint;
 	struct umidi_softc *sc = ep->sc;
 	unsigned char *packet;
 	int plen;
 	int poff;
 	if (sc->sc_dying)
 		return EIO;
 	if (!out_jack->opened)
 		return ENODEV; /* XXX as it was, is this the right errno? */
 #ifdef UMIDI_DEBUG