sys/arm/allwinner/if_awg.c

   1 /*-
   2  * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  18  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  20  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  21  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 /*
  29  * Allwinner Gigabit Ethernet MAC (EMAC) controller
  30  */
  31
  32 #include "opt_device_polling.h"
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/bus.h>
  40 #include <sys/rman.h>
  41 #include <sys/kernel.h>
  42 #include <sys/endian.h>
  43 #include <sys/mbuf.h>
  44 #include <sys/socket.h>
  45 #include <sys/sockio.h>
  46 #include <sys/module.h>
  47 #include <sys/gpio.h>
  48
  49 #include <net/bpf.h>
  50 #include <net/if.h>
  51 #include <net/ethernet.h>
  52 #include <net/if_dl.h>
  53 #include <net/if_media.h>
  54 #include <net/if_types.h>
  55 #include <net/if_var.h>
  56
  57 #include <machine/bus.h>
  58
  59 #include <dev/ofw/ofw_bus.h>
  60 #include <dev/ofw/ofw_bus_subr.h>
  61
  62 #include <arm/allwinner/if_awgreg.h>
  63 #include <arm/allwinner/aw_sid.h>
  64 #include <dev/mii/mii.h>
  65 #include <dev/mii/miivar.h>
  66
  67 #include <dev/extres/clk/clk.h>
  68 #include <dev/extres/hwreset/hwreset.h>
  69 #include <dev/extres/regulator/regulator.h>
  70 #include <dev/extres/syscon/syscon.h>
  71
  72 #include "syscon_if.h"
  73 #include "miibus_if.h"
  74 #include "gpio_if.h"
  75
  76 #define RD4(sc, reg)            bus_read_4((sc)->res[_RES_EMAC], (reg))
  77 #define WR4(sc, reg, val)       bus_write_4((sc)->res[_RES_EMAC], (reg), (val))
  78
  79 #define AWG_LOCK(sc)            mtx_lock(&(sc)->mtx)
  80 #define AWG_UNLOCK(sc)          mtx_unlock(&(sc)->mtx);
  81 #define AWG_ASSERT_LOCKED(sc)   mtx_assert(&(sc)->mtx, MA_OWNED)
  82 #define AWG_ASSERT_UNLOCKED(sc) mtx_assert(&(sc)->mtx, MA_NOTOWNED)
  83
  84 #define DESC_ALIGN              4
  85 #define TX_DESC_COUNT           1024
  86 #define TX_DESC_SIZE            (sizeof(struct emac_desc) * TX_DESC_COUNT)
  87 #define RX_DESC_COUNT           256
  88 #define RX_DESC_SIZE            (sizeof(struct emac_desc) * RX_DESC_COUNT)
  89
  90 #define DESC_OFF(n)             ((n) * sizeof(struct emac_desc))
  91 #define TX_NEXT(n)              (((n) + 1) & (TX_DESC_COUNT - 1))
  92 #define TX_SKIP(n, o)           (((n) + (o)) & (TX_DESC_COUNT - 1))
  93 #define RX_NEXT(n)              (((n) + 1) & (RX_DESC_COUNT - 1))
  94
  95 #define TX_MAX_SEGS             20
  96
  97 #define SOFT_RST_RETRY          1000
  98 #define MII_BUSY_RETRY          1000
  99 #define MDIO_FREQ               2500000
 100
 101 #define BURST_LEN_DEFAULT       8
 102 #define RX_TX_PRI_DEFAULT       0
 103 #define PAUSE_TIME_DEFAULT      0x400
 104 #define TX_INTERVAL_DEFAULT     64
 105 #define RX_BATCH_DEFAULT        64
 106
 107 /* syscon EMAC clock register */
 108 #define EMAC_CLK_REG            0x30
 109 #define EMAC_CLK_EPHY_ADDR      (0x1f << 20)    /* H3 */
 110 #define EMAC_CLK_EPHY_ADDR_SHIFT 20
 111 #define EMAC_CLK_EPHY_LED_POL   (1 << 17)       /* H3 */
 112 #define EMAC_CLK_EPHY_SHUTDOWN  (1 << 16)       /* H3 */
 113 #define EMAC_CLK_EPHY_SELECT    (1 << 15)       /* H3 */
 114 #define EMAC_CLK_RMII_EN        (1 << 13)
 115 #define EMAC_CLK_ETXDC          (0x7 << 10)
 116 #define EMAC_CLK_ETXDC_SHIFT    10
 117 #define EMAC_CLK_ERXDC          (0x1f << 5)
 118 #define EMAC_CLK_ERXDC_SHIFT    5
 119 #define EMAC_CLK_PIT            (0x1 << 2)
 120 #define  EMAC_CLK_PIT_MII       (0 << 2)
 121 #define  EMAC_CLK_PIT_RGMII     (1 << 2)
 122 #define EMAC_CLK_SRC            (0x3 << 0)
 123 #define  EMAC_CLK_SRC_MII       (0 << 0)
 124 #define  EMAC_CLK_SRC_EXT_RGMII (1 << 0)
 125 #define  EMAC_CLK_SRC_RGMII     (2 << 0)
 126
 127 /* Burst length of RX and TX DMA transfers */
 128 static int awg_burst_len = BURST_LEN_DEFAULT;
 129 TUNABLE_INT("hw.awg.burst_len", &awg_burst_len);
 130
 131 /* RX / TX DMA priority. If 1, RX DMA has priority over TX DMA. */
 132 static int awg_rx_tx_pri = RX_TX_PRI_DEFAULT;
 133 TUNABLE_INT("hw.awg.rx_tx_pri", &awg_rx_tx_pri);
 134
 135 /* Pause time field in the transmitted control frame */
 136 static int awg_pause_time = PAUSE_TIME_DEFAULT;
 137 TUNABLE_INT("hw.awg.pause_time", &awg_pause_time);
 138
 139 /* Request a TX interrupt every <n> descriptors */
 140 static int awg_tx_interval = TX_INTERVAL_DEFAULT;
 141 TUNABLE_INT("hw.awg.tx_interval", &awg_tx_interval);
 142
 143 /* Maximum number of mbufs to send to if_input */
 144 static int awg_rx_batch = RX_BATCH_DEFAULT;
 145 TUNABLE_INT("hw.awg.rx_batch", &awg_rx_batch);
 146
 147 enum awg_type {
 148         EMAC_A83T = 1,
 149         EMAC_H3,
 150         EMAC_A64,
 151 };
 152
 153 static struct ofw_compat_data compat_data[] = {
 154         { "allwinner,sun8i-a83t-emac",          EMAC_A83T },
 155         { "allwinner,sun8i-h3-emac",            EMAC_H3 },
 156         { "allwinner,sun50i-a64-emac",          EMAC_A64 },
 157         { NULL,                                 0 }
 158 };
 159
 160 struct awg_bufmap {
 161         bus_dmamap_t            map;
 162         struct mbuf             *mbuf;
 163 };
 164
 165 struct awg_txring {
 166         bus_dma_tag_t           desc_tag;
 167         bus_dmamap_t            desc_map;
 168         struct emac_desc        *desc_ring;
 169         bus_addr_t              desc_ring_paddr;
 170         bus_dma_tag_t           buf_tag;
 171         struct awg_bufmap       buf_map[TX_DESC_COUNT];
 172         u_int                   cur, next, queued;
 173         u_int                   segs;
 174 };
 175
 176 struct awg_rxring {
 177         bus_dma_tag_t           desc_tag;
 178         bus_dmamap_t            desc_map;
 179         struct emac_desc        *desc_ring;
 180         bus_addr_t              desc_ring_paddr;
 181         bus_dma_tag_t           buf_tag;
 182         struct awg_bufmap       buf_map[RX_DESC_COUNT];
 183         bus_dmamap_t            buf_spare_map;
 184         u_int                   cur;
 185 };
 186
 187 enum {
 188         _RES_EMAC,
 189         _RES_IRQ,
 190         _RES_SYSCON,
 191         _RES_NITEMS
 192 };
 193
 194 struct awg_softc {
 195         struct resource         *res[_RES_NITEMS];
 196         struct mtx              mtx;
 197         if_t                    ifp;
 198         device_t                dev;
 199         device_t                miibus;
 200         struct callout          stat_ch;
 201         void                    *ih;
 202         u_int                   mdc_div_ratio_m;
 203         int                     link;
 204         int                     if_flags;
 205         enum awg_type           type;
 206         struct syscon           *syscon;
 207
 208         struct awg_txring       tx;
 209         struct awg_rxring       rx;
 210 };
 211
 212 static struct resource_spec awg_spec[] = {
 213         { SYS_RES_MEMORY,       0,      RF_ACTIVE },
 214         { SYS_RES_IRQ,          0,      RF_ACTIVE },
 215         { SYS_RES_MEMORY,       1,      RF_ACTIVE | RF_OPTIONAL },
 216         { -1, 0 }
 217 };
 218
 219 static void awg_txeof(struct awg_softc *sc);
 220 static void awg_start_locked(struct awg_softc *sc);
 221
 222 static void awg_tick(void *softc);
 223
 224 static int awg_parse_delay(device_t dev, uint32_t *tx_delay,
 225     uint32_t *rx_delay);
 226 static uint32_t syscon_read_emac_clk_reg(device_t dev);
 227 static void syscon_write_emac_clk_reg(device_t dev, uint32_t val);
 228 static phandle_t awg_get_phy_node(device_t dev);
 229 static bool awg_has_internal_phy(device_t dev);
 230
 231 /*
 232  * MII functions
 233  */
 234
 235 static int
 236 awg_miibus_readreg(device_t dev, int phy, int reg)
 237 {
 238         struct awg_softc *sc;
 239         int retry, val;
 240
 241         sc = device_get_softc(dev);
 242         val = 0;
 243
 244         WR4(sc, EMAC_MII_CMD,
 245             (sc->mdc_div_ratio_m << MDC_DIV_RATIO_M_SHIFT) |
 246             (phy << PHY_ADDR_SHIFT) |
 247             (reg << PHY_REG_ADDR_SHIFT) |
 248             MII_BUSY);
 249         for (retry = MII_BUSY_RETRY; retry > 0; retry--) {
 250                 if ((RD4(sc, EMAC_MII_CMD) & MII_BUSY) == 0) {
 251                         val = RD4(sc, EMAC_MII_DATA);
 252                         break;
 253                 }
 254                 DELAY(10);
 255         }
 256
 257         if (retry == 0)
 258                 device_printf(dev, "phy read timeout, phy=%d reg=%d\n",
 259                     phy, reg);
 260
 261         return (val);
 262 }
 263
 264 static int
 265 awg_miibus_writereg(device_t dev, int phy, int reg, int val)
 266 {
 267         struct awg_softc *sc;
 268         int retry;
 269
 270         sc = device_get_softc(dev);
 271
 272         WR4(sc, EMAC_MII_DATA, val);
 273         WR4(sc, EMAC_MII_CMD,
 274             (sc->mdc_div_ratio_m << MDC_DIV_RATIO_M_SHIFT) |
 275             (phy << PHY_ADDR_SHIFT) |
 276             (reg << PHY_REG_ADDR_SHIFT) |
 277             MII_WR | MII_BUSY);
 278         for (retry = MII_BUSY_RETRY; retry > 0; retry--) {
 279                 if ((RD4(sc, EMAC_MII_CMD) & MII_BUSY) == 0)
 280                         break;
 281                 DELAY(10);
 282         }
 283
 284         if (retry == 0)
 285                 device_printf(dev, "phy write timeout, phy=%d reg=%d\n",
 286                     phy, reg);
 287
 288         return (0);
 289 }
 290
 291 static void
 292 awg_miibus_statchg(device_t dev)
 293 {
 294         struct awg_softc *sc;
 295         struct mii_data *mii;
 296         uint32_t val;
 297
 298         sc = device_get_softc(dev);
 299
 300         AWG_ASSERT_LOCKED(sc);
 301
 302         if ((if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) == 0)
 303                 return;
 304         mii = device_get_softc(sc->miibus);
 305
 306         if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
 307             (IFM_ACTIVE | IFM_AVALID)) {
 308                 switch (IFM_SUBTYPE(mii->mii_media_active)) {
 309                 case IFM_1000_T:
 310                 case IFM_1000_SX:
 311                 case IFM_100_TX:
 312                 case IFM_10_T:
 313                         sc->link = 1;
 314                         break;
 315                 default:
 316                         sc->link = 0;
 317                         break;
 318                 }
 319         } else
 320                 sc->link = 0;
 321
 322         if (sc->link == 0)
 323                 return;
 324
 325         val = RD4(sc, EMAC_BASIC_CTL_0);
 326         val &= ~(BASIC_CTL_SPEED | BASIC_CTL_DUPLEX);
 327
 328         if (IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T ||
 329             IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_SX)
 330                 val |= BASIC_CTL_SPEED_1000 << BASIC_CTL_SPEED_SHIFT;
 331         else if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX)
 332                 val |= BASIC_CTL_SPEED_100 << BASIC_CTL_SPEED_SHIFT;
 333         else
 334                 val |= BASIC_CTL_SPEED_10 << BASIC_CTL_SPEED_SHIFT;
 335
 336         if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
 337                 val |= BASIC_CTL_DUPLEX;
 338
 339         WR4(sc, EMAC_BASIC_CTL_0, val);
 340
 341         val = RD4(sc, EMAC_RX_CTL_0);
 342         val &= ~RX_FLOW_CTL_EN;
 343         if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0)
 344                 val |= RX_FLOW_CTL_EN;
 345         WR4(sc, EMAC_RX_CTL_0, val);
 346
 347         val = RD4(sc, EMAC_TX_FLOW_CTL);
 348         val &= ~(PAUSE_TIME|TX_FLOW_CTL_EN);
 349         if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0)
 350                 val |= TX_FLOW_CTL_EN;
 351         if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
 352                 val |= awg_pause_time << PAUSE_TIME_SHIFT;
 353         WR4(sc, EMAC_TX_FLOW_CTL, val);
 354 }
 355
 356 /*
 357  * Media functions
 358  */
 359
 360 static void
 361 awg_media_status(if_t ifp, struct ifmediareq *ifmr)
 362 {
 363         struct awg_softc *sc;
 364         struct mii_data *mii;
 365
 366         sc = if_getsoftc(ifp);
 367         mii = device_get_softc(sc->miibus);
 368
 369         AWG_LOCK(sc);
 370         mii_pollstat(mii);
 371         ifmr->ifm_active = mii->mii_media_active;
 372         ifmr->ifm_status = mii->mii_media_status;
 373         AWG_UNLOCK(sc);
 374 }
 375
 376 static int
 377 awg_media_change(if_t ifp)
 378 {
 379         struct awg_softc *sc;
 380         struct mii_data *mii;
 381         int error;
 382
 383         sc = if_getsoftc(ifp);
 384         mii = device_get_softc(sc->miibus);
 385
 386         AWG_LOCK(sc);
 387         error = mii_mediachg(mii);
 388         AWG_UNLOCK(sc);
 389
 390         return (error);
 391 }
 392
 393 /*
 394  * Core functions
 395  */
 396
 397 /* Bit Reversal - http://aggregate.org/MAGIC/#Bit%20Reversal */
 398 static uint32_t
 399 bitrev32(uint32_t x)
 400 {
 401         x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
 402         x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
 403         x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
 404         x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
 405
 406         return (x >> 16) | (x << 16);
 407 }
 408
 409 static u_int
 410 awg_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
 411 {
 412         uint32_t crc, hashreg, hashbit, *hash = arg;
 413
 414         crc = ether_crc32_le(LLADDR(sdl), ETHER_ADDR_LEN) & 0x7f;
 415         crc = bitrev32(~crc) >> 26;
 416         hashreg = (crc >> 5);
 417         hashbit = (crc & 0x1f);
 418         hash[hashreg] |= (1 << hashbit);
 419
 420         return (1);
 421 }
 422
 423 static void
 424 awg_setup_rxfilter(struct awg_softc *sc)
 425 {
 426         uint32_t val, hash[2], machi, maclo;
 427         uint8_t *eaddr;
 428         if_t ifp;
 429
 430         AWG_ASSERT_LOCKED(sc);
 431
 432         ifp = sc->ifp;
 433         val = 0;
 434         hash[0] = hash[1] = 0;
 435
 436         if (if_getflags(ifp) & IFF_PROMISC)
 437                 val |= DIS_ADDR_FILTER;
 438         else if (if_getflags(ifp) & IFF_ALLMULTI) {
 439                 val |= RX_ALL_MULTICAST;
 440                 hash[0] = hash[1] = ~0;
 441         } else if (if_foreach_llmaddr(ifp, awg_hash_maddr, hash) > 0)
 442                 val |= HASH_MULTICAST;
 443
 444         /* Write our unicast address */
 445         eaddr = if_getlladdr(ifp);
 446         machi = (eaddr[5] << 8) | eaddr[4];
 447         maclo = (eaddr[3] << 24) | (eaddr[2] << 16) | (eaddr[1] << 8) |
 448            (eaddr[0] << 0);
 449         WR4(sc, EMAC_ADDR_HIGH(0), machi);
 450         WR4(sc, EMAC_ADDR_LOW(0), maclo);
 451
 452         /* Multicast hash filters */
 453         WR4(sc, EMAC_RX_HASH_0, hash[1]);
 454         WR4(sc, EMAC_RX_HASH_1, hash[0]);
 455
 456         /* RX frame filter config */
 457         WR4(sc, EMAC_RX_FRM_FLT, val);
 458 }
 459
 460 static void
 461 awg_setup_core(struct awg_softc *sc)
 462 {
 463         uint32_t val;
 464
 465         AWG_ASSERT_LOCKED(sc);
 466         /* Configure DMA burst length and priorities */
 467         val = awg_burst_len << BASIC_CTL_BURST_LEN_SHIFT;
 468         if (awg_rx_tx_pri)
 469                 val |= BASIC_CTL_RX_TX_PRI;
 470         WR4(sc, EMAC_BASIC_CTL_1, val);
 471
 472 }
 473
 474 static void
 475 awg_enable_mac(struct awg_softc *sc, bool enable)
 476 {
 477         uint32_t tx, rx;
 478
 479         AWG_ASSERT_LOCKED(sc);
 480
 481         tx = RD4(sc, EMAC_TX_CTL_0);
 482         rx = RD4(sc, EMAC_RX_CTL_0);
 483         if (enable) {
 484                 tx |= TX_EN;
 485                 rx |= RX_EN | CHECK_CRC;
 486         } else {
 487                 tx &= ~TX_EN;
 488                 rx &= ~(RX_EN | CHECK_CRC);
 489         }
 490
 491         WR4(sc, EMAC_TX_CTL_0, tx);
 492         WR4(sc, EMAC_RX_CTL_0, rx);
 493 }
 494
 495 static void
 496 awg_get_eaddr(device_t dev, uint8_t *eaddr)
 497 {
 498         struct awg_softc *sc;
 499         uint32_t maclo, machi, rnd;
 500         u_char rootkey[16];
 501         uint32_t rootkey_size;
 502
 503         sc = device_get_softc(dev);
 504
 505         machi = RD4(sc, EMAC_ADDR_HIGH(0)) & 0xffff;
 506         maclo = RD4(sc, EMAC_ADDR_LOW(0));
 507
 508         rootkey_size = sizeof(rootkey);
 509         if (maclo == 0xffffffff && machi == 0xffff) {
 510                 /* MAC address in hardware is invalid, create one */
 511                 if (aw_sid_get_fuse(AW_SID_FUSE_ROOTKEY, rootkey,
 512                     &rootkey_size) == 0 &&
 513                     (rootkey[3] | rootkey[12] | rootkey[13] | rootkey[14] |
 514                      rootkey[15]) != 0) {
 515                         /* MAC address is derived from the root key in SID */
 516                         maclo = (rootkey[13] << 24) | (rootkey[12] << 16) |
 517                                 (rootkey[3] << 8) | 0x02;
 518                         machi = (rootkey[15] << 8) | rootkey[14];
 519                 } else {
 520                         /* Create one */
 521                         rnd = arc4random();
 522                         maclo = 0x00f2 | (rnd & 0xffff0000);
 523                         machi = rnd & 0xffff;
 524                 }
 525         }
 526
 527         eaddr[0] = maclo & 0xff;
 528         eaddr[1] = (maclo >> 8) & 0xff;
 529         eaddr[2] = (maclo >> 16) & 0xff;
 530         eaddr[3] = (maclo >> 24) & 0xff;
 531         eaddr[4] = machi & 0xff;
 532         eaddr[5] = (machi >> 8) & 0xff;
 533 }
 534
 535 /*
 536  * DMA functions
 537  */
 538
 539 static void
 540 awg_enable_dma_intr(struct awg_softc *sc)
 541 {
 542         /* Enable interrupts */
 543         WR4(sc, EMAC_INT_EN, RX_INT_EN | TX_INT_EN | TX_BUF_UA_INT_EN);
 544 }
 545
 546 static void
 547 awg_disable_dma_intr(struct awg_softc *sc)
 548 {
 549         /* Disable interrupts */
 550         WR4(sc, EMAC_INT_EN, 0);
 551 }
 552
 553 static void
 554 awg_init_dma(struct awg_softc *sc)
 555 {
 556         uint32_t val;
 557
 558         AWG_ASSERT_LOCKED(sc);
 559
 560         /* Enable interrupts */
 561 #ifdef DEVICE_POLLING
 562         if ((if_getcapenable(sc->ifp) & IFCAP_POLLING) == 0)
 563                 awg_enable_dma_intr(sc);
 564         else
 565                 awg_disable_dma_intr(sc);
 566 #else
 567         awg_enable_dma_intr(sc);
 568 #endif
 569
 570         /* Enable transmit DMA */
 571         val = RD4(sc, EMAC_TX_CTL_1);
 572         WR4(sc, EMAC_TX_CTL_1, val | TX_DMA_EN | TX_MD | TX_NEXT_FRAME);
 573
 574         /* Enable receive DMA */
 575         val = RD4(sc, EMAC_RX_CTL_1);
 576         WR4(sc, EMAC_RX_CTL_1, val | RX_DMA_EN | RX_MD);
 577 }
 578
 579 static void
 580 awg_stop_dma(struct awg_softc *sc)
 581 {
 582         uint32_t val;
 583
 584         AWG_ASSERT_LOCKED(sc);
 585
 586         /* Stop transmit DMA and flush data in the TX FIFO */
 587         val = RD4(sc, EMAC_TX_CTL_1);
 588         val &= ~TX_DMA_EN;
 589         val |= FLUSH_TX_FIFO;
 590         WR4(sc, EMAC_TX_CTL_1, val);
 591
 592         /* Disable interrupts */
 593         awg_disable_dma_intr(sc);
 594
 595         /* Disable transmit DMA */
 596         val = RD4(sc, EMAC_TX_CTL_1);
 597         WR4(sc, EMAC_TX_CTL_1, val & ~TX_DMA_EN);
 598
 599         /* Disable receive DMA */
 600         val = RD4(sc, EMAC_RX_CTL_1);
 601         WR4(sc, EMAC_RX_CTL_1, val & ~RX_DMA_EN);
 602 }
 603
 604 static int
 605 awg_encap(struct awg_softc *sc, struct mbuf **mp)
 606 {
 607         bus_dmamap_t map;
 608         bus_dma_segment_t segs[TX_MAX_SEGS];
 609         int error, nsegs, cur, first, last, i;
 610         u_int csum_flags;
 611         uint32_t flags, status;
 612         struct mbuf *m;
 613
 614         cur = first = sc->tx.cur;
 615         map = sc->tx.buf_map[first].map;
 616
 617         m = *mp;
 618         error = bus_dmamap_load_mbuf_sg(sc->tx.buf_tag, map, m, segs,
 619             &nsegs, BUS_DMA_NOWAIT);
 620         if (error == EFBIG) {
 621                 m = m_collapse(m, M_NOWAIT, TX_MAX_SEGS);
 622                 if (m == NULL) {
 623                         device_printf(sc->dev, "awg_encap: m_collapse failed\n");
 624                         m_freem(*mp);
 625                         *mp = NULL;
 626                         return (ENOMEM);
 627                 }
 628                 *mp = m;
 629                 error = bus_dmamap_load_mbuf_sg(sc->tx.buf_tag, map, m,
 630                     segs, &nsegs, BUS_DMA_NOWAIT);
 631                 if (error != 0) {
 632                         m_freem(*mp);
 633                         *mp = NULL;
 634                 }
 635         }
 636         if (error != 0) {
 637                 device_printf(sc->dev, "awg_encap: bus_dmamap_load_mbuf_sg failed\n");
 638                 return (error);
 639         }
 640         if (nsegs == 0) {
 641                 m_freem(*mp);
 642                 *mp = NULL;
 643                 return (EIO);
 644         }
 645
 646         if (sc->tx.queued + nsegs > TX_DESC_COUNT) {
 647                 bus_dmamap_unload(sc->tx.buf_tag, map);
 648                 return (ENOBUFS);
 649         }
 650
 651         bus_dmamap_sync(sc->tx.buf_tag, map, BUS_DMASYNC_PREWRITE);
 652
 653         flags = TX_FIR_DESC;
 654         status = 0;
 655         if ((m->m_pkthdr.csum_flags & CSUM_IP) != 0) {
 656                 if ((m->m_pkthdr.csum_flags & (CSUM_TCP|CSUM_UDP)) != 0)
 657                         csum_flags = TX_CHECKSUM_CTL_FULL;
 658                 else
 659                         csum_flags = TX_CHECKSUM_CTL_IP;
 660                 flags |= (csum_flags << TX_CHECKSUM_CTL_SHIFT);
 661         }
 662
 663         for (i = 0; i < nsegs; i++) {
 664                 sc->tx.segs++;
 665                 if (i == nsegs - 1) {
 666                         flags |= TX_LAST_DESC;
 667                         /*
 668                          * Can only request TX completion
 669                          * interrupt on last descriptor.
 670                          */
 671                         if (sc->tx.segs >= awg_tx_interval) {
 672                                 sc->tx.segs = 0;
 673                                 flags |= TX_INT_CTL;
 674                         }
 675                 }
 676
 677                 sc->tx.desc_ring[cur].addr = htole32((uint32_t)segs[i].ds_addr);
 678                 sc->tx.desc_ring[cur].size = htole32(flags | segs[i].ds_len);
 679                 sc->tx.desc_ring[cur].status = htole32(status);
 680
 681                 flags &= ~TX_FIR_DESC;
 682                 /*
 683                  * Setting of the valid bit in the first descriptor is
 684                  * deferred until the whole chain is fully set up.
 685                  */
 686                 status = TX_DESC_CTL;
 687
 688                 ++sc->tx.queued;
 689                 cur = TX_NEXT(cur);
 690         }
 691
 692         sc->tx.cur = cur;
 693
 694         /* Store mapping and mbuf in the last segment */
 695         last = TX_SKIP(cur, TX_DESC_COUNT - 1);
 696         sc->tx.buf_map[first].map = sc->tx.buf_map[last].map;
 697         sc->tx.buf_map[last].map = map;
 698         sc->tx.buf_map[last].mbuf = m;
 699
 700         /*
 701          * The whole mbuf chain has been DMA mapped,
 702          * fix the first descriptor.
 703          */
 704         sc->tx.desc_ring[first].status = htole32(TX_DESC_CTL);
 705
 706         return (0);
 707 }
 708
 709 static void
 710 awg_clean_txbuf(struct awg_softc *sc, int index)
 711 {
 712         struct awg_bufmap *bmap;
 713
 714         --sc->tx.queued;
 715
 716         bmap = &sc->tx.buf_map[index];
 717         if (bmap->mbuf != NULL) {
 718                 bus_dmamap_sync(sc->tx.buf_tag, bmap->map,
 719                     BUS_DMASYNC_POSTWRITE);
 720                 bus_dmamap_unload(sc->tx.buf_tag, bmap->map);
 721                 m_freem(bmap->mbuf);
 722                 bmap->mbuf = NULL;
 723         }
 724 }
 725
 726 static void
 727 awg_setup_rxdesc(struct awg_softc *sc, int index, bus_addr_t paddr)
 728 {
 729         uint32_t status, size;
 730
 731         status = RX_DESC_CTL;
 732         size = MCLBYTES - 1;
 733
 734         sc->rx.desc_ring[index].addr = htole32((uint32_t)paddr);
 735         sc->rx.desc_ring[index].size = htole32(size);
 736         sc->rx.desc_ring[index].status = htole32(status);
 737 }
 738
 739 static void
 740 awg_reuse_rxdesc(struct awg_softc *sc, int index)
 741 {
 742
 743         sc->rx.desc_ring[index].status = htole32(RX_DESC_CTL);
 744 }
 745
 746 static int
 747 awg_newbuf_rx(struct awg_softc *sc, int index)
 748 {
 749         struct mbuf *m;
 750         bus_dma_segment_t seg;
 751         bus_dmamap_t map;
 752         int nsegs;
 753
 754         m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
 755         if (m == NULL)
 756                 return (ENOBUFS);
 757
 758         m->m_pkthdr.len = m->m_len = m->m_ext.ext_size;
 759         m_adj(m, ETHER_ALIGN);
 760
 761         if (bus_dmamap_load_mbuf_sg(sc->rx.buf_tag, sc->rx.buf_spare_map,
 762             m, &seg, &nsegs, BUS_DMA_NOWAIT) != 0) {
 763                 m_freem(m);
 764                 return (ENOBUFS);
 765         }
 766
 767         if (sc->rx.buf_map[index].mbuf != NULL) {
 768                 bus_dmamap_sync(sc->rx.buf_tag, sc->rx.buf_map[index].map,
 769                     BUS_DMASYNC_POSTREAD);
 770                 bus_dmamap_unload(sc->rx.buf_tag, sc->rx.buf_map[index].map);
 771         }
 772         map = sc->rx.buf_map[index].map;
 773         sc->rx.buf_map[index].map = sc->rx.buf_spare_map;
 774         sc->rx.buf_spare_map = map;
 775         bus_dmamap_sync(sc->rx.buf_tag, sc->rx.buf_map[index].map,
 776             BUS_DMASYNC_PREREAD);
 777
 778         sc->rx.buf_map[index].mbuf = m;
 779         awg_setup_rxdesc(sc, index, seg.ds_addr);
 780
 781         return (0);
 782 }
 783
 784 static void
 785 awg_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 786 {
 787         if (error != 0)
 788                 return;
 789         *(bus_addr_t *)arg = segs[0].ds_addr;
 790 }
 791
 792 static int
 793 awg_setup_dma(device_t dev)
 794 {
 795         struct awg_softc *sc;
 796         int error, i;
 797
 798         sc = device_get_softc(dev);
 799
 800         /* Setup TX ring */
 801         error = bus_dma_tag_create(
 802             bus_get_dma_tag(dev),       /* Parent tag */
 803             DESC_ALIGN, 0,              /* alignment, boundary */
 804             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 805             BUS_SPACE_MAXADDR,          /* highaddr */
 806             NULL, NULL,                 /* filter, filterarg */
 807             TX_DESC_SIZE, 1,            /* maxsize, nsegs */
 808             TX_DESC_SIZE,               /* maxsegsize */
 809             0,                          /* flags */
 810             NULL, NULL,                 /* lockfunc, lockarg */
 811             &sc->tx.desc_tag);
 812         if (error != 0) {
 813                 device_printf(dev, "cannot create TX descriptor ring tag\n");
 814                 return (error);
 815         }
 816
 817         error = bus_dmamem_alloc(sc->tx.desc_tag, (void **)&sc->tx.desc_ring,
 818             BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->tx.desc_map);
 819         if (error != 0) {
 820                 device_printf(dev, "cannot allocate TX descriptor ring\n");
 821                 return (error);
 822         }
 823
 824         error = bus_dmamap_load(sc->tx.desc_tag, sc->tx.desc_map,
 825             sc->tx.desc_ring, TX_DESC_SIZE, awg_dmamap_cb,
 826             &sc->tx.desc_ring_paddr, 0);
 827         if (error != 0) {
 828                 device_printf(dev, "cannot load TX descriptor ring\n");
 829                 return (error);
 830         }
 831
 832         for (i = 0; i < TX_DESC_COUNT; i++)
 833                 sc->tx.desc_ring[i].next =
 834                     htole32(sc->tx.desc_ring_paddr + DESC_OFF(TX_NEXT(i)));
 835
 836         error = bus_dma_tag_create(
 837             bus_get_dma_tag(dev),       /* Parent tag */
 838             1, 0,                       /* alignment, boundary */
 839             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 840             BUS_SPACE_MAXADDR,          /* highaddr */
 841             NULL, NULL,                 /* filter, filterarg */
 842             MCLBYTES, TX_MAX_SEGS,      /* maxsize, nsegs */
 843             MCLBYTES,                   /* maxsegsize */
 844             0,                          /* flags */
 845             NULL, NULL,                 /* lockfunc, lockarg */
 846             &sc->tx.buf_tag);
 847         if (error != 0) {
 848                 device_printf(dev, "cannot create TX buffer tag\n");
 849                 return (error);
 850         }
 851
 852         sc->tx.queued = 0;
 853         for (i = 0; i < TX_DESC_COUNT; i++) {
 854                 error = bus_dmamap_create(sc->tx.buf_tag, 0,
 855                     &sc->tx.buf_map[i].map);
 856                 if (error != 0) {
 857                         device_printf(dev, "cannot create TX buffer map\n");
 858                         return (error);
 859                 }
 860         }
 861
 862         /* Setup RX ring */
 863         error = bus_dma_tag_create(
 864             bus_get_dma_tag(dev),       /* Parent tag */
 865             DESC_ALIGN, 0,              /* alignment, boundary */
 866             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 867             BUS_SPACE_MAXADDR,          /* highaddr */
 868             NULL, NULL,                 /* filter, filterarg */
 869             RX_DESC_SIZE, 1,            /* maxsize, nsegs */
 870             RX_DESC_SIZE,               /* maxsegsize */
 871             0,                          /* flags */
 872             NULL, NULL,                 /* lockfunc, lockarg */
 873             &sc->rx.desc_tag);
 874         if (error != 0) {
 875                 device_printf(dev, "cannot create RX descriptor ring tag\n");
 876                 return (error);
 877         }
 878
 879         error = bus_dmamem_alloc(sc->rx.desc_tag, (void **)&sc->rx.desc_ring,
 880             BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->rx.desc_map);
 881         if (error != 0) {
 882                 device_printf(dev, "cannot allocate RX descriptor ring\n");
 883                 return (error);
 884         }
 885
 886         error = bus_dmamap_load(sc->rx.desc_tag, sc->rx.desc_map,
 887             sc->rx.desc_ring, RX_DESC_SIZE, awg_dmamap_cb,
 888             &sc->rx.desc_ring_paddr, 0);
 889         if (error != 0) {
 890                 device_printf(dev, "cannot load RX descriptor ring\n");
 891                 return (error);
 892         }
 893
 894         error = bus_dma_tag_create(
 895             bus_get_dma_tag(dev),       /* Parent tag */
 896             1, 0,                       /* alignment, boundary */
 897             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 898             BUS_SPACE_MAXADDR,          /* highaddr */
 899             NULL, NULL,                 /* filter, filterarg */
 900             MCLBYTES, 1,                /* maxsize, nsegs */
 901             MCLBYTES,                   /* maxsegsize */
 902             0,                          /* flags */
 903             NULL, NULL,                 /* lockfunc, lockarg */
 904             &sc->rx.buf_tag);
 905         if (error != 0) {
 906                 device_printf(dev, "cannot create RX buffer tag\n");
 907                 return (error);
 908         }
 909
 910         error = bus_dmamap_create(sc->rx.buf_tag, 0, &sc->rx.buf_spare_map);
 911         if (error != 0) {
 912                 device_printf(dev,
 913                     "cannot create RX buffer spare map\n");
 914                 return (error);
 915         }
 916
 917         for (i = 0; i < RX_DESC_COUNT; i++) {
 918                 sc->rx.desc_ring[i].next =
 919                     htole32(sc->rx.desc_ring_paddr + DESC_OFF(RX_NEXT(i)));
 920
 921                 error = bus_dmamap_create(sc->rx.buf_tag, 0,
 922                     &sc->rx.buf_map[i].map);
 923                 if (error != 0) {
 924                         device_printf(dev, "cannot create RX buffer map\n");
 925                         return (error);
 926                 }
 927                 sc->rx.buf_map[i].mbuf = NULL;
 928                 error = awg_newbuf_rx(sc, i);
 929                 if (error != 0) {
 930                         device_printf(dev, "cannot create RX buffer\n");
 931                         return (error);
 932                 }
 933         }
 934         bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
 935             BUS_DMASYNC_PREWRITE);
 936
 937         /* Write transmit and receive descriptor base address registers */
 938         WR4(sc, EMAC_TX_DMA_LIST, sc->tx.desc_ring_paddr);
 939         WR4(sc, EMAC_RX_DMA_LIST, sc->rx.desc_ring_paddr);
 940
 941         return (0);
 942 }
 943
 944 static void
 945 awg_dma_start_tx(struct awg_softc *sc)
 946 {
 947         uint32_t val;
 948
 949         AWG_ASSERT_LOCKED(sc);
 950
 951         /* Start and run TX DMA */
 952         val = RD4(sc, EMAC_TX_CTL_1);
 953         WR4(sc, EMAC_TX_CTL_1, val | TX_DMA_START);
 954 }
 955
 956 /*
 957  * if_ functions
 958  */
 959
 960 static void
 961 awg_start_locked(struct awg_softc *sc)
 962 {
 963         struct mbuf *m;
 964         if_t ifp;
 965         int cnt, err;
 966
 967         AWG_ASSERT_LOCKED(sc);
 968
 969         if (!sc->link)
 970                 return;
 971
 972         ifp = sc->ifp;
 973
 974         if ((if_getdrvflags(ifp) & (IFF_DRV_RUNNING|IFF_DRV_OACTIVE)) !=
 975             IFF_DRV_RUNNING)
 976                 return;
 977
 978         for (cnt = 0; ; cnt++) {
 979                 m = if_dequeue(ifp);
 980                 if (m == NULL)
 981                         break;
 982
 983                 err = awg_encap(sc, &m);
 984                 if (err != 0) {
 985                         if (err == ENOBUFS)
 986                                 if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
 987                         if (m != NULL)
 988                                 if_sendq_prepend(ifp, m);
 989                         break;
 990                 }
 991                 if_bpfmtap(ifp, m);
 992         }
 993
 994         if (cnt != 0) {
 995                 bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map,
 996                     BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
 997
 998                 awg_dma_start_tx(sc);
 999         }
1000 }
1001
1002 static void
1003 awg_start(if_t ifp)
1004 {
1005         struct awg_softc *sc;
1006
1007         sc = if_getsoftc(ifp);
1008
1009         AWG_LOCK(sc);
1010         awg_start_locked(sc);
1011         AWG_UNLOCK(sc);
1012 }
1013
1014 static void
1015 awg_init_locked(struct awg_softc *sc)
1016 {
1017         struct mii_data *mii;
1018         if_t ifp;
1019
1020         mii = device_get_softc(sc->miibus);
1021         ifp = sc->ifp;
1022
1023         AWG_ASSERT_LOCKED(sc);
1024
1025         if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
1026                 return;
1027
1028         awg_setup_rxfilter(sc);
1029         awg_setup_core(sc);
1030         awg_enable_mac(sc, true);
1031         awg_init_dma(sc);
1032
1033         if_setdrvflagbits(ifp, IFF_DRV_RUNNING, IFF_DRV_OACTIVE);
1034
1035         mii_mediachg(mii);
1036         callout_reset(&sc->stat_ch, hz, awg_tick, sc);
1037 }
1038
1039 static void
1040 awg_init(void *softc)
1041 {
1042         struct awg_softc *sc;
1043
1044         sc = softc;
1045
1046         AWG_LOCK(sc);
1047         awg_init_locked(sc);
1048         AWG_UNLOCK(sc);
1049 }
1050
1051 static void
1052 awg_stop(struct awg_softc *sc)
1053 {
1054         if_t ifp;
1055         uint32_t val;
1056         int i;
1057
1058         AWG_ASSERT_LOCKED(sc);
1059
1060         ifp = sc->ifp;
1061
1062         callout_stop(&sc->stat_ch);
1063
1064         awg_stop_dma(sc);
1065         awg_enable_mac(sc, false);
1066
1067         sc->link = 0;
1068
1069         /* Finish handling transmitted buffers */
1070         awg_txeof(sc);
1071
1072         /* Release any untransmitted buffers. */
1073         for (i = sc->tx.next; sc->tx.queued > 0; i = TX_NEXT(i)) {
1074                 val = le32toh(sc->tx.desc_ring[i].status);
1075                 if ((val & TX_DESC_CTL) != 0)
1076                         break;
1077                 awg_clean_txbuf(sc, i);
1078         }
1079         sc->tx.next = i;
1080         for (; sc->tx.queued > 0; i = TX_NEXT(i)) {
1081                 sc->tx.desc_ring[i].status = 0;
1082                 awg_clean_txbuf(sc, i);
1083         }
1084         sc->tx.cur = sc->tx.next;
1085         bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map,
1086             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1087
1088         /* Setup RX buffers for reuse */
1089         bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
1090             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1091
1092         for (i = sc->rx.cur; ; i = RX_NEXT(i)) {
1093                 val = le32toh(sc->rx.desc_ring[i].status);
1094                 if ((val & RX_DESC_CTL) != 0)
1095                         break;
1096                 awg_reuse_rxdesc(sc, i);
1097         }
1098         sc->rx.cur = i;
1099         bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
1100             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1101
1102         if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1103 }
1104
1105 static int
1106 awg_ioctl(if_t ifp, u_long cmd, caddr_t data)
1107 {
1108         struct awg_softc *sc;
1109         struct mii_data *mii;
1110         struct ifreq *ifr;
1111         int flags, mask, error;
1112
1113         sc = if_getsoftc(ifp);
1114         mii = device_get_softc(sc->miibus);
1115         ifr = (struct ifreq *)data;
1116         error = 0;
1117
1118         switch (cmd) {
1119         case SIOCSIFFLAGS:
1120                 AWG_LOCK(sc);
1121                 if (if_getflags(ifp) & IFF_UP) {
1122                         if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
1123                                 flags = if_getflags(ifp) ^ sc->if_flags;
1124                                 if ((flags & (IFF_PROMISC|IFF_ALLMULTI)) != 0)
1125                                         awg_setup_rxfilter(sc);
1126                         } else
1127                                 awg_init_locked(sc);
1128                 } else {
1129                         if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
1130                                 awg_stop(sc);
1131                 }
1132                 sc->if_flags = if_getflags(ifp);
1133                 AWG_UNLOCK(sc);
1134                 break;
1135         case SIOCADDMULTI:
1136         case SIOCDELMULTI:
1137                 if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
1138                         AWG_LOCK(sc);
1139                         awg_setup_rxfilter(sc);
1140                         AWG_UNLOCK(sc);
1141                 }
1142                 break;
1143         case SIOCSIFMEDIA:
1144         case SIOCGIFMEDIA:
1145                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
1146                 break;
1147         case SIOCSIFCAP:
1148                 mask = ifr->ifr_reqcap ^ if_getcapenable(ifp);
1149 #ifdef DEVICE_POLLING
1150                 if (mask & IFCAP_POLLING) {
1151                         if ((ifr->ifr_reqcap & IFCAP_POLLING) != 0) {
1152                                 error = ether_poll_register(awg_poll, ifp);
1153                                 if (error != 0)
1154                                         break;
1155                                 AWG_LOCK(sc);
1156                                 awg_disable_dma_intr(sc);
1157                                 if_setcapenablebit(ifp, IFCAP_POLLING, 0);
1158                                 AWG_UNLOCK(sc);
1159                         } else {
1160                                 error = ether_poll_deregister(ifp);
1161                                 AWG_LOCK(sc);
1162                                 awg_enable_dma_intr(sc);
1163                                 if_setcapenablebit(ifp, 0, IFCAP_POLLING);
1164                                 AWG_UNLOCK(sc);
1165                         }
1166                 }
1167 #endif
1168                 if (mask & IFCAP_VLAN_MTU)
1169                         if_togglecapenable(ifp, IFCAP_VLAN_MTU);
1170                 if (mask & IFCAP_RXCSUM)
1171                         if_togglecapenable(ifp, IFCAP_RXCSUM);
1172                 if (mask & IFCAP_TXCSUM)
1173                         if_togglecapenable(ifp, IFCAP_TXCSUM);
1174                 if ((if_getcapenable(ifp) & IFCAP_TXCSUM) != 0)
1175                         if_sethwassistbits(ifp, CSUM_IP | CSUM_UDP | CSUM_TCP, 0);
1176                 else
1177                         if_sethwassistbits(ifp, 0, CSUM_IP | CSUM_UDP | CSUM_TCP);
1178                 break;
1179         default:
1180                 error = ether_ioctl(ifp, cmd, data);
1181                 break;
1182         }
1183
1184         return (error);
1185 }
1186
1187 /*
1188  * Interrupts functions
1189  */
1190
1191 static int
1192 awg_rxintr(struct awg_softc *sc)
1193 {
1194         if_t ifp;
1195         struct mbuf *m, *mh, *mt;
1196         int error, index, len, cnt, npkt;
1197         uint32_t status;
1198
1199         ifp = sc->ifp;
1200         mh = mt = NULL;
1201         cnt = 0;
1202         npkt = 0;
1203
1204         bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
1205             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1206
1207         for (index = sc->rx.cur; ; index = RX_NEXT(index)) {
1208                 status = le32toh(sc->rx.desc_ring[index].status);
1209                 if ((status & RX_DESC_CTL) != 0)
1210                         break;
1211
1212                 len = (status & RX_FRM_LEN) >> RX_FRM_LEN_SHIFT;
1213
1214                 if (len == 0) {
1215                         if ((status & (RX_NO_ENOUGH_BUF_ERR | RX_OVERFLOW_ERR)) != 0)
1216                                 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1217                         awg_reuse_rxdesc(sc, index);
1218                         continue;
1219                 }
1220
1221                 m = sc->rx.buf_map[index].mbuf;
1222
1223                 error = awg_newbuf_rx(sc, index);
1224                 if (error != 0) {
1225                         if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
1226                         awg_reuse_rxdesc(sc, index);
1227                         continue;
1228                 }
1229
1230                 m->m_pkthdr.rcvif = ifp;
1231                 m->m_pkthdr.len = len;
1232                 m->m_len = len;
1233                 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
1234
1235                 if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0 &&
1236                     (status & RX_FRM_TYPE) != 0) {
1237                         m->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
1238                         if ((status & RX_HEADER_ERR) == 0)
1239                                 m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
1240                         if ((status & RX_PAYLOAD_ERR) == 0) {
1241                                 m->m_pkthdr.csum_flags |=
1242                                     CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1243                                 m->m_pkthdr.csum_data = 0xffff;
1244                         }
1245                 }
1246
1247                 m->m_nextpkt = NULL;
1248                 if (mh == NULL)
1249                         mh = m;
1250                 else
1251                         mt->m_nextpkt = m;
1252                 mt = m;
1253                 ++cnt;
1254                 ++npkt;
1255
1256                 if (cnt == awg_rx_batch) {
1257                         AWG_UNLOCK(sc);
1258                         if_input(ifp, mh);
1259                         AWG_LOCK(sc);
1260                         mh = mt = NULL;
1261                         cnt = 0;
1262                 }
1263         }
1264
1265         if (index != sc->rx.cur) {
1266                 bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
1267                     BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1268         }
1269
1270         if (mh != NULL) {
1271                 AWG_UNLOCK(sc);
1272                 if_input(ifp, mh);
1273                 AWG_LOCK(sc);
1274         }
1275
1276         sc->rx.cur = index;
1277
1278         return (npkt);
1279 }
1280
1281 static void
1282 awg_txeof(struct awg_softc *sc)
1283 {
1284         struct emac_desc *desc;
1285         uint32_t status, size;
1286         if_t ifp;
1287         int i, prog;
1288
1289         AWG_ASSERT_LOCKED(sc);
1290
1291         bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map,
1292             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1293
1294         ifp = sc->ifp;
1295
1296         prog = 0;
1297         for (i = sc->tx.next; sc->tx.queued > 0; i = TX_NEXT(i)) {
1298                 desc = &sc->tx.desc_ring[i];
1299                 status = le32toh(desc->status);
1300                 if ((status & TX_DESC_CTL) != 0)
1301                         break;
1302                 size = le32toh(desc->size);
1303                 if (size & TX_LAST_DESC) {
1304                         if ((status & (TX_HEADER_ERR | TX_PAYLOAD_ERR)) != 0)
1305                                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1306                         else
1307                                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
1308                 }
1309                 prog++;
1310                 awg_clean_txbuf(sc, i);
1311         }
1312
1313         if (prog > 0) {
1314                 sc->tx.next = i;
1315                 if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
1316         }
1317 }
1318
1319 static void
1320 awg_intr(void *arg)
1321 {
1322         struct awg_softc *sc;
1323         uint32_t val;
1324
1325         sc = arg;
1326
1327         AWG_LOCK(sc);
1328         val = RD4(sc, EMAC_INT_STA);
1329         WR4(sc, EMAC_INT_STA, val);
1330
1331         if (val & RX_INT)
1332                 awg_rxintr(sc);
1333
1334         if (val & TX_INT)
1335                 awg_txeof(sc);
1336
1337         if (val & (TX_INT | TX_BUF_UA_INT)) {
1338                 if (!if_sendq_empty(sc->ifp))
1339                         awg_start_locked(sc);
1340         }
1341
1342         AWG_UNLOCK(sc);
1343 }
1344
1345 #ifdef DEVICE_POLLING
1346 static int
1347 awg_poll(if_t ifp, enum poll_cmd cmd, int count)
1348 {
1349         struct awg_softc *sc;
1350         uint32_t val;
1351         int rx_npkts;
1352
1353         sc = if_getsoftc(ifp);
1354         rx_npkts = 0;
1355
1356         AWG_LOCK(sc);
1357
1358         if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0) {
1359                 AWG_UNLOCK(sc);
1360                 return (0);
1361         }
1362
1363         rx_npkts = awg_rxintr(sc);
1364         awg_txeof(sc);
1365         if (!if_sendq_empty(ifp))
1366                 awg_start_locked(sc);
1367
1368         if (cmd == POLL_AND_CHECK_STATUS) {
1369                 val = RD4(sc, EMAC_INT_STA);
1370                 if (val != 0)
1371                         WR4(sc, EMAC_INT_STA, val);
1372         }
1373
1374         AWG_UNLOCK(sc);
1375
1376         return (rx_npkts);
1377 }
1378 #endif
1379
1380 /*
1381  * syscon functions
1382  */
1383 static uint32_t
1384 syscon_read_emac_clk_reg(device_t dev)
1385 {
1386         struct awg_softc *sc;
1387
1388         sc = device_get_softc(dev);
1389         if (sc->syscon != NULL)
1390                 return (SYSCON_READ_4(sc->syscon, EMAC_CLK_REG));
1391         else if (sc->res[_RES_SYSCON] != NULL)
1392                 return (bus_read_4(sc->res[_RES_SYSCON], 0));
1393
1394         return (0);
1395 }
1396
1397 static void
1398 syscon_write_emac_clk_reg(device_t dev, uint32_t val)
1399 {
1400         struct awg_softc *sc;
1401
1402         sc = device_get_softc(dev);
1403         if (sc->syscon != NULL)
1404                 SYSCON_WRITE_4(sc->syscon, EMAC_CLK_REG, val);
1405         else if (sc->res[_RES_SYSCON] != NULL)
1406                 bus_write_4(sc->res[_RES_SYSCON], 0, val);
1407 }
1408
1409 /*
1410  * PHY functions
1411  */
1412
1413 static phandle_t
1414 awg_get_phy_node(device_t dev)
1415 {
1416         phandle_t node;
1417         pcell_t phy_handle;
1418
1419         node = ofw_bus_get_node(dev);
1420         if (OF_getencprop(node, "phy-handle", (void *)&phy_handle,
1421             sizeof(phy_handle)) <= 0)
1422                 return (0);
1423
1424         return (OF_node_from_xref(phy_handle));
1425 }
1426
1427 static bool
1428 awg_has_internal_phy(device_t dev)
1429 {
1430         phandle_t node, phy_node;
1431
1432         node = ofw_bus_get_node(dev);
1433         /* Legacy binding */
1434         if (OF_hasprop(node, "allwinner,use-internal-phy"))
1435                 return (true);
1436
1437         phy_node = awg_get_phy_node(dev);
1438         return (phy_node != 0 && ofw_bus_node_is_compatible(OF_parent(phy_node),
1439             "allwinner,sun8i-h3-mdio-internal") != 0);
1440 }
1441
1442 static int
1443 awg_parse_delay(device_t dev, uint32_t *tx_delay, uint32_t *rx_delay)
1444 {
1445         phandle_t node;
1446         uint32_t delay;
1447
1448         if (tx_delay == NULL || rx_delay == NULL)
1449                 return (EINVAL);
1450         *tx_delay = *rx_delay = 0;
1451         node = ofw_bus_get_node(dev);
1452
1453         if (OF_getencprop(node, "tx-delay", &delay, sizeof(delay)) >= 0)
1454                 *tx_delay = delay;
1455         else if (OF_getencprop(node, "allwinner,tx-delay-ps", &delay,
1456             sizeof(delay)) >= 0) {
1457                 if ((delay % 100) != 0) {
1458                         device_printf(dev, "tx-delay-ps is not a multiple of 100\n");
1459                         return (EDOM);
1460                 }
1461                 *tx_delay = delay / 100;
1462         }
1463         if (*tx_delay > 7) {
1464                 device_printf(dev, "tx-delay out of range\n");
1465                 return (ERANGE);
1466         }
1467
1468         if (OF_getencprop(node, "rx-delay", &delay, sizeof(delay)) >= 0)
1469                 *rx_delay = delay;
1470         else if (OF_getencprop(node, "allwinner,rx-delay-ps", &delay,
1471             sizeof(delay)) >= 0) {
1472                 if ((delay % 100) != 0) {
1473                         device_printf(dev, "rx-delay-ps is not within documented domain\n");
1474                         return (EDOM);
1475                 }
1476                 *rx_delay = delay / 100;
1477         }
1478         if (*rx_delay > 31) {
1479                 device_printf(dev, "rx-delay out of range\n");
1480                 return (ERANGE);
1481         }
1482
1483         return (0);
1484 }
1485
1486 static int
1487 awg_setup_phy(device_t dev)
1488 {
1489         struct awg_softc *sc;
1490         clk_t clk_tx, clk_tx_parent;
1491         const char *tx_parent_name;
1492         char *phy_type;
1493         phandle_t node;
1494         uint32_t reg, tx_delay, rx_delay;
1495         int error;
1496         bool use_syscon;
1497
1498         sc = device_get_softc(dev);
1499         node = ofw_bus_get_node(dev);
1500         use_syscon = false;
1501
1502         if (OF_getprop_alloc(node, "phy-mode", (void **)&phy_type) == 0)
1503                 return (0);
1504
1505         if (sc->syscon != NULL || sc->res[_RES_SYSCON] != NULL)
1506                 use_syscon = true;
1507
1508         if (bootverbose)
1509                 device_printf(dev, "PHY type: %s, conf mode: %s\n", phy_type,
1510                     use_syscon ? "reg" : "clk");
1511
1512         if (use_syscon) {
1513                 /*
1514                  * Abstract away writing to syscon for devices like the pine64.
1515                  * For the pine64, we get dtb from U-Boot and it still uses the
1516                  * legacy setup of specifying syscon register in emac node
1517                  * rather than as its own node and using an xref in emac.
1518                  * These abstractions can go away once U-Boot dts is up-to-date.
1519                  */
1520                 reg = syscon_read_emac_clk_reg(dev);
1521                 reg &= ~(EMAC_CLK_PIT | EMAC_CLK_SRC | EMAC_CLK_RMII_EN);
1522                 if (strncmp(phy_type, "rgmii", 5) == 0)
1523                         reg |= EMAC_CLK_PIT_RGMII | EMAC_CLK_SRC_RGMII;
1524                 else if (strcmp(phy_type, "rmii") == 0)
1525                         reg |= EMAC_CLK_RMII_EN;
1526                 else
1527                         reg |= EMAC_CLK_PIT_MII | EMAC_CLK_SRC_MII;
1528
1529                 /*
1530                  * Fail attach if we fail to parse either of the delay
1531                  * parameters. If we don't have the proper delay to write to
1532                  * syscon, then awg likely won't function properly anyways.
1533                  * Lack of delay is not an error!
1534                  */
1535                 error = awg_parse_delay(dev, &tx_delay, &rx_delay);
1536                 if (error != 0)
1537                         goto fail;
1538
1539                 /* Default to 0 and we'll increase it if we need to. */
1540                 reg &= ~(EMAC_CLK_ETXDC | EMAC_CLK_ERXDC);
1541                 if (tx_delay > 0)
1542                         reg |= (tx_delay << EMAC_CLK_ETXDC_SHIFT);
1543                 if (rx_delay > 0)
1544                         reg |= (rx_delay << EMAC_CLK_ERXDC_SHIFT);
1545
1546                 if (sc->type == EMAC_H3) {
1547                         if (awg_has_internal_phy(dev)) {
1548                                 reg |= EMAC_CLK_EPHY_SELECT;
1549                                 reg &= ~EMAC_CLK_EPHY_SHUTDOWN;
1550                                 if (OF_hasprop(node,
1551                                     "allwinner,leds-active-low"))
1552                                         reg |= EMAC_CLK_EPHY_LED_POL;
1553                                 else
1554                                         reg &= ~EMAC_CLK_EPHY_LED_POL;
1555
1556                                 /* Set internal PHY addr to 1 */
1557                                 reg &= ~EMAC_CLK_EPHY_ADDR;
1558                                 reg |= (1 << EMAC_CLK_EPHY_ADDR_SHIFT);
1559                         } else {
1560                                 reg &= ~EMAC_CLK_EPHY_SELECT;
1561                         }
1562                 }
1563
1564                 if (bootverbose)
1565                         device_printf(dev, "EMAC clock: 0x%08x\n", reg);
1566                 syscon_write_emac_clk_reg(dev, reg);
1567         } else {
1568                 if (strncmp(phy_type, "rgmii", 5) == 0)
1569                         tx_parent_name = "emac_int_tx";
1570                 else
1571                         tx_parent_name = "mii_phy_tx";
1572
1573                 /* Get the TX clock */
1574                 error = clk_get_by_ofw_name(dev, 0, "tx", &clk_tx);
1575                 if (error != 0) {
1576                         device_printf(dev, "cannot get tx clock\n");
1577                         goto fail;
1578                 }
1579
1580                 /* Find the desired parent clock based on phy-mode property */
1581                 error = clk_get_by_name(dev, tx_parent_name, &clk_tx_parent);
1582                 if (error != 0) {
1583                         device_printf(dev, "cannot get clock '%s'\n",
1584                             tx_parent_name);
1585                         goto fail;
1586                 }
1587
1588                 /* Set TX clock parent */
1589                 error = clk_set_parent_by_clk(clk_tx, clk_tx_parent);
1590                 if (error != 0) {
1591                         device_printf(dev, "cannot set tx clock parent\n");
1592                         goto fail;
1593                 }
1594
1595                 /* Enable TX clock */
1596                 error = clk_enable(clk_tx);
1597                 if (error != 0) {
1598                         device_printf(dev, "cannot enable tx clock\n");
1599                         goto fail;
1600                 }
1601         }
1602
1603         error = 0;
1604
1605 fail:
1606         OF_prop_free(phy_type);
1607         return (error);
1608 }
1609
1610 static int
1611 awg_setup_extres(device_t dev)
1612 {
1613         struct awg_softc *sc;
1614         phandle_t node, phy_node;
1615         hwreset_t rst_ahb, rst_ephy;
1616         clk_t clk_ahb, clk_ephy;
1617         regulator_t reg;
1618         uint64_t freq;
1619         int error, div;
1620
1621         sc = device_get_softc(dev);
1622         rst_ahb = rst_ephy = NULL;
1623         clk_ahb = clk_ephy = NULL;
1624         reg = NULL;
1625         node = ofw_bus_get_node(dev);
1626         phy_node = awg_get_phy_node(dev);
1627
1628         if (phy_node == 0 && OF_hasprop(node, "phy-handle")) {
1629                 error = ENXIO;
1630                 device_printf(dev, "cannot get phy handle\n");
1631                 goto fail;
1632         }
1633
1634         /* Get AHB clock and reset resources */
1635         error = hwreset_get_by_ofw_name(dev, 0, "stmmaceth", &rst_ahb);
1636         if (error != 0)
1637                 error = hwreset_get_by_ofw_name(dev, 0, "ahb", &rst_ahb);
1638         if (error != 0) {
1639                 device_printf(dev, "cannot get ahb reset\n");
1640                 goto fail;
1641         }
1642         if (hwreset_get_by_ofw_name(dev, 0, "ephy", &rst_ephy) != 0)
1643                 if (phy_node == 0 || hwreset_get_by_ofw_idx(dev, phy_node, 0,
1644                     &rst_ephy) != 0)
1645                         rst_ephy = NULL;
1646         error = clk_get_by_ofw_name(dev, 0, "stmmaceth", &clk_ahb);
1647         if (error != 0)
1648                 error = clk_get_by_ofw_name(dev, 0, "ahb", &clk_ahb);
1649         if (error != 0) {
1650                 device_printf(dev, "cannot get ahb clock\n");
1651                 goto fail;
1652         }
1653         if (clk_get_by_ofw_name(dev, 0, "ephy", &clk_ephy) != 0)
1654                 if (phy_node == 0 || clk_get_by_ofw_index(dev, phy_node, 0,
1655                     &clk_ephy) != 0)
1656                         clk_ephy = NULL;
1657
1658         if (OF_hasprop(node, "syscon") && syscon_get_by_ofw_property(dev, node,
1659             "syscon", &sc->syscon) != 0) {
1660                 device_printf(dev, "cannot get syscon driver handle\n");
1661                 goto fail;
1662         }
1663
1664         /* Configure PHY for MII or RGMII mode */
1665         if (awg_setup_phy(dev) != 0)
1666                 goto fail;
1667
1668         /* Enable clocks */
1669         error = clk_enable(clk_ahb);
1670         if (error != 0) {
1671                 device_printf(dev, "cannot enable ahb clock\n");
1672                 goto fail;
1673         }
1674         if (clk_ephy != NULL) {
1675                 error = clk_enable(clk_ephy);
1676                 if (error != 0) {
1677                         device_printf(dev, "cannot enable ephy clock\n");
1678                         goto fail;
1679                 }
1680         }
1681
1682         /* De-assert reset */
1683         error = hwreset_deassert(rst_ahb);
1684         if (error != 0) {
1685                 device_printf(dev, "cannot de-assert ahb reset\n");
1686                 goto fail;
1687         }
1688         if (rst_ephy != NULL) {
1689                 /*
1690                  * The ephy reset is left de-asserted by U-Boot.  Assert it
1691                  * here to make sure that we're in a known good state going
1692                  * into the PHY reset.
1693                  */
1694                 hwreset_assert(rst_ephy);
1695                 error = hwreset_deassert(rst_ephy);
1696                 if (error != 0) {
1697                         device_printf(dev, "cannot de-assert ephy reset\n");
1698                         goto fail;
1699                 }
1700         }
1701
1702         /* Enable PHY regulator if applicable */
1703         if (regulator_get_by_ofw_property(dev, 0, "phy-supply", &reg) == 0) {
1704                 error = regulator_enable(reg);
1705                 if (error != 0) {
1706                         device_printf(dev, "cannot enable PHY regulator\n");
1707                         goto fail;
1708                 }
1709         }
1710
1711         /* Determine MDC clock divide ratio based on AHB clock */
1712         error = clk_get_freq(clk_ahb, &freq);
1713         if (error != 0) {
1714                 device_printf(dev, "cannot get AHB clock frequency\n");
1715                 goto fail;
1716         }
1717         div = freq / MDIO_FREQ;
1718         if (div <= 16)
1719                 sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_16;
1720         else if (div <= 32)
1721                 sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_32;
1722         else if (div <= 64)
1723                 sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_64;
1724         else if (div <= 128)
1725                 sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_128;
1726         else {
1727                 device_printf(dev, "cannot determine MDC clock divide ratio\n");
1728                 error = ENXIO;
1729                 goto fail;
1730         }
1731
1732         if (bootverbose)
1733                 device_printf(dev, "AHB frequency %ju Hz, MDC div: 0x%x\n",
1734                     (uintmax_t)freq, sc->mdc_div_ratio_m);
1735
1736         return (0);
1737
1738 fail:
1739         if (reg != NULL)
1740                 regulator_release(reg);
1741         if (clk_ephy != NULL)
1742                 clk_release(clk_ephy);
1743         if (clk_ahb != NULL)
1744                 clk_release(clk_ahb);
1745         if (rst_ephy != NULL)
1746                 hwreset_release(rst_ephy);
1747         if (rst_ahb != NULL)
1748                 hwreset_release(rst_ahb);
1749         return (error);
1750 }
1751
1752 #ifdef AWG_DEBUG
1753 static void
1754 awg_dump_regs(device_t dev)
1755 {
1756         static const struct {
1757                 const char *name;
1758                 u_int reg;
1759         } regs[] = {
1760                 { "BASIC_CTL_0", EMAC_BASIC_CTL_0 },
1761                 { "BASIC_CTL_1", EMAC_BASIC_CTL_1 },
1762                 { "INT_STA", EMAC_INT_STA },
1763                 { "INT_EN", EMAC_INT_EN },
1764                 { "TX_CTL_0", EMAC_TX_CTL_0 },
1765                 { "TX_CTL_1", EMAC_TX_CTL_1 },
1766                 { "TX_FLOW_CTL", EMAC_TX_FLOW_CTL },
1767                 { "TX_DMA_LIST", EMAC_TX_DMA_LIST },
1768                 { "RX_CTL_0", EMAC_RX_CTL_0 },
1769                 { "RX_CTL_1", EMAC_RX_CTL_1 },
1770                 { "RX_DMA_LIST", EMAC_RX_DMA_LIST },
1771                 { "RX_FRM_FLT", EMAC_RX_FRM_FLT },
1772                 { "RX_HASH_0", EMAC_RX_HASH_0 },
1773                 { "RX_HASH_1", EMAC_RX_HASH_1 },
1774                 { "MII_CMD", EMAC_MII_CMD },
1775                 { "ADDR_HIGH0", EMAC_ADDR_HIGH(0) },
1776                 { "ADDR_LOW0", EMAC_ADDR_LOW(0) },
1777                 { "TX_DMA_STA", EMAC_TX_DMA_STA },
1778                 { "TX_DMA_CUR_DESC", EMAC_TX_DMA_CUR_DESC },
1779                 { "TX_DMA_CUR_BUF", EMAC_TX_DMA_CUR_BUF },
1780                 { "RX_DMA_STA", EMAC_RX_DMA_STA },
1781                 { "RX_DMA_CUR_DESC", EMAC_RX_DMA_CUR_DESC },
1782                 { "RX_DMA_CUR_BUF", EMAC_RX_DMA_CUR_BUF },
1783                 { "RGMII_STA", EMAC_RGMII_STA },
1784         };
1785         struct awg_softc *sc;
1786         unsigned int n;
1787
1788         sc = device_get_softc(dev);
1789
1790         for (n = 0; n < nitems(regs); n++)
1791                 device_printf(dev, "  %-20s %08x\n", regs[n].name,
1792                     RD4(sc, regs[n].reg));
1793 }
1794 #endif
1795
1796 #define GPIO_ACTIVE_LOW         1
1797
1798 static int
1799 awg_phy_reset(device_t dev)
1800 {
1801         pcell_t gpio_prop[4], delay_prop[3];
1802         phandle_t node, gpio_node;
1803         device_t gpio;
1804         uint32_t pin, flags;
1805         uint32_t pin_value;
1806
1807         node = ofw_bus_get_node(dev);
1808         if (OF_getencprop(node, "allwinner,reset-gpio", gpio_prop,
1809             sizeof(gpio_prop)) <= 0)
1810                 return (0);
1811
1812         if (OF_getencprop(node, "allwinner,reset-delays-us", delay_prop,
1813             sizeof(delay_prop)) <= 0)
1814                 return (ENXIO);
1815
1816         gpio_node = OF_node_from_xref(gpio_prop[0]);
1817         if ((gpio = OF_device_from_xref(gpio_prop[0])) == NULL)
1818                 return (ENXIO);
1819
1820         if (GPIO_MAP_GPIOS(gpio, node, gpio_node, nitems(gpio_prop) - 1,
1821             gpio_prop + 1, &pin, &flags) != 0)
1822                 return (ENXIO);
1823
1824         pin_value = GPIO_PIN_LOW;
1825         if (OF_hasprop(node, "allwinner,reset-active-low"))
1826                 pin_value = GPIO_PIN_HIGH;
1827
1828         if (flags & GPIO_ACTIVE_LOW)
1829                 pin_value = !pin_value;
1830
1831         GPIO_PIN_SETFLAGS(gpio, pin, GPIO_PIN_OUTPUT);
1832         GPIO_PIN_SET(gpio, pin, pin_value);
1833         DELAY(delay_prop[0]);
1834         GPIO_PIN_SET(gpio, pin, !pin_value);
1835         DELAY(delay_prop[1]);
1836         GPIO_PIN_SET(gpio, pin, pin_value);
1837         DELAY(delay_prop[2]);
1838
1839         return (0);
1840 }
1841
1842 static int
1843 awg_reset(device_t dev)
1844 {
1845         struct awg_softc *sc;
1846         int retry;
1847
1848         sc = device_get_softc(dev);
1849
1850         /* Reset PHY if necessary */
1851         if (awg_phy_reset(dev) != 0) {
1852                 device_printf(dev, "failed to reset PHY\n");
1853                 return (ENXIO);
1854         }
1855
1856         /* Soft reset all registers and logic */
1857         WR4(sc, EMAC_BASIC_CTL_1, BASIC_CTL_SOFT_RST);
1858
1859         /* Wait for soft reset bit to self-clear */
1860         for (retry = SOFT_RST_RETRY; retry > 0; retry--) {
1861                 if ((RD4(sc, EMAC_BASIC_CTL_1) & BASIC_CTL_SOFT_RST) == 0)
1862                         break;
1863                 DELAY(10);
1864         }
1865         if (retry == 0) {
1866                 device_printf(dev, "soft reset timed out\n");
1867 #ifdef AWG_DEBUG
1868                 awg_dump_regs(dev);
1869 #endif
1870                 return (ETIMEDOUT);
1871         }
1872
1873         return (0);
1874 }
1875
1876 /*
1877  * Stats
1878  */
1879
1880 static void
1881 awg_tick(void *softc)
1882 {
1883         struct awg_softc *sc;
1884         struct mii_data *mii;
1885         if_t ifp;
1886         int link;
1887
1888         sc = softc;
1889         ifp = sc->ifp;
1890         mii = device_get_softc(sc->miibus);
1891
1892         AWG_ASSERT_LOCKED(sc);
1893
1894         if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0)
1895                 return;
1896
1897         link = sc->link;
1898         mii_tick(mii);
1899         if (sc->link && !link)
1900                 awg_start_locked(sc);
1901
1902         callout_reset(&sc->stat_ch, hz, awg_tick, sc);
1903 }
1904
1905 /*
1906  * Probe/attach functions
1907  */
1908
1909 static int
1910 awg_probe(device_t dev)
1911 {
1912         if (!ofw_bus_status_okay(dev))
1913                 return (ENXIO);
1914
1915         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
1916                 return (ENXIO);
1917
1918         device_set_desc(dev, "Allwinner Gigabit Ethernet");
1919         return (BUS_PROBE_DEFAULT);
1920 }
1921
1922 static int
1923 awg_attach(device_t dev)
1924 {
1925         uint8_t eaddr[ETHER_ADDR_LEN];
1926         struct awg_softc *sc;
1927         int error;
1928
1929         sc = device_get_softc(dev);
1930         sc->dev = dev;
1931         sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
1932
1933         if (bus_alloc_resources(dev, awg_spec, sc->res) != 0) {
1934                 device_printf(dev, "cannot allocate resources for device\n");
1935                 return (ENXIO);
1936         }
1937
1938         mtx_init(&sc->mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK, MTX_DEF);
1939         callout_init_mtx(&sc->stat_ch, &sc->mtx, 0);
1940
1941         /* Setup clocks and regulators */
1942         error = awg_setup_extres(dev);
1943         if (error != 0)
1944                 return (error);
1945
1946         /* Read MAC address before resetting the chip */
1947         awg_get_eaddr(dev, eaddr);
1948
1949         /* Soft reset EMAC core */
1950         error = awg_reset(dev);
1951         if (error != 0)
1952                 return (error);
1953
1954         /* Setup DMA descriptors */
1955         error = awg_setup_dma(dev);
1956         if (error != 0)
1957                 return (error);
1958
1959         /* Install interrupt handler */
1960         error = bus_setup_intr(dev, sc->res[_RES_IRQ],
1961             INTR_TYPE_NET | INTR_MPSAFE, NULL, awg_intr, sc, &sc->ih);
1962         if (error != 0) {
1963                 device_printf(dev, "cannot setup interrupt handler\n");
1964                 return (error);
1965         }
1966
1967         /* Setup ethernet interface */
1968         sc->ifp = if_alloc(IFT_ETHER);
1969         if_setsoftc(sc->ifp, sc);
1970         if_initname(sc->ifp, device_get_name(dev), device_get_unit(dev));
1971         if_setflags(sc->ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
1972         if_setstartfn(sc->ifp, awg_start);
1973         if_setioctlfn(sc->ifp, awg_ioctl);
1974         if_setinitfn(sc->ifp, awg_init);
1975         if_setsendqlen(sc->ifp, TX_DESC_COUNT - 1);
1976         if_setsendqready(sc->ifp);
1977         if_sethwassist(sc->ifp, CSUM_IP | CSUM_UDP | CSUM_TCP);
1978         if_setcapabilities(sc->ifp, IFCAP_VLAN_MTU | IFCAP_HWCSUM);
1979         if_setcapenable(sc->ifp, if_getcapabilities(sc->ifp));
1980 #ifdef DEVICE_POLLING
1981         if_setcapabilitiesbit(sc->ifp, IFCAP_POLLING, 0);
1982 #endif
1983
1984         /* Attach MII driver */
1985         error = mii_attach(dev, &sc->miibus, sc->ifp, awg_media_change,
1986             awg_media_status, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY,
1987             MIIF_DOPAUSE);
1988         if (error != 0) {
1989                 device_printf(dev, "cannot attach PHY\n");
1990                 return (error);
1991         }
1992
1993         /* Attach ethernet interface */
1994         ether_ifattach(sc->ifp, eaddr);
1995
1996         return (0);
1997 }
1998
1999 static device_method_t awg_methods[] = {
2000         /* Device interface */
2001         DEVMETHOD(device_probe,         awg_probe),
2002         DEVMETHOD(device_attach,        awg_attach),
2003
2004         /* MII interface */
2005         DEVMETHOD(miibus_readreg,       awg_miibus_readreg),
2006         DEVMETHOD(miibus_writereg,      awg_miibus_writereg),
2007         DEVMETHOD(miibus_statchg,       awg_miibus_statchg),
2008
2009         DEVMETHOD_END
2010 };
2011
2012 static driver_t awg_driver = {
2013         "awg",
2014         awg_methods,
2015         sizeof(struct awg_softc),
2016 };
2017
2018 DRIVER_MODULE(awg, simplebus, awg_driver, 0, 0);
2019 DRIVER_MODULE(miibus, awg, miibus_driver, 0, 0);
2020 MODULE_DEPEND(awg, ether, 1, 1, 1);
2021 MODULE_DEPEND(awg, miibus, 1, 1, 1);
2022 MODULE_DEPEND(awg, aw_sid, 1, 1, 1);
2023 SIMPLEBUS_PNP_INFO(compat_data);