1d3810ff9SJared McNeill /*- 2d3810ff9SJared McNeill * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca> 3d3810ff9SJared McNeill * All rights reserved. 4d3810ff9SJared McNeill * 5d3810ff9SJared McNeill * Redistribution and use in source and binary forms, with or without 6d3810ff9SJared McNeill * modification, are permitted provided that the following conditions 7d3810ff9SJared McNeill * are met: 8d3810ff9SJared McNeill * 1. Redistributions of source code must retain the above copyright 9d3810ff9SJared McNeill * notice, this list of conditions and the following disclaimer. 10d3810ff9SJared McNeill * 2. Redistributions in binary form must reproduce the above copyright 11d3810ff9SJared McNeill * notice, this list of conditions and the following disclaimer in the 12d3810ff9SJared McNeill * documentation and/or other materials provided with the distribution. 13d3810ff9SJared McNeill * 14d3810ff9SJared McNeill * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 15d3810ff9SJared McNeill * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16d3810ff9SJared McNeill * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17d3810ff9SJared McNeill * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 18d3810ff9SJared McNeill * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 19d3810ff9SJared McNeill * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 20d3810ff9SJared McNeill * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 21d3810ff9SJared McNeill * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 22d3810ff9SJared McNeill * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23d3810ff9SJared McNeill * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24d3810ff9SJared McNeill * SUCH DAMAGE. 25d3810ff9SJared McNeill * 26d3810ff9SJared McNeill * $FreeBSD$ 27d3810ff9SJared McNeill */ 28d3810ff9SJared McNeill 29d3810ff9SJared McNeill /* 30d3810ff9SJared McNeill * Allwinner Gigabit Ethernet MAC (EMAC) controller 31d3810ff9SJared McNeill */ 32d3810ff9SJared McNeill 3316928528SJared McNeill #include "opt_device_polling.h" 3416928528SJared McNeill 35d3810ff9SJared McNeill #include <sys/cdefs.h> 36d3810ff9SJared McNeill __FBSDID("$FreeBSD$"); 37d3810ff9SJared McNeill 38d3810ff9SJared McNeill #include <sys/param.h> 39d3810ff9SJared McNeill #include <sys/systm.h> 40d3810ff9SJared McNeill #include <sys/bus.h> 41d3810ff9SJared McNeill #include <sys/rman.h> 42d3810ff9SJared McNeill #include <sys/kernel.h> 43d3810ff9SJared McNeill #include <sys/endian.h> 44d3810ff9SJared McNeill #include <sys/mbuf.h> 45d3810ff9SJared McNeill #include <sys/socket.h> 46d3810ff9SJared McNeill #include <sys/sockio.h> 47d3810ff9SJared McNeill #include <sys/module.h> 48d3810ff9SJared McNeill #include <sys/taskqueue.h> 4901a469b8SJared McNeill #include <sys/gpio.h> 50d3810ff9SJared McNeill 51d3810ff9SJared McNeill #include <net/bpf.h> 52d3810ff9SJared McNeill #include <net/if.h> 53d3810ff9SJared McNeill #include <net/ethernet.h> 54d3810ff9SJared McNeill #include <net/if_dl.h> 55d3810ff9SJared McNeill #include <net/if_media.h> 56d3810ff9SJared McNeill #include <net/if_types.h> 57d3810ff9SJared McNeill #include <net/if_var.h> 58d3810ff9SJared McNeill 59d3810ff9SJared McNeill #include <machine/bus.h> 60d3810ff9SJared McNeill 61d3810ff9SJared McNeill #include <dev/ofw/ofw_bus.h> 62d3810ff9SJared McNeill #include <dev/ofw/ofw_bus_subr.h> 63d3810ff9SJared McNeill 64d3810ff9SJared McNeill #include <arm/allwinner/if_awgreg.h> 65*1403e695SJared McNeill #include <arm/allwinner/aw_sid.h> 66d3810ff9SJared McNeill #include <dev/mii/mii.h> 67d3810ff9SJared McNeill #include <dev/mii/miivar.h> 68d3810ff9SJared McNeill 69d3810ff9SJared McNeill #include <dev/extres/clk/clk.h> 70d3810ff9SJared McNeill #include <dev/extres/hwreset/hwreset.h> 71d3810ff9SJared McNeill #include <dev/extres/regulator/regulator.h> 72d3810ff9SJared McNeill 73d3810ff9SJared McNeill #include "miibus_if.h" 7401a469b8SJared McNeill #include "gpio_if.h" 75d3810ff9SJared McNeill 7601a469b8SJared McNeill #define RD4(sc, reg) bus_read_4((sc)->res[_RES_EMAC], (reg)) 7701a469b8SJared McNeill #define WR4(sc, reg, val) bus_write_4((sc)->res[_RES_EMAC], (reg), (val)) 78d3810ff9SJared McNeill 79d3810ff9SJared McNeill #define AWG_LOCK(sc) mtx_lock(&(sc)->mtx) 80d3810ff9SJared McNeill #define AWG_UNLOCK(sc) mtx_unlock(&(sc)->mtx); 81d3810ff9SJared McNeill #define AWG_ASSERT_LOCKED(sc) mtx_assert(&(sc)->mtx, MA_OWNED) 82d3810ff9SJared McNeill #define AWG_ASSERT_UNLOCKED(sc) mtx_assert(&(sc)->mtx, MA_NOTOWNED) 83d3810ff9SJared McNeill 84d3810ff9SJared McNeill #define DESC_ALIGN 4 8516928528SJared McNeill #define TX_DESC_COUNT 1024 86d3810ff9SJared McNeill #define TX_DESC_SIZE (sizeof(struct emac_desc) * TX_DESC_COUNT) 87d3810ff9SJared McNeill #define RX_DESC_COUNT 256 88d3810ff9SJared McNeill #define RX_DESC_SIZE (sizeof(struct emac_desc) * RX_DESC_COUNT) 89d3810ff9SJared McNeill 90d3810ff9SJared McNeill #define DESC_OFF(n) ((n) * sizeof(struct emac_desc)) 91d3810ff9SJared McNeill #define TX_NEXT(n) (((n) + 1) & (TX_DESC_COUNT - 1)) 92d3810ff9SJared McNeill #define TX_SKIP(n, o) (((n) + (o)) & (TX_DESC_COUNT - 1)) 93d3810ff9SJared McNeill #define RX_NEXT(n) (((n) + 1) & (RX_DESC_COUNT - 1)) 94d3810ff9SJared McNeill 95d3810ff9SJared McNeill #define TX_MAX_SEGS 10 96d3810ff9SJared McNeill 97d3810ff9SJared McNeill #define SOFT_RST_RETRY 1000 98d3810ff9SJared McNeill #define MII_BUSY_RETRY 1000 99d3810ff9SJared McNeill #define MDIO_FREQ 2500000 100d3810ff9SJared McNeill 101d3810ff9SJared McNeill #define BURST_LEN_DEFAULT 8 102d3810ff9SJared McNeill #define RX_TX_PRI_DEFAULT 0 103d3810ff9SJared McNeill #define PAUSE_TIME_DEFAULT 0x400 104d3810ff9SJared McNeill #define TX_INTERVAL_DEFAULT 64 10516928528SJared McNeill #define RX_BATCH_DEFAULT 64 106d3810ff9SJared McNeill 10701a469b8SJared McNeill /* syscon EMAC clock register */ 10801a469b8SJared McNeill #define EMAC_CLK_EPHY_ADDR (0x1f << 20) /* H3 */ 10901a469b8SJared McNeill #define EMAC_CLK_EPHY_ADDR_SHIFT 20 11001a469b8SJared McNeill #define EMAC_CLK_EPHY_LED_POL (1 << 17) /* H3 */ 11101a469b8SJared McNeill #define EMAC_CLK_EPHY_SHUTDOWN (1 << 16) /* H3 */ 11201a469b8SJared McNeill #define EMAC_CLK_EPHY_SELECT (1 << 15) /* H3 */ 11301a469b8SJared McNeill #define EMAC_CLK_RMII_EN (1 << 13) 11401a469b8SJared McNeill #define EMAC_CLK_ETXDC (0x7 << 10) 11501a469b8SJared McNeill #define EMAC_CLK_ETXDC_SHIFT 10 11601a469b8SJared McNeill #define EMAC_CLK_ERXDC (0x1f << 5) 11701a469b8SJared McNeill #define EMAC_CLK_ERXDC_SHIFT 5 11801a469b8SJared McNeill #define EMAC_CLK_PIT (0x1 << 2) 11901a469b8SJared McNeill #define EMAC_CLK_PIT_MII (0 << 2) 12001a469b8SJared McNeill #define EMAC_CLK_PIT_RGMII (1 << 2) 12101a469b8SJared McNeill #define EMAC_CLK_SRC (0x3 << 0) 12201a469b8SJared McNeill #define EMAC_CLK_SRC_MII (0 << 0) 12301a469b8SJared McNeill #define EMAC_CLK_SRC_EXT_RGMII (1 << 0) 12401a469b8SJared McNeill #define EMAC_CLK_SRC_RGMII (2 << 0) 12501a469b8SJared McNeill 126d3810ff9SJared McNeill /* Burst length of RX and TX DMA transfers */ 127d3810ff9SJared McNeill static int awg_burst_len = BURST_LEN_DEFAULT; 128d3810ff9SJared McNeill TUNABLE_INT("hw.awg.burst_len", &awg_burst_len); 129d3810ff9SJared McNeill 130d3810ff9SJared McNeill /* RX / TX DMA priority. If 1, RX DMA has priority over TX DMA. */ 131d3810ff9SJared McNeill static int awg_rx_tx_pri = RX_TX_PRI_DEFAULT; 132d3810ff9SJared McNeill TUNABLE_INT("hw.awg.rx_tx_pri", &awg_rx_tx_pri); 133d3810ff9SJared McNeill 134d3810ff9SJared McNeill /* Pause time field in the transmitted control frame */ 135d3810ff9SJared McNeill static int awg_pause_time = PAUSE_TIME_DEFAULT; 136d3810ff9SJared McNeill TUNABLE_INT("hw.awg.pause_time", &awg_pause_time); 137d3810ff9SJared McNeill 138d3810ff9SJared McNeill /* Request a TX interrupt every <n> descriptors */ 139d3810ff9SJared McNeill static int awg_tx_interval = TX_INTERVAL_DEFAULT; 140d3810ff9SJared McNeill TUNABLE_INT("hw.awg.tx_interval", &awg_tx_interval); 141d3810ff9SJared McNeill 14216928528SJared McNeill /* Maximum number of mbufs to send to if_input */ 14316928528SJared McNeill static int awg_rx_batch = RX_BATCH_DEFAULT; 14416928528SJared McNeill TUNABLE_INT("hw.awg.rx_batch", &awg_rx_batch); 14516928528SJared McNeill 14601a469b8SJared McNeill enum awg_type { 14701a469b8SJared McNeill EMAC_A83T = 1, 14801a469b8SJared McNeill EMAC_H3, 14901a469b8SJared McNeill }; 15001a469b8SJared McNeill 151d3810ff9SJared McNeill static struct ofw_compat_data compat_data[] = { 15201a469b8SJared McNeill { "allwinner,sun8i-a83t-emac", EMAC_A83T }, 15301a469b8SJared McNeill { "allwinner,sun8i-h3-emac", EMAC_H3 }, 154d3810ff9SJared McNeill { NULL, 0 } 155d3810ff9SJared McNeill }; 156d3810ff9SJared McNeill 157d3810ff9SJared McNeill struct awg_bufmap { 158d3810ff9SJared McNeill bus_dmamap_t map; 159d3810ff9SJared McNeill struct mbuf *mbuf; 160d3810ff9SJared McNeill }; 161d3810ff9SJared McNeill 162d3810ff9SJared McNeill struct awg_txring { 163d3810ff9SJared McNeill bus_dma_tag_t desc_tag; 164d3810ff9SJared McNeill bus_dmamap_t desc_map; 165d3810ff9SJared McNeill struct emac_desc *desc_ring; 166d3810ff9SJared McNeill bus_addr_t desc_ring_paddr; 167d3810ff9SJared McNeill bus_dma_tag_t buf_tag; 168d3810ff9SJared McNeill struct awg_bufmap buf_map[TX_DESC_COUNT]; 169d3810ff9SJared McNeill u_int cur, next, queued; 170d3810ff9SJared McNeill }; 171d3810ff9SJared McNeill 172d3810ff9SJared McNeill struct awg_rxring { 173d3810ff9SJared McNeill bus_dma_tag_t desc_tag; 174d3810ff9SJared McNeill bus_dmamap_t desc_map; 175d3810ff9SJared McNeill struct emac_desc *desc_ring; 176d3810ff9SJared McNeill bus_addr_t desc_ring_paddr; 177d3810ff9SJared McNeill bus_dma_tag_t buf_tag; 178d3810ff9SJared McNeill struct awg_bufmap buf_map[RX_DESC_COUNT]; 179d3810ff9SJared McNeill u_int cur; 180d3810ff9SJared McNeill }; 181d3810ff9SJared McNeill 18201a469b8SJared McNeill enum { 18301a469b8SJared McNeill _RES_EMAC, 18401a469b8SJared McNeill _RES_IRQ, 18501a469b8SJared McNeill _RES_SYSCON, 18601a469b8SJared McNeill _RES_NITEMS 18701a469b8SJared McNeill }; 18801a469b8SJared McNeill 189d3810ff9SJared McNeill struct awg_softc { 19001a469b8SJared McNeill struct resource *res[_RES_NITEMS]; 191d3810ff9SJared McNeill struct mtx mtx; 192d3810ff9SJared McNeill if_t ifp; 193d3810ff9SJared McNeill device_t miibus; 194d3810ff9SJared McNeill struct callout stat_ch; 195d3810ff9SJared McNeill struct task link_task; 196d3810ff9SJared McNeill void *ih; 197d3810ff9SJared McNeill u_int mdc_div_ratio_m; 198d3810ff9SJared McNeill int link; 199d3810ff9SJared McNeill int if_flags; 20001a469b8SJared McNeill enum awg_type type; 201d3810ff9SJared McNeill 202d3810ff9SJared McNeill struct awg_txring tx; 203d3810ff9SJared McNeill struct awg_rxring rx; 204d3810ff9SJared McNeill }; 205d3810ff9SJared McNeill 206d3810ff9SJared McNeill static struct resource_spec awg_spec[] = { 207d3810ff9SJared McNeill { SYS_RES_MEMORY, 0, RF_ACTIVE }, 208d3810ff9SJared McNeill { SYS_RES_IRQ, 0, RF_ACTIVE }, 20901a469b8SJared McNeill { SYS_RES_MEMORY, 1, RF_ACTIVE | RF_OPTIONAL }, 210d3810ff9SJared McNeill { -1, 0 } 211d3810ff9SJared McNeill }; 212d3810ff9SJared McNeill 213d3810ff9SJared McNeill static int 214d3810ff9SJared McNeill awg_miibus_readreg(device_t dev, int phy, int reg) 215d3810ff9SJared McNeill { 216d3810ff9SJared McNeill struct awg_softc *sc; 217d3810ff9SJared McNeill int retry, val; 218d3810ff9SJared McNeill 219d3810ff9SJared McNeill sc = device_get_softc(dev); 220d3810ff9SJared McNeill val = 0; 221d3810ff9SJared McNeill 222d3810ff9SJared McNeill WR4(sc, EMAC_MII_CMD, 223d3810ff9SJared McNeill (sc->mdc_div_ratio_m << MDC_DIV_RATIO_M_SHIFT) | 224d3810ff9SJared McNeill (phy << PHY_ADDR_SHIFT) | 225d3810ff9SJared McNeill (reg << PHY_REG_ADDR_SHIFT) | 226d3810ff9SJared McNeill MII_BUSY); 227d3810ff9SJared McNeill for (retry = MII_BUSY_RETRY; retry > 0; retry--) { 228d3810ff9SJared McNeill if ((RD4(sc, EMAC_MII_CMD) & MII_BUSY) == 0) { 229d3810ff9SJared McNeill val = RD4(sc, EMAC_MII_DATA); 230d3810ff9SJared McNeill break; 231d3810ff9SJared McNeill } 232d3810ff9SJared McNeill DELAY(10); 233d3810ff9SJared McNeill } 234d3810ff9SJared McNeill 235d3810ff9SJared McNeill if (retry == 0) 236d3810ff9SJared McNeill device_printf(dev, "phy read timeout, phy=%d reg=%d\n", 237d3810ff9SJared McNeill phy, reg); 238d3810ff9SJared McNeill 239d3810ff9SJared McNeill return (val); 240d3810ff9SJared McNeill } 241d3810ff9SJared McNeill 242d3810ff9SJared McNeill static int 243d3810ff9SJared McNeill awg_miibus_writereg(device_t dev, int phy, int reg, int val) 244d3810ff9SJared McNeill { 245d3810ff9SJared McNeill struct awg_softc *sc; 246d3810ff9SJared McNeill int retry; 247d3810ff9SJared McNeill 248d3810ff9SJared McNeill sc = device_get_softc(dev); 249d3810ff9SJared McNeill 250d3810ff9SJared McNeill WR4(sc, EMAC_MII_DATA, val); 251d3810ff9SJared McNeill WR4(sc, EMAC_MII_CMD, 252d3810ff9SJared McNeill (sc->mdc_div_ratio_m << MDC_DIV_RATIO_M_SHIFT) | 253d3810ff9SJared McNeill (phy << PHY_ADDR_SHIFT) | 254d3810ff9SJared McNeill (reg << PHY_REG_ADDR_SHIFT) | 255d3810ff9SJared McNeill MII_WR | MII_BUSY); 256d3810ff9SJared McNeill for (retry = MII_BUSY_RETRY; retry > 0; retry--) { 257d3810ff9SJared McNeill if ((RD4(sc, EMAC_MII_CMD) & MII_BUSY) == 0) 258d3810ff9SJared McNeill break; 259d3810ff9SJared McNeill DELAY(10); 260d3810ff9SJared McNeill } 261d3810ff9SJared McNeill 262d3810ff9SJared McNeill if (retry == 0) 263d3810ff9SJared McNeill device_printf(dev, "phy write timeout, phy=%d reg=%d\n", 264d3810ff9SJared McNeill phy, reg); 265d3810ff9SJared McNeill 266d3810ff9SJared McNeill return (0); 267d3810ff9SJared McNeill } 268d3810ff9SJared McNeill 269d3810ff9SJared McNeill static void 270d3810ff9SJared McNeill awg_update_link_locked(struct awg_softc *sc) 271d3810ff9SJared McNeill { 272d3810ff9SJared McNeill struct mii_data *mii; 273d3810ff9SJared McNeill uint32_t val; 274d3810ff9SJared McNeill 275d3810ff9SJared McNeill AWG_ASSERT_LOCKED(sc); 276d3810ff9SJared McNeill 277d3810ff9SJared McNeill if ((if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) == 0) 278d3810ff9SJared McNeill return; 279d3810ff9SJared McNeill mii = device_get_softc(sc->miibus); 280d3810ff9SJared McNeill 281d3810ff9SJared McNeill if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) == 282d3810ff9SJared McNeill (IFM_ACTIVE | IFM_AVALID)) { 283d3810ff9SJared McNeill switch (IFM_SUBTYPE(mii->mii_media_active)) { 284d3810ff9SJared McNeill case IFM_1000_T: 285d3810ff9SJared McNeill case IFM_1000_SX: 286d3810ff9SJared McNeill case IFM_100_TX: 287d3810ff9SJared McNeill case IFM_10_T: 288d3810ff9SJared McNeill sc->link = 1; 289d3810ff9SJared McNeill break; 290d3810ff9SJared McNeill default: 291d3810ff9SJared McNeill sc->link = 0; 292d3810ff9SJared McNeill break; 293d3810ff9SJared McNeill } 294d3810ff9SJared McNeill } else 295d3810ff9SJared McNeill sc->link = 0; 296d3810ff9SJared McNeill 297d3810ff9SJared McNeill if (sc->link == 0) 298d3810ff9SJared McNeill return; 299d3810ff9SJared McNeill 300d3810ff9SJared McNeill val = RD4(sc, EMAC_BASIC_CTL_0); 301d3810ff9SJared McNeill val &= ~(BASIC_CTL_SPEED | BASIC_CTL_DUPLEX); 302d3810ff9SJared McNeill 303d3810ff9SJared McNeill if (IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T || 304d3810ff9SJared McNeill IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_SX) 305d3810ff9SJared McNeill val |= BASIC_CTL_SPEED_1000 << BASIC_CTL_SPEED_SHIFT; 306d3810ff9SJared McNeill else if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) 307d3810ff9SJared McNeill val |= BASIC_CTL_SPEED_100 << BASIC_CTL_SPEED_SHIFT; 308d3810ff9SJared McNeill else 309d3810ff9SJared McNeill val |= BASIC_CTL_SPEED_10 << BASIC_CTL_SPEED_SHIFT; 310d3810ff9SJared McNeill 311d3810ff9SJared McNeill if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) 312d3810ff9SJared McNeill val |= BASIC_CTL_DUPLEX; 313d3810ff9SJared McNeill 314d3810ff9SJared McNeill WR4(sc, EMAC_BASIC_CTL_0, val); 315d3810ff9SJared McNeill 316d3810ff9SJared McNeill val = RD4(sc, EMAC_RX_CTL_0); 317d3810ff9SJared McNeill val &= ~RX_FLOW_CTL_EN; 318d3810ff9SJared McNeill if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0) 319d3810ff9SJared McNeill val |= RX_FLOW_CTL_EN; 320d3810ff9SJared McNeill WR4(sc, EMAC_RX_CTL_0, val); 321d3810ff9SJared McNeill 322d3810ff9SJared McNeill val = RD4(sc, EMAC_TX_FLOW_CTL); 323d3810ff9SJared McNeill val &= ~(PAUSE_TIME|TX_FLOW_CTL_EN); 324d3810ff9SJared McNeill if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0) 325d3810ff9SJared McNeill val |= TX_FLOW_CTL_EN; 326d3810ff9SJared McNeill if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) 327d3810ff9SJared McNeill val |= awg_pause_time << PAUSE_TIME_SHIFT; 328d3810ff9SJared McNeill WR4(sc, EMAC_TX_FLOW_CTL, val); 329d3810ff9SJared McNeill } 330d3810ff9SJared McNeill 331d3810ff9SJared McNeill static void 332d3810ff9SJared McNeill awg_link_task(void *arg, int pending) 333d3810ff9SJared McNeill { 334d3810ff9SJared McNeill struct awg_softc *sc; 335d3810ff9SJared McNeill 336d3810ff9SJared McNeill sc = arg; 337d3810ff9SJared McNeill 338d3810ff9SJared McNeill AWG_LOCK(sc); 339d3810ff9SJared McNeill awg_update_link_locked(sc); 340d3810ff9SJared McNeill AWG_UNLOCK(sc); 341d3810ff9SJared McNeill } 342d3810ff9SJared McNeill 343d3810ff9SJared McNeill static void 344d3810ff9SJared McNeill awg_miibus_statchg(device_t dev) 345d3810ff9SJared McNeill { 346d3810ff9SJared McNeill struct awg_softc *sc; 347d3810ff9SJared McNeill 348d3810ff9SJared McNeill sc = device_get_softc(dev); 349d3810ff9SJared McNeill 350d3810ff9SJared McNeill taskqueue_enqueue(taskqueue_swi, &sc->link_task); 351d3810ff9SJared McNeill } 352d3810ff9SJared McNeill 353d3810ff9SJared McNeill static void 354d3810ff9SJared McNeill awg_media_status(if_t ifp, struct ifmediareq *ifmr) 355d3810ff9SJared McNeill { 356d3810ff9SJared McNeill struct awg_softc *sc; 357d3810ff9SJared McNeill struct mii_data *mii; 358d3810ff9SJared McNeill 359d3810ff9SJared McNeill sc = if_getsoftc(ifp); 360d3810ff9SJared McNeill mii = device_get_softc(sc->miibus); 361d3810ff9SJared McNeill 362d3810ff9SJared McNeill AWG_LOCK(sc); 363d3810ff9SJared McNeill mii_pollstat(mii); 364d3810ff9SJared McNeill ifmr->ifm_active = mii->mii_media_active; 365d3810ff9SJared McNeill ifmr->ifm_status = mii->mii_media_status; 366d3810ff9SJared McNeill AWG_UNLOCK(sc); 367d3810ff9SJared McNeill } 368d3810ff9SJared McNeill 369d3810ff9SJared McNeill static int 370d3810ff9SJared McNeill awg_media_change(if_t ifp) 371d3810ff9SJared McNeill { 372d3810ff9SJared McNeill struct awg_softc *sc; 373d3810ff9SJared McNeill struct mii_data *mii; 374d3810ff9SJared McNeill int error; 375d3810ff9SJared McNeill 376d3810ff9SJared McNeill sc = if_getsoftc(ifp); 377d3810ff9SJared McNeill mii = device_get_softc(sc->miibus); 378d3810ff9SJared McNeill 379d3810ff9SJared McNeill AWG_LOCK(sc); 380d3810ff9SJared McNeill error = mii_mediachg(mii); 381d3810ff9SJared McNeill AWG_UNLOCK(sc); 382d3810ff9SJared McNeill 383d3810ff9SJared McNeill return (error); 384d3810ff9SJared McNeill } 385d3810ff9SJared McNeill 386d3810ff9SJared McNeill static void 387d3810ff9SJared McNeill awg_setup_txdesc(struct awg_softc *sc, int index, int flags, bus_addr_t paddr, 388d3810ff9SJared McNeill u_int len) 389d3810ff9SJared McNeill { 390d3810ff9SJared McNeill uint32_t status, size; 391d3810ff9SJared McNeill 392d3810ff9SJared McNeill if (paddr == 0 || len == 0) { 393d3810ff9SJared McNeill status = 0; 394d3810ff9SJared McNeill size = 0; 395d3810ff9SJared McNeill --sc->tx.queued; 396d3810ff9SJared McNeill } else { 397d3810ff9SJared McNeill status = TX_DESC_CTL; 398d3810ff9SJared McNeill size = flags | len; 399d3810ff9SJared McNeill if ((index & (awg_tx_interval - 1)) == 0) 40016928528SJared McNeill size |= TX_INT_CTL; 401d3810ff9SJared McNeill ++sc->tx.queued; 402d3810ff9SJared McNeill } 403d3810ff9SJared McNeill 404d3810ff9SJared McNeill sc->tx.desc_ring[index].addr = htole32((uint32_t)paddr); 405d3810ff9SJared McNeill sc->tx.desc_ring[index].size = htole32(size); 406d3810ff9SJared McNeill sc->tx.desc_ring[index].status = htole32(status); 407d3810ff9SJared McNeill } 408d3810ff9SJared McNeill 409d3810ff9SJared McNeill static int 410d3810ff9SJared McNeill awg_setup_txbuf(struct awg_softc *sc, int index, struct mbuf **mp) 411d3810ff9SJared McNeill { 412d3810ff9SJared McNeill bus_dma_segment_t segs[TX_MAX_SEGS]; 413d3810ff9SJared McNeill int error, nsegs, cur, i, flags; 414d3810ff9SJared McNeill u_int csum_flags; 415d3810ff9SJared McNeill struct mbuf *m; 416d3810ff9SJared McNeill 417d3810ff9SJared McNeill m = *mp; 418d3810ff9SJared McNeill error = bus_dmamap_load_mbuf_sg(sc->tx.buf_tag, 419d3810ff9SJared McNeill sc->tx.buf_map[index].map, m, segs, &nsegs, BUS_DMA_NOWAIT); 420d3810ff9SJared McNeill if (error == EFBIG) { 421d3810ff9SJared McNeill m = m_collapse(m, M_NOWAIT, TX_MAX_SEGS); 422d3810ff9SJared McNeill if (m == NULL) 423d3810ff9SJared McNeill return (0); 424d3810ff9SJared McNeill *mp = m; 425d3810ff9SJared McNeill error = bus_dmamap_load_mbuf_sg(sc->tx.buf_tag, 426d3810ff9SJared McNeill sc->tx.buf_map[index].map, m, segs, &nsegs, BUS_DMA_NOWAIT); 427d3810ff9SJared McNeill } 428d3810ff9SJared McNeill if (error != 0) 429d3810ff9SJared McNeill return (0); 430d3810ff9SJared McNeill 431d3810ff9SJared McNeill bus_dmamap_sync(sc->tx.buf_tag, sc->tx.buf_map[index].map, 432d3810ff9SJared McNeill BUS_DMASYNC_PREWRITE); 433d3810ff9SJared McNeill 434d3810ff9SJared McNeill flags = TX_FIR_DESC; 435d3810ff9SJared McNeill if ((m->m_pkthdr.csum_flags & CSUM_IP) != 0) { 436d3810ff9SJared McNeill if ((m->m_pkthdr.csum_flags & (CSUM_TCP|CSUM_UDP)) != 0) 437d3810ff9SJared McNeill csum_flags = TX_CHECKSUM_CTL_FULL; 438d3810ff9SJared McNeill else 439d3810ff9SJared McNeill csum_flags = TX_CHECKSUM_CTL_IP; 440d3810ff9SJared McNeill flags |= (csum_flags << TX_CHECKSUM_CTL_SHIFT); 441d3810ff9SJared McNeill } 442d3810ff9SJared McNeill 443d3810ff9SJared McNeill for (cur = index, i = 0; i < nsegs; i++) { 444d3810ff9SJared McNeill sc->tx.buf_map[cur].mbuf = (i == 0 ? m : NULL); 445d3810ff9SJared McNeill if (i == nsegs - 1) 446d3810ff9SJared McNeill flags |= TX_LAST_DESC; 447d3810ff9SJared McNeill awg_setup_txdesc(sc, cur, flags, segs[i].ds_addr, 448d3810ff9SJared McNeill segs[i].ds_len); 449d3810ff9SJared McNeill flags &= ~TX_FIR_DESC; 450d3810ff9SJared McNeill cur = TX_NEXT(cur); 451d3810ff9SJared McNeill } 452d3810ff9SJared McNeill 453d3810ff9SJared McNeill return (nsegs); 454d3810ff9SJared McNeill } 455d3810ff9SJared McNeill 456d3810ff9SJared McNeill static void 457d3810ff9SJared McNeill awg_setup_rxdesc(struct awg_softc *sc, int index, bus_addr_t paddr) 458d3810ff9SJared McNeill { 459d3810ff9SJared McNeill uint32_t status, size; 460d3810ff9SJared McNeill 461d3810ff9SJared McNeill status = RX_DESC_CTL; 462d3810ff9SJared McNeill size = MCLBYTES - 1; 463d3810ff9SJared McNeill 464d3810ff9SJared McNeill sc->rx.desc_ring[index].addr = htole32((uint32_t)paddr); 465d3810ff9SJared McNeill sc->rx.desc_ring[index].size = htole32(size); 466d3810ff9SJared McNeill sc->rx.desc_ring[index].next = 467d3810ff9SJared McNeill htole32(sc->rx.desc_ring_paddr + DESC_OFF(RX_NEXT(index))); 468d3810ff9SJared McNeill sc->rx.desc_ring[index].status = htole32(status); 469d3810ff9SJared McNeill } 470d3810ff9SJared McNeill 471d3810ff9SJared McNeill static int 472d3810ff9SJared McNeill awg_setup_rxbuf(struct awg_softc *sc, int index, struct mbuf *m) 473d3810ff9SJared McNeill { 474d3810ff9SJared McNeill bus_dma_segment_t seg; 475d3810ff9SJared McNeill int error, nsegs; 476d3810ff9SJared McNeill 477d3810ff9SJared McNeill m_adj(m, ETHER_ALIGN); 478d3810ff9SJared McNeill 479d3810ff9SJared McNeill error = bus_dmamap_load_mbuf_sg(sc->rx.buf_tag, 480d3810ff9SJared McNeill sc->rx.buf_map[index].map, m, &seg, &nsegs, 0); 481d3810ff9SJared McNeill if (error != 0) 482d3810ff9SJared McNeill return (error); 483d3810ff9SJared McNeill 484d3810ff9SJared McNeill bus_dmamap_sync(sc->rx.buf_tag, sc->rx.buf_map[index].map, 485d3810ff9SJared McNeill BUS_DMASYNC_PREREAD); 486d3810ff9SJared McNeill 487d3810ff9SJared McNeill sc->rx.buf_map[index].mbuf = m; 488d3810ff9SJared McNeill awg_setup_rxdesc(sc, index, seg.ds_addr); 489d3810ff9SJared McNeill 490d3810ff9SJared McNeill return (0); 491d3810ff9SJared McNeill } 492d3810ff9SJared McNeill 493d3810ff9SJared McNeill static struct mbuf * 494d3810ff9SJared McNeill awg_alloc_mbufcl(struct awg_softc *sc) 495d3810ff9SJared McNeill { 496d3810ff9SJared McNeill struct mbuf *m; 497d3810ff9SJared McNeill 498d3810ff9SJared McNeill m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 499d3810ff9SJared McNeill if (m != NULL) 500d3810ff9SJared McNeill m->m_pkthdr.len = m->m_len = m->m_ext.ext_size; 501d3810ff9SJared McNeill 502d3810ff9SJared McNeill return (m); 503d3810ff9SJared McNeill } 504d3810ff9SJared McNeill 505d3810ff9SJared McNeill static void 506d3810ff9SJared McNeill awg_start_locked(struct awg_softc *sc) 507d3810ff9SJared McNeill { 508d3810ff9SJared McNeill struct mbuf *m; 509d3810ff9SJared McNeill uint32_t val; 510d3810ff9SJared McNeill if_t ifp; 511d3810ff9SJared McNeill int cnt, nsegs; 512d3810ff9SJared McNeill 513d3810ff9SJared McNeill AWG_ASSERT_LOCKED(sc); 514d3810ff9SJared McNeill 515d3810ff9SJared McNeill if (!sc->link) 516d3810ff9SJared McNeill return; 517d3810ff9SJared McNeill 518d3810ff9SJared McNeill ifp = sc->ifp; 519d3810ff9SJared McNeill 520d3810ff9SJared McNeill if ((if_getdrvflags(ifp) & (IFF_DRV_RUNNING|IFF_DRV_OACTIVE)) != 521d3810ff9SJared McNeill IFF_DRV_RUNNING) 522d3810ff9SJared McNeill return; 523d3810ff9SJared McNeill 524d3810ff9SJared McNeill for (cnt = 0; ; cnt++) { 525d3810ff9SJared McNeill if (sc->tx.queued >= TX_DESC_COUNT - TX_MAX_SEGS) { 526d3810ff9SJared McNeill if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0); 527d3810ff9SJared McNeill break; 528d3810ff9SJared McNeill } 529d3810ff9SJared McNeill 530d3810ff9SJared McNeill m = if_dequeue(ifp); 531d3810ff9SJared McNeill if (m == NULL) 532d3810ff9SJared McNeill break; 533d3810ff9SJared McNeill 534d3810ff9SJared McNeill nsegs = awg_setup_txbuf(sc, sc->tx.cur, &m); 535d3810ff9SJared McNeill if (nsegs == 0) { 536d3810ff9SJared McNeill if_sendq_prepend(ifp, m); 537d3810ff9SJared McNeill break; 538d3810ff9SJared McNeill } 539d3810ff9SJared McNeill if_bpfmtap(ifp, m); 540d3810ff9SJared McNeill sc->tx.cur = TX_SKIP(sc->tx.cur, nsegs); 541d3810ff9SJared McNeill } 542d3810ff9SJared McNeill 543d3810ff9SJared McNeill if (cnt != 0) { 544d3810ff9SJared McNeill bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map, 545d3810ff9SJared McNeill BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 546d3810ff9SJared McNeill 547d3810ff9SJared McNeill /* Start and run TX DMA */ 548d3810ff9SJared McNeill val = RD4(sc, EMAC_TX_CTL_1); 549d3810ff9SJared McNeill WR4(sc, EMAC_TX_CTL_1, val | TX_DMA_START); 550d3810ff9SJared McNeill } 551d3810ff9SJared McNeill } 552d3810ff9SJared McNeill 553d3810ff9SJared McNeill static void 554d3810ff9SJared McNeill awg_start(if_t ifp) 555d3810ff9SJared McNeill { 556d3810ff9SJared McNeill struct awg_softc *sc; 557d3810ff9SJared McNeill 558d3810ff9SJared McNeill sc = if_getsoftc(ifp); 559d3810ff9SJared McNeill 560d3810ff9SJared McNeill AWG_LOCK(sc); 561d3810ff9SJared McNeill awg_start_locked(sc); 562d3810ff9SJared McNeill AWG_UNLOCK(sc); 563d3810ff9SJared McNeill } 564d3810ff9SJared McNeill 565d3810ff9SJared McNeill static void 566d3810ff9SJared McNeill awg_tick(void *softc) 567d3810ff9SJared McNeill { 568d3810ff9SJared McNeill struct awg_softc *sc; 569d3810ff9SJared McNeill struct mii_data *mii; 570d3810ff9SJared McNeill if_t ifp; 571d3810ff9SJared McNeill int link; 572d3810ff9SJared McNeill 573d3810ff9SJared McNeill sc = softc; 574d3810ff9SJared McNeill ifp = sc->ifp; 575d3810ff9SJared McNeill mii = device_get_softc(sc->miibus); 576d3810ff9SJared McNeill 577d3810ff9SJared McNeill AWG_ASSERT_LOCKED(sc); 578d3810ff9SJared McNeill 579d3810ff9SJared McNeill if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0) 580d3810ff9SJared McNeill return; 581d3810ff9SJared McNeill 582d3810ff9SJared McNeill link = sc->link; 583d3810ff9SJared McNeill mii_tick(mii); 584d3810ff9SJared McNeill if (sc->link && !link) 585d3810ff9SJared McNeill awg_start_locked(sc); 586d3810ff9SJared McNeill 587d3810ff9SJared McNeill callout_reset(&sc->stat_ch, hz, awg_tick, sc); 588d3810ff9SJared McNeill } 589d3810ff9SJared McNeill 590d3810ff9SJared McNeill /* Bit Reversal - http://aggregate.org/MAGIC/#Bit%20Reversal */ 591d3810ff9SJared McNeill static uint32_t 592d3810ff9SJared McNeill bitrev32(uint32_t x) 593d3810ff9SJared McNeill { 594d3810ff9SJared McNeill x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1)); 595d3810ff9SJared McNeill x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2)); 596d3810ff9SJared McNeill x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4)); 597d3810ff9SJared McNeill x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8)); 598d3810ff9SJared McNeill 599d3810ff9SJared McNeill return (x >> 16) | (x << 16); 600d3810ff9SJared McNeill } 601d3810ff9SJared McNeill 602d3810ff9SJared McNeill static void 603d3810ff9SJared McNeill awg_setup_rxfilter(struct awg_softc *sc) 604d3810ff9SJared McNeill { 605d3810ff9SJared McNeill uint32_t val, crc, hashreg, hashbit, hash[2], machi, maclo; 606d3810ff9SJared McNeill int mc_count, mcnt, i; 607d3810ff9SJared McNeill uint8_t *eaddr, *mta; 608d3810ff9SJared McNeill if_t ifp; 609d3810ff9SJared McNeill 610d3810ff9SJared McNeill AWG_ASSERT_LOCKED(sc); 611d3810ff9SJared McNeill 612d3810ff9SJared McNeill ifp = sc->ifp; 613d3810ff9SJared McNeill val = 0; 614d3810ff9SJared McNeill hash[0] = hash[1] = 0; 615d3810ff9SJared McNeill 616d3810ff9SJared McNeill mc_count = if_multiaddr_count(ifp, -1); 617d3810ff9SJared McNeill 618d3810ff9SJared McNeill if (if_getflags(ifp) & IFF_PROMISC) 619d3810ff9SJared McNeill val |= DIS_ADDR_FILTER; 620d3810ff9SJared McNeill else if (if_getflags(ifp) & IFF_ALLMULTI) { 621d3810ff9SJared McNeill val |= RX_ALL_MULTICAST; 622d3810ff9SJared McNeill hash[0] = hash[1] = ~0; 623d3810ff9SJared McNeill } else if (mc_count > 0) { 624d3810ff9SJared McNeill val |= HASH_MULTICAST; 625d3810ff9SJared McNeill 626d3810ff9SJared McNeill mta = malloc(sizeof(unsigned char) * ETHER_ADDR_LEN * mc_count, 627d3810ff9SJared McNeill M_DEVBUF, M_NOWAIT); 628d3810ff9SJared McNeill if (mta == NULL) { 629d3810ff9SJared McNeill if_printf(ifp, 630d3810ff9SJared McNeill "failed to allocate temporary multicast list\n"); 631d3810ff9SJared McNeill return; 632d3810ff9SJared McNeill } 633d3810ff9SJared McNeill 634d3810ff9SJared McNeill if_multiaddr_array(ifp, mta, &mcnt, mc_count); 635d3810ff9SJared McNeill for (i = 0; i < mcnt; i++) { 636d3810ff9SJared McNeill crc = ether_crc32_le(mta + (i * ETHER_ADDR_LEN), 637d3810ff9SJared McNeill ETHER_ADDR_LEN) & 0x7f; 638d3810ff9SJared McNeill crc = bitrev32(~crc) >> 26; 639d3810ff9SJared McNeill hashreg = (crc >> 5); 640d3810ff9SJared McNeill hashbit = (crc & 0x1f); 641d3810ff9SJared McNeill hash[hashreg] |= (1 << hashbit); 642d3810ff9SJared McNeill } 643d3810ff9SJared McNeill 644d3810ff9SJared McNeill free(mta, M_DEVBUF); 645d3810ff9SJared McNeill } 646d3810ff9SJared McNeill 647d3810ff9SJared McNeill /* Write our unicast address */ 648d3810ff9SJared McNeill eaddr = IF_LLADDR(ifp); 649d3810ff9SJared McNeill machi = (eaddr[5] << 8) | eaddr[4]; 650d3810ff9SJared McNeill maclo = (eaddr[3] << 24) | (eaddr[2] << 16) | (eaddr[1] << 8) | 651d3810ff9SJared McNeill (eaddr[0] << 0); 652d3810ff9SJared McNeill WR4(sc, EMAC_ADDR_HIGH(0), machi); 653d3810ff9SJared McNeill WR4(sc, EMAC_ADDR_LOW(0), maclo); 654d3810ff9SJared McNeill 655d3810ff9SJared McNeill /* Multicast hash filters */ 656d3810ff9SJared McNeill WR4(sc, EMAC_RX_HASH_0, hash[1]); 657d3810ff9SJared McNeill WR4(sc, EMAC_RX_HASH_1, hash[0]); 658d3810ff9SJared McNeill 659d3810ff9SJared McNeill /* RX frame filter config */ 660d3810ff9SJared McNeill WR4(sc, EMAC_RX_FRM_FLT, val); 661d3810ff9SJared McNeill } 662d3810ff9SJared McNeill 663d3810ff9SJared McNeill static void 66416928528SJared McNeill awg_enable_intr(struct awg_softc *sc) 66516928528SJared McNeill { 66616928528SJared McNeill /* Enable interrupts */ 66716928528SJared McNeill WR4(sc, EMAC_INT_EN, RX_INT_EN | TX_INT_EN | TX_BUF_UA_INT_EN); 66816928528SJared McNeill } 66916928528SJared McNeill 67016928528SJared McNeill static void 67116928528SJared McNeill awg_disable_intr(struct awg_softc *sc) 67216928528SJared McNeill { 67316928528SJared McNeill /* Disable interrupts */ 67416928528SJared McNeill WR4(sc, EMAC_INT_EN, 0); 67516928528SJared McNeill } 67616928528SJared McNeill 67716928528SJared McNeill static void 678d3810ff9SJared McNeill awg_init_locked(struct awg_softc *sc) 679d3810ff9SJared McNeill { 680d3810ff9SJared McNeill struct mii_data *mii; 681d3810ff9SJared McNeill uint32_t val; 682d3810ff9SJared McNeill if_t ifp; 683d3810ff9SJared McNeill 684d3810ff9SJared McNeill mii = device_get_softc(sc->miibus); 685d3810ff9SJared McNeill ifp = sc->ifp; 686d3810ff9SJared McNeill 687d3810ff9SJared McNeill AWG_ASSERT_LOCKED(sc); 688d3810ff9SJared McNeill 689d3810ff9SJared McNeill if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) 690d3810ff9SJared McNeill return; 691d3810ff9SJared McNeill 692d3810ff9SJared McNeill awg_setup_rxfilter(sc); 693d3810ff9SJared McNeill 694d3810ff9SJared McNeill /* Configure DMA burst length and priorities */ 695d3810ff9SJared McNeill val = awg_burst_len << BASIC_CTL_BURST_LEN_SHIFT; 696d3810ff9SJared McNeill if (awg_rx_tx_pri) 697d3810ff9SJared McNeill val |= BASIC_CTL_RX_TX_PRI; 698d3810ff9SJared McNeill WR4(sc, EMAC_BASIC_CTL_1, val); 699d3810ff9SJared McNeill 700d3810ff9SJared McNeill /* Enable interrupts */ 70116928528SJared McNeill #ifdef DEVICE_POLLING 70216928528SJared McNeill if ((if_getcapenable(ifp) & IFCAP_POLLING) == 0) 70316928528SJared McNeill awg_enable_intr(sc); 70416928528SJared McNeill else 70516928528SJared McNeill awg_disable_intr(sc); 70616928528SJared McNeill #else 70716928528SJared McNeill awg_enable_intr(sc); 70816928528SJared McNeill #endif 709d3810ff9SJared McNeill 710d3810ff9SJared McNeill /* Enable transmit DMA */ 711d3810ff9SJared McNeill val = RD4(sc, EMAC_TX_CTL_1); 71216928528SJared McNeill WR4(sc, EMAC_TX_CTL_1, val | TX_DMA_EN | TX_MD | TX_NEXT_FRAME); 713d3810ff9SJared McNeill 714d3810ff9SJared McNeill /* Enable receive DMA */ 715d3810ff9SJared McNeill val = RD4(sc, EMAC_RX_CTL_1); 716d3810ff9SJared McNeill WR4(sc, EMAC_RX_CTL_1, val | RX_DMA_EN | RX_MD); 717d3810ff9SJared McNeill 718d3810ff9SJared McNeill /* Enable transmitter */ 719d3810ff9SJared McNeill val = RD4(sc, EMAC_TX_CTL_0); 720d3810ff9SJared McNeill WR4(sc, EMAC_TX_CTL_0, val | TX_EN); 721d3810ff9SJared McNeill 722d3810ff9SJared McNeill /* Enable receiver */ 723d3810ff9SJared McNeill val = RD4(sc, EMAC_RX_CTL_0); 724d3810ff9SJared McNeill WR4(sc, EMAC_RX_CTL_0, val | RX_EN | CHECK_CRC); 725d3810ff9SJared McNeill 726d3810ff9SJared McNeill if_setdrvflagbits(ifp, IFF_DRV_RUNNING, IFF_DRV_OACTIVE); 727d3810ff9SJared McNeill 728d3810ff9SJared McNeill mii_mediachg(mii); 729d3810ff9SJared McNeill callout_reset(&sc->stat_ch, hz, awg_tick, sc); 730d3810ff9SJared McNeill } 731d3810ff9SJared McNeill 732d3810ff9SJared McNeill static void 733d3810ff9SJared McNeill awg_init(void *softc) 734d3810ff9SJared McNeill { 735d3810ff9SJared McNeill struct awg_softc *sc; 736d3810ff9SJared McNeill 737d3810ff9SJared McNeill sc = softc; 738d3810ff9SJared McNeill 739d3810ff9SJared McNeill AWG_LOCK(sc); 740d3810ff9SJared McNeill awg_init_locked(sc); 741d3810ff9SJared McNeill AWG_UNLOCK(sc); 742d3810ff9SJared McNeill } 743d3810ff9SJared McNeill 744d3810ff9SJared McNeill static void 745d3810ff9SJared McNeill awg_stop(struct awg_softc *sc) 746d3810ff9SJared McNeill { 747d3810ff9SJared McNeill if_t ifp; 748d3810ff9SJared McNeill uint32_t val; 749d3810ff9SJared McNeill 750d3810ff9SJared McNeill AWG_ASSERT_LOCKED(sc); 751d3810ff9SJared McNeill 752d3810ff9SJared McNeill ifp = sc->ifp; 753d3810ff9SJared McNeill 754d3810ff9SJared McNeill callout_stop(&sc->stat_ch); 755d3810ff9SJared McNeill 756d3810ff9SJared McNeill /* Stop transmit DMA and flush data in the TX FIFO */ 757d3810ff9SJared McNeill val = RD4(sc, EMAC_TX_CTL_1); 758d3810ff9SJared McNeill val &= ~TX_DMA_EN; 759d3810ff9SJared McNeill val |= FLUSH_TX_FIFO; 760d3810ff9SJared McNeill WR4(sc, EMAC_TX_CTL_1, val); 761d3810ff9SJared McNeill 762d3810ff9SJared McNeill /* Disable transmitter */ 763d3810ff9SJared McNeill val = RD4(sc, EMAC_TX_CTL_0); 764d3810ff9SJared McNeill WR4(sc, EMAC_TX_CTL_0, val & ~TX_EN); 765d3810ff9SJared McNeill 766d3810ff9SJared McNeill /* Disable receiver */ 767d3810ff9SJared McNeill val = RD4(sc, EMAC_RX_CTL_0); 768d3810ff9SJared McNeill WR4(sc, EMAC_RX_CTL_0, val & ~RX_EN); 769d3810ff9SJared McNeill 770d3810ff9SJared McNeill /* Disable interrupts */ 77116928528SJared McNeill awg_disable_intr(sc); 772d3810ff9SJared McNeill 773d3810ff9SJared McNeill /* Disable transmit DMA */ 774d3810ff9SJared McNeill val = RD4(sc, EMAC_TX_CTL_1); 775d3810ff9SJared McNeill WR4(sc, EMAC_TX_CTL_1, val & ~TX_DMA_EN); 776d3810ff9SJared McNeill 777d3810ff9SJared McNeill /* Disable receive DMA */ 778d3810ff9SJared McNeill val = RD4(sc, EMAC_RX_CTL_1); 779d3810ff9SJared McNeill WR4(sc, EMAC_RX_CTL_1, val & ~RX_DMA_EN); 780d3810ff9SJared McNeill 781d3810ff9SJared McNeill sc->link = 0; 782d3810ff9SJared McNeill 783d3810ff9SJared McNeill if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 784d3810ff9SJared McNeill } 785d3810ff9SJared McNeill 78616928528SJared McNeill static int 787d3810ff9SJared McNeill awg_rxintr(struct awg_softc *sc) 788d3810ff9SJared McNeill { 789d3810ff9SJared McNeill if_t ifp; 79016928528SJared McNeill struct mbuf *m, *m0, *mh, *mt; 79116928528SJared McNeill int error, index, len, cnt, npkt; 792d3810ff9SJared McNeill uint32_t status; 793d3810ff9SJared McNeill 794d3810ff9SJared McNeill ifp = sc->ifp; 79516928528SJared McNeill mh = mt = NULL; 79616928528SJared McNeill cnt = 0; 79716928528SJared McNeill npkt = 0; 798d3810ff9SJared McNeill 799d3810ff9SJared McNeill bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map, 800d3810ff9SJared McNeill BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 801d3810ff9SJared McNeill 802d3810ff9SJared McNeill for (index = sc->rx.cur; ; index = RX_NEXT(index)) { 803d3810ff9SJared McNeill status = le32toh(sc->rx.desc_ring[index].status); 804d3810ff9SJared McNeill if ((status & RX_DESC_CTL) != 0) 805d3810ff9SJared McNeill break; 806d3810ff9SJared McNeill 807d3810ff9SJared McNeill bus_dmamap_sync(sc->rx.buf_tag, sc->rx.buf_map[index].map, 808d3810ff9SJared McNeill BUS_DMASYNC_POSTREAD); 809d3810ff9SJared McNeill bus_dmamap_unload(sc->rx.buf_tag, sc->rx.buf_map[index].map); 810d3810ff9SJared McNeill 811d3810ff9SJared McNeill len = (status & RX_FRM_LEN) >> RX_FRM_LEN_SHIFT; 812d3810ff9SJared McNeill if (len != 0) { 813d3810ff9SJared McNeill m = sc->rx.buf_map[index].mbuf; 814d3810ff9SJared McNeill m->m_pkthdr.rcvif = ifp; 815d3810ff9SJared McNeill m->m_pkthdr.len = len; 816d3810ff9SJared McNeill m->m_len = len; 817d3810ff9SJared McNeill if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); 818d3810ff9SJared McNeill 819d3810ff9SJared McNeill if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0 && 820d3810ff9SJared McNeill (status & RX_FRM_TYPE) != 0) { 821d3810ff9SJared McNeill m->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 822d3810ff9SJared McNeill if ((status & RX_HEADER_ERR) == 0) 823d3810ff9SJared McNeill m->m_pkthdr.csum_flags |= CSUM_IP_VALID; 824d3810ff9SJared McNeill if ((status & RX_PAYLOAD_ERR) == 0) { 825d3810ff9SJared McNeill m->m_pkthdr.csum_flags |= 826d3810ff9SJared McNeill CSUM_DATA_VALID | CSUM_PSEUDO_HDR; 827d3810ff9SJared McNeill m->m_pkthdr.csum_data = 0xffff; 828d3810ff9SJared McNeill } 829d3810ff9SJared McNeill } 830d3810ff9SJared McNeill 83116928528SJared McNeill m->m_nextpkt = NULL; 83216928528SJared McNeill if (mh == NULL) 83316928528SJared McNeill mh = m; 83416928528SJared McNeill else 83516928528SJared McNeill mt->m_nextpkt = m; 83616928528SJared McNeill mt = m; 83716928528SJared McNeill ++cnt; 83816928528SJared McNeill ++npkt; 83916928528SJared McNeill 84016928528SJared McNeill if (cnt == awg_rx_batch) { 841d3810ff9SJared McNeill AWG_UNLOCK(sc); 84216928528SJared McNeill if_input(ifp, mh); 843d3810ff9SJared McNeill AWG_LOCK(sc); 84416928528SJared McNeill mh = mt = NULL; 84516928528SJared McNeill cnt = 0; 84616928528SJared McNeill } 84716928528SJared McNeill 848d3810ff9SJared McNeill } 849d3810ff9SJared McNeill 850d3810ff9SJared McNeill if ((m0 = awg_alloc_mbufcl(sc)) != NULL) { 851d3810ff9SJared McNeill error = awg_setup_rxbuf(sc, index, m0); 852d3810ff9SJared McNeill if (error != 0) { 853d3810ff9SJared McNeill /* XXX hole in RX ring */ 854d3810ff9SJared McNeill } 855d3810ff9SJared McNeill } else 856d3810ff9SJared McNeill if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); 857d3810ff9SJared McNeill } 858d3810ff9SJared McNeill 859d3810ff9SJared McNeill if (index != sc->rx.cur) { 860d3810ff9SJared McNeill bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map, 861d3810ff9SJared McNeill BUS_DMASYNC_PREWRITE); 862d3810ff9SJared McNeill } 863d3810ff9SJared McNeill 86416928528SJared McNeill if (mh != NULL) { 86516928528SJared McNeill AWG_UNLOCK(sc); 86616928528SJared McNeill if_input(ifp, mh); 86716928528SJared McNeill AWG_LOCK(sc); 86816928528SJared McNeill } 86916928528SJared McNeill 870d3810ff9SJared McNeill sc->rx.cur = index; 87116928528SJared McNeill 87216928528SJared McNeill return (npkt); 873d3810ff9SJared McNeill } 874d3810ff9SJared McNeill 875d3810ff9SJared McNeill static void 876d3810ff9SJared McNeill awg_txintr(struct awg_softc *sc) 877d3810ff9SJared McNeill { 878d3810ff9SJared McNeill struct awg_bufmap *bmap; 879d3810ff9SJared McNeill struct emac_desc *desc; 880d3810ff9SJared McNeill uint32_t status; 881d3810ff9SJared McNeill if_t ifp; 882d3810ff9SJared McNeill int i; 883d3810ff9SJared McNeill 884d3810ff9SJared McNeill AWG_ASSERT_LOCKED(sc); 885d3810ff9SJared McNeill 886d3810ff9SJared McNeill bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map, 887d3810ff9SJared McNeill BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 888d3810ff9SJared McNeill 889d3810ff9SJared McNeill ifp = sc->ifp; 890d3810ff9SJared McNeill for (i = sc->tx.next; sc->tx.queued > 0; i = TX_NEXT(i)) { 891d3810ff9SJared McNeill desc = &sc->tx.desc_ring[i]; 892d3810ff9SJared McNeill status = le32toh(desc->status); 893d3810ff9SJared McNeill if ((status & TX_DESC_CTL) != 0) 894d3810ff9SJared McNeill break; 895d3810ff9SJared McNeill bmap = &sc->tx.buf_map[i]; 896d3810ff9SJared McNeill if (bmap->mbuf != NULL) { 897d3810ff9SJared McNeill bus_dmamap_sync(sc->tx.buf_tag, bmap->map, 898d3810ff9SJared McNeill BUS_DMASYNC_POSTWRITE); 899d3810ff9SJared McNeill bus_dmamap_unload(sc->tx.buf_tag, bmap->map); 900d3810ff9SJared McNeill m_freem(bmap->mbuf); 901d3810ff9SJared McNeill bmap->mbuf = NULL; 902d3810ff9SJared McNeill } 903d3810ff9SJared McNeill awg_setup_txdesc(sc, i, 0, 0, 0); 904d3810ff9SJared McNeill if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE); 905d3810ff9SJared McNeill if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 906d3810ff9SJared McNeill } 907d3810ff9SJared McNeill 908d3810ff9SJared McNeill sc->tx.next = i; 909d3810ff9SJared McNeill 910d3810ff9SJared McNeill bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map, 911d3810ff9SJared McNeill BUS_DMASYNC_PREWRITE); 912d3810ff9SJared McNeill } 913d3810ff9SJared McNeill 914d3810ff9SJared McNeill static void 915d3810ff9SJared McNeill awg_intr(void *arg) 916d3810ff9SJared McNeill { 917d3810ff9SJared McNeill struct awg_softc *sc; 918d3810ff9SJared McNeill uint32_t val; 919d3810ff9SJared McNeill 920d3810ff9SJared McNeill sc = arg; 921d3810ff9SJared McNeill 922d3810ff9SJared McNeill AWG_LOCK(sc); 923d3810ff9SJared McNeill val = RD4(sc, EMAC_INT_STA); 924d3810ff9SJared McNeill WR4(sc, EMAC_INT_STA, val); 925d3810ff9SJared McNeill 926d3810ff9SJared McNeill if (val & RX_INT) 927d3810ff9SJared McNeill awg_rxintr(sc); 928d3810ff9SJared McNeill 929d3810ff9SJared McNeill if (val & (TX_INT|TX_BUF_UA_INT)) { 930d3810ff9SJared McNeill awg_txintr(sc); 931d3810ff9SJared McNeill if (!if_sendq_empty(sc->ifp)) 932d3810ff9SJared McNeill awg_start_locked(sc); 933d3810ff9SJared McNeill } 934d3810ff9SJared McNeill 935d3810ff9SJared McNeill AWG_UNLOCK(sc); 936d3810ff9SJared McNeill } 937d3810ff9SJared McNeill 93816928528SJared McNeill #ifdef DEVICE_POLLING 93916928528SJared McNeill static int 94016928528SJared McNeill awg_poll(if_t ifp, enum poll_cmd cmd, int count) 94116928528SJared McNeill { 94216928528SJared McNeill struct awg_softc *sc; 94316928528SJared McNeill uint32_t val; 94416928528SJared McNeill int rx_npkts; 94516928528SJared McNeill 94616928528SJared McNeill sc = if_getsoftc(ifp); 94716928528SJared McNeill rx_npkts = 0; 94816928528SJared McNeill 94916928528SJared McNeill AWG_LOCK(sc); 95016928528SJared McNeill 95116928528SJared McNeill if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0) { 95216928528SJared McNeill AWG_UNLOCK(sc); 95316928528SJared McNeill return (0); 95416928528SJared McNeill } 95516928528SJared McNeill 95616928528SJared McNeill rx_npkts = awg_rxintr(sc); 95716928528SJared McNeill awg_txintr(sc); 95816928528SJared McNeill if (!if_sendq_empty(ifp)) 95916928528SJared McNeill awg_start_locked(sc); 96016928528SJared McNeill 96116928528SJared McNeill if (cmd == POLL_AND_CHECK_STATUS) { 96216928528SJared McNeill val = RD4(sc, EMAC_INT_STA); 96316928528SJared McNeill if (val != 0) 96416928528SJared McNeill WR4(sc, EMAC_INT_STA, val); 96516928528SJared McNeill } 96616928528SJared McNeill 96716928528SJared McNeill AWG_UNLOCK(sc); 96816928528SJared McNeill 96916928528SJared McNeill return (rx_npkts); 97016928528SJared McNeill } 97116928528SJared McNeill #endif 97216928528SJared McNeill 973d3810ff9SJared McNeill static int 974d3810ff9SJared McNeill awg_ioctl(if_t ifp, u_long cmd, caddr_t data) 975d3810ff9SJared McNeill { 976d3810ff9SJared McNeill struct awg_softc *sc; 977d3810ff9SJared McNeill struct mii_data *mii; 978d3810ff9SJared McNeill struct ifreq *ifr; 979d3810ff9SJared McNeill int flags, mask, error; 980d3810ff9SJared McNeill 981d3810ff9SJared McNeill sc = if_getsoftc(ifp); 982d3810ff9SJared McNeill mii = device_get_softc(sc->miibus); 983d3810ff9SJared McNeill ifr = (struct ifreq *)data; 984d3810ff9SJared McNeill error = 0; 985d3810ff9SJared McNeill 986d3810ff9SJared McNeill switch (cmd) { 987d3810ff9SJared McNeill case SIOCSIFFLAGS: 988d3810ff9SJared McNeill AWG_LOCK(sc); 989d3810ff9SJared McNeill if (if_getflags(ifp) & IFF_UP) { 990d3810ff9SJared McNeill if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) { 991d3810ff9SJared McNeill flags = if_getflags(ifp) ^ sc->if_flags; 992d3810ff9SJared McNeill if ((flags & (IFF_PROMISC|IFF_ALLMULTI)) != 0) 993d3810ff9SJared McNeill awg_setup_rxfilter(sc); 994d3810ff9SJared McNeill } else 995d3810ff9SJared McNeill awg_init_locked(sc); 996d3810ff9SJared McNeill } else { 997d3810ff9SJared McNeill if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) 998d3810ff9SJared McNeill awg_stop(sc); 999d3810ff9SJared McNeill } 1000d3810ff9SJared McNeill sc->if_flags = if_getflags(ifp); 1001d3810ff9SJared McNeill AWG_UNLOCK(sc); 1002d3810ff9SJared McNeill break; 1003d3810ff9SJared McNeill case SIOCADDMULTI: 1004d3810ff9SJared McNeill case SIOCDELMULTI: 1005d3810ff9SJared McNeill if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) { 1006d3810ff9SJared McNeill AWG_LOCK(sc); 1007d3810ff9SJared McNeill awg_setup_rxfilter(sc); 1008d3810ff9SJared McNeill AWG_UNLOCK(sc); 1009d3810ff9SJared McNeill } 1010d3810ff9SJared McNeill break; 1011d3810ff9SJared McNeill case SIOCSIFMEDIA: 1012d3810ff9SJared McNeill case SIOCGIFMEDIA: 1013d3810ff9SJared McNeill error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd); 1014d3810ff9SJared McNeill break; 1015d3810ff9SJared McNeill case SIOCSIFCAP: 1016d3810ff9SJared McNeill mask = ifr->ifr_reqcap ^ if_getcapenable(ifp); 101716928528SJared McNeill #ifdef DEVICE_POLLING 101816928528SJared McNeill if (mask & IFCAP_POLLING) { 101916928528SJared McNeill if ((ifr->ifr_reqcap & IFCAP_POLLING) != 0) { 102016928528SJared McNeill error = ether_poll_register(awg_poll, ifp); 102116928528SJared McNeill if (error != 0) 102216928528SJared McNeill break; 102316928528SJared McNeill AWG_LOCK(sc); 102416928528SJared McNeill awg_disable_intr(sc); 102516928528SJared McNeill if_setcapenablebit(ifp, IFCAP_POLLING, 0); 102616928528SJared McNeill AWG_UNLOCK(sc); 102716928528SJared McNeill } else { 102816928528SJared McNeill error = ether_poll_deregister(ifp); 102916928528SJared McNeill AWG_LOCK(sc); 103016928528SJared McNeill awg_enable_intr(sc); 103116928528SJared McNeill if_setcapenablebit(ifp, 0, IFCAP_POLLING); 103216928528SJared McNeill AWG_UNLOCK(sc); 103316928528SJared McNeill } 103416928528SJared McNeill } 103516928528SJared McNeill #endif 1036d3810ff9SJared McNeill if (mask & IFCAP_VLAN_MTU) 1037d3810ff9SJared McNeill if_togglecapenable(ifp, IFCAP_VLAN_MTU); 1038d3810ff9SJared McNeill if (mask & IFCAP_RXCSUM) 1039d3810ff9SJared McNeill if_togglecapenable(ifp, IFCAP_RXCSUM); 1040d3810ff9SJared McNeill if (mask & IFCAP_TXCSUM) 1041d3810ff9SJared McNeill if_togglecapenable(ifp, IFCAP_TXCSUM); 1042d3810ff9SJared McNeill if ((if_getcapenable(ifp) & (IFCAP_RXCSUM|IFCAP_TXCSUM)) != 0) 1043d3810ff9SJared McNeill if_sethwassistbits(ifp, CSUM_IP, 0); 1044d3810ff9SJared McNeill else 1045d3810ff9SJared McNeill if_sethwassistbits(ifp, 0, CSUM_IP); 1046d3810ff9SJared McNeill break; 1047d3810ff9SJared McNeill default: 1048d3810ff9SJared McNeill error = ether_ioctl(ifp, cmd, data); 1049d3810ff9SJared McNeill break; 1050d3810ff9SJared McNeill } 1051d3810ff9SJared McNeill 1052d3810ff9SJared McNeill return (error); 1053d3810ff9SJared McNeill } 1054d3810ff9SJared McNeill 1055d3810ff9SJared McNeill static int 105601a469b8SJared McNeill awg_setup_phy(device_t dev) 1057d3810ff9SJared McNeill { 1058d3810ff9SJared McNeill struct awg_softc *sc; 105901a469b8SJared McNeill clk_t clk_tx, clk_tx_parent; 1060d3810ff9SJared McNeill const char *tx_parent_name; 1061d3810ff9SJared McNeill char *phy_type; 1062d3810ff9SJared McNeill phandle_t node; 106301a469b8SJared McNeill uint32_t reg, tx_delay, rx_delay; 106401a469b8SJared McNeill int error; 1065d3810ff9SJared McNeill 1066d3810ff9SJared McNeill sc = device_get_softc(dev); 1067d3810ff9SJared McNeill node = ofw_bus_get_node(dev); 1068d3810ff9SJared McNeill 106901a469b8SJared McNeill if (OF_getprop_alloc(node, "phy-mode", 1, (void **)&phy_type) == 0) 107001a469b8SJared McNeill return (0); 1071d3810ff9SJared McNeill 1072d3810ff9SJared McNeill if (bootverbose) 107301a469b8SJared McNeill device_printf(dev, "PHY type: %s, conf mode: %s\n", phy_type, 107401a469b8SJared McNeill sc->res[_RES_SYSCON] != NULL ? "reg" : "clk"); 1075d3810ff9SJared McNeill 107601a469b8SJared McNeill if (sc->res[_RES_SYSCON] != NULL) { 107701a469b8SJared McNeill reg = bus_read_4(sc->res[_RES_SYSCON], 0); 107801a469b8SJared McNeill reg &= ~(EMAC_CLK_PIT | EMAC_CLK_SRC | EMAC_CLK_RMII_EN); 107901a469b8SJared McNeill if (strcmp(phy_type, "rgmii") == 0) 108001a469b8SJared McNeill reg |= EMAC_CLK_PIT_RGMII | EMAC_CLK_SRC_RGMII; 108101a469b8SJared McNeill else if (strcmp(phy_type, "rmii") == 0) 108201a469b8SJared McNeill reg |= EMAC_CLK_RMII_EN; 108301a469b8SJared McNeill else 108401a469b8SJared McNeill reg |= EMAC_CLK_PIT_MII | EMAC_CLK_SRC_MII; 108501a469b8SJared McNeill 108601a469b8SJared McNeill if (OF_getencprop(node, "tx-delay", &tx_delay, 108701a469b8SJared McNeill sizeof(tx_delay)) > 0) { 108801a469b8SJared McNeill reg &= ~EMAC_CLK_ETXDC; 108901a469b8SJared McNeill reg |= (tx_delay << EMAC_CLK_ETXDC_SHIFT); 109001a469b8SJared McNeill } 109101a469b8SJared McNeill if (OF_getencprop(node, "rx-delay", &rx_delay, 109201a469b8SJared McNeill sizeof(rx_delay)) > 0) { 109301a469b8SJared McNeill reg &= ~EMAC_CLK_ERXDC; 109401a469b8SJared McNeill reg |= (rx_delay << EMAC_CLK_ERXDC_SHIFT); 109501a469b8SJared McNeill } 109601a469b8SJared McNeill 109701a469b8SJared McNeill if (sc->type == EMAC_H3) { 109801a469b8SJared McNeill if (OF_hasprop(node, "allwinner,use-internal-phy")) { 109901a469b8SJared McNeill reg |= EMAC_CLK_EPHY_SELECT; 110001a469b8SJared McNeill reg &= ~EMAC_CLK_EPHY_SHUTDOWN; 110101a469b8SJared McNeill if (OF_hasprop(node, 110201a469b8SJared McNeill "allwinner,leds-active-low")) 110301a469b8SJared McNeill reg |= EMAC_CLK_EPHY_LED_POL; 110401a469b8SJared McNeill else 110501a469b8SJared McNeill reg &= ~EMAC_CLK_EPHY_LED_POL; 110601a469b8SJared McNeill 110701a469b8SJared McNeill /* Set internal PHY addr to 1 */ 110801a469b8SJared McNeill reg &= ~EMAC_CLK_EPHY_ADDR; 110901a469b8SJared McNeill reg |= (1 << EMAC_CLK_EPHY_ADDR_SHIFT); 111001a469b8SJared McNeill } else { 111101a469b8SJared McNeill reg &= ~EMAC_CLK_EPHY_SELECT; 111201a469b8SJared McNeill } 111301a469b8SJared McNeill } 111401a469b8SJared McNeill 111501a469b8SJared McNeill if (bootverbose) 111601a469b8SJared McNeill device_printf(dev, "EMAC clock: 0x%08x\n", reg); 111701a469b8SJared McNeill bus_write_4(sc->res[_RES_SYSCON], 0, reg); 111801a469b8SJared McNeill } else { 1119d3810ff9SJared McNeill if (strcmp(phy_type, "rgmii") == 0) 1120d3810ff9SJared McNeill tx_parent_name = "emac_int_tx"; 1121d3810ff9SJared McNeill else 1122d3810ff9SJared McNeill tx_parent_name = "mii_phy_tx"; 1123d3810ff9SJared McNeill 1124d3810ff9SJared McNeill /* Get the TX clock */ 1125dac93553SMichal Meloun error = clk_get_by_ofw_name(dev, 0, "tx", &clk_tx); 1126d3810ff9SJared McNeill if (error != 0) { 1127d3810ff9SJared McNeill device_printf(dev, "cannot get tx clock\n"); 1128d3810ff9SJared McNeill goto fail; 1129d3810ff9SJared McNeill } 1130d3810ff9SJared McNeill 1131d3810ff9SJared McNeill /* Find the desired parent clock based on phy-mode property */ 1132d3810ff9SJared McNeill error = clk_get_by_name(dev, tx_parent_name, &clk_tx_parent); 1133d3810ff9SJared McNeill if (error != 0) { 1134d3810ff9SJared McNeill device_printf(dev, "cannot get clock '%s'\n", 1135d3810ff9SJared McNeill tx_parent_name); 1136d3810ff9SJared McNeill goto fail; 1137d3810ff9SJared McNeill } 1138d3810ff9SJared McNeill 1139d3810ff9SJared McNeill /* Set TX clock parent */ 1140d3810ff9SJared McNeill error = clk_set_parent_by_clk(clk_tx, clk_tx_parent); 1141d3810ff9SJared McNeill if (error != 0) { 1142d3810ff9SJared McNeill device_printf(dev, "cannot set tx clock parent\n"); 1143d3810ff9SJared McNeill goto fail; 1144d3810ff9SJared McNeill } 1145d3810ff9SJared McNeill 1146d3810ff9SJared McNeill /* Enable TX clock */ 1147d3810ff9SJared McNeill error = clk_enable(clk_tx); 1148d3810ff9SJared McNeill if (error != 0) { 1149d3810ff9SJared McNeill device_printf(dev, "cannot enable tx clock\n"); 1150d3810ff9SJared McNeill goto fail; 1151d3810ff9SJared McNeill } 1152d3810ff9SJared McNeill } 1153d3810ff9SJared McNeill 115401a469b8SJared McNeill error = 0; 115501a469b8SJared McNeill 115601a469b8SJared McNeill fail: 115701a469b8SJared McNeill OF_prop_free(phy_type); 115801a469b8SJared McNeill return (error); 115901a469b8SJared McNeill } 116001a469b8SJared McNeill 116101a469b8SJared McNeill static int 116201a469b8SJared McNeill awg_setup_extres(device_t dev) 116301a469b8SJared McNeill { 116401a469b8SJared McNeill struct awg_softc *sc; 116501a469b8SJared McNeill hwreset_t rst_ahb, rst_ephy; 116601a469b8SJared McNeill clk_t clk_ahb, clk_ephy; 116701a469b8SJared McNeill regulator_t reg; 116801a469b8SJared McNeill phandle_t node; 116901a469b8SJared McNeill uint64_t freq; 117001a469b8SJared McNeill int error, div; 117101a469b8SJared McNeill 117201a469b8SJared McNeill sc = device_get_softc(dev); 117301a469b8SJared McNeill node = ofw_bus_get_node(dev); 117401a469b8SJared McNeill rst_ahb = rst_ephy = NULL; 117501a469b8SJared McNeill clk_ahb = clk_ephy = NULL; 117601a469b8SJared McNeill reg = NULL; 117701a469b8SJared McNeill 117801a469b8SJared McNeill /* Get AHB clock and reset resources */ 117901a469b8SJared McNeill error = hwreset_get_by_ofw_name(dev, 0, "ahb", &rst_ahb); 118001a469b8SJared McNeill if (error != 0) { 118101a469b8SJared McNeill device_printf(dev, "cannot get ahb reset\n"); 118201a469b8SJared McNeill goto fail; 118301a469b8SJared McNeill } 118401a469b8SJared McNeill if (hwreset_get_by_ofw_name(dev, 0, "ephy", &rst_ephy) != 0) 118501a469b8SJared McNeill rst_ephy = NULL; 118601a469b8SJared McNeill error = clk_get_by_ofw_name(dev, 0, "ahb", &clk_ahb); 118701a469b8SJared McNeill if (error != 0) { 118801a469b8SJared McNeill device_printf(dev, "cannot get ahb clock\n"); 118901a469b8SJared McNeill goto fail; 119001a469b8SJared McNeill } 119101a469b8SJared McNeill if (clk_get_by_ofw_name(dev, 0, "ephy", &clk_ephy) != 0) 119201a469b8SJared McNeill clk_ephy = NULL; 119301a469b8SJared McNeill 119401a469b8SJared McNeill /* Configure PHY for MII or RGMII mode */ 119501a469b8SJared McNeill if (awg_setup_phy(dev) != 0) 119601a469b8SJared McNeill goto fail; 119701a469b8SJared McNeill 119801a469b8SJared McNeill /* Enable clocks */ 1199d3810ff9SJared McNeill error = clk_enable(clk_ahb); 1200d3810ff9SJared McNeill if (error != 0) { 1201d3810ff9SJared McNeill device_printf(dev, "cannot enable ahb clock\n"); 1202d3810ff9SJared McNeill goto fail; 1203d3810ff9SJared McNeill } 120401a469b8SJared McNeill if (clk_ephy != NULL) { 120501a469b8SJared McNeill error = clk_enable(clk_ephy); 120601a469b8SJared McNeill if (error != 0) { 120701a469b8SJared McNeill device_printf(dev, "cannot enable ephy clock\n"); 120801a469b8SJared McNeill goto fail; 120901a469b8SJared McNeill } 121001a469b8SJared McNeill } 1211d3810ff9SJared McNeill 1212d3810ff9SJared McNeill /* De-assert reset */ 1213d3810ff9SJared McNeill error = hwreset_deassert(rst_ahb); 1214d3810ff9SJared McNeill if (error != 0) { 1215d3810ff9SJared McNeill device_printf(dev, "cannot de-assert ahb reset\n"); 1216d3810ff9SJared McNeill goto fail; 1217d3810ff9SJared McNeill } 121801a469b8SJared McNeill if (rst_ephy != NULL) { 121901a469b8SJared McNeill error = hwreset_deassert(rst_ephy); 122001a469b8SJared McNeill if (error != 0) { 122101a469b8SJared McNeill device_printf(dev, "cannot de-assert ephy reset\n"); 122201a469b8SJared McNeill goto fail; 122301a469b8SJared McNeill } 122401a469b8SJared McNeill } 1225d3810ff9SJared McNeill 1226d3810ff9SJared McNeill /* Enable PHY regulator if applicable */ 1227dac93553SMichal Meloun if (regulator_get_by_ofw_property(dev, 0, "phy-supply", ®) == 0) { 1228d3810ff9SJared McNeill error = regulator_enable(reg); 1229d3810ff9SJared McNeill if (error != 0) { 1230d3810ff9SJared McNeill device_printf(dev, "cannot enable PHY regulator\n"); 1231d3810ff9SJared McNeill goto fail; 1232d3810ff9SJared McNeill } 1233d3810ff9SJared McNeill } 1234d3810ff9SJared McNeill 1235d3810ff9SJared McNeill /* Determine MDC clock divide ratio based on AHB clock */ 1236d3810ff9SJared McNeill error = clk_get_freq(clk_ahb, &freq); 1237d3810ff9SJared McNeill if (error != 0) { 1238d3810ff9SJared McNeill device_printf(dev, "cannot get AHB clock frequency\n"); 1239d3810ff9SJared McNeill goto fail; 1240d3810ff9SJared McNeill } 1241d3810ff9SJared McNeill div = freq / MDIO_FREQ; 1242d3810ff9SJared McNeill if (div <= 16) 1243d3810ff9SJared McNeill sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_16; 1244d3810ff9SJared McNeill else if (div <= 32) 1245d3810ff9SJared McNeill sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_32; 1246d3810ff9SJared McNeill else if (div <= 64) 1247d3810ff9SJared McNeill sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_64; 1248d3810ff9SJared McNeill else if (div <= 128) 1249d3810ff9SJared McNeill sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_128; 1250d3810ff9SJared McNeill else { 1251d3810ff9SJared McNeill device_printf(dev, "cannot determine MDC clock divide ratio\n"); 1252d3810ff9SJared McNeill error = ENXIO; 1253d3810ff9SJared McNeill goto fail; 1254d3810ff9SJared McNeill } 1255d3810ff9SJared McNeill 1256d3810ff9SJared McNeill if (bootverbose) 125701a469b8SJared McNeill device_printf(dev, "AHB frequency %ju Hz, MDC div: 0x%x\n", 125801a469b8SJared McNeill (uintmax_t)freq, sc->mdc_div_ratio_m); 1259d3810ff9SJared McNeill 1260d3810ff9SJared McNeill return (0); 1261d3810ff9SJared McNeill 1262d3810ff9SJared McNeill fail: 1263d3810ff9SJared McNeill if (reg != NULL) 1264d3810ff9SJared McNeill regulator_release(reg); 126501a469b8SJared McNeill if (clk_ephy != NULL) 126601a469b8SJared McNeill clk_release(clk_ephy); 1267d3810ff9SJared McNeill if (clk_ahb != NULL) 1268d3810ff9SJared McNeill clk_release(clk_ahb); 126901a469b8SJared McNeill if (rst_ephy != NULL) 127001a469b8SJared McNeill hwreset_release(rst_ephy); 1271d3810ff9SJared McNeill if (rst_ahb != NULL) 1272d3810ff9SJared McNeill hwreset_release(rst_ahb); 1273d3810ff9SJared McNeill return (error); 1274d3810ff9SJared McNeill } 1275d3810ff9SJared McNeill 1276d3810ff9SJared McNeill static void 1277d3810ff9SJared McNeill awg_get_eaddr(device_t dev, uint8_t *eaddr) 1278d3810ff9SJared McNeill { 1279d3810ff9SJared McNeill struct awg_softc *sc; 1280d3810ff9SJared McNeill uint32_t maclo, machi, rnd; 1281*1403e695SJared McNeill u_char rootkey[16]; 1282d3810ff9SJared McNeill 1283d3810ff9SJared McNeill sc = device_get_softc(dev); 1284d3810ff9SJared McNeill 1285d3810ff9SJared McNeill machi = RD4(sc, EMAC_ADDR_HIGH(0)) & 0xffff; 1286d3810ff9SJared McNeill maclo = RD4(sc, EMAC_ADDR_LOW(0)); 1287d3810ff9SJared McNeill 1288d3810ff9SJared McNeill if (maclo == 0xffffffff && machi == 0xffff) { 1289d3810ff9SJared McNeill /* MAC address in hardware is invalid, create one */ 1290*1403e695SJared McNeill if (aw_sid_get_rootkey(rootkey) == 0 && 1291*1403e695SJared McNeill (rootkey[3] | rootkey[12] | rootkey[13] | rootkey[14] | 1292*1403e695SJared McNeill rootkey[15]) != 0) { 1293*1403e695SJared McNeill /* MAC address is derived from the root key in SID */ 1294*1403e695SJared McNeill maclo = (rootkey[13] << 24) | (rootkey[12] << 16) | 1295*1403e695SJared McNeill (rootkey[3] << 8) | 0x02; 1296*1403e695SJared McNeill machi = (rootkey[15] << 8) | rootkey[14]; 1297*1403e695SJared McNeill } else { 1298*1403e695SJared McNeill /* Create one */ 1299d3810ff9SJared McNeill rnd = arc4random(); 1300d3810ff9SJared McNeill maclo = 0x00f2 | (rnd & 0xffff0000); 1301d3810ff9SJared McNeill machi = rnd & 0xffff; 1302d3810ff9SJared McNeill } 1303*1403e695SJared McNeill } 1304d3810ff9SJared McNeill 1305d3810ff9SJared McNeill eaddr[0] = maclo & 0xff; 1306d3810ff9SJared McNeill eaddr[1] = (maclo >> 8) & 0xff; 1307d3810ff9SJared McNeill eaddr[2] = (maclo >> 16) & 0xff; 1308d3810ff9SJared McNeill eaddr[3] = (maclo >> 24) & 0xff; 1309d3810ff9SJared McNeill eaddr[4] = machi & 0xff; 1310d3810ff9SJared McNeill eaddr[5] = (machi >> 8) & 0xff; 1311d3810ff9SJared McNeill } 1312d3810ff9SJared McNeill 1313d3810ff9SJared McNeill #ifdef AWG_DEBUG 1314d3810ff9SJared McNeill static void 1315d3810ff9SJared McNeill awg_dump_regs(device_t dev) 1316d3810ff9SJared McNeill { 1317d3810ff9SJared McNeill static const struct { 1318d3810ff9SJared McNeill const char *name; 1319d3810ff9SJared McNeill u_int reg; 1320d3810ff9SJared McNeill } regs[] = { 1321d3810ff9SJared McNeill { "BASIC_CTL_0", EMAC_BASIC_CTL_0 }, 1322d3810ff9SJared McNeill { "BASIC_CTL_1", EMAC_BASIC_CTL_1 }, 1323d3810ff9SJared McNeill { "INT_STA", EMAC_INT_STA }, 1324d3810ff9SJared McNeill { "INT_EN", EMAC_INT_EN }, 1325d3810ff9SJared McNeill { "TX_CTL_0", EMAC_TX_CTL_0 }, 1326d3810ff9SJared McNeill { "TX_CTL_1", EMAC_TX_CTL_1 }, 1327d3810ff9SJared McNeill { "TX_FLOW_CTL", EMAC_TX_FLOW_CTL }, 1328d3810ff9SJared McNeill { "TX_DMA_LIST", EMAC_TX_DMA_LIST }, 1329d3810ff9SJared McNeill { "RX_CTL_0", EMAC_RX_CTL_0 }, 1330d3810ff9SJared McNeill { "RX_CTL_1", EMAC_RX_CTL_1 }, 1331d3810ff9SJared McNeill { "RX_DMA_LIST", EMAC_RX_DMA_LIST }, 1332d3810ff9SJared McNeill { "RX_FRM_FLT", EMAC_RX_FRM_FLT }, 1333d3810ff9SJared McNeill { "RX_HASH_0", EMAC_RX_HASH_0 }, 1334d3810ff9SJared McNeill { "RX_HASH_1", EMAC_RX_HASH_1 }, 1335d3810ff9SJared McNeill { "MII_CMD", EMAC_MII_CMD }, 1336d3810ff9SJared McNeill { "ADDR_HIGH0", EMAC_ADDR_HIGH(0) }, 1337d3810ff9SJared McNeill { "ADDR_LOW0", EMAC_ADDR_LOW(0) }, 1338d3810ff9SJared McNeill { "TX_DMA_STA", EMAC_TX_DMA_STA }, 1339d3810ff9SJared McNeill { "TX_DMA_CUR_DESC", EMAC_TX_DMA_CUR_DESC }, 1340d3810ff9SJared McNeill { "TX_DMA_CUR_BUF", EMAC_TX_DMA_CUR_BUF }, 1341d3810ff9SJared McNeill { "RX_DMA_STA", EMAC_RX_DMA_STA }, 1342d3810ff9SJared McNeill { "RX_DMA_CUR_DESC", EMAC_RX_DMA_CUR_DESC }, 1343d3810ff9SJared McNeill { "RX_DMA_CUR_BUF", EMAC_RX_DMA_CUR_BUF }, 1344d3810ff9SJared McNeill { "RGMII_STA", EMAC_RGMII_STA }, 1345d3810ff9SJared McNeill }; 1346d3810ff9SJared McNeill struct awg_softc *sc; 1347d3810ff9SJared McNeill unsigned int n; 1348d3810ff9SJared McNeill 1349d3810ff9SJared McNeill sc = device_get_softc(dev); 1350d3810ff9SJared McNeill 1351d3810ff9SJared McNeill for (n = 0; n < nitems(regs); n++) 1352d3810ff9SJared McNeill device_printf(dev, " %-20s %08x\n", regs[n].name, 1353d3810ff9SJared McNeill RD4(sc, regs[n].reg)); 1354d3810ff9SJared McNeill } 1355d3810ff9SJared McNeill #endif 1356d3810ff9SJared McNeill 135701a469b8SJared McNeill #define GPIO_ACTIVE_LOW 1 135801a469b8SJared McNeill 135901a469b8SJared McNeill static int 136001a469b8SJared McNeill awg_phy_reset(device_t dev) 136101a469b8SJared McNeill { 136201a469b8SJared McNeill pcell_t gpio_prop[4], delay_prop[3]; 136301a469b8SJared McNeill phandle_t node, gpio_node; 136401a469b8SJared McNeill device_t gpio; 136501a469b8SJared McNeill uint32_t pin, flags; 136601a469b8SJared McNeill uint32_t pin_value; 136701a469b8SJared McNeill 136801a469b8SJared McNeill node = ofw_bus_get_node(dev); 136901a469b8SJared McNeill if (OF_getencprop(node, "allwinner,reset-gpio", gpio_prop, 137001a469b8SJared McNeill sizeof(gpio_prop)) <= 0) 137101a469b8SJared McNeill return (0); 137201a469b8SJared McNeill 137301a469b8SJared McNeill if (OF_getencprop(node, "allwinner,reset-delays-us", delay_prop, 137401a469b8SJared McNeill sizeof(delay_prop)) <= 0) 137501a469b8SJared McNeill return (ENXIO); 137601a469b8SJared McNeill 137701a469b8SJared McNeill gpio_node = OF_node_from_xref(gpio_prop[0]); 137801a469b8SJared McNeill if ((gpio = OF_device_from_xref(gpio_prop[0])) == NULL) 137901a469b8SJared McNeill return (ENXIO); 138001a469b8SJared McNeill 138101a469b8SJared McNeill if (GPIO_MAP_GPIOS(gpio, node, gpio_node, nitems(gpio_prop) - 1, 138201a469b8SJared McNeill gpio_prop + 1, &pin, &flags) != 0) 138301a469b8SJared McNeill return (ENXIO); 138401a469b8SJared McNeill 138501a469b8SJared McNeill pin_value = GPIO_PIN_LOW; 138601a469b8SJared McNeill if (OF_hasprop(node, "allwinner,reset-active-low")) 138701a469b8SJared McNeill pin_value = GPIO_PIN_HIGH; 138801a469b8SJared McNeill 138901a469b8SJared McNeill if (flags & GPIO_ACTIVE_LOW) 139001a469b8SJared McNeill pin_value = !pin_value; 139101a469b8SJared McNeill 139201a469b8SJared McNeill GPIO_PIN_SETFLAGS(gpio, pin, GPIO_PIN_OUTPUT); 139301a469b8SJared McNeill GPIO_PIN_SET(gpio, pin, pin_value); 139401a469b8SJared McNeill DELAY(delay_prop[0]); 139501a469b8SJared McNeill GPIO_PIN_SET(gpio, pin, !pin_value); 139601a469b8SJared McNeill DELAY(delay_prop[1]); 139701a469b8SJared McNeill GPIO_PIN_SET(gpio, pin, pin_value); 139801a469b8SJared McNeill DELAY(delay_prop[2]); 139901a469b8SJared McNeill 140001a469b8SJared McNeill return (0); 140101a469b8SJared McNeill } 140201a469b8SJared McNeill 1403d3810ff9SJared McNeill static int 1404d3810ff9SJared McNeill awg_reset(device_t dev) 1405d3810ff9SJared McNeill { 1406d3810ff9SJared McNeill struct awg_softc *sc; 1407d3810ff9SJared McNeill int retry; 1408d3810ff9SJared McNeill 1409d3810ff9SJared McNeill sc = device_get_softc(dev); 1410d3810ff9SJared McNeill 141101a469b8SJared McNeill /* Reset PHY if necessary */ 141201a469b8SJared McNeill if (awg_phy_reset(dev) != 0) { 141301a469b8SJared McNeill device_printf(dev, "failed to reset PHY\n"); 141401a469b8SJared McNeill return (ENXIO); 141501a469b8SJared McNeill } 141601a469b8SJared McNeill 1417d3810ff9SJared McNeill /* Soft reset all registers and logic */ 1418d3810ff9SJared McNeill WR4(sc, EMAC_BASIC_CTL_1, BASIC_CTL_SOFT_RST); 1419d3810ff9SJared McNeill 1420d3810ff9SJared McNeill /* Wait for soft reset bit to self-clear */ 1421d3810ff9SJared McNeill for (retry = SOFT_RST_RETRY; retry > 0; retry--) { 1422d3810ff9SJared McNeill if ((RD4(sc, EMAC_BASIC_CTL_1) & BASIC_CTL_SOFT_RST) == 0) 1423d3810ff9SJared McNeill break; 1424d3810ff9SJared McNeill DELAY(10); 1425d3810ff9SJared McNeill } 1426d3810ff9SJared McNeill if (retry == 0) { 1427d3810ff9SJared McNeill device_printf(dev, "soft reset timed out\n"); 1428d3810ff9SJared McNeill #ifdef AWG_DEBUG 1429d3810ff9SJared McNeill awg_dump_regs(dev); 1430d3810ff9SJared McNeill #endif 1431d3810ff9SJared McNeill return (ETIMEDOUT); 1432d3810ff9SJared McNeill } 1433d3810ff9SJared McNeill 1434d3810ff9SJared McNeill return (0); 1435d3810ff9SJared McNeill } 1436d3810ff9SJared McNeill 1437d3810ff9SJared McNeill static void 1438d3810ff9SJared McNeill awg_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) 1439d3810ff9SJared McNeill { 1440d3810ff9SJared McNeill if (error != 0) 1441d3810ff9SJared McNeill return; 1442d3810ff9SJared McNeill *(bus_addr_t *)arg = segs[0].ds_addr; 1443d3810ff9SJared McNeill } 1444d3810ff9SJared McNeill 1445d3810ff9SJared McNeill static int 1446d3810ff9SJared McNeill awg_setup_dma(device_t dev) 1447d3810ff9SJared McNeill { 1448d3810ff9SJared McNeill struct awg_softc *sc; 1449d3810ff9SJared McNeill struct mbuf *m; 1450d3810ff9SJared McNeill int error, i; 1451d3810ff9SJared McNeill 1452d3810ff9SJared McNeill sc = device_get_softc(dev); 1453d3810ff9SJared McNeill 1454d3810ff9SJared McNeill /* Setup TX ring */ 1455d3810ff9SJared McNeill error = bus_dma_tag_create( 1456d3810ff9SJared McNeill bus_get_dma_tag(dev), /* Parent tag */ 1457d3810ff9SJared McNeill DESC_ALIGN, 0, /* alignment, boundary */ 1458d3810ff9SJared McNeill BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 1459d3810ff9SJared McNeill BUS_SPACE_MAXADDR, /* highaddr */ 1460d3810ff9SJared McNeill NULL, NULL, /* filter, filterarg */ 1461d3810ff9SJared McNeill TX_DESC_SIZE, 1, /* maxsize, nsegs */ 1462d3810ff9SJared McNeill TX_DESC_SIZE, /* maxsegsize */ 1463d3810ff9SJared McNeill 0, /* flags */ 1464d3810ff9SJared McNeill NULL, NULL, /* lockfunc, lockarg */ 1465d3810ff9SJared McNeill &sc->tx.desc_tag); 1466d3810ff9SJared McNeill if (error != 0) { 1467d3810ff9SJared McNeill device_printf(dev, "cannot create TX descriptor ring tag\n"); 1468d3810ff9SJared McNeill return (error); 1469d3810ff9SJared McNeill } 1470d3810ff9SJared McNeill 1471d3810ff9SJared McNeill error = bus_dmamem_alloc(sc->tx.desc_tag, (void **)&sc->tx.desc_ring, 1472d3810ff9SJared McNeill BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->tx.desc_map); 1473d3810ff9SJared McNeill if (error != 0) { 1474d3810ff9SJared McNeill device_printf(dev, "cannot allocate TX descriptor ring\n"); 1475d3810ff9SJared McNeill return (error); 1476d3810ff9SJared McNeill } 1477d3810ff9SJared McNeill 1478d3810ff9SJared McNeill error = bus_dmamap_load(sc->tx.desc_tag, sc->tx.desc_map, 1479d3810ff9SJared McNeill sc->tx.desc_ring, TX_DESC_SIZE, awg_dmamap_cb, 1480d3810ff9SJared McNeill &sc->tx.desc_ring_paddr, 0); 1481d3810ff9SJared McNeill if (error != 0) { 1482d3810ff9SJared McNeill device_printf(dev, "cannot load TX descriptor ring\n"); 1483d3810ff9SJared McNeill return (error); 1484d3810ff9SJared McNeill } 1485d3810ff9SJared McNeill 1486d3810ff9SJared McNeill for (i = 0; i < TX_DESC_COUNT; i++) 1487d3810ff9SJared McNeill sc->tx.desc_ring[i].next = 1488d3810ff9SJared McNeill htole32(sc->tx.desc_ring_paddr + DESC_OFF(TX_NEXT(i))); 1489d3810ff9SJared McNeill 1490d3810ff9SJared McNeill error = bus_dma_tag_create( 1491d3810ff9SJared McNeill bus_get_dma_tag(dev), /* Parent tag */ 1492d3810ff9SJared McNeill 1, 0, /* alignment, boundary */ 1493d3810ff9SJared McNeill BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 1494d3810ff9SJared McNeill BUS_SPACE_MAXADDR, /* highaddr */ 1495d3810ff9SJared McNeill NULL, NULL, /* filter, filterarg */ 1496d3810ff9SJared McNeill MCLBYTES, TX_MAX_SEGS, /* maxsize, nsegs */ 1497d3810ff9SJared McNeill MCLBYTES, /* maxsegsize */ 1498d3810ff9SJared McNeill 0, /* flags */ 1499d3810ff9SJared McNeill NULL, NULL, /* lockfunc, lockarg */ 1500d3810ff9SJared McNeill &sc->tx.buf_tag); 1501d3810ff9SJared McNeill if (error != 0) { 1502d3810ff9SJared McNeill device_printf(dev, "cannot create TX buffer tag\n"); 1503d3810ff9SJared McNeill return (error); 1504d3810ff9SJared McNeill } 1505d3810ff9SJared McNeill 1506d3810ff9SJared McNeill sc->tx.queued = TX_DESC_COUNT; 1507d3810ff9SJared McNeill for (i = 0; i < TX_DESC_COUNT; i++) { 1508d3810ff9SJared McNeill error = bus_dmamap_create(sc->tx.buf_tag, 0, 1509d3810ff9SJared McNeill &sc->tx.buf_map[i].map); 1510d3810ff9SJared McNeill if (error != 0) { 1511d3810ff9SJared McNeill device_printf(dev, "cannot create TX buffer map\n"); 1512d3810ff9SJared McNeill return (error); 1513d3810ff9SJared McNeill } 1514d3810ff9SJared McNeill awg_setup_txdesc(sc, i, 0, 0, 0); 1515d3810ff9SJared McNeill } 1516d3810ff9SJared McNeill 1517d3810ff9SJared McNeill /* Setup RX ring */ 1518d3810ff9SJared McNeill error = bus_dma_tag_create( 1519d3810ff9SJared McNeill bus_get_dma_tag(dev), /* Parent tag */ 1520d3810ff9SJared McNeill DESC_ALIGN, 0, /* alignment, boundary */ 1521d3810ff9SJared McNeill BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 1522d3810ff9SJared McNeill BUS_SPACE_MAXADDR, /* highaddr */ 1523d3810ff9SJared McNeill NULL, NULL, /* filter, filterarg */ 1524d3810ff9SJared McNeill RX_DESC_SIZE, 1, /* maxsize, nsegs */ 1525d3810ff9SJared McNeill RX_DESC_SIZE, /* maxsegsize */ 1526d3810ff9SJared McNeill 0, /* flags */ 1527d3810ff9SJared McNeill NULL, NULL, /* lockfunc, lockarg */ 1528d3810ff9SJared McNeill &sc->rx.desc_tag); 1529d3810ff9SJared McNeill if (error != 0) { 1530d3810ff9SJared McNeill device_printf(dev, "cannot create RX descriptor ring tag\n"); 1531d3810ff9SJared McNeill return (error); 1532d3810ff9SJared McNeill } 1533d3810ff9SJared McNeill 1534d3810ff9SJared McNeill error = bus_dmamem_alloc(sc->rx.desc_tag, (void **)&sc->rx.desc_ring, 1535d3810ff9SJared McNeill BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->rx.desc_map); 1536d3810ff9SJared McNeill if (error != 0) { 1537d3810ff9SJared McNeill device_printf(dev, "cannot allocate RX descriptor ring\n"); 1538d3810ff9SJared McNeill return (error); 1539d3810ff9SJared McNeill } 1540d3810ff9SJared McNeill 1541d3810ff9SJared McNeill error = bus_dmamap_load(sc->rx.desc_tag, sc->rx.desc_map, 1542d3810ff9SJared McNeill sc->rx.desc_ring, RX_DESC_SIZE, awg_dmamap_cb, 1543d3810ff9SJared McNeill &sc->rx.desc_ring_paddr, 0); 1544d3810ff9SJared McNeill if (error != 0) { 1545d3810ff9SJared McNeill device_printf(dev, "cannot load RX descriptor ring\n"); 1546d3810ff9SJared McNeill return (error); 1547d3810ff9SJared McNeill } 1548d3810ff9SJared McNeill 1549d3810ff9SJared McNeill error = bus_dma_tag_create( 1550d3810ff9SJared McNeill bus_get_dma_tag(dev), /* Parent tag */ 1551d3810ff9SJared McNeill 1, 0, /* alignment, boundary */ 1552d3810ff9SJared McNeill BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 1553d3810ff9SJared McNeill BUS_SPACE_MAXADDR, /* highaddr */ 1554d3810ff9SJared McNeill NULL, NULL, /* filter, filterarg */ 1555d3810ff9SJared McNeill MCLBYTES, 1, /* maxsize, nsegs */ 1556d3810ff9SJared McNeill MCLBYTES, /* maxsegsize */ 1557d3810ff9SJared McNeill 0, /* flags */ 1558d3810ff9SJared McNeill NULL, NULL, /* lockfunc, lockarg */ 1559d3810ff9SJared McNeill &sc->rx.buf_tag); 1560d3810ff9SJared McNeill if (error != 0) { 1561d3810ff9SJared McNeill device_printf(dev, "cannot create RX buffer tag\n"); 1562d3810ff9SJared McNeill return (error); 1563d3810ff9SJared McNeill } 1564d3810ff9SJared McNeill 1565d3810ff9SJared McNeill for (i = 0; i < RX_DESC_COUNT; i++) { 1566d3810ff9SJared McNeill error = bus_dmamap_create(sc->rx.buf_tag, 0, 1567d3810ff9SJared McNeill &sc->rx.buf_map[i].map); 1568d3810ff9SJared McNeill if (error != 0) { 1569d3810ff9SJared McNeill device_printf(dev, "cannot create RX buffer map\n"); 1570d3810ff9SJared McNeill return (error); 1571d3810ff9SJared McNeill } 1572d3810ff9SJared McNeill if ((m = awg_alloc_mbufcl(sc)) == NULL) { 1573d3810ff9SJared McNeill device_printf(dev, "cannot allocate RX mbuf\n"); 1574d3810ff9SJared McNeill return (ENOMEM); 1575d3810ff9SJared McNeill } 1576d3810ff9SJared McNeill error = awg_setup_rxbuf(sc, i, m); 1577d3810ff9SJared McNeill if (error != 0) { 1578d3810ff9SJared McNeill device_printf(dev, "cannot create RX buffer\n"); 1579d3810ff9SJared McNeill return (error); 1580d3810ff9SJared McNeill } 1581d3810ff9SJared McNeill } 1582d3810ff9SJared McNeill bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map, 1583d3810ff9SJared McNeill BUS_DMASYNC_PREWRITE); 1584d3810ff9SJared McNeill 1585d3810ff9SJared McNeill /* Write transmit and receive descriptor base address registers */ 1586d3810ff9SJared McNeill WR4(sc, EMAC_TX_DMA_LIST, sc->tx.desc_ring_paddr); 1587d3810ff9SJared McNeill WR4(sc, EMAC_RX_DMA_LIST, sc->rx.desc_ring_paddr); 1588d3810ff9SJared McNeill 1589d3810ff9SJared McNeill return (0); 1590d3810ff9SJared McNeill } 1591d3810ff9SJared McNeill 1592d3810ff9SJared McNeill static int 1593d3810ff9SJared McNeill awg_probe(device_t dev) 1594d3810ff9SJared McNeill { 1595d3810ff9SJared McNeill if (!ofw_bus_status_okay(dev)) 1596d3810ff9SJared McNeill return (ENXIO); 1597d3810ff9SJared McNeill 1598d3810ff9SJared McNeill if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) 1599d3810ff9SJared McNeill return (ENXIO); 1600d3810ff9SJared McNeill 1601d3810ff9SJared McNeill device_set_desc(dev, "Allwinner Gigabit Ethernet"); 1602d3810ff9SJared McNeill return (BUS_PROBE_DEFAULT); 1603d3810ff9SJared McNeill } 1604d3810ff9SJared McNeill 1605d3810ff9SJared McNeill static int 1606d3810ff9SJared McNeill awg_attach(device_t dev) 1607d3810ff9SJared McNeill { 1608d3810ff9SJared McNeill uint8_t eaddr[ETHER_ADDR_LEN]; 1609d3810ff9SJared McNeill struct awg_softc *sc; 1610d3810ff9SJared McNeill phandle_t node; 1611d3810ff9SJared McNeill int error; 1612d3810ff9SJared McNeill 1613d3810ff9SJared McNeill sc = device_get_softc(dev); 161401a469b8SJared McNeill sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data; 1615d3810ff9SJared McNeill node = ofw_bus_get_node(dev); 1616d3810ff9SJared McNeill 1617d3810ff9SJared McNeill if (bus_alloc_resources(dev, awg_spec, sc->res) != 0) { 1618d3810ff9SJared McNeill device_printf(dev, "cannot allocate resources for device\n"); 1619d3810ff9SJared McNeill return (ENXIO); 1620d3810ff9SJared McNeill } 1621d3810ff9SJared McNeill 1622d3810ff9SJared McNeill mtx_init(&sc->mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK, MTX_DEF); 1623d3810ff9SJared McNeill callout_init_mtx(&sc->stat_ch, &sc->mtx, 0); 1624d3810ff9SJared McNeill TASK_INIT(&sc->link_task, 0, awg_link_task, sc); 1625d3810ff9SJared McNeill 1626d3810ff9SJared McNeill /* Setup clocks and regulators */ 1627d3810ff9SJared McNeill error = awg_setup_extres(dev); 1628d3810ff9SJared McNeill if (error != 0) 1629d3810ff9SJared McNeill return (error); 1630d3810ff9SJared McNeill 1631d3810ff9SJared McNeill /* Read MAC address before resetting the chip */ 1632d3810ff9SJared McNeill awg_get_eaddr(dev, eaddr); 1633d3810ff9SJared McNeill 1634d3810ff9SJared McNeill /* Soft reset EMAC core */ 1635d3810ff9SJared McNeill error = awg_reset(dev); 1636d3810ff9SJared McNeill if (error != 0) 1637d3810ff9SJared McNeill return (error); 1638d3810ff9SJared McNeill 1639d3810ff9SJared McNeill /* Setup DMA descriptors */ 1640d3810ff9SJared McNeill error = awg_setup_dma(dev); 1641d3810ff9SJared McNeill if (error != 0) 1642d3810ff9SJared McNeill return (error); 1643d3810ff9SJared McNeill 1644d3810ff9SJared McNeill /* Install interrupt handler */ 164501a469b8SJared McNeill error = bus_setup_intr(dev, sc->res[_RES_IRQ], 164601a469b8SJared McNeill INTR_TYPE_NET | INTR_MPSAFE, NULL, awg_intr, sc, &sc->ih); 1647d3810ff9SJared McNeill if (error != 0) { 1648d3810ff9SJared McNeill device_printf(dev, "cannot setup interrupt handler\n"); 1649d3810ff9SJared McNeill return (error); 1650d3810ff9SJared McNeill } 1651d3810ff9SJared McNeill 1652d3810ff9SJared McNeill /* Setup ethernet interface */ 1653d3810ff9SJared McNeill sc->ifp = if_alloc(IFT_ETHER); 1654d3810ff9SJared McNeill if_setsoftc(sc->ifp, sc); 1655d3810ff9SJared McNeill if_initname(sc->ifp, device_get_name(dev), device_get_unit(dev)); 1656d3810ff9SJared McNeill if_setflags(sc->ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST); 1657d3810ff9SJared McNeill if_setstartfn(sc->ifp, awg_start); 1658d3810ff9SJared McNeill if_setioctlfn(sc->ifp, awg_ioctl); 1659d3810ff9SJared McNeill if_setinitfn(sc->ifp, awg_init); 1660d3810ff9SJared McNeill if_setsendqlen(sc->ifp, TX_DESC_COUNT - 1); 1661d3810ff9SJared McNeill if_setsendqready(sc->ifp); 1662d3810ff9SJared McNeill if_sethwassist(sc->ifp, CSUM_IP | CSUM_UDP | CSUM_TCP); 1663d3810ff9SJared McNeill if_setcapabilities(sc->ifp, IFCAP_VLAN_MTU | IFCAP_HWCSUM); 1664d3810ff9SJared McNeill if_setcapenable(sc->ifp, if_getcapabilities(sc->ifp)); 166516928528SJared McNeill #ifdef DEVICE_POLLING 166616928528SJared McNeill if_setcapabilitiesbit(sc->ifp, IFCAP_POLLING, 0); 166716928528SJared McNeill #endif 1668d3810ff9SJared McNeill 1669d3810ff9SJared McNeill /* Attach MII driver */ 1670d3810ff9SJared McNeill error = mii_attach(dev, &sc->miibus, sc->ifp, awg_media_change, 1671d3810ff9SJared McNeill awg_media_status, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 1672d3810ff9SJared McNeill MIIF_DOPAUSE); 1673d3810ff9SJared McNeill if (error != 0) { 1674d3810ff9SJared McNeill device_printf(dev, "cannot attach PHY\n"); 1675d3810ff9SJared McNeill return (error); 1676d3810ff9SJared McNeill } 1677d3810ff9SJared McNeill 1678d3810ff9SJared McNeill /* Attach ethernet interface */ 1679d3810ff9SJared McNeill ether_ifattach(sc->ifp, eaddr); 1680d3810ff9SJared McNeill 1681d3810ff9SJared McNeill return (0); 1682d3810ff9SJared McNeill } 1683d3810ff9SJared McNeill 1684d3810ff9SJared McNeill static device_method_t awg_methods[] = { 1685d3810ff9SJared McNeill /* Device interface */ 1686d3810ff9SJared McNeill DEVMETHOD(device_probe, awg_probe), 1687d3810ff9SJared McNeill DEVMETHOD(device_attach, awg_attach), 1688d3810ff9SJared McNeill 1689d3810ff9SJared McNeill /* MII interface */ 1690d3810ff9SJared McNeill DEVMETHOD(miibus_readreg, awg_miibus_readreg), 1691d3810ff9SJared McNeill DEVMETHOD(miibus_writereg, awg_miibus_writereg), 1692d3810ff9SJared McNeill DEVMETHOD(miibus_statchg, awg_miibus_statchg), 1693d3810ff9SJared McNeill 1694d3810ff9SJared McNeill DEVMETHOD_END 1695d3810ff9SJared McNeill }; 1696d3810ff9SJared McNeill 1697d3810ff9SJared McNeill static driver_t awg_driver = { 1698d3810ff9SJared McNeill "awg", 1699d3810ff9SJared McNeill awg_methods, 1700d3810ff9SJared McNeill sizeof(struct awg_softc), 1701d3810ff9SJared McNeill }; 1702d3810ff9SJared McNeill 1703d3810ff9SJared McNeill static devclass_t awg_devclass; 1704d3810ff9SJared McNeill 1705d3810ff9SJared McNeill DRIVER_MODULE(awg, simplebus, awg_driver, awg_devclass, 0, 0); 1706d3810ff9SJared McNeill DRIVER_MODULE(miibus, awg, miibus_driver, miibus_devclass, 0, 0); 1707d3810ff9SJared McNeill 1708d3810ff9SJared McNeill MODULE_DEPEND(awg, ether, 1, 1, 1); 1709d3810ff9SJared McNeill MODULE_DEPEND(awg, miibus, 1, 1, 1); 1710