39#include <sys/condvar.h>
40#include <sys/endian.h>
41#include <sys/kernel.h>
43#include <sys/module.h>
45#include <sys/socket.h>
46#include <sys/sysctl.h>
47#include <sys/unistd.h>
50#include <net/if_var.h>
51#include <net/if_media.h>
53#include <dev/mii/mii.h>
54#include <dev/mii/miivar.h>
61#define USB_DEBUG_VAR axge_debug
75#define AXGE_DEV(v,p) { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
92 { 7, 0x4f, 0x00, 0x12, 0xff },
93 { 7, 0x20, 0x03, 0x16, 0xff },
94 { 7, 0xae, 0x07, 0x18, 0xff },
95 { 7, 0xcc, 0x4c, 0x18, 0x08 }
119 uint16_t,
void *,
int);
121 uint16_t,
void *,
int);
135static int axge_ioctl(
struct ifnet *, u_long, caddr_t);
138 unsigned int,
unsigned int, uint32_t);
141#define AXGE_CSUM_FEATURES (CSUM_IP | CSUM_TCP | CSUM_UDP)
144static int axge_debug = 0;
146static SYSCTL_NODE(_hw_usb, OID_AUTO, axge, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
148SYSCTL_INT(_hw_usb_axge, OID_AUTO,
debug, CTLFLAG_RWTUN, &axge_debug, 0,
159 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
168 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
220 uint16_t
val,
void *buf,
int len)
237 uint16_t
val,
void *buf,
int len)
281 uint16_t
reg, uint16_t
val)
296 sc = device_get_softc(
dev);
297 locked = mtx_owned(&sc->
sc_mtx);
315 sc = device_get_softc(
dev);
316 locked = mtx_owned(&sc->
sc_mtx);
332 struct mii_data *mii;
334 uint8_t link_status, tmp[5];
338 sc = device_get_softc(
dev);
340 locked = mtx_owned(&sc->
sc_mtx);
345 if (mii == NULL || ifp == NULL ||
346 (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
350 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
351 (IFM_ACTIVE | IFM_AVALID)) {
352 switch (IFM_SUBTYPE(mii->mii_media_active)) {
370 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
372 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0)
374 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0)
378 switch (IFM_SUBTYPE(mii->mii_media_active)) {
430 DPRINTF(
"reset failed (ignored)\n");
459 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
463 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
464 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
465 IFQ_SET_READY(&ifp->if_snd);
467 ifp->if_capabilities |= IFCAP_VLAN_MTU | IFCAP_TXCSUM | IFCAP_RXCSUM;
469 ifp->if_capenable = ifp->if_capabilities;
474 BMSR_DEFCAPMASK,
AXGE_PHY_ADDR, MII_OFFSET_ANY, MIIF_DOPAUSE);
487 struct mii_data *mii;
488 struct mii_softc *miisc;
495 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
497 error = mii_mediachg(mii);
509 struct mii_data *mii;
515 ifmr->ifm_active = mii->mii_media_active;
516 ifmr->ifm_status = mii->mii_media_status;
528 uaa = device_get_ivars(
dev);
552 uaa = device_get_ivars(
dev);
553 sc = device_get_softc(
dev);
557 mtx_init(&sc->
sc_mtx, device_get_nameunit(
dev), NULL, MTX_DEF);
563 device_printf(
dev,
"allocating USB transfers failed\n");
576 device_printf(
dev,
"could not attach interface\n");
593 sc = device_get_softc(
dev);
595 if (device_is_attached(
dev)) {
671 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
676 (ifp->if_drv_flags & IFF_DRV_OACTIVE) != 0) {
685 !IFQ_DRV_IS_EMPTY(&ifp->if_snd); nframes++) {
686 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
694 if ((ifp->if_capenable & IFCAP_TXCSUM) != 0 &&
700 pos +=
sizeof(txhdr);
702 pos += m->m_pkthdr.len;
725 if_inc_counter(ifp, IFCOUNTER_OPACKETS, nframes);
728 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
733 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
734 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
748 struct mii_data *mii;
760 uint8_t *hashtbl = arg;
763 h = ether_crc32_be(LLADDR(sdl), ETHER_ADDR_LEN) >> 26;
764 hashtbl[h / 8] |= 1 << (h % 8);
775 uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
790 if (ifp->if_flags & IFF_BROADCAST)
792 if (ifp->if_flags & (IFF_ALLMULTI | IFF_PROMISC)) {
793 if (ifp->if_flags & IFF_PROMISC)
830 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
842 IF_LLADDR(ifp), ETHER_ADDR_LEN);
869 ifp->if_drv_flags |= IFF_DRV_RUNNING;
891 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
907 int error, mask, reinit;
911 ifr = (
struct ifreq *)
data;
914 if (cmd == SIOCSIFCAP) {
916 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
917 if ((mask & IFCAP_TXCSUM) != 0 &&
918 (ifp->if_capabilities & IFCAP_TXCSUM) != 0) {
919 ifp->if_capenable ^= IFCAP_TXCSUM;
920 if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
923 ifp->if_hwassist &= ~AXGE_CSUM_FEATURES;
926 if ((mask & IFCAP_RXCSUM) != 0 &&
927 (ifp->if_capabilities & IFCAP_RXCSUM) != 0) {
928 ifp->if_capenable ^= IFCAP_RXCSUM;
931 if (reinit > 0 && ifp->if_drv_flags & IFF_DRV_RUNNING)
932 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
950 uint32_t pkt_cnt, pkt_end;
955 if (actlen < (
int)
sizeof(rxhdr))
960 usbd_copy_out(pc, actlen -
sizeof(rxhdr), &rxhdr,
sizeof(rxhdr));
961 rxhdr = le32toh(rxhdr);
963 pkt_cnt = rxhdr & 0xFFFF;
964 hdr_off = pkt_end = (rxhdr >> 16) & 0xFFFF;
979 if ((
int)(hdr_off +
sizeof(pkt_hdr)) > actlen) {
980 DPRINTF(
"End of packet headers\n");
986 if (pos + pktlen > pkt_end) {
987 DPRINTF(
"Data position reached end\n");
993 if_inc_counter(ue->
ue_ifp, IFCOUNTER_IERRORS, 1);
996 pos += (pktlen + 7) & ~7;
997 hdr_off +=
sizeof(pkt_hdr);
1009 if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN) {
1010 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1014 if (
len > MHLEN - ETHER_ALIGN)
1015 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
1017 m = m_gethdr(M_NOWAIT, MT_DATA);
1019 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
1022 m->m_pkthdr.rcvif = ifp;
1023 m->m_len = m->m_pkthdr.len =
len;
1024 m->m_data += ETHER_ALIGN;
1028 if ((ifp->if_capenable & IFCAP_RXCSUM) != 0) {
1031 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED |
1036 m->m_pkthdr.csum_flags |= CSUM_DATA_VALID |
1038 m->m_pkthdr.csum_data = 0xffff;
1041 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
1043 (void)mbufq_enqueue(&ue->
ue_rxq, m);
1058 if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
1063 if ((ifp->if_capenable & IFCAP_RXCSUM) != 0)
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 u_int axge_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
static void axge_rxeof(struct usb_ether *, struct usb_page_cache *, unsigned int, unsigned int, uint32_t)
static void axge_rx_frame(struct usb_ether *, struct usb_page_cache *, int)
static usb_callback_t axge_bulk_write_callback
static device_method_t axge_methods[]
static void axge_ifmedia_sts(struct ifnet *, struct ifmediareq *)
static void axge_csum_cfg(struct usb_ether *)
static miibus_writereg_t axge_miibus_writereg
static uether_fn_t axge_rxfilter
static uether_fn_t axge_start
static uint8_t axge_read_cmd_1(struct axge_softc *, uint8_t, uint16_t)
static const struct usb_config axge_config[AXGE_N_TRANSFER]
static int axge_ifmedia_upd(struct ifnet *)
static const struct usb_ether_methods axge_ue_methods
static int axge_attach_post_sub(struct usb_ether *)
static uether_fn_t axge_stop
static uether_fn_t axge_init
static int axge_ioctl(struct ifnet *, u_long, caddr_t)
static driver_t axge_driver
static void axge_write_cmd_2(struct axge_softc *, uint8_t, uint16_t, uint16_t, uint16_t)
static uint16_t axge_read_cmd_2(struct axge_softc *, uint8_t, uint16_t, uint16_t)
MODULE_DEPEND(axge, uether, 1, 1, 1)
static uether_fn_t axge_tick
DRIVER_MODULE(axge, uhub, axge_driver, axge_devclass, NULL, NULL)
static device_probe_t axge_probe
static device_detach_t axge_detach
USB_PNP_HOST_INFO(axge_devs)
static const struct @27 axge_bulk_size[]
#define AXGE_CSUM_FEATURES
static const STRUCT_USB_HOST_ID axge_devs[]
static int axge_read_mem(struct axge_softc *, uint8_t, uint16_t, uint16_t, void *, int)
static miibus_readreg_t axge_miibus_readreg
static device_attach_t axge_attach
static uether_fn_t axge_attach_post
static usb_callback_t axge_bulk_read_callback
static void axge_reset(struct axge_softc *)
static void axge_write_mem(struct axge_softc *, uint8_t, uint16_t, uint16_t, void *, int)
static miibus_statchg_t axge_miibus_statchg
static devclass_t axge_devclass
static void axge_write_cmd_1(struct axge_softc *, uint8_t, uint16_t, uint8_t)
static void axge_chip_init(struct axge_softc *)
#define AXGE_RX_L4_TYPE_MASK
#define AXGE_RX_L3_TYPE_IPV4
#define AXGE_CLK_SELECT_ACS
#define AXGE_RX_L3_CSUM_ERR
#define AXGE_LOCK_ASSERT(_sc, t)
#define AXGE_RX_L3_TYPE_MASK
#define AXGE_RX_L4_CSUM_ERR
#define AXGE_CLK_SELECT_BCS
#define AXGE_RX_BULKIN_QCTRL
#define AXGE_RX_L4_TYPE_TCP
#define AXGE_RX_L4_TYPE_UDP
#define RCR_ACPT_ALL_MCAST
#define AXGE_CSUM_DISABLE
struct usb_xfer * sc_xfer[AXGE_N_TRANSFER]
enum usb_hc_mode usb_mode
struct usbd_lookup_info info
struct usb_device * device
uByte bConfigurationValue
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)
void uether_rxflush(struct usb_ether *ue)
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_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_start(struct ifnet *ifp)
#define uether_do_request(ue, req, data, timo)
void() uether_fn_t(struct usb_ether *)
int usbd_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id, struct usb_attach_arg *uaa)
void usb_proc_drain(struct usb_process *up)
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)
void() usb_callback_t(struct usb_xfer *, usb_error_t)
#define STRUCT_USB_HOST_ID
#define USB_GET_STATE(xfer)