68#include <sys/callout.h>
69#include <sys/condvar.h>
70#include <sys/kernel.h>
72#include <sys/malloc.h>
73#include <sys/module.h>
77#include <sys/random.h>
78#include <sys/socket.h>
79#include <sys/stddef.h>
80#include <sys/stdint.h>
82#include <sys/sysctl.h>
84#include <sys/unistd.h>
87#include <net/if_var.h>
88#include <net/if_media.h>
90#include <dev/mii/mii.h>
91#include <dev/mii/miivar.h>
93#include <netinet/in.h>
94#include <netinet/ip.h>
96#include "opt_platform.h"
99#include <dev/fdt/fdt_common.h>
100#include <dev/ofw/ofw_bus.h>
101#include <dev/ofw/ofw_bus_subr.h>
110#define USB_DEBUG_VAR lan78xx_debug
118#include "miibus_if.h"
121static int muge_debug = 0;
123SYSCTL_NODE(_hw_usb, OID_AUTO, muge, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
124 "Microchip LAN78xx USB-GigE");
125SYSCTL_INT(_hw_usb_muge, OID_AUTO,
debug, CTLFLAG_RWTUN, &muge_debug, 0,
129#define MUGE_DEFAULT_TX_CSUM_ENABLE (false)
130#define MUGE_DEFAULT_TSO_ENABLE (false)
134#define MUGE_DEV(p,i) { USB_VPI(USB_VENDOR_SMC2, USB_PRODUCT_SMC2_##p, i) }
142#define muge_dbg_printf(sc, fmt, args...) \
144 if (muge_debug > 0) \
145 device_printf((sc)->sc_ue.ue_dev, "debug: " fmt, ##args); \
148#define muge_dbg_printf(sc, fmt, args...) do { } while (0)
151#define muge_warn_printf(sc, fmt, args...) \
152 device_printf((sc)->sc_ue.ue_dev, "warning: " fmt, ##args)
154#define muge_err_printf(sc, fmt, args...) \
155 device_printf((sc)->sc_ue.ue_dev, "error: " fmt, ##args)
157#define ETHER_IS_VALID(addr) \
158 (!ETHER_IS_MULTICAST(addr) && !ETHER_IS_ZERO(addr))
190#define MUGE_FLAG_LINK 0x0001
191#define MUGE_FLAG_INIT_DONE 0x0002
194#define MUGE_IFACE_IDX 0
196#define MUGE_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)
197#define MUGE_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)
198#define MUGE_LOCK_ASSERT(_sc, t) mtx_assert(&(_sc)->sc_mtx, t)
224static int muge_ioctl(
struct ifnet *ifp, u_long cmd, caddr_t data);
232 .bufsize = 16 * (MCLBYTES + 16),
243 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
297 *
data = le32toh(buf);
365 }
while (((
usb_ticks_t)(ticks - start_ticks)) < max_ticks);
396 locked = mtx_owned(&sc->
sc_mtx);
416 for (i = 0; i < buflen; i++) {
432 }
while (((
usb_ticks_t)(ticks - start_ticks)) < max_ticks);
443 buf[i] = (
val & 0xff);
490 locked = mtx_owned(&sc->
sc_mtx);
507 for (i = 0; i < buflen; i++) {
524 buf[i] = (uint8_t)(
val & 0xff);
587 "setting mac address to %02x:%02x:%02x:%02x:%02x:%02x\n",
626 buf &= ~ETH_MAC_RX_EN_;
631 buf &= ~ETH_MAC_RX_MAX_FR_SIZE_MASK_;
667 locked = mtx_owned(&sc->
sc_mtx);
677 addr = (phy << 11) | (
reg << 6) |
694 return (
val & 0xFFFF);
722 locked = mtx_owned(&sc->
sc_mtx);
735 addr = (phy << 11) | (
reg << 6) |
766 uint32_t fct_flow = 0;
769 locked = mtx_owned(&sc->
sc_mtx);
774 if (mii == NULL || ifp == NULL ||
775 (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
780 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
781 (IFM_ACTIVE | IFM_AVALID)) {
783 switch (IFM_SUBTYPE(mii->mii_media_active)) {
806 "failed to read initial flow control thresholds, error %d\n",
812 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
816 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0)
819 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0)
865 buf &= ~MUGE_EXT_MODE_CTRL_MDIX_MASK_;
913 }
while ((bmcr & BMCR_RESET) && ((ticks - start_ticks) < max_ticks));
915 if (((
usb_ticks_t)(ticks - start_ticks)) >= max_ticks) {
932 ANAR_10 | ANAR_10_FD | ANAR_TX | ANAR_TX_FD |
933 ANAR_CSMA | ANAR_FC | ANAR_PAUSE_ASYM);
936 bmcr |= BMCR_STARTNEG;
945 lmsr &= ~sc->sc_led_modes_mask;
987 "timed-out waiting for lite reset to complete\n");
1101 "timed-out waiting for phy reset to complete\n");
1171 uint32_t rx_cmd_a, rx_cmd_b;
1186 if (actlen < (
sizeof(rx_cmd_a) + ETHER_CRC_LEN))
1197 while (off < actlen) {
1199 off = ((off + 0x3) & ~0x3);
1202 if (off +
sizeof(rx_cmd_a) > actlen)
1205 off += (
sizeof(rx_cmd_a));
1206 rx_cmd_a = le32toh(rx_cmd_a);
1209 if (off +
sizeof(rx_cmd_b) > actlen)
1212 off += (
sizeof(rx_cmd_b));
1213 rx_cmd_b = le32toh(rx_cmd_b);
1216 if (off +
sizeof(rx_cmd_c) > actlen)
1219 off += (
sizeof(rx_cmd_c));
1220 rx_cmd_c = le16toh(rx_cmd_c);
1228 "rx_cmd_a 0x%08x rx_cmd_b 0x%08x rx_cmd_c 0x%04x "
1229 " pktlen %d actlen %d off %d\n",
1230 rx_cmd_a, rx_cmd_b, rx_cmd_c, pktlen, actlen, off);
1234 "rx error (hdr 0x%08x)\n", rx_cmd_a);
1235 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1238 if ((pktlen < ETHER_HDR_LEN) ||
1239 (pktlen > (actlen - off)))
1246 "failed to create new mbuf\n");
1247 if_inc_counter(ifp, IFCOUNTER_IQDROPS,
1251 if (pktlen > m->m_len) {
1253 "buffer too small %d vs %d bytes",
1255 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
1266 if ((ifp->if_capenable & IFCAP_RXCSUM) &&
1268 struct ether_header *eh;
1269 eh = mtod(m,
struct ether_header *);
1287 if (pktlen > ETHER_MIN_LEN) {
1288 m->m_pkthdr.csum_flags |=
1300 &m->m_pkthdr.csum_data, 2);
1308 m->m_pkthdr.csum_data =
1312 "RX checksum offloaded (0x%04x)\n",
1313 m->m_pkthdr.csum_data);
1318 if (pktlen < (4 + ETHER_HDR_LEN)) {
1367 uint32_t frm_len = 0, tx_cmd_a = 0, tx_cmd_b = 0;
1372 "USB TRANSFER status: USB_ST_TRANSFERRED\n");
1373 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1379 (ifp->if_drv_flags & IFF_DRV_OACTIVE) != 0) {
1381 "sc->sc_flags & MUGE_FLAG_LINK: %d\n",
1384 "ifp->if_drv_flags & IFF_DRV_OACTIVE: %d\n",
1385 (ifp->if_drv_flags & IFF_DRV_OACTIVE));
1387 "USB TRANSFER not sending: no link or controller is busy \n");
1395 nframes < 16 && !IFQ_DRV_IS_EMPTY(&ifp->if_snd);
1397 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1411 tx_cmd_a = htole32(tx_cmd_a);
1417 tx_cmd_b = htole32(tx_cmd_b);
1424 frm_len += m->m_pkthdr.len;
1426 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
1444 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1449 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1450 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1473 uint32_t mac_h, mac_l;
1475 memset(ue->
ue_eaddr, 0xff, ETHER_ADDR_LEN);
1483 ue->
ue_eaddr[5] = (uint8_t)((mac_h >> 8) & 0xff);
1484 ue->
ue_eaddr[4] = (uint8_t)((mac_h) & 0xff);
1485 ue->
ue_eaddr[3] = (uint8_t)((mac_l >> 24) & 0xff);
1486 ue->
ue_eaddr[2] = (uint8_t)((mac_l >> 16) & 0xff);
1487 ue->
ue_eaddr[1] = (uint8_t)((mac_l >> 8) & 0xff);
1488 ue->
ue_eaddr[0] = (uint8_t)((mac_l) & 0xff);
1517 arc4rand(ue->
ue_eaddr, ETHER_ADDR_LEN, 0);
1541 (proplen = OF_getencprop(node,
"microchip,led-modes", modes,
1542 sizeof(modes))) > 0) {
1543 count = proplen /
sizeof( uint32_t );
1548 while (
count-- > 0) {
1604 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1608 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
1609 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
1610 IFQ_SET_READY(&ifp->if_snd);
1617 ifp->if_capabilities |= IFCAP_VLAN_MTU;
1618 ifp->if_hwassist = 0;
1619 ifp->if_capabilities |= IFCAP_RXCSUM;
1622 ifp->if_capabilities |= IFCAP_TXCSUM;
1630 ifp->if_capabilities |= IFCAP_TSO4 | IFCAP_TSO6;
1634 ifp->if_capabilities |= IFCAP_TXCSUM;
1635 ifp->if_capenable |= IFCAP_TXCSUM;
1636 ifp->if_hwassist = CSUM_TCP | CSUM_UDP;
1639 ifp->if_capenable = ifp->if_capabilities;
1689 if (cmd == SIOCSIFCAP) {
1691 ifr = (
struct ifreq *)
data;
1698 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
1701 if ((mask & IFCAP_RXCSUM) != 0 &&
1702 (ifp->if_capabilities & IFCAP_RXCSUM) != 0) {
1703 ifp->if_capenable ^= IFCAP_RXCSUM;
1705 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1706 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1758 uint8_t addr[ETHER_ADDR_LEN])
1764 tmp |=
addr[2] | (tmp << 8);
1765 tmp |=
addr[1] | (tmp << 8);
1766 tmp |=
addr[0] | (tmp << 8);
1769 tmp |=
addr[4] | (tmp << 8);
1789 uint32_t addr, uint32_t length, uint32_t *buf)
1801 dp_sel &= ~ETH_DP_SEL_RSEL_MASK_;
1802 dp_sel |= ram_select;
1806 for (i = 0; i < length; i++) {
1855static inline uint32_t
1858 return (ether_crc32_be(
addr, ETHER_ADDR_LEN) >> 23) & 0x1ff;
1912 if (ifp->if_flags & IFF_PROMISC) {
1915 }
else if (ifp->if_flags & IFF_ALLMULTI) {
1939 (ifp->if_flags & IFF_PROMISC) ?
"en" :
"dis");
1943 if (ifp->if_flags & IFF_PROMISC)
1972 if (ifp->if_capenable & IFCAP_RXCSUM) {
2014 struct mii_softc *miisc;
2019 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
2021 err = mii_mediachg(mii);
2046 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
2064 ifp->if_drv_flags |= IFF_DRV_RUNNING;
2083 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
2137 ifmr->ifm_active = mii->mii_media_active;
2138 ifmr->ifm_status = mii->mii_media_status;
2180 uint8_t iface_index;
2187 mtx_init(&sc->
sc_mtx, device_get_nameunit(
dev), NULL, MTX_DEF);
2194 device_printf(
dev,
"error: allocating USB transfers failed\n");
2206 device_printf(
dev,
"error: could not attach interface\n");
2222 mtx_destroy(&sc->
sc_mtx);
2242 mtx_destroy(&sc->
sc_mtx);
2254 DEVMETHOD(bus_print_child, bus_generic_print_child),
2255 DEVMETHOD(bus_driver_added, bus_generic_driver_added),
static SYSCTL_NODE(_hw_usb, OID_AUTO, dwc_otg, CTLFLAG_RW|CTLFLAG_MPSAFE, 0, "USB DWC OTG")
SYSCTL_INT(_hw_usb_dwc_otg, OID_AUTO, phy_type, CTLFLAG_RDTUN, &dwc_otg_phy_type, 0, "DWC OTG PHY TYPE - 0/1/2/3 - ULPI/HSIC/INTERNAL/UTMI+")
static const struct usb_device_id lan78xx_devs[]
#define muge_warn_printf(sc, fmt, args...)
static const struct usb_ether_methods muge_ue_methods
static u_int muge_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
#define MUGE_DEFAULT_TSO_ENABLE
DRIVER_MODULE(muge, uhub, muge_driver, muge_devclass, NULL, NULL)
static uether_fn_t muge_tick
MODULE_DEPEND(muge, uether, 1, 1, 1)
#define muge_dbg_printf(sc, fmt, args...)
static driver_t muge_driver
static int muge_attach_post_sub(struct usb_ether *ue)
static int lan78xx_chip_init(struct muge_softc *sc)
static miibus_writereg_t lan78xx_miibus_writereg
static int muge_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
static int lan78xx_dataport_write(struct muge_softc *sc, uint32_t ram_select, uint32_t addr, uint32_t length, uint32_t *buf)
#define MUGE_FLAG_INIT_DONE
static void muge_set_mac_addr(struct usb_ether *ue)
static usb_callback_t muge_bulk_read_callback
static void muge_set_addr_filter(struct muge_softc *sc, int index, uint8_t addr[ETHER_ADDR_LEN])
static miibus_statchg_t lan78xx_miibus_statchg
static uint32_t muge_hash(uint8_t addr[ETHER_ADDR_LEN])
static int lan78xx_phy_init(struct muge_softc *sc)
static void muge_multicast_write(struct muge_softc *sc)
static void muge_reset(struct muge_softc *sc)
static uether_fn_t muge_stop
static int lan78xx_set_rx_max_frame_length(struct muge_softc *sc, int size)
#define ETHER_IS_VALID(addr)
static int muge_ifmedia_upd(struct ifnet *)
static usb_callback_t muge_bulk_write_callback
static void lan78xx_set_mdix_auto(struct muge_softc *sc)
static int lan78xx_wait_for_bits(struct muge_softc *sc, uint32_t reg, uint32_t bits)
static int muge_sethwcsum(struct muge_softc *sc)
static uether_fn_t muge_attach_post
static void muge_ifmedia_sts(struct ifnet *, struct ifmediareq *)
static void muge_set_leds(struct usb_ether *ue)
static device_attach_t muge_attach
static const struct usb_config muge_config[MUGE_N_TRANSFER]
static int lan78xx_setmacaddress(struct muge_softc *sc, const uint8_t *addr)
static devclass_t muge_devclass
static uether_fn_t muge_setpromisc
static int lan78xx_otp_read_raw(struct muge_softc *sc, uint16_t off, uint8_t *buf, uint16_t buflen)
static uether_fn_t muge_setmulti
static device_detach_t muge_detach
#define MUGE_LOCK_ASSERT(_sc, t)
static uether_fn_t muge_init
static int lan78xx_otp_read(struct muge_softc *sc, uint16_t off, uint8_t *buf, uint16_t buflen)
static int lan78xx_read_reg(struct muge_softc *sc, uint32_t off, uint32_t *data)
static bool lan78xx_eeprom_present(struct muge_softc *sc)
static device_probe_t muge_probe
#define MUGE_DEFAULT_TX_CSUM_ENABLE
static int lan78xx_write_reg(struct muge_softc *sc, uint32_t off, uint32_t data)
static int lan78xx_eeprom_read_raw(struct muge_softc *sc, uint16_t off, uint8_t *buf, uint16_t buflen)
static uether_fn_t muge_start
static device_method_t muge_methods[]
static miibus_readreg_t lan78xx_miibus_readreg
#define muge_err_printf(sc, fmt, args...)
USB_PNP_HOST_INFO(lan78xx_devs)
#define ETH_E2P_CMD_ADDR_MASK_
#define MUGE_NUM_PFILTER_ADDRS_
#define ETH_RFE_CTL_IGMP_COE_
#define MUGE_MAX_TX_FIFO_SIZE
#define ETH_HW_CFG_LED3_EN_
#define ETH_RFE_CTL_BCAST_EN_
#define ETH_FLOW_CR_RX_FCEN_
#define ETH_ID_REV_CHIP_REV_MASK_
#define MUGE_MAX_RX_FIFO_SIZE
#define MUGE_HS_USB_PKT_SIZE
#define MUGE_PHY_INTR_ANEG_COMP
#define ETH_INT_STS_CLEAR_ALL_
#define OTP_INDICATOR_OFFSET
#define MUGE_PHY_INTR_LINK_CHANGE
#define ETH_ID_REV_CHIP_ID_7800_
#define ETH_E2P_CMD_TIMEOUT_
#define ETH_INT_ENP_PHY_INT
#define ETH_DP_SEL_RSEL_VLAN_DA_
#define MUGE_EXT_PAGE_SPACE_0
#define ETH_HW_CFG_LED2_EN_
#define ETH_ID_REV_CHIP_ID_7850_
#define MUGE_PHY_INTR_MASK
#define ETH_MII_ACC_MII_BUSY_
#define ETH_DP_SEL_VHF_HASH_LEN
#define MUGE_EXT_MODE_CTRL_AUTO_MDIX_
#define ETH_MAC_RX_MAX_FR_SIZE_SHIFT_
#define ETH_MAC_CR_AUTO_SPEED_
#define ETH_DP_SEL_VHF_VLAN_LEN
#define ETH_MAF_HI_TYPE_DST_
#define MUGE_DEFAULT_BURST_CAP_SIZE
#define ETH_RFE_CTL_DA_PERFECT_
#define ETH_E2P_MAC_OFFSET
#define ETH_FCT_TX_CTL_EN_
#define ETH_FLOW_CR_TX_FCEN_
#define ETH_RFE_CTL_MCAST_HASH_
#define ETH_DP_CMD_WRITE_
#define ETH_E2P_CMD_READ_
#define MUGE_SS_USB_PKT_SIZE
#define ETH_RFE_CTL_ICMP_COE_
#define RX_CMD_A_LEN_MASK_
#define ETH_ID_REV_CHIP_ID_MASK_
#define ETH_RFE_CTL_UCAST_EN_
#define MUGE_CONFIG_INDEX
#define TX_CMD_A_LEN_MASK_
#define MUGE_PHY_INTR_STAT
#define MUGE_FS_USB_PKT_SIZE
#define ETH_RFE_CTL_MCAST_EN_
#define ETH_FCT_TX_FIFO_END
#define ETH_PMT_CTL_PHY_RST_
#define ETH_MAC_RX_MAX_FR_SIZE_MASK_
#define ETH_MAF_HI_VALID_
#define ETH_E2P_INDICATOR_OFFSET
#define OTP_FUNC_CMD_READ_
#define MUGE_EXT_PAGE_SPACE_1
#define PFILTER_LO(index)
#define ETH_RFE_CTL_IP_COE_
#define MUGE_EXT_MODE_CTRL
#define ETH_HW_CFG_LEDO_EN_
#define ETH_RFE_CTL_TCPUDP_COE_
#define ETH_MII_ACC_MII_WRITE_
#define ETH_DP_SEL_DPRDY_
#define OTP_PWR_DN_PWRDN_N
#define ETH_MAC_CR_AUTO_DUPLEX_
#define ETH_E2P_INDICATOR
#define ETH_HW_CFG_LED1_EN_
#define ETH_E2P_CMD_BUSY_
#define ETH_MII_ACC_MII_READ_
#define MUGE_DEFAULT_BULK_IN_DELAY
#define PFILTER_HI(index)
#define ETH_FCT_RX_FIFO_END
#define MUGE_PHY_LED_MODE
#define MUGE_EXT_PAGE_ACCESS
uint16_t sc_led_modes_mask
struct usb_xfer * sc_xfer[MUGE_N_TRANSFER]
uint32_t sc_pfilter_table[MUGE_NUM_PFILTER_ADDRS_][2]
uint32_t sc_mchash_table[ETH_DP_SEL_VHF_HASH_LEN]
enum usb_hc_mode usb_mode
struct usbd_lookup_info info
struct usb_device * device
uByte bConfigurationValue
struct usb_xfer_flags flags
void(* ue_mii_sts)(struct ifnet *, struct ifmediareq *)
uether_fn_t * ue_attach_post
const struct usb_ether_methods * ue_methods
struct usb_device * ue_udev
uint8_t ue_eaddr[ETHER_ADDR_LEN]
#define UT_WRITE_VENDOR_DEVICE
#define UT_READ_VENDOR_DEVICE
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)
struct usb_config_descriptor * usbd_get_config_descriptor(struct usb_device *udev)
enum usb_dev_speed usbd_get_speed(struct usb_device *udev)
const char * usbd_errstr(usb_error_t err)
void uether_rxflush(struct usb_ether *ue)
struct mbuf * uether_newbuf(void)
void uether_ifdetach(struct usb_ether *ue)
void * uether_getsc(struct usb_ether *ue)
struct ifnet * uether_getifp(struct usb_ether *ue)
uint8_t uether_pause(struct usb_ether *ue, unsigned int _ticks)
int uether_rxmbuf(struct usb_ether *ue, struct mbuf *m, unsigned int len)
struct mii_data * uether_getmii(struct usb_ether *ue)
int uether_ifmedia_upd(struct ifnet *ifp)
void uether_init(void *arg)
int uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
int uether_ifattach(struct usb_ether *ue)
void uether_ifattach_wait(struct usb_ether *ue)
void uether_start(struct ifnet *ifp)
#define uether_do_request(ue, req, data, timo)
void() uether_fn_t(struct usb_ether *)
int usb_fdt_get_mac_addr(device_t dev, struct usb_ether *ue)
phandle_t usb_fdt_get_node(device_t dev, struct usb_device *udev)
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 usbd_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf)
void usbd_transfer_submit(struct usb_xfer *xfer)
void usbd_xfer_set_frames(struct usb_xfer *xfer, usb_frcount_t n)
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)
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_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset, usb_frcount_t frindex)
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)
void device_set_usb_desc(device_t dev)
#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)
#define USB_MS_TO_TICKS(ms)
void() usb_callback_t(struct usb_xfer *, usb_error_t)
#define USB_GET_DRIVER_INFO(did)
#define USB_GET_STATE(xfer)