 @@ -1,14 +1,14 @@
-/*	$NetBSD: usbnet.c,v 1.22 2019/08/20 06:37:06 mrg Exp $	*/
+/*	$NetBSD: usbnet.c,v 1.23 2019/08/23 04:29:28 mrg Exp $	*/
 /*
  * Copyright (c) 2019 Matthew R. Green
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -23,43 +23,43 @@
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Common code shared between USB network drivers.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: usbnet.c,v 1.22 2019/08/20 06:37:06 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: usbnet.c,v 1.23 2019/08/23 04:29:28 mrg Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include <sys/atomic.h>
 #include <dev/usb/usbnet.h>
 #include <dev/usb/usbhist.h>
 struct usbnet_cdata {
 	struct usbnet_chain	*uncd_tx_chain;
 	struct usbnet_chain	*uncd_rx_chain;
 	int			uncd_tx_prod;
 	int			uncd_tx_cnt;
 	int			uncd_rx_cnt;
 };
 struct usbnet_private {
 	/*
 	 * - unp_lock protects most of the structure, and the public one
 	 * - unp_miilock must be held to access this device's MII bus
 	 * - unp_rxlock protects the rx path and its data
 	 * - unp_txlock protects the tx path and its data
 	 * - unp_detachcv handles detach vs open references
 	 */
 	kmutex_t		unp_lock;
 	kmutex_t		unp_miilock;
 	kmutex_t		unp_rxlock;
 @@ -72,36 +72,39 @@ struct usbnet_private {
 	struct mii_data		unp_mii;
 	struct usb_task		unp_ticktask;
 	struct callout		unp_stat_ch;
 	struct usbd_pipe	*unp_ep[USBNET_ENDPT_MAX];
 	bool			unp_dying;
 	bool			unp_stopping;
 	bool			unp_attached;
 	bool			unp_link;
 	int			unp_refcnt;
 	int			unp_timer;
 	int			unp_if_flags;
 	unsigned		unp_number;
 	krndsource_t		unp_rndsrc;
 	struct timeval		unp_rx_notice;
 	struct timeval		unp_tx_notice;
 	struct timeval		unp_intr_notice;
 };
 #define un_cdata(un)	(&(un)->un_pri->unp_cdata)
 volatile unsigned usbnet_number;
 static int usbnet_modcmd(modcmd_t, void *);
 #ifdef USB_DEBUG
 #ifndef USBNET_DEBUG
 #define usbnetdebug 0
 #else
 static int usbnetdebug = 1;
 SYSCTL_SETUP(sysctl_hw_usbnet_setup, "sysctl hw.usbnet setup")
+{
 	int err;
 	const struct sysctlnode *rnode;
 	const struct sysctlnode *cnode;
 @@ -126,26 +129,28 @@ SYSCTL_SETUP(sysctl_hw_usbnet_setup, "sy
 fail:
 	aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
+}
 #endif /* USBNET_DEBUG */
 #endif /* USB_DEBUG */
 #define DPRINTF(FMT,A,B,C,D)	USBHIST_LOGN(usbnetdebug,1,FMT,A,B,C,D)
 #define DPRINTFN(N,FMT,A,B,C,D)	USBHIST_LOGN(usbnetdebug,N,FMT,A,B,C,D)
 #define USBNETHIST_FUNC()	USBHIST_FUNC()
 #define USBNETHIST_CALLED(name)	USBHIST_CALLED(usbnetdebug)
 #define USBNETHIST_CALLARGS(FMT,A,B,C,D) \
 				USBHIST_CALLARGS(usbnetdebug,FMT,A,B,C,D)
 #define USBNETHIST_CALLARGSN(N,FMT,A,B,C,D) \
 				USBHIST_CALLARGSN(usbnetdebug,N,FMT,A,B,C,D)
 /* Callback vectors. */
 static void
 uno_stop(struct usbnet *un, struct ifnet *ifp, int disable)
+{
 	if (un->un_ops->uno_stop)
 		(*un->un_ops->uno_stop)(ifp, disable);
+}
 static int
 uno_ioctl(struct usbnet *un, struct ifnet *ifp, u_long cmd, void *data)
+{
 @@ -236,86 +241,96 @@ usbnet_newbuf(size_t buflen)
+}
 /*
  * usbnet_rxeof() is designed to be the done callback for rx completion.
  * it provides generic setup and finalisation, calls a different usbnet
  * rx_loop callback in the middle, which can use usbnet_enqueue() to
  * enqueue a packet for higher levels (or usbnet_input() if previously
  * using if_input() path.)
  */
 void
 usbnet_enqueue(struct usbnet * const un, uint8_t *buf, size_t buflen,
 	       int csum_flags, uint32_t csum_data, int mbuf_flags)
+{
-	USBNETHIST_FUNC(); USBNETHIST_CALLED();
+	USBNETHIST_FUNC();
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct usbnet_private * const unp __unused = un->un_pri;
 	struct mbuf *m;
 	USBNETHIST_CALLARGSN(5, "%d: enter: len=%zu csf %x mbf %x",
 	    unp->unp_number, buflen, csum_flags, mbuf_flags);
 	usbnet_isowned_rx(un);
 	m = usbnet_newbuf(buflen);
 	if (m == NULL) {
 		DPRINTF("%d: no memory", unp->unp_number, 0, 0, 0);
 		ifp->if_ierrors++;
 		return;
+	}
 	m_set_rcvif(m, ifp);
 	m->m_pkthdr.csum_flags = csum_flags;
 	m->m_pkthdr.csum_data = csum_data;
 	m->m_flags |= mbuf_flags;
 	memcpy(mtod(m, uint8_t *), buf, buflen);
 	/* push the packet up */
 	if_percpuq_enqueue(ifp->if_percpuq, m);
+}
 void
 usbnet_input(struct usbnet * const un, uint8_t *buf, size_t buflen)
+{
-	USBNETHIST_FUNC(); USBNETHIST_CALLED();
+	USBNETHIST_FUNC();
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct usbnet_private * const unp __unused = un->un_pri;
 	struct mbuf *m;
 	USBNETHIST_CALLARGSN(5, "%d: enter: buf %jx len %ju",
 	    unp->unp_number, (uintptr_t)buf, buflen, 0);
 	usbnet_isowned_rx(un);
 	DPRINTFN(0, "called! un %jx buf %jx len %ju",
 	    (uintmax_t)(uintptr_t)un, (uintmax_t)(uintptr_t)buf, buflen, 0);
 	m = usbnet_newbuf(buflen);
 	if (m == NULL) {
 		ifp->if_ierrors++;
 		return;
+	}
 	m_set_rcvif(m, ifp);
 	memcpy(mtod(m, char *), buf, buflen);
 	/* push the packet up */
 	if_input(ifp, m);
+}
 /*
  * A frame has been uploaded: pass the resulting mbuf chain up to
  * the higher level protocols.
  */
 static void
 usbnet_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
-	USBNETHIST_FUNC(); USBNETHIST_CALLED();
+	USBNETHIST_FUNC();
 	struct usbnet_chain * const c = priv;
 	struct usbnet * const un = c->unc_un;
 	struct usbnet_private * const unp = un->un_pri;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	uint32_t total_len;
 	USBNETHIST_CALLARGSN(5, "%d: enter: status %x xfer %jx",
 	    unp->unp_number, status, (uintptr_t)xfer, 0);
 	mutex_enter(&unp->unp_rxlock);
 	if (unp->unp_dying || unp->unp_stopping ||
 	    status == USBD_INVAL || status == USBD_NOT_STARTED ||
 	    status == USBD_CANCELLED || !(ifp->if_flags & IFF_RUNNING))
 		goto out;
 	if (status != USBD_NORMAL_COMPLETION) {
 		if (usbd_ratecheck(&unp->unp_rx_notice))
 			aprint_error_dev(un->un_dev, "usb errors on rx: %s\n",
 			    usbd_errstr(status));
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(unp->unp_ep[USBNET_ENDPT_RX]);
 @@ -350,26 +365,29 @@ out:
 	mutex_exit(&unp->unp_rxlock);
+}
 static void
 usbnet_txeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet_chain * const c = priv;
 	struct usbnet * const un = c->unc_un;
 	struct usbnet_cdata * const cd = un_cdata(un);
 	struct usbnet_private * const unp = un->un_pri;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	USBNETHIST_CALLARGSN(5, "%d: enter: status %x xfer %jx",
 	    unp->unp_number, status, (uintptr_t)xfer, 0);
 	mutex_enter(&unp->unp_txlock);
 	if (unp->unp_stopping || unp->unp_dying) {
 		mutex_exit(&unp->unp_txlock);
 		return;
+	}
 	KASSERT(cd->uncd_tx_cnt > 0);
 	cd->uncd_tx_cnt--;
 	unp->unp_timer = 0;
 	switch (status) {
 	case USBD_NOT_STARTED:
 @@ -433,52 +451,64 @@ usbnet_start_locked(struct ifnet *ifp)
 	struct mbuf *m;
 	unsigned length;
 	int idx;
 	usbnet_isowned_tx(un);
 	KASSERT(cd->uncd_tx_cnt <= un->un_tx_list_cnt);
 	if (!unp->unp_link || (ifp->if_flags & IFF_RUNNING) == 0) {
 		DPRINTF("start called no link (%x) or running (flags %x)",
 		    unp->unp_link, ifp->if_flags, 0, 0);
 		return;
+	}
 	if (cd->uncd_tx_cnt == un->un_tx_list_cnt) {
 		DPRINTF("start called, tx busy (%jx == %jx)",
 		    cd->uncd_tx_cnt, un->un_tx_list_cnt, 0, 0);
 		return;
+	}
 	idx = cd->uncd_tx_prod;
 	while (cd->uncd_tx_cnt < un->un_tx_list_cnt) {
 		IFQ_POLL(&ifp->if_snd, m);
-		if (m == NULL)
+		if (m == NULL) {
 			DPRINTF("start called, queue empty", 0, 0, 0, 0);
 			break;
+		}
 		KASSERT(m->m_pkthdr.len <= un->un_tx_bufsz);
 		struct usbnet_chain *c = &cd->uncd_tx_chain[idx];
 		length = uno_tx_prepare(un, m, c);
 		if (length == 0) {
 			DPRINTF("uno_tx_prepare gave zero length", 0, 0, 0, 0);
 			ifp->if_oerrors++;
 			break;
+		}
 		if (__predict_false(c->unc_xfer == NULL)) {
 			DPRINTF("unc_xfer is NULL", 0, 0, 0, 0);
 			ifp->if_oerrors++;
 			break;
+		}
 		usbd_setup_xfer(c->unc_xfer, c, c->unc_buf, length,
 		    un->un_tx_xfer_flags, 10000, usbnet_txeof);
 		/* Transmit */
 		usbd_status err = usbd_transfer(c->unc_xfer);
 		if (err != USBD_IN_PROGRESS) {
 			DPRINTF("usbd_transfer on %jx for %ju bytes: %d",
 			    (uintptr_t)c->unc_buf, length, err, 0);
 			ifp->if_oerrors++;
 			break;
+		}
 		IFQ_DEQUEUE(&ifp->if_snd, m);
 		/*
 		 * If there's a BPF listener, bounce a copy of this frame
 		 * to him.
 		 */
 		bpf_mtap(ifp, m, BPF_D_OUT);
 		m_freem(m);
 @@ -655,26 +685,27 @@ static void
 usbnet_tx_list_fini(struct usbnet * const un)
+{
 	struct usbnet_cdata * const cd = un_cdata(un);
 	for (size_t i = 0; i < un->un_tx_list_cnt; i++) {
 		struct usbnet_chain *c = &cd->uncd_tx_chain[i];
 		if (c->unc_xfer != NULL) {
 			usbd_destroy_xfer(c->unc_xfer);
 			c->unc_xfer = NULL;
 			c->unc_buf = NULL;
+		}
+	}
 	cd->uncd_tx_prod = cd->uncd_tx_cnt = 0;
+}
 /* End of common TX functions */
 /* Endpoint pipe management. */
 static void
 usbnet_ep_close_pipes(struct usbnet * const un)
+{
 	struct usbnet_private * const unp = un->un_pri;
 	for (size_t i = 0; i < __arraycount(unp->unp_ep); i++) {
 		if (unp->unp_ep[i] == NULL)
 @@ -966,30 +997,34 @@ usbnet_ifflags_cb(struct ethercom *ec)
 			rv = ENETRESET;
 	} else {
 		rv = ENETRESET;
+	}
 	mutex_exit(&unp->unp_lock);
 	return rv;
+}
 static int
 usbnet_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
-	USBNETHIST_FUNC(); USBNETHIST_CALLED();
+	USBNETHIST_FUNC();
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_private * const unp __unused = un->un_pri;
 	int error;
 	USBNETHIST_CALLARGSN(11, "%d: enter %jx data %x",
 	    unp->unp_number, cmd, (uintptr_t)data, 0);
 	if (un->un_ops->uno_override_ioctl)
 		return uno_override_ioctl(un, ifp, cmd, data);
 	error = ether_ioctl(ifp, cmd, data);
 	if (error == ENETRESET)
 		error = uno_ioctl(un, ifp, cmd, data);
 	return error;
+}
 /*
  * Generic stop network function:
  *	- mark as stopping
 @@ -1067,49 +1102,52 @@ usbnet_tick(void *arg)
 	struct usbnet_private * const unp = un->un_pri;
 	mutex_enter(&unp->unp_lock);
 	if (!unp->unp_stopping && !unp->unp_dying) {
 		/* Perform periodic stuff in process context */
 		usb_add_task(un->un_udev, &unp->unp_ticktask, USB_TASKQ_DRIVER);
+	}
 	mutex_exit(&unp->unp_lock);
+}
 static void
 usbnet_watchdog(struct ifnet *ifp)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = ifp->if_softc;
 	struct usbnet_private * const unp = un->un_pri;
 	struct usbnet_cdata * const cd = un_cdata(un);
 	usbd_status err;
 	ifp->if_oerrors++;
 	aprint_error_dev(un->un_dev, "watchdog timeout\n");
 	if (cd->uncd_tx_cnt > 0) {
 		DPRINTF("uncd_tx_cnt=%u non zero, aborting pipe", 0, 0, 0, 0);
 		err = usbd_abort_pipe(unp->unp_ep[USBNET_ENDPT_TX]);
 		if (err)
 			aprint_error_dev(un->un_dev, "pipe abort failed: %s\n",
 			    usbd_errstr(err));
 		if (cd->uncd_tx_cnt != 0)
 			DPRINTF("uncd_tx_cnt now %u", cd->uncd_tx_cnt, 0, 0, 0);
+	}
 	if (!IFQ_IS_EMPTY(&ifp->if_snd))
 		(*ifp->if_start)(ifp);
+}
 static void
 usbnet_tick_task(void *arg)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet * const un = arg;
 	struct usbnet_private * const unp = un->un_pri;
 	mutex_enter(&unp->unp_lock);
 	if (unp->unp_stopping || unp->unp_dying) {
 		mutex_exit(&unp->unp_lock);
 		return;
+	}
 	struct ifnet * const ifp = usbnet_ifp(un);
 	struct mii_data * const mii = usbnet_mii(un);
 	unp->unp_refcnt++;
 @@ -1310,26 +1348,28 @@ usbnet_attach(struct usbnet *un,
 	mutex_init(&unp->unp_miilock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&unp->unp_txlock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	mutex_init(&unp->unp_rxlock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	mutex_init(&unp->unp_lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&unp->unp_detachcv, detname);
 	rnd_attach_source(&unp->unp_rndsrc, device_xname(un->un_dev),
 	    RND_TYPE_NET, RND_FLAG_DEFAULT);
 	usbnet_rx_list_alloc(un);
 	usbnet_tx_list_alloc(un);
 	unp->unp_number = atomic_inc_uint_nv(&usbnet_number);
 	unp->unp_attached = true;
+}
 static void
 usbnet_attach_mii(struct usbnet *un, const struct usbnet_mii *unm)
+{
 	USBNETHIST_FUNC(); USBNETHIST_CALLED();
 	struct usbnet_private * const unp = un->un_pri;
 	struct mii_data * const mii = &unp->unp_mii;
 	struct ifnet * const ifp = usbnet_ifp(un);
 	KASSERT(un->un_ops->uno_read_reg);
 	KASSERT(un->un_ops->uno_write_reg);