/* $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;
}
}