summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--sys/dev/pci/if_myx.c1606
-rw-r--r--sys/dev/pci/if_myxreg.h31
2 files changed, 1046 insertions, 591 deletions
diff --git a/sys/dev/pci/if_myx.c b/sys/dev/pci/if_myx.c
index c44a539124d..a831effde8f 100644
--- a/sys/dev/pci/if_myx.c
+++ b/sys/dev/pci/if_myx.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: if_myx.c,v 1.13 2011/05/02 22:13:27 chl Exp $ */
+/* $OpenBSD: if_myx.c,v 1.14 2011/06/20 05:19:20 dlg Exp $ */
/*
* Copyright (c) 2007 Reyk Floeter <reyk@openbsd.org>
@@ -32,7 +32,7 @@
#include <sys/timeout.h>
#include <sys/proc.h>
#include <sys/device.h>
-#include <sys/sensors.h>
+#include <sys/queue.h>
#include <machine/bus.h>
#include <machine/intr.h>
@@ -84,15 +84,19 @@ struct myx_dmamem {
};
struct myx_buf {
- bus_dmamap_t mb_dmamap;
+ SIMPLEQ_ENTRY(myx_buf) mb_entry;
+ bus_dmamap_t mb_map;
struct mbuf *mb_m;
};
+SIMPLEQ_HEAD(myx_buf_list, myx_buf);
+struct pool *myx_buf_pool;
struct myx_softc {
struct device sc_dev;
struct arpcom sc_ac;
pci_chipset_tag_t sc_pc;
+ pci_intr_handle_t sc_ih;
pcitag_t sc_tag;
u_int sc_function;
@@ -101,46 +105,46 @@ struct myx_softc {
bus_space_handle_t sc_memh;
bus_size_t sc_mems;
+ struct myx_dmamem sc_zerodma;
struct myx_dmamem sc_cmddma;
struct myx_dmamem sc_paddma;
- struct myx_dmamem sc_stsdma;
+ struct myx_dmamem sc_sts_dma;
struct myx_status *sc_sts;
- struct myx_dmamem sc_rxdma;
- struct myx_rxdesc *sc_rxdesc;
- struct myx_rxbufdesc *sc_rxbufdesc[2];
- struct myx_buf *sc_rxbuf[2];
-#define MYX_RXSMALL 0
-#define MYX_RXBIG 1
- int sc_rxactive;
- int sc_rxidx;
-
void *sc_irqh;
u_int32_t sc_irqcoaloff;
u_int32_t sc_irqclaimoff;
u_int32_t sc_irqdeassertoff;
+ struct myx_dmamem sc_intrq_dma;
+ struct myx_intrq_desc *sc_intrq;
+ u_int sc_intrq_count;
+ u_int sc_intrq_idx;
+
+ u_int sc_rx_ring_count;
+ u_int32_t sc_rx_ring_offset[2];
+ struct myx_buf_list sc_rx_buf_free[2];
+ struct myx_buf_list sc_rx_buf_list[2];
+ u_int sc_rx_ring_idx[2];
+#define MYX_RXSMALL 0
+#define MYX_RXBIG 1
+
+ u_int sc_tx_ring_count;
+ u_int32_t sc_tx_ring_offset;
+ u_int sc_tx_nsegs;
+ u_int32_t sc_tx_count; /* shadows ms_txdonecnt */
+ u_int sc_tx_free;
+ struct myx_buf_list sc_tx_buf_free;
+ struct myx_buf_list sc_tx_buf_list;
+ u_int sc_tx_ring_idx;
+
u_int8_t sc_lladdr[ETHER_ADDR_LEN];
struct ifmedia sc_media;
- u_int32_t sc_rxringsize;
- u_int32_t sc_rxsmallringoff;
- u_int32_t sc_rxbigringoff;
- int sc_rxndesc;
- size_t sc_rxdescsize;
- size_t sc_rxbufsize;
- size_t sc_rxbufdescsize;
- u_int32_t sc_txringsize;
- u_int32_t sc_txringoff;
- int sc_txndesc;
-
- u_int sc_phy; /* PHY type (CX4/SR/LR) */
u_int sc_hwflags;
#define MYXFLAG_FLOW_CONTROL (1<<0) /* Rx/Tx pause is enabled */
-#define MYXFLAG_PROMISC (1<<1) /* promisc mode is enabled */
-#define MYXFLAG_ALLMULTI (1<<2) /* allmulti is set */
- u_int8_t sc_active;
+ volatile u_int8_t sc_linkdown;
struct timeout sc_tick;
};
@@ -149,17 +153,18 @@ int myx_match(struct device *, void *, void *);
void myx_attach(struct device *, struct device *, void *);
int myx_query(struct myx_softc *sc);
u_int myx_ether_aton(char *, u_int8_t *, u_int);
-int myx_loadfirmware(struct myx_softc *, u_int8_t *, size_t,
- u_int32_t, int);
void myx_attachhook(void *);
-void myx_read(struct myx_softc *, bus_size_t, u_int8_t *, bus_size_t);
-void myx_rawread(struct myx_softc *, bus_size_t, u_int8_t *, bus_size_t);
-void myx_write(struct myx_softc *, bus_size_t, u_int8_t *, bus_size_t);
-void myx_rawwrite(struct myx_softc *, bus_size_t, u_int8_t *, bus_size_t);
+int myx_loadfirmware(struct myx_softc *, const char *);
+
+void myx_read(struct myx_softc *, bus_size_t, void *, bus_size_t);
+void myx_rawread(struct myx_softc *, bus_size_t, void *, bus_size_t);
+void myx_write(struct myx_softc *, bus_size_t, void *, bus_size_t);
+void myx_rawwrite(struct myx_softc *, bus_size_t, void *, bus_size_t);
+
int myx_cmd(struct myx_softc *, u_int32_t, struct myx_cmd *, u_int32_t *);
-int myx_boot(struct myx_softc *, u_int32_t, struct myx_bootcmd *);
+int myx_boot(struct myx_softc *, u_int32_t);
+
int myx_rdma(struct myx_softc *, u_int);
-int myx_reset(struct myx_softc *);
int myx_dmamem_alloc(struct myx_softc *, struct myx_dmamem *,
bus_size_t, u_int align, const char *);
void myx_dmamem_free(struct myx_softc *, struct myx_dmamem *);
@@ -169,15 +174,25 @@ void myx_link_state(struct myx_softc *);
void myx_watchdog(struct ifnet *);
void myx_tick(void *);
int myx_ioctl(struct ifnet *, u_long, caddr_t);
+void myx_up(struct myx_softc *);
void myx_iff(struct myx_softc *);
-void myx_init(struct ifnet *);
+void myx_down(struct myx_softc *);
+
void myx_start(struct ifnet *);
-void myx_stop(struct ifnet *);
-int myx_setlladdr(struct myx_softc *, u_int8_t *);
+int myx_load_buf(struct myx_softc *, struct myx_buf *, struct mbuf *);
+int myx_setlladdr(struct myx_softc *, u_int32_t, u_int8_t *);
int myx_intr(void *);
-int myx_init_rings(struct myx_softc *);
-void myx_free_rings(struct myx_softc *);
-struct mbuf *myx_getbuf(struct myx_softc *, bus_dmamap_t, int);
+int myx_rxeof(struct myx_softc *);
+void myx_txeof(struct myx_softc *, u_int32_t);
+
+struct myx_buf * myx_buf_alloc(struct myx_softc *, bus_size_t, int);
+void myx_buf_free(struct myx_softc *, struct myx_buf *);
+struct myx_buf * myx_buf_get(struct myx_buf_list *);
+void myx_buf_put(struct myx_buf_list *, struct myx_buf *);
+struct myx_buf * myx_buf_fill(struct myx_softc *, int);
+
+void myx_rx_zero(struct myx_softc *, int);
+int myx_rx_fill(struct myx_softc *, int);
struct cfdriver myx_cd = {
NULL, "myx", DV_IFNET
@@ -193,8 +208,7 @@ const struct pci_matchid myx_devices[] = {
int
myx_match(struct device *parent, void *match, void *aux)
{
- return (pci_matchbyid((struct pci_attach_args *)aux,
- myx_devices, sizeof(myx_devices) / sizeof(myx_devices[0])));
+ return (pci_matchbyid(aux, myx_devices, nitems(myx_devices)));
}
void
@@ -202,16 +216,21 @@ myx_attach(struct device *parent, struct device *self, void *aux)
{
struct myx_softc *sc = (struct myx_softc *)self;
struct pci_attach_args *pa = aux;
- pci_intr_handle_t ih;
pcireg_t memtype;
- const char *intrstr;
- struct ifnet *ifp;
sc->sc_pc = pa->pa_pc;
sc->sc_tag = pa->pa_tag;
sc->sc_dmat = pa->pa_dmat;
sc->sc_function = pa->pa_function;
+ SIMPLEQ_INIT(&sc->sc_rx_buf_free[MYX_RXSMALL]);
+ SIMPLEQ_INIT(&sc->sc_rx_buf_list[MYX_RXSMALL]);
+ SIMPLEQ_INIT(&sc->sc_rx_buf_free[MYX_RXBIG]);
+ SIMPLEQ_INIT(&sc->sc_rx_buf_list[MYX_RXBIG]);
+
+ SIMPLEQ_INIT(&sc->sc_tx_buf_free);
+ SIMPLEQ_INIT(&sc->sc_tx_buf_list);
+
/* Map the PCI memory space */
memtype = pci_mapreg_type(sc->sc_pc, sc->sc_tag, MYXBAR0);
if (pci_mapreg_map(pa, MYXBAR0, memtype, 0, &sc->sc_memt,
@@ -220,88 +239,39 @@ myx_attach(struct device *parent, struct device *self, void *aux)
return;
}
- /* Get the board information and initialize the h/w */
+ /* Get the mac address */
if (myx_query(sc) != 0)
goto unmap;
- /*
- * Allocate command DMA memory
- */
- if (myx_dmamem_alloc(sc, &sc->sc_cmddma, MYXALIGN_CMD,
- MYXALIGN_CMD, "cmd") != 0) {
- printf(": failed to allocate command DMA memory\n");
+ /* Map the interrupt */
+ if (pci_intr_map(pa, &sc->sc_ih) != 0) {
+ printf(": unable to map interrupt\n");
goto unmap;
}
- if (myx_dmamem_alloc(sc, &sc->sc_paddma,
- MYXALIGN_CMD, MYXALIGN_CMD, "pad") != 0) {
- printf(": failed to allocate pad DMA memory\n");
- goto err2;
- }
+ printf(": %s, address %s\n", pci_intr_string(pa->pa_pc, sc->sc_ih),
+ ether_sprintf(sc->sc_ac.ac_enaddr));
- if (myx_dmamem_alloc(sc, &sc->sc_stsdma,
- sizeof(struct myx_status), MYXALIGN_DATA /* XXX */, "status") != 0) {
- printf(": failed to allocate status DMA memory\n");
- goto err1;
+ /* this is sort of racy */
+ if (myx_buf_pool == NULL) {
+ myx_buf_pool = malloc(sizeof(*myx_buf_pool), M_DEVBUF,
+ M_WAITOK);
+ if (myx_buf_pool == NULL) {
+ printf("%s: unable to allocate buf pool\n",
+ DEVNAME(sc));
+ goto unmap;
+ }
+ pool_init(myx_buf_pool, sizeof(struct myx_buf),
+ 0, 0, 0, "myxbufs", &pool_allocator_nointr);
}
- sc->sc_sts = (struct myx_status *)sc->sc_stsdma.mxm_kva;
- /*
- * Map and establish the interrupt
- */
- if (pci_intr_map(pa, &ih) != 0) {
- printf(": unable to map interrupt\n");
- goto err;
- }
- intrstr = pci_intr_string(pa->pa_pc, ih);
- sc->sc_irqh = pci_intr_establish(pa->pa_pc, ih, IPL_NET,
- myx_intr, sc, DEVNAME(sc));
- if (sc->sc_irqh == NULL) {
- printf(": unable to establish interrupt %s\n", intrstr);
- goto err;
+ if (mountroothook_establish(myx_attachhook, sc) == NULL) {
+ printf("%s: unable to establish mountroot hook\n", DEVNAME(sc));
+ goto unmap;
}
- printf(": %s, address %s\n", intrstr,
- ether_sprintf(sc->sc_ac.ac_enaddr));
-
- ifp = &sc->sc_ac.ac_if;
- ifp->if_softc = sc;
- ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
- ifp->if_ioctl = myx_ioctl;
- ifp->if_start = myx_start;
- ifp->if_watchdog = myx_watchdog;
- strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
- IFQ_SET_MAXLEN(&ifp->if_snd, MYX_NTXDESC_MIN - 1);
- IFQ_SET_READY(&ifp->if_snd);
-
- ifp->if_capabilities = IFCAP_VLAN_MTU;
-#if 0
- ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING;
- ifp->if_capabilities |= IFCAP_CSUM_IPv4 | IFCAP_CSUM_TCPv4 |
- IFCAP_CSUM_UDPv4;
-#endif
- ifp->if_baudrate = IF_Gbps(10);
-
- ifmedia_init(&sc->sc_media, 0,
- myx_media_change, myx_media_status);
- ifmedia_add(&sc->sc_media, IFM_ETHER|sc->sc_phy, 0, NULL);
- ifmedia_set(&sc->sc_media, IFM_ETHER|sc->sc_phy);
-
- if_attach(ifp);
- ether_ifattach(ifp);
-
- timeout_set(&sc->sc_tick, myx_tick, sc);
- timeout_add_sec(&sc->sc_tick, 1);
-
- mountroothook_establish(myx_attachhook, sc);
return;
- err:
- myx_dmamem_free(sc, &sc->sc_stsdma);
- err1:
- myx_dmamem_free(sc, &sc->sc_paddma);
- err2:
- myx_dmamem_free(sc, &sc->sc_cmddma);
unmap:
bus_space_unmap(sc->sc_memt, sc->sc_memh, sc->sc_mems);
sc->sc_mems = 0;
@@ -334,63 +304,93 @@ myx_ether_aton(char *mac, u_int8_t *lladdr, u_int maxlen)
int
myx_query(struct myx_softc *sc)
{
- u_int8_t eeprom[MYX_EEPROM_SIZE];
- u_int i, maxlen;
+ struct myx_gen_hdr hdr;
+ u_int32_t offset;
+ u_int8_t strings[MYX_STRING_SPECS_SIZE];
+ u_int i, len, maxlen;
+
+ myx_read(sc, MYX_HEADER_POS, &offset, sizeof(offset));
+ offset = betoh32(offset);
+ if (offset + sizeof(hdr) > sc->sc_mems) {
+ printf(": header is outside register window\n");
+ return (1);
+ }
- myx_read(sc, MYX_EEPROM, eeprom, MYX_EEPROM_SIZE);
+ myx_rawread(sc, offset, &hdr, sizeof(hdr));
+ offset = betoh32(hdr.fw_specs);
+ len = min(betoh32(hdr.fw_specs_len), sizeof(strings));
- for (i = 0; i < MYX_EEPROM_SIZE; i++) {
- maxlen = MYX_EEPROM_SIZE - i;
- if (eeprom[i] == '\0')
+ bus_space_read_region_1(sc->sc_memt, sc->sc_memh, offset, strings, len);
+
+ for (i = 0; i < len; i++) {
+ maxlen = len - i;
+ if (strings[i] == '\0')
break;
- if (maxlen > 4 && bcmp("MAC=", &eeprom[i], 4) == 0) {
+ if (maxlen > 4 && bcmp("MAC=", &strings[i], 4) == 0) {
i += 4;
- i += myx_ether_aton(&eeprom[i],
+ i += myx_ether_aton(&strings[i],
sc->sc_ac.ac_enaddr, maxlen);
}
- for (; i < MYX_EEPROM_SIZE; i++)
- if (eeprom[i] == '\0')
+ for (; i < len; i++) {
+ if (strings[i] == '\0')
break;
+ }
}
return (0);
}
int
-myx_loadfirmware(struct myx_softc *sc, u_int8_t *fw, size_t fwlen,
- u_int32_t fwhdroff, int reload)
+myx_loadfirmware(struct myx_softc *sc, const char *filename)
{
- struct myx_firmware_hdr *fwhdr;
- u_int i, len, ret = 0;
+ struct myx_gen_hdr hdr;
+ u_int8_t *fw;
+ size_t fwlen;
+ u_int32_t offset;
+ u_int i, ret = 1;
+
+ if (loadfirmware(filename, &fw, &fwlen) != 0) {
+ printf("%s: could not load firmware %s\n", DEVNAME(sc),
+ filename);
+ return (1);
+ }
+ if (fwlen > MYX_SRAM_SIZE || fwlen < MYXFW_MIN_LEN) {
+ printf("%s: invalid firmware %s size\n", DEVNAME(sc), filename);
+ goto err;
+ }
- fwhdr = (struct myx_firmware_hdr *)(fw + fwhdroff);
- DPRINTF(MYXDBG_INIT, "%s(%s): "
- "fw hdr off %d, length %d, type 0x%x, version %s\n",
- DEVNAME(sc), __func__,
- fwhdroff, betoh32(fwhdr->fw_hdrlength),
- betoh32(fwhdr->fw_type),
- fwhdr->fw_version);
-
- if (betoh32(fwhdr->fw_type) != MYXFW_TYPE_ETH ||
- bcmp(MYXFW_VER, fwhdr->fw_version, strlen(MYXFW_VER)) != 0) {
- if (reload)
- printf("%s: invalid firmware type 0x%x version %s\n",
- DEVNAME(sc), betoh32(fwhdr->fw_type),
- fwhdr->fw_version);
- ret = 1;
- goto done;
+ bcopy(fw + MYX_HEADER_POS, &offset, sizeof(offset));
+ offset = betoh32(offset);
+ if ((offset + sizeof(hdr)) > fwlen) {
+ printf("%s: invalid firmware %s\n", DEVNAME(sc), filename);
+ goto err;
}
- if (!reload)
- goto done;
+ bcopy(fw + offset, &hdr, sizeof(hdr));
+ DPRINTF(MYXDBG_INIT, "%s: "
+ "fw hdr off %u, length %u, type 0x%x, version %s\n",
+ DEVNAME(sc), offset, betoh32(hdr.fw_hdrlength),
+ betoh32(hdr.fw_type), hdr.fw_version);
+
+ if (betoh32(hdr.fw_type) != MYXFW_TYPE_ETH ||
+ bcmp(MYXFW_VER, hdr.fw_version, strlen(MYXFW_VER)) != 0) {
+ printf("%s: invalid firmware type 0x%x version %s\n",
+ DEVNAME(sc), betoh32(hdr.fw_type), hdr.fw_version);
+ goto err;
+ }
/* Write the firmware to the card's SRAM */
- for (i = 0; i < fwlen; i += 256) {
- len = min(256, fwlen - i);
+ for (i = 0; i < fwlen; i += 256)
myx_rawwrite(sc, i + MYX_FW, fw + i, min(256, fwlen - i));
+
+ if (myx_boot(sc, fwlen) != 0) {
+ printf("%s: failed to boot %s\n", DEVNAME(sc), filename);
+ goto err;
}
- done:
+ ret = 0;
+
+err:
free(fw, M_DEVBUF);
return (ret);
}
@@ -399,71 +399,82 @@ void
myx_attachhook(void *arg)
{
struct myx_softc *sc = (struct myx_softc *)arg;
- size_t fwlen;
- u_int8_t *fw = NULL;
- u_int32_t fwhdroff;
- struct myx_bootcmd bc;
-
- /*
- * First try the firmware found in the SRAM
- */
- myx_read(sc, MYX_HEADER_POS, (u_int8_t *)&fwhdroff, sizeof(fwhdroff));
- fwhdroff = betoh32(fwhdroff);
- fwlen = sizeof(struct myx_firmware_hdr);
- if ((fwhdroff + fwlen) > MYX_SRAM_SIZE)
- goto load;
-
- fw = malloc(fwlen, M_DEVBUF, M_WAIT);
- myx_rawread(sc, MYX_HEADER_POS, fw, fwlen);
-
- if (myx_loadfirmware(sc, fw, fwlen, fwhdroff, 0) == 0)
- goto boot;
+ struct ifnet *ifp = &sc->sc_ac.ac_if;
+ struct myx_cmd mc;
+ u_int32_t r;
- load:
- /*
- * Now try the firmware stored on disk
- */
- if (loadfirmware(MYXFW_ALIGNED /* XXX */, &fw, &fwlen) != 0) {
- printf("%s: could not load firmware\n", DEVNAME(sc));
+ /* Allocate command DMA memory */
+ if (myx_dmamem_alloc(sc, &sc->sc_cmddma, MYXALIGN_CMD,
+ MYXALIGN_CMD, "cmd") != 0) {
+ printf("%s: failed to allocate command DMA memory\n",
+ DEVNAME(sc));
return;
}
- if (fwlen > MYX_SRAM_SIZE || fwlen < MYXFW_MIN_LEN) {
- printf("%s: invalid firmware image size\n", DEVNAME(sc));
- goto err;
+
+ /* Try the firmware stored on disk */
+ if (myx_loadfirmware(sc, MYXFW_ALIGNED) != 0) {
+ /* error printed by myx_loadfirmware */
+ goto freecmd;
}
- bcopy(fw + MYX_HEADER_POS, &fwhdroff, sizeof(fwhdroff));
- fwhdroff = betoh32(fwhdroff);
- if ((fwhdroff + sizeof(struct myx_firmware_hdr)) > fwlen) {
- printf("%s: invalid firmware image\n", DEVNAME(sc));
- goto err;
+ bzero(&mc, sizeof(mc));
+
+ if (myx_cmd(sc, MYXCMD_RESET, &mc, NULL) != 0) {
+ printf("%s: failed to reset the device\n", DEVNAME(sc));
+ goto freecmd;
}
- if (myx_loadfirmware(sc, fw, fwlen, fwhdroff, 1) != 0) {
- fw = NULL;
- goto err;
+ if (myx_cmd(sc, MYXCMD_GET_RXRINGSZ, &mc, &r) != 0) {
+ printf("%s: unable to get rx ring size\n", DEVNAME(sc));
+ goto freecmd;
}
- fw = NULL;
+ sc->sc_rx_ring_count = r / sizeof(struct myx_rx_desc);
- boot:
- bzero(&bc, sizeof(bc));
- if (myx_boot(sc, fwlen, &bc) != 0) {
- printf("%s: failed to bootstrap the device\n", DEVNAME(sc));
- goto err;
+ sc->sc_irqh = pci_intr_establish(sc->sc_pc, sc->sc_ih, IPL_NET,
+ myx_intr, sc, DEVNAME(sc));
+ if (sc->sc_irqh == NULL) {
+ printf("%s: unable to establish interrupt\n", DEVNAME(sc));
+ goto freecmd;
}
- if (myx_reset(sc) != 0)
- goto err;
- sc->sc_active = 1;
+ ifp->if_softc = sc;
+ ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
+ ifp->if_ioctl = myx_ioctl;
+ ifp->if_start = myx_start;
+ ifp->if_watchdog = myx_watchdog;
+ ifp->if_hardmtu = 9000;
+ strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
+ IFQ_SET_MAXLEN(&ifp->if_snd, 1);
+ IFQ_SET_READY(&ifp->if_snd);
+
+ m_clsetwms(ifp, MCLBYTES, 2, sc->sc_rx_ring_count - 2);
+ m_clsetwms(ifp, 4096, 2, sc->sc_rx_ring_count - 2);
+
+ ifp->if_capabilities = IFCAP_VLAN_MTU;
+#if 0
+ ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING;
+ ifp->if_capabilities |= IFCAP_CSUM_IPv4 | IFCAP_CSUM_TCPv4 |
+ IFCAP_CSUM_UDPv4;
+#endif
+ ifp->if_baudrate = 0;
+
+ ifmedia_init(&sc->sc_media, 0, myx_media_change, myx_media_status);
+ ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO, 0, NULL);
+ ifmedia_set(&sc->sc_media, IFM_ETHER | IFM_AUTO);
+
+ if_attach(ifp);
+ ether_ifattach(ifp);
+
+ timeout_set(&sc->sc_tick, myx_tick, sc);
+
return;
- err:
- if (fw != NULL)
- free(fw, M_DEVBUF);
+freecmd:
+ myx_dmamem_free(sc, &sc->sc_cmddma);
}
void
-myx_read(struct myx_softc *sc, bus_size_t off, u_int8_t *ptr, bus_size_t len)
+myx_read(struct myx_softc *sc, bus_size_t off, void *ptr, bus_size_t len)
{
bus_space_barrier(sc->sc_memt, sc->sc_memh, off, len,
BUS_SPACE_BARRIER_READ);
@@ -471,7 +482,7 @@ myx_read(struct myx_softc *sc, bus_size_t off, u_int8_t *ptr, bus_size_t len)
}
void
-myx_rawread(struct myx_softc *sc, bus_size_t off, u_int8_t *ptr,
+myx_rawread(struct myx_softc *sc, bus_size_t off, void *ptr,
bus_size_t len)
{
bus_space_barrier(sc->sc_memt, sc->sc_memh, off, len,
@@ -480,7 +491,7 @@ myx_rawread(struct myx_softc *sc, bus_size_t off, u_int8_t *ptr,
}
void
-myx_write(struct myx_softc *sc, bus_size_t off, u_int8_t *ptr, bus_size_t len)
+myx_write(struct myx_softc *sc, bus_size_t off, void *ptr, bus_size_t len)
{
bus_space_write_region_4(sc->sc_memt, sc->sc_memh, off, ptr, len / 4);
bus_space_barrier(sc->sc_memt, sc->sc_memh, off, len,
@@ -488,7 +499,7 @@ myx_write(struct myx_softc *sc, bus_size_t off, u_int8_t *ptr, bus_size_t len)
}
void
-myx_rawwrite(struct myx_softc *sc, bus_size_t off, u_int8_t *ptr,
+myx_rawwrite(struct myx_softc *sc, bus_size_t off, void *ptr,
bus_size_t len)
{
bus_space_write_raw_region_4(sc->sc_memt, sc->sc_memh, off, ptr, len);
@@ -593,6 +604,8 @@ myx_cmd(struct myx_softc *sc, u_int32_t cmd, struct myx_cmd *mc, u_int32_t *r)
/* Send command */
myx_write(sc, MYX_CMD, (u_int8_t *)mc, sizeof(struct myx_cmd));
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
for (i = 0; i < 20; i++) {
bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
@@ -602,6 +615,9 @@ myx_cmd(struct myx_softc *sc, u_int32_t cmd, struct myx_cmd *mc, u_int32_t *r)
if (result != 0xffffffff)
break;
+
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
delay(1000);
}
@@ -618,41 +634,47 @@ myx_cmd(struct myx_softc *sc, u_int32_t cmd, struct myx_cmd *mc, u_int32_t *r)
}
int
-myx_boot(struct myx_softc *sc, u_int32_t length, struct myx_bootcmd *bc)
+myx_boot(struct myx_softc *sc, u_int32_t length)
{
+ struct myx_bootcmd bc;
bus_dmamap_t map = sc->sc_cmddma.mxm_map;
u_int32_t *status;
- u_int i;
+ u_int i, ret = 1;
- bc->bc_addr_high = htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
- bc->bc_addr_low = htobe32(MYX_ADDRLOW(map->dm_segs[0].ds_addr));
- bc->bc_result = 0xffffffff;
- bc->bc_offset = htobe32(MYX_FW_BOOT);
- bc->bc_length = htobe32(length);
- bc->bc_copyto = htobe32(8);
- bc->bc_jumpto = htobe32(0);
+ bzero(&bc, sizeof(bc));
+ bc.bc_addr_high = htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
+ bc.bc_addr_low = htobe32(MYX_ADDRLOW(map->dm_segs[0].ds_addr));
+ bc.bc_result = 0xffffffff;
+ bc.bc_offset = htobe32(MYX_FW_BOOT);
+ bc.bc_length = htobe32(length - 8);
+ bc.bc_copyto = htobe32(8);
+ bc.bc_jumpto = htobe32(0);
status = (u_int32_t *)sc->sc_cmddma.mxm_kva;
*status = 0;
/* Send command */
- myx_write(sc, MYX_BOOT, (u_int8_t *)bc, sizeof(struct myx_bootcmd));
+ myx_write(sc, MYX_BOOT, &bc, sizeof(bc));
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
for (i = 0; i < 200; i++) {
bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
BUS_DMASYNC_POSTREAD);
- if (*status == 0xffffffff)
+ if (*status == 0xffffffff) {
+ ret = 0;
break;
+ }
+
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
delay(1000);
}
- DPRINTF(MYXDBG_CMD, "%s(%s): boot completed, i %d, result 0x%x\n",
- DEVNAME(sc), __func__, i, betoh32(*status));
+ DPRINTF(MYXDBG_CMD, "%s: boot completed, i %d, result %d\n",
+ DEVNAME(sc), i, ret);
- if (*status != 0xffffffff)
- return (-1);
-
- return (0);
+ return (ret);
}
int
@@ -662,6 +684,7 @@ myx_rdma(struct myx_softc *sc, u_int do_enable)
bus_dmamap_t map = sc->sc_cmddma.mxm_map;
bus_dmamap_t pad = sc->sc_paddma.mxm_map;
u_int32_t *status;
+ int ret = 1;
u_int i;
/*
@@ -678,14 +701,23 @@ myx_rdma(struct myx_softc *sc, u_int do_enable)
status = (u_int32_t *)sc->sc_cmddma.mxm_kva;
*status = 0;
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
+
/* Send command */
- myx_write(sc, MYX_RDMA, (u_int8_t *)&rc, sizeof(struct myx_rdmacmd));
+ myx_write(sc, MYX_RDMA, &rc, sizeof(rc));
for (i = 0; i < 20; i++) {
bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
BUS_DMASYNC_POSTREAD);
- if (*status == 0xffffffff)
+
+ if (*status == 0xffffffff) {
+ ret = 0;
break;
+ }
+
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
delay(1000);
}
@@ -693,71 +725,14 @@ myx_rdma(struct myx_softc *sc, u_int do_enable)
DEVNAME(sc), __func__,
do_enable ? "enabled" : "disabled", i, betoh32(*status));
- if (*status != 0xffffffff)
- return (-1);
-
- return (0);
-}
-
-int
-myx_reset(struct myx_softc *sc)
-{
- struct myx_cmd mc;
- u_int32_t data;
- struct ifnet *ifp = &sc->sc_ac.ac_if;
-
- bzero(&mc, sizeof(mc));
- if (myx_cmd(sc, MYXCMD_RESET, &mc, NULL) != 0) {
- printf("%s: failed to reset the device\n", DEVNAME(sc));
- return (-1);
- }
-
- if (myx_rdma(sc, MYXRDMA_ON) != 0) {
- printf("%s: failed to enable dummy RDMA\n", DEVNAME(sc));
- return (-1);
- }
-
- if (myx_cmd(sc, MYXCMD_GET_INTRCOALDELAYOFF, &mc,
- &sc->sc_irqcoaloff) != 0) {
- printf("%s: failed to get IRQ coal offset\n", DEVNAME(sc));
- return (-1);
- }
- data = htobe32(MYX_IRQCOALDELAY);
- myx_write(sc, sc->sc_irqcoaloff, (u_int8_t *)&data, sizeof(data));
-
- if (myx_cmd(sc, MYXCMD_GET_INTRACKOFF, &mc,
- &sc->sc_irqclaimoff) != 0) {
- printf("%s: failed to get IRQ ack offset\n", DEVNAME(sc));
- return (-1);
- }
-
- if (myx_cmd(sc, MYXCMD_GET_INTRDEASSERTOFF, &mc,
- &sc->sc_irqdeassertoff) != 0) {
- printf("%s: failed to get IRQ deassert offset\n", DEVNAME(sc));
- return (-1);
- }
-
- if (myx_cmd(sc, MYXCMD_UNSET_PROMISC, &mc, NULL) != 0) {
- printf("%s: failed to disable promisc mode\n", DEVNAME(sc));
- return (-1);
- }
-
- if (myx_cmd(sc, MYXCMD_FC_DEFAULT, &mc, NULL) != 0) {
- printf("%s: failed to configure flow control\n", DEVNAME(sc));
- return (-1);
- }
-
- if (myx_setlladdr(sc, LLADDR(ifp->if_sadl)) != 0)
- return (-1);
-
- return (0);
+ return (ret);
}
-
int
myx_media_change(struct ifnet *ifp)
{
- return (EINVAL);
+ /* ignore */
+ return (0);
}
void
@@ -765,17 +740,20 @@ myx_media_status(struct ifnet *ifp, struct ifmediareq *imr)
{
struct myx_softc *sc = (struct myx_softc *)ifp->if_softc;
- imr->ifm_active = IFM_ETHER|sc->sc_phy;
+ imr->ifm_active = IFM_ETHER | IFM_AUTO;
imr->ifm_status = IFM_AVALID;
+
myx_link_state(sc);
+
if (!LINK_STATE_IS_UP(ifp->if_link_state))
return;
+
imr->ifm_active |= IFM_FDX;
imr->ifm_status |= IFM_ACTIVE;
/* Flow control */
if (sc->sc_hwflags & MYXFLAG_FLOW_CONTROL)
- imr->ifm_active |= IFM_FLOW|IFM_ETH_RXPAUSE|IFM_ETH_TXPAUSE;
+ imr->ifm_active |= IFM_FLOW | IFM_ETH_RXPAUSE | IFM_ETH_TXPAUSE;
}
void
@@ -784,13 +762,16 @@ myx_link_state(struct myx_softc *sc)
struct ifnet *ifp = &sc->sc_ac.ac_if;
int link_state = LINK_STATE_DOWN;
- if (sc->sc_sts == NULL)
+ if (!ISSET(ifp->if_flags, IFF_RUNNING))
return;
- if (sc->sc_sts->ms_linkstate == MYXSTS_LINKUP)
+
+ if (betoh32(sc->sc_sts->ms_linkstate) == MYXSTS_LINKUP)
link_state = LINK_STATE_FULL_DUPLEX;
if (ifp->if_link_state != link_state) {
ifp->if_link_state = link_state;
if_link_state_change(ifp);
+ ifp->if_baudrate = LINK_STATE_IS_UP(ifp->if_link_state) ?
+ IF_Gbps(10) : 0;
}
}
@@ -804,8 +785,9 @@ void
myx_tick(void *arg)
{
struct myx_softc *sc = (struct myx_softc *)arg;
+ struct ifnet *ifp = &sc->sc_ac.ac_if;
- if (!sc->sc_active)
+ if (!ISSET(ifp->if_flags, IFF_RUNNING))
return;
myx_link_state(sc);
@@ -832,14 +814,14 @@ myx_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
/* FALLTHROUGH */
case SIOCSIFFLAGS:
- if (ifp->if_flags & IFF_UP) {
- if (ifp->if_flags & IFF_RUNNING)
+ if (ISSET(ifp->if_flags, IFF_UP)) {
+ if (ISSET(ifp->if_flags, IFF_RUNNING))
myx_iff(sc);
else
- myx_init(ifp);
+ myx_up(sc);
} else {
- if (ifp->if_flags & IFF_RUNNING)
- myx_stop(ifp);
+ if (ISSET(ifp->if_flags, IFF_RUNNING))
+ myx_down(sc);
}
break;
@@ -864,377 +846,853 @@ myx_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
}
void
-myx_iff(struct myx_softc *sc)
+myx_up(struct myx_softc *sc)
{
- /* XXX set multicast filters etc. */
- return;
-}
+ struct ifnet *ifp = &sc->sc_ac.ac_if;
+ struct myx_buf *mb;
+ struct myx_cmd mc;
+ bus_dmamap_t map;
+ size_t size;
+ u_int32_t r;
+ int i;
-void
-myx_init(struct ifnet *ifp)
-{
- struct myx_softc *sc = (struct myx_softc *)ifp->if_softc;
- struct myx_cmd mc;
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_RESET, &mc, NULL) != 0) {
+ printf("%s: failed to reset the device\n", DEVNAME(sc));
+ return;
+ }
- if (myx_reset(sc) != 0)
+ if (myx_dmamem_alloc(sc, &sc->sc_zerodma,
+ 64, MYXALIGN_CMD, "zero") != 0) {
+ printf("%s: failed to allocate zero pad memory\n",
+ DEVNAME(sc));
return;
+ }
+ bzero(sc->sc_zerodma.mxm_kva, 64);
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_zerodma.mxm_map, 0,
+ sc->sc_zerodma.mxm_map->dm_mapsize, BUS_DMASYNC_PREREAD);
+
+ if (myx_dmamem_alloc(sc, &sc->sc_paddma,
+ MYXALIGN_CMD, MYXALIGN_CMD, "pad") != 0) {
+ printf("%s: failed to allocate pad DMA memory\n",
+ DEVNAME(sc));
+ goto free_zero;
+ }
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_paddma.mxm_map, 0,
+ sc->sc_paddma.mxm_map->dm_mapsize,
+ BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
- if (myx_init_rings(sc) != 0)
+ if (myx_rdma(sc, MYXRDMA_ON) != 0) {
+ printf("%s: failed to enable dummy RDMA\n", DEVNAME(sc));
+ goto free_pad;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_GET_TXRINGSZ, &mc, &r) != 0) {
+ printf("%s: unable to get tx ring size\n", DEVNAME(sc));
return;
+ }
+ sc->sc_tx_ring_idx = 0;
+ sc->sc_tx_ring_count = r / sizeof(struct myx_tx_desc);
+ sc->sc_tx_free = sc->sc_tx_ring_count - 1;
+ sc->sc_tx_nsegs = min(16, sc->sc_tx_ring_count / 4); /* magic */
+ IFQ_SET_MAXLEN(&ifp->if_snd, sc->sc_tx_ring_count - 1);
+ IFQ_SET_READY(&ifp->if_snd);
+
+ /* Allocate Interrupt Queue */
+
+ sc->sc_intrq_count = sc->sc_rx_ring_count * 2;
+ sc->sc_intrq_idx = 0;
+
+ size = sc->sc_intrq_count * sizeof(struct myx_intrq_desc);
+ if (myx_dmamem_alloc(sc, &sc->sc_intrq_dma,
+ size, MYXALIGN_DATA, "intrq") != 0) {
+ goto free_pad;
+ }
+ sc->sc_intrq = (struct myx_intrq_desc *)sc->sc_intrq_dma.mxm_kva;
+ map = sc->sc_intrq_dma.mxm_map;
+ bzero(sc->sc_intrq, size);
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
+
+ bzero(&mc, sizeof(mc));
+ mc.mc_data0 = htobe32(size);
+ if (myx_cmd(sc, MYXCMD_SET_INTRQSZ, &mc, NULL) != 0) {
+ printf("%s: failed to set intrq size\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ mc.mc_data0 = htobe32(MYX_ADDRLOW(map->dm_segs[0].ds_addr));
+ mc.mc_data1 = htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
+ if (myx_cmd(sc, MYXCMD_SET_INTRQDMA, &mc, NULL) != 0) {
+ printf("%s: failed to set intrq address\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ /*
+ * get interrupt offsets
+ */
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_GET_INTRACKOFF, &mc,
+ &sc->sc_irqclaimoff) != 0) {
+ printf("%s: failed to get IRQ ack offset\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_GET_INTRDEASSERTOFF, &mc,
+ &sc->sc_irqdeassertoff) != 0) {
+ printf("%s: failed to get IRQ deassert offset\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_GET_INTRCOALDELAYOFF, &mc,
+ &sc->sc_irqcoaloff) != 0) {
+ printf("%s: failed to get IRQ coal offset\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ /* Set an appropriate interrupt coalescing period */
+ r = htobe32(MYX_IRQCOALDELAY);
+ myx_write(sc, sc->sc_irqcoaloff, &r, sizeof(r));
+
+ if (myx_setlladdr(sc, MYXCMD_SET_LLADDR, LLADDR(ifp->if_sadl)) != 0) {
+ printf("%s: failed to configure lladdr\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_UNSET_PROMISC, &mc, NULL) != 0) {
+ printf("%s: failed to disable promisc mode\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_FC_DEFAULT, &mc, NULL) != 0) {
+ printf("%s: failed to configure flow control\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_GET_TXRINGOFF, &mc,
+ &sc->sc_tx_ring_offset) != 0) {
+ printf("%s: unable to get tx ring offset\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_GET_RXSMALLRINGOFF, &mc,
+ &sc->sc_rx_ring_offset[MYX_RXSMALL]) != 0) {
+ printf("%s: unable to get small rx ring offset\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_GET_RXBIGRINGOFF, &mc,
+ &sc->sc_rx_ring_offset[MYX_RXBIG]) != 0) {
+ printf("%s: unable to get big rx ring offset\n", DEVNAME(sc));
+ goto free_intrq;
+ }
+
+ /* Allocate Interrupt Data */
+ if (myx_dmamem_alloc(sc, &sc->sc_sts_dma,
+ sizeof(struct myx_status), MYXALIGN_DATA, "status") != 0) {
+ printf("%s: failed to allocate status DMA memory\n",
+ DEVNAME(sc));
+ goto free_intrq;
+ }
+ sc->sc_sts = (struct myx_status *)sc->sc_sts_dma.mxm_kva;
+ map = sc->sc_sts_dma.mxm_map;
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
+
+ bzero(&mc, sizeof(mc));
+ mc.mc_data0 = htobe32(MYX_ADDRLOW(map->dm_segs[0].ds_addr));
+ mc.mc_data1 = htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
+ mc.mc_data2 = htobe32(sizeof(struct myx_status));
+ if (myx_cmd(sc, MYXCMD_SET_STATSDMA, &mc, NULL) != 0) {
+ printf("%s: failed to set status DMA offset\n", DEVNAME(sc));
+ goto free_sts;
+ }
+
+ bzero(&mc, sizeof(mc));
+ mc.mc_data0 = htobe32(ifp->if_mtu + ETHER_HDR_LEN + 4 + 4);
+ if (myx_cmd(sc, MYXCMD_SET_MTU, &mc, NULL) != 0) {
+ printf("%s: failed to set MTU size %d\n",
+ DEVNAME(sc), ifp->if_mtu + ETHER_HDR_LEN + 4 + 4);
+ goto free_sts;
+ }
+
+ for (i = 0; i < sc->sc_tx_ring_count; i++) {
+ mb = myx_buf_alloc(sc, 4096, sc->sc_tx_nsegs);
+ if (mb == NULL)
+ goto free_tx_bufs;
+
+ myx_buf_put(&sc->sc_tx_buf_free, mb);
+ }
+
+ for (i = 0; i < sc->sc_rx_ring_count; i++) {
+ mb = myx_buf_alloc(sc, MCLBYTES, 1);
+ if (mb == NULL)
+ goto free_rxsmall_bufs;
+
+ myx_buf_put(&sc->sc_rx_buf_free[MYX_RXSMALL], mb);
+ }
+
+ for (i = 0; i < sc->sc_rx_ring_count; i++) {
+ mb = myx_buf_alloc(sc, 4096, 1);
+ if (mb == NULL)
+ goto free_rxbig_bufs;
+
+ myx_buf_put(&sc->sc_rx_buf_free[MYX_RXBIG], mb);
+ }
+
+ myx_rx_zero(sc, MYX_RXSMALL);
+ if (myx_rx_fill(sc, MYX_RXSMALL) != 0) {
+ printf("%s: failed to fill small rx ring\n", DEVNAME(sc));
+ goto free_rxbig_bufs;
+ }
+
+ myx_rx_zero(sc, MYX_RXBIG);
+ if (myx_rx_fill(sc, MYX_RXBIG) != 0) {
+ printf("%s: failed to fill big rx ring\n", DEVNAME(sc));
+ goto free_rxsmall;
+ }
+
+ bzero(&mc, sizeof(mc));
+ mc.mc_data0 = htobe32(MCLBYTES - 2);
+ if (myx_cmd(sc, MYXCMD_SET_SMALLBUFSZ, &mc, NULL) != 0) {
+ printf("%s: failed to set small buf size\n", DEVNAME(sc));
+ goto free_rxbig;
+ }
+
+ bzero(&mc, sizeof(mc));
+ mc.mc_data0 = htobe32(4096);
+ if (myx_cmd(sc, MYXCMD_SET_BIGBUFSZ, &mc, NULL) != 0) {
+ printf("%s: failed to set big buf size\n", DEVNAME(sc));
+ goto free_rxbig;
+ }
if (myx_cmd(sc, MYXCMD_SET_IFUP, &mc, NULL) != 0) {
printf("%s: failed to start the device\n", DEVNAME(sc));
- myx_free_rings(sc);
- return;
+ goto free_rxbig;
}
- ifp->if_flags |= IFF_RUNNING;
- ifp->if_flags &= ~IFF_OACTIVE;
-}
+ CLR(ifp->if_flags, IFF_OACTIVE);
+ SET(ifp->if_flags, IFF_RUNNING);
-void
-myx_start(struct ifnet *ifp)
-{
-}
+ myx_iff(sc);
-void
-myx_stop(struct ifnet *ifp)
-{
- struct myx_softc *sc = (struct myx_softc *)ifp->if_softc;
- struct myx_cmd mc;
+ return;
- bzero(&mc, sizeof(mc));
- (void)myx_cmd(sc, MYXCMD_SET_IFDOWN, &mc, NULL);
- myx_free_rings(sc);
+free_rxbig:
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_list[MYX_RXBIG])) != NULL) {
+ bus_dmamap_sync(sc->sc_dmat, mb->mb_map, 0,
+ mb->mb_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ bus_dmamap_unload(sc->sc_dmat, mb->mb_map);
+ m_freem(mb->mb_m);
+ myx_buf_free(sc, mb);
+ }
+free_rxsmall:
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_list[MYX_RXSMALL])) != NULL) {
+ bus_dmamap_sync(sc->sc_dmat, mb->mb_map, 0,
+ mb->mb_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ bus_dmamap_unload(sc->sc_dmat, mb->mb_map);
+ m_freem(mb->mb_m);
+ myx_buf_free(sc, mb);
+ }
+free_rxbig_bufs:
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_free[MYX_RXBIG])) != NULL)
+ myx_buf_free(sc, mb);
+free_rxsmall_bufs:
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_free[MYX_RXSMALL])) != NULL)
+ myx_buf_free(sc, mb);
+free_tx_bufs:
+ while ((mb = myx_buf_get(&sc->sc_tx_buf_free)) != NULL)
+ myx_buf_free(sc, mb);
+free_sts:
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_sts_dma.mxm_map, 0,
+ sc->sc_sts_dma.mxm_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ myx_dmamem_free(sc, &sc->sc_sts_dma);
+free_intrq:
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_intrq_dma.mxm_map, 0,
+ sc->sc_intrq_dma.mxm_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ myx_dmamem_free(sc, &sc->sc_intrq_dma);
+free_pad:
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_paddma.mxm_map, 0,
+ sc->sc_paddma.mxm_map->dm_mapsize,
+ BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
+ myx_dmamem_free(sc, &sc->sc_paddma);
- ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_RESET, &mc, NULL) != 0) {
+ printf("%s: failed to reset the device\n", DEVNAME(sc));
+ }
+free_zero:
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_zerodma.mxm_map, 0,
+ sc->sc_zerodma.mxm_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ myx_dmamem_free(sc, &sc->sc_zerodma);
}
int
-myx_setlladdr(struct myx_softc *sc, u_int8_t *addr)
+myx_setlladdr(struct myx_softc *sc, u_int32_t cmd, u_int8_t *addr)
{
struct myx_cmd mc;
bzero(&mc, sizeof(mc));
- mc.mc_data0 = addr[3] | addr[2] << 8 | addr[1] << 16 | addr[0] << 24;
- mc.mc_data1 = addr[5] | addr[4] << 8;
- if (myx_cmd(sc, MYXCMD_SET_LLADDR, &mc, NULL) != 0) {
+ mc.mc_data0 = addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24;
+ mc.mc_data1 = addr[4] << 16 | addr[5] << 24;
+ if (myx_cmd(sc, cmd, &mc, NULL) != 0) {
printf("%s: failed to set the lladdr\n", DEVNAME(sc));
return (-1);
}
return (0);
}
-int
-myx_intr(void *arg)
+void
+myx_iff(struct myx_softc *sc)
{
- struct myx_softc *sc = (struct myx_softc *)arg;
- u_int32_t data, valid;
- struct myx_status *sts = sc->sc_sts;
- bus_dmamap_t map = sc->sc_stsdma.mxm_map;
+ struct myx_cmd mc;
+ struct ifnet *ifp = &sc->sc_ac.ac_if;
+ struct ether_multi *enm;
+ struct ether_multistep step;
- if (!sc->sc_active)
- return (0);
+ if (myx_cmd(sc, ISSET(ifp->if_flags, IFF_PROMISC) ?
+ MYXCMD_SET_PROMISC : MYXCMD_UNSET_PROMISC, &mc, NULL) != 0) {
+ printf("%s: failed to configure promisc mode\n", DEVNAME(sc));
+ return;
+ }
- bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
- BUS_DMASYNC_POSTWRITE);
+ CLR(ifp->if_flags, IFF_ALLMULTI);
- /*
- * XXX The 'valid' flags should be set by the NIC, but it doesn't
- * XXX work yet.
- */
- valid = sts->ms_isvalid;
- if (!valid)
- return (0);
+ if (myx_cmd(sc, MYXCMD_SET_ALLMULTI, &mc, NULL) != 0) {
+ printf("%s: failed to enable ALLMULTI\n", DEVNAME(sc));
+ return;
+ }
- data = 0;
- myx_write(sc, sc->sc_irqdeassertoff, (u_int8_t *)&data, sizeof(data));
+ if (myx_cmd(sc, MYXCMD_UNSET_MCAST, &mc, NULL) != 0) {
+ printf("%s: failed to leave all mcast groups \n", DEVNAME(sc));
+ return;
+ }
- DPRINTF(MYXDBG_INTR, "%s(%s): interrupt, valid 0x%x\n",
- DEVNAME(sc), __func__, valid);
+ if (sc->sc_ac.ac_multirangecnt > 0) {
+ SET(ifp->if_flags, IFF_ALLMULTI);
+ return;
+ }
-#ifdef MYX_DEBUG
-#define DPRINT_STATUS(_n) \
- DPRINTF(MYXDBG_INTR, "%s(%s): %s: %u, 0x%x\n", DEVNAME(sc), __func__,\
- #_n, sts->_n, sts->_n)
-
- DPRINT_STATUS(ms_reserved);
- DPRINT_STATUS(ms_dropped_pause);
- DPRINT_STATUS(ms_dropped_unicast);
- DPRINT_STATUS(ms_dropped_crc32err);
- DPRINT_STATUS(ms_dropped_phyerr);
- DPRINT_STATUS(ms_dropped_mcast);
- DPRINT_STATUS(ms_txdonecnt);
- DPRINT_STATUS(ms_linkstate);
- DPRINT_STATUS(ms_dropped_linkoverflow);
- DPRINT_STATUS(ms_dropped_linkerror);
- DPRINT_STATUS(ms_dropped_runt);
- DPRINT_STATUS(ms_dropped_overrun);
- DPRINT_STATUS(ms_dropped_smallbufunderrun);
- DPRINT_STATUS(ms_dropped_bigbufunderrun);
- DPRINT_STATUS(ms_rdmatags_available);
- DPRINT_STATUS(ms_txstopped);
- DPRINT_STATUS(ms_linkdowncnt);
- DPRINT_STATUS(ms_statusupdated);
- DPRINT_STATUS(ms_isvalid);
-#endif
+ ETHER_FIRST_MULTI(step, &sc->sc_ac, enm);
+ while (enm != NULL) {
+ if (myx_setlladdr(sc, MYXCMD_SET_MCASTGROUP,
+ enm->enm_addrlo) != 0) {
+ printf("%s: failed to join mcast group\n", DEVNAME(sc));
+ return;
+ }
- data = htobe32(3);
- if (sts->ms_isvalid)
- myx_write(sc, sc->sc_irqclaimoff, (u_int8_t *)&data,
- sizeof(data));
- myx_write(sc, sc->sc_irqclaimoff + sizeof(u_int32_t),
- (u_int8_t *)&data, sizeof(data));
+ ETHER_NEXT_MULTI(step, enm);
+ }
- return (1);
+ bzero(&mc, sizeof(mc));
+ if (myx_cmd(sc, MYXCMD_UNSET_ALLMULTI, &mc, NULL) != 0) {
+ printf("%s: failed to disable ALLMULTI\n", DEVNAME(sc));
+ return;
+ }
}
-int
-myx_init_rings(struct myx_softc *sc)
+void
+myx_down(struct myx_softc *sc)
{
- struct myx_cmd mc;
struct ifnet *ifp = &sc->sc_ac.ac_if;
- bus_dmamap_t map;
- int i;
+ bus_dmamap_t map = sc->sc_sts_dma.mxm_map;
struct myx_buf *mb;
- struct myx_rxbufdesc *rxb;
- u_int32_t data;
+ struct myx_cmd mc;
+ int s;
+
+ s = splnet();
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_POSTREAD);
+ sc->sc_linkdown = sc->sc_sts->ms_linkdown;
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
bzero(&mc, sizeof(mc));
- if (!(myx_cmd(sc, MYXCMD_GET_RXRINGSZ, &mc,
- &sc->sc_rxringsize) == 0 && sc->sc_rxringsize &&
- myx_cmd(sc, MYXCMD_GET_RXSMALLRINGOFF, &mc,
- &sc->sc_rxsmallringoff) == 0 && sc->sc_rxsmallringoff &&
- myx_cmd(sc, MYXCMD_GET_RXBIGRINGOFF, &mc,
- &sc->sc_rxbigringoff) == 0 && sc->sc_rxbigringoff &&
- myx_cmd(sc, MYXCMD_GET_TXRINGSZ, &mc,
- &sc->sc_txringsize) == 0 && sc->sc_txringsize &&
- myx_cmd(sc, MYXCMD_GET_TXRINGOFF, &mc,
- &sc->sc_txringoff) == 0 && sc->sc_txringoff)) {
- printf("%s: failed to get ring sizes and offsets\n",
- DEVNAME(sc));
- return (-1);
- }
- sc->sc_rxndesc = sc->sc_rxringsize / sizeof(struct myx_rxbufdesc);
- sc->sc_txndesc = sc->sc_txringsize / sizeof(struct myx_txdesc);
- sc->sc_rxdescsize = sc->sc_rxndesc * 2 * sizeof(struct myx_rxdesc);
- sc->sc_rxbufsize = sc->sc_rxndesc * sizeof(struct myx_buf);
- sc->sc_rxbufdescsize = sc->sc_rxndesc * sizeof(struct myx_rxbufdesc);
- IFQ_SET_MAXLEN(&ifp->if_snd, sc->sc_txndesc - 1);
- IFQ_SET_READY(&ifp->if_snd);
+ (void)myx_cmd(sc, MYXCMD_SET_IFDOWN, &mc, NULL);
+
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_POSTREAD);
+ while (sc->sc_linkdown == sc->sc_sts->ms_linkdown) {
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
- DPRINTF(MYXDBG_INIT, "%s(%s): Rx ring ndesc %u size %u bufsize %u, "
- "Tx ring ndesc %u size %u offset 0x%x\n", DEVNAME(sc), __func__,
- sc->sc_rxndesc, sc->sc_rxdescsize, sc->sc_rxringsize,
- sc->sc_txndesc, sc->sc_txringsize, sc->sc_txringoff);
+ tsleep(sc->sc_sts, 0, "myxdown", 0);
- /*
- * Setup Rx DMA descriptors
- */
- if (myx_dmamem_alloc(sc, &sc->sc_rxdma,
- sc->sc_rxdescsize, MYXALIGN_DATA, "rxring") != 0) {
- printf(": failed to allocate Rx DMA memory\n");
- return (-1);
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_POSTREAD);
}
- sc->sc_rxdesc = (struct myx_rxdesc *)sc->sc_rxdma.mxm_kva;
+
+ CLR(ifp->if_flags, IFF_RUNNING);
+ splx(s);
bzero(&mc, sizeof(mc));
- mc.mc_data0 = htobe32(sc->sc_rxdescsize);
- if (myx_cmd(sc, MYXCMD_SET_INTRQSZ, &mc, NULL) != 0) {
- printf("%s: failed to set Rx DMA size\n", DEVNAME(sc));
- goto err;
+ if (myx_cmd(sc, MYXCMD_RESET, &mc, NULL) != 0) {
+ printf("%s: failed to reset the device\n", DEVNAME(sc));
}
- map = sc->sc_rxdma.mxm_map;
- mc.mc_data0 = MYX_ADDRLOW(map->dm_segs[0].ds_addr);
- mc.mc_data1 = MYX_ADDRHIGH(map->dm_segs[0].ds_addr);
- if (myx_cmd(sc, MYXCMD_SET_INTRQDMA, &mc, NULL) != 0) {
- printf("%s: failed to set Rx DMA address\n", DEVNAME(sc));
- goto err;
+ CLR(ifp->if_flags, IFF_RUNNING | IFF_OACTIVE);
+
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_list[MYX_RXBIG])) != NULL) {
+ bus_dmamap_sync(sc->sc_dmat, mb->mb_map, 0,
+ mb->mb_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ bus_dmamap_unload(sc->sc_dmat, mb->mb_map);
+ m_freem(mb->mb_m);
+ myx_buf_free(sc, mb);
}
-#ifdef notyet
- /*
- * XXX It fails to set the MTU and it always returns
- * XXX MYXCMD_ERR_RANGE.
- */
- bzero(&mc, sizeof(mc));
- mc.mc_data0 = ifp->if_mtu + ETHER_HDR_LEN + 4;
- if (myx_cmd(sc, MYXCMD_SET_MTU, &mc, NULL) != 0) {
- printf("%s: failed to set MTU size %d\n",
- DEVNAME(sc), ifp->if_mtu + ETHER_HDR_LEN + 4);
- goto err;
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_list[MYX_RXSMALL])) != NULL) {
+ bus_dmamap_sync(sc->sc_dmat, mb->mb_map, 0,
+ mb->mb_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ bus_dmamap_unload(sc->sc_dmat, mb->mb_map);
+ m_freem(mb->mb_m);
+ myx_buf_free(sc, mb);
}
-#endif
- /*
- * Setup Rx buffer descriptors
- */
- sc->sc_rxbuf[MYX_RXSMALL] = (struct myx_buf *)
- malloc(sc->sc_rxbufsize, M_DEVBUF, M_WAITOK);
- sc->sc_rxbufdesc[MYX_RXSMALL] = (struct myx_rxbufdesc *)
- malloc(sc->sc_rxbufdescsize, M_DEVBUF, M_WAITOK);
- sc->sc_rxbuf[MYX_RXBIG] = (struct myx_buf *)
- malloc(sc->sc_rxbufsize, M_DEVBUF, M_WAITOK);
- sc->sc_rxbufdesc[MYX_RXBIG] = (struct myx_rxbufdesc *)
- malloc(sc->sc_rxbufdescsize, M_DEVBUF, M_WAITOK);
-
- for (i = 0; i < sc->sc_rxndesc; i++) {
- /*
- * Small Rx buffers and descriptors
- */
- mb = sc->sc_rxbuf[MYX_RXSMALL] + i;
- rxb = sc->sc_rxbufdesc[MYX_RXSMALL] + i;
-
- if (bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
- MCLBYTES, 0, BUS_DMA_WAITOK, &mb->mb_dmamap) != 0) {
- printf("%s: unable to create dmamap for small rx %d\n",
- DEVNAME(sc), i);
- goto err;
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_free[MYX_RXBIG])) != NULL)
+ myx_buf_free(sc, mb);
+
+ while ((mb = myx_buf_get(&sc->sc_rx_buf_free[MYX_RXSMALL])) != NULL)
+ myx_buf_free(sc, mb);
+
+ while ((mb = myx_buf_get(&sc->sc_tx_buf_list)) != NULL) {
+ bus_dmamap_sync(sc->sc_dmat, mb->mb_map, 0,
+ mb->mb_map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
+ bus_dmamap_unload(sc->sc_dmat, mb->mb_map);
+ m_freem(mb->mb_m);
+ myx_buf_free(sc, mb);
+ }
+
+ while ((mb = myx_buf_get(&sc->sc_tx_buf_free)) != NULL)
+ myx_buf_free(sc, mb);
+
+ /* the sleep shizz above already synced this dmamem */
+ myx_dmamem_free(sc, &sc->sc_sts_dma);
+
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_intrq_dma.mxm_map, 0,
+ sc->sc_intrq_dma.mxm_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ myx_dmamem_free(sc, &sc->sc_intrq_dma);
+
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_paddma.mxm_map, 0,
+ sc->sc_paddma.mxm_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ myx_dmamem_free(sc, &sc->sc_paddma);
+
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_zerodma.mxm_map, 0,
+ sc->sc_zerodma.mxm_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ myx_dmamem_free(sc, &sc->sc_zerodma);
+
+}
+
+void
+myx_start(struct ifnet *ifp)
+{
+ struct myx_tx_desc txd;
+ struct myx_softc *sc = ifp->if_softc;
+ bus_dmamap_t map;
+ bus_dmamap_t zmap = sc->sc_zerodma.mxm_map;;
+ struct myx_buf *mb;
+ struct mbuf *m;
+ u_int32_t offset = sc->sc_tx_ring_offset;
+ u_int idx;
+ u_int i;
+ u_int8_t flags;
+
+ if (!ISSET(ifp->if_flags, IFF_RUNNING) ||
+ ISSET(ifp->if_flags, IFF_OACTIVE) ||
+ IFQ_IS_EMPTY(&ifp->if_snd))
+ return;
+
+ idx = sc->sc_tx_ring_idx;
+
+ for (;;) {
+ if (sc->sc_tx_free <= sc->sc_tx_nsegs) {
+ SET(ifp->if_flags, IFF_OACTIVE);
+ break;
+ }
+
+ IFQ_POLL(&ifp->if_snd, m);
+ if (m == NULL)
+ break;
+
+ mb = myx_buf_get(&sc->sc_tx_buf_free);
+ if (mb == NULL) {
+ SET(ifp->if_flags, IFF_OACTIVE);
+ break;
}
- map = mb->mb_dmamap;
- mb->mb_m = myx_getbuf(sc, map, 1);
- if (mb->mb_m == NULL) {
- bus_dmamap_destroy(sc->sc_dmat, map);
- goto err;
+ IFQ_DEQUEUE(&ifp->if_snd, m);
+ if (myx_load_buf(sc, mb, m) != 0) {
+ m_freem(m);
+ myx_buf_put(&sc->sc_tx_buf_free, mb);
+ ifp->if_oerrors++;
+ break;
}
+#if NBPFILTER > 0
+ if (ifp->if_bpf)
+ bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
+#endif
+
+ mb->mb_m = m;
+ map = mb->mb_map;
+
bus_dmamap_sync(sc->sc_dmat, map, 0,
- mb->mb_m->m_pkthdr.len, BUS_DMASYNC_PREREAD);
-
- rxb->rb_addr_high =
- htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
- rxb->rb_addr_low =
- htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
-
- data = sc->sc_rxsmallringoff + i * sizeof(*rxb);
- myx_write(sc, data, (u_int8_t *)rxb, sizeof(*rxb));
-
- /*
- * Big Rx buffers and descriptors
- */
- mb = sc->sc_rxbuf[MYX_RXBIG] + i;
- rxb = sc->sc_rxbufdesc[MYX_RXBIG] + i;
-
- if (bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
- MCLBYTES, 0, BUS_DMA_WAITOK, &mb->mb_dmamap) != 0) {
- printf("%s: unable to create dmamap for big rx %d\n",
- DEVNAME(sc), i);
- goto err;
+ map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
+
+ sc->sc_tx_free -= map->dm_nsegs;
+
+ myx_buf_put(&sc->sc_tx_buf_list, mb);
+
+ flags = MYXTXD_FLAGS_NO_TSO;
+ if (m->m_pkthdr.len < 1520)
+ flags |= MYXTXD_FLAGS_SMALL;
+
+ for (i = 1; i < map->dm_nsegs; i++) {
+ bzero(&txd, sizeof(txd));
+ txd.tx_addr = htobe64(map->dm_segs[i].ds_addr);
+ txd.tx_length = htobe16(map->dm_segs[i].ds_len);
+ txd.tx_flags = flags;
+
+ /* complicated maths is cool */
+ myx_write(sc, offset + sizeof(txd) *
+ ((idx + i) % sc->sc_tx_ring_count),
+ &txd, sizeof(txd));
}
- map = mb->mb_dmamap;
- mb->mb_m = myx_getbuf(sc, map, 1);
- if (mb->mb_m == NULL) {
- bus_dmamap_destroy(sc->sc_dmat, map);
- goto err;
+ /* pad runt frames */
+ if (map->dm_mapsize < 60) {
+ bzero(&txd, sizeof(txd));
+ txd.tx_addr = htobe64(zmap->dm_segs[0].ds_addr);
+ txd.tx_length = htobe16(60 - map->dm_mapsize);
+ txd.tx_flags = flags;
+
+ myx_write(sc, offset + sizeof(txd) *
+ ((idx + i) % sc->sc_tx_ring_count),
+ &txd, sizeof(txd));
+
+ i++;
}
- bus_dmamap_sync(sc->sc_dmat, map, 0,
- mb->mb_m->m_pkthdr.len, BUS_DMASYNC_PREREAD);
+ /* commit by posting the first descriptor */
+ bzero(&txd, sizeof(txd));
+ txd.tx_addr = htobe64(map->dm_segs[0].ds_addr);
+ txd.tx_length = htobe16(map->dm_segs[0].ds_len);
+ txd.tx_nsegs = i;
+ txd.tx_flags = flags | MYXTXD_FLAGS_FIRST;
- rxb->rb_addr_high =
- htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
- rxb->rb_addr_low =
- htobe32(MYX_ADDRHIGH(map->dm_segs[0].ds_addr));
+ myx_write(sc, offset + idx * sizeof(txd),
+ &txd, sizeof(txd));
- data = sc->sc_rxbigringoff + i * sizeof(*rxb);
- myx_write(sc, data, (u_int8_t *)rxb, sizeof(*rxb));
+ idx += i;
+ idx %= sc->sc_tx_ring_count;
}
- bzero(&mc, sizeof(mc));
- mc.mc_data0 = MYX_MAX_MTU_SMALL;
- if (myx_cmd(sc, MYXCMD_SET_SMALLBUFSZ, &mc, NULL) != 0) {
- printf("%s: failed to set small buf size\n", DEVNAME(sc));
- goto err;
- }
+ sc->sc_tx_ring_idx = idx;
+}
- bzero(&mc, sizeof(mc));
- mc.mc_data0 = MCLBYTES;
- if (myx_cmd(sc, MYXCMD_SET_BIGBUFSZ, &mc, NULL) != 0) {
- printf("%s: failed to set big buf size\n", DEVNAME(sc));
- goto err;
- }
+int
+myx_load_buf(struct myx_softc *sc, struct myx_buf *mb, struct mbuf *m)
+{
+ bus_dma_tag_t dmat = sc->sc_dmat;
+ bus_dmamap_t dmap = mb->mb_map;
- /*
- * Setup status DMA
- */
- map = sc->sc_stsdma.mxm_map;
+ switch (bus_dmamap_load_mbuf(dmat, dmap, m, BUS_DMA_NOWAIT)) {
+ case 0:
+ break;
- bzero(&mc, sizeof(mc));
- mc.mc_data0 = MYX_ADDRLOW(map->dm_segs[0].ds_addr);
- mc.mc_data1 = MYX_ADDRHIGH(map->dm_segs[0].ds_addr);
- mc.mc_data2 = sizeof(struct myx_status);
- if (myx_cmd(sc, MYXCMD_SET_STATSDMA, &mc, NULL) != 0) {
- printf("%s: failed to set status DMA offset\n", DEVNAME(sc));
- goto err;
+ case EFBIG: /* mbuf chain is too fragmented */
+ if (m_defrag(m, M_DONTWAIT) == 0 &&
+ bus_dmamap_load_mbuf(dmat, dmap, m, BUS_DMA_NOWAIT) == 0)
+ break;
+ default:
+ return (1);
}
- bus_dmamap_sync(sc->sc_dmat, map, 0,
- map->dm_mapsize, BUS_DMASYNC_PREWRITE);
-
+ mb->mb_m = m;
return (0);
- err:
- myx_free_rings(sc);
- return (-1);
}
-void
-myx_free_rings(struct myx_softc *sc)
+int
+myx_intr(void *arg)
{
- if (sc->sc_rxbuf[MYX_RXSMALL] != NULL) {
- free(sc->sc_rxbuf[MYX_RXSMALL], M_DEVBUF);
- sc->sc_rxbuf[MYX_RXSMALL] = NULL;
- }
- if (sc->sc_rxbufdesc[MYX_RXSMALL] != NULL) {
- free(sc->sc_rxbufdesc[MYX_RXSMALL], M_DEVBUF);
- sc->sc_rxbufdesc[MYX_RXSMALL] = NULL;
+ struct myx_softc *sc = (struct myx_softc *)arg;
+ struct ifnet *ifp = &sc->sc_ac.ac_if;
+ struct myx_status *sts = sc->sc_sts;
+ bus_dmamap_t map = sc->sc_sts_dma.mxm_map;
+ u_int32_t data;
+ int refill = 0;
+ u_int8_t valid = 0;
+ int ret = 0;
+ int i;
+
+ if (!ISSET(ifp->if_flags, IFF_RUNNING))
+ return (0);
+
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_POSTREAD);
+
+ valid = sts->ms_isvalid;
+ if (valid) {
+ data = htobe32(0);
+ myx_write(sc, sc->sc_irqdeassertoff, &data, sizeof(data));
+
+ data = betoh32(sts->ms_txdonecnt);
+ if (data != sc->sc_tx_count) {
+ myx_txeof(sc, data);
+ if (ISSET(ifp->if_flags, IFF_OACTIVE)) {
+ CLR(ifp->if_flags, IFF_OACTIVE);
+ myx_start(ifp);
+ }
+ }
+
+ refill = myx_rxeof(sc);
+ for (i = 0; i < 2; i++) {
+ if (ISSET(refill, 1 << i))
+ myx_rx_fill(sc, i);
+ }
+
+ if (sts->ms_statusupdated)
+ myx_link_state(sc);
+
+ data = htobe32(3);
+ if (valid & 0x1)
+ myx_write(sc, sc->sc_irqclaimoff, &data, sizeof(data));
+ myx_write(sc, sc->sc_irqclaimoff + sizeof(u_int32_t),
+ &data, sizeof(data));
+
+ ret = 1;
}
- if (sc->sc_rxbuf[MYX_RXBIG] != NULL) {
- free(sc->sc_rxbuf[MYX_RXBIG], M_DEVBUF);
- sc->sc_rxbuf[MYX_RXBIG] = NULL;
+
+ if (!ISSET(ifp->if_flags, IFF_UP) &&
+ sc->sc_linkdown != sts->ms_linkdown) {
+ /* myx_down is waiting for us */
+ wakeup_one(sc->sc_sts);
+ ret = 1;
}
- if (sc->sc_rxbufdesc[MYX_RXBIG] != NULL) {
- free(sc->sc_rxbufdesc[MYX_RXBIG], M_DEVBUF);
- sc->sc_rxbufdesc[MYX_RXBIG] = NULL;
+
+ bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
+
+ return (ret);
+}
+
+void
+myx_txeof(struct myx_softc *sc, u_int32_t done_count)
+{
+ struct ifnet *ifp = &sc->sc_ac.ac_if;
+ struct myx_buf *mb;
+ struct mbuf *m;
+ bus_dmamap_t map;
+
+ do {
+ mb = myx_buf_get(&sc->sc_tx_buf_list);
+ if (mb == NULL) {
+ printf("oh noes, no mb!\n");
+ break;
+ }
+
+ m = mb->mb_m;
+ map = mb->mb_map;
+
+ sc->sc_tx_free += map->dm_nsegs;
+ if (map->dm_mapsize < 60)
+ sc->sc_tx_free += 1;
+
+ bus_dmamap_sync(sc->sc_dmat, map, 0,
+ map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
+ bus_dmamap_unload(sc->sc_dmat, map);
+ m_freem(m);
+
+ myx_buf_put(&sc->sc_tx_buf_free, mb);
+
+ ifp->if_opackets++;
+ } while (++sc->sc_tx_count != done_count);
+}
+
+int
+myx_rxeof(struct myx_softc *sc)
+{
+ static const struct myx_intrq_desc zerodesc = { 0, 0 };
+ struct ifnet *ifp = &sc->sc_ac.ac_if;
+ struct myx_buf *mb;
+ struct mbuf *m;
+ int ring;
+ int rings = 0;
+ u_int len;
+
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_intrq_dma.mxm_map, 0,
+ sc->sc_intrq_dma.mxm_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+
+ while ((len = betoh16(sc->sc_intrq[sc->sc_intrq_idx].iq_length)) != 0) {
+ sc->sc_intrq[sc->sc_intrq_idx] = zerodesc;
+
+ if (++sc->sc_intrq_idx >= sc->sc_intrq_count)
+ sc->sc_intrq_idx = 0;
+
+ ring = (len <= (MCLBYTES - 2)) ? MYX_RXSMALL : MYX_RXBIG;
+
+ mb = myx_buf_get(&sc->sc_rx_buf_list[ring]);
+ if (mb == NULL) {
+ printf("oh noes, no mb!\n");
+ break;
+ }
+
+ bus_dmamap_sync(sc->sc_dmat, mb->mb_map, 0,
+ mb->mb_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
+ bus_dmamap_unload(sc->sc_dmat, mb->mb_map);
+
+ m = mb->mb_m;
+ m->m_data += ETHER_ALIGN;
+ m->m_pkthdr.rcvif = ifp;
+ m->m_pkthdr.len = m->m_len = len;
+
+#if NBPFILTER > 0
+ if (ifp->if_bpf)
+ bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
+#endif
+
+ ether_input_mbuf(ifp, m);
+
+ myx_buf_put(&sc->sc_rx_buf_free[ring], mb);
+
+ SET(rings, 1 << ring);
+ ifp->if_ipackets++;
}
- if (sc->sc_rxdesc != NULL) {
- myx_dmamem_free(sc, &sc->sc_rxdma);
- sc->sc_rxdesc = NULL;
+
+ bus_dmamap_sync(sc->sc_dmat, sc->sc_intrq_dma.mxm_map, 0,
+ sc->sc_intrq_dma.mxm_map->dm_mapsize, BUS_DMASYNC_PREREAD);
+
+ return (rings);
+}
+
+void
+myx_rx_zero(struct myx_softc *sc, int ring)
+{
+ struct myx_rx_desc rxd;
+ u_int32_t offset = sc->sc_rx_ring_offset[ring];
+ int idx;
+
+ sc->sc_rx_ring_idx[ring] = 0;
+
+ memset(&rxd, 0xff, sizeof(rxd));
+ for (idx = 0; idx < sc->sc_rx_ring_count; idx++) {
+ myx_write(sc, offset + idx * sizeof(rxd),
+ &rxd, sizeof(rxd));
}
- if (sc->sc_sts != NULL) {
- myx_dmamem_free(sc, &sc->sc_stsdma);
- sc->sc_sts = NULL;
+}
+
+int
+myx_rx_fill(struct myx_softc *sc, int ring)
+{
+ struct myx_rx_desc rxd;
+ struct myx_buf *mb;
+ u_int32_t offset = sc->sc_rx_ring_offset[ring];
+ u_int idx;
+ int ret = 1;
+
+ idx = sc->sc_rx_ring_idx[ring];
+ while ((mb = myx_buf_fill(sc, ring)) != NULL) {
+ rxd.rx_addr = htobe64(mb->mb_map->dm_segs[0].ds_addr);
+
+ myx_buf_put(&sc->sc_rx_buf_list[ring], mb);
+ myx_write(sc, offset + idx * sizeof(rxd),
+ &rxd, sizeof(rxd));
+
+ if (++idx >= sc->sc_rx_ring_count)
+ idx = 0;
+
+ ret = 0;
}
- return;
+ sc->sc_rx_ring_idx[ring] = idx;
+
+ return (ret);
}
-struct mbuf *
-myx_getbuf(struct myx_softc *sc, bus_dmamap_t map, int wait)
+struct myx_buf *
+myx_buf_fill(struct myx_softc *sc, int ring)
{
- struct mbuf *m = NULL;
+ static size_t sizes[2] = { MCLBYTES, 4096 };
+ struct myx_buf *mb;
+ struct mbuf *m;
- MGETHDR(m, wait ? M_WAIT : M_DONTWAIT, MT_DATA);
+ m = MCLGETI(NULL, M_DONTWAIT, &sc->sc_ac.ac_if, sizes[ring]);
if (m == NULL)
- goto merr;
+ return (NULL);
+ m->m_len = m->m_pkthdr.len = sizes[ring];
- MCLGET(m, wait ? M_WAIT : M_DONTWAIT);
- if ((m->m_flags & M_EXT) == 0)
- goto merr;
- m->m_len = m->m_pkthdr.len = MCLBYTES;
+ mb = myx_buf_get(&sc->sc_rx_buf_free[ring]);
+ if (mb == NULL)
+ goto mfree;
- if (bus_dmamap_load_mbuf(sc->sc_dmat, map, m,
- wait ? BUS_DMA_WAITOK : BUS_DMA_NOWAIT) != 0) {
- printf("%s: could not load mbuf dma map\n", DEVNAME(sc));
- goto err;
- }
+ if (bus_dmamap_load_mbuf(sc->sc_dmat, mb->mb_map, m,
+ BUS_DMA_NOWAIT) != 0)
+ goto put;
+
+ mb->mb_m = m;
+ bus_dmamap_sync(sc->sc_dmat, mb->mb_map, 0, mb->mb_map->dm_mapsize,
+ BUS_DMASYNC_PREREAD);
+
+ return (mb);
+
+mfree:
+ m_freem(m);
+put:
+ myx_buf_put(&sc->sc_rx_buf_free[ring], mb);
- return (m);
- merr:
- printf("%s: unable to allocate mbuf\n", DEVNAME(sc));
- err:
- if (m != NULL)
- m_freem(m);
return (NULL);
}
+
+struct myx_buf *
+myx_buf_alloc(struct myx_softc *sc, bus_size_t size, int nsegs)
+{
+ struct myx_buf *mb;
+
+ mb = pool_get(myx_buf_pool, PR_WAITOK);
+ if (mb == NULL)
+ return (NULL);
+
+ if (bus_dmamap_create(sc->sc_dmat, size, nsegs, 4096, 4096,
+ BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW, &mb->mb_map) != 0) {
+ pool_put(myx_buf_pool, mb);
+ return (NULL);
+ }
+
+ return (mb);
+}
+
+void
+myx_buf_free(struct myx_softc *sc, struct myx_buf *mb)
+{
+ bus_dmamap_destroy(sc->sc_dmat, mb->mb_map);
+ pool_put(myx_buf_pool, mb);
+}
+
+struct myx_buf *
+myx_buf_get(struct myx_buf_list *mbl)
+{
+ struct myx_buf *mb;
+
+ mb = SIMPLEQ_FIRST(mbl);
+ if (mb == NULL)
+ return (NULL);
+
+ SIMPLEQ_REMOVE_HEAD(mbl, mb_entry);
+
+ return (mb);
+}
+
+void
+myx_buf_put(struct myx_buf_list *mbl, struct myx_buf *mb)
+{
+ SIMPLEQ_INSERT_TAIL(mbl, mb, mb_entry);
+}
+
diff --git a/sys/dev/pci/if_myxreg.h b/sys/dev/pci/if_myxreg.h
index c145b8df7a4..d5df2f710bb 100644
--- a/sys/dev/pci/if_myxreg.h
+++ b/sys/dev/pci/if_myxreg.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: if_myxreg.h,v 1.3 2008/01/17 18:56:05 thib Exp $ */
+/* $OpenBSD: if_myxreg.h,v 1.4 2011/06/20 05:19:20 dlg Exp $ */
/*
* Copyright (c) 2007 Reyk Floeter <reyk@openbsd.org>
@@ -52,8 +52,8 @@
#define MYX_HEADER_POS_SIZE 0x00000004 /* Header position size */
#define MYX_FW 0x00100000 /* Firmware offset */
#define MYX_FW_BOOT 0x00100008 /* Firmware boot offset */
-#define MYX_EEPROM 0x001dfe00 /* EEPROM offset */
-#define MYX_EEPROM_SIZE 0x00000100 /* EEPROM size */
+#define MYX_STRING_SPECS 0x001dfe00 /* STRING_SPECS offset */
+#define MYX_STRING_SPECS_SIZE 0x00000100 /* STRING_SPECS size */
#define MYX_BOOT 0x00fc0000 /* Boot handoff */
#define MYX_RDMA 0x00fc01c0 /* Dummy RDMA */
#define MYX_CMD 0x00f80000 /* Command offset */
@@ -69,16 +69,16 @@
#define MYXFW_MIN_LEN (MYX_HEADER_POS + MYX_HEADER_POS_SIZE)
-struct myx_firmware_hdr {
+struct myx_gen_hdr {
u_int32_t fw_hdrlength;
u_int32_t fw_type;
u_int8_t fw_version[128];
+ u_int32_t fw_mcp_globals;
u_int32_t fw_sram_size;
u_int32_t fw_specs;
u_int32_t fw_specs_len;
} __packed;
-
/*
* Commands, descriptors, and DMA structures
*/
@@ -132,8 +132,7 @@ struct myx_status {
u_int32_t ms_linkstate;
#define MYXSTS_LINKDOWN 0
#define MYXSTS_LINKUP 1
-#define MYXSTS_LINKMYRINET 2
-#define MYXSTS_LINKUNKNOWN 3
+#define MYXSTS_LINKUNKNOWN 2
u_int32_t ms_dropped_linkoverflow;
u_int32_t ms_dropped_linkerror;
u_int32_t ms_dropped_runt;
@@ -144,24 +143,22 @@ struct myx_status {
#define MYXSTS_RDMAON 1
#define MYXSTS_RDMAOFF 0
u_int8_t ms_txstopped;
- u_int8_t ms_linkdowncnt;
+ u_int8_t ms_linkdown;
u_int8_t ms_statusupdated;
u_int8_t ms_isvalid;
} __packed;
-struct myx_rxdesc {
- u_int16_t rx_csum;
- u_int16_t rx_length;
+struct myx_intrq_desc {
+ u_int16_t iq_csum;
+ u_int16_t iq_length;
} __packed;
-struct myx_rxbufdesc {
- u_int32_t rb_addr_high;
- u_int32_t rb_addr_low;
+struct myx_rx_desc {
+ u_int64_t rx_addr;
} __packed;
-struct myx_txdesc {
- u_int32_t tx_addr_high;
- u_int32_t tx_addr_low;
+struct myx_tx_desc {
+ u_int64_t tx_addr;
u_int16_t tx_hdr_offset;
u_int16_t tx_length;
u_int8_t tx_pad;
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-14 02:34:43 +0000