32#include <sys/eventhandler.h>
33#include <sys/sockio.h>
35#include <sys/malloc.h>
36#include <sys/kernel.h>
37#include <sys/module.h>
38#include <sys/socket.h>
40#include <sys/sysctl.h>
41#include <sys/condvar.h>
47#include <sys/limits.h>
49#include <machine/bus.h>
52#include <net/if_var.h>
53#include <net/if_types.h>
54#include <net/netisr.h>
56#include <netinet/in.h>
57#include <netinet/ip.h>
58#include <netinet/ip6.h>
65#define USB_DEBUG_VAR uhso_debug
114#define UHSO_MAX_MTU 2048
124#define UHSO_IFACE_SPEC(usb_type, port, port_type) \
125 (((usb_type) << 24) | ((port) << 16) | (port_type))
127#define UHSO_IFACE_USB_TYPE(x) ((x >> 24) & 0xff)
128#define UHSO_IFACE_PORT(x) ((x >> 16) & 0xff)
129#define UHSO_IFACE_PORT_TYPE(x) (x & 0xff)
134#define UHSO_IF_NET 0x01
135#define UHSO_IF_MUX 0x02
136#define UHSO_IF_BULK 0x04
141#define UHSO_PORT_UNKNOWN 0x00
142#define UHSO_PORT_SERIAL 0x01
143#define UHSO_PORT_NETWORK 0x02
148#define UHSO_MPORT_TYPE_CTL 0x00
149#define UHSO_MPORT_TYPE_APP 0x01
150#define UHSO_MPORT_TYPE_PCSC 0x02
151#define UHSO_MPORT_TYPE_GPS 0x03
152#define UHSO_MPORT_TYPE_APP2 0x04
153#define UHSO_MPORT_TYPE_MAX UHSO_MPORT_TYPE_APP2
154#define UHSO_MPORT_TYPE_NOMAX 8
161#define UHSO_PORT_TYPE_UNKNOWN 0x00
162#define UHSO_PORT_TYPE_CTL 0x01
163#define UHSO_PORT_TYPE_APP 0x02
164#define UHSO_PORT_TYPE_APP2 0x03
165#define UHSO_PORT_TYPE_MODEM 0x04
166#define UHSO_PORT_TYPE_NETWORK 0x05
167#define UHSO_PORT_TYPE_DIAG 0x06
168#define UHSO_PORT_TYPE_DIAG2 0x07
169#define UHSO_PORT_TYPE_GPS 0x08
170#define UHSO_PORT_TYPE_GPSCTL 0x09
171#define UHSO_PORT_TYPE_PCSC 0x0a
172#define UHSO_PORT_TYPE_MSD 0x0b
173#define UHSO_PORT_TYPE_VOICE 0x0c
174#define UHSO_PORT_TYPE_MAX 0x0c
219 "Application (Secondary)",
223 "Diagnostic (Secondary)",
247#define UHSO_STATIC_IFACE 0x01
248#define UHSO_AUTO_IFACE 0x02
254#define UHSO_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }
291static SYSCTL_NODE(_hw_usb, OID_AUTO, uhso, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
294SYSCTL_INT(_hw_usb_uhso, OID_AUTO, auto_switch, CTLFLAG_RWTUN,
299static int uhso_debug = UHSO_DEBUG;
301static int uhso_debug = -1;
305 &uhso_debug, 0,
"Debug level");
307#define UHSO_DPRINTF(n, x, ...) {\
308 if (uhso_debug >= n) {\
309 printf("%s: " x, __func__, ##__VA_ARGS__);\
313#define UHSO_DPRINTF(n, x, ...)
316#ifdef UHSO_DEBUG_HEXDUMP
317# define UHSO_HEXDUMP(_buf, _len) do { \
320 const char *__buf = (const char *)_buf; \
321 for (__tmp = 0; __tmp < _len; __tmp++) \
322 printf("%02hhx ", *__buf++); \
327# define UHSO_HEXDUMP(_buf, _len)
369 .flags = { .pipe_bof = 1, .short_xfer_ok = 1 },
378 .flags = { .pipe_bof = 1, .force_short_xfer = 1 },
391 .flags = { .short_xfer_ok = 1 },
403 .flags = { .pipe_bof = 1, .short_xfer_ok = 1 },
411 .flags = { .pipe_bof = 1, .force_short_xfer = 1 },
424 .flags = { .pipe_bof = 1, .short_xfer_ok = 1 },
433 .flags = { .pipe_bof = 1, .force_short_xfer = 1 },
442 .flags = { .short_xfer_ok = 1 },
477 const struct sockaddr *,
struct route *);
548 struct uhso_softc *sc = device_get_softc(self);
551 struct sysctl_ctx_list *sctx;
552 struct sysctl_oid *soid;
553 struct sysctl_oid *tree = NULL, *tty_node;
563 mtx_init(&sc->
sc_mtx,
"uhso", NULL, MTX_DEF);
564 mbufq_init(&sc->
sc_rxq, INT_MAX);
580 device_printf(self,
"Failed to setup control pipe: %s\n",
596 sctx = device_get_sysctl_ctx(sc->
sc_dev);
597 soid = device_get_sysctl_tree(sc->
sc_dev);
599 SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
"type",
601 "Port available at this interface");
602 SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
"radio",
603 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, sc, 0,
613 device_printf(self,
"<%s port> at <%s %s> on %s\n",
617 device_get_nameunit(device_get_parent(self)));
620 SYSCTL_ADD_INT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
"ports",
621 CTLFLAG_RD, &sc->
sc_ttys, 0,
"Number of attached serial ports");
623 tree = SYSCTL_ADD_NODE(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
624 "port", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
"Serial ports");
631 for (i = 0; i < sc->
sc_ttys; i++) {
642 tty_node = SYSCTL_ADD_NODE(sctx, SYSCTL_CHILDREN(tree), OID_AUTO,
643 desc, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
"");
649 snprintf(ht->
ht_name, 32,
"cuaU%d.%d",
654 SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(tty_node), OID_AUTO,
655 "tty", CTLFLAG_RD, ht->
ht_name, 0,
"");
656 SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(tty_node), OID_AUTO,
657 "desc", CTLFLAG_RD,
desc, 0,
"");
673 struct uhso_softc *sc = device_get_softc(self);
681 for (i = 0; i < sc->
sc_ttys; i++) {
690 callout_drain(&sc->
sc_c);
701 device_claim_softc(self);
714 free(sc->
sc_tty, M_USBDEV);
717 device_free_softc(sc);
758 uhso_etag = EVENTHANDLER_REGISTER(usb_dev_configured,
764 EVENTHANDLER_DEREGISTER(usb_dev_configured,
uhso_etag);
796 printf(
"%s: usbd_do_request_flags failed, %s\n",
804 if (index < 0 || index > 16) {
934 device_printf(sc->
sc_dev,
"ucom_attach failed\n");
952 device_printf(sc->
sc_dev,
"ucom_attach failed\n");
972 req.bRequest = onoff ? 0x82 : 0x81;
979 device_printf(sc->
sc_dev,
"usbd_do_request_flags failed: %s\n",
993 error = sysctl_handle_int(oidp, &radio, 0,
req);
997 radio = radio != 0 ? 1 : 0;
1017 M_USBDEV, M_WAITOK | M_ZERO);
1053 UHSO_DPRINTF(0,
"Failed to find UDESC_CS_INTERFACE\n");
1058 if (
desc->bDescriptorSubtype == 0)
1065 for (i = 0; i < 8; i++) {
1067 if ((port &
desc->bDescriptorSubtype) == port) {
1077 device_printf(sc->
sc_dev,
1078 "Failed to setup control pipe: %s\n",
1105 unsigned int i, mux;
1118 i = *((
unsigned char *)res.
buffer);
1227 UHSO_DPRINTF(3,
"wrote %zd data bytes to muxport %d\n",
1377 device_printf(sc->
sc_dev,
"failed to set ctrl line state to "
1396 UHSO_DPRINTF(0,
"UCDC notification too short: %d\n", actlen);
1400 UHSO_DPRINTF(0,
"UCDC notification too large: %d\n", actlen);
1408 UHSO_DPRINTF(0,
"Interface mismatch, got %d expected %d\n",
1458 sc->
sc_line &= ~UCDC_LINE_DTR;
1474 sc->
sc_line &= ~UCDC_LINE_RTS;
1558 struct sysctl_ctx_list *sctx;
1559 struct sysctl_oid *soid;
1560 unsigned int devunit;
1571 sc->
sc_ifp = ifp = if_alloc(IFT_OTHER);
1572 if (sc->
sc_ifp == NULL) {
1573 device_printf(sc->
sc_dev,
"if_alloc() failed\n");
1589 if_initname(ifp, device_get_name(sc->
sc_dev), devunit);
1595 ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_NOARP;
1597 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
1598 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
1599 IFQ_SET_READY(&ifp->if_snd);
1602 bpfattach(ifp, DLT_RAW, 0);
1604 sctx = device_get_sysctl_ctx(sc->
sc_dev);
1605 soid = device_get_sysctl_tree(sc->
sc_dev);
1607 SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
"netif",
1608 CTLFLAG_RD, ifp->if_xname, 0,
"Attached network interface");
1627 if (actlen > 0 && (sc->
sc_ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1629 if (mbufq_full(&sc->
sc_rxq))
1631 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
1633 m->m_pkthdr.len = m->m_len = actlen;
1635 mbufq_enqueue(&sc->
sc_rxq, m);
1636 if (!callout_pending(&sc->
sc_c) ||
1637 !callout_active(&sc->
sc_c)) {
1638 callout_schedule(&sc->
sc_c, 1);
1666 struct epoch_tracker et;
1668 struct ifnet *ifp = sc->
sc_ifp;
1670 struct mbuf *m, *m0, *mwait;
1673 struct ip6_hdr *ip6;
1680 NET_EPOCH_ENTER(et);
1683 if ((m = mbufq_dequeue(&sc->
sc_rxq)) == NULL)
1685 UHSO_DPRINTF(3,
"dequeue m=%p, len=%d\n", m, m->m_len);
1690 if (mwait != NULL) {
1694 UHSO_DPRINTF(3,
"partial m0=%p(%d), concat w/ m=%p(%d)\n",
1695 m0, m0->m_len, m, m->m_len);
1698 m = m_pullup(m0,
sizeof(
struct ip));
1700 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1706 m, m->m_pkthdr.len);
1709 cp = mtod(m, uint8_t *);
1710 ip = (
struct ip *)cp;
1712 ip6 = (
struct ip6_hdr *)cp;
1716 if (ip->ip_v == IPVERSION) {
1717 iplen = htons(ip->ip_len);
1722 else if ((ip6->ip6_vfc & IPV6_VERSION_MASK) == IPV6_VERSION) {
1723 iplen = htons(ip6->ip6_plen);
1729 "m=%p, len=%d\n", (*cp & 0xf0) >> 4, m, m->m_len);
1730 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1740 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1748 m, m->m_pkthdr.len, cp, iplen);
1753 if (iplen < m->m_pkthdr.len) {
1760 m = m_getcl(M_WAITOK, MT_DATA, M_PKTHDR);
1761 memcpy(mtod(m, uint8_t *), mtod(m0, uint8_t *), iplen);
1762 m->m_pkthdr.len = m->m_len = iplen;
1766 m0 = m_defrag(m0, M_WAITOK);
1769 "m0_len=%d/%d\n", m, m->m_pkthdr.len, m->m_len,
1770 m0, m0->m_pkthdr.len, m0->m_len);
1772 else if (iplen > m->m_pkthdr.len) {
1774 m, m->m_pkthdr.len);
1781 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
1782 m->m_pkthdr.rcvif = ifp;
1786 M_SETFIB(m, ifp->if_fib);
1787 netisr_dispatch(isr, m);
1788 m = m0 != NULL ? m0 : NULL;
1799 struct ifnet *ifp = sc->
sc_ifp;
1810 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
1811 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1814 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1818 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1820 if (m->m_pkthdr.len > MCLBYTES)
1821 m->m_pkthdr.len = MCLBYTES;
1849 if (ifp->if_flags & IFF_UP) {
1850 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1855 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1876 struct ifnet *ifp = sc->
sc_ifp;
1881 ifp->if_flags |= IFF_UP;
1882 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1895 if (dst->sa_family != AF_INET
1897 && dst->sa_family != AF_INET6
1900 return (EAFNOSUPPORT);
1903 error = (ifp->if_transmit)(ifp, m0);
1905 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1908 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
1917 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
1935 sc->
sc_ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
void(* ucom_cfg_get_status)(struct ucom_softc *, uint8_t *plsr, uint8_t *pmsr)
struct ucom_super_softc * sc_super
struct ucom_softc * sc_ucom
struct usb_device * sc_udev
struct usb_xfer * sc_ctrl_xfer[2]
struct ucom_super_softc sc_super_ucom
struct usb_xfer * sc_if_xfer[2]
struct usb_xfer * sc_xfer[3]
struct usb_xfer * ht_xfer[3]
struct uhso_softc * ht_sc
enum usb_hc_mode usb_mode
struct usbd_lookup_info info
struct usb_interface * iface
struct usb_device * device
struct usb_interface_descriptor * idesc
static SYSCTL_NODE(_hw_usb, OID_AUTO, uhso, CTLFLAG_RW|CTLFLAG_MPSAFE, 0, "USB uhso")
static char * uhso_port_type_sysctl[]
static unsigned char uhso_port_map[]
static char * uhso_port_type[]
static void uhso_if_init(void *)
static int uhso_probe_iface_auto(struct usb_device *, int)
static const struct usb_config uhso_ifnet_config[UHSO_IFNET_MAX]
static usb_callback_t uhso_mux_read_callback
static void uhso_if_rxflush(void *)
static char uhso_port_map_max
static int uhso_if_ioctl(struct ifnet *, u_long, caddr_t)
static usb_callback_t uhso_mux_write_callback
#define UHSO_PORT_TYPE_MODEM
static int uhso_radio_sysctl(SYSCTL_HANDLER_ARGS)
static void uhso_ucom_cfg_set_dtr(struct ucom_softc *, uint8_t)
static int uhso_driver_loaded(struct module *, int, void *)
static usb_callback_t uhso_mux_intr_callback
static int uhso_attach_ifnet(struct uhso_softc *, struct usb_interface *, int type)
static int uhso_autoswitch
static eventhandler_tag uhso_etag
static int uhso_attach_muxserial(struct uhso_softc *, struct usb_interface *, int type)
static void uhso_if_start(struct ifnet *)
static const struct usb_config uhso_mux_config[UHSO_MUX_ENDPT_MAX]
#define UHSO_PORT_TYPE_APP2
static void uhso_bs_cfg(struct uhso_softc *sc)
#define UHSO_PORT_TYPE_VOICE
#define UHSO_PORT_TYPE_MSD
static int uhso_radio_ctrl(struct uhso_softc *, int)
#define UHSO_HEXDUMP(_buf, _len)
static usb_callback_t uhso_bs_read_callback
static device_detach_t uhso_detach
#define UHSO_IFACE_SPEC(usb_type, port, port_type)
#define UHSO_PORT_TYPE_UNKNOWN
static void uhso_free(struct ucom_softc *)
static struct ucom_callback uhso_ucom_callback
DRIVER_MODULE(uhso, uhub, uhso_driver, uhso_devclass, uhso_driver_loaded, 0)
#define UHSO_PORT_TYPE_NETWORK
static void uhso_ucom_stop_read(struct ucom_softc *)
static const struct usb_config uhso_ctrl_config[UHSO_CTRL_MAX]
static usb_callback_t uhso_bs_intr_callback
static int uhso_alloc_tty(struct uhso_softc *sc)
USB_PNP_HOST_INFO(uhso_devs)
#define UHSO_MPORT_TYPE_NOMAX
static usb_callback_t uhso_bs_write_callback
static driver_t uhso_driver
static int uhso_if_output(struct ifnet *, struct mbuf *, const struct sockaddr *, struct route *)
static void uhso_test_autoinst(void *, struct usb_device *, struct usb_attach_arg *)
#define UHSO_PORT_TYPE_DIAG
static usb_callback_t uhso_ifnet_read_callback
static const STRUCT_USB_HOST_ID uhso_devs[]
static const struct usb_config uhso_bs_config[UHSO_BULK_ENDPT_MAX]
#define UHSO_PORT_TYPE_GPSCTL
#define UHSO_STATIC_IFACE
#define UHSO_PORT_NETWORK
static void uhso_if_stop(struct uhso_softc *)
static void uhso_ucom_start_write(struct ucom_softc *)
static void uhso_ucom_cfg_get_status(struct ucom_softc *, uint8_t *, uint8_t *)
#define UHSO_DPRINTF(n, x,...)
#define UHSO_DEV(v, p, i)
#define UHSO_PORT_TYPE_PCSC
static struct unrhdr * uhso_ifnet_unit
#define UHSO_PORT_TYPE_CTL
static char * uhso_port[]
SYSCTL_INT(_hw_usb_uhso, OID_AUTO, auto_switch, CTLFLAG_RWTUN, &uhso_autoswitch, 0, "Automatically switch to modem mode")
static device_method_t uhso_methods[]
MODULE_DEPEND(uhso, ucom, 1, 1, 1)
#define UHSO_PORT_TYPE_GPS
static void uhso_ucom_cfg_set_rts(struct ucom_softc *, uint8_t)
#define UHSO_IFACE_USB_TYPE(x)
static int uhso_probe_iface_static(struct usb_device *, int)
static device_probe_t uhso_probe
static void uhso_ucom_stop_write(struct ucom_softc *)
static device_attach_t uhso_attach
static int uhso_attach_bulkserial(struct uhso_softc *, struct usb_interface *, int type)
static void uhso_free_softc(struct uhso_softc *)
#define UHSO_IFACE_PORT_TYPE(x)
static unsigned char uhso_mux_port_map[]
static devclass_t uhso_devclass
#define UHSO_PORT_TYPE_DIAG2
static usb_callback_t uhso_ifnet_write_callback
#define UHSO_IFACE_PORT(x)
static void uhso_ucom_start_read(struct ucom_softc *)
#define UHSO_PORT_TYPE_APP
static int uhso_probe_iface(struct uhso_softc *, int, int(*probe)(struct usb_device *, int))
#define UT_READ_CLASS_INTERFACE
#define UT_READ_VENDOR_DEVICE
#define UT_WRITE_CLASS_INTERFACE
#define UDESC_CS_INTERFACE
void usbd_get_page(struct usb_page_cache *pc, usb_frlength_t offset, struct usb_page_search *res)
void usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, const void *ptr, usb_frlength_t len)
void usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, void *ptr, usb_frlength_t len)
#define UCDC_SEND_ENCAPSULATED_COMMAND
#define UCDC_NOTIFICATION_LENGTH
#define UCDC_N_SERIAL_STATE
#define UCDC_N_SERIAL_DCD
#define UCDC_SET_CONTROL_LINE_STATE
#define UCDC_N_SERIAL_DSR
#define UCDC_GET_ENCAPSULATED_RESPONSE
#define UCDC_NOTIFICATION
struct usb_interface_descriptor * usbd_get_interface_descriptor(struct usb_interface *iface)
struct usb_config_descriptor * usbd_get_config_descriptor(struct usb_device *udev)
void * usbd_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index, uint8_t type, uint8_t type_mask, uint8_t subtype, uint8_t subtype_mask)
const char * usb_get_product(struct usb_device *udev)
struct usb_interface * usbd_get_iface(struct usb_device *udev, uint8_t iface_index)
const char * usb_get_manufacturer(struct usb_device *udev)
struct usb_endpoint_descriptor desc
const char * usbd_errstr(usb_error_t err)
int usbd_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id, struct usb_attach_arg *uaa)
usb_error_t usb_msc_eject(struct usb_device *udev, uint8_t iface_index, int method)
usb_error_t usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx, struct usb_device_request *req, void *data, uint16_t flags, uint16_t *actlen, usb_timeout_t timeout)
uint8_t ucom_get_data(struct ucom_softc *sc, struct usb_page_cache *pc, uint32_t offset, uint32_t len, uint32_t *actlen)
void ucom_status_change(struct ucom_softc *sc)
int ucom_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc, int subunits, void *parent, const struct ucom_callback *callback, struct mtx *mtx)
int ucom_unref(struct ucom_super_softc *ssc)
void ucom_ref(struct ucom_super_softc *ssc)
void ucom_set_pnpinfo_usb(struct ucom_super_softc *ssc, device_t dev)
void ucom_detach(struct ucom_super_softc *ssc, struct ucom_softc *sc)
void ucom_put_data(struct ucom_softc *sc, struct usb_page_cache *pc, uint32_t offset, uint32_t len)
#define ucom_cfg_do_request(udev, com, req, ptr, flags, timo)
void usbd_transfer_submit(struct usb_xfer *xfer)
void usbd_xfer_set_frames(struct usb_xfer *xfer, usb_frcount_t n)
void * usbd_xfer_get_priv(struct usb_xfer *xfer)
void usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
void usbd_xfer_set_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex, usb_frlength_t len)
usb_frlength_t usbd_xfer_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex)
struct usb_page_cache * usbd_xfer_get_frame(struct usb_xfer *xfer, usb_frcount_t frindex)
usb_error_t usbd_transfer_setup(struct usb_device *udev, const uint8_t *ifaces, struct usb_xfer **ppxfer, const struct usb_config *setup_start, uint16_t n_setup, void *priv_sc, struct mtx *xfer_mtx)
void usbd_transfer_start(struct usb_xfer *xfer)
void usbd_xfer_set_priv(struct usb_xfer *xfer, void *ptr)
void * usbd_xfer_softc(struct usb_xfer *xfer)
void usbd_xfer_set_stall(struct usb_xfer *xfer)
void usbd_transfer_stop(struct usb_xfer *xfer)
void usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen, int *aframes, int *nframes)
usb_frlength_t usbd_xfer_max_len(struct usb_xfer *xfer)
#define USB_ST_TRANSFERRED
void usbd_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset, struct mbuf *m, usb_size_t src_offset, usb_frlength_t src_len)
void() usb_callback_t(struct usb_xfer *, usb_error_t)
#define STRUCT_USB_HOST_ID
#define USB_GET_DRIVER_INFO(did)
#define USB_GET_STATE(xfer)
#define usbd_do_request(u, m, r, d)