/*      $NetBSD: if_gscan.c,v 1.3 2025/04/26 07:09:13 skrll Exp $       */

/*
 * Copyright (c) 2025 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Manuel Bouyer.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */


#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_gscan.c,v 1.3 2025/04/26 07:09:13 skrll Exp $");

#ifdef _KERNEL_OPT
#include "opt_usb.h"
#include "opt_net_mpsafe.h"
#include "opt_can.h"
#endif

#include <sys/param.h>

#include <sys/device.h>
#include <sys/mbuf.h>
#include <sys/rndsource.h>
#include <sys/mutex.h>
#include <sys/module.h>
#include <sys/syslog.h>

#include <net/bpf.h>
#include <net/if.h>
#include <net/if_types.h>

#include <netcan/can.h>
#include <netcan/can_var.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdivar.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbdevs.h>

#include <dev/usb/usbhist.h>
#include <dev/usb/if_gscanreg.h>

#ifdef USB_DEBUG
#ifndef GSCAN_DEBUG
#define gscandebug 0
#else
static int gscandebug = 0;
SYSCTL_SETUP(sysctl_hw_gscan_setup, "sysctl hw.gscan setup")
{
        int err;
        const struct sysctlnode *rnode;
        const struct sysctlnode *cnode;

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

        return;
fail:
        aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
}

#endif /* GSCAN_DEBUG */
#endif /* USB_DEBUG */

#define DPRINTF(FMT,A,B,C,D)    USBHIST_LOGN(gscandebug,1,FMT,A,B,C,D)
#define DPRINTFN(N,FMT,A,B,C,D) USBHIST_LOGN(gscandebug,N,FMT,A,B,C,D)
#define GSCANHIST_FUNC()        USBHIST_FUNC()
#define GSCANHIST_CALLED(name)  USBHIST_CALLED(gscandebug)
#define GSCANHIST_CALLARGS(FMT,A,B,C,D) \
                USBHIST_CALLARGS(gscandebug,FMT,A,B,C,D)

struct gscan_softc {
        struct canif_softc sc_cansc;
        struct usbd_interface *sc_iface;
        struct usbd_device    *sc_udev;
        uByte sc_ed_tx;
        uByte sc_ed_rx;
        struct usbd_pipe *sc_tx_pipe;
        struct usbd_pipe *sc_rx_pipe;
        struct usbd_xfer *sc_tx_xfer;
        struct usbd_xfer *sc_rx_xfer;
        struct gscan_frame *sc_tx_frame;
        struct gscan_frame *sc_rx_frame;
        kmutex_t sc_txlock;
        kmutex_t sc_rxlock;
        bool sc_txstopped;
        bool sc_rxstopped;
        int sc_rx_nerr;
        struct ifnet *sc_ifp;
        struct if_percpuq *sc_ipq;
        volatile bool sc_dying;
        krndsource_t sc_rnd_source;
        struct mbuf *sc_m_transmit; /* mbuf being transmitted */
};

#define sc_dev    sc_cansc.csc_dev
#define sc_timecaps     sc_cansc.csc_timecaps
#define sc_timings      sc_cansc.csc_timings
#define sc_linkmodes    sc_cansc.csc_linkmodes

static bool
gscan_isdying(struct gscan_softc *sc)
{
        return atomic_load_relaxed(&sc->sc_dying);
}

static int
gscan_write_device(struct gscan_softc *sc, int breq, void *v, int len)
{
        usb_device_request_t req;
        req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
        req.bRequest =  breq;
        USETW(req.wValue, 0);
        USETW(req.wIndex, 0);
        USETW(req.wLength, len);
        return usbd_do_request(sc->sc_udev, &req, v);
}

static int
gscan_read_device(struct gscan_softc *sc, int breq, void *v, int len)
{
        usb_device_request_t req;
        req.bmRequestType = UT_READ_VENDOR_DEVICE;
        req.bRequest =  breq;
        USETW(req.wValue, 0);
        USETW(req.wIndex, 0);
        USETW(req.wLength, len);
        return usbd_do_request(sc->sc_udev, &req, v);
}

static int      gscan_match(device_t, cfdata_t, void *);
static void     gscan_attach(device_t, device_t, void *);
static int      gscan_detach(device_t, int);
static int      gscan_activate(device_t, devact_t);

static void     gscan_ifstart(struct ifnet *);
static int      gscan_ifioctl(struct ifnet *, u_long, void *);
static void     gscan_ifwatchdog(struct ifnet *);

static int      gscan_ifup(struct gscan_softc * const);
static void     gscan_stop(struct gscan_softc * const, struct ifnet *, int);
static void     gscan_startrx(struct gscan_softc * const);

CFATTACH_DECL_NEW(gscan, sizeof(struct gscan_softc),
        gscan_match, gscan_attach, gscan_detach, gscan_activate);

static void
gscan_rx(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
        GSCANHIST_FUNC();
        struct gscan_softc *sc = priv;
        struct gscan_frame *gsframe;
        struct can_frame *cf;
        uint32_t len,  dlc, can_id;
        int32_t echo_id;
        struct ifnet *ifp = sc->sc_ifp;
        struct mbuf *m;

        GSCANHIST_CALLARGS("status: %d", status, 0, 0, 0);

        mutex_enter(&sc->sc_rxlock);
        if (sc->sc_rxstopped || gscan_isdying(sc) ||
            status == USBD_NOT_STARTED || status == USBD_CANCELLED ||
            status == USBD_INVAL) {
                mutex_exit(&sc->sc_rxlock);
                return;
        }
        if (status != USBD_NORMAL_COMPLETION) {
                DPRINTF("rx error: %jd", status, 0, 0, 0);
                if (status == USBD_STALLED)
                        usbd_clear_endpoint_stall_async(sc->sc_rx_pipe);
                if (++sc->sc_rx_nerr > 100) {
                        log(LOG_ERR, "%s: too many rx errors, disabling\n",
                            device_xname(sc->sc_dev));
                        gscan_activate(sc->sc_dev, DVACT_DEACTIVATE);
                }
                goto out;
        }
        sc->sc_rx_nerr = 0;
        usbd_get_xfer_status(xfer, NULL, (void **)&gsframe, &len, NULL);
        if (len < sizeof(struct gscan_frame) - 8) {
                if_statinc(ifp, if_ierrors);
                goto out;
        }
        if (gsframe->gsframe_flags & GSFRAME_FLAG_OVER) {
                if_statinc(ifp, if_ierrors);
                goto out;
        }
        dlc = le32toh(gsframe->gsframe_can_dlc);
        if (dlc > CAN_MAX_DLC) {
                if_statinc(ifp, if_ierrors);
                goto out;
        }
        echo_id = le32toh(gsframe->gsframe_echo_id);
        if (echo_id != -1) {
                /* echo of a frame we sent */
                goto out;
        }
        can_id = le32toh(gsframe->gsframe_can_id);
        /* for now ignore error frames */
        if (can_id & CAN_ERR_FLAG) {
                goto out;
        }
        m = m_gethdr(M_NOWAIT, MT_HEADER);
        if (m == NULL) {
                if_statinc(ifp, if_ierrors);
                goto out;
        }
        cf = mtod(m, struct can_frame *);
        memset(cf, 0, sizeof(struct can_frame));
        cf->can_id = can_id;
        cf->can_dlc = dlc;
        memcpy(&cf->data[0], &gsframe->gsframe_can_data[0], 8);
        /* done with the buffer, get next frame */
        mutex_exit(&sc->sc_rxlock);
        gscan_startrx(sc);

        m->m_len = m->m_pkthdr.len = CAN_MTU;
        m_set_rcvif(m, ifp);
        if_statadd(ifp, if_ibytes, m->m_len);
        can_bpf_mtap(ifp, m, 1);
        can_input(ifp, m);
        return;

out:
        mutex_exit(&sc->sc_rxlock);
        gscan_startrx(sc);
}

static void
gscan_startrx(struct gscan_softc * const sc)
{
        usbd_setup_xfer(sc->sc_rx_xfer, sc, sc->sc_rx_frame,
            sizeof(struct gscan_frame), USBD_SHORT_XFER_OK,
            USBD_NO_TIMEOUT, gscan_rx);
        usbd_transfer(sc->sc_rx_xfer);
}

static void
gscan_tx(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
        GSCANHIST_FUNC();
        struct gscan_softc *sc = priv;
        struct ifnet *ifp = sc->sc_ifp;
        struct mbuf *m;

        GSCANHIST_CALLARGS("status: %d", status, 0, 0, 0);
        mutex_enter(&sc->sc_txlock);
        if (sc->sc_txstopped || gscan_isdying(sc)) {
                mutex_exit(&sc->sc_txlock);
                return;
        }
        ifp->if_timer = 0;
        m = sc->sc_m_transmit;
        sc->sc_m_transmit = NULL;
        if (m != NULL) {
                if (status == USBD_NORMAL_COMPLETION)
                        if_statadd2(ifp, if_obytes, m->m_len, if_opackets, 1);
                can_mbuf_tag_clean(m);
                m_set_rcvif(m, ifp);
                can_input(ifp, m); /* loopback */
        }
        if (status != USBD_NORMAL_COMPLETION) {
                if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
                        mutex_exit(&sc->sc_txlock);
                        return;
                }
                DPRINTF("rx error: %jd", status, 0, 0, 0);
                if (status == USBD_STALLED)
                        usbd_clear_endpoint_stall_async(sc->sc_rx_pipe);
        }
        if_schedule_deferred_start(ifp);
        mutex_exit(&sc->sc_txlock);
}

static void
gscan_ifstart(struct ifnet *ifp)
{
        GSCANHIST_FUNC();
        struct gscan_softc * const sc = ifp->if_softc;
        struct mbuf *m;
        struct can_frame *cf;
        int err;
        GSCANHIST_CALLED();

        mutex_enter(&sc->sc_txlock);
        if (sc->sc_txstopped || gscan_isdying(sc))
                goto out;

        if (sc->sc_m_transmit != NULL)
                goto out;
        IF_DEQUEUE(&ifp->if_snd, m);
        if (m == NULL)
                goto out;

        MCLAIM(m, ifp->if_mowner);

        KASSERT((m->m_flags & M_PKTHDR) != 0);
        KASSERT(m->m_len == m->m_pkthdr.len);

        cf = mtod(m, struct can_frame *);
        memset(sc->sc_tx_frame, 0, sizeof(struct gscan_frame));
        sc->sc_tx_frame->gsframe_echo_id = 0;
        sc->sc_tx_frame->gsframe_can_id = htole32(cf->can_id);
        sc->sc_tx_frame->gsframe_can_dlc = htole32(cf->can_dlc);
        memcpy(&sc->sc_tx_frame->gsframe_can_data[0], &cf->data[0], 8);

        usbd_setup_xfer(sc->sc_tx_xfer, sc, sc->sc_tx_frame,
            sizeof(struct gscan_frame), 0, 10000, gscan_tx);
        err = usbd_transfer(sc->sc_tx_xfer);
        if (err != USBD_IN_PROGRESS) {
                DPRINTF("start tx error: %jd", err, 0, 0, 0);
                if_statadd(ifp, if_oerrors, 1);
        } else {
                sc->sc_m_transmit = m;
                ifp->if_timer = 5;
        }
        can_bpf_mtap(ifp, m, 0);
out:
        mutex_exit(&sc->sc_txlock);
}

static int
gscan_ifup(struct gscan_softc * const sc)
{
        struct gscan_bt gscan_bt;
        struct gscan_set_mode gscan_set_mode;
        int err;
        struct ifnet * const ifp = sc->sc_ifp;

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

        gscan_set_mode.mode_mode = MODE_START;
        gscan_set_mode.mode_flags = 0;

        if (sc->sc_linkmodes & CAN_LINKMODE_LISTENONLY) {
                if ((sc->sc_timecaps.cltc_linkmode_caps & CAN_LINKMODE_LISTENONLY) == 0)
                        return EINVAL;
                gscan_set_mode.mode_flags |= FLAGS_LISTEN_ONLY;
        }
        if (sc->sc_linkmodes & CAN_LINKMODE_LOOPBACK) {
                if ((sc->sc_timecaps.cltc_linkmode_caps & CAN_LINKMODE_LOOPBACK) == 0)
                        return EINVAL;
                gscan_set_mode.mode_flags |= FLAGS_LOOPBACK;
        }
        if (sc->sc_linkmodes & CAN_LINKMODE_3SAMPLES) {
                if ((sc->sc_timecaps.cltc_linkmode_caps & CAN_LINKMODE_3SAMPLES) == 0)
                        return EINVAL;
                gscan_set_mode.mode_flags |= FLAGS_TRIPLE_SAMPLE;
        }
        if (sc->sc_timings.clt_prop != 0)
                return EINVAL;
        gscan_bt.bt_prop_seg = 0;

        if (sc->sc_timings.clt_brp > sc->sc_timecaps.cltc_brp_max ||
           sc->sc_timings.clt_brp < sc->sc_timecaps.cltc_brp_min)
                return EINVAL;
        gscan_bt.bt_brp = sc->sc_timings.clt_brp;

        if (sc->sc_timings.clt_ps1 > sc->sc_timecaps.cltc_ps1_max ||
           sc->sc_timings.clt_ps1 < sc->sc_timecaps.cltc_ps1_min)
                return EINVAL;
        gscan_bt.bt_phase_seg1 = sc->sc_timings.clt_ps1;
        if (sc->sc_timings.clt_ps2 > sc->sc_timecaps.cltc_ps2_max ||
           sc->sc_timings.clt_ps2 < sc->sc_timecaps.cltc_ps2_min)
                return EINVAL;
        gscan_bt.bt_phase_seg2 = sc->sc_timings.clt_ps2;
        if (sc->sc_timings.clt_sjw > sc->sc_timecaps.cltc_sjw_max ||
            sc->sc_timings.clt_sjw < 1)
                return EINVAL;
        gscan_bt.bt_swj = sc->sc_timings.clt_sjw;

        err = gscan_write_device(sc, GSCAN_SET_BITTIMING,
             &gscan_bt, sizeof(gscan_bt));
        if (err) {
                aprint_error_dev(sc->sc_dev, "SET_BITTIMING: %s\n",
                    usbd_errstr(err));
                return EIO;
        }
        err = gscan_write_device(sc, GSCAN_SET_MODE,
             &gscan_set_mode, sizeof(gscan_set_mode));
        if (err) {
                aprint_error_dev(sc->sc_dev, "SET_MODE start: %s\n",
                    usbd_errstr(err));
                return EIO;
        }

        if ((err = usbd_open_pipe(sc->sc_iface, sc->sc_ed_rx,
            USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_rx_pipe)) != 0) {
                aprint_error_dev(sc->sc_dev, "open rx pipe: %s\n",
                    usbd_errstr(err));
                goto fail;
        }
        if ((err = usbd_open_pipe(sc->sc_iface, sc->sc_ed_tx,
            USBD_EXCLUSIVE_USE | USBD_MPSAFE, &sc->sc_tx_pipe)) != 0) {
                aprint_error_dev(sc->sc_dev, "open tx pipe: %s\n",
                    usbd_errstr(err));
                goto fail;
        }

        if ((err = usbd_create_xfer(sc->sc_rx_pipe, sizeof(struct gscan_frame),
            0, 0, &sc->sc_rx_xfer)) != 0) {
                aprint_error_dev(sc->sc_dev, "create rx xfer: %s\n",
                    usbd_errstr(err));
                goto fail;
        }
        if ((err = usbd_create_xfer(sc->sc_tx_pipe, sizeof(struct gscan_frame),
            0, 0, &sc->sc_tx_xfer)) != 0) {
                aprint_error_dev(sc->sc_dev, "create tx xfer: %s\n",
                    usbd_errstr(err));
                goto fail;
        }

        sc->sc_rx_frame = usbd_get_buffer(sc->sc_rx_xfer);
        sc->sc_tx_frame = usbd_get_buffer(sc->sc_tx_xfer);
        sc->sc_ifp->if_flags |= IFF_RUNNING;

        mutex_enter(&sc->sc_rxlock);
        sc->sc_rxstopped = false;
        sc->sc_rx_nerr = 0;
        mutex_exit(&sc->sc_rxlock);
        gscan_startrx(sc);
        mutex_enter(&sc->sc_txlock);
        sc->sc_txstopped = false;
        mutex_exit(&sc->sc_txlock);
        return 0;

fail:
        gscan_stop(sc, ifp, 1);
        return EIO;
}

static void
gscan_stop(struct gscan_softc * const sc, struct ifnet *ifp, int disable)
{
        struct gscan_set_mode gscan_set_mode;
        int err;

        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        mutex_enter(&sc->sc_txlock);
        sc->sc_txstopped = true;
        ifp->if_timer = 0;
        if (sc->sc_m_transmit != NULL) {
                m_freem(sc->sc_m_transmit);
                sc->sc_m_transmit = NULL;
        }
        mutex_exit(&sc->sc_txlock);
        mutex_enter(&sc->sc_rxlock);
        sc->sc_rxstopped = true;
        mutex_exit(&sc->sc_rxlock);
        if (ifp->if_flags & IFF_RUNNING) {
                if (sc->sc_tx_pipe)
                        usbd_abort_pipe(sc->sc_tx_pipe);
                if (sc->sc_rx_pipe)
                        usbd_abort_pipe(sc->sc_rx_pipe);
        }
        if (sc->sc_rx_pipe) {
                usbd_close_pipe(sc->sc_rx_pipe);
                sc->sc_rx_pipe = NULL;
        }
        if (sc->sc_tx_pipe) {
                usbd_close_pipe(sc->sc_tx_pipe);
                sc->sc_tx_pipe = NULL;
        }
        if (sc->sc_rx_xfer != NULL) {
                usbd_destroy_xfer(sc->sc_rx_xfer);
                sc->sc_rx_xfer = NULL;
                sc->sc_rx_pipe = NULL;
        }
        if (sc->sc_tx_xfer != NULL) {
                usbd_destroy_xfer(sc->sc_tx_xfer);
                sc->sc_tx_xfer = NULL;
                sc->sc_tx_pipe = NULL;
        }

        gscan_set_mode.mode_mode = MODE_RESET;
        gscan_set_mode.mode_flags = 0;
        err = gscan_write_device(sc, GSCAN_SET_MODE,
             &gscan_set_mode, sizeof(gscan_set_mode));
        if (err != 0 && err  != USBD_CANCELLED) {
                aprint_error_dev(sc->sc_dev, "SET_MODE stop: %s\n",
                    usbd_errstr(err));
        }
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        ifp->if_flags &= ~IFF_RUNNING;
}

static void
gscan_ifstop(struct ifnet *ifp, int disable)
{
        struct gscan_softc * const sc = ifp->if_softc;
        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        gscan_stop(sc, ifp, disable);
}


static int
gscan_ifioctl(struct ifnet *ifp, u_long cmd, void *data)
{
        struct gscan_softc * const sc = ifp->if_softc;
        struct ifreq *ifr = (struct ifreq *)data;
        int error = 0;

        KASSERTMSG(IFNET_LOCKED(ifp), "%s", ifp->if_xname);
        if (gscan_isdying(sc))
                return EIO;

        switch (cmd) {
        case SIOCINITIFADDR:
                error = EAFNOSUPPORT;
                break;
        case SIOCSIFMTU:
                if ((unsigned)ifr->ifr_mtu != sizeof(struct can_frame))
                        error = EINVAL;
                break;
        case SIOCADDMULTI:
        case SIOCDELMULTI:
                error = EAFNOSUPPORT;
                break;
        default:
                error = ifioctl_common(ifp, cmd, data);
                if (error == 0) {
                        if ((ifp->if_flags & IFF_UP) != 0 &&
                            (ifp->if_flags & IFF_RUNNING) == 0) {
                                error = gscan_ifup(sc);
                                if (error) {
                                        ifp->if_flags &= ~IFF_UP;
                                }
                        } else if ((ifp->if_flags & IFF_UP) == 0 &&
                            (ifp->if_flags & IFF_RUNNING) != 0) {
                                gscan_stop(sc, sc->sc_ifp, 1);
                        }
                }
                break;
        }
        return error;
}

static void
gscan_ifwatchdog(struct ifnet *ifp)
{
        struct gscan_softc * const sc = ifp->if_softc;
        printf("%s: watchdog timeout\n", device_xname(sc->sc_dev));
#if 0
        /* if there is a transmit in progress abort */
        if (gscan_tx_abort(sc)) {
                if_statinc(ifp, if_oerrors);
        }
#endif
}

static const struct usb_devno gscan_devs[] = {
    {USB_VENDOR_FUTUREBITS, USB_PRODUCT_FUTUREBITS_CDL_CAN},
    {USB_VENDOR_INTERBIO, USB_PRODUCT_INTERBIO_CDL_CAN},
};

static int
gscan_match(device_t parent, cfdata_t match, void *aux)
{
        struct usb_attach_arg *uaa = aux;

        return
            (usb_lookup(gscan_devs, uaa->uaa_vendor, uaa->uaa_product) != NULL ?
             UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
}

static void
gscan_attach(device_t parent, device_t self, void *aux)
{
        GSCANHIST_FUNC(); GSCANHIST_CALLED();
        struct gscan_softc *sc = device_private(self);
        struct usb_attach_arg *uaa = aux;
        struct usbd_device *dev = uaa->uaa_device;
        usbd_status err;
        usb_interface_descriptor_t *id;
        usb_endpoint_descriptor_t *ed;
        char *devinfop;
        uint32_t val32;
        struct gscan_config gscan_config;
        struct gscan_bt_const gscan_bt_const;
        struct ifnet *ifp;

        aprint_naive("\n");
        aprint_normal("\n");
        devinfop = usbd_devinfo_alloc(dev, 0);
        aprint_normal_dev(self, "%s\n", devinfop);
        usbd_devinfo_free(devinfop);

        sc->sc_dev = self;
        sc->sc_udev = dev;

        err = usbd_set_config_no(dev, 1, 0);
        if (err) {
                aprint_error_dev(self, "failed to set configuration"
                    ", err=%s\n", usbd_errstr(err));
                return;
        }

        err = usbd_device2interface_handle(dev, 0, &sc->sc_iface);
        if (err) {
                aprint_error_dev(self, "getting interface handle failed\n");
                return;
        }

        id = usbd_get_interface_descriptor(sc->sc_iface);
        if (id->bNumEndpoints < 2) {
                aprint_error_dev(self, "%d endpoints < 2\n", id->bNumEndpoints);
                return;
        }

        val32 = htole32(0x0000beef);
        err = gscan_write_device(sc, GSCAN_SET_HOST_FORMAT,
            &val32, sizeof(val32));

        if (err) {
                aprint_error_dev(self, "SET_HOST_FORMAT: %s\n",
                    usbd_errstr(err));
                return;
        }

        err = gscan_read_device(sc, GSCAN_GET_DEVICE_CONFIG,
            &gscan_config, sizeof(struct gscan_config));
        if (err) {
                aprint_error_dev(self, "GET_DEVICE_CONFIG: %s\n",
                    usbd_errstr(err));
                return;
        }
        aprint_normal_dev(self, "%d port%s, sw version %d, hw version %d\n",
            gscan_config.conf_count + 1, gscan_config.conf_count ? "s" : "",
            le32toh(gscan_config.sw_version), le32toh(gscan_config.hw_version));

        err = gscan_read_device(sc, GSCAN_GET_BT_CONST,
            &gscan_bt_const, sizeof(struct gscan_bt_const));
        if (err) {
                aprint_error_dev(self, "GET_BT_CONST: %s\n",
                    usbd_errstr(err));
                return;
        }
        aprint_debug_dev(self, "feat 0x%x clk %dHz tseg1 %d -> %d tseg2 %d -> %d max swj %d brp %d -> %d/%d\n",
            le32toh(gscan_bt_const.btc_features),
            le32toh(gscan_bt_const.btc_fclk),
            le32toh(gscan_bt_const.btc_tseg1_min),
            le32toh(gscan_bt_const.btc_tseg1_max),
            le32toh(gscan_bt_const.btc_tseg2_min),
            le32toh(gscan_bt_const.btc_tseg2_max),
            le32toh(gscan_bt_const.btc_swj_max),
            le32toh(gscan_bt_const.btc_brp_min),
            le32toh(gscan_bt_const.btc_brp_max),
            le32toh(gscan_bt_const.btc_brp_inc));

        sc->sc_timecaps.cltc_prop_min = 0;
        sc->sc_timecaps.cltc_prop_max = 0;
        sc->sc_timecaps.cltc_ps1_min = le32toh(gscan_bt_const.btc_tseg1_min);
        sc->sc_timecaps.cltc_ps1_max = le32toh(gscan_bt_const.btc_tseg1_max);
        sc->sc_timecaps.cltc_ps2_min = le32toh(gscan_bt_const.btc_tseg2_min);
        sc->sc_timecaps.cltc_ps2_max = le32toh(gscan_bt_const.btc_tseg2_max);
        sc->sc_timecaps.cltc_sjw_max = le32toh(gscan_bt_const.btc_swj_max);
        sc->sc_timecaps.cltc_brp_min = le32toh(gscan_bt_const.btc_brp_min);
        sc->sc_timecaps.cltc_brp_max = le32toh(gscan_bt_const.btc_brp_max);
        sc->sc_timecaps.cltc_brp_inc = le32toh(gscan_bt_const.btc_brp_inc);
        sc->sc_timecaps.cltc_clock_freq = le32toh(gscan_bt_const.btc_fclk);
        sc->sc_timecaps.cltc_linkmode_caps = 0;
        if (le32toh(gscan_bt_const.btc_features) & FEAT_LISTEN_ONLY)
                sc->sc_timecaps.cltc_linkmode_caps |= CAN_LINKMODE_LISTENONLY;
        if (le32toh(gscan_bt_const.btc_features) & FEAT_LOOPBACK)
                sc->sc_timecaps.cltc_linkmode_caps |= CAN_LINKMODE_LOOPBACK;
        if (le32toh(gscan_bt_const.btc_features) & FEAT_TRIPLE_SAMPLE)
                sc->sc_timecaps.cltc_linkmode_caps |= CAN_LINKMODE_3SAMPLES;

        can_ifinit_timings(&sc->sc_cansc);
        sc->sc_timings.clt_prop = 0;
        sc->sc_timings.clt_sjw = 1;

        /* Find endpoints. */
        ed = usbd_interface2endpoint_descriptor(sc->sc_iface, 0);
        if (ed == NULL) {
                aprint_error_dev(self, "couldn't get ep 1\n");
                return;
        }
        const uint8_t xt1 = UE_GET_XFERTYPE(ed->bmAttributes);
        const uint8_t dir1 = UE_GET_DIR(ed->bEndpointAddress);

        if (dir1 != UE_DIR_IN || xt1 != UE_BULK) {
                aprint_error_dev(self,
                    "ep 1 wrong dir %d or xt %d\n", dir1, xt1);
                return;
        }
        sc->sc_ed_rx = ed->bEndpointAddress;

        ed = usbd_interface2endpoint_descriptor(sc->sc_iface, 1);
        if (ed == NULL) {
                aprint_error_dev(self, "couldn't get ep 2\n");
                return;
        }
        const uint8_t xt2 = UE_GET_XFERTYPE(ed->bmAttributes);
        const uint8_t dir2 = UE_GET_DIR(ed->bEndpointAddress);

        if (dir2 != UE_DIR_OUT || xt2 != UE_BULK) {
                aprint_error_dev(self,
                    "ep 2 wrong dir %d or xt %d\n", dir2, xt2);
                return;
        }
        sc->sc_ed_tx = ed->bEndpointAddress;

        mutex_init(&sc->sc_txlock, MUTEX_DEFAULT, IPL_SOFTUSB);
        mutex_init(&sc->sc_rxlock, MUTEX_DEFAULT, IPL_SOFTUSB);
        sc->sc_rxstopped = true;
        sc->sc_txstopped = true;


        ifp = if_alloc(IFT_OTHER);
        strlcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
        ifp->if_softc = sc;
        ifp->if_capabilities = 0;
        ifp->if_flags = 0;
        ifp->if_extflags = IFEF_MPSAFE;
        ifp->if_start = gscan_ifstart;
        ifp->if_ioctl = gscan_ifioctl;
        ifp->if_stop = gscan_ifstop;
        ifp->if_watchdog = gscan_ifwatchdog;
        IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);

        sc->sc_ifp = ifp;
        can_ifattach(ifp);
        if_deferred_start_init(ifp, NULL);
        bpf_mtap_softint_init(ifp);
        rnd_attach_source(&sc->sc_rnd_source, device_xname(self),
            RND_TYPE_NET, RND_FLAG_DEFAULT);
#ifdef MBUFTRACE
        ifp->if_mowner = kmem_zalloc(sizeof(*ifp->if_mowner), KM_SLEEP);
        strlcpy(ifp->if_mowner->mo_name, ifp->if_xname,
                sizeof(ifp->if_mowner->mo_name));
        MOWNER_ATTACH(ifp->if_mowner);
#endif
        usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
};

static int
gscan_detach(device_t self, int flags)
{
        GSCANHIST_FUNC(); GSCANHIST_CALLED();
        struct gscan_softc * const sc = device_private(self);

        struct ifnet * const ifp = sc->sc_ifp;
        /*
         * Prevent new activity.  After we stop the interface, it
         * cannot be brought back up.
         */
        atomic_store_relaxed(&sc->sc_dying, true);

        /*
         * If we're still running on the network, stop and wait for all
         * asynchronous activity to finish.
         *
         * If _attach_ifp never ran, IFNET_LOCK won't work, but
         * no activity is possible, so just skip this part.
         */
        if (ifp != NULL) {
                IFNET_LOCK(ifp);
                if (ifp->if_flags & IFF_RUNNING) {
                        gscan_stop(sc, ifp, 1);
                }
                IFNET_UNLOCK(ifp);
                bpf_detach(ifp);
                if_detach(ifp);
        }
        rnd_detach_source(&sc->sc_rnd_source);
        mutex_destroy(&sc->sc_txlock);
        mutex_destroy(&sc->sc_rxlock);

        pmf_device_deregister(sc->sc_dev);
        if (ifp != NULL) {
                usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
                    sc->sc_dev);
        }
        return 0;
}

static int
gscan_activate(device_t self, devact_t act)
{
        GSCANHIST_FUNC(); GSCANHIST_CALLED();
        struct gscan_softc * const sc = device_private(self);
        struct ifnet * const ifp = sc->sc_ifp;

        switch (act) {
        case DVACT_DEACTIVATE:
                if_deactivate(ifp);
                atomic_store_relaxed(&sc->sc_dying, true);
                mutex_enter(&sc->sc_txlock);
                sc->sc_txstopped = true;
                if (sc->sc_m_transmit != NULL) {
                        m_freem(sc->sc_m_transmit);
                        sc->sc_m_transmit = NULL;
                }
                mutex_exit(&sc->sc_txlock);
                mutex_enter(&sc->sc_rxlock);
                sc->sc_rxstopped = true;
                mutex_exit(&sc->sc_rxlock);
                return 0;
        default:
                return EOPNOTSUPP;
        }
}

#ifdef _MODULE
#include "ioconf.c"
#endif

MODULE(MODULE_CLASS_DRIVER, gscan, NULL);

static int
gscan_modcmd(modcmd_t cmd, void *aux)
{
        int error = 0;

        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                error = config_init_component(cfdriver_ioconf_gscan,
                    cfattach_ioconf_gscan, cfdata_ioconf_gscan);
#endif
                return error;
        case MODULE_CMD_FINI:
#ifdef _MODULE
                error = config_fini_component(cfdriver_ioconf_gscan,
                    cfattach_ioconf_gscan, cfdata_ioconf_gscan);
#endif
                return error;
        default:
                return ENOTTY;
        }
}