 @@ -1,36 +1,36 @@
-/*	$NetBSD: if_mue.c,v 1.60 2020/06/27 13:33:26 jmcneill Exp $	*/
+/*	$NetBSD: if_mue.c,v 1.61 2021/07/15 03:25:50 nisimura Exp $	*/
 /*	$OpenBSD: if_mue.c,v 1.3 2018/08/04 16:42:46 jsg Exp $	*/
 /*
  * Copyright (c) 2018 Kevin Lo <kevlo@openbsd.org>
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 /* Driver for Microchip LAN7500/LAN7800 chipsets. */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_mue.c,v 1.60 2020/06/27 13:33:26 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_mue.c,v 1.61 2021/07/15 03:25:50 nisimura Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/if_muereg.h>
 #include <dev/usb/if_muevar.h>
 @@ -88,66 +88,73 @@ static bool	mue_eeprom_present(struct us
 static void	mue_dataport_write(struct usbnet *, uint32_t, uint32_t,
 		    uint32_t, uint32_t *);
 static void	mue_init_ltm(struct usbnet *);
 static int	mue_chip_init(struct usbnet *);
 static void	mue_set_macaddr(struct usbnet *);
 static int	mue_get_macaddr(struct usbnet *, prop_dictionary_t);
 static int	mue_prepare_tso(struct usbnet *, struct mbuf *);
 static void	mue_setiff_locked(struct usbnet *);
 static void	mue_sethwcsum_locked(struct usbnet *);
 static void	mue_setmtu_locked(struct usbnet *);
 static void	mue_reset(struct usbnet *);
 static void	mue_uno_stop(struct ifnet *, int);
-static int	mue_uno_ioctl(struct ifnet *, u_long, void *);
+static int	mue_uno_override_ioctl(struct ifnet *, u_long, void *);
 static int	mue_uno_mii_read_reg(struct usbnet *, int, int, uint16_t *);
 static int	mue_uno_mii_write_reg(struct usbnet *, int, int, uint16_t);
 static void	mue_uno_mii_statchg(struct ifnet *);
 static void	mue_uno_rx_loop(struct usbnet *, struct usbnet_chain *,
 				uint32_t);
 static unsigned	mue_uno_tx_prepare(struct usbnet *, struct mbuf *,
 				   struct usbnet_chain *);
 static int	mue_uno_init(struct ifnet *);
 static const struct usbnet_ops mue_ops = {
 	.uno_stop = mue_uno_stop,
-	.uno_ioctl = mue_uno_ioctl,
+	.uno_override_ioctl = mue_uno_override_ioctl,
 	.uno_read_reg = mue_uno_mii_read_reg,
 	.uno_write_reg = mue_uno_mii_write_reg,
 	.uno_statchg = mue_uno_mii_statchg,
 	.uno_tx_prepare = mue_uno_tx_prepare,
 	.uno_rx_loop = mue_uno_rx_loop,
 	.uno_init = mue_uno_init,
 };
 #define MUE_SETBIT(un, reg, x)	\
 	mue_csr_write(un, reg, mue_csr_read(un, reg) | (x))
 #define MUE_CLRBIT(un, reg, x)	\
 	mue_csr_write(un, reg, mue_csr_read(un, reg) & ~(x))
 #define MUE_WAIT_SET(un, reg, set, fail)	\
 	mue_wait_for_bits(un, reg, set, ~0, fail)
 #define MUE_WAIT_CLR(un, reg, clear, fail)	\
 	mue_wait_for_bits(un, reg, 0, clear, fail)
 #define ETHER_IS_VALID(addr) \
 	(!ETHER_IS_MULTICAST(addr) && !ETHER_IS_ZERO(addr))
 #define ETHER_IS_ZERO(addr) \
 	(!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]))
-CFATTACH_DECL_NEW(mue, sizeof(struct usbnet), mue_match, mue_attach,
+struct mue_softc {
 	struct usbnet	   sc_un;
 	struct usbnet_intr sc_intr;
 	uint8_t sc_ibuf[8];
 	unsigned sc_flowflags;		/* 802.3x PAUSE flow control */
 };
 CFATTACH_DECL_NEW(mue, sizeof(struct mue_softc), mue_match, mue_attach,
     usbnet_detach, usbnet_activate);
 static uint32_t
 mue_csr_read(struct usbnet *un, uint32_t reg)
+{
 	usb_device_request_t req;
 	usbd_status err;
 	uDWord val;
 	if (usbnet_isdying(un))
 		return 0;
 	USETDW(val, 0);
 @@ -750,49 +757,50 @@ mue_get_macaddr(struct usbnet *un, prop_
  */
 static int
 mue_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	return (MUE_LOOKUP(uaa) != NULL) ?  UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 static void
 mue_attach(device_t parent, device_t self, void *aux)
+{
 	USBNET_MII_DECL_DEFAULT(unm);
 	struct usbnet * const un = device_private(self);
 	prop_dictionary_t dict = device_properties(self);
 	struct mue_softc * const sc = device_private(self);
 	struct usb_attach_arg *uaa = aux;
 	struct usbd_device *dev = uaa->uaa_device;
 	struct usbnet *un = &sc->sc_un;
 	usb_interface_descriptor_t *id;
 	usb_endpoint_descriptor_t *ed;
 	char *devinfop;
 	usbd_status err;
 	char *devinfop;
 	const char *descr;
 	uint32_t id_rev;
 	uint8_t i;
 	unsigned rx_list_cnt, tx_list_cnt;
 	unsigned rx_bufsz;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	devinfop = usbd_devinfo_alloc(dev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	un->un_dev = self;
 	un->un_udev = dev;
-	un->un_sc = un;
+	un->un_sc = sc; /* @@! */
 	un->un_ops = &mue_ops;
 	un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
 	un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
 #define MUE_CONFIG_NO	1
 	err = usbd_set_config_no(dev, MUE_CONFIG_NO, 1);
 	if (err) {
 		aprint_error_dev(self, "failed to set configuration: %s\n",
 		    usbd_errstr(err));
 		return;
+	}
 #define MUE_IFACE_IDX	0
 @@ -874,26 +882,28 @@ mue_attach(device_t parent, device_t sel
 	ifp->if_capabilities = IFCAP_TSOv4 | IFCAP_TSOv6 |
 	    IFCAP_CSUM_IPv4_Tx | IFCAP_CSUM_IPv4_Rx |
 	    IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv4_Rx |
 	    IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv4_Rx |
 	    IFCAP_CSUM_TCPv6_Tx | IFCAP_CSUM_TCPv6_Rx |
 	    IFCAP_CSUM_UDPv6_Tx | IFCAP_CSUM_UDPv6_Rx;
 	struct ethercom *ec = usbnet_ec(un);
 	ec->ec_capabilities = ETHERCAP_VLAN_MTU;
 #if 0 /* XXX not yet */
 	ec->ec_capabilities = ETHERCAP_VLAN_MTU | ETHERCAP_JUMBO_MTU;
 #endif
 	unm.un_mii_phyloc = un->un_phyno;	/* use internal PHY 1 */
 	unm.un_mii_flags |= MIIF_DOPAUSE;	/* use PAUSE cap. */
 	usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
 , &unm);
+}
 static unsigned
 mue_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct mue_txbuf_hdr hdr;
 	uint32_t tx_cmd_a, tx_cmd_b;
 	int csum, len, rv;
 	bool tso, ipe, tpe;
 @@ -987,110 +997,113 @@ mue_prepare_tso(struct usbnet *un, struc
 			ip6->ip6_plen = 0;
 		} else
 			m_copyback(m, off + offsetof(struct ip6_hdr, ip6_plen),
 			    sizeof(len), &len);
+	}
 	return 0;
+}
 static void
 mue_setiff_locked(struct usbnet *un)
+{
 	struct ethercom *ec = usbnet_ec(un);
 	struct ifnet * const ifp = usbnet_ifp(un);
 	const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
 	struct ether_multi *enm;
 	struct ether_multistep step;
-	uint32_t pfiltbl[MUE_NUM_ADDR_FILTX][2];
+	struct ether_multi *enm;
-	uint32_t hashtbl[MUE_DP_SEL_VHF_HASH_LEN];
+	uint32_t mchash[MUE_DP_SEL_VHF_HASH_LEN];
-	uint32_t reg, rxfilt, h, hireg, loreg;
+	uint32_t rfe, rxfilt, crc, hireg, loreg;
 	size_t i;
 	if (usbnet_isdying(un))
 		return;
-	/* Clear perfect filter and hash tables. */
+	for (i = 1; i < MUE_NUM_ADDR_FILTX; i++) {
-	memset(pfiltbl, 0, sizeof(pfiltbl));
+		hireg = (un->un_flags & LAN7500)
-	memset(hashtbl, 0, sizeof(hashtbl));
+		    ? MUE_7500_ADDR_FILTX(i) : MUE_7800_ADDR_FILTX(i);
 		mue_csr_write(un, hireg, 0);
+	}
 	memset(mchash, 0, sizeof(mchash));
-	reg = (un->un_flags & LAN7500) ? MUE_7500_RFE_CTL : MUE_7800_RFE_CTL;
+	rfe = (un->un_flags & LAN7500) ? MUE_7500_RFE_CTL : MUE_7800_RFE_CTL;
-	rxfilt = mue_csr_read(un, reg);
+	rxfilt = mue_csr_read(un, rfe);
-	rxfilt &= ~(MUE_RFE_CTL_PERFECT | MUE_RFE_CTL_MULTICAST_HASH |
+	rxfilt &= ~(MUE_RFE_CTL_MULTICAST_HASH |
 	    MUE_RFE_CTL_UNICAST | MUE_RFE_CTL_MULTICAST);
-	/* Always accept broadcast frames. */
+	ETHER_LOCK(ec);
 	rxfilt |= MUE_RFE_CTL_BROADCAST;
 	if (ifp->if_flags & IFF_PROMISC) {
-		rxfilt |= MUE_RFE_CTL_UNICAST;
+		ec->ec_flags |= ETHER_F_ALLMULTI;
-allmulti:	rxfilt |= MUE_RFE_CTL_MULTICAST;
+		ETHER_UNLOCK(ec);
-		ifp->if_flags |= IFF_ALLMULTI;
+		/* run promisc. mode */
-		if (ifp->if_flags & IFF_PROMISC)
+		rxfilt |= (MUE_RFE_CTL_UNICAST | MUE_RFE_CTL_MULTICAST);
-			DPRINTF(un, "promisc\n");
+		DPRINTF(un, "promisc\n");
-		else
+		goto update;
 			DPRINTF(un, "allmulti\n");
-	} else {
+	ec->ec_flags &= ~ETHER_F_ALLMULTI;
-		/* Now program new ones. */
+	ETHER_FIRST_MULTI(step, ec, enm);
-		pfiltbl[0][0] = MUE_ENADDR_HI(enaddr) | MUE_ADDR_FILTX_VALID;
+	i = 1; /* the first slot is occupied by my station address */
-		pfiltbl[0][1] = MUE_ENADDR_LO(enaddr);
+	while (enm != NULL) {
-		i = 1;
+		if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
-		ETHER_LOCK(ec);
+			/*
-		ETHER_FIRST_MULTI(step, ec, enm);
+			 * We must listen to a range of multicast addresses.
-		while (enm != NULL) {
+			 * For now, just accept all multicasts, rather than
-			if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
+			 * trying to set only those filter bits needed to match
-			    ETHER_ADDR_LEN)) {
+			 * the range.  (At this time, the only use of address
-				memset(pfiltbl, 0, sizeof(pfiltbl));
+			 * ranges is for IP multicast routing, for which the
-				memset(hashtbl, 0, sizeof(hashtbl));
+			 * range is big enough to require all bits set.)
-				rxfilt &= ~MUE_RFE_CTL_MULTICAST_HASH;
+			 */
-				ETHER_UNLOCK(ec);
+			ec->ec_flags |= ETHER_F_ALLMULTI;
-				goto allmulti;
+			ETHER_UNLOCK(ec);
 			/* accept all multicast */
-			if (i < MUE_NUM_ADDR_FILTX) {
+			for (i = 1; i < MUE_NUM_ADDR_FILTX; i++) {
-				/* Use perfect address table if possible. */
+				hireg = (un->un_flags & LAN7500)
-				pfiltbl[i][0] = MUE_ENADDR_HI(enm->enm_addrlo) |
+				    ? MUE_7500_ADDR_FILTX(i)
-				    MUE_ADDR_FILTX_VALID;
+				    : MUE_7800_ADDR_FILTX(i);
-				pfiltbl[i][1] = MUE_ENADDR_LO(enm->enm_addrlo);
+				mue_csr_write(un, hireg, 0);
 			} else {
 				/* Otherwise, use hash table. */
 				rxfilt |= MUE_RFE_CTL_MULTICAST_HASH;
 				h = (ether_crc32_be(enm->enm_addrlo,
 				    ETHER_ADDR_LEN) >> 23) & 0x1ff;
 				hashtbl[h / 32] |= 1 << (h % 32);
+			}
-			i++;
+			memset(mchash, 0, sizeof(mchash));
-			ETHER_NEXT_MULTI(step, enm);
+			rxfilt |= MUE_RFE_CTL_MULTICAST;
 			rxfilt &= ~MUE_RFE_CTL_MULTICAST_HASH;
 			DPRINTF(un, "allmulti\n");
 			goto update;
+		}
-		ETHER_UNLOCK(ec);
+		if (i < MUE_NUM_ADDR_FILTX) {
-		rxfilt |= MUE_RFE_CTL_PERFECT;
+			/* Use perfect address table if possible. */
-		ifp->if_flags &= ~IFF_ALLMULTI;
+			uint8_t *en = enm->enm_addrlo;
-		if (rxfilt & MUE_RFE_CTL_MULTICAST_HASH)
+			hireg = (un->un_flags & LAN7500) ?
-			DPRINTF(un, "perfect filter and hash tables\n");
+			    MUE_7500_ADDR_FILTX(i) : MUE_7800_ADDR_FILTX(i);
-		else
+			loreg = hireg + 4;
-			DPRINTF(un, "perfect filter\n");
+			mue_csr_write(un, hireg, 0);
 			mue_csr_write(un, loreg, MUE_ENADDR_LO(en));
 			mue_csr_write(un, hireg, MUE_ENADDR_HI(en)
-	for (i = 0; i < MUE_NUM_ADDR_FILTX; i++) {
+			    | MUE_ADDR_FILTX_VALID);
-		hireg = (un->un_flags & LAN7500) ?
+		} else {
-		    MUE_7500_ADDR_FILTX(i) : MUE_7800_ADDR_FILTX(i);
+			/* Otherwise, use hash table. */
-		loreg = hireg + 4;
+			rxfilt |= MUE_RFE_CTL_MULTICAST_HASH;
-		mue_csr_write(un, hireg, 0);
+			crc = (ether_crc32_be(enm->enm_addrlo,
-		mue_csr_write(un, loreg, pfiltbl[i][1]);
+			    ETHER_ADDR_LEN) >> 23) & 0x1ff;
-		mue_csr_write(un, hireg, pfiltbl[i][0]);
+			mchash[crc / 32] |= 1 << (crc % 32);
+		}
 		i++;
 		ETHER_NEXT_MULTI(step, enm);
+	}
 	ETHER_UNLOCK(ec);
  update:
 	if (rxfilt & MUE_RFE_CTL_MULTICAST_HASH)
 		DPRINTF(un, "perfect filter and hash tables\n");
 	else
 		DPRINTF(un, "perfect filter\n");
 	mue_dataport_write(un, MUE_DP_SEL_VHF, MUE_DP_SEL_VHF_VLAN_LEN,
-	    MUE_DP_SEL_VHF_HASH_LEN, hashtbl);
+		    MUE_DP_SEL_VHF_HASH_LEN, mchash);
 	mue_csr_write(un, rfe, rxfilt);
 	mue_csr_write(un, reg, rxfilt);
+}
 static void
 mue_sethwcsum_locked(struct usbnet *un)
+{
 	struct ifnet * const ifp = usbnet_ifp(un);
 	uint32_t reg, val;
 	reg = (un->un_flags & LAN7500) ? MUE_7500_RFE_CTL : MUE_7800_RFE_CTL;
 	val = mue_csr_read(un, reg);
 	if (ifp->if_capenable & IFCAP_CSUM_IPv4_Rx) {
 		DPRINTF(un, "RX IPv4 hwcsum enabled\n");
 @@ -1212,41 +1225,52 @@ mue_uno_rx_loop(struct usbnet *un, struc
 		/* Attention: sizeof(hdr) = 10 */
 		pktlen = roundup(pktlen + sizeof(*hdrp), 4);
 		if (pktlen > total_len)
 			pktlen = total_len;
 		total_len -= pktlen;
 		buf += pktlen;
 	} while (total_len > 0);
+}
 static int
 mue_init_locked(struct ifnet *ifp)
+{
 	struct usbnet * const un = ifp->if_softc;
 	const uint8_t *ea = CLLADDR(ifp->if_sadl);
 	uint32_t rfe, hireg, loreg;
 	if (usbnet_isdying(un)) {
 		DPRINTF(un, "dying\n");
 		return EIO;
+	}
 	/* Cancel pending I/O and free all TX/RX buffers. */
 	if (ifp->if_flags & IFF_RUNNING)
 		usbnet_stop(un, ifp, 1);
 	mue_reset(un);
 	/* Set MAC address. */
 	mue_set_macaddr(un);
 	hireg = (un->un_flags & LAN7500)
 		    ? MUE_7500_ADDR_FILTX(0) : MUE_7800_ADDR_FILTX(0);
 	loreg = hireg + 4;
 	mue_csr_write(un, loreg, MUE_ENADDR_LO(ea));
 	mue_csr_write(un, hireg, MUE_ENADDR_HI(ea) | MUE_ADDR_FILTX_VALID);
 	rfe = (un->un_flags & LAN7500) ? MUE_7500_RFE_CTL : MUE_7800_RFE_CTL;
 	mue_csr_write(un, rfe, MUE_RFE_CTL_BROADCAST | MUE_RFE_CTL_PERFECT);
 	/* Load the multicast filter. */
 	mue_setiff_locked(un);
 	/* TCP/UDP checksum offload engines. */
 	mue_sethwcsum_locked(un);
 	/* Set MTU. */
 	mue_setmtu_locked(un);
 	return usbnet_init_rx_tx(un);
+}
 static int
 @@ -1255,27 +1279,27 @@ mue_uno_init(struct ifnet *ifp)
 	struct usbnet * const	un = ifp->if_softc;
 	int rv;
 	usbnet_lock_core(un);
 	usbnet_busy(un);
 	rv = mue_init_locked(ifp);
 	usbnet_unbusy(un);
 	usbnet_unlock_core(un);
 	return rv;
+}
 static int
-mue_uno_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+mue_uno_override_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	struct usbnet * const un = ifp->if_softc;
 	usbnet_lock_core(un);
 	usbnet_busy(un);
 	switch (cmd) {
 	case SIOCSIFFLAGS:
 	case SIOCSETHERCAP:
 	case SIOCADDMULTI:
 	case SIOCDELMULTI:
 		mue_setiff_locked(un);
 		break;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uchcom.c,v 1.38 2021/07/14 07:34:16 nisimura Exp $	*/
+/*	$NetBSD: uchcom.c,v 1.39 2021/07/15 03:25:50 nisimura Exp $	*/
 /*
  * Copyright (c) 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Takuya SHIOZAKI (tshiozak@netbsd.org).
+ *
  * 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.
 @@ -20,27 +20,27 @@
  * ``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: uchcom.c,v 1.38 2021/07/14 07:34:16 nisimura Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uchcom.c,v 1.39 2021/07/15 03:25:50 nisimura Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 /*
  * driver for WinChipHead CH341/340, the worst USB-serial chip in the world.
  */
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 @@ -749,27 +749,27 @@ clear_chip(struct uchcom_softc *sc)
+{
 	usbd_status err;
 	DPRINTF(("%s: clear\n", device_xname(sc->sc_dev)));
 	err = generic_control_out(sc, UCHCOM_REQ_RESET, 0, 0);
 	if (err) {
 		device_printf(sc->sc_dev, "cannot clear: %s\n",
 		    usbd_errstr(err));
 		return EIO;
+	}
 	/*
 	 * this REQ_RESET call ends up with
 	 * LCR=0xc0 (8N1)
-	 * PRE=0x02, DIV=0xb2 (19200)
+	 * PRE=0x02, DIV=0xd9 (19200)
 	 */
 	return 0;
+}
 static int
 setup_comm(struct uchcom_softc *sc)
+{
 	int ret;
 	ret = update_version(sc);
 	if (ret)
 		return ret;