2 * Copyright (c) 2008, Pyun YongHyeon <yongari@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * $FreeBSD: src/sys/dev/ale/if_ale.c,v 1.3 2008/12/03 09:01:12 yongari Exp $
30 /* Driver for Atheros AR8121/AR8113/AR8114 PCIe Ethernet. */
32 #include <sys/param.h>
33 #include <sys/endian.h>
34 #include <sys/kernel.h>
36 #include <sys/interrupt.h>
37 #include <sys/malloc.h>
40 #include <sys/serialize.h>
41 #include <sys/socket.h>
42 #include <sys/sockio.h>
43 #include <sys/sysctl.h>
45 #include <net/ethernet.h>
48 #include <net/if_arp.h>
49 #include <net/if_dl.h>
50 #include <net/if_llc.h>
51 #include <net/if_media.h>
52 #include <net/ifq_var.h>
53 #include <net/vlan/if_vlan_var.h>
54 #include <net/vlan/if_vlan_ether.h>
56 #include <netinet/ip.h>
58 #include <dev/netif/mii_layer/mii.h>
59 #include <dev/netif/mii_layer/miivar.h>
61 #include <bus/pci/pcireg.h>
62 #include <bus/pci/pcivar.h>
63 #include <bus/pci/pcidevs.h>
65 #include <dev/netif/ale/if_alereg.h>
66 #include <dev/netif/ale/if_alevar.h>
68 /* "device miibus" required. See GENERIC if you get errors here. */
69 #include "miibus_if.h"
71 /* For more information about Tx checksum offload issues see ale_encap(). */
72 #define ALE_CSUM_FEATURES (CSUM_TCP | CSUM_UDP)
74 struct ale_dmamap_ctx {
76 bus_dma_segment_t *segs;
79 static int ale_probe(device_t);
80 static int ale_attach(device_t);
81 static int ale_detach(device_t);
82 static int ale_shutdown(device_t);
83 static int ale_suspend(device_t);
84 static int ale_resume(device_t);
86 static int ale_miibus_readreg(device_t, int, int);
87 static int ale_miibus_writereg(device_t, int, int, int);
88 static void ale_miibus_statchg(device_t);
90 static void ale_init(void *);
91 static void ale_start(struct ifnet *);
92 static int ale_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
93 static void ale_watchdog(struct ifnet *);
94 static int ale_mediachange(struct ifnet *);
95 static void ale_mediastatus(struct ifnet *, struct ifmediareq *);
97 static void ale_intr(void *);
98 static int ale_rxeof(struct ale_softc *sc);
99 static void ale_rx_update_page(struct ale_softc *, struct ale_rx_page **,
100 uint32_t, uint32_t *);
101 static void ale_rxcsum(struct ale_softc *, struct mbuf *, uint32_t);
102 static void ale_txeof(struct ale_softc *);
104 static int ale_dma_alloc(struct ale_softc *);
105 static void ale_dma_free(struct ale_softc *);
106 static int ale_check_boundary(struct ale_softc *);
107 static void ale_dmamap_cb(void *, bus_dma_segment_t *, int, int);
108 static void ale_dmamap_buf_cb(void *, bus_dma_segment_t *, int,
110 static int ale_encap(struct ale_softc *, struct mbuf **);
111 static void ale_init_rx_pages(struct ale_softc *);
112 static void ale_init_tx_ring(struct ale_softc *);
114 static void ale_stop(struct ale_softc *);
115 static void ale_tick(void *);
116 static void ale_get_macaddr(struct ale_softc *);
117 static void ale_mac_config(struct ale_softc *);
118 static void ale_phy_reset(struct ale_softc *);
119 static void ale_reset(struct ale_softc *);
120 static void ale_rxfilter(struct ale_softc *);
121 static void ale_rxvlan(struct ale_softc *);
122 static void ale_stats_clear(struct ale_softc *);
123 static void ale_stats_update(struct ale_softc *);
124 static void ale_stop_mac(struct ale_softc *);
126 static void ale_setlinkspeed(struct ale_softc *);
127 static void ale_setwol(struct ale_softc *);
130 static void ale_sysctl_node(struct ale_softc *);
131 static int sysctl_hw_ale_int_mod(SYSCTL_HANDLER_ARGS);
134 * Devices supported by this driver.
136 static struct ale_dev {
137 uint16_t ale_vendorid;
138 uint16_t ale_deviceid;
139 const char *ale_name;
141 { VENDORID_ATHEROS, DEVICEID_ATHEROS_AR81XX,
142 "Atheros AR8121/AR8113/AR8114 PCIe Ethernet" },
145 static device_method_t ale_methods[] = {
146 /* Device interface. */
147 DEVMETHOD(device_probe, ale_probe),
148 DEVMETHOD(device_attach, ale_attach),
149 DEVMETHOD(device_detach, ale_detach),
150 DEVMETHOD(device_shutdown, ale_shutdown),
151 DEVMETHOD(device_suspend, ale_suspend),
152 DEVMETHOD(device_resume, ale_resume),
155 DEVMETHOD(bus_print_child, bus_generic_print_child),
156 DEVMETHOD(bus_driver_added, bus_generic_driver_added),
159 DEVMETHOD(miibus_readreg, ale_miibus_readreg),
160 DEVMETHOD(miibus_writereg, ale_miibus_writereg),
161 DEVMETHOD(miibus_statchg, ale_miibus_statchg),
166 static driver_t ale_driver = {
169 sizeof(struct ale_softc)
172 static devclass_t ale_devclass;
174 DECLARE_DUMMY_MODULE(if_ale);
175 MODULE_DEPEND(if_ale, miibus, 1, 1, 1);
176 DRIVER_MODULE(if_ale, pci, ale_driver, ale_devclass, NULL, NULL);
177 DRIVER_MODULE(miibus, ale, miibus_driver, miibus_devclass, NULL, NULL);
180 ale_miibus_readreg(device_t dev, int phy, int reg)
182 struct ale_softc *sc;
186 sc = device_get_softc(dev);
188 if (phy != sc->ale_phyaddr)
191 if (sc->ale_flags & ALE_FLAG_FASTETHER) {
192 if (reg == MII_100T2CR || reg == MII_100T2SR ||
197 CSR_WRITE_4(sc, ALE_MDIO, MDIO_OP_EXECUTE | MDIO_OP_READ |
198 MDIO_SUP_PREAMBLE | MDIO_CLK_25_4 | MDIO_REG_ADDR(reg));
199 for (i = ALE_PHY_TIMEOUT; i > 0; i--) {
201 v = CSR_READ_4(sc, ALE_MDIO);
202 if ((v & (MDIO_OP_EXECUTE | MDIO_OP_BUSY)) == 0)
207 device_printf(sc->ale_dev, "phy read timeout : %d\n", reg);
211 return ((v & MDIO_DATA_MASK) >> MDIO_DATA_SHIFT);
215 ale_miibus_writereg(device_t dev, int phy, int reg, int val)
217 struct ale_softc *sc;
221 sc = device_get_softc(dev);
223 if (phy != sc->ale_phyaddr)
226 if (sc->ale_flags & ALE_FLAG_FASTETHER) {
227 if (reg == MII_100T2CR || reg == MII_100T2SR ||
232 CSR_WRITE_4(sc, ALE_MDIO, MDIO_OP_EXECUTE | MDIO_OP_WRITE |
233 (val & MDIO_DATA_MASK) << MDIO_DATA_SHIFT |
234 MDIO_SUP_PREAMBLE | MDIO_CLK_25_4 | MDIO_REG_ADDR(reg));
235 for (i = ALE_PHY_TIMEOUT; i > 0; i--) {
237 v = CSR_READ_4(sc, ALE_MDIO);
238 if ((v & (MDIO_OP_EXECUTE | MDIO_OP_BUSY)) == 0)
243 device_printf(sc->ale_dev, "phy write timeout : %d\n", reg);
249 ale_miibus_statchg(device_t dev)
251 struct ale_softc *sc = device_get_softc(dev);
252 struct ifnet *ifp = &sc->arpcom.ac_if;
253 struct mii_data *mii;
256 ASSERT_SERIALIZED(ifp->if_serializer);
258 if ((ifp->if_flags & IFF_RUNNING) == 0)
261 mii = device_get_softc(sc->ale_miibus);
263 sc->ale_flags &= ~ALE_FLAG_LINK;
264 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
265 (IFM_ACTIVE | IFM_AVALID)) {
266 switch (IFM_SUBTYPE(mii->mii_media_active)) {
269 sc->ale_flags |= ALE_FLAG_LINK;
273 if ((sc->ale_flags & ALE_FLAG_FASTETHER) == 0)
274 sc->ale_flags |= ALE_FLAG_LINK;
282 /* Stop Rx/Tx MACs. */
285 /* Program MACs with resolved speed/duplex/flow-control. */
286 if ((sc->ale_flags & ALE_FLAG_LINK) != 0) {
288 /* Reenable Tx/Rx MACs. */
289 reg = CSR_READ_4(sc, ALE_MAC_CFG);
290 reg |= MAC_CFG_TX_ENB | MAC_CFG_RX_ENB;
291 CSR_WRITE_4(sc, ALE_MAC_CFG, reg);
296 ale_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
298 struct ale_softc *sc = ifp->if_softc;
299 struct mii_data *mii = device_get_softc(sc->ale_miibus);
301 ASSERT_SERIALIZED(ifp->if_serializer);
304 ifmr->ifm_status = mii->mii_media_status;
305 ifmr->ifm_active = mii->mii_media_active;
309 ale_mediachange(struct ifnet *ifp)
311 struct ale_softc *sc = ifp->if_softc;
312 struct mii_data *mii = device_get_softc(sc->ale_miibus);
315 ASSERT_SERIALIZED(ifp->if_serializer);
317 if (mii->mii_instance != 0) {
318 struct mii_softc *miisc;
320 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
321 mii_phy_reset(miisc);
323 error = mii_mediachg(mii);
329 ale_probe(device_t dev)
333 uint16_t vendor, devid;
335 vendor = pci_get_vendor(dev);
336 devid = pci_get_device(dev);
338 for (i = 0; i < NELEM(ale_devs); i++) {
339 if (vendor == sp->ale_vendorid &&
340 devid == sp->ale_deviceid) {
341 device_set_desc(dev, sp->ale_name);
351 ale_get_macaddr(struct ale_softc *sc)
356 reg = CSR_READ_4(sc, ALE_SPI_CTRL);
357 if ((reg & SPI_VPD_ENB) != 0) {
359 CSR_WRITE_4(sc, ALE_SPI_CTRL, reg);
362 vpdc = pci_get_vpdcap_ptr(sc->ale_dev);
365 * PCI VPD capability found, let TWSI reload EEPROM.
366 * This will set ethernet address of controller.
368 CSR_WRITE_4(sc, ALE_TWSI_CTRL, CSR_READ_4(sc, ALE_TWSI_CTRL) |
369 TWSI_CTRL_SW_LD_START);
370 for (i = 100; i > 0; i--) {
372 reg = CSR_READ_4(sc, ALE_TWSI_CTRL);
373 if ((reg & TWSI_CTRL_SW_LD_START) == 0)
377 device_printf(sc->ale_dev,
378 "reloading EEPROM timeout!\n");
381 device_printf(sc->ale_dev,
382 "PCI VPD capability not found!\n");
385 ea[0] = CSR_READ_4(sc, ALE_PAR0);
386 ea[1] = CSR_READ_4(sc, ALE_PAR1);
387 sc->ale_eaddr[0] = (ea[1] >> 8) & 0xFF;
388 sc->ale_eaddr[1] = (ea[1] >> 0) & 0xFF;
389 sc->ale_eaddr[2] = (ea[0] >> 24) & 0xFF;
390 sc->ale_eaddr[3] = (ea[0] >> 16) & 0xFF;
391 sc->ale_eaddr[4] = (ea[0] >> 8) & 0xFF;
392 sc->ale_eaddr[5] = (ea[0] >> 0) & 0xFF;
396 ale_phy_reset(struct ale_softc *sc)
398 /* Reset magic from Linux. */
399 CSR_WRITE_2(sc, ALE_GPHY_CTRL,
400 GPHY_CTRL_HIB_EN | GPHY_CTRL_HIB_PULSE | GPHY_CTRL_SEL_ANA_RESET |
401 GPHY_CTRL_PHY_PLL_ON);
403 CSR_WRITE_2(sc, ALE_GPHY_CTRL,
404 GPHY_CTRL_EXT_RESET | GPHY_CTRL_HIB_EN | GPHY_CTRL_HIB_PULSE |
405 GPHY_CTRL_SEL_ANA_RESET | GPHY_CTRL_PHY_PLL_ON);
408 #define ATPHY_DBG_ADDR 0x1D
409 #define ATPHY_DBG_DATA 0x1E
411 /* Enable hibernation mode. */
412 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
413 ATPHY_DBG_ADDR, 0x0B);
414 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
415 ATPHY_DBG_DATA, 0xBC00);
416 /* Set Class A/B for all modes. */
417 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
418 ATPHY_DBG_ADDR, 0x00);
419 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
420 ATPHY_DBG_DATA, 0x02EF);
421 /* Enable 10BT power saving. */
422 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
423 ATPHY_DBG_ADDR, 0x12);
424 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
425 ATPHY_DBG_DATA, 0x4C04);
426 /* Adjust 1000T power. */
427 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
428 ATPHY_DBG_ADDR, 0x04);
429 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
430 ATPHY_DBG_ADDR, 0x8BBB);
431 /* 10BT center tap voltage. */
432 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
433 ATPHY_DBG_ADDR, 0x05);
434 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
435 ATPHY_DBG_ADDR, 0x2C46);
437 #undef ATPHY_DBG_ADDR
438 #undef ATPHY_DBG_DATA
443 ale_attach(device_t dev)
445 struct ale_softc *sc = device_get_softc(dev);
446 struct ifnet *ifp = &sc->arpcom.ac_if;
448 uint32_t rxf_len, txf_len;
451 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
454 callout_init(&sc->ale_tick_ch);
457 if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0) {
460 irq = pci_read_config(dev, PCIR_INTLINE, 4);
461 mem = pci_read_config(dev, ALE_PCIR_BAR, 4);
463 device_printf(dev, "chip is in D%d power mode "
464 "-- setting to D0\n", pci_get_powerstate(dev));
466 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
468 pci_write_config(dev, PCIR_INTLINE, irq, 4);
469 pci_write_config(dev, ALE_PCIR_BAR, mem, 4);
471 #endif /* !BURN_BRIDGE */
473 /* Enable bus mastering */
474 pci_enable_busmaster(dev);
477 * Allocate memory mapped IO
479 sc->ale_mem_rid = ALE_PCIR_BAR;
480 sc->ale_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
481 &sc->ale_mem_rid, RF_ACTIVE);
482 if (sc->ale_mem_res == NULL) {
483 device_printf(dev, "can't allocate IO memory\n");
486 sc->ale_mem_bt = rman_get_bustag(sc->ale_mem_res);
487 sc->ale_mem_bh = rman_get_bushandle(sc->ale_mem_res);
493 sc->ale_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
495 RF_SHAREABLE | RF_ACTIVE);
496 if (sc->ale_irq_res == NULL) {
497 device_printf(dev, "can't allocate irq\n");
502 /* Set PHY address. */
503 sc->ale_phyaddr = ALE_PHY_ADDR;
508 /* Reset the ethernet controller. */
511 /* Get PCI and chip id/revision. */
512 sc->ale_rev = pci_get_revid(dev);
513 if (sc->ale_rev >= 0xF0) {
514 /* L2E Rev. B. AR8114 */
515 sc->ale_flags |= ALE_FLAG_FASTETHER;
517 if ((CSR_READ_4(sc, ALE_PHY_STATUS) & PHY_STATUS_100M) != 0) {
519 sc->ale_flags |= ALE_FLAG_JUMBO;
521 /* L2E Rev. A. AR8113 */
522 sc->ale_flags |= ALE_FLAG_FASTETHER;
527 * All known controllers seems to require 4 bytes alignment
528 * of Tx buffers to make Tx checksum offload with custom
529 * checksum generation method work.
531 sc->ale_flags |= ALE_FLAG_TXCSUM_BUG;
534 * All known controllers seems to have issues on Rx checksum
535 * offload for fragmented IP datagrams.
537 sc->ale_flags |= ALE_FLAG_RXCSUM_BUG;
540 * Don't use Tx CMB. It is known to cause RRS update failure
541 * under certain circumstances. Typical phenomenon of the
542 * issue would be unexpected sequence number encountered in
545 sc->ale_flags |= ALE_FLAG_TXCMB_BUG;
546 sc->ale_chip_rev = CSR_READ_4(sc, ALE_MASTER_CFG) >>
547 MASTER_CHIP_REV_SHIFT;
549 device_printf(dev, "PCI device revision : 0x%04x\n",
551 device_printf(dev, "Chip id/revision : 0x%04x\n",
556 * Uninitialized hardware returns an invalid chip id/revision
557 * as well as 0xFFFFFFFF for Tx/Rx fifo length.
559 txf_len = CSR_READ_4(sc, ALE_SRAM_TX_FIFO_LEN);
560 rxf_len = CSR_READ_4(sc, ALE_SRAM_RX_FIFO_LEN);
561 if (sc->ale_chip_rev == 0xFFFF || txf_len == 0xFFFFFFFF ||
562 rxf_len == 0xFFFFFFF) {
563 device_printf(dev,"chip revision : 0x%04x, %u Tx FIFO "
564 "%u Rx FIFO -- not initialized?\n", sc->ale_chip_rev,
569 device_printf(dev, "%u Tx FIFO, %u Rx FIFO\n", txf_len, rxf_len);
571 /* Get DMA parameters from PCIe device control register. */
572 pcie_ptr = pci_get_pciecap_ptr(dev);
576 sc->ale_flags |= ALE_FLAG_PCIE;
577 devctl = pci_read_config(dev, pcie_ptr + PCIER_DEVCTRL, 2);
578 /* Max read request size. */
579 sc->ale_dma_rd_burst = ((devctl >> 12) & 0x07) <<
580 DMA_CFG_RD_BURST_SHIFT;
581 /* Max payload size. */
582 sc->ale_dma_wr_burst = ((devctl >> 5) & 0x07) <<
583 DMA_CFG_WR_BURST_SHIFT;
585 device_printf(dev, "Read request size : %d bytes.\n",
586 128 << ((devctl >> 12) & 0x07));
587 device_printf(dev, "TLP payload size : %d bytes.\n",
588 128 << ((devctl >> 5) & 0x07));
591 sc->ale_dma_rd_burst = DMA_CFG_RD_BURST_128;
592 sc->ale_dma_wr_burst = DMA_CFG_WR_BURST_128;
595 /* Create device sysctl node. */
598 if ((error = ale_dma_alloc(sc) != 0))
601 /* Load station address. */
605 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
606 ifp->if_ioctl = ale_ioctl;
607 ifp->if_start = ale_start;
608 ifp->if_init = ale_init;
609 ifp->if_watchdog = ale_watchdog;
610 ifq_set_maxlen(&ifp->if_snd, ALE_TX_RING_CNT - 1);
611 ifq_set_ready(&ifp->if_snd);
613 ifp->if_capabilities = IFCAP_RXCSUM |
615 IFCAP_VLAN_HWTAGGING;
617 ifp->if_capabilities |= IFCAP_TXCSUM;
618 ifp->if_hwassist = ALE_CSUM_FEATURES;
620 ifp->if_capenable = ifp->if_capabilities;
622 /* Set up MII bus. */
623 if ((error = mii_phy_probe(dev, &sc->ale_miibus, ale_mediachange,
624 ale_mediastatus)) != 0) {
625 device_printf(dev, "no PHY found!\n");
629 ether_ifattach(ifp, sc->ale_eaddr, NULL);
631 /* Tell the upper layer(s) we support long frames. */
632 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
634 error = bus_setup_intr(dev, sc->ale_irq_res, INTR_MPSAFE, ale_intr, sc,
635 &sc->ale_irq_handle, ifp->if_serializer);
637 device_printf(dev, "could not set up interrupt handler.\n");
642 ifp->if_cpuid = ithread_cpuid(rman_get_start(sc->ale_irq_res));
643 KKASSERT(ifp->if_cpuid >= 0 && ifp->if_cpuid < ncpus);
651 ale_detach(device_t dev)
653 struct ale_softc *sc = device_get_softc(dev);
655 if (device_is_attached(dev)) {
656 struct ifnet *ifp = &sc->arpcom.ac_if;
658 lwkt_serialize_enter(ifp->if_serializer);
659 sc->ale_flags |= ALE_FLAG_DETACH;
661 bus_teardown_intr(dev, sc->ale_irq_res, sc->ale_irq_handle);
662 lwkt_serialize_exit(ifp->if_serializer);
667 if (sc->ale_sysctl_tree != NULL)
668 sysctl_ctx_free(&sc->ale_sysctl_ctx);
670 if (sc->ale_miibus != NULL)
671 device_delete_child(dev, sc->ale_miibus);
672 bus_generic_detach(dev);
674 if (sc->ale_irq_res != NULL) {
675 bus_release_resource(dev, SYS_RES_IRQ, sc->ale_irq_rid,
678 if (sc->ale_mem_res != NULL) {
679 bus_release_resource(dev, SYS_RES_MEMORY, sc->ale_mem_rid,
688 #define ALE_SYSCTL_STAT_ADD32(c, h, n, p, d) \
689 SYSCTL_ADD_UINT(c, h, OID_AUTO, n, CTLFLAG_RD, p, 0, d)
690 #define ALE_SYSCTL_STAT_ADD64(c, h, n, p, d) \
691 SYSCTL_ADD_QUAD(c, h, OID_AUTO, n, CTLFLAG_RD, p, 0, d)
694 ale_sysctl_node(struct ale_softc *sc)
696 struct sysctl_ctx_list *ctx;
697 struct sysctl_oid_list *child, *parent;
698 struct sysctl_oid *tree;
699 struct ale_hw_stats *stats;
702 sysctl_ctx_init(&sc->ale_sysctl_ctx);
703 sc->ale_sysctl_tree = SYSCTL_ADD_NODE(&sc->ale_sysctl_ctx,
704 SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
705 device_get_nameunit(sc->ale_dev),
707 if (sc->ale_sysctl_tree == NULL) {
708 device_printf(sc->ale_dev, "can't add sysctl node\n");
712 stats = &sc->ale_stats;
713 ctx = &sc->ale_sysctl_ctx;
714 child = SYSCTL_CHILDREN(sc->ale_sysctl_tree);
716 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_rx_mod",
717 CTLTYPE_INT | CTLFLAG_RW, &sc->ale_int_rx_mod, 0,
718 sysctl_hw_ale_int_mod, "I", "ale Rx interrupt moderation");
719 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_tx_mod",
720 CTLTYPE_INT | CTLFLAG_RW, &sc->ale_int_tx_mod, 0,
721 sysctl_hw_ale_int_mod, "I", "ale Tx interrupt moderation");
724 * Pull in device tunables.
726 sc->ale_int_rx_mod = ALE_IM_RX_TIMER_DEFAULT;
727 error = resource_int_value(device_get_name(sc->ale_dev),
728 device_get_unit(sc->ale_dev), "int_rx_mod", &sc->ale_int_rx_mod);
730 if (sc->ale_int_rx_mod < ALE_IM_TIMER_MIN ||
731 sc->ale_int_rx_mod > ALE_IM_TIMER_MAX) {
732 device_printf(sc->ale_dev, "int_rx_mod value out of "
733 "range; using default: %d\n",
734 ALE_IM_RX_TIMER_DEFAULT);
735 sc->ale_int_rx_mod = ALE_IM_RX_TIMER_DEFAULT;
739 sc->ale_int_tx_mod = ALE_IM_TX_TIMER_DEFAULT;
740 error = resource_int_value(device_get_name(sc->ale_dev),
741 device_get_unit(sc->ale_dev), "int_tx_mod", &sc->ale_int_tx_mod);
743 if (sc->ale_int_tx_mod < ALE_IM_TIMER_MIN ||
744 sc->ale_int_tx_mod > ALE_IM_TIMER_MAX) {
745 device_printf(sc->ale_dev, "int_tx_mod value out of "
746 "range; using default: %d\n",
747 ALE_IM_TX_TIMER_DEFAULT);
748 sc->ale_int_tx_mod = ALE_IM_TX_TIMER_DEFAULT;
752 /* Misc statistics. */
753 ALE_SYSCTL_STAT_ADD32(ctx, child, "reset_brk_seq",
754 &stats->reset_brk_seq,
755 "Controller resets due to broken Rx sequnce number");
757 tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
758 NULL, "ATE statistics");
759 parent = SYSCTL_CHILDREN(tree);
762 tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD,
763 NULL, "Rx MAC statistics");
764 child = SYSCTL_CHILDREN(tree);
765 ALE_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
766 &stats->rx_frames, "Good frames");
767 ALE_SYSCTL_STAT_ADD32(ctx, child, "good_bcast_frames",
768 &stats->rx_bcast_frames, "Good broadcast frames");
769 ALE_SYSCTL_STAT_ADD32(ctx, child, "good_mcast_frames",
770 &stats->rx_mcast_frames, "Good multicast frames");
771 ALE_SYSCTL_STAT_ADD32(ctx, child, "pause_frames",
772 &stats->rx_pause_frames, "Pause control frames");
773 ALE_SYSCTL_STAT_ADD32(ctx, child, "control_frames",
774 &stats->rx_control_frames, "Control frames");
775 ALE_SYSCTL_STAT_ADD32(ctx, child, "crc_errs",
776 &stats->rx_crcerrs, "CRC errors");
777 ALE_SYSCTL_STAT_ADD32(ctx, child, "len_errs",
778 &stats->rx_lenerrs, "Frames with length mismatched");
779 ALE_SYSCTL_STAT_ADD64(ctx, child, "good_octets",
780 &stats->rx_bytes, "Good octets");
781 ALE_SYSCTL_STAT_ADD64(ctx, child, "good_bcast_octets",
782 &stats->rx_bcast_bytes, "Good broadcast octets");
783 ALE_SYSCTL_STAT_ADD64(ctx, child, "good_mcast_octets",
784 &stats->rx_mcast_bytes, "Good multicast octets");
785 ALE_SYSCTL_STAT_ADD32(ctx, child, "runts",
786 &stats->rx_runts, "Too short frames");
787 ALE_SYSCTL_STAT_ADD32(ctx, child, "fragments",
788 &stats->rx_fragments, "Fragmented frames");
789 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_64",
790 &stats->rx_pkts_64, "64 bytes frames");
791 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_65_127",
792 &stats->rx_pkts_65_127, "65 to 127 bytes frames");
793 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_128_255",
794 &stats->rx_pkts_128_255, "128 to 255 bytes frames");
795 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_256_511",
796 &stats->rx_pkts_256_511, "256 to 511 bytes frames");
797 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_512_1023",
798 &stats->rx_pkts_512_1023, "512 to 1023 bytes frames");
799 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_1024_1518",
800 &stats->rx_pkts_1024_1518, "1024 to 1518 bytes frames");
801 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_1519_max",
802 &stats->rx_pkts_1519_max, "1519 to max frames");
803 ALE_SYSCTL_STAT_ADD32(ctx, child, "trunc_errs",
804 &stats->rx_pkts_truncated, "Truncated frames due to MTU size");
805 ALE_SYSCTL_STAT_ADD32(ctx, child, "fifo_oflows",
806 &stats->rx_fifo_oflows, "FIFO overflows");
807 ALE_SYSCTL_STAT_ADD32(ctx, child, "rrs_errs",
808 &stats->rx_rrs_errs, "Return status write-back errors");
809 ALE_SYSCTL_STAT_ADD32(ctx, child, "align_errs",
810 &stats->rx_alignerrs, "Alignment errors");
811 ALE_SYSCTL_STAT_ADD32(ctx, child, "filtered",
812 &stats->rx_pkts_filtered,
813 "Frames dropped due to address filtering");
816 tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD,
817 NULL, "Tx MAC statistics");
818 child = SYSCTL_CHILDREN(tree);
819 ALE_SYSCTL_STAT_ADD32(ctx, child, "good_frames",
820 &stats->tx_frames, "Good frames");
821 ALE_SYSCTL_STAT_ADD32(ctx, child, "good_bcast_frames",
822 &stats->tx_bcast_frames, "Good broadcast frames");
823 ALE_SYSCTL_STAT_ADD32(ctx, child, "good_mcast_frames",
824 &stats->tx_mcast_frames, "Good multicast frames");
825 ALE_SYSCTL_STAT_ADD32(ctx, child, "pause_frames",
826 &stats->tx_pause_frames, "Pause control frames");
827 ALE_SYSCTL_STAT_ADD32(ctx, child, "control_frames",
828 &stats->tx_control_frames, "Control frames");
829 ALE_SYSCTL_STAT_ADD32(ctx, child, "excess_defers",
830 &stats->tx_excess_defer, "Frames with excessive derferrals");
831 ALE_SYSCTL_STAT_ADD32(ctx, child, "defers",
832 &stats->tx_excess_defer, "Frames with derferrals");
833 ALE_SYSCTL_STAT_ADD64(ctx, child, "good_octets",
834 &stats->tx_bytes, "Good octets");
835 ALE_SYSCTL_STAT_ADD64(ctx, child, "good_bcast_octets",
836 &stats->tx_bcast_bytes, "Good broadcast octets");
837 ALE_SYSCTL_STAT_ADD64(ctx, child, "good_mcast_octets",
838 &stats->tx_mcast_bytes, "Good multicast octets");
839 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_64",
840 &stats->tx_pkts_64, "64 bytes frames");
841 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_65_127",
842 &stats->tx_pkts_65_127, "65 to 127 bytes frames");
843 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_128_255",
844 &stats->tx_pkts_128_255, "128 to 255 bytes frames");
845 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_256_511",
846 &stats->tx_pkts_256_511, "256 to 511 bytes frames");
847 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_512_1023",
848 &stats->tx_pkts_512_1023, "512 to 1023 bytes frames");
849 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_1024_1518",
850 &stats->tx_pkts_1024_1518, "1024 to 1518 bytes frames");
851 ALE_SYSCTL_STAT_ADD32(ctx, child, "frames_1519_max",
852 &stats->tx_pkts_1519_max, "1519 to max frames");
853 ALE_SYSCTL_STAT_ADD32(ctx, child, "single_colls",
854 &stats->tx_single_colls, "Single collisions");
855 ALE_SYSCTL_STAT_ADD32(ctx, child, "multi_colls",
856 &stats->tx_multi_colls, "Multiple collisions");
857 ALE_SYSCTL_STAT_ADD32(ctx, child, "late_colls",
858 &stats->tx_late_colls, "Late collisions");
859 ALE_SYSCTL_STAT_ADD32(ctx, child, "excess_colls",
860 &stats->tx_excess_colls, "Excessive collisions");
861 ALE_SYSCTL_STAT_ADD32(ctx, child, "abort",
862 &stats->tx_abort, "Aborted frames due to Excessive collisions");
863 ALE_SYSCTL_STAT_ADD32(ctx, child, "underruns",
864 &stats->tx_underrun, "FIFO underruns");
865 ALE_SYSCTL_STAT_ADD32(ctx, child, "desc_underruns",
866 &stats->tx_desc_underrun, "Descriptor write-back errors");
867 ALE_SYSCTL_STAT_ADD32(ctx, child, "len_errs",
868 &stats->tx_lenerrs, "Frames with length mismatched");
869 ALE_SYSCTL_STAT_ADD32(ctx, child, "trunc_errs",
870 &stats->tx_pkts_truncated, "Truncated frames due to MTU size");
873 #undef ALE_SYSCTL_STAT_ADD32
874 #undef ALE_SYSCTL_STAT_ADD64
876 struct ale_dmamap_arg {
877 bus_addr_t ale_busaddr;
881 ale_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
883 struct ale_dmamap_arg *ctx;
888 KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
890 ctx = (struct ale_dmamap_arg *)arg;
891 ctx->ale_busaddr = segs[0].ds_addr;
895 * Tx descriptors/RXF0/CMB DMA blocks share ALE_DESC_ADDR_HI register
896 * which specifies high address region of DMA blocks. Therefore these
897 * blocks should have the same high address of given 4GB address
898 * space(i.e. crossing 4GB boundary is not allowed).
901 ale_check_boundary(struct ale_softc *sc)
903 bus_addr_t rx_cmb_end[ALE_RX_PAGES], tx_cmb_end;
904 bus_addr_t rx_page_end[ALE_RX_PAGES], tx_ring_end;
906 rx_page_end[0] = sc->ale_cdata.ale_rx_page[0].page_paddr +
908 rx_page_end[1] = sc->ale_cdata.ale_rx_page[1].page_paddr +
910 tx_ring_end = sc->ale_cdata.ale_tx_ring_paddr + ALE_TX_RING_SZ;
911 tx_cmb_end = sc->ale_cdata.ale_tx_cmb_paddr + ALE_TX_CMB_SZ;
912 rx_cmb_end[0] = sc->ale_cdata.ale_rx_page[0].cmb_paddr + ALE_RX_CMB_SZ;
913 rx_cmb_end[1] = sc->ale_cdata.ale_rx_page[1].cmb_paddr + ALE_RX_CMB_SZ;
915 if ((ALE_ADDR_HI(tx_ring_end) !=
916 ALE_ADDR_HI(sc->ale_cdata.ale_tx_ring_paddr)) ||
917 (ALE_ADDR_HI(rx_page_end[0]) !=
918 ALE_ADDR_HI(sc->ale_cdata.ale_rx_page[0].page_paddr)) ||
919 (ALE_ADDR_HI(rx_page_end[1]) !=
920 ALE_ADDR_HI(sc->ale_cdata.ale_rx_page[1].page_paddr)) ||
921 (ALE_ADDR_HI(tx_cmb_end) !=
922 ALE_ADDR_HI(sc->ale_cdata.ale_tx_cmb_paddr)) ||
923 (ALE_ADDR_HI(rx_cmb_end[0]) !=
924 ALE_ADDR_HI(sc->ale_cdata.ale_rx_page[0].cmb_paddr)) ||
925 (ALE_ADDR_HI(rx_cmb_end[1]) !=
926 ALE_ADDR_HI(sc->ale_cdata.ale_rx_page[1].cmb_paddr)))
929 if ((ALE_ADDR_HI(tx_ring_end) != ALE_ADDR_HI(rx_page_end[0])) ||
930 (ALE_ADDR_HI(tx_ring_end) != ALE_ADDR_HI(rx_page_end[1])) ||
931 (ALE_ADDR_HI(tx_ring_end) != ALE_ADDR_HI(rx_cmb_end[0])) ||
932 (ALE_ADDR_HI(tx_ring_end) != ALE_ADDR_HI(rx_cmb_end[1])) ||
933 (ALE_ADDR_HI(tx_ring_end) != ALE_ADDR_HI(tx_cmb_end)))
940 ale_dma_alloc(struct ale_softc *sc)
942 struct ale_txdesc *txd;
944 struct ale_dmamap_arg ctx;
945 int error, guard_size, i;
947 if ((sc->ale_flags & ALE_FLAG_JUMBO) != 0)
948 guard_size = ALE_JUMBO_FRAMELEN;
950 guard_size = ALE_MAX_FRAMELEN;
951 sc->ale_pagesize = roundup(guard_size + ALE_RX_PAGE_SZ,
953 lowaddr = BUS_SPACE_MAXADDR;
955 /* Create parent DMA tag. */
956 error = bus_dma_tag_create(
958 1, 0, /* alignment, boundary */
959 lowaddr, /* lowaddr */
960 BUS_SPACE_MAXADDR, /* highaddr */
961 NULL, NULL, /* filter, filterarg */
962 BUS_SPACE_MAXSIZE_32BIT, /* maxsize */
964 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
966 &sc->ale_cdata.ale_parent_tag);
968 device_printf(sc->ale_dev,
969 "could not create parent DMA tag.\n");
973 /* Create DMA tag for Tx descriptor ring. */
974 error = bus_dma_tag_create(
975 sc->ale_cdata.ale_parent_tag, /* parent */
976 ALE_TX_RING_ALIGN, 0, /* alignment, boundary */
977 BUS_SPACE_MAXADDR, /* lowaddr */
978 BUS_SPACE_MAXADDR, /* highaddr */
979 NULL, NULL, /* filter, filterarg */
980 ALE_TX_RING_SZ, /* maxsize */
982 ALE_TX_RING_SZ, /* maxsegsize */
984 &sc->ale_cdata.ale_tx_ring_tag);
986 device_printf(sc->ale_dev,
987 "could not create Tx ring DMA tag.\n");
991 /* Create DMA tag for Rx pages. */
992 for (i = 0; i < ALE_RX_PAGES; i++) {
993 error = bus_dma_tag_create(
994 sc->ale_cdata.ale_parent_tag, /* parent */
995 ALE_RX_PAGE_ALIGN, 0, /* alignment, boundary */
996 BUS_SPACE_MAXADDR, /* lowaddr */
997 BUS_SPACE_MAXADDR, /* highaddr */
998 NULL, NULL, /* filter, filterarg */
999 sc->ale_pagesize, /* maxsize */
1001 sc->ale_pagesize, /* maxsegsize */
1003 &sc->ale_cdata.ale_rx_page[i].page_tag);
1005 device_printf(sc->ale_dev,
1006 "could not create Rx page %d DMA tag.\n", i);
1011 /* Create DMA tag for Tx coalescing message block. */
1012 error = bus_dma_tag_create(
1013 sc->ale_cdata.ale_parent_tag, /* parent */
1014 ALE_CMB_ALIGN, 0, /* alignment, boundary */
1015 BUS_SPACE_MAXADDR, /* lowaddr */
1016 BUS_SPACE_MAXADDR, /* highaddr */
1017 NULL, NULL, /* filter, filterarg */
1018 ALE_TX_CMB_SZ, /* maxsize */
1020 ALE_TX_CMB_SZ, /* maxsegsize */
1022 &sc->ale_cdata.ale_tx_cmb_tag);
1024 device_printf(sc->ale_dev,
1025 "could not create Tx CMB DMA tag.\n");
1029 /* Create DMA tag for Rx coalescing message block. */
1030 for (i = 0; i < ALE_RX_PAGES; i++) {
1031 error = bus_dma_tag_create(
1032 sc->ale_cdata.ale_parent_tag, /* parent */
1033 ALE_CMB_ALIGN, 0, /* alignment, boundary */
1034 BUS_SPACE_MAXADDR, /* lowaddr */
1035 BUS_SPACE_MAXADDR, /* highaddr */
1036 NULL, NULL, /* filter, filterarg */
1037 ALE_RX_CMB_SZ, /* maxsize */
1039 ALE_RX_CMB_SZ, /* maxsegsize */
1041 &sc->ale_cdata.ale_rx_page[i].cmb_tag);
1043 device_printf(sc->ale_dev,
1044 "could not create Rx page %d CMB DMA tag.\n", i);
1049 /* Allocate DMA'able memory and load the DMA map for Tx ring. */
1050 error = bus_dmamem_alloc(sc->ale_cdata.ale_tx_ring_tag,
1051 (void **)&sc->ale_cdata.ale_tx_ring,
1052 BUS_DMA_WAITOK | BUS_DMA_ZERO,
1053 &sc->ale_cdata.ale_tx_ring_map);
1055 device_printf(sc->ale_dev,
1056 "could not allocate DMA'able memory for Tx ring.\n");
1059 ctx.ale_busaddr = 0;
1060 error = bus_dmamap_load(sc->ale_cdata.ale_tx_ring_tag,
1061 sc->ale_cdata.ale_tx_ring_map, sc->ale_cdata.ale_tx_ring,
1062 ALE_TX_RING_SZ, ale_dmamap_cb, &ctx, 0);
1063 if (error != 0 || ctx.ale_busaddr == 0) {
1064 device_printf(sc->ale_dev,
1065 "could not load DMA'able memory for Tx ring.\n");
1068 sc->ale_cdata.ale_tx_ring_paddr = ctx.ale_busaddr;
1071 for (i = 0; i < ALE_RX_PAGES; i++) {
1072 error = bus_dmamem_alloc(sc->ale_cdata.ale_rx_page[i].page_tag,
1073 (void **)&sc->ale_cdata.ale_rx_page[i].page_addr,
1074 BUS_DMA_WAITOK | BUS_DMA_ZERO,
1075 &sc->ale_cdata.ale_rx_page[i].page_map);
1077 device_printf(sc->ale_dev,
1078 "could not allocate DMA'able memory for "
1079 "Rx page %d.\n", i);
1082 ctx.ale_busaddr = 0;
1083 error = bus_dmamap_load(sc->ale_cdata.ale_rx_page[i].page_tag,
1084 sc->ale_cdata.ale_rx_page[i].page_map,
1085 sc->ale_cdata.ale_rx_page[i].page_addr,
1086 sc->ale_pagesize, ale_dmamap_cb, &ctx, 0);
1087 if (error != 0 || ctx.ale_busaddr == 0) {
1088 device_printf(sc->ale_dev,
1089 "could not load DMA'able memory for "
1090 "Rx page %d.\n", i);
1093 sc->ale_cdata.ale_rx_page[i].page_paddr = ctx.ale_busaddr;
1097 error = bus_dmamem_alloc(sc->ale_cdata.ale_tx_cmb_tag,
1098 (void **)&sc->ale_cdata.ale_tx_cmb,
1099 BUS_DMA_WAITOK | BUS_DMA_ZERO,
1100 &sc->ale_cdata.ale_tx_cmb_map);
1102 device_printf(sc->ale_dev,
1103 "could not allocate DMA'able memory for Tx CMB.\n");
1106 ctx.ale_busaddr = 0;
1107 error = bus_dmamap_load(sc->ale_cdata.ale_tx_cmb_tag,
1108 sc->ale_cdata.ale_tx_cmb_map, sc->ale_cdata.ale_tx_cmb,
1109 ALE_TX_CMB_SZ, ale_dmamap_cb, &ctx, 0);
1110 if (error != 0 || ctx.ale_busaddr == 0) {
1111 device_printf(sc->ale_dev,
1112 "could not load DMA'able memory for Tx CMB.\n");
1115 sc->ale_cdata.ale_tx_cmb_paddr = ctx.ale_busaddr;
1118 for (i = 0; i < ALE_RX_PAGES; i++) {
1119 error = bus_dmamem_alloc(sc->ale_cdata.ale_rx_page[i].cmb_tag,
1120 (void **)&sc->ale_cdata.ale_rx_page[i].cmb_addr,
1121 BUS_DMA_WAITOK | BUS_DMA_ZERO,
1122 &sc->ale_cdata.ale_rx_page[i].cmb_map);
1124 device_printf(sc->ale_dev, "could not allocate "
1125 "DMA'able memory for Rx page %d CMB.\n", i);
1128 ctx.ale_busaddr = 0;
1129 error = bus_dmamap_load(sc->ale_cdata.ale_rx_page[i].cmb_tag,
1130 sc->ale_cdata.ale_rx_page[i].cmb_map,
1131 sc->ale_cdata.ale_rx_page[i].cmb_addr,
1132 ALE_RX_CMB_SZ, ale_dmamap_cb, &ctx, 0);
1133 if (error != 0 || ctx.ale_busaddr == 0) {
1134 device_printf(sc->ale_dev, "could not load DMA'able "
1135 "memory for Rx page %d CMB.\n", i);
1138 sc->ale_cdata.ale_rx_page[i].cmb_paddr = ctx.ale_busaddr;
1142 * Tx descriptors/RXF0/CMB DMA blocks share the same
1143 * high address region of 64bit DMA address space.
1145 if (lowaddr != BUS_SPACE_MAXADDR_32BIT &&
1146 (error = ale_check_boundary(sc)) != 0) {
1147 device_printf(sc->ale_dev, "4GB boundary crossed, "
1148 "switching to 32bit DMA addressing mode.\n");
1151 * Limit max allowable DMA address space to 32bit
1154 lowaddr = BUS_SPACE_MAXADDR_32BIT;
1159 * Create Tx buffer parent tag.
1160 * AR81xx allows 64bit DMA addressing of Tx buffers so it
1161 * needs separate parent DMA tag as parent DMA address space
1162 * could be restricted to be within 32bit address space by
1163 * 4GB boundary crossing.
1165 error = bus_dma_tag_create(
1167 1, 0, /* alignment, boundary */
1168 BUS_SPACE_MAXADDR, /* lowaddr */
1169 BUS_SPACE_MAXADDR, /* highaddr */
1170 NULL, NULL, /* filter, filterarg */
1171 BUS_SPACE_MAXSIZE_32BIT, /* maxsize */
1173 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
1175 &sc->ale_cdata.ale_buffer_tag);
1177 device_printf(sc->ale_dev,
1178 "could not create parent buffer DMA tag.\n");
1182 /* Create DMA tag for Tx buffers. */
1183 error = bus_dma_tag_create(
1184 sc->ale_cdata.ale_buffer_tag, /* parent */
1185 1, 0, /* alignment, boundary */
1186 BUS_SPACE_MAXADDR, /* lowaddr */
1187 BUS_SPACE_MAXADDR, /* highaddr */
1188 NULL, NULL, /* filter, filterarg */
1189 ALE_TSO_MAXSIZE, /* maxsize */
1190 ALE_MAXTXSEGS, /* nsegments */
1191 ALE_TSO_MAXSEGSIZE, /* maxsegsize */
1193 &sc->ale_cdata.ale_tx_tag);
1195 device_printf(sc->ale_dev, "could not create Tx DMA tag.\n");
1199 /* Create DMA maps for Tx buffers. */
1200 for (i = 0; i < ALE_TX_RING_CNT; i++) {
1201 txd = &sc->ale_cdata.ale_txdesc[i];
1203 txd->tx_dmamap = NULL;
1204 error = bus_dmamap_create(sc->ale_cdata.ale_tx_tag, 0,
1207 device_printf(sc->ale_dev,
1208 "could not create Tx dmamap.\n");
1217 ale_dma_free(struct ale_softc *sc)
1219 struct ale_txdesc *txd;
1223 if (sc->ale_cdata.ale_tx_tag != NULL) {
1224 for (i = 0; i < ALE_TX_RING_CNT; i++) {
1225 txd = &sc->ale_cdata.ale_txdesc[i];
1226 if (txd->tx_dmamap != NULL) {
1227 bus_dmamap_destroy(sc->ale_cdata.ale_tx_tag,
1229 txd->tx_dmamap = NULL;
1232 bus_dma_tag_destroy(sc->ale_cdata.ale_tx_tag);
1233 sc->ale_cdata.ale_tx_tag = NULL;
1235 /* Tx descriptor ring. */
1236 if (sc->ale_cdata.ale_tx_ring_tag != NULL) {
1237 if (sc->ale_cdata.ale_tx_ring_map != NULL)
1238 bus_dmamap_unload(sc->ale_cdata.ale_tx_ring_tag,
1239 sc->ale_cdata.ale_tx_ring_map);
1240 if (sc->ale_cdata.ale_tx_ring_map != NULL &&
1241 sc->ale_cdata.ale_tx_ring != NULL)
1242 bus_dmamem_free(sc->ale_cdata.ale_tx_ring_tag,
1243 sc->ale_cdata.ale_tx_ring,
1244 sc->ale_cdata.ale_tx_ring_map);
1245 sc->ale_cdata.ale_tx_ring = NULL;
1246 sc->ale_cdata.ale_tx_ring_map = NULL;
1247 bus_dma_tag_destroy(sc->ale_cdata.ale_tx_ring_tag);
1248 sc->ale_cdata.ale_tx_ring_tag = NULL;
1250 /* Rx page block. */
1251 for (i = 0; i < ALE_RX_PAGES; i++) {
1252 if (sc->ale_cdata.ale_rx_page[i].page_tag != NULL) {
1253 if (sc->ale_cdata.ale_rx_page[i].page_map != NULL)
1255 sc->ale_cdata.ale_rx_page[i].page_tag,
1256 sc->ale_cdata.ale_rx_page[i].page_map);
1257 if (sc->ale_cdata.ale_rx_page[i].page_map != NULL &&
1258 sc->ale_cdata.ale_rx_page[i].page_addr != NULL)
1260 sc->ale_cdata.ale_rx_page[i].page_tag,
1261 sc->ale_cdata.ale_rx_page[i].page_addr,
1262 sc->ale_cdata.ale_rx_page[i].page_map);
1263 sc->ale_cdata.ale_rx_page[i].page_addr = NULL;
1264 sc->ale_cdata.ale_rx_page[i].page_map = NULL;
1265 bus_dma_tag_destroy(
1266 sc->ale_cdata.ale_rx_page[i].page_tag);
1267 sc->ale_cdata.ale_rx_page[i].page_tag = NULL;
1271 for (i = 0; i < ALE_RX_PAGES; i++) {
1272 if (sc->ale_cdata.ale_rx_page[i].cmb_tag != NULL) {
1273 if (sc->ale_cdata.ale_rx_page[i].cmb_map != NULL)
1275 sc->ale_cdata.ale_rx_page[i].cmb_tag,
1276 sc->ale_cdata.ale_rx_page[i].cmb_map);
1277 if (sc->ale_cdata.ale_rx_page[i].cmb_map != NULL &&
1278 sc->ale_cdata.ale_rx_page[i].cmb_addr != NULL)
1280 sc->ale_cdata.ale_rx_page[i].cmb_tag,
1281 sc->ale_cdata.ale_rx_page[i].cmb_addr,
1282 sc->ale_cdata.ale_rx_page[i].cmb_map);
1283 sc->ale_cdata.ale_rx_page[i].cmb_addr = NULL;
1284 sc->ale_cdata.ale_rx_page[i].cmb_map = NULL;
1285 bus_dma_tag_destroy(
1286 sc->ale_cdata.ale_rx_page[i].cmb_tag);
1287 sc->ale_cdata.ale_rx_page[i].cmb_tag = NULL;
1291 if (sc->ale_cdata.ale_tx_cmb_tag != NULL) {
1292 if (sc->ale_cdata.ale_tx_cmb_map != NULL)
1293 bus_dmamap_unload(sc->ale_cdata.ale_tx_cmb_tag,
1294 sc->ale_cdata.ale_tx_cmb_map);
1295 if (sc->ale_cdata.ale_tx_cmb_map != NULL &&
1296 sc->ale_cdata.ale_tx_cmb != NULL)
1297 bus_dmamem_free(sc->ale_cdata.ale_tx_cmb_tag,
1298 sc->ale_cdata.ale_tx_cmb,
1299 sc->ale_cdata.ale_tx_cmb_map);
1300 sc->ale_cdata.ale_tx_cmb = NULL;
1301 sc->ale_cdata.ale_tx_cmb_map = NULL;
1302 bus_dma_tag_destroy(sc->ale_cdata.ale_tx_cmb_tag);
1303 sc->ale_cdata.ale_tx_cmb_tag = NULL;
1305 if (sc->ale_cdata.ale_buffer_tag != NULL) {
1306 bus_dma_tag_destroy(sc->ale_cdata.ale_buffer_tag);
1307 sc->ale_cdata.ale_buffer_tag = NULL;
1309 if (sc->ale_cdata.ale_parent_tag != NULL) {
1310 bus_dma_tag_destroy(sc->ale_cdata.ale_parent_tag);
1311 sc->ale_cdata.ale_parent_tag = NULL;
1316 ale_shutdown(device_t dev)
1318 return (ale_suspend(dev));
1324 * Note, this driver resets the link speed to 10/100Mbps by
1325 * restarting auto-negotiation in suspend/shutdown phase but we
1326 * don't know whether that auto-negotiation would succeed or not
1327 * as driver has no control after powering off/suspend operation.
1328 * If the renegotiation fail WOL may not work. Running at 1Gbps
1329 * will draw more power than 375mA at 3.3V which is specified in
1330 * PCI specification and that would result in complete
1331 * shutdowning power to ethernet controller.
1334 * Save current negotiated media speed/duplex/flow-control to
1335 * softc and restore the same link again after resuming. PHY
1336 * handling such as power down/resetting to 100Mbps may be better
1337 * handled in suspend method in phy driver.
1340 ale_setlinkspeed(struct ale_softc *sc)
1342 struct mii_data *mii;
1345 mii = device_get_softc(sc->ale_miibus);
1348 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
1349 (IFM_ACTIVE | IFM_AVALID)) {
1350 switch IFM_SUBTYPE(mii->mii_media_active) {
1361 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr, MII_100T2CR, 0);
1362 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
1363 MII_ANAR, ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10 | ANAR_CSMA);
1364 ale_miibus_writereg(sc->ale_dev, sc->ale_phyaddr,
1365 MII_BMCR, BMCR_RESET | BMCR_AUTOEN | BMCR_STARTNEG);
1369 * Poll link state until ale(4) get a 10/100Mbps link.
1371 for (i = 0; i < MII_ANEGTICKS_GIGE; i++) {
1373 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID))
1374 == (IFM_ACTIVE | IFM_AVALID)) {
1375 switch (IFM_SUBTYPE(
1376 mii->mii_media_active)) {
1386 pause("alelnk", hz);
1389 if (i == MII_ANEGTICKS_GIGE)
1390 device_printf(sc->ale_dev,
1391 "establishing a link failed, WOL may not work!");
1394 * No link, force MAC to have 100Mbps, full-duplex link.
1395 * This is the last resort and may/may not work.
1397 mii->mii_media_status = IFM_AVALID | IFM_ACTIVE;
1398 mii->mii_media_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
1403 ale_setwol(struct ale_softc *sc)
1410 ALE_LOCK_ASSERT(sc);
1412 if (pci_find_extcap(sc->ale_dev, PCIY_PMG, &pmc) != 0) {
1414 CSR_WRITE_4(sc, ALE_WOL_CFG, 0);
1415 reg = CSR_READ_4(sc, ALE_PCIE_PHYMISC);
1416 reg |= PCIE_PHYMISC_FORCE_RCV_DET;
1417 CSR_WRITE_4(sc, ALE_PCIE_PHYMISC, reg);
1418 /* Force PHY power down. */
1419 CSR_WRITE_2(sc, ALE_GPHY_CTRL,
1420 GPHY_CTRL_EXT_RESET | GPHY_CTRL_HIB_EN |
1421 GPHY_CTRL_HIB_PULSE | GPHY_CTRL_PHY_PLL_ON |
1422 GPHY_CTRL_SEL_ANA_RESET | GPHY_CTRL_PHY_IDDQ |
1423 GPHY_CTRL_PCLK_SEL_DIS | GPHY_CTRL_PWDOWN_HW);
1428 if ((ifp->if_capenable & IFCAP_WOL) != 0) {
1429 if ((sc->ale_flags & ALE_FLAG_FASTETHER) == 0)
1430 ale_setlinkspeed(sc);
1434 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
1435 pmcs |= WOL_CFG_MAGIC | WOL_CFG_MAGIC_ENB;
1436 CSR_WRITE_4(sc, ALE_WOL_CFG, pmcs);
1437 reg = CSR_READ_4(sc, ALE_MAC_CFG);
1438 reg &= ~(MAC_CFG_DBG | MAC_CFG_PROMISC | MAC_CFG_ALLMULTI |
1440 if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0)
1441 reg |= MAC_CFG_ALLMULTI | MAC_CFG_BCAST;
1442 if ((ifp->if_capenable & IFCAP_WOL) != 0)
1443 reg |= MAC_CFG_RX_ENB;
1444 CSR_WRITE_4(sc, ALE_MAC_CFG, reg);
1446 if ((ifp->if_capenable & IFCAP_WOL) == 0) {
1447 /* WOL disabled, PHY power down. */
1448 reg = CSR_READ_4(sc, ALE_PCIE_PHYMISC);
1449 reg |= PCIE_PHYMISC_FORCE_RCV_DET;
1450 CSR_WRITE_4(sc, ALE_PCIE_PHYMISC, reg);
1451 CSR_WRITE_2(sc, ALE_GPHY_CTRL,
1452 GPHY_CTRL_EXT_RESET | GPHY_CTRL_HIB_EN |
1453 GPHY_CTRL_HIB_PULSE | GPHY_CTRL_SEL_ANA_RESET |
1454 GPHY_CTRL_PHY_IDDQ | GPHY_CTRL_PCLK_SEL_DIS |
1455 GPHY_CTRL_PWDOWN_HW);
1458 pmstat = pci_read_config(sc->ale_dev, pmc + PCIR_POWER_STATUS, 2);
1459 pmstat &= ~(PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE);
1460 if ((ifp->if_capenable & IFCAP_WOL) != 0)
1461 pmstat |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
1462 pci_write_config(sc->ale_dev, pmc + PCIR_POWER_STATUS, pmstat, 2);
1468 ale_suspend(device_t dev)
1470 struct ale_softc *sc = device_get_softc(dev);
1471 struct ifnet *ifp = &sc->arpcom.ac_if;
1473 lwkt_serialize_enter(ifp->if_serializer);
1478 lwkt_serialize_exit(ifp->if_serializer);
1483 ale_resume(device_t dev)
1485 struct ale_softc *sc = device_get_softc(dev);
1486 struct ifnet *ifp = &sc->arpcom.ac_if;
1489 lwkt_serialize_enter(ifp->if_serializer);
1492 * Clear INTx emulation disable for hardwares that
1493 * is set in resume event. From Linux.
1495 cmd = pci_read_config(sc->ale_dev, PCIR_COMMAND, 2);
1496 if ((cmd & 0x0400) != 0) {
1498 pci_write_config(sc->ale_dev, PCIR_COMMAND, cmd, 2);
1502 if (pci_find_extcap(sc->ale_dev, PCIY_PMG, &pmc) == 0) {
1506 /* Disable PME and clear PME status. */
1507 pmstat = pci_read_config(sc->ale_dev,
1508 pmc + PCIR_POWER_STATUS, 2);
1509 if ((pmstat & PCIM_PSTAT_PMEENABLE) != 0) {
1510 pmstat &= ~PCIM_PSTAT_PMEENABLE;
1511 pci_write_config(sc->ale_dev,
1512 pmc + PCIR_POWER_STATUS, pmstat, 2);
1519 if ((ifp->if_flags & IFF_UP) != 0)
1522 lwkt_serialize_exit(ifp->if_serializer);
1527 ale_encap(struct ale_softc *sc, struct mbuf **m_head)
1529 struct ale_txdesc *txd, *txd_last;
1530 struct tx_desc *desc;
1532 bus_dma_segment_t txsegs[ALE_MAXTXSEGS];
1533 struct ale_dmamap_ctx ctx;
1535 uint32_t cflags, poff, vtag;
1536 int error, i, nsegs, prod, si;
1538 M_ASSERTPKTHDR((*m_head));
1544 si = prod = sc->ale_cdata.ale_tx_prod;
1545 txd = &sc->ale_cdata.ale_txdesc[prod];
1547 map = txd->tx_dmamap;
1549 ctx.nsegs = ALE_MAXTXSEGS;
1551 error = bus_dmamap_load_mbuf(sc->ale_cdata.ale_tx_tag, map,
1552 *m_head, ale_dmamap_buf_cb, &ctx,
1554 if (error == EFBIG) {
1555 m = m_defrag(*m_head, MB_DONTWAIT);
1563 ctx.nsegs = ALE_MAXTXSEGS;
1565 error = bus_dmamap_load_mbuf(sc->ale_cdata.ale_tx_tag, map,
1566 *m_head, ale_dmamap_buf_cb, &ctx,
1573 } else if (error != 0) {
1584 /* Check descriptor overrun. */
1585 if (sc->ale_cdata.ale_tx_cnt + nsegs >= ALE_TX_RING_CNT - 2) {
1586 bus_dmamap_unload(sc->ale_cdata.ale_tx_tag, map);
1589 bus_dmamap_sync(sc->ale_cdata.ale_tx_tag, map, BUS_DMASYNC_PREWRITE);
1592 /* Configure Tx checksum offload. */
1593 if ((m->m_pkthdr.csum_flags & ALE_CSUM_FEATURES) != 0) {
1595 * AR81xx supports Tx custom checksum offload feature
1596 * that offloads single 16bit checksum computation.
1597 * So you can choose one among IP, TCP and UDP.
1598 * Normally driver sets checksum start/insertion
1599 * position from the information of TCP/UDP frame as
1600 * TCP/UDP checksum takes more time than that of IP.
1601 * However it seems that custom checksum offload
1602 * requires 4 bytes aligned Tx buffers due to hardware
1604 * AR81xx also supports explicit Tx checksum computation
1605 * if it is told that the size of IP header and TCP
1606 * header(for UDP, the header size does not matter
1607 * because it's fixed length). However with this scheme
1608 * TSO does not work so you have to choose one either
1609 * TSO or explicit Tx checksum offload. I chosen TSO
1610 * plus custom checksum offload with work-around which
1611 * will cover most common usage for this consumer
1612 * ethernet controller. The work-around takes a lot of
1613 * CPU cycles if Tx buffer is not aligned on 4 bytes
1616 cflags |= ALE_TD_CXSUM;
1617 /* Set checksum start offset. */
1618 cflags |= (poff << ALE_TD_CSUM_PLOADOFFSET_SHIFT);
1619 /* Set checksum insertion position of TCP/UDP. */
1620 cflags |= ((poff + m->m_pkthdr.csum_data) <<
1621 ALE_TD_CSUM_XSUMOFFSET_SHIFT);
1624 /* Configure VLAN hardware tag insertion. */
1625 if ((m->m_flags & M_VLANTAG) != 0) {
1626 vtag = ALE_TX_VLAN_TAG(m->m_pkthdr.ether_vlantag);
1627 vtag = ((vtag << ALE_TD_VLAN_SHIFT) & ALE_TD_VLAN_MASK);
1628 cflags |= ALE_TD_INSERT_VLAN_TAG;
1632 for (i = 0; i < nsegs; i++) {
1633 desc = &sc->ale_cdata.ale_tx_ring[prod];
1634 desc->addr = htole64(txsegs[i].ds_addr);
1635 desc->len = htole32(ALE_TX_BYTES(txsegs[i].ds_len) | vtag);
1636 desc->flags = htole32(cflags);
1637 sc->ale_cdata.ale_tx_cnt++;
1638 ALE_DESC_INC(prod, ALE_TX_RING_CNT);
1640 /* Update producer index. */
1641 sc->ale_cdata.ale_tx_prod = prod;
1643 /* Finally set EOP on the last descriptor. */
1644 prod = (prod + ALE_TX_RING_CNT - 1) % ALE_TX_RING_CNT;
1645 desc = &sc->ale_cdata.ale_tx_ring[prod];
1646 desc->flags |= htole32(ALE_TD_EOP);
1648 /* Swap dmamap of the first and the last. */
1649 txd = &sc->ale_cdata.ale_txdesc[prod];
1650 map = txd_last->tx_dmamap;
1651 txd_last->tx_dmamap = txd->tx_dmamap;
1652 txd->tx_dmamap = map;
1655 /* Sync descriptors. */
1656 bus_dmamap_sync(sc->ale_cdata.ale_tx_ring_tag,
1657 sc->ale_cdata.ale_tx_ring_map, BUS_DMASYNC_PREWRITE);
1663 ale_start(struct ifnet *ifp)
1665 struct ale_softc *sc = ifp->if_softc;
1666 struct mbuf *m_head;
1669 ASSERT_SERIALIZED(ifp->if_serializer);
1671 if ((sc->ale_flags & ALE_FLAG_LINK) == 0) {
1672 ifq_purge(&ifp->if_snd);
1676 if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
1679 /* Reclaim transmitted frames. */
1680 if (sc->ale_cdata.ale_tx_cnt >= ALE_TX_DESC_HIWAT)
1684 while (!ifq_is_empty(&ifp->if_snd)) {
1685 m_head = ifq_dequeue(&ifp->if_snd, NULL);
1690 * Pack the data into the transmit ring. If we
1691 * don't have room, set the OACTIVE flag and wait
1692 * for the NIC to drain the ring.
1694 if (ale_encap(sc, &m_head)) {
1697 ifq_prepend(&ifp->if_snd, m_head);
1698 ifp->if_flags |= IFF_OACTIVE;
1704 * If there's a BPF listener, bounce a copy of this frame
1707 ETHER_BPF_MTAP(ifp, m_head);
1712 CSR_WRITE_4(sc, ALE_MBOX_TPD_PROD_IDX,
1713 sc->ale_cdata.ale_tx_prod);
1715 /* Set a timeout in case the chip goes out to lunch. */
1716 ifp->if_timer = ALE_TX_TIMEOUT;
1721 ale_watchdog(struct ifnet *ifp)
1723 struct ale_softc *sc = ifp->if_softc;
1725 ASSERT_SERIALIZED(ifp->if_serializer);
1727 if ((sc->ale_flags & ALE_FLAG_LINK) == 0) {
1728 if_printf(ifp, "watchdog timeout (lost link)\n");
1734 if_printf(ifp, "watchdog timeout -- resetting\n");
1738 if (!ifq_is_empty(&ifp->if_snd))
1743 ale_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
1745 struct ale_softc *sc;
1747 struct mii_data *mii;
1750 ASSERT_SERIALIZED(ifp->if_serializer);
1753 ifr = (struct ifreq *)data;
1758 if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > ALE_JUMBO_MTU ||
1759 ((sc->ale_flags & ALE_FLAG_JUMBO) == 0 &&
1760 ifr->ifr_mtu > ETHERMTU))
1762 else if (ifp->if_mtu != ifr->ifr_mtu) {
1763 ifp->if_mtu = ifr->ifr_mtu;
1764 if ((ifp->if_flags & IFF_RUNNING) != 0)
1770 if ((ifp->if_flags & IFF_UP) != 0) {
1771 if ((ifp->if_flags & IFF_RUNNING) != 0) {
1772 if (((ifp->if_flags ^ sc->ale_if_flags)
1773 & (IFF_PROMISC | IFF_ALLMULTI)) != 0)
1776 if ((sc->ale_flags & ALE_FLAG_DETACH) == 0)
1780 if ((ifp->if_flags & IFF_RUNNING) != 0)
1783 sc->ale_if_flags = ifp->if_flags;
1788 if ((ifp->if_flags & IFF_RUNNING) != 0)
1794 mii = device_get_softc(sc->ale_miibus);
1795 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
1799 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
1800 if ((mask & IFCAP_TXCSUM) != 0 &&
1801 (ifp->if_capabilities & IFCAP_TXCSUM) != 0) {
1802 ifp->if_capenable ^= IFCAP_TXCSUM;
1803 if ((ifp->if_capenable & IFCAP_TXCSUM) != 0)
1804 ifp->if_hwassist |= ALE_CSUM_FEATURES;
1806 ifp->if_hwassist &= ~ALE_CSUM_FEATURES;
1808 if ((mask & IFCAP_RXCSUM) != 0 &&
1809 (ifp->if_capabilities & IFCAP_RXCSUM) != 0)
1810 ifp->if_capenable ^= IFCAP_RXCSUM;
1812 if ((mask & IFCAP_VLAN_HWTAGGING) != 0 &&
1813 (ifp->if_capabilities & IFCAP_VLAN_HWTAGGING) != 0) {
1814 ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
1820 error = ether_ioctl(ifp, cmd, data);
1827 ale_mac_config(struct ale_softc *sc)
1829 struct mii_data *mii;
1832 mii = device_get_softc(sc->ale_miibus);
1833 reg = CSR_READ_4(sc, ALE_MAC_CFG);
1834 reg &= ~(MAC_CFG_FULL_DUPLEX | MAC_CFG_TX_FC | MAC_CFG_RX_FC |
1835 MAC_CFG_SPEED_MASK);
1836 /* Reprogram MAC with resolved speed/duplex. */
1837 switch (IFM_SUBTYPE(mii->mii_media_active)) {
1840 reg |= MAC_CFG_SPEED_10_100;
1843 reg |= MAC_CFG_SPEED_1000;
1846 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) {
1847 reg |= MAC_CFG_FULL_DUPLEX;
1849 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0)
1850 reg |= MAC_CFG_TX_FC;
1851 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0)
1852 reg |= MAC_CFG_RX_FC;
1855 CSR_WRITE_4(sc, ALE_MAC_CFG, reg);
1859 ale_stats_clear(struct ale_softc *sc)
1865 for (reg = &sb.rx_frames, i = 0; reg <= &sb.rx_pkts_filtered; reg++) {
1866 CSR_READ_4(sc, ALE_RX_MIB_BASE + i);
1867 i += sizeof(uint32_t);
1869 /* Read Tx statistics. */
1870 for (reg = &sb.tx_frames, i = 0; reg <= &sb.tx_mcast_bytes; reg++) {
1871 CSR_READ_4(sc, ALE_TX_MIB_BASE + i);
1872 i += sizeof(uint32_t);
1877 ale_stats_update(struct ale_softc *sc)
1879 struct ale_hw_stats *stat;
1880 struct smb sb, *smb;
1885 ifp = &sc->arpcom.ac_if;
1886 stat = &sc->ale_stats;
1889 /* Read Rx statistics. */
1890 for (reg = &sb.rx_frames, i = 0; reg <= &sb.rx_pkts_filtered; reg++) {
1891 *reg = CSR_READ_4(sc, ALE_RX_MIB_BASE + i);
1892 i += sizeof(uint32_t);
1894 /* Read Tx statistics. */
1895 for (reg = &sb.tx_frames, i = 0; reg <= &sb.tx_mcast_bytes; reg++) {
1896 *reg = CSR_READ_4(sc, ALE_TX_MIB_BASE + i);
1897 i += sizeof(uint32_t);
1901 stat->rx_frames += smb->rx_frames;
1902 stat->rx_bcast_frames += smb->rx_bcast_frames;
1903 stat->rx_mcast_frames += smb->rx_mcast_frames;
1904 stat->rx_pause_frames += smb->rx_pause_frames;
1905 stat->rx_control_frames += smb->rx_control_frames;
1906 stat->rx_crcerrs += smb->rx_crcerrs;
1907 stat->rx_lenerrs += smb->rx_lenerrs;
1908 stat->rx_bytes += smb->rx_bytes;
1909 stat->rx_runts += smb->rx_runts;
1910 stat->rx_fragments += smb->rx_fragments;
1911 stat->rx_pkts_64 += smb->rx_pkts_64;
1912 stat->rx_pkts_65_127 += smb->rx_pkts_65_127;
1913 stat->rx_pkts_128_255 += smb->rx_pkts_128_255;
1914 stat->rx_pkts_256_511 += smb->rx_pkts_256_511;
1915 stat->rx_pkts_512_1023 += smb->rx_pkts_512_1023;
1916 stat->rx_pkts_1024_1518 += smb->rx_pkts_1024_1518;
1917 stat->rx_pkts_1519_max += smb->rx_pkts_1519_max;
1918 stat->rx_pkts_truncated += smb->rx_pkts_truncated;
1919 stat->rx_fifo_oflows += smb->rx_fifo_oflows;
1920 stat->rx_rrs_errs += smb->rx_rrs_errs;
1921 stat->rx_alignerrs += smb->rx_alignerrs;
1922 stat->rx_bcast_bytes += smb->rx_bcast_bytes;
1923 stat->rx_mcast_bytes += smb->rx_mcast_bytes;
1924 stat->rx_pkts_filtered += smb->rx_pkts_filtered;
1927 stat->tx_frames += smb->tx_frames;
1928 stat->tx_bcast_frames += smb->tx_bcast_frames;
1929 stat->tx_mcast_frames += smb->tx_mcast_frames;
1930 stat->tx_pause_frames += smb->tx_pause_frames;
1931 stat->tx_excess_defer += smb->tx_excess_defer;
1932 stat->tx_control_frames += smb->tx_control_frames;
1933 stat->tx_deferred += smb->tx_deferred;
1934 stat->tx_bytes += smb->tx_bytes;
1935 stat->tx_pkts_64 += smb->tx_pkts_64;
1936 stat->tx_pkts_65_127 += smb->tx_pkts_65_127;
1937 stat->tx_pkts_128_255 += smb->tx_pkts_128_255;
1938 stat->tx_pkts_256_511 += smb->tx_pkts_256_511;
1939 stat->tx_pkts_512_1023 += smb->tx_pkts_512_1023;
1940 stat->tx_pkts_1024_1518 += smb->tx_pkts_1024_1518;
1941 stat->tx_pkts_1519_max += smb->tx_pkts_1519_max;
1942 stat->tx_single_colls += smb->tx_single_colls;
1943 stat->tx_multi_colls += smb->tx_multi_colls;
1944 stat->tx_late_colls += smb->tx_late_colls;
1945 stat->tx_excess_colls += smb->tx_excess_colls;
1946 stat->tx_abort += smb->tx_abort;
1947 stat->tx_underrun += smb->tx_underrun;
1948 stat->tx_desc_underrun += smb->tx_desc_underrun;
1949 stat->tx_lenerrs += smb->tx_lenerrs;
1950 stat->tx_pkts_truncated += smb->tx_pkts_truncated;
1951 stat->tx_bcast_bytes += smb->tx_bcast_bytes;
1952 stat->tx_mcast_bytes += smb->tx_mcast_bytes;
1954 /* Update counters in ifnet. */
1955 ifp->if_opackets += smb->tx_frames;
1957 ifp->if_collisions += smb->tx_single_colls +
1958 smb->tx_multi_colls * 2 + smb->tx_late_colls +
1959 smb->tx_abort * HDPX_CFG_RETRY_DEFAULT;
1963 * tx_pkts_truncated counter looks suspicious. It constantly
1964 * increments with no sign of Tx errors. This may indicate
1965 * the counter name is not correct one so I've removed the
1966 * counter in output errors.
1968 ifp->if_oerrors += smb->tx_abort + smb->tx_late_colls +
1971 ifp->if_ipackets += smb->rx_frames;
1973 ifp->if_ierrors += smb->rx_crcerrs + smb->rx_lenerrs +
1974 smb->rx_runts + smb->rx_pkts_truncated +
1975 smb->rx_fifo_oflows + smb->rx_rrs_errs +
1982 struct ale_softc *sc = xsc;
1983 struct ifnet *ifp = &sc->arpcom.ac_if;
1986 ASSERT_SERIALIZED(ifp->if_serializer);
1988 status = CSR_READ_4(sc, ALE_INTR_STATUS);
1989 if ((status & ALE_INTRS) == 0)
1992 /* Acknowledge and disable interrupts. */
1993 CSR_WRITE_4(sc, ALE_INTR_STATUS, status | INTR_DIS_INT);
1995 if ((ifp->if_flags & IFF_RUNNING) != 0) {
1998 error = ale_rxeof(sc);
2000 sc->ale_stats.reset_brk_seq++;
2005 if ((status & (INTR_DMA_RD_TO_RST | INTR_DMA_WR_TO_RST)) != 0) {
2006 if ((status & INTR_DMA_RD_TO_RST) != 0)
2007 device_printf(sc->ale_dev,
2008 "DMA read error! -- resetting\n");
2009 if ((status & INTR_DMA_WR_TO_RST) != 0)
2010 device_printf(sc->ale_dev,
2011 "DMA write error! -- resetting\n");
2017 if (!ifq_is_empty(&ifp->if_snd))
2021 /* Re-enable interrupts. */
2022 CSR_WRITE_4(sc, ALE_INTR_STATUS, 0x7FFFFFFF);
2026 ale_txeof(struct ale_softc *sc)
2028 struct ifnet *ifp = &sc->arpcom.ac_if;
2029 struct ale_txdesc *txd;
2030 uint32_t cons, prod;
2033 if (sc->ale_cdata.ale_tx_cnt == 0)
2036 bus_dmamap_sync(sc->ale_cdata.ale_tx_ring_tag,
2037 sc->ale_cdata.ale_tx_ring_map, BUS_DMASYNC_POSTREAD);
2038 if ((sc->ale_flags & ALE_FLAG_TXCMB_BUG) == 0) {
2039 bus_dmamap_sync(sc->ale_cdata.ale_tx_cmb_tag,
2040 sc->ale_cdata.ale_tx_cmb_map, BUS_DMASYNC_POSTREAD);
2041 prod = *sc->ale_cdata.ale_tx_cmb & TPD_CNT_MASK;
2043 prod = CSR_READ_2(sc, ALE_TPD_CONS_IDX);
2044 cons = sc->ale_cdata.ale_tx_cons;
2046 * Go through our Tx list and free mbufs for those
2047 * frames which have been transmitted.
2049 for (prog = 0; cons != prod; prog++,
2050 ALE_DESC_INC(cons, ALE_TX_RING_CNT)) {
2051 if (sc->ale_cdata.ale_tx_cnt <= 0)
2054 ifp->if_flags &= ~IFF_OACTIVE;
2055 sc->ale_cdata.ale_tx_cnt--;
2056 txd = &sc->ale_cdata.ale_txdesc[cons];
2057 if (txd->tx_m != NULL) {
2058 /* Reclaim transmitted mbufs. */
2059 bus_dmamap_unload(sc->ale_cdata.ale_tx_tag,
2067 sc->ale_cdata.ale_tx_cons = cons;
2069 * Unarm watchdog timer only when there is no pending
2070 * Tx descriptors in queue.
2072 if (sc->ale_cdata.ale_tx_cnt == 0)
2078 ale_rx_update_page(struct ale_softc *sc, struct ale_rx_page **page,
2079 uint32_t length, uint32_t *prod)
2081 struct ale_rx_page *rx_page;
2084 /* Update consumer position. */
2085 rx_page->cons += roundup(length + sizeof(struct rx_rs),
2087 if (rx_page->cons >= ALE_RX_PAGE_SZ) {
2089 * End of Rx page reached, let hardware reuse
2093 *rx_page->cmb_addr = 0;
2094 bus_dmamap_sync(rx_page->cmb_tag, rx_page->cmb_map,
2095 BUS_DMASYNC_PREWRITE);
2096 CSR_WRITE_1(sc, ALE_RXF0_PAGE0 + sc->ale_cdata.ale_rx_curp,
2098 /* Switch to alternate Rx page. */
2099 sc->ale_cdata.ale_rx_curp ^= 1;
2101 &sc->ale_cdata.ale_rx_page[sc->ale_cdata.ale_rx_curp];
2102 /* Page flipped, sync CMB and Rx page. */
2103 bus_dmamap_sync(rx_page->page_tag, rx_page->page_map,
2104 BUS_DMASYNC_POSTREAD);
2105 bus_dmamap_sync(rx_page->cmb_tag, rx_page->cmb_map,
2106 BUS_DMASYNC_POSTREAD);
2107 /* Sync completed, cache updated producer index. */
2108 *prod = *rx_page->cmb_addr;
2114 * It seems that AR81xx controller can compute partial checksum.
2115 * The partial checksum value can be used to accelerate checksum
2116 * computation for fragmented TCP/UDP packets. Upper network stack
2117 * already takes advantage of the partial checksum value in IP
2118 * reassembly stage. But I'm not sure the correctness of the
2119 * partial hardware checksum assistance due to lack of data sheet.
2120 * In addition, the Rx feature of controller that requires copying
2121 * for every frames effectively nullifies one of most nice offload
2122 * capability of controller.
2125 ale_rxcsum(struct ale_softc *sc, struct mbuf *m, uint32_t status)
2127 struct ifnet *ifp = &sc->arpcom.ac_if;
2131 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
2132 if ((status & ALE_RD_IPCSUM_NOK) == 0)
2133 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
2135 if ((sc->ale_flags & ALE_FLAG_RXCSUM_BUG) == 0) {
2136 if (((status & ALE_RD_IPV4_FRAG) == 0) &&
2137 ((status & (ALE_RD_TCP | ALE_RD_UDP)) != 0) &&
2138 ((status & ALE_RD_TCP_UDPCSUM_NOK) == 0)) {
2139 m->m_pkthdr.csum_flags |=
2140 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
2141 m->m_pkthdr.csum_data = 0xffff;
2144 if ((status & (ALE_RD_TCP | ALE_RD_UDP)) != 0 &&
2145 (status & ALE_RD_TCP_UDPCSUM_NOK) == 0) {
2146 p = mtod(m, char *);
2148 if ((status & ALE_RD_802_3) != 0)
2149 p += LLC_SNAPFRAMELEN;
2150 if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == 0 &&
2151 (status & ALE_RD_VLAN) != 0)
2153 ip = (struct ip *)p;
2154 if (ip->ip_off != 0 && (status & ALE_RD_IPV4_DF) == 0)
2156 m->m_pkthdr.csum_flags |= CSUM_DATA_VALID |
2158 m->m_pkthdr.csum_data = 0xffff;
2162 * Don't mark bad checksum for TCP/UDP frames
2163 * as fragmented frames may always have set
2164 * bad checksummed bit of frame status.
2168 /* Process received frames. */
2170 ale_rxeof(struct ale_softc *sc)
2172 struct ifnet *ifp = &sc->arpcom.ac_if;
2173 struct ale_rx_page *rx_page;
2176 uint32_t length, prod, seqno, status, vtags;
2179 rx_page = &sc->ale_cdata.ale_rx_page[sc->ale_cdata.ale_rx_curp];
2180 bus_dmamap_sync(rx_page->cmb_tag, rx_page->cmb_map,
2181 BUS_DMASYNC_POSTREAD);
2182 bus_dmamap_sync(rx_page->page_tag, rx_page->page_map,
2183 BUS_DMASYNC_POSTREAD);
2185 * Don't directly access producer index as hardware may
2186 * update it while Rx handler is in progress. It would
2187 * be even better if there is a way to let hardware
2188 * know how far driver processed its received frames.
2189 * Alternatively, hardware could provide a way to disable
2190 * CMB updates until driver acknowledges the end of CMB
2193 prod = *rx_page->cmb_addr;
2194 for (prog = 0; ; prog++) {
2195 if (rx_page->cons >= prod)
2197 rs = (struct rx_rs *)(rx_page->page_addr + rx_page->cons);
2198 seqno = ALE_RX_SEQNO(le32toh(rs->seqno));
2199 if (sc->ale_cdata.ale_rx_seqno != seqno) {
2201 * Normally I believe this should not happen unless
2202 * severe driver bug or corrupted memory. However
2203 * it seems to happen under certain conditions which
2204 * is triggered by abrupt Rx events such as initiation
2205 * of bulk transfer of remote host. It's not easy to
2206 * reproduce this and I doubt it could be related
2207 * with FIFO overflow of hardware or activity of Tx
2208 * CMB updates. I also remember similar behaviour
2209 * seen on RealTek 8139 which uses resembling Rx
2213 device_printf(sc->ale_dev,
2214 "garbled seq: %u, expected: %u -- "
2215 "resetting!\n", seqno,
2216 sc->ale_cdata.ale_rx_seqno);
2219 /* Frame received. */
2220 sc->ale_cdata.ale_rx_seqno++;
2221 length = ALE_RX_BYTES(le32toh(rs->length));
2222 status = le32toh(rs->flags);
2223 if ((status & ALE_RD_ERROR) != 0) {
2225 * We want to pass the following frames to upper
2226 * layer regardless of error status of Rx return
2229 * o IP/TCP/UDP checksum is bad.
2230 * o frame length and protocol specific length
2233 if ((status & (ALE_RD_CRC | ALE_RD_CODE |
2234 ALE_RD_DRIBBLE | ALE_RD_RUNT | ALE_RD_OFLOW |
2235 ALE_RD_TRUNC)) != 0) {
2236 ale_rx_update_page(sc, &rx_page, length, &prod);
2241 * m_devget(9) is major bottle-neck of ale(4)(It comes
2242 * from hardware limitation). For jumbo frames we could
2243 * get a slightly better performance if driver use
2244 * m_getjcl(9) with proper buffer size argument. However
2245 * that would make code more complicated and I don't
2246 * think users would expect good Rx performance numbers
2247 * on these low-end consumer ethernet controller.
2249 m = m_devget((char *)(rs + 1), length - ETHER_CRC_LEN,
2250 ETHER_ALIGN, ifp, NULL);
2253 ale_rx_update_page(sc, &rx_page, length, &prod);
2256 if ((ifp->if_capenable & IFCAP_RXCSUM) != 0 &&
2257 (status & ALE_RD_IPV4) != 0)
2258 ale_rxcsum(sc, m, status);
2259 if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0 &&
2260 (status & ALE_RD_VLAN) != 0) {
2261 vtags = ALE_RX_VLAN(le32toh(rs->vtags));
2262 m->m_pkthdr.ether_vlantag = ALE_RX_VLAN_TAG(vtags);
2263 m->m_flags |= M_VLANTAG;
2266 /* Pass it to upper layer. */
2267 ifp->if_input(ifp, m);
2269 ale_rx_update_page(sc, &rx_page, length, &prod);
2277 struct ale_softc *sc = xsc;
2278 struct ifnet *ifp = &sc->arpcom.ac_if;
2279 struct mii_data *mii;
2281 lwkt_serialize_enter(ifp->if_serializer);
2283 mii = device_get_softc(sc->ale_miibus);
2285 ale_stats_update(sc);
2287 callout_reset(&sc->ale_tick_ch, hz, ale_tick, sc);
2289 lwkt_serialize_exit(ifp->if_serializer);
2293 ale_reset(struct ale_softc *sc)
2298 /* Initialize PCIe module. From Linux. */
2299 CSR_WRITE_4(sc, 0x1008, CSR_READ_4(sc, 0x1008) | 0x8000);
2301 CSR_WRITE_4(sc, ALE_MASTER_CFG, MASTER_RESET);
2302 for (i = ALE_RESET_TIMEOUT; i > 0; i--) {
2304 if ((CSR_READ_4(sc, ALE_MASTER_CFG) & MASTER_RESET) == 0)
2308 device_printf(sc->ale_dev, "master reset timeout!\n");
2310 for (i = ALE_RESET_TIMEOUT; i > 0; i--) {
2311 if ((reg = CSR_READ_4(sc, ALE_IDLE_STATUS)) == 0)
2317 device_printf(sc->ale_dev, "reset timeout(0x%08x)!\n", reg);
2323 struct ale_softc *sc = xsc;
2324 struct ifnet *ifp = &sc->arpcom.ac_if;
2325 struct mii_data *mii;
2326 uint8_t eaddr[ETHER_ADDR_LEN];
2328 uint32_t reg, rxf_hi, rxf_lo;
2330 ASSERT_SERIALIZED(ifp->if_serializer);
2332 mii = device_get_softc(sc->ale_miibus);
2335 * Cancel any pending I/O.
2340 * Reset the chip to a known state.
2344 /* Initialize Tx descriptors, DMA memory blocks. */
2345 ale_init_rx_pages(sc);
2346 ale_init_tx_ring(sc);
2348 /* Reprogram the station address. */
2349 bcopy(IF_LLADDR(ifp), eaddr, ETHER_ADDR_LEN);
2350 CSR_WRITE_4(sc, ALE_PAR0,
2351 eaddr[2] << 24 | eaddr[3] << 16 | eaddr[4] << 8 | eaddr[5]);
2352 CSR_WRITE_4(sc, ALE_PAR1, eaddr[0] << 8 | eaddr[1]);
2355 * Clear WOL status and disable all WOL feature as WOL
2356 * would interfere Rx operation under normal environments.
2358 CSR_READ_4(sc, ALE_WOL_CFG);
2359 CSR_WRITE_4(sc, ALE_WOL_CFG, 0);
2362 * Set Tx descriptor/RXF0/CMB base addresses. They share
2363 * the same high address part of DMAable region.
2365 paddr = sc->ale_cdata.ale_tx_ring_paddr;
2366 CSR_WRITE_4(sc, ALE_TPD_ADDR_HI, ALE_ADDR_HI(paddr));
2367 CSR_WRITE_4(sc, ALE_TPD_ADDR_LO, ALE_ADDR_LO(paddr));
2368 CSR_WRITE_4(sc, ALE_TPD_CNT,
2369 (ALE_TX_RING_CNT << TPD_CNT_SHIFT) & TPD_CNT_MASK);
2371 /* Set Rx page base address, note we use single queue. */
2372 paddr = sc->ale_cdata.ale_rx_page[0].page_paddr;
2373 CSR_WRITE_4(sc, ALE_RXF0_PAGE0_ADDR_LO, ALE_ADDR_LO(paddr));
2374 paddr = sc->ale_cdata.ale_rx_page[1].page_paddr;
2375 CSR_WRITE_4(sc, ALE_RXF0_PAGE1_ADDR_LO, ALE_ADDR_LO(paddr));
2377 /* Set Tx/Rx CMB addresses. */
2378 paddr = sc->ale_cdata.ale_tx_cmb_paddr;
2379 CSR_WRITE_4(sc, ALE_TX_CMB_ADDR_LO, ALE_ADDR_LO(paddr));
2380 paddr = sc->ale_cdata.ale_rx_page[0].cmb_paddr;
2381 CSR_WRITE_4(sc, ALE_RXF0_CMB0_ADDR_LO, ALE_ADDR_LO(paddr));
2382 paddr = sc->ale_cdata.ale_rx_page[1].cmb_paddr;
2383 CSR_WRITE_4(sc, ALE_RXF0_CMB1_ADDR_LO, ALE_ADDR_LO(paddr));
2385 /* Mark RXF0 is valid. */
2386 CSR_WRITE_1(sc, ALE_RXF0_PAGE0, RXF_VALID);
2387 CSR_WRITE_1(sc, ALE_RXF0_PAGE1, RXF_VALID);
2389 * No need to initialize RFX1/RXF2/RXF3. We don't use
2393 /* Set Rx page size, excluding guard frame size. */
2394 CSR_WRITE_4(sc, ALE_RXF_PAGE_SIZE, ALE_RX_PAGE_SZ);
2396 /* Tell hardware that we're ready to load DMA blocks. */
2397 CSR_WRITE_4(sc, ALE_DMA_BLOCK, DMA_BLOCK_LOAD);
2399 /* Set Rx/Tx interrupt trigger threshold. */
2400 CSR_WRITE_4(sc, ALE_INT_TRIG_THRESH, (1 << INT_TRIG_RX_THRESH_SHIFT) |
2401 (4 << INT_TRIG_TX_THRESH_SHIFT));
2404 * Set interrupt trigger timer, its purpose and relation
2405 * with interrupt moderation mechanism is not clear yet.
2407 CSR_WRITE_4(sc, ALE_INT_TRIG_TIMER,
2408 ((ALE_USECS(10) << INT_TRIG_RX_TIMER_SHIFT) |
2409 (ALE_USECS(1000) << INT_TRIG_TX_TIMER_SHIFT)));
2411 /* Configure interrupt moderation timer. */
2412 reg = ALE_USECS(sc->ale_int_rx_mod) << IM_TIMER_RX_SHIFT;
2413 reg |= ALE_USECS(sc->ale_int_tx_mod) << IM_TIMER_TX_SHIFT;
2414 CSR_WRITE_4(sc, ALE_IM_TIMER, reg);
2415 reg = CSR_READ_4(sc, ALE_MASTER_CFG);
2416 reg &= ~(MASTER_CHIP_REV_MASK | MASTER_CHIP_ID_MASK);
2417 reg &= ~(MASTER_IM_RX_TIMER_ENB | MASTER_IM_TX_TIMER_ENB);
2418 if (ALE_USECS(sc->ale_int_rx_mod) != 0)
2419 reg |= MASTER_IM_RX_TIMER_ENB;
2420 if (ALE_USECS(sc->ale_int_tx_mod) != 0)
2421 reg |= MASTER_IM_TX_TIMER_ENB;
2422 CSR_WRITE_4(sc, ALE_MASTER_CFG, reg);
2423 CSR_WRITE_2(sc, ALE_INTR_CLR_TIMER, ALE_USECS(1000));
2425 /* Set Maximum frame size of controller. */
2426 if (ifp->if_mtu < ETHERMTU)
2427 sc->ale_max_frame_size = ETHERMTU;
2429 sc->ale_max_frame_size = ifp->if_mtu;
2430 sc->ale_max_frame_size += ETHER_HDR_LEN + EVL_ENCAPLEN + ETHER_CRC_LEN;
2431 CSR_WRITE_4(sc, ALE_FRAME_SIZE, sc->ale_max_frame_size);
2433 /* Configure IPG/IFG parameters. */
2434 CSR_WRITE_4(sc, ALE_IPG_IFG_CFG,
2435 ((IPG_IFG_IPGT_DEFAULT << IPG_IFG_IPGT_SHIFT) & IPG_IFG_IPGT_MASK) |
2436 ((IPG_IFG_MIFG_DEFAULT << IPG_IFG_MIFG_SHIFT) & IPG_IFG_MIFG_MASK) |
2437 ((IPG_IFG_IPG1_DEFAULT << IPG_IFG_IPG1_SHIFT) & IPG_IFG_IPG1_MASK) |
2438 ((IPG_IFG_IPG2_DEFAULT << IPG_IFG_IPG2_SHIFT) & IPG_IFG_IPG2_MASK));
2440 /* Set parameters for half-duplex media. */
2441 CSR_WRITE_4(sc, ALE_HDPX_CFG,
2442 ((HDPX_CFG_LCOL_DEFAULT << HDPX_CFG_LCOL_SHIFT) &
2443 HDPX_CFG_LCOL_MASK) |
2444 ((HDPX_CFG_RETRY_DEFAULT << HDPX_CFG_RETRY_SHIFT) &
2445 HDPX_CFG_RETRY_MASK) | HDPX_CFG_EXC_DEF_EN |
2446 ((HDPX_CFG_ABEBT_DEFAULT << HDPX_CFG_ABEBT_SHIFT) &
2447 HDPX_CFG_ABEBT_MASK) |
2448 ((HDPX_CFG_JAMIPG_DEFAULT << HDPX_CFG_JAMIPG_SHIFT) &
2449 HDPX_CFG_JAMIPG_MASK));
2451 /* Configure Tx jumbo frame parameters. */
2452 if ((sc->ale_flags & ALE_FLAG_JUMBO) != 0) {
2453 if (ifp->if_mtu < ETHERMTU)
2454 reg = sc->ale_max_frame_size;
2455 else if (ifp->if_mtu < 6 * 1024)
2456 reg = (sc->ale_max_frame_size * 2) / 3;
2458 reg = sc->ale_max_frame_size / 2;
2459 CSR_WRITE_4(sc, ALE_TX_JUMBO_THRESH,
2460 roundup(reg, TX_JUMBO_THRESH_UNIT) >>
2461 TX_JUMBO_THRESH_UNIT_SHIFT);
2464 /* Configure TxQ. */
2465 reg = (128 << (sc->ale_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT))
2466 << TXQ_CFG_TX_FIFO_BURST_SHIFT;
2467 reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
2468 TXQ_CFG_TPD_BURST_MASK;
2469 CSR_WRITE_4(sc, ALE_TXQ_CFG, reg | TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB);
2471 /* Configure Rx jumbo frame & flow control parameters. */
2472 if ((sc->ale_flags & ALE_FLAG_JUMBO) != 0) {
2473 reg = roundup(sc->ale_max_frame_size, RX_JUMBO_THRESH_UNIT);
2474 CSR_WRITE_4(sc, ALE_RX_JUMBO_THRESH,
2475 (((reg >> RX_JUMBO_THRESH_UNIT_SHIFT) <<
2476 RX_JUMBO_THRESH_MASK_SHIFT) & RX_JUMBO_THRESH_MASK) |
2477 ((RX_JUMBO_LKAH_DEFAULT << RX_JUMBO_LKAH_SHIFT) &
2478 RX_JUMBO_LKAH_MASK));
2479 reg = CSR_READ_4(sc, ALE_SRAM_RX_FIFO_LEN);
2480 rxf_hi = (reg * 7) / 10;
2481 rxf_lo = (reg * 3)/ 10;
2482 CSR_WRITE_4(sc, ALE_RX_FIFO_PAUSE_THRESH,
2483 ((rxf_lo << RX_FIFO_PAUSE_THRESH_LO_SHIFT) &
2484 RX_FIFO_PAUSE_THRESH_LO_MASK) |
2485 ((rxf_hi << RX_FIFO_PAUSE_THRESH_HI_SHIFT) &
2486 RX_FIFO_PAUSE_THRESH_HI_MASK));
2490 CSR_WRITE_4(sc, ALE_RSS_IDT_TABLE0, 0);
2491 CSR_WRITE_4(sc, ALE_RSS_CPU, 0);
2493 /* Configure RxQ. */
2494 CSR_WRITE_4(sc, ALE_RXQ_CFG,
2495 RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB | RXQ_CFG_ENB);
2497 /* Configure DMA parameters. */
2499 if ((sc->ale_flags & ALE_FLAG_TXCMB_BUG) == 0)
2500 reg |= DMA_CFG_TXCMB_ENB;
2501 CSR_WRITE_4(sc, ALE_DMA_CFG,
2502 DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2503 sc->ale_dma_rd_burst | reg |
2504 sc->ale_dma_wr_burst | DMA_CFG_RXCMB_ENB |
2505 ((DMA_CFG_RD_DELAY_CNT_DEFAULT << DMA_CFG_RD_DELAY_CNT_SHIFT) &
2506 DMA_CFG_RD_DELAY_CNT_MASK) |
2507 ((DMA_CFG_WR_DELAY_CNT_DEFAULT << DMA_CFG_WR_DELAY_CNT_SHIFT) &
2508 DMA_CFG_WR_DELAY_CNT_MASK));
2511 * Hardware can be configured to issue SMB interrupt based
2512 * on programmed interval. Since there is a callout that is
2513 * invoked for every hz in driver we use that instead of
2514 * relying on periodic SMB interrupt.
2516 CSR_WRITE_4(sc, ALE_SMB_STAT_TIMER, ALE_USECS(0));
2518 /* Clear MAC statistics. */
2519 ale_stats_clear(sc);
2522 * Configure Tx/Rx MACs.
2523 * - Auto-padding for short frames.
2524 * - Enable CRC generation.
2525 * Actual reconfiguration of MAC for resolved speed/duplex
2526 * is followed after detection of link establishment.
2527 * AR81xx always does checksum computation regardless of
2528 * MAC_CFG_RXCSUM_ENB bit. In fact, setting the bit will
2529 * cause Rx handling issue for fragmented IP datagrams due
2532 reg = MAC_CFG_TX_CRC_ENB | MAC_CFG_TX_AUTO_PAD | MAC_CFG_FULL_DUPLEX |
2533 ((MAC_CFG_PREAMBLE_DEFAULT << MAC_CFG_PREAMBLE_SHIFT) &
2534 MAC_CFG_PREAMBLE_MASK);
2535 if ((sc->ale_flags & ALE_FLAG_FASTETHER) != 0)
2536 reg |= MAC_CFG_SPEED_10_100;
2538 reg |= MAC_CFG_SPEED_1000;
2539 CSR_WRITE_4(sc, ALE_MAC_CFG, reg);
2541 /* Set up the receive filter. */
2545 /* Acknowledge all pending interrupts and clear it. */
2546 CSR_WRITE_4(sc, ALE_INTR_MASK, ALE_INTRS);
2547 CSR_WRITE_4(sc, ALE_INTR_STATUS, 0xFFFFFFFF);
2548 CSR_WRITE_4(sc, ALE_INTR_STATUS, 0);
2550 sc->ale_flags &= ~ALE_FLAG_LINK;
2552 /* Switch to the current media. */
2555 callout_reset(&sc->ale_tick_ch, hz, ale_tick, sc);
2557 ifp->if_flags |= IFF_RUNNING;
2558 ifp->if_flags &= ~IFF_OACTIVE;
2562 ale_stop(struct ale_softc *sc)
2564 struct ifnet *ifp = &sc->arpcom.ac_if;
2565 struct ale_txdesc *txd;
2569 ASSERT_SERIALIZED(ifp->if_serializer);
2572 * Mark the interface down and cancel the watchdog timer.
2574 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2577 callout_stop(&sc->ale_tick_ch);
2578 sc->ale_flags &= ~ALE_FLAG_LINK;
2580 ale_stats_update(sc);
2582 /* Disable interrupts. */
2583 CSR_WRITE_4(sc, ALE_INTR_MASK, 0);
2584 CSR_WRITE_4(sc, ALE_INTR_STATUS, 0xFFFFFFFF);
2586 /* Disable queue processing and DMA. */
2587 reg = CSR_READ_4(sc, ALE_TXQ_CFG);
2588 reg &= ~TXQ_CFG_ENB;
2589 CSR_WRITE_4(sc, ALE_TXQ_CFG, reg);
2590 reg = CSR_READ_4(sc, ALE_RXQ_CFG);
2591 reg &= ~RXQ_CFG_ENB;
2592 CSR_WRITE_4(sc, ALE_RXQ_CFG, reg);
2593 reg = CSR_READ_4(sc, ALE_DMA_CFG);
2594 reg &= ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB);
2595 CSR_WRITE_4(sc, ALE_DMA_CFG, reg);
2598 /* Stop Rx/Tx MACs. */
2601 /* Disable interrupts again? XXX */
2602 CSR_WRITE_4(sc, ALE_INTR_STATUS, 0xFFFFFFFF);
2605 * Free TX mbufs still in the queues.
2607 for (i = 0; i < ALE_TX_RING_CNT; i++) {
2608 txd = &sc->ale_cdata.ale_txdesc[i];
2609 if (txd->tx_m != NULL) {
2610 bus_dmamap_unload(sc->ale_cdata.ale_tx_tag,
2619 ale_stop_mac(struct ale_softc *sc)
2624 reg = CSR_READ_4(sc, ALE_MAC_CFG);
2625 if ((reg & (MAC_CFG_TX_ENB | MAC_CFG_RX_ENB)) != 0) {
2626 reg &= ~MAC_CFG_TX_ENB | MAC_CFG_RX_ENB;
2627 CSR_WRITE_4(sc, ALE_MAC_CFG, reg);
2630 for (i = ALE_TIMEOUT; i > 0; i--) {
2631 reg = CSR_READ_4(sc, ALE_IDLE_STATUS);
2637 device_printf(sc->ale_dev,
2638 "could not disable Tx/Rx MAC(0x%08x)!\n", reg);
2642 ale_init_tx_ring(struct ale_softc *sc)
2644 struct ale_txdesc *txd;
2647 sc->ale_cdata.ale_tx_prod = 0;
2648 sc->ale_cdata.ale_tx_cons = 0;
2649 sc->ale_cdata.ale_tx_cnt = 0;
2651 bzero(sc->ale_cdata.ale_tx_ring, ALE_TX_RING_SZ);
2652 bzero(sc->ale_cdata.ale_tx_cmb, ALE_TX_CMB_SZ);
2653 for (i = 0; i < ALE_TX_RING_CNT; i++) {
2654 txd = &sc->ale_cdata.ale_txdesc[i];
2657 *sc->ale_cdata.ale_tx_cmb = 0;
2658 bus_dmamap_sync(sc->ale_cdata.ale_tx_cmb_tag,
2659 sc->ale_cdata.ale_tx_cmb_map,
2660 BUS_DMASYNC_PREWRITE);
2661 bus_dmamap_sync(sc->ale_cdata.ale_tx_ring_tag,
2662 sc->ale_cdata.ale_tx_ring_map,
2663 BUS_DMASYNC_PREWRITE);
2667 ale_init_rx_pages(struct ale_softc *sc)
2669 struct ale_rx_page *rx_page;
2672 sc->ale_cdata.ale_rx_seqno = 0;
2673 sc->ale_cdata.ale_rx_curp = 0;
2675 for (i = 0; i < ALE_RX_PAGES; i++) {
2676 rx_page = &sc->ale_cdata.ale_rx_page[i];
2677 bzero(rx_page->page_addr, sc->ale_pagesize);
2678 bzero(rx_page->cmb_addr, ALE_RX_CMB_SZ);
2680 *rx_page->cmb_addr = 0;
2681 bus_dmamap_sync(rx_page->page_tag, rx_page->page_map,
2682 BUS_DMASYNC_PREWRITE);
2683 bus_dmamap_sync(rx_page->cmb_tag, rx_page->cmb_map,
2684 BUS_DMASYNC_PREWRITE);
2689 ale_rxvlan(struct ale_softc *sc)
2694 ifp = &sc->arpcom.ac_if;
2695 reg = CSR_READ_4(sc, ALE_MAC_CFG);
2696 reg &= ~MAC_CFG_VLAN_TAG_STRIP;
2697 if ((ifp->if_capenable & IFCAP_VLAN_HWTAGGING) != 0)
2698 reg |= MAC_CFG_VLAN_TAG_STRIP;
2699 CSR_WRITE_4(sc, ALE_MAC_CFG, reg);
2703 ale_rxfilter(struct ale_softc *sc)
2706 struct ifmultiaddr *ifma;
2711 ifp = &sc->arpcom.ac_if;
2713 rxcfg = CSR_READ_4(sc, ALE_MAC_CFG);
2714 rxcfg &= ~(MAC_CFG_ALLMULTI | MAC_CFG_BCAST | MAC_CFG_PROMISC);
2715 if ((ifp->if_flags & IFF_BROADCAST) != 0)
2716 rxcfg |= MAC_CFG_BCAST;
2717 if ((ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI)) != 0) {
2718 if ((ifp->if_flags & IFF_PROMISC) != 0)
2719 rxcfg |= MAC_CFG_PROMISC;
2720 if ((ifp->if_flags & IFF_ALLMULTI) != 0)
2721 rxcfg |= MAC_CFG_ALLMULTI;
2722 CSR_WRITE_4(sc, ALE_MAR0, 0xFFFFFFFF);
2723 CSR_WRITE_4(sc, ALE_MAR1, 0xFFFFFFFF);
2724 CSR_WRITE_4(sc, ALE_MAC_CFG, rxcfg);
2728 /* Program new filter. */
2729 bzero(mchash, sizeof(mchash));
2731 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
2732 if (ifma->ifma_addr->sa_family != AF_LINK)
2734 crc = ether_crc32_le(LLADDR((struct sockaddr_dl *)
2735 ifma->ifma_addr), ETHER_ADDR_LEN);
2736 mchash[crc >> 31] |= 1 << ((crc >> 26) & 0x1f);
2739 CSR_WRITE_4(sc, ALE_MAR0, mchash[0]);
2740 CSR_WRITE_4(sc, ALE_MAR1, mchash[1]);
2741 CSR_WRITE_4(sc, ALE_MAC_CFG, rxcfg);
2745 sysctl_hw_ale_int_mod(SYSCTL_HANDLER_ARGS)
2747 return (sysctl_int_range(oidp, arg1, arg2, req,
2748 ALE_IM_TIMER_MIN, ALE_IM_TIMER_MAX));
2752 ale_dmamap_buf_cb(void *xctx, bus_dma_segment_t *segs, int nsegs,
2753 bus_size_t mapsz __unused, int error)
2755 struct ale_dmamap_ctx *ctx = xctx;
2761 if (nsegs > ctx->nsegs) {
2767 for (i = 0; i < nsegs; ++i)
2768 ctx->segs[i] = segs[i];