 @@ -1,1192 +1,1186 @@
-/*	$NetBSD: sl811hs.c,v 1.96 2016/09/24 15:06:29 skrll Exp $	*/
+/*	$NetBSD: sl811hs.c,v 1.97 2016/10/01 13:46:52 christos Exp $	*/
 /*
  * Not (c) 2007 Matthew Orgass
  * This file is public domain, meaning anyone can make any use of part or all
  * of this file including copying into other works without credit.  Any use,
  * modified or not, is solely the responsibility of the user.  If this file is
  * part of a collection then use in the collection is governed by the terms of
  * the collection.
  */
 /*
  * Cypress/ScanLogic SL811HS/T USB Host Controller
  * Datasheet, Errata, and App Note available at www.cypress.com
+ *
  * Uses: Ratoc CFU1U PCMCIA USB Host Controller, Nereid X68k USB HC, ISA
  * HCs.  The Ratoc CFU2 uses a different chip.
+ *
  * This chip puts the serial in USB.  It implements USB by means of an eight
  * bit I/O interface.  It can be used for ISA, PCMCIA/CF, parallel port,
  * serial port, or any eight bit interface.  It has 256 bytes of memory, the
  * first 16 of which are used for register access.  There are two sets of
  * registers for sending individual bus transactions.  Because USB is polled,
  * this organization means that some amount of card access must often be made
  * when devices are attached, even if when they are not directly being used.
  * A per-ms frame interrupt is necessary and many devices will poll with a
  * per-frame bulk transfer.
+ *
  * It is possible to write a little over two bytes to the chip (auto
  * incremented) per full speed byte time on the USB.  Unfortunately,
  * auto-increment does not work reliably so write and bus speed is
  * approximately the same for full speed devices.
+ *
  * In addition to the 240 byte packet size limit for isochronous transfers,
  * this chip has no means of determining the current frame number other than
  * getting all 1ms SOF interrupts, which is not always possible even on a fast
  * system.  Isochronous transfers guarantee that transfers will never be
  * retried in a later frame, so this can cause problems with devices beyond
  * the difficulty in actually performing the transfer most frames.  I tried
  * implementing isoc transfers and was able to play CD-derrived audio via an
  * iMic on a 2GHz PC, however it would still be interrupted at times and
  * once interrupted, would stay out of sync.  All isoc support has been
  * removed.
+ *
  * BUGS: all chip revisions have problems with low speed devices through hubs.
  * The chip stops generating SOF with hubs that send SE0 during SOF.  See
  * comment in dointr().  All performance enhancing features of this chip seem
  * not to work properly, most confirmed buggy in errata doc.
+ *
  */
 /*
  * The hard interrupt is the main entry point.  Start, callbacks, and repeat
  * are the only others called frequently.
+ *
  * Since this driver attaches to pcmcia, card removal at any point should be
  * expected and not cause panics or infinite loops.
  */
 /*
  * XXX TODO:
  *   copy next output packet while transfering
  *   usb suspend
  *   could keep track of known values of all buffer space?
  *   combined print/log function for errors
+ *
  *   ub_usepolling support is untested and may not work
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sl811hs.c,v 1.96 2016/09/24 15:06:29 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sl811hs.c,v 1.97 2016/10/01 13:46:52 christos Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_slhci.h"
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/gcq.h>
 #include <sys/intr.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdivar.h>
 #include <dev/usb/usbhist.h>
 #include <dev/usb/usb_mem.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/usbroothub.h>
 #include <dev/ic/sl811hsreg.h>
 #include <dev/ic/sl811hsvar.h>
 #define Q_CB 0				/* Control/Bulk */
 #define Q_NEXT_CB 1
 #define Q_MAX_XFER Q_CB
 #define Q_CALLBACKS 2
 #define Q_MAX Q_CALLBACKS
 #define F_AREADY		(0x00000001)
 #define F_BREADY		(0x00000002)
 #define F_AINPROG		(0x00000004)
 #define F_BINPROG		(0x00000008)
 #define F_LOWSPEED		(0x00000010)
 #define F_UDISABLED		(0x00000020) /* Consider disabled for USB */
 #define F_NODEV			(0x00000040)
 #define F_ROOTINTR		(0x00000080)
 #define F_REALPOWER		(0x00000100) /* Actual power state */
 #define F_POWER			(0x00000200) /* USB reported power state */
 #define F_ACTIVE		(0x00000400)
 #define F_CALLBACK		(0x00000800) /* Callback scheduled */
 #define F_SOFCHECK1		(0x00001000)
 #define F_SOFCHECK2		(0x00002000)
 #define F_CRESET		(0x00004000) /* Reset done not reported */
 #define F_CCONNECT		(0x00008000) /* Connect change not reported */
 #define F_RESET			(0x00010000)
 #define F_ISOC_WARNED		(0x00020000)
 #define F_LSVH_WARNED		(0x00040000)
 #define F_DISABLED		(F_NODEV|F_UDISABLED)
 #define F_CHANGE		(F_CRESET|F_CCONNECT)
 #ifdef SLHCI_TRY_LSVH
 unsigned int slhci_try_lsvh = 1;
 #else
 unsigned int slhci_try_lsvh = 0;
 #endif
 #define ADR 0
 #define LEN 1
 #define PID 2
 #define DEV 3
 #define STAT 2
 #define CONT 3
 #define A 0
 #define B 1
 static const uint8_t slhci_tregs[2][4] =
 {{SL11_E0ADDR, SL11_E0LEN, SL11_E0PID, SL11_E0DEV },
  {SL11_E1ADDR, SL11_E1LEN, SL11_E1PID, SL11_E1DEV }};
 #define PT_ROOT_CTRL	0
 #define PT_ROOT_INTR	1
 #define PT_CTRL_SETUP	2
 #define PT_CTRL_DATA	3
 #define PT_CTRL_STATUS	4
 #define PT_INTR		5
 #define PT_BULK		6
 #define PT_MAX		6
 #ifdef SLHCI_DEBUG
 #define SLHCI_MEM_ACCOUNTING
 #endif
 /*
  * Maximum allowable reserved bus time.  Since intr/isoc transfers have
  * unconditional priority, this is all that ensures control and bulk transfers
  * get a chance.  It is a single value for all frames since all transfers can
  * use multiple consecutive frames if an error is encountered.  Note that it
  * is not really possible to fill the bus with transfers, so this value should
  * be on the low side.  Defaults to giving a warning unless SLHCI_NO_OVERTIME
  * is defined.  Full time is 12000 - END_BUSTIME.
  */
 #ifndef SLHCI_RESERVED_BUSTIME
 #define SLHCI_RESERVED_BUSTIME 5000
 #endif
 /*
  * Rate for "exceeds reserved bus time" warnings (default) or errors.
  * Warnings only happen when an endpoint open causes the time to go above
  * SLHCI_RESERVED_BUSTIME, not if it is already above.
  */
 #ifndef SLHCI_OVERTIME_WARNING_RATE
 #define SLHCI_OVERTIME_WARNING_RATE { 60, 0 } /* 60 seconds */
 #endif
 static const struct timeval reserved_warn_rate = SLHCI_OVERTIME_WARNING_RATE;
 /* Rate for overflow warnings */
 #ifndef SLHCI_OVERFLOW_WARNING_RATE
 #define SLHCI_OVERFLOW_WARNING_RATE { 60, 0 } /* 60 seconds */
 #endif
 static const struct timeval overflow_warn_rate = SLHCI_OVERFLOW_WARNING_RATE;
 /*
  * For EOF, the spec says 42 bit times, plus (I think) a possible hub skew of
  * 20 bit times.  By default leave 66 bit times to start the transfer beyond
  * the required time.  Units are full-speed bit times (a bit over 5us per 64).
  * Only multiples of 64 are significant.
  */
 #define SLHCI_STANDARD_END_BUSTIME 128
 #ifndef SLHCI_EXTRA_END_BUSTIME
 #define SLHCI_EXTRA_END_BUSTIME 0
 #endif
 #define SLHCI_END_BUSTIME (SLHCI_STANDARD_END_BUSTIME+SLHCI_EXTRA_END_BUSTIME)
 /*
  * This is an approximation of the USB worst-case timings presented on p. 54 of
  * the USB 1.1 spec translated to full speed bit times.
  * FS = full speed with handshake, FSII = isoc in, FSIO = isoc out,
  * FSI = isoc (worst case), LS = low speed
  */
 #define SLHCI_FS_CONST		114
 #define SLHCI_FSII_CONST	92
 #define SLHCI_FSIO_CONST	80
 #define SLHCI_FSI_CONST		92
 #define SLHCI_LS_CONST		804
 #ifndef SLHCI_PRECICE_BUSTIME
 /*
  * These values are < 3% too high (compared to the multiply and divide) for
  * max sized packets.
  */
 #define SLHCI_FS_DATA_TIME(len) (((u_int)(len)<<3)+(len)+((len)>>1))
 #define SLHCI_LS_DATA_TIME(len) (((u_int)(len)<<6)+((u_int)(len)<<4))
 #else
 #define SLHCI_FS_DATA_TIME(len) (56*(len)/6)
 #define SLHCI_LS_DATA_TIME(len) (449*(len)/6)
 #endif
 /*
  * Set SLHCI_WAIT_SIZE to the desired maximum size of single FS transfer
  * to poll for after starting a transfer.  64 gets all full speed transfers.
  * Note that even if 0 polling will occur if data equal or greater than the
  * transfer size is copied to the chip while the transfer is in progress.
  * Setting SLHCI_WAIT_TIME to -12000 will disable polling.
  */
 #ifndef SLHCI_WAIT_SIZE
 #define SLHCI_WAIT_SIZE 8
 #endif
 #ifndef SLHCI_WAIT_TIME
 #define SLHCI_WAIT_TIME (SLHCI_FS_CONST + \
     SLHCI_FS_DATA_TIME(SLHCI_WAIT_SIZE))
 #endif
 const int slhci_wait_time = SLHCI_WAIT_TIME;
 #ifndef SLHCI_MAX_RETRIES
 #define SLHCI_MAX_RETRIES 3
 #endif
 /* Check IER values for corruption after this many unrecognized interrupts. */
 #ifndef SLHCI_IER_CHECK_FREQUENCY
 #ifdef SLHCI_DEBUG
 #define SLHCI_IER_CHECK_FREQUENCY 1
 #else
 #define SLHCI_IER_CHECK_FREQUENCY 100
 #endif
 #endif
 /* Note that buffer points to the start of the buffer for this transfer.  */
 struct slhci_pipe {
 	struct usbd_pipe pipe;
 	struct usbd_xfer *xfer;		/* xfer in progress */
 	uint8_t		*buffer;	/* I/O buffer (if needed) */
 	struct gcq 	ap;		/* All pipes */
 	struct gcq 	to;		/* Timeout list */
 	struct gcq 	xq;		/* Xfer queues */
 	unsigned int	pflags;		/* Pipe flags */
 #define PF_GONE		(0x01)		/* Pipe is on disabled device */
 #define PF_TOGGLE 	(0x02)		/* Data toggle status */
 #define PF_LS		(0x04)		/* Pipe is low speed */
 #define PF_PREAMBLE	(0x08)		/* Needs preamble */
 	Frame		to_frame;	/* Frame number for timeout */
 	Frame		frame;		/* Frame number for intr xfer */
 	Frame		lastframe;	/* Previous frame number for intr */
 	uint16_t	bustime;	/* Worst case bus time usage */
 	uint16_t	newbustime[2];	/* new bustimes (see index below) */
 	uint8_t		tregs[4];	/* ADR, LEN, PID, DEV */
 	uint8_t		newlen[2];	/* 0 = short data, 1 = ctrl data */
 	uint8_t		newpid;		/* for ctrl */
 	uint8_t		wantshort;	/* last xfer must be short */
 	uint8_t		control;	/* Host control register settings */
 	uint8_t		nerrs;		/* Current number of errors */
 	uint8_t 	ptype;		/* Pipe type */
 };
 #define SLHCI_BUS2SC(bus)	((bus)->ub_hcpriv)
 #define SLHCI_PIPE2SC(pipe)	SLHCI_BUS2SC((pipe)->up_dev->ud_bus)
 #define SLHCI_XFER2SC(xfer)	SLHCI_BUS2SC((xfer)->ux_bus)
 #define SLHCI_PIPE2SPIPE(pipe)	((struct slhci_pipe *)(pipe))
 #define SLHCI_XFER2SPIPE(xfer)	SLHCI_PIPE2SPIPE((xfer)->ux_pipe)
 #define SLHCI_XFER_TYPE(x)	(SLHCI_XFER2SPIPE(xfer)->ptype)
 #ifdef SLHCI_PROFILE_TRANSFER
 #if defined(__mips__)
 /*
  * MIPS cycle counter does not directly count cpu cycles but is a different
  * fraction of cpu cycles depending on the cpu.
  */
 typedef uint32_t cc_type;
 #define CC_TYPE_FMT "%u"
 #define slhci_cc_set(x) __asm volatile ("mfc0 %[cc], $9\n\tnop\n\tnop\n\tnop" \
     : [cc] "=r"(x))
 #elif defined(__i386__)
 typedef uint64_t cc_type;
 #define CC_TYPE_FMT "%llu"
 #define slhci_cc_set(x) __asm volatile ("rdtsc" : "=A"(x))
 #else
 #error "SLHCI_PROFILE_TRANSFER not implemented on this MACHINE_ARCH (see sys/dev/ic/sl811hs.c)"
 #endif
 struct slhci_cc_time {
 	cc_type start;
 	cc_type stop;
 	unsigned int miscdata;
 };
 #ifndef SLHCI_N_TIMES
 #define SLHCI_N_TIMES 200
 #endif
 struct slhci_cc_times {
 	struct slhci_cc_time times[SLHCI_N_TIMES];
 	int current;
 	int wraparound;
 };
 static struct slhci_cc_times t_ab[2];
 static struct slhci_cc_times t_abdone;
 static struct slhci_cc_times t_copy_to_dev;
 static struct slhci_cc_times t_copy_from_dev;
 static struct slhci_cc_times t_intr;
 static struct slhci_cc_times t_lock;
 static struct slhci_cc_times t_delay;
 static struct slhci_cc_times t_hard_int;
 static struct slhci_cc_times t_callback;
 static inline void
 start_cc_time(struct slhci_cc_times *times, unsigned int misc) {
 	times->times[times->current].miscdata = misc;
 	slhci_cc_set(times->times[times->current].start);
+}
 static inline void
 stop_cc_time(struct slhci_cc_times *times) {
 	slhci_cc_set(times->times[times->current].stop);
 	if (++times->current >= SLHCI_N_TIMES) {
 		times->current = 0;
 		times->wraparound = 1;
+	}
+}
 void slhci_dump_cc_times(int);
 void
 slhci_dump_cc_times(int n) {
 	struct slhci_cc_times *times;
 	int i;
 	switch (n) {
 	default:
 	case 0:
 		printf("USBA start transfer to intr:\n");
 		times = &t_ab[A];
 		break;
 	case 1:
 		printf("USBB start transfer to intr:\n");
 		times = &t_ab[B];
 		break;
 	case 2:
 		printf("abdone:\n");
 		times = &t_abdone;
 		break;
 	case 3:
 		printf("copy to device:\n");
 		times = &t_copy_to_dev;
 		break;
 	case 4:
 		printf("copy from device:\n");
 		times = &t_copy_from_dev;
 		break;
 	case 5:
 		printf("intr to intr:\n");
 		times = &t_intr;
 		break;
 	case 6:
 		printf("lock to release:\n");
 		times = &t_lock;
 		break;
 	case 7:
 		printf("delay time:\n");
 		times = &t_delay;
 		break;
 	case 8:
 		printf("hard interrupt enter to exit:\n");
 		times = &t_hard_int;
 		break;
 	case 9:
 		printf("callback:\n");
 		times = &t_callback;
 		break;
+	}
 	if (times->wraparound)
 		for (i = times->current + 1; i < SLHCI_N_TIMES; i++)
 			printf("start " CC_TYPE_FMT " stop " CC_TYPE_FMT
 			    " difference %8i miscdata %#x\n",
 			    times->times[i].start, times->times[i].stop,
 			    (int)(times->times[i].stop -
 			    times->times[i].start), times->times[i].miscdata);
 	for (i = 0; i < times->current; i++)
 		printf("start " CC_TYPE_FMT " stop " CC_TYPE_FMT
 		    " difference %8i miscdata %#x\n", times->times[i].start,
 		    times->times[i].stop, (int)(times->times[i].stop -
 		    times->times[i].start), times->times[i].miscdata);
+}
 #else
 #define start_cc_time(x, y)
 #define stop_cc_time(x)
 #endif /* SLHCI_PROFILE_TRANSFER */
 typedef usbd_status (*LockCallFunc)(struct slhci_softc *, struct slhci_pipe
     *, struct usbd_xfer *);
 struct usbd_xfer * slhci_allocx(struct usbd_bus *, unsigned int);
 void slhci_freex(struct usbd_bus *, struct usbd_xfer *);
 static void slhci_get_lock(struct usbd_bus *, kmutex_t **);
 usbd_status slhci_transfer(struct usbd_xfer *);
 usbd_status slhci_start(struct usbd_xfer *);
 usbd_status slhci_root_start(struct usbd_xfer *);
 usbd_status slhci_open(struct usbd_pipe *);
 static int slhci_roothub_ctrl(struct usbd_bus *, usb_device_request_t *,
     void *, int);
 /*
  * slhci_supported_rev, slhci_preinit, slhci_attach, slhci_detach,
  * slhci_activate
  */
 void slhci_abort(struct usbd_xfer *);
 void slhci_close(struct usbd_pipe *);
 void slhci_clear_toggle(struct usbd_pipe *);
 void slhci_poll(struct usbd_bus *);
 void slhci_done(struct usbd_xfer *);
 void slhci_void(void *);
 /* lock entry functions */
 #ifdef SLHCI_MEM_ACCOUNTING
 void slhci_mem_use(struct usbd_bus *, int);
 #endif
 void slhci_reset_entry(void *);
 usbd_status slhci_lock_call(struct slhci_softc *, LockCallFunc,
     struct slhci_pipe *, struct usbd_xfer *);
 void slhci_start_entry(struct slhci_softc *, struct slhci_pipe *);
 void slhci_callback_entry(void *arg);
 void slhci_do_callback(struct slhci_softc *, struct usbd_xfer *);
 /* slhci_intr */
 void slhci_main(struct slhci_softc *);
 /* in lock functions */
 static void slhci_write(struct slhci_softc *, uint8_t, uint8_t);
 static uint8_t slhci_read(struct slhci_softc *, uint8_t);
 static void slhci_write_multi(struct slhci_softc *, uint8_t, uint8_t *, int);
 static void slhci_read_multi(struct slhci_softc *, uint8_t, uint8_t *, int);
 static void slhci_waitintr(struct slhci_softc *, int);
 static int slhci_dointr(struct slhci_softc *);
 static void slhci_abdone(struct slhci_softc *, int);
 static void slhci_tstart(struct slhci_softc *);
 static void slhci_dotransfer(struct slhci_softc *);
 static void slhci_callback(struct slhci_softc *);
 static void slhci_enter_xfer(struct slhci_softc *, struct slhci_pipe *);
 static void slhci_enter_xfers(struct slhci_softc *);
 static void slhci_queue_timed(struct slhci_softc *, struct slhci_pipe *);
 static void slhci_xfer_timer(struct slhci_softc *, struct slhci_pipe *);
 static void slhci_callback_schedule(struct slhci_softc *);
 static void slhci_do_callback_schedule(struct slhci_softc *);
 #if 0
 void slhci_pollxfer(struct slhci_softc *, struct usbd_xfer *); /* XXX */
 #endif
 static usbd_status slhci_do_poll(struct slhci_softc *, struct slhci_pipe *,
     struct usbd_xfer *);
 static usbd_status slhci_lsvh_warn(struct slhci_softc *, struct slhci_pipe *,
     struct usbd_xfer *);
 static usbd_status slhci_isoc_warn(struct slhci_softc *, struct slhci_pipe *,
     struct usbd_xfer *);
 static usbd_status slhci_open_pipe(struct slhci_softc *, struct slhci_pipe *,
     struct usbd_xfer *);
 static usbd_status slhci_close_pipe(struct slhci_softc *, struct slhci_pipe *,
     struct usbd_xfer *);
 static usbd_status slhci_do_abort(struct slhci_softc *, struct slhci_pipe *,
     struct usbd_xfer *);
 static usbd_status slhci_halt(struct slhci_softc *, struct slhci_pipe *,
     struct usbd_xfer *);
 static void slhci_intrchange(struct slhci_softc *, uint8_t);
 static void slhci_drain(struct slhci_softc *);
 static void slhci_reset(struct slhci_softc *);
 static int slhci_reserve_bustime(struct slhci_softc *, struct slhci_pipe *,
     int);
 static void slhci_insert(struct slhci_softc *);
 static usbd_status slhci_clear_feature(struct slhci_softc *, unsigned int);
 static usbd_status slhci_set_feature(struct slhci_softc *, unsigned int);
 static void slhci_get_status(struct slhci_softc *, usb_port_status_t *);
 #define	SLHCIHIST_FUNC()	USBHIST_FUNC()
 #define	SLHCIHIST_CALLED()	USBHIST_CALLED(slhcidebug)
 #ifdef SLHCI_DEBUG
 static int slhci_memtest(struct slhci_softc *);
 void slhci_log_buffer(struct usbd_xfer *);
 void slhci_log_req(usb_device_request_t *);
 void slhci_log_dumpreg(void);
 void slhci_log_xfer(struct usbd_xfer *);
 void slhci_log_spipe(struct slhci_pipe *);
 void slhci_print_intr(void);
 void slhci_log_sc(void);
 void slhci_log_slreq(struct slhci_pipe *);
 /* Constified so you can read the values from ddb */
 const int SLHCI_D_TRACE =	0x0001;
 const int SLHCI_D_MSG = 	0x0002;
 const int SLHCI_D_XFER =	0x0004;
 const int SLHCI_D_MEM = 	0x0008;
 const int SLHCI_D_INTR =	0x0010;
 const int SLHCI_D_SXFER =	0x0020;
 const int SLHCI_D_ERR = 	0x0080;
 const int SLHCI_D_BUF = 	0x0100;
 const int SLHCI_D_SOFT =	0x0200;
 const int SLHCI_D_WAIT =	0x0400;
 const int SLHCI_D_ROOT =	0x0800;
 /* SOF/NAK alone normally ignored, SOF also needs D_INTR */
 const int SLHCI_D_SOF =		0x1000;
 const int SLHCI_D_NAK =		0x2000;
 int slhcidebug = 0x1cbc; /* 0xc8c; */ /* 0xffff; */ /* 0xd8c; */
 SYSCTL_SETUP(sysctl_hw_slhci_setup, "sysctl hw.slhci setup")
+{
 	int err;
 	const struct sysctlnode *rnode;
 	const struct sysctlnode *cnode;
 	err = sysctl_createv(clog, 0, NULL, &rnode,
 	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "slhci",
 	    SYSCTL_DESCR("slhci 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, &slhcidebug, sizeof(slhcidebug), CTL_CREATE, CTL_EOL);
 	if (err)
 		goto fail;
 	return;
 fail:
 	aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
+}
 struct slhci_softc *ssc;
 #define SLHCI_DEXEC(x, y) do { if ((slhcidebug & SLHCI_ ## x)) { y; } \
 } while (/*CONSTCOND*/ 0)
 #define DDOLOG(f, a, b, c, d) do { KERNHIST_LOG(usbhist, f, a, b, c, d); \
 } while (/*CONSTCOND*/0)
 #define DLOG(x, f, a, b, c, d) SLHCI_DEXEC(x, DDOLOG(f, a, b, c, d))
 /*
  * DDOLOGBUF logs a buffer up to 8 bytes at a time. No identifier so that we
  * can make it a real function.
  */
 static void
 DDOLOGBUF(uint8_t *buf, unsigned int length)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	int i;
 	for(i=0; i+8 <= length; i+=8)
 		DDOLOG("%.4x %.4x %.4x %.4x", (buf[i] << 8) | buf[i+1],
 		    (buf[i+2] << 8) | buf[i+3], (buf[i+4] << 8) | buf[i+5],
 		    (buf[i+6] << 8) | buf[i+7]);
 	if (length == i+7)
 		DDOLOG("%.4x %.4x %.4x %.2x", (buf[i] << 8) | buf[i+1],
 		    (buf[i+2] << 8) | buf[i+3], (buf[i+4] << 8) | buf[i+5],
 		    buf[i+6]);
 	else if (length == i+6)
 		DDOLOG("%.4x %.4x %.4x", (buf[i] << 8) | buf[i+1],
 		    (buf[i+2] << 8) | buf[i+3], (buf[i+4] << 8) | buf[i+5], 0);
 	else if (length == i+5)
 		DDOLOG("%.4x %.4x %.2x", (buf[i] << 8) | buf[i+1],
 		    (buf[i+2] << 8) | buf[i+3], buf[i+4], 0);
 	else if (length == i+4)
 		DDOLOG("%.4x %.4x", (buf[i] << 8) | buf[i+1],
 		    (buf[i+2] << 8) | buf[i+3], 0,0);
 	else if (length == i+3)
 		DDOLOG("%.4x %.2x", (buf[i] << 8) | buf[i+1], buf[i+2], 0,0);
 	else if (length == i+2)
 		DDOLOG("%.4x", (buf[i] << 8) | buf[i+1], 0,0,0);
 	else if (length == i+1)
 		DDOLOG("%.2x", buf[i], 0,0,0);
+}
 #define DLOGBUF(x, b, l) SLHCI_DEXEC(x, DDOLOGBUF(b, l))
 #define DDOLOGCTRL(x)	do {						\
     DDOLOG("CTRL suspend=%d", !!((x) & SL11_CTRL_SUSPEND), 0, 0, 0);	\
     DDOLOG("CTRL ls     =%d  jk     =%d  reset  =%d  sof    =%d",	\
 	!!((x) & SL11_CTRL_LOWSPEED), !!((x) & SL11_CTRL_JKSTATE),	\
 	!!((x) & SL11_CTRL_RESETENGINE), !!((x) & SL11_CTRL_ENABLESOF));\
 } while (0)
 #define DDOLOGISR(r)	do {						\
     DDOLOG("ISR  data   =%d  det/res=%d  insert =%d  sof    =%d",	\
 	!!((r) & SL11_ISR_DATA), !!((r) & SL11_ISR_RESUME),		\
 	!!((r) & SL11_ISR_INSERT), !!!!((r) & SL11_ISR_SOF));		\
     DDOLOG("ISR             babble =%d  usbb   =%d  usba   =%d",	\
 	!!((r) & SL11_ISR_BABBLE), !!((r) & SL11_ISR_USBB),		\
 	!!((r) & SL11_ISR_USBA), 0);					\
 } while (0)
 #define DDOLOGIER(r)	do {						\
     DDOLOG("IER              det/res=%d  insert =%d  sof    =%d",	\
 	!!((r) & SL11_IER_RESUME),					\
 	!!((r) & SL11_IER_INSERT), !!!!((r) & SL11_IER_SOF), 0);		\
     DDOLOG("IER              babble =%d  usbb   =%d  usba   =%d",	\
 	!!((r) & SL11_IER_BABBLE), !!((r) & SL11_IER_USBB),		\
 	!!((r) & SL11_IER_USBA), 0);					\
 } while (0)
 #define DDOLOGSTATUS(s)	do {						\
     DDOLOG("STAT stall   =%d  nak     =%d  overflow =%d  setup   =%d",	\
 	!!((s) & SL11_EPSTAT_STALL), !!((s) & SL11_EPSTAT_NAK),		\
 	!!((s) & SL11_EPSTAT_OVERFLOW), !!((s) & SL11_EPSTAT_SETUP));	\
     DDOLOG("STAT sequence=%d  timeout =%d  error    =%d  ack     =%d",	\
 	!!((s) & SL11_EPSTAT_SEQUENCE),	!!((s) & SL11_EPSTAT_TIMEOUT),	\
 	!!((s) & SL11_EPSTAT_ERROR), !!((s) & SL11_EPSTAT_ACK));	\
 } while (0)
 #define DDOLOGEPCTRL(r)	do {						\
     DDOLOG("CTRL preamble=%d  toggle  =%d  sof     =%d  iso     =%d",	\
 	!!((r) & SL11_EPCTRL_PREAMBLE), !!((r) & SL11_EPCTRL_DATATOGGLE),\
 	!!((r) & SL11_EPCTRL_SOF), !!((r) & SL11_EPCTRL_ISO));		\
     DDOLOG("CTRL              out     =%d  enable  =%d  arm     =%d",	\
 	!!((r) & SL11_EPCTRL_DIRECTION),				\
 	!!((r) & SL11_EPCTRL_ENABLE), !!((r) & SL11_EPCTRL_ARM), 0);	\
 } while (0)
 #define DDOLOGEPSTAT(r)	do {						\
     DDOLOG("STAT stall   =%d  nak     =%d  overflow =%d  setup   =%d",	\
 	!!((r) & SL11_EPSTAT_STALL), !!((r) & SL11_EPSTAT_NAK),		\
 	!!((r) & SL11_EPSTAT_OVERFLOW), !!((r) & SL11_EPSTAT_SETUP));	\
     DDOLOG("STAT sequence=%d  timeout =%d  error    =%d  ack   =%d",	\
 	!!((r) & SL11_EPSTAT_SEQUENCE), !!((r) & SL11_EPSTAT_TIMEOUT),	\
 	!!((r) & SL11_EPSTAT_ERROR), !!((r) & SL11_EPSTAT_ACK));	\
 } while (0)
 #else /* now !SLHCI_DEBUG */
 #define slhcidebug 0
 #define slhci_log_spipe(spipe) ((void)0)
 #define slhci_log_xfer(xfer) ((void)0)
 #define SLHCI_DEXEC(x, y) ((void)0)
 #define DDOLOG(f, a, b, c, d) ((void)0)
 #define DLOG(x, f, a, b, c, d) ((void)0)
 #define DDOLOGBUF(b, l) ((void)0)
 #define DLOGBUF(x, b, l) ((void)0)
 #define DDOLOGCTRL(x) ((void)0)
 #define DDOLOGISR(r) ((void)0)
 #define DDOLOGIER(r) ((void)0)
 #define DDOLOGSTATUS(s) ((void)0)
 #define DDOLOGEPCTRL(r) ((void)0)
 #define DDOLOGEPSTAT(r) ((void)0)
 #endif /* SLHCI_DEBUG */
 #ifdef DIAGNOSTIC
 #define LK_SLASSERT(exp, sc, spipe, xfer, ext) do {			\
 	if (!(exp)) {							\
 		printf("%s: assertion %s failed line %u function %s!"	\
 		" halted\n", SC_NAME(sc), #exp, __LINE__, __func__);\
 		slhci_halt(sc, spipe, xfer);				\
 		ext;							\
 	}								\
 } while (/*CONSTCOND*/0)
 #define UL_SLASSERT(exp, sc, spipe, xfer, ext) do {			\
 	if (!(exp)) {							\
 		printf("%s: assertion %s failed line %u function %s!"	\
 		" halted\n", SC_NAME(sc), #exp, __LINE__, __func__);	\
 		slhci_lock_call(sc, &slhci_halt, spipe, xfer);		\
 		ext;							\
 	}								\
 } while (/*CONSTCOND*/0)
 #else
 #define LK_SLASSERT(exp, sc, spipe, xfer, ext) ((void)0)
 #define UL_SLASSERT(exp, sc, spipe, xfer, ext) ((void)0)
 #endif
 const struct usbd_bus_methods slhci_bus_methods = {
 	.ubm_open = slhci_open,
 	.ubm_softint= slhci_void,
 	.ubm_dopoll = slhci_poll,
 	.ubm_allocx = slhci_allocx,
 	.ubm_freex = slhci_freex,
 	.ubm_getlock = slhci_get_lock,
 	.ubm_rhctrl = slhci_roothub_ctrl,
 };
 const struct usbd_pipe_methods slhci_pipe_methods = {
 	.upm_transfer = slhci_transfer,
 	.upm_start = slhci_start,
 	.upm_abort = slhci_abort,
 	.upm_close = slhci_close,
 	.upm_cleartoggle = slhci_clear_toggle,
 	.upm_done = slhci_done,
 };
 const struct usbd_pipe_methods slhci_root_methods = {
 	.upm_transfer = slhci_transfer,
 	.upm_start = slhci_root_start,
 	.upm_abort = slhci_abort,
 	.upm_close = (void (*)(struct usbd_pipe *))slhci_void, /* XXX safe? */
 	.upm_cleartoggle = slhci_clear_toggle,
 	.upm_done = slhci_done,
 };
 /* Queue inlines */
 #define GOT_FIRST_TO(tvar, t) \
     GCQ_GOT_FIRST_TYPED(tvar, &(t)->to, struct slhci_pipe, to)
 #define FIND_TO(var, t, tvar, cond) \
     GCQ_FIND_TYPED(var, &(t)->to, tvar, struct slhci_pipe, to, cond)
 #define FOREACH_AP(var, t, tvar) \
     GCQ_FOREACH_TYPED(var, &(t)->ap, tvar, struct slhci_pipe, ap)
 #define GOT_FIRST_TIMED_COND(tvar, t, cond) \
     GCQ_GOT_FIRST_COND_TYPED(tvar, &(t)->timed, struct slhci_pipe, xq, cond)
 #define GOT_FIRST_CB(tvar, t) \
     GCQ_GOT_FIRST_TYPED(tvar, &(t)->q[Q_CB], struct slhci_pipe, xq)
 #define DEQUEUED_CALLBACK(tvar, t) \
     GCQ_DEQUEUED_FIRST_TYPED(tvar, &(t)->q[Q_CALLBACKS], struct slhci_pipe, xq)
 #define FIND_TIMED(var, t, tvar, cond) \
    GCQ_FIND_TYPED(var, &(t)->timed, tvar, struct slhci_pipe, xq, cond)
 #define DEQUEUED_WAITQ(tvar, sc) \
     GCQ_DEQUEUED_FIRST_TYPED(tvar, &(sc)->sc_waitq, struct slhci_pipe, xq)
 static inline void
 enter_waitq(struct slhci_softc *sc, struct slhci_pipe *spipe)
+{
 	gcq_insert_tail(&sc->sc_waitq, &spipe->xq);
+}
 static inline void
 enter_q(struct slhci_transfers *t, struct slhci_pipe *spipe, int i)
+{
 	gcq_insert_tail(&t->q[i], &spipe->xq);
+}
 static inline void
 enter_callback(struct slhci_transfers *t, struct slhci_pipe *spipe)
+{
 	gcq_insert_tail(&t->q[Q_CALLBACKS], &spipe->xq);
+}
 static inline void
 enter_all_pipes(struct slhci_transfers *t, struct slhci_pipe *spipe)
+{
 	gcq_insert_tail(&t->ap, &spipe->ap);
+}
 /* Start out of lock functions. */
 struct usbd_xfer *
 slhci_allocx(struct usbd_bus *bus, unsigned int nframes)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct usbd_xfer *xfer;
 	xfer = kmem_zalloc(sizeof(*xfer), KM_SLEEP);
 	DLOG(D_MEM, "allocx %p", xfer, 0,0,0);
 #ifdef SLHCI_MEM_ACCOUNTING
 	slhci_mem_use(bus, 1);
 #endif
 #ifdef DIAGNOSTIC
 	if (xfer != NULL)
 		xfer->ux_state = XFER_BUSY;
 #endif
 	return xfer;
+}
 void
 slhci_freex(struct usbd_bus *bus, struct usbd_xfer *xfer)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	DLOG(D_MEM, "freex xfer %p spipe %p", xfer, xfer->ux_pipe,0,0);
 #ifdef SLHCI_MEM_ACCOUNTING
 	slhci_mem_use(bus, -1);
 #endif
 #ifdef DIAGNOSTIC
 	if (xfer->ux_state != XFER_BUSY) {
 		struct slhci_softc *sc = SLHCI_BUS2SC(bus);
 		printf("%s: slhci_freex: xfer=%p not busy, %#08x halted\n",
 		    SC_NAME(sc), xfer, xfer->ux_state);
 		DDOLOG("xfer=%p not busy, %#08x halted\n", xfer,
 		    xfer->ux_state, 0, 0);
 		slhci_lock_call(sc, &slhci_halt, NULL, NULL);
 		return;
+	}
 	xfer->ux_state = XFER_FREE;
 #endif
 	kmem_free(xfer, sizeof(*xfer));
+}
 static void
 slhci_get_lock(struct usbd_bus *bus, kmutex_t **lock)
+{
 	struct slhci_softc *sc = SLHCI_BUS2SC(bus);
 	*lock = &sc->sc_lock;
+}
 usbd_status
 slhci_transfer(struct usbd_xfer *xfer)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct slhci_softc *sc = SLHCI_XFER2SC(xfer);
 	usbd_status error;
 	DLOG(D_TRACE, "transfer type %d xfer %p spipe %p ",
 	    SLHCI_XFER_TYPE(xfer), xfer, xfer->ux_pipe, 0);
 	/* Insert last in queue */
 	mutex_enter(&sc->sc_lock);
 	error = usb_insert_transfer(xfer);
 	mutex_exit(&sc->sc_lock);
 	if (error) {
 		if (error != USBD_IN_PROGRESS)
 			DLOG(D_ERR, "usb_insert_transfer returns %d!", error,
 ,0,0);
 		return error;
+	}
 	/*
 	 * Pipe isn't running (otherwise error would be USBD_INPROG),
 	 * so start it first.
 	 */
 	/*
 	 * Start will take the lock.
 	 */
 	error = xfer->ux_pipe->up_methods->upm_start(SIMPLEQ_FIRST(&xfer->ux_pipe->up_queue));
 	return error;
+}
 /* It is not safe for start to return anything other than USBD_INPROG. */
 usbd_status
 slhci_start(struct usbd_xfer *xfer)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct slhci_softc *sc = SLHCI_XFER2SC(xfer);
 	struct usbd_pipe *pipe = xfer->ux_pipe;
 	struct slhci_pipe *spipe = SLHCI_PIPE2SPIPE(pipe);
 	struct slhci_transfers *t = &sc->sc_transfers;
 	usb_endpoint_descriptor_t *ed = pipe->up_endpoint->ue_edesc;
 	unsigned int max_packet;
 	mutex_enter(&sc->sc_lock);
 	max_packet = UGETW(ed->wMaxPacketSize);
 	DLOG(D_TRACE, "transfer type %d start xfer %p spipe %p length %d",
 	    spipe->ptype, xfer, spipe, xfer->ux_length);
 	/* root transfers use slhci_root_start */
 	KASSERT(spipe->xfer == NULL); /* not SLASSERT */
 	xfer->ux_actlen = 0;
 	xfer->ux_status = USBD_IN_PROGRESS;
 	spipe->xfer = xfer;
 	spipe->nerrs = 0;
 	spipe->frame = t->frame;
 	spipe->control = SL11_EPCTRL_ARM_ENABLE;
 	spipe->tregs[DEV] = pipe->up_dev->ud_addr;
 	spipe->tregs[PID] = spipe->newpid = UE_GET_ADDR(ed->bEndpointAddress)
 	    | (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN ? SL11_PID_IN :
 	    SL11_PID_OUT);
 	spipe->newlen[0] = xfer->ux_length % max_packet;
 	spipe->newlen[1] = min(xfer->ux_length, max_packet);
 	if (spipe->ptype == PT_BULK || spipe->ptype == PT_INTR) {
 		if (spipe->pflags & PF_TOGGLE)
 			spipe->control |= SL11_EPCTRL_DATATOGGLE;
 		spipe->tregs[LEN] = spipe->newlen[1];
 		if (spipe->tregs[LEN])
 			spipe->buffer = xfer->ux_buf;
 		else
 			spipe->buffer = NULL;
 		spipe->lastframe = t->frame;
 		if (spipe->ptype == PT_INTR) {
 			spipe->frame = spipe->lastframe +
 			    spipe->pipe.up_interval;
+		}
 #if defined(DEBUG) || defined(SLHCI_DEBUG)
 		if (__predict_false(spipe->ptype == PT_INTR &&
 		    xfer->ux_length > spipe->tregs[LEN])) {
 			printf("%s: Long INTR transfer not supported!\n",
 			    SC_NAME(sc));
 			DDOLOG("Long INTR transfer not supported!", 0, 0, 0, 0);
 			xfer->ux_status = USBD_INVAL;
+		}
 #endif
 	} else {
 		/* ptype may be currently set to any control transfer type. */
 		SLHCI_DEXEC(D_TRACE, slhci_log_xfer(xfer));
 		/* SETUP contains IN/OUT bits also */
 		spipe->tregs[PID] |= SL11_PID_SETUP;
 		spipe->tregs[LEN] = 8;
 		spipe->buffer = (uint8_t *)&xfer->ux_request;
 		DLOGBUF(D_XFER, spipe->buffer, spipe->tregs[LEN]);
 		spipe->ptype = PT_CTRL_SETUP;
 		spipe->newpid &= ~SL11_PID_BITS;
 		if (xfer->ux_length == 0 ||
 		    (xfer->ux_request.bmRequestType & UT_READ))
 			spipe->newpid |= SL11_PID_IN;
 		else
 			spipe->newpid |= SL11_PID_OUT;
+	}
 	if (xfer->ux_flags & USBD_FORCE_SHORT_XFER &&
 	    spipe->tregs[LEN] == max_packet &&
 	    (spipe->newpid & SL11_PID_BITS) == SL11_PID_OUT)
 		spipe->wantshort = 1;
 	else
 		spipe->wantshort = 0;
 	/*
 	 * The goal of newbustime and newlen is to avoid bustime calculation
 	 * in the interrupt.  The calculations are not too complex, but they
 	 * complicate the conditional logic somewhat and doing them all in the
 	 * same place shares constants. Index 0 is "short length" for bulk and
 	 * ctrl data and 1 is "full length" for ctrl data (bulk/intr are
 	 * already set to full length).
 	 */
 	if (spipe->pflags & PF_LS) {
 		/*
 		 * Setting PREAMBLE for directly connected LS devices will
 		 * lock up the chip.
 		 */
 		if (spipe->pflags & PF_PREAMBLE)
 			spipe->control |= SL11_EPCTRL_PREAMBLE;
 		if (max_packet <= 8) {
 			spipe->bustime = SLHCI_LS_CONST +
 			    SLHCI_LS_DATA_TIME(spipe->tregs[LEN]);
 			spipe->newbustime[0] = SLHCI_LS_CONST +
 			    SLHCI_LS_DATA_TIME(spipe->newlen[0]);
 			spipe->newbustime[1] = SLHCI_LS_CONST +
 			    SLHCI_LS_DATA_TIME(spipe->newlen[1]);
 		} else
 			xfer->ux_status = USBD_INVAL;
 	} else {
 		UL_SLASSERT(pipe->up_dev->ud_speed == USB_SPEED_FULL, sc,
 		    spipe, xfer, return USBD_IN_PROGRESS);
 		if (max_packet <= SL11_MAX_PACKET_SIZE) {
 			spipe->bustime = SLHCI_FS_CONST +
 			    SLHCI_FS_DATA_TIME(spipe->tregs[LEN]);
 			spipe->newbustime[0] = SLHCI_FS_CONST +
 			    SLHCI_FS_DATA_TIME(spipe->newlen[0]);
 			spipe->newbustime[1] = SLHCI_FS_CONST +
 			    SLHCI_FS_DATA_TIME(spipe->newlen[1]);
 		} else
 			xfer->ux_status = USBD_INVAL;
+	}
 	/*
 	 * The datasheet incorrectly indicates that DIRECTION is for
 	 * "transmit to host".  It is for OUT and SETUP.  The app note
 	 * describes its use correctly.
 	 */
 	if ((spipe->tregs[PID] & SL11_PID_BITS) != SL11_PID_IN)
 		spipe->control |= SL11_EPCTRL_DIRECTION;
 	slhci_start_entry(sc, spipe);
 	mutex_exit(&sc->sc_lock);
 	return USBD_IN_PROGRESS;
+}
 usbd_status
 slhci_root_start(struct usbd_xfer *xfer)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct slhci_softc *sc;
 	struct slhci_pipe *spipe __diagused;
 	spipe = SLHCI_PIPE2SPIPE(xfer->ux_pipe);
 	sc = SLHCI_XFER2SC(xfer);
 	struct slhci_transfers *t = &sc->sc_transfers;
 	LK_SLASSERT(spipe != NULL && xfer != NULL, sc, spipe, xfer, return
 	    USBD_CANCELLED);
 	DLOG(D_TRACE, "transfer type %d start", SLHCI_XFER_TYPE(xfer), 0, 0, 0);
 	KASSERT(spipe->ptype == PT_ROOT_INTR);
 	mutex_enter(&sc->sc_intr_lock);
 	t->rootintr = xfer;
 	mutex_exit(&sc->sc_intr_lock);
 	return USBD_IN_PROGRESS;
+}
 usbd_status
 slhci_open(struct usbd_pipe *pipe)
+{
 	SLHCIHIST_FUNC(); SLHCIHIST_CALLED();
 	struct usbd_device *dev;
 	struct slhci_softc *sc;
 	struct slhci_pipe *spipe;
 	usb_endpoint_descriptor_t *ed;
 	unsigned int max_packet, pmaxpkt;
 	uint8_t rhaddr;
 	dev = pipe->up_dev;
 	sc = SLHCI_PIPE2SC(pipe);
 	spipe = SLHCI_PIPE2SPIPE(pipe);
 	ed = pipe->up_endpoint->ue_edesc;
 	rhaddr = dev->ud_bus->ub_rhaddr;
 	DLOG(D_TRACE, "slhci_open(addr=%d,ep=%d,rootaddr=%d)",
 		dev->ud_addr, ed->bEndpointAddress, rhaddr, 0);
 	spipe->pflags = 0;
 	spipe->frame = 0;
 	spipe->lastframe = 0;
 	spipe->xfer = NULL;
 	spipe->buffer = NULL;
 	gcq_init(&spipe->ap);
 	gcq_init(&spipe->to);
 	gcq_init(&spipe->xq);
 	/*
 	 * The endpoint descriptor will not have been set up yet in the case
 	 * of the standard control pipe, so the max packet checks are also
 	 * necessary in start.
 	 */
 	max_packet = UGETW(ed->wMaxPacketSize);
 	if (dev->ud_speed == USB_SPEED_LOW) {
 		spipe->pflags |= PF_LS;
 		if (dev->ud_myhub->ud_addr != rhaddr) {
 			spipe->pflags |= PF_PREAMBLE;
 			if (!slhci_try_lsvh)
 				return slhci_lock_call(sc, &slhci_lsvh_warn,
 				    spipe, NULL);
+		}
 		pmaxpkt = 8;
 	} else
 		pmaxpkt = SL11_MAX_PACKET_SIZE;
 	if (max_packet > pmaxpkt) {
 		DLOG(D_ERR, "packet too large! size %d spipe %p", max_packet,
 		    spipe, 0,0);
 		return USBD_INVAL;
+	}
 	if (dev->ud_addr == rhaddr) {
 		switch (ed->bEndpointAddress) {
 		case USB_CONTROL_ENDPOINT:
 			spipe->ptype = PT_ROOT_CTRL;
 			pipe->up_interval = 0;
 			pipe->up_methods = &roothub_ctrl_methods;
 			break;
 		case UE_DIR_IN | USBROOTHUB_INTR_ENDPT:
 			spipe->ptype = PT_ROOT_INTR;
 			pipe->up_interval = 1;
 			pipe->up_methods = &slhci_root_methods;
 			break;
 		default:
 			printf("%s: Invalid root endpoint!\n", SC_NAME(sc));
 			DDOLOG("Invalid root endpoint", 0, 0, 0, 0);
 			return USBD_INVAL;
+		}
 		return USBD_NORMAL_COMPLETION;
 	} else {
 		switch (ed->bmAttributes & UE_XFERTYPE) {
 		case UE_CONTROL:
 			spipe->ptype = PT_CTRL_SETUP;
 			pipe->up_interval = 0;
 			break;
 		case UE_INTERRUPT:
 			spipe->ptype = PT_INTR;
 			if (pipe->up_interval == USBD_DEFAULT_INTERVAL)
 				pipe->up_interval = ed->bInterval;
 			break;
 		case UE_ISOCHRONOUS:
 			return slhci_lock_call(sc, &slhci_isoc_warn, spipe,
 			    NULL);
 		case UE_BULK:
 			spipe->ptype = PT_BULK;
 			pipe->up_interval = 0;
 			break;
+		}
 		DLOG(D_MSG, "open pipe type %d interval %d", spipe->ptype,
 		    pipe->up_interval, 0,0);
 		pipe->up_methods = __UNCONST(&slhci_pipe_methods);
 		return slhci_lock_call(sc, &slhci_open_pipe, spipe, NULL);
+	}
+}
 int
 slhci_supported_rev(uint8_t rev)
+{
 	return rev >= SLTYPE_SL811HS_R12 && rev <= SLTYPE_SL811HS_R15;
+}
 /*
  * Must be called before the ISR is registered. Interrupts can be shared so
  * slhci_intr could be called as soon as the ISR is registered.
  * Note max_current argument is actual current, but stored as current/2
  */
 void
 slhci_preinit(struct slhci_softc *sc, PowerFunc pow, bus_space_tag_t iot,
     bus_space_handle_t ioh, uint16_t max_current, uint32_t stride)
+{
 	struct slhci_transfers *t;
 	int i;
 	t = &sc->sc_transfers;
 #ifdef SLHCI_DEBUG
 	ssc = sc;
 #endif
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_USB);
 	/* sc->sc_ier = 0;	*/
 	/* t->rootintr = NULL;	*/
 	t->flags = F_NODEV|F_UDISABLED;
 	t->pend = INT_MAX;
 	KASSERT(slhci_wait_time != INT_MAX);
 	t->len[0] = t->len[1] = -1;
 	if (max_current > 500)
 		max_current = 500;
 	t->max_current = (uint8_t)(max_current / 2);
 	sc->sc_enable_power = pow;
 	sc->sc_iot = iot;
 	sc->sc_ioh = ioh;
 	sc->sc_stride = stride;
 	KASSERT(Q_MAX+1 == sizeof(t->q) / sizeof(t->q[0]));
 	for (i = 0; i <= Q_MAX; i++)
 		gcq_init_head(&t->q[i]);
 	gcq_init_head(&t->timed);
 	gcq_init_head(&t->to);
 	gcq_init_head(&t->ap);
 	gcq_init_head(&sc->sc_waitq);