/*      $NetBSD: usbnet.c,v 1.122 2026/02/01 03:33:19 riastradh 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/*
 * Common code shared between USB network drivers.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: usbnet.c,v 1.122 2026/02/01 03:33:19 riastradh 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;
};

struct usbnet_private {
        /*
         * - unp_miilock protects the MII / media data and tick scheduling.
         * - unp_rxlock protects the rx path and its data
         * - unp_txlock protects the tx path and its data
         *
         * the lock ordering is:
         *      ifnet lock -> unp_miilock
         *                 -> unp_rxlock
         *                 -> unp_txlock
         *                 -> unp_mcastlock
         */
        kmutex_t                unp_miilock;
        kmutex_t                unp_rxlock;
        kmutex_t                unp_txlock;

        kmutex_t                unp_mcastlock;
        bool                    unp_mcastactive;

        struct usbnet_cdata     unp_cdata;

        struct ethercom         unp_ec;
        struct mii_data         unp_mii;
        struct usb_task         unp_ticktask;
        struct callout          unp_stat_ch;
        struct usbd_pipe        *unp_ep[USBNET_ENDPT_MAX];

        volatile bool           unp_dying;
        bool                    unp_stopped;
        bool                    unp_rxstopped;
        bool                    unp_txstopped;
        bool                    unp_attached;
        bool                    unp_ifp_attached;
        bool                    unp_link;

        int                     unp_timer;
        unsigned short          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 void usbnet_isowned_rx(struct usbnet *);
static void usbnet_isowned_tx(struct usbnet *);

static inline void
usbnet_isowned_mii(struct usbnet *un)
{
        KASSERT(mutex_owned(&un->un_pri->unp_miilock));
}

static int usbnet_modcmd(modcmd_t, void *);

#ifdef USB_DEBUG
#ifndef USBNET_DEBUG
#define usbnetdebug 0
#else
static int usbnetdebug = 0;

SYSCTL_SETUP(sysctl_hw_usbnet_setup, "sysctl hw.usbnet setup")
{
        int err;
        const struct sysctlnode *rnode;
        const struct sysctlnode *cnode;

        err = sysctl_createv(clog, 0, NULL, &rnode,
            CTLFLAG_PERMANENT, CTLTYPE_NODE, "usbnet",
            SYSCTL_DESCR("usbnet 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, &usbnetdebug, sizeof(usbnetdebug), CTL_CREATE, CTL_EOL);
        if (err)
                goto fail;

        return;
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)
{
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        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)
{

        KASSERTMSG(cmd != SIOCADDMULTI, "%s", ifp->if_xname);
        KASSERTMSG(cmd != SIOCDELMULTI, "%s", ifp->if_xname);
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);

        if (un->un_ops->uno_ioctl)
                return (*un->un_ops->uno_ioctl)(ifp, cmd, data);
        return 0;
}

static int
uno_override_ioctl(struct usbnet *un, struct ifnet *ifp, u_long cmd, void *data)
{

        switch (cmd) {
        case SIOCADDMULTI:
        case SIOCDELMULTI:
                break;
        default:
                KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        }

        return (*un->un_ops->uno_override_ioctl)(ifp, cmd, data);
}

static int
uno_init(struct usbnet *un, struct ifnet *ifp)
{
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        return un->un_ops->uno_init ? (*un->un_ops->uno_init)(ifp) : 0;
}

static int
uno_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
{
        usbnet_isowned_mii(un);
        return (*un->un_ops->uno_read_reg)(un, phy, reg, val);
}

static int
uno_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
{
        usbnet_isowned_mii(un);
        return (*un->un_ops->uno_write_reg)(un, phy, reg, val);
}

static void
uno_mii_statchg(struct usbnet *un, struct ifnet *ifp)
{
        usbnet_isowned_mii(un);
        (*un->un_ops->uno_statchg)(ifp);
}

static unsigned
uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
{
        usbnet_isowned_tx(un);
        return (*un->un_ops->uno_tx_prepare)(un, m, c);
}

static void
uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len)
{
        usbnet_isowned_rx(un);
        (*un->un_ops->uno_rx_loop)(un, c, total_len);
}

static void
uno_tick(struct usbnet *un)
{
        if (un->un_ops->uno_tick)
                (*un->un_ops->uno_tick)(un);
}

static void
uno_intr(struct usbnet *un, usbd_status status)
{
        if (un->un_ops->uno_intr)
                (*un->un_ops->uno_intr)(un, status);
}

/* Interrupt handling. */

static struct mbuf *
usbnet_newbuf(size_t buflen)
{
        struct mbuf *m;

        if (buflen > MCLBYTES - ETHER_ALIGN)
                return NULL;

        MGETHDR(m, M_DONTWAIT, MT_DATA);
        if (m == NULL)
                return NULL;

        if (buflen > MHLEN - ETHER_ALIGN) {
                MCLGET(m, M_DONTWAIT);
                if (!(m->m_flags & M_EXT)) {
                        m_freem(m);
                        return NULL;
                }
        }

        m->m_len = m->m_pkthdr.len = ETHER_ALIGN + buflen;
        m_adj(m, ETHER_ALIGN);

        return m;
}

/*
 * 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();
        struct ifnet * const ifp = usbnet_ifp(un);
        struct usbnet_private * const unp __unused = un->un_pri;
        struct mbuf *m;

        USBNETHIST_CALLARGSN(5, "%jd: enter: len=%ju csf %#jx mbf %#jx",
            unp->unp_number, buflen, csum_flags, mbuf_flags);

        usbnet_isowned_rx(un);

        m = usbnet_newbuf(buflen);
        if (m == NULL) {
                DPRINTF("%jd: no memory", unp->unp_number, 0, 0, 0);
                if_statinc(ifp, if_ierrors);
                return;
        }
        MCLAIM(m, &unp->unp_ec.ec_rx_mowner);

        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();
        struct ifnet * const ifp = usbnet_ifp(un);
        struct usbnet_private * const unp __unused = un->un_pri;
        struct mbuf *m;

        USBNETHIST_CALLARGSN(5, "%jd: enter: buf %#jx len %ju",
            unp->unp_number, (uintptr_t)buf, buflen, 0);

        usbnet_isowned_rx(un);

        m = usbnet_newbuf(buflen);
        if (m == NULL) {
                if_statinc(ifp, if_ierrors);
                return;
        }
        MCLAIM(m, &unp->unp_ec.ec_rx_mowner);

        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();
        struct usbnet_chain * const c = priv;
        struct usbnet * const un = c->unc_un;
        struct usbnet_private * const unp = un->un_pri;
        uint32_t total_len;

        USBNETHIST_CALLARGSN(5, "%jd: enter: status %#jx xfer %#jx",
            unp->unp_number, status, (uintptr_t)xfer, 0);

        mutex_enter(&unp->unp_rxlock);

        if (usbnet_isdying(un) || unp->unp_rxstopped ||
            status == USBD_INVAL || status == USBD_NOT_STARTED ||
            status == USBD_CANCELLED)
                goto out;

        if (status != USBD_NORMAL_COMPLETION) {
                if (usbd_ratecheck(&unp->unp_rx_notice))
                        device_printf(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]);
                goto done;
        }

        usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);

        if (total_len > un->un_rx_bufsz) {
                device_printf(un->un_dev,
                    "rxeof: too large transfer (%u > %u)\n",
                    total_len, un->un_rx_bufsz);
                goto done;
        }

        uno_rx_loop(un, c, total_len);
        usbnet_isowned_rx(un);

done:
        if (usbnet_isdying(un) || unp->unp_rxstopped)
                goto out;

        mutex_exit(&unp->unp_rxlock);

        /* Setup new transfer. */
        usbd_setup_xfer(xfer, c, c->unc_buf, un->un_rx_bufsz,
            un->un_rx_xfer_flags, USBD_NO_TIMEOUT, usbnet_rxeof);
        usbd_transfer(xfer);
        return;

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, "%jd: enter: status %#jx xfer %#jx",
            unp->unp_number, status, (uintptr_t)xfer, 0);

        mutex_enter(&unp->unp_txlock);
        if (unp->unp_txstopped || usbnet_isdying(un)) {
                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:
        case USBD_CANCELLED:
                break;

        case USBD_NORMAL_COMPLETION:
                if_statinc(ifp, if_opackets);
                break;

        default:

                if_statinc(ifp, if_oerrors);
                if (usbd_ratecheck(&unp->unp_tx_notice))
                        device_printf(un->un_dev, "usb error on tx: %s\n",
                            usbd_errstr(status));
                if (status == USBD_STALLED)
                        usbd_clear_endpoint_stall_async(unp->unp_ep[USBNET_ENDPT_TX]);
                break;
        }

        mutex_exit(&unp->unp_txlock);

        if (status == USBD_NORMAL_COMPLETION && !IFQ_IS_EMPTY(&ifp->if_snd))
                (*ifp->if_start)(ifp);
}

static void
usbnet_pipe_intr(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
        USBNETHIST_FUNC();
        struct usbnet * const un = priv;
        struct usbnet_private * const unp = un->un_pri;
        struct usbnet_intr * const uni __unused = un->un_intr;

        if (usbnet_isdying(un) ||
            status == USBD_INVAL || status == USBD_NOT_STARTED ||
            status == USBD_CANCELLED) {
                USBNETHIST_CALLARGS("%jd: uni %#jx dying %#jx status %#jx",
                    unp->unp_number, (uintptr_t)uni,
                    usbnet_isdying(un), status);
                return;
        }

        if (status != USBD_NORMAL_COMPLETION) {
                if (usbd_ratecheck(&unp->unp_intr_notice)) {
                        device_printf(un->un_dev, "usb error on intr: %s\n",
                            usbd_errstr(status));
                }
                if (status == USBD_STALLED)
                        usbd_clear_endpoint_stall_async(unp->unp_ep[USBNET_ENDPT_INTR]);
                USBNETHIST_CALLARGS("%jd: not normal status %#jx",
                    unp->unp_number, status, 0, 0);
                return;
        }

        uno_intr(un, status);
}

static void
usbnet_start_locked(struct ifnet *ifp)
{
        USBNETHIST_FUNC();
        struct usbnet * const un = ifp->if_softc;
        struct usbnet_cdata * const cd = un_cdata(un);
        struct usbnet_private * const unp = un->un_pri;
        struct mbuf *m;
        unsigned length;
        bool done_transmit = false;
        int idx, count;

        USBNETHIST_CALLARGS("%jd: tx_cnt %jd list_cnt %jd link %jd",
            unp->unp_number, cd->uncd_tx_cnt, un->un_tx_list_cnt,
            unp->unp_link);

        usbnet_isowned_tx(un);
        KASSERT(cd->uncd_tx_cnt <= un->un_tx_list_cnt);
        KASSERT(!unp->unp_txstopped);

        if (!unp->unp_link) {
                DPRINTF("start called no link (%jx)",
                    unp->unp_link, 0, 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;
        count = 0;
        while (cd->uncd_tx_cnt < un->un_tx_list_cnt) {
                IFQ_DEQUEUE(&ifp->if_snd, m);
                if (m == NULL) {
                        DPRINTF("start called, queue empty", 0, 0, 0, 0);
                        break;
                }
                if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz) {
                        DPRINTF("oversize packet, %ju > %ju",
                            (unsigned)m->m_pkthdr.len, un->un_tx_bufsz, 0, 0);
                        if_statinc(ifp, if_oerrors);
                        m_freem(m);
                        continue;
                }
                KASSERTMSG((unsigned)m->m_pkthdr.len <= un->un_tx_bufsz,
                    "m->m_pkthdr.len=%d bufsz=%u",
                    m->m_pkthdr.len, un->un_tx_bufsz);

                struct usbnet_chain *const c = &cd->uncd_tx_chain[idx];
                KASSERT(c->unc_xfer != NULL);

                length = uno_tx_prepare(un, m, c);
                if (length == 0) {
                        DPRINTF("uno_tx_prepare gave zero length", 0, 0, 0, 0);
                        if_statinc(ifp, if_oerrors);
                        m_freem(m);
                        continue;
                }

                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: %jd",
                            (uintptr_t)c->unc_buf, length, err, 0);
                        if_statinc(ifp, if_oerrors);
                        m_freem(m);
                        continue;
                }
                done_transmit = true;

                /*
                 * If there's a BPF listener, bounce a copy of this frame
                 * to him.
                 */
                bpf_mtap(ifp, m, BPF_D_OUT);
                m_freem(m);

                idx = (idx + 1) % un->un_tx_list_cnt;
                cd->uncd_tx_cnt++;
                count++;
        }
        cd->uncd_tx_prod = idx;

        DPRINTF("finished with start; tx_cnt %jd list_cnt %jd link %jd",
            cd->uncd_tx_cnt, un->un_tx_list_cnt, unp->unp_link, 0);

        /*
         * Set a timeout in case the chip goes out to lunch.
         */
        if (done_transmit)
                unp->unp_timer = 5;

        if (count != 0)
                rnd_add_uint32(&unp->unp_rndsrc, count);
}

static void
usbnet_if_start(struct ifnet *ifp)
{
        struct usbnet * const un = ifp->if_softc;
        struct usbnet_private * const unp = un->un_pri;

        USBNETHIST_FUNC();
        USBNETHIST_CALLARGS("%jd: txstopped %jd",
            unp->unp_number, unp->unp_txstopped, 0, 0);

        mutex_enter(&unp->unp_txlock);
        if (!unp->unp_txstopped)
                usbnet_start_locked(ifp);
        mutex_exit(&unp->unp_txlock);
}

/*
 * Chain management.
 *
 * RX and TX are identical. Keep them that way.
 */

/* Start of common RX functions */

static size_t
usbnet_rx_list_size(struct usbnet_cdata * const cd, struct usbnet * const un)
{
        return sizeof(*cd->uncd_rx_chain) * un->un_rx_list_cnt;
}

static void
usbnet_rx_list_alloc(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);

        cd->uncd_rx_chain = kmem_zalloc(usbnet_rx_list_size(cd, un), KM_SLEEP);
}

static void
usbnet_rx_list_free(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);

        if (cd->uncd_rx_chain) {
                kmem_free(cd->uncd_rx_chain, usbnet_rx_list_size(cd, un));
                cd->uncd_rx_chain = NULL;
        }
}

static int
usbnet_rx_list_init(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);
        struct usbnet_private * const unp = un->un_pri;

        for (size_t i = 0; i < un->un_rx_list_cnt; i++) {
                struct usbnet_chain *c = &cd->uncd_rx_chain[i];

                c->unc_un = un;
                if (c->unc_xfer == NULL) {
                        int err = usbd_create_xfer(unp->unp_ep[USBNET_ENDPT_RX],
                            un->un_rx_bufsz, un->un_rx_xfer_flags, 0,
                            &c->unc_xfer);
                        if (err)
                                return err;
                        c->unc_buf = usbd_get_buffer(c->unc_xfer);
                }
        }

        return 0;
}

static void
usbnet_rx_list_fini(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);

        for (size_t i = 0; i < un->un_rx_list_cnt; i++) {
                struct usbnet_chain *c = &cd->uncd_rx_chain[i];

                if (c->unc_xfer != NULL) {
                        usbd_destroy_xfer(c->unc_xfer);
                        c->unc_xfer = NULL;
                        c->unc_buf = NULL;
                }
        }
}

/* End of common RX functions */

static void
usbnet_rx_start_pipes(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);
        struct usbnet_private * const unp = un->un_pri;

        mutex_enter(&unp->unp_rxlock);
        KASSERT(unp->unp_rxstopped);
        unp->unp_rxstopped = false;

        for (size_t i = 0; i < un->un_rx_list_cnt; i++) {
                struct usbnet_chain *c = &cd->uncd_rx_chain[i];

                usbd_setup_xfer(c->unc_xfer, c, c->unc_buf, un->un_rx_bufsz,
                    un->un_rx_xfer_flags, USBD_NO_TIMEOUT, usbnet_rxeof);
                usbd_transfer(c->unc_xfer);
        }

        mutex_exit(&unp->unp_rxlock);
}

/* Start of common TX functions */

static size_t
usbnet_tx_list_size(struct usbnet_cdata * const cd, struct usbnet * const un)
{
        return sizeof(*cd->uncd_tx_chain) * un->un_tx_list_cnt;
}

static void
usbnet_tx_list_alloc(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);

        cd->uncd_tx_chain = kmem_zalloc(usbnet_tx_list_size(cd, un), KM_SLEEP);
}

static void
usbnet_tx_list_free(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);

        if (cd->uncd_tx_chain) {
                kmem_free(cd->uncd_tx_chain, usbnet_tx_list_size(cd, un));
                cd->uncd_tx_chain = NULL;
        }
}

static int
usbnet_tx_list_init(struct usbnet * const un)
{
        struct usbnet_cdata * const cd = un_cdata(un);
        struct usbnet_private * const unp = un->un_pri;

        for (size_t i = 0; i < un->un_tx_list_cnt; i++) {
                struct usbnet_chain *c = &cd->uncd_tx_chain[i];

                c->unc_un = un;
                if (c->unc_xfer == NULL) {
                        int err = usbd_create_xfer(unp->unp_ep[USBNET_ENDPT_TX],
                            un->un_tx_bufsz, un->un_tx_xfer_flags, 0,
                            &c->unc_xfer);
                        if (err)
                                return err;
                        c->unc_buf = usbd_get_buffer(c->unc_xfer);
                }
        }

        return 0;
}

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)
                        continue;
                usbd_close_pipe(unp->unp_ep[i]);
                unp->unp_ep[i] = NULL;
        }
}

static usbd_status
usbnet_ep_open_pipes(struct usbnet * const un)
{
        struct usbnet_intr * const uni = un->un_intr;
        struct usbnet_private * const unp = un->un_pri;

        for (size_t i = 0; i < __arraycount(unp->unp_ep); i++) {
                usbd_status err;

                if (un->un_ed[i] == 0)
                        continue;

                if (i == USBNET_ENDPT_INTR && uni) {
                        err = usbd_open_pipe_intr(un->un_iface, un->un_ed[i],
                            USBD_EXCLUSIVE_USE | USBD_MPSAFE, &unp->unp_ep[i], un,
                            uni->uni_buf, uni->uni_bufsz, usbnet_pipe_intr,
                            uni->uni_interval);
                } else {
                        err = usbd_open_pipe(un->un_iface, un->un_ed[i],
                            USBD_EXCLUSIVE_USE | USBD_MPSAFE, &unp->unp_ep[i]);
                }
                if (err) {
                        usbnet_ep_close_pipes(un);
                        return err;
                }
        }

        return USBD_NORMAL_COMPLETION;
}

static void
usbnet_ep_stop_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)
                        continue;
                usbd_abort_pipe(unp->unp_ep[i]);
        }
}

static int
usbnet_init_rx_tx(struct usbnet * const un)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct usbnet_private * const unp = un->un_pri;
        struct ifnet * const ifp = usbnet_ifp(un);
        usbd_status err;
        int error = 0;

        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);

        if (usbnet_isdying(un)) {
                return EIO;
        }

        /* Open RX and TX pipes. */
        err = usbnet_ep_open_pipes(un);
        if (err) {
                aprint_error_dev(un->un_dev, "open rx/tx pipes failed: %s\n",
                    usbd_errstr(err));
                error = EIO;
                goto out;
        }

        /* Init RX ring. */
        if (usbnet_rx_list_init(un)) {
                aprint_error_dev(un->un_dev, "rx list init failed\n");
                error = ENOBUFS;
                goto out;
        }

        /* Init TX ring. */
        if (usbnet_tx_list_init(un)) {
                aprint_error_dev(un->un_dev, "tx list init failed\n");
                error = ENOBUFS;
                goto out;
        }

        /* Indicate we are up and running. */
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        ifp->if_flags |= IFF_RUNNING;

        /*
         * If the hardware has a multicast filter, program it and then
         * allow updates to it while we're running.
         */
        if (un->un_ops->uno_mcast) {
                mutex_enter(&unp->unp_mcastlock);
                KASSERTMSG(!unp->unp_mcastactive, "%s", ifp->if_xname);
                unp->unp_if_flags = ifp->if_flags;
                (*un->un_ops->uno_mcast)(ifp);
                unp->unp_mcastactive = true;
                mutex_exit(&unp->unp_mcastlock);
        }

        /* Allow transmit.  */
        mutex_enter(&unp->unp_txlock);
        KASSERT(unp->unp_txstopped);
        unp->unp_txstopped = false;
        mutex_exit(&unp->unp_txlock);

        /* Start up the receive pipe(s). */
        usbnet_rx_start_pipes(un);

        /* Kick off the watchdog/stats/mii tick.  */
        mutex_enter(&unp->unp_miilock);
        unp->unp_stopped = false;
        callout_schedule(&unp->unp_stat_ch, hz);
        mutex_exit(&unp->unp_miilock);

out:
        if (error) {
                usbnet_rx_list_fini(un);
                usbnet_tx_list_fini(un);
                usbnet_ep_close_pipes(un);
        }

        /*
         * For devices without any media autodetection, treat success
         * here as an active link.
         */
        if (un->un_ops->uno_statchg == NULL) {
                mutex_enter(&unp->unp_miilock);
                usbnet_set_link(un, error == 0);
                mutex_exit(&unp->unp_miilock);
        }

        return error;
}

/* MII management. */

static int
usbnet_mii_readreg(device_t dev, int phy, int reg, uint16_t *val)
{
        USBNETHIST_FUNC();
        struct usbnet * const un = device_private(dev);
        int err;

        /* MII layer ensures miilock is held. */
        usbnet_isowned_mii(un);

        if (usbnet_isdying(un)) {
                return EIO;
        }

        err = uno_read_reg(un, phy, reg, val);
        if (err) {
                USBNETHIST_CALLARGS("%jd: read PHY failed: %jd",
                    un->un_pri->unp_number, err, 0, 0);
                return err;
        }

        return 0;
}

static int
usbnet_mii_writereg(device_t dev, int phy, int reg, uint16_t val)
{
        USBNETHIST_FUNC();
        struct usbnet * const un = device_private(dev);
        int err;

        /* MII layer ensures miilock is held. */
        usbnet_isowned_mii(un);

        if (usbnet_isdying(un)) {
                return EIO;
        }

        err = uno_write_reg(un, phy, reg, val);
        if (err) {
                USBNETHIST_CALLARGS("%jd: write PHY failed: %jd",
                    un->un_pri->unp_number, err, 0, 0);
                return err;
        }

        return 0;
}

static void
usbnet_mii_statchg(struct ifnet *ifp)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct usbnet * const un = ifp->if_softc;

        /* MII layer ensures miilock is held. */
        usbnet_isowned_mii(un);

        uno_mii_statchg(un, ifp);
}

static int
usbnet_media_upd(struct ifnet *ifp)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct usbnet * const un = ifp->if_softc;
        struct usbnet_private * const unp = un->un_pri;
        struct mii_data * const mii = usbnet_mii(un);

        /* ifmedia layer ensures miilock is held. */
        usbnet_isowned_mii(un);

        /* ifmedia changes only with IFNET_LOCK held.  */
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);

        if (usbnet_isdying(un))
                return EIO;

        unp->unp_link = false;

        if (mii->mii_instance) {
                struct mii_softc *miisc;

                LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
                        mii_phy_reset(miisc);
        }

        return ether_mediachange(ifp);
}

/* ioctl */

/*
 * usbnet_ifflags_cb(ec)
 *
 *      Called by if_ethersubr when interface flags change
 *      (SIOCSIFFLAGS), or ethernet capabilities change
 *      (SIOCSETHERCAP), on a running interface.
 */
static int
usbnet_ifflags_cb(struct ethercom *ec)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct ifnet *ifp = &ec->ec_if;
        struct usbnet *un = ifp->if_softc;
        struct usbnet_private * const unp = un->un_pri;

        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);

        const u_short changed = ifp->if_flags ^ unp->unp_if_flags;

        /*
         * If any user-settable flags have changed other than
         * IFF_DEBUG, just reset the interface.
         */
        if ((changed & ~(IFF_CANTCHANGE | IFF_DEBUG)) != 0)
                return ENETRESET;

        /*
         * Otherwise, cache the flags change so we can read the flags
         * under unp_mcastlock for multicast updates in SIOCADDMULTI or
         * SIOCDELMULTI without IFNET_LOCK.
         */
        mutex_enter(&unp->unp_mcastlock);
        unp->unp_if_flags = ifp->if_flags;
        mutex_exit(&unp->unp_mcastlock);

        /*
         * If we're switching on or off promiscuous mode, reprogram the
         * hardware multicast filter now.
         *
         * XXX Actually, reset the interface, because some usbnet
         * drivers (e.g., aue(4)) initialize the hardware differently
         * in uno_init depending on IFF_PROMISC.  But some (again,
         * aue(4)) _also_ need to know whether IFF_PROMISC is set in
         * uno_mcast and do something different with it there.  Maybe
         * the logic can be unified, but it will require an audit and
         * testing of all the usbnet drivers.
         */
        if (changed & IFF_PROMISC)
                return ENETRESET;

        return 0;
}

bool
usbnet_ispromisc(struct usbnet *un)
{
        struct ifnet * const ifp = usbnet_ifp(un);
        struct usbnet_private * const unp = un->un_pri;

        KASSERTMSG(mutex_owned(&unp->unp_mcastlock) || IFNET_LOCKED(ifp),
            "%s", ifp->if_xname);

        return unp->unp_if_flags & IFF_PROMISC;
}

static int
usbnet_if_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
        USBNETHIST_FUNC();
        struct usbnet * const un = ifp->if_softc;
        struct usbnet_private * const unp __unused = un->un_pri;
        int error;

        USBNETHIST_CALLARGSN(11, "%jd: enter %#jx data %#jx",
            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) {
                switch (cmd) {
                case SIOCADDMULTI:
                case SIOCDELMULTI:
                        /*
                         * If there's a hardware multicast filter, and
                         * it has been programmed by usbnet_init_rx_tx
                         * and is active, update it now.  Otherwise,
                         * drop the update on the floor -- it will be
                         * observed by usbnet_init_rx_tx next time we
                         * bring the interface up.
                         */
                        if (un->un_ops->uno_mcast) {
                                mutex_enter(&unp->unp_mcastlock);
                                if (unp->unp_mcastactive)
                                        (*un->un_ops->uno_mcast)(ifp);
                                mutex_exit(&unp->unp_mcastlock);
                        }
                        error = 0;
                        break;
                default:
                        error = uno_ioctl(un, ifp, cmd, data);
                }
        }

        return error;
}

/*
 * Generic stop network function:
 *      - mark as stopping
 *      - call DD routine to stop the device
 *      - turn off running, timer, statchg callout, link
 *      - stop transfers
 *      - free RX and TX resources
 *      - close pipes
 *
 * usbnet_if_stop() is for the if_stop handler.
 */
static void
usbnet_stop(struct usbnet *un, struct ifnet *ifp, int disable)
{
        struct usbnet_private * const unp = un->un_pri;
        struct mii_data * const mii = usbnet_mii(un);

        USBNETHIST_FUNC(); USBNETHIST_CALLED();

        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        KASSERTMSG(ifp->if_flags & IFF_RUNNING, "%s", ifp->if_xname);

        /*
         * For drivers with hardware multicast filter update callbacks:
         * Prevent concurrent access to the hardware registers by
         * multicast filter updates, which happens without IFNET_LOCK.
         */
        if (un->un_ops->uno_mcast) {
                mutex_enter(&unp->unp_mcastlock);
                KASSERTMSG(unp->unp_mcastactive, "%p", ifp->if_xname);
                unp->unp_mcastactive = false;
                unp->unp_if_flags = 0;
                mutex_exit(&unp->unp_mcastlock);
        }

        /*
         * Prevent new activity (rescheduling ticks, xfers, &c.) and
         * clear the watchdog timer.
         */
        mutex_enter(&unp->unp_miilock);
        unp->unp_stopped = true;
        mutex_exit(&unp->unp_miilock);

        mutex_enter(&unp->unp_rxlock);
        unp->unp_rxstopped = true;
        mutex_exit(&unp->unp_rxlock);

        mutex_enter(&unp->unp_txlock);
        unp->unp_txstopped = true;
        unp->unp_timer = 0;
        mutex_exit(&unp->unp_txlock);

        /*
         * Stop the timer first, then the task -- if the timer was
         * already firing, we stop the task or wait for it complete
         * only after it last fired.  Setting unp_stopped prevents the
         * timer task from being scheduled again.
         */
        callout_halt(&unp->unp_stat_ch, NULL);
        usb_rem_task_wait(un->un_udev, &unp->unp_ticktask, USB_TASKQ_DRIVER,
            NULL);

        /*
         * Now that we have stopped calling mii_tick, bring the MII
         * state machine down.
         */
        if (mii) {
                mutex_enter(&unp->unp_miilock);
                mii_down(mii);
                mutex_exit(&unp->unp_miilock);
        }

        /* Stop transfers. */
        usbnet_ep_stop_pipes(un);

        /*
         * Now that the software is quiescent, ask the driver to stop
         * the hardware.  The driver's uno_stop routine now has
         * exclusive access to any registers that might previously have
         * been used by to ifmedia, mii, or ioctl callbacks.
         *
         * Don't bother if the device is being detached, though -- if
         * it's been unplugged then there's no point in trying to touch
         * the registers.
         */
        if (!usbnet_isdying(un))
                uno_stop(un, ifp, disable);

        /* Free RX/TX resources. */
        usbnet_rx_list_fini(un);
        usbnet_tx_list_fini(un);

        /* Close pipes. */
        usbnet_ep_close_pipes(un);

        /* Everything is quesced now. */
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        ifp->if_flags &= ~IFF_RUNNING;
}

static void
usbnet_if_stop(struct ifnet *ifp, int disable)
{
        struct usbnet * const un = ifp->if_softc;

        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);

        /*
         * If we're already stopped, nothing to do.
         *
         * XXX This should be an assertion, but it may require some
         * analysis -- and possibly some tweaking -- of sys/net to
         * ensure.
         */
        if ((ifp->if_flags & IFF_RUNNING) == 0)
                return;

        usbnet_stop(un, ifp, disable);
}

/*
 * Generic tick task function.
 *
 * usbnet_tick() is triggered from a callout, and triggers a call to
 * usbnet_tick_task() from the usb_task subsystem.
 */
static void
usbnet_tick(void *arg)
{
        USBNETHIST_FUNC();
        struct usbnet * const un = arg;
        struct usbnet_private * const unp = un->un_pri;

        USBNETHIST_CALLARGSN(10, "%jd: enter", unp->unp_number, 0, 0, 0);

        /* Perform periodic stuff in process context */
        usb_add_task(un->un_udev, &unp->unp_ticktask, USB_TASKQ_DRIVER);
}

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);

        if_statinc(ifp, if_oerrors);
        device_printf(un->un_dev, "watchdog timeout\n");

        if (cd->uncd_tx_cnt > 0) {
                DPRINTF("uncd_tx_cnt=%ju non zero, aborting pipe", 0, 0, 0, 0);
                usbd_abort_pipe(unp->unp_ep[USBNET_ENDPT_TX]);
                if (cd->uncd_tx_cnt != 0)
                        DPRINTF("uncd_tx_cnt now %ju", 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();
        struct usbnet * const un = arg;
        struct usbnet_private * const unp = un->un_pri;
        struct ifnet * const ifp = usbnet_ifp(un);
        struct mii_data * const mii = usbnet_mii(un);

        USBNETHIST_CALLARGSN(8, "%jd: enter", unp->unp_number, 0, 0, 0);

        mutex_enter(&unp->unp_txlock);
        const bool timeout = unp->unp_timer != 0 && --unp->unp_timer == 0;
        mutex_exit(&unp->unp_txlock);
        if (timeout)
                usbnet_watchdog(ifp);

        /* Call driver if requested. */
        uno_tick(un);

        mutex_enter(&unp->unp_miilock);
        DPRINTFN(8, "mii %#jx ifp %#jx", (uintptr_t)mii, (uintptr_t)ifp, 0, 0);
        if (mii) {
                mii_tick(mii);
                if (!unp->unp_link)
                        (*mii->mii_statchg)(ifp);
        }

        if (!unp->unp_stopped && !usbnet_isdying(un))
                callout_schedule(&unp->unp_stat_ch, hz);
        mutex_exit(&unp->unp_miilock);
}

static int
usbnet_if_init(struct ifnet *ifp)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct usbnet * const un = ifp->if_softc;
        int error;

        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);

        /*
         * Prevent anyone from bringing the interface back up once
         * we're detaching.
         */
        if (usbnet_isdying(un))
                return EIO;

        /*
         * If we're already running, stop the interface first -- we're
         * reinitializing it.
         *
         * XXX Grody for sys/net to call if_init to reinitialize.  This
         * should be an assertion, not a branch, but it will require
         * some tweaking of sys/net to avoid.  See also the comment in
         * usbnet_ifflags_cb about if_init vs uno_mcast on reinitialize.
         */
        if (ifp->if_flags & IFF_RUNNING)
                usbnet_stop(un, ifp, /*disable*/1/*XXX???*/);
        KASSERTMSG((ifp->if_flags & IFF_RUNNING) == 0, "%s", ifp->if_xname);

        error = uno_init(un, ifp);
        if (error)
                return error;
        error = usbnet_init_rx_tx(un);
        if (error)
                return error;

        return 0;
}


/* Various accessors. */

void
usbnet_set_link(struct usbnet *un, bool link)
{
        usbnet_isowned_mii(un);
        un->un_pri->unp_link = link;
}

struct ifnet *
usbnet_ifp(struct usbnet *un)
{
        return &un->un_pri->unp_ec.ec_if;
}

struct ethercom *
usbnet_ec(struct usbnet *un)
{
        return &un->un_pri->unp_ec;
}

struct mii_data *
usbnet_mii(struct usbnet *un)
{
        return un->un_pri->unp_ec.ec_mii;
}

krndsource_t *
usbnet_rndsrc(struct usbnet *un)
{
        return &un->un_pri->unp_rndsrc;
}

void *
usbnet_softc(struct usbnet *un)
{
        return un->un_sc;
}

bool
usbnet_havelink(struct usbnet *un)
{
        return un->un_pri->unp_link;
}

bool
usbnet_isdying(struct usbnet *un)
{
        return atomic_load_relaxed(&un->un_pri->unp_dying);
}


/* Locking. */

static void
usbnet_isowned_rx(struct usbnet *un)
{
        KASSERT(mutex_owned(&un->un_pri->unp_rxlock));
}

static void
usbnet_isowned_tx(struct usbnet *un)
{
        KASSERT(mutex_owned(&un->un_pri->unp_txlock));
}

/* Autoconf management. */

static bool
usbnet_empty_eaddr(struct usbnet * const un)
{
        return (un->un_eaddr[0] == 0 && un->un_eaddr[1] == 0 &&
                un->un_eaddr[2] == 0 && un->un_eaddr[3] == 0 &&
                un->un_eaddr[4] == 0 && un->un_eaddr[5] == 0);
}

/*
 * usbnet_attach() and usbnet_attach_ifp() perform setup of the relevant
 * 'usbnet'.  The first is enough to enable device access (eg, endpoints
 * are connected and commands can be sent), and the second connects the
 * device to the system networking.
 *
 * Always call usbnet_detach(), even if usbnet_attach_ifp() is skipped.
 * Also usable as driver detach directly.
 *
 * To skip ethernet configuration (eg, point-to-point), make sure that
 * the un_eaddr[] is fully zero.
 */

void
usbnet_attach(struct usbnet *un)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();

        /* Required inputs.  */
        KASSERT(un->un_ops->uno_tx_prepare);
        KASSERT(un->un_ops->uno_rx_loop);
        KASSERT(un->un_rx_bufsz);
        KASSERT(un->un_tx_bufsz);
        KASSERT(un->un_rx_list_cnt);
        KASSERT(un->un_tx_list_cnt);

        /* Unfortunate fact.  */
        KASSERT(un == device_private(un->un_dev));

        un->un_pri = kmem_zalloc(sizeof(*un->un_pri), KM_SLEEP);
        struct usbnet_private * const unp = un->un_pri;

        usb_init_task(&unp->unp_ticktask, usbnet_tick_task, un,
            USB_TASKQ_MPSAFE);
        callout_init(&unp->unp_stat_ch, CALLOUT_MPSAFE);
        callout_setfunc(&unp->unp_stat_ch, usbnet_tick, un);

        mutex_init(&unp->unp_txlock, MUTEX_DEFAULT, IPL_SOFTUSB);
        mutex_init(&unp->unp_rxlock, MUTEX_DEFAULT, IPL_SOFTUSB);
        mutex_init(&unp->unp_miilock, MUTEX_DEFAULT, IPL_NONE);
        mutex_init(&unp->unp_mcastlock, MUTEX_DEFAULT, IPL_SOFTCLOCK);

        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_stopped = true;
        unp->unp_rxstopped = true;
        unp->unp_txstopped = true;
        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);
        KASSERT(un->un_ops->uno_statchg);

        mii->mii_ifp = ifp;
        mii->mii_readreg = usbnet_mii_readreg;
        mii->mii_writereg = usbnet_mii_writereg;
        mii->mii_statchg = usbnet_mii_statchg;
        mii->mii_flags = MIIF_AUTOTSLEEP;

        usbnet_ec(un)->ec_mii = mii;
        ifmedia_init_with_lock(&mii->mii_media, 0,
            usbnet_media_upd, ether_mediastatus, &unp->unp_miilock);
        mii_attach(un->un_dev, mii, unm->un_mii_capmask, unm->un_mii_phyloc,
            unm->un_mii_offset, unm->un_mii_flags);

        if (LIST_FIRST(&mii->mii_phys) == NULL) {
                ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
                ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
        } else
                ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
}

void
usbnet_attach_ifp(struct usbnet *un,
                  unsigned if_flags,            /* additional if_flags */
                  unsigned if_extflags,         /* additional if_extflags */
                  const struct usbnet_mii *unm) /* additional mii_attach flags */
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct usbnet_private * const unp = un->un_pri;
        struct ifnet * const ifp = usbnet_ifp(un);

        KASSERT(unp->unp_attached);
        KASSERT(!unp->unp_ifp_attached);

        ifp->if_softc = un;
        strlcpy(ifp->if_xname, device_xname(un->un_dev), IFNAMSIZ);
        ifp->if_flags = if_flags;
        ifp->if_extflags = IFEF_MPSAFE | if_extflags;
        ifp->if_ioctl = usbnet_if_ioctl;
        ifp->if_start = usbnet_if_start;
        ifp->if_init = usbnet_if_init;
        ifp->if_stop = usbnet_if_stop;

        if (unm)
                usbnet_attach_mii(un, unm);
        else
                unp->unp_link = true;

        /* Attach the interface. */
        if_initialize(ifp);
        if (ifp->_if_input == NULL)
                ifp->if_percpuq = if_percpuq_create(ifp);
        if_register(ifp);
        unp->unp_ifp_attached = true;

        /*
         * If ethernet address is all zero, skip ether_ifattach() and
         * instead attach bpf here..
         */
        if (!usbnet_empty_eaddr(un)) {
                ether_set_ifflags_cb(&unp->unp_ec, usbnet_ifflags_cb);
                aprint_normal_dev(un->un_dev, "Ethernet address %s\n",
                    ether_sprintf(un->un_eaddr));
                ether_ifattach(ifp, un->un_eaddr);
        } else {
                if_alloc_sadl(ifp);
                bpf_attach(ifp, DLT_RAW, 0);
        }

        /* Now ready, and attached. */
        IFQ_SET_READY(&ifp->if_snd);

        usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, un->un_udev, un->un_dev);

        if (!pmf_device_register(un->un_dev, NULL, NULL))
                aprint_error_dev(un->un_dev, "couldn't establish power handler\n");
}

int
usbnet_detach(device_t self, int flags)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct usbnet * const un = device_private(self);
        struct usbnet_private * const unp = un->un_pri;

        /* Detached before attached finished, so just bail out. */
        if (unp == NULL || !unp->unp_attached)
                return 0;

        struct ifnet * const ifp = usbnet_ifp(un);
        struct mii_data * const mii = usbnet_mii(un);

        /*
         * Prevent new activity.  After we stop the interface, it
         * cannot be brought back up.
         */
        atomic_store_relaxed(&unp->unp_dying, true);

        /*
         * If we're still running on the network, stop and wait for all
         * asynchronous activity to finish.
         *
         * If usbnet_attach_ifp never ran, IFNET_LOCK won't work, but
         * no activity is possible, so just skip this part.
         */
        if (unp->unp_ifp_attached) {
                IFNET_LOCK(ifp);
                if (ifp->if_flags & IFF_RUNNING) {
                        usbnet_if_stop(ifp, 1);
                }
                IFNET_UNLOCK(ifp);
        }

        /*
         * The callout and tick task can't be scheduled anew at this
         * point, and usbnet_if_stop has waited for them to complete.
         */
        KASSERT(!callout_pending(&unp->unp_stat_ch));
        KASSERT(!usb_task_pending(un->un_udev, &unp->unp_ticktask));

        if (mii) {
                mii_detach(mii, MII_PHY_ANY, MII_OFFSET_ANY);
                ifmedia_fini(&mii->mii_media);
        }
        if (unp->unp_ifp_attached) {
                if (!usbnet_empty_eaddr(un))
                        ether_ifdetach(ifp);
                else
                        bpf_detach(ifp);
                if_detach(ifp);
        }
        usbnet_ec(un)->ec_mii = NULL;

        usbnet_rx_list_free(un);
        usbnet_tx_list_free(un);

        rnd_detach_source(&unp->unp_rndsrc);

        mutex_destroy(&unp->unp_mcastlock);
        mutex_destroy(&unp->unp_miilock);
        mutex_destroy(&unp->unp_rxlock);
        mutex_destroy(&unp->unp_txlock);

        callout_destroy(&unp->unp_stat_ch);

        pmf_device_deregister(un->un_dev);

        /*
         * Notify userland that we're going away, if we arrived in the
         * first place.
         */
        if (unp->unp_ifp_attached) {
                usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, un->un_udev,
                    un->un_dev);
        }

        kmem_free(unp, sizeof(*unp));
        un->un_pri = NULL;

        return 0;
}

int
usbnet_activate(device_t self, devact_t act)
{
        USBNETHIST_FUNC(); USBNETHIST_CALLED();
        struct usbnet * const un = device_private(self);
        struct usbnet_private * const unp = un->un_pri;
        struct ifnet * const ifp = usbnet_ifp(un);

        switch (act) {
        case DVACT_DEACTIVATE:
                if_deactivate(ifp);

                atomic_store_relaxed(&unp->unp_dying, true);

                mutex_enter(&unp->unp_miilock);
                unp->unp_stopped = true;
                mutex_exit(&unp->unp_miilock);

                mutex_enter(&unp->unp_rxlock);
                unp->unp_rxstopped = true;
                mutex_exit(&unp->unp_rxlock);

                mutex_enter(&unp->unp_txlock);
                unp->unp_txstopped = true;
                mutex_exit(&unp->unp_txlock);

                return 0;
        default:
                return EOPNOTSUPP;
        }
}

MODULE(MODULE_CLASS_MISC, usbnet, NULL);

static int
usbnet_modcmd(modcmd_t cmd, void *arg)
{
        switch (cmd) {
        case MODULE_CMD_INIT:
                return 0;
        case MODULE_CMD_FINI:
                return 0;
        case MODULE_CMD_STAT:
        case MODULE_CMD_AUTOUNLOAD:
        default:
                return ENOTTY;
        }
}