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