From owner-svn-src-head@FreeBSD.ORG Fri Dec 31 00:21:41 2010 Return-Path: Delivered-To: svn-src-head@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id CBF1C106566C; Fri, 31 Dec 2010 00:21:41 +0000 (UTC) (envelope-from yongari@FreeBSD.org) Received: from svn.freebsd.org (svn.freebsd.org [IPv6:2001:4f8:fff6::2c]) by mx1.freebsd.org (Postfix) with ESMTP id B98BD8FC15; Fri, 31 Dec 2010 00:21:41 +0000 (UTC) Received: from svn.freebsd.org (localhost [127.0.0.1]) by svn.freebsd.org (8.14.3/8.14.3) with ESMTP id oBV0Lfph055393; Fri, 31 Dec 2010 00:21:41 GMT (envelope-from yongari@svn.freebsd.org) Received: (from yongari@localhost) by svn.freebsd.org (8.14.3/8.14.3/Submit) id oBV0Lfpc055387; Fri, 31 Dec 2010 00:21:41 GMT (envelope-from yongari@svn.freebsd.org) Message-Id: <201012310021.oBV0Lfpc055387@svn.freebsd.org> From: Pyun YongHyeon Date: Fri, 31 Dec 2010 00:21:41 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org X-SVN-Group: head MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cc: Subject: svn commit: r216829 - in head/sys: boot/forth conf dev/vte i386/conf modules modules/vte X-BeenThere: svn-src-head@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: SVN commit messages for the src tree for head/-current List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 31 Dec 2010 00:21:41 -0000 Author: yongari Date: Fri Dec 31 00:21:41 2010 New Revision: 216829 URL: http://svn.freebsd.org/changeset/base/216829 Log: Add driver for DM&P Vortex86 RDC R6040 Fast Ethernet. The controller is commonly found on DM&P Vortex86 x86 SoC. The driver supports all hardware features except flow control. The flow control was intentionally disabled due to silicon bug. DM&P Electronics, Inc. provided all necessary information including sample board to write driver and answered many questions I had. Many thanks for their support of FreeBSD. H/W donated by: DM&P Electronics, Inc. Added: head/sys/dev/vte/ head/sys/dev/vte/if_vte.c (contents, props changed) head/sys/dev/vte/if_vtereg.h (contents, props changed) head/sys/dev/vte/if_vtevar.h (contents, props changed) head/sys/modules/vte/ head/sys/modules/vte/Makefile (contents, props changed) Modified: head/sys/boot/forth/loader.conf head/sys/conf/NOTES head/sys/conf/files head/sys/i386/conf/GENERIC head/sys/modules/Makefile Modified: head/sys/boot/forth/loader.conf ============================================================================== --- head/sys/boot/forth/loader.conf Thu Dec 30 23:50:25 2010 (r216828) +++ head/sys/boot/forth/loader.conf Fri Dec 31 00:21:41 2010 (r216829) @@ -328,6 +328,7 @@ if_tl_load="NO" # Texas Instruments TN if_tx_load="NO" # SMC 83c17x Fast Ethernet if_txp_load="NO" # 3Com 3XP Typhoon/Sidewinder (3CR990) if_vge_load="NO" # VIA VT6122 PCI Gigabit Ethernet +if_vte_load="NO" # DM&P Vortex86 RDC R6040 Fast Ethernet if_uath_load="NO" # Atheros USB wireless for AR5005UG & AR5005UX if_udav_load="NO" # Davicom DM9601 USB Ethernet if_upgt_load="NO" # Conexant/Intersil PrismGT USB wireless Modified: head/sys/conf/NOTES ============================================================================== --- head/sys/conf/NOTES Thu Dec 30 23:50:25 2010 (r216828) +++ head/sys/conf/NOTES Fri Dec 31 00:21:41 2010 (r216829) @@ -1995,6 +1995,7 @@ device xmphy # XaQti XMAC II # Technologies VT3043 `Rhine I' and VT86C100A `Rhine II' chips, # including the D-Link DFE520TX and D-Link DFE530TX (see 'rl' for # DFE530TX+), the Hawking Technologies PN102TX, and the AOpen/Acer ALN-320. +# vte: DM&P Vortex86 RDC R6040 Fast Ethernet # vx: 3Com 3C590 and 3C595 # wb: Support for fast ethernet adapters based on the Winbond W89C840F chip. # Note: this is not the same as the Winbond W89C940F, which is a @@ -2067,6 +2068,7 @@ device stge # Sundance/Tamarack TC9021 device tl # Texas Instruments ThunderLAN device tx # SMC EtherPower II (83c170 ``EPIC'') device vr # VIA Rhine, Rhine II +device vte # DM&P Vortex86 RDC R6040 Fast Ethernet device wb # Winbond W89C840F device xl # 3Com 3c90x (``Boomerang'', ``Cyclone'') Modified: head/sys/conf/files ============================================================================== --- head/sys/conf/files Thu Dec 30 23:50:25 2010 (r216828) +++ head/sys/conf/files Fri Dec 31 00:21:41 2010 (r216829) @@ -1876,6 +1876,7 @@ dev/utopia/utopia.c optional utopia dev/vge/if_vge.c optional vge dev/vkbd/vkbd.c optional vkbd dev/vr/if_vr.c optional vr pci +dev/vte/if_vte.c optional vte pci dev/vx/if_vx.c optional vx dev/vx/if_vx_eisa.c optional vx eisa dev/vx/if_vx_pci.c optional vx pci Added: head/sys/dev/vte/if_vte.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/dev/vte/if_vte.c Fri Dec 31 00:21:41 2010 (r216829) @@ -0,0 +1,2056 @@ +/*- + * Copyright (c) 2010, Pyun YongHyeon + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice unmodified, this list of conditions, and the following + * disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* Driver for DM&P Electronics, Inc, Vortex86 RDC R6040 FastEthernet. */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include +#include + +#include + +#if 0 +#include "if_vtereg.h" +#include "if_vtevar.h" +#else +#include +#include +#endif + +/* "device miibus" required. See GENERIC if you get errors here. */ +#include "miibus_if.h" + +MODULE_DEPEND(vte, pci, 1, 1, 1); +MODULE_DEPEND(vte, ether, 1, 1, 1); +MODULE_DEPEND(vte, miibus, 1, 1, 1); + +/* Tunables. */ +static int tx_deep_copy = 1; +TUNABLE_INT("hw.vte.tx_deep_copy", &tx_deep_copy); + +/* + * Devices supported by this driver. + */ +static const struct vte_ident vte_ident_table[] = { + { VENDORID_RDC, DEVICEID_RDC_R6040, "RDC R6040 FastEthernet"}, + { 0, 0, NULL} +}; + +static int vte_attach(device_t); +static int vte_detach(device_t); +static int vte_dma_alloc(struct vte_softc *); +static void vte_dma_free(struct vte_softc *); +static void vte_dmamap_cb(void *, bus_dma_segment_t *, int, int); +static struct vte_txdesc * + vte_encap(struct vte_softc *, struct mbuf **); +static const struct vte_ident * + vte_find_ident(device_t); +#ifndef __NO_STRICT_ALIGNMENT +static struct mbuf * + vte_fixup_rx(struct ifnet *, struct mbuf *); +#endif +static void vte_get_macaddr(struct vte_softc *); +static void vte_init(void *); +static void vte_init_locked(struct vte_softc *); +static int vte_init_rx_ring(struct vte_softc *); +static int vte_init_tx_ring(struct vte_softc *); +static void vte_intr(void *); +static int vte_ioctl(struct ifnet *, u_long, caddr_t); +static void vte_mac_config(struct vte_softc *); +static int vte_miibus_readreg(device_t, int, int); +static void vte_miibus_statchg(device_t); +static int vte_miibus_writereg(device_t, int, int, int); +static int vte_mediachange(struct ifnet *); +static int vte_mediachange_locked(struct ifnet *); +static void vte_mediastatus(struct ifnet *, struct ifmediareq *); +static int vte_newbuf(struct vte_softc *, struct vte_rxdesc *); +static int vte_probe(device_t); +static void vte_reset(struct vte_softc *); +static int vte_resume(device_t); +static void vte_rxeof(struct vte_softc *); +static void vte_rxfilter(struct vte_softc *); +static int vte_shutdown(device_t); +static void vte_start(struct ifnet *); +static void vte_start_locked(struct vte_softc *); +static void vte_start_mac(struct vte_softc *); +static void vte_stats_clear(struct vte_softc *); +static void vte_stats_update(struct vte_softc *); +static void vte_stop(struct vte_softc *); +static void vte_stop_mac(struct vte_softc *); +static int vte_suspend(device_t); +static void vte_sysctl_node(struct vte_softc *); +static void vte_tick(void *); +static void vte_txeof(struct vte_softc *); +static void vte_watchdog(struct vte_softc *); +static int sysctl_int_range(SYSCTL_HANDLER_ARGS, int, int); +static int sysctl_hw_vte_int_mod(SYSCTL_HANDLER_ARGS); + +static device_method_t vte_methods[] = { + /* Device interface. */ + DEVMETHOD(device_probe, vte_probe), + DEVMETHOD(device_attach, vte_attach), + DEVMETHOD(device_detach, vte_detach), + DEVMETHOD(device_shutdown, vte_shutdown), + DEVMETHOD(device_suspend, vte_suspend), + DEVMETHOD(device_resume, vte_resume), + + /* MII interface. */ + DEVMETHOD(miibus_readreg, vte_miibus_readreg), + DEVMETHOD(miibus_writereg, vte_miibus_writereg), + DEVMETHOD(miibus_statchg, vte_miibus_statchg), + + KOBJMETHOD_END +}; + +static driver_t vte_driver = { + "vte", + vte_methods, + sizeof(struct vte_softc) +}; + +static devclass_t vte_devclass; + +DRIVER_MODULE(vte, pci, vte_driver, vte_devclass, 0, 0); +DRIVER_MODULE(miibus, vte, miibus_driver, miibus_devclass, 0, 0); + +static int +vte_miibus_readreg(device_t dev, int phy, int reg) +{ + struct vte_softc *sc; + int i; + + sc = device_get_softc(dev); + + CSR_WRITE_2(sc, VTE_MMDIO, MMDIO_READ | + (phy << MMDIO_PHY_ADDR_SHIFT) | (reg << MMDIO_REG_ADDR_SHIFT)); + for (i = VTE_PHY_TIMEOUT; i > 0; i--) { + DELAY(5); + if ((CSR_READ_2(sc, VTE_MMDIO) & MMDIO_READ) == 0) + break; + } + + if (i == 0) { + device_printf(sc->vte_dev, "phy read timeout : %d\n", reg); + return (0); + } + + return (CSR_READ_2(sc, VTE_MMRD)); +} + +static int +vte_miibus_writereg(device_t dev, int phy, int reg, int val) +{ + struct vte_softc *sc; + int i; + + sc = device_get_softc(dev); + + CSR_WRITE_2(sc, VTE_MMWD, val); + CSR_WRITE_2(sc, VTE_MMDIO, MMDIO_WRITE | + (phy << MMDIO_PHY_ADDR_SHIFT) | (reg << MMDIO_REG_ADDR_SHIFT)); + for (i = VTE_PHY_TIMEOUT; i > 0; i--) { + DELAY(5); + if ((CSR_READ_2(sc, VTE_MMDIO) & MMDIO_WRITE) == 0) + break; + } + + if (i == 0) + device_printf(sc->vte_dev, "phy write timeout : %d\n", reg); + + return (0); +} + +static void +vte_miibus_statchg(device_t dev) +{ + struct vte_softc *sc; + struct mii_data *mii; + struct ifnet *ifp; + uint16_t val; + + sc = device_get_softc(dev); + + mii = device_get_softc(sc->vte_miibus); + ifp = sc->vte_ifp; + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) + return; + + sc->vte_flags &= ~VTE_FLAG_LINK; + if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) == + (IFM_ACTIVE | IFM_AVALID)) { + switch (IFM_SUBTYPE(mii->mii_media_active)) { + case IFM_10_T: + case IFM_100_TX: + sc->vte_flags |= VTE_FLAG_LINK; + break; + default: + break; + } + } + + /* Stop RX/TX MACs. */ + vte_stop_mac(sc); + /* Program MACs with resolved duplex and flow control. */ + if ((sc->vte_flags & VTE_FLAG_LINK) != 0) { + /* + * Timer waiting time : (63 + TIMER * 64) MII clock. + * MII clock : 25MHz(100Mbps) or 2.5MHz(10Mbps). + */ + if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) + val = 18 << VTE_IM_TIMER_SHIFT; + else + val = 1 << VTE_IM_TIMER_SHIFT; + val |= sc->vte_int_rx_mod << VTE_IM_BUNDLE_SHIFT; + /* 48.6us for 100Mbps, 50.8us for 10Mbps */ + CSR_WRITE_2(sc, VTE_MRICR, val); + + if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) + val = 18 << VTE_IM_TIMER_SHIFT; + else + val = 1 << VTE_IM_TIMER_SHIFT; + val |= sc->vte_int_tx_mod << VTE_IM_BUNDLE_SHIFT; + /* 48.6us for 100Mbps, 50.8us for 10Mbps */ + CSR_WRITE_2(sc, VTE_MTICR, val); + + vte_mac_config(sc); + vte_start_mac(sc); + } +} + +static void +vte_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr) +{ + struct vte_softc *sc; + struct mii_data *mii; + + sc = ifp->if_softc; + VTE_LOCK(sc); + if ((ifp->if_flags & IFF_UP) == 0) { + VTE_UNLOCK(sc); + return; + } + mii = device_get_softc(sc->vte_miibus); + + mii_pollstat(mii); + VTE_UNLOCK(sc); + ifmr->ifm_status = mii->mii_media_status; + ifmr->ifm_active = mii->mii_media_active; +} + +static int +vte_mediachange(struct ifnet *ifp) +{ + struct vte_softc *sc; + int error; + + sc = ifp->if_softc; + VTE_LOCK(sc); + error = vte_mediachange_locked(ifp); + VTE_UNLOCK(sc); + return (error); +} + +static int +vte_mediachange_locked(struct ifnet *ifp) +{ + struct vte_softc *sc; + struct mii_data *mii; + struct mii_softc *miisc; + int error; + + sc = ifp->if_softc; + mii = device_get_softc(sc->vte_miibus); + if (mii->mii_instance != 0) { + LIST_FOREACH(miisc, &mii->mii_phys, mii_list) + mii_phy_reset(miisc); + } + error = mii_mediachg(mii); + + return (error); +} + +static const struct vte_ident * +vte_find_ident(device_t dev) +{ + const struct vte_ident *ident; + uint16_t vendor, devid; + + vendor = pci_get_vendor(dev); + devid = pci_get_device(dev); + for (ident = vte_ident_table; ident->name != NULL; ident++) { + if (vendor == ident->vendorid && devid == ident->deviceid) + return (ident); + } + + return (NULL); +} + +static int +vte_probe(device_t dev) +{ + const struct vte_ident *ident; + + ident = vte_find_ident(dev); + if (ident != NULL) { + device_set_desc(dev, ident->name); + return (BUS_PROBE_DEFAULT); + } + + return (ENXIO); +} + +static void +vte_get_macaddr(struct vte_softc *sc) +{ + uint16_t mid; + + /* + * It seems there is no way to reload station address and + * it is supposed to be set by BIOS. + */ + mid = CSR_READ_2(sc, VTE_MID0L); + sc->vte_eaddr[0] = (mid >> 0) & 0xFF; + sc->vte_eaddr[1] = (mid >> 8) & 0xFF; + mid = CSR_READ_2(sc, VTE_MID0M); + sc->vte_eaddr[2] = (mid >> 0) & 0xFF; + sc->vte_eaddr[3] = (mid >> 8) & 0xFF; + mid = CSR_READ_2(sc, VTE_MID0H); + sc->vte_eaddr[4] = (mid >> 0) & 0xFF; + sc->vte_eaddr[5] = (mid >> 8) & 0xFF; +} + +static int +vte_attach(device_t dev) +{ + struct vte_softc *sc; + struct ifnet *ifp; + uint16_t macid; + int error, rid; + + error = 0; + sc = device_get_softc(dev); + sc->vte_dev = dev; + + mtx_init(&sc->vte_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK, + MTX_DEF); + callout_init_mtx(&sc->vte_tick_ch, &sc->vte_mtx, 0); + sc->vte_ident = vte_find_ident(dev); + + /* Map the device. */ + pci_enable_busmaster(dev); + sc->vte_res_id = PCIR_BAR(1); + sc->vte_res_type = SYS_RES_MEMORY; + sc->vte_res = bus_alloc_resource_any(dev, sc->vte_res_type, + &sc->vte_res_id, RF_ACTIVE); + if (sc->vte_res == NULL) { + sc->vte_res_id = PCIR_BAR(0); + sc->vte_res_type = SYS_RES_IOPORT; + sc->vte_res = bus_alloc_resource_any(dev, sc->vte_res_type, + &sc->vte_res_id, RF_ACTIVE); + if (sc->vte_res == NULL) { + device_printf(dev, "cannot map memory/ports.\n"); + mtx_destroy(&sc->vte_mtx); + return (ENXIO); + } + } + if (bootverbose) { + device_printf(dev, "using %s space register mapping\n", + sc->vte_res_type == SYS_RES_MEMORY ? "memory" : "I/O"); + device_printf(dev, "MAC Identifier : 0x%04x\n", + CSR_READ_2(sc, VTE_MACID)); + macid = CSR_READ_2(sc, VTE_MACID_REV); + device_printf(dev, "MAC Id. 0x%02x, Rev. 0x%02x\n", + (macid & VTE_MACID_MASK) >> VTE_MACID_SHIFT, + (macid & VTE_MACID_REV_MASK) >> VTE_MACID_REV_SHIFT); + } + + rid = 0; + sc->vte_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, + RF_SHAREABLE | RF_ACTIVE); + if (sc->vte_irq == NULL) { + device_printf(dev, "cannot allocate IRQ resources.\n"); + error = ENXIO; + goto fail; + } + + /* Reset the ethernet controller. */ + vte_reset(sc); + + if ((error = vte_dma_alloc(sc) != 0)) + goto fail; + + /* Create device sysctl node. */ + vte_sysctl_node(sc); + + /* Load station address. */ + vte_get_macaddr(sc); + + ifp = sc->vte_ifp = if_alloc(IFT_ETHER); + if (ifp == NULL) { + device_printf(dev, "cannot allocate ifnet structure.\n"); + error = ENXIO; + goto fail; + } + + ifp->if_softc = sc; + if_initname(ifp, device_get_name(dev), device_get_unit(dev)); + ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; + ifp->if_ioctl = vte_ioctl; + ifp->if_start = vte_start; + ifp->if_init = vte_init; + ifp->if_snd.ifq_drv_maxlen = VTE_TX_RING_CNT - 1; + IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen); + IFQ_SET_READY(&ifp->if_snd); + + /* + * Set up MII bus. + * BIOS would have initialized VTE_MPSCCR to catch PHY + * status changes so driver may be able to extract + * configured PHY address. Since it's common to see BIOS + * fails to initialize the register(including the sample + * board I have), let mii(4) probe it. This is more + * reliable than relying on BIOS's initialization. + * + * Advertising flow control capability to mii(4) was + * intentionally disabled due to severe problems in TX + * pause frame generation. See vte_rxeof() for more + * details. + */ + error = mii_attach(dev, &sc->vte_miibus, ifp, vte_mediachange, + vte_mediastatus, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0); + if (error != 0) { + device_printf(dev, "attaching PHYs failed\n"); + goto fail; + } + + ether_ifattach(ifp, sc->vte_eaddr); + + /* VLAN capability setup. */ + ifp->if_capabilities |= IFCAP_VLAN_MTU; + ifp->if_capenable = ifp->if_capabilities; + /* Tell the upper layer we support VLAN over-sized frames. */ + ifp->if_hdrlen = sizeof(struct ether_vlan_header); + + error = bus_setup_intr(dev, sc->vte_irq, INTR_TYPE_NET | INTR_MPSAFE, + NULL, vte_intr, sc, &sc->vte_intrhand); + if (error != 0) { + device_printf(dev, "could not set up interrupt handler.\n"); + ether_ifdetach(ifp); + goto fail; + } + +fail: + if (error != 0) + vte_detach(dev); + + return (error); +} + +static int +vte_detach(device_t dev) +{ + struct vte_softc *sc; + struct ifnet *ifp; + + sc = device_get_softc(dev); + + ifp = sc->vte_ifp; + if (device_is_attached(dev)) { + VTE_LOCK(sc); + vte_stop(sc); + VTE_UNLOCK(sc); + callout_drain(&sc->vte_tick_ch); + ether_ifdetach(ifp); + } + + if (sc->vte_miibus != NULL) { + device_delete_child(dev, sc->vte_miibus); + sc->vte_miibus = NULL; + } + bus_generic_detach(dev); + + if (sc->vte_intrhand != NULL) { + bus_teardown_intr(dev, sc->vte_irq, sc->vte_intrhand); + sc->vte_intrhand = NULL; + } + if (sc->vte_irq != NULL) { + bus_release_resource(dev, SYS_RES_IRQ, 0, sc->vte_irq); + sc->vte_irq = NULL; + } + if (sc->vte_res != NULL) { + bus_release_resource(dev, sc->vte_res_type, sc->vte_res_id, + sc->vte_res); + sc->vte_res = NULL; + } + if (ifp != NULL) { + if_free(ifp); + sc->vte_ifp = NULL; + } + vte_dma_free(sc); + mtx_destroy(&sc->vte_mtx); + + return (0); +} + +#define VTE_SYSCTL_STAT_ADD32(c, h, n, p, d) \ + SYSCTL_ADD_UINT(c, h, OID_AUTO, n, CTLFLAG_RD, p, 0, d) + +static void +vte_sysctl_node(struct vte_softc *sc) +{ + struct sysctl_ctx_list *ctx; + struct sysctl_oid_list *child, *parent; + struct sysctl_oid *tree; + struct vte_hw_stats *stats; + int error; + + stats = &sc->vte_stats; + ctx = device_get_sysctl_ctx(sc->vte_dev); + child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->vte_dev)); + + SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_rx_mod", + CTLTYPE_INT | CTLFLAG_RW, &sc->vte_int_rx_mod, 0, + sysctl_hw_vte_int_mod, "I", "vte RX interrupt moderation"); + SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_tx_mod", + CTLTYPE_INT | CTLFLAG_RW, &sc->vte_int_tx_mod, 0, + sysctl_hw_vte_int_mod, "I", "vte TX interrupt moderation"); + /* Pull in device tunables. */ + sc->vte_int_rx_mod = VTE_IM_RX_BUNDLE_DEFAULT; + error = resource_int_value(device_get_name(sc->vte_dev), + device_get_unit(sc->vte_dev), "int_rx_mod", &sc->vte_int_rx_mod); + if (error == 0) { + if (sc->vte_int_rx_mod < VTE_IM_BUNDLE_MIN || + sc->vte_int_rx_mod > VTE_IM_BUNDLE_MAX) { + device_printf(sc->vte_dev, "int_rx_mod value out of " + "range; using default: %d\n", + VTE_IM_RX_BUNDLE_DEFAULT); + sc->vte_int_rx_mod = VTE_IM_RX_BUNDLE_DEFAULT; + } + } + + sc->vte_int_tx_mod = VTE_IM_TX_BUNDLE_DEFAULT; + error = resource_int_value(device_get_name(sc->vte_dev), + device_get_unit(sc->vte_dev), "int_tx_mod", &sc->vte_int_tx_mod); + if (error == 0) { + if (sc->vte_int_tx_mod < VTE_IM_BUNDLE_MIN || + sc->vte_int_tx_mod > VTE_IM_BUNDLE_MAX) { + device_printf(sc->vte_dev, "int_tx_mod value out of " + "range; using default: %d\n", + VTE_IM_TX_BUNDLE_DEFAULT); + sc->vte_int_tx_mod = VTE_IM_TX_BUNDLE_DEFAULT; + } + } + + tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD, + NULL, "VTE statistics"); + parent = SYSCTL_CHILDREN(tree); + + /* RX statistics. */ + tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", CTLFLAG_RD, + NULL, "RX MAC statistics"); + child = SYSCTL_CHILDREN(tree); + VTE_SYSCTL_STAT_ADD32(ctx, child, "good_frames", + &stats->rx_frames, "Good frames"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "good_bcast_frames", + &stats->rx_bcast_frames, "Good broadcast frames"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "good_mcast_frames", + &stats->rx_mcast_frames, "Good multicast frames"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "runt", + &stats->rx_runts, "Too short frames"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "crc_errs", + &stats->rx_crcerrs, "CRC errors"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "long_frames", + &stats->rx_long_frames, + "Frames that have longer length than maximum packet length"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "fifo_full", + &stats->rx_fifo_full, "FIFO full"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "desc_unavail", + &stats->rx_desc_unavail, "Descriptor unavailable frames"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "pause_frames", + &stats->rx_pause_frames, "Pause control frames"); + + /* TX statistics. */ + tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", CTLFLAG_RD, + NULL, "TX MAC statistics"); + child = SYSCTL_CHILDREN(tree); + VTE_SYSCTL_STAT_ADD32(ctx, child, "good_frames", + &stats->tx_frames, "Good frames"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "underruns", + &stats->tx_underruns, "FIFO underruns"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "late_colls", + &stats->tx_late_colls, "Late collisions"); + VTE_SYSCTL_STAT_ADD32(ctx, child, "pause_frames", + &stats->tx_pause_frames, "Pause control frames"); +} + +#undef VTE_SYSCTL_STAT_ADD32 + +struct vte_dmamap_arg { + bus_addr_t vte_busaddr; +}; + +static void +vte_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) +{ + struct vte_dmamap_arg *ctx; + + if (error != 0) + return; + + KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs)); + + ctx = (struct vte_dmamap_arg *)arg; + ctx->vte_busaddr = segs[0].ds_addr; +} + +static int +vte_dma_alloc(struct vte_softc *sc) +{ + struct vte_txdesc *txd; + struct vte_rxdesc *rxd; + struct vte_dmamap_arg ctx; + int error, i; + + /* Create parent DMA tag. */ + error = bus_dma_tag_create( + bus_get_dma_tag(sc->vte_dev), /* parent */ + 1, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsize */ + 0, /* nsegments */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ + 0, /* flags */ + NULL, NULL, /* lockfunc, lockarg */ + &sc->vte_cdata.vte_parent_tag); + if (error != 0) { + device_printf(sc->vte_dev, + "could not create parent DMA tag.\n"); + goto fail; + } + + /* Create DMA tag for TX descriptor ring. */ + error = bus_dma_tag_create( + sc->vte_cdata.vte_parent_tag, /* parent */ + VTE_TX_RING_ALIGN, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + VTE_TX_RING_SZ, /* maxsize */ + 1, /* nsegments */ + VTE_TX_RING_SZ, /* maxsegsize */ + 0, /* flags */ + NULL, NULL, /* lockfunc, lockarg */ + &sc->vte_cdata.vte_tx_ring_tag); + if (error != 0) { + device_printf(sc->vte_dev, + "could not create TX ring DMA tag.\n"); + goto fail; + } + + /* Create DMA tag for RX free descriptor ring. */ + error = bus_dma_tag_create( + sc->vte_cdata.vte_parent_tag, /* parent */ + VTE_RX_RING_ALIGN, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + VTE_RX_RING_SZ, /* maxsize */ + 1, /* nsegments */ + VTE_RX_RING_SZ, /* maxsegsize */ + 0, /* flags */ + NULL, NULL, /* lockfunc, lockarg */ + &sc->vte_cdata.vte_rx_ring_tag); + if (error != 0) { + device_printf(sc->vte_dev, + "could not create RX ring DMA tag.\n"); + goto fail; + } + + /* Allocate DMA'able memory and load the DMA map for TX ring. */ + error = bus_dmamem_alloc(sc->vte_cdata.vte_tx_ring_tag, + (void **)&sc->vte_cdata.vte_tx_ring, + BUS_DMA_WAITOK | BUS_DMA_ZERO | BUS_DMA_COHERENT, + &sc->vte_cdata.vte_tx_ring_map); + if (error != 0) { + device_printf(sc->vte_dev, + "could not allocate DMA'able memory for TX ring.\n"); + goto fail; + } + ctx.vte_busaddr = 0; + error = bus_dmamap_load(sc->vte_cdata.vte_tx_ring_tag, + sc->vte_cdata.vte_tx_ring_map, sc->vte_cdata.vte_tx_ring, + VTE_TX_RING_SZ, vte_dmamap_cb, &ctx, 0); + if (error != 0 || ctx.vte_busaddr == 0) { + device_printf(sc->vte_dev, + "could not load DMA'able memory for TX ring.\n"); + goto fail; + } + sc->vte_cdata.vte_tx_ring_paddr = ctx.vte_busaddr; + + /* Allocate DMA'able memory and load the DMA map for RX ring. */ + error = bus_dmamem_alloc(sc->vte_cdata.vte_rx_ring_tag, + (void **)&sc->vte_cdata.vte_rx_ring, + BUS_DMA_WAITOK | BUS_DMA_ZERO | BUS_DMA_COHERENT, + &sc->vte_cdata.vte_rx_ring_map); + if (error != 0) { + device_printf(sc->vte_dev, + "could not allocate DMA'able memory for RX ring.\n"); + goto fail; + } + ctx.vte_busaddr = 0; + error = bus_dmamap_load(sc->vte_cdata.vte_rx_ring_tag, + sc->vte_cdata.vte_rx_ring_map, sc->vte_cdata.vte_rx_ring, + VTE_RX_RING_SZ, vte_dmamap_cb, &ctx, 0); + if (error != 0 || ctx.vte_busaddr == 0) { + device_printf(sc->vte_dev, + "could not load DMA'able memory for RX ring.\n"); + goto fail; + } + sc->vte_cdata.vte_rx_ring_paddr = ctx.vte_busaddr; + + /* Create TX buffer parent tag. */ + error = bus_dma_tag_create( + bus_get_dma_tag(sc->vte_dev), /* parent */ + 1, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsize */ + 0, /* nsegments */ + BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ + 0, /* flags */ + NULL, NULL, /* lockfunc, lockarg */ + &sc->vte_cdata.vte_buffer_tag); + if (error != 0) { + device_printf(sc->vte_dev, + "could not create parent buffer DMA tag.\n"); + goto fail; + } + + /* Create DMA tag for TX buffers. */ + error = bus_dma_tag_create( + sc->vte_cdata.vte_buffer_tag, /* parent */ + 1, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + MCLBYTES, /* maxsize */ + 1, /* nsegments */ + MCLBYTES, /* maxsegsize */ + 0, /* flags */ + NULL, NULL, /* lockfunc, lockarg */ + &sc->vte_cdata.vte_tx_tag); + if (error != 0) { + device_printf(sc->vte_dev, "could not create TX DMA tag.\n"); + goto fail; + } + + /* Create DMA tag for RX buffers. */ + error = bus_dma_tag_create( + sc->vte_cdata.vte_buffer_tag, /* parent */ + VTE_RX_BUF_ALIGN, 0, /* alignment, boundary */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + MCLBYTES, /* maxsize */ + 1, /* nsegments */ + MCLBYTES, /* maxsegsize */ + 0, /* flags */ + NULL, NULL, /* lockfunc, lockarg */ + &sc->vte_cdata.vte_rx_tag); + if (error != 0) { + device_printf(sc->vte_dev, "could not create RX DMA tag.\n"); + goto fail; + } + /* Create DMA maps for TX buffers. */ + for (i = 0; i < VTE_TX_RING_CNT; i++) { + txd = &sc->vte_cdata.vte_txdesc[i]; + txd->tx_m = NULL; + txd->tx_dmamap = NULL; + error = bus_dmamap_create(sc->vte_cdata.vte_tx_tag, 0, + &txd->tx_dmamap); + if (error != 0) { + device_printf(sc->vte_dev, + "could not create TX dmamap.\n"); + goto fail; + } + } + /* Create DMA maps for RX buffers. */ + if ((error = bus_dmamap_create(sc->vte_cdata.vte_rx_tag, 0, + &sc->vte_cdata.vte_rx_sparemap)) != 0) { + device_printf(sc->vte_dev, + "could not create spare RX dmamap.\n"); + goto fail; + } + for (i = 0; i < VTE_RX_RING_CNT; i++) { + rxd = &sc->vte_cdata.vte_rxdesc[i]; + rxd->rx_m = NULL; + rxd->rx_dmamap = NULL; + error = bus_dmamap_create(sc->vte_cdata.vte_rx_tag, 0, + &rxd->rx_dmamap); + if (error != 0) { + device_printf(sc->vte_dev, + "could not create RX dmamap.\n"); + goto fail; + } + } + +fail: + return (error); +} + +static void +vte_dma_free(struct vte_softc *sc) +{ + struct vte_txdesc *txd; + struct vte_rxdesc *rxd; + int i; + + /* TX buffers. */ + if (sc->vte_cdata.vte_tx_tag != NULL) { + for (i = 0; i < VTE_TX_RING_CNT; i++) { + txd = &sc->vte_cdata.vte_txdesc[i]; + if (txd->tx_dmamap != NULL) { + bus_dmamap_destroy(sc->vte_cdata.vte_tx_tag, + txd->tx_dmamap); + txd->tx_dmamap = NULL; + } + } + bus_dma_tag_destroy(sc->vte_cdata.vte_tx_tag); + sc->vte_cdata.vte_tx_tag = NULL; + } + /* RX buffers */ + if (sc->vte_cdata.vte_rx_tag != NULL) { + for (i = 0; i < VTE_RX_RING_CNT; i++) { + rxd = &sc->vte_cdata.vte_rxdesc[i]; + if (rxd->rx_dmamap != NULL) { + bus_dmamap_destroy(sc->vte_cdata.vte_rx_tag, + rxd->rx_dmamap); + rxd->rx_dmamap = NULL; + } + } + if (sc->vte_cdata.vte_rx_sparemap != NULL) { + bus_dmamap_destroy(sc->vte_cdata.vte_rx_tag, + sc->vte_cdata.vte_rx_sparemap); + sc->vte_cdata.vte_rx_sparemap = NULL; + } + bus_dma_tag_destroy(sc->vte_cdata.vte_rx_tag); + sc->vte_cdata.vte_rx_tag = NULL; + } + /* TX descriptor ring. */ + if (sc->vte_cdata.vte_tx_ring_tag != NULL) { + if (sc->vte_cdata.vte_tx_ring_map != NULL) + bus_dmamap_unload(sc->vte_cdata.vte_tx_ring_tag, + sc->vte_cdata.vte_tx_ring_map); + if (sc->vte_cdata.vte_tx_ring_map != NULL && + sc->vte_cdata.vte_tx_ring != NULL) + bus_dmamem_free(sc->vte_cdata.vte_tx_ring_tag, + sc->vte_cdata.vte_tx_ring, + sc->vte_cdata.vte_tx_ring_map); + sc->vte_cdata.vte_tx_ring = NULL; + sc->vte_cdata.vte_tx_ring_map = NULL; + bus_dma_tag_destroy(sc->vte_cdata.vte_tx_ring_tag); + sc->vte_cdata.vte_tx_ring_tag = NULL; + } + /* RX ring. */ + if (sc->vte_cdata.vte_rx_ring_tag != NULL) { + if (sc->vte_cdata.vte_rx_ring_map != NULL) + bus_dmamap_unload(sc->vte_cdata.vte_rx_ring_tag, + sc->vte_cdata.vte_rx_ring_map); + if (sc->vte_cdata.vte_rx_ring_map != NULL && + sc->vte_cdata.vte_rx_ring != NULL) + bus_dmamem_free(sc->vte_cdata.vte_rx_ring_tag, + sc->vte_cdata.vte_rx_ring, + sc->vte_cdata.vte_rx_ring_map); + sc->vte_cdata.vte_rx_ring = NULL; + sc->vte_cdata.vte_rx_ring_map = NULL; + bus_dma_tag_destroy(sc->vte_cdata.vte_rx_ring_tag); + sc->vte_cdata.vte_rx_ring_tag = NULL; + } + if (sc->vte_cdata.vte_buffer_tag != NULL) { + bus_dma_tag_destroy(sc->vte_cdata.vte_buffer_tag); + sc->vte_cdata.vte_buffer_tag = NULL; + } + if (sc->vte_cdata.vte_parent_tag != NULL) { + bus_dma_tag_destroy(sc->vte_cdata.vte_parent_tag); + sc->vte_cdata.vte_parent_tag = NULL; + } +} + +static int +vte_shutdown(device_t dev) +{ + + return (vte_suspend(dev)); +} + +static int +vte_suspend(device_t dev) +{ + struct vte_softc *sc; + struct ifnet *ifp; + + sc = device_get_softc(dev); + + VTE_LOCK(sc); + ifp = sc->vte_ifp; + if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) + vte_stop(sc); + VTE_UNLOCK(sc); + *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***