sys/dev/dwc/if_dwc.c

   1 /*-
   2  * Copyright (c) 2014 Ruslan Bukin <br@bsdpad.com>
   3  * All rights reserved.
   4  *
   5  * This software was developed by SRI International and the University of
   6  * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
   7  * ("CTSRD"), as part of the DARPA CRASH research programme.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 /*
  32  * Ethernet media access controller (EMAC)
  33  * Chapter 17, Altera Cyclone V Device Handbook (CV-5V2 2014.07.22)
  34  *
  35  * EMAC is an instance of the Synopsys DesignWare 3504-0
  36  * Universal 10/100/1000 Ethernet MAC (DWC_gmac).
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/bus.h>
  45 #include <sys/gpio.h>
  46 #include <sys/kernel.h>
  47 #include <sys/lock.h>
  48 #include <sys/malloc.h>
  49 #include <sys/mbuf.h>
  50 #include <sys/module.h>
  51 #include <sys/mutex.h>
  52 #include <sys/rman.h>
  53 #include <sys/socket.h>
  54 #include <sys/sockio.h>
  55
  56 #include <net/bpf.h>
  57 #include <net/if.h>
  58 #include <net/ethernet.h>
  59 #include <net/if_dl.h>
  60 #include <net/if_media.h>
  61 #include <net/if_types.h>
  62 #include <net/if_var.h>
  63
  64 #include <machine/bus.h>
  65
  66 #include <dev/dwc/if_dwc.h>
  67 #include <dev/dwc/if_dwcvar.h>
  68 #include <dev/mii/mii.h>
  69 #include <dev/mii/miivar.h>
  70 #include <dev/ofw/ofw_bus.h>
  71 #include <dev/ofw/ofw_bus_subr.h>
  72
  73 #ifdef EXT_RESOURCES
  74 #include <dev/extres/clk/clk.h>
  75 #include <dev/extres/hwreset/hwreset.h>
  76 #endif
  77
  78 #include "if_dwc_if.h"
  79 #include "gpio_if.h"
  80 #include "miibus_if.h"
  81
  82 #define READ4(_sc, _reg) \
  83         bus_read_4((_sc)->res[0], _reg)
  84 #define WRITE4(_sc, _reg, _val) \
  85         bus_write_4((_sc)->res[0], _reg, _val)
  86
  87 #define MAC_RESET_TIMEOUT       100
  88 #define WATCHDOG_TIMEOUT_SECS   5
  89 #define STATS_HARVEST_INTERVAL  2
  90
  91 #define DWC_LOCK(sc)                    mtx_lock(&(sc)->mtx)
  92 #define DWC_UNLOCK(sc)                  mtx_unlock(&(sc)->mtx)
  93 #define DWC_ASSERT_LOCKED(sc)           mtx_assert(&(sc)->mtx, MA_OWNED)
  94 #define DWC_ASSERT_UNLOCKED(sc)         mtx_assert(&(sc)->mtx, MA_NOTOWNED)
  95
  96 #define DDESC_TDES0_OWN                 (1U << 31)
  97 #define DDESC_TDES0_TXINT               (1U << 30)
  98 #define DDESC_TDES0_TXLAST              (1U << 29)
  99 #define DDESC_TDES0_TXFIRST             (1U << 28)
 100 #define DDESC_TDES0_TXCRCDIS            (1U << 27)
 101 #define DDESC_TDES0_TXRINGEND           (1U << 21)
 102 #define DDESC_TDES0_TXCHAIN             (1U << 20)
 103
 104 #define DDESC_RDES0_OWN                 (1U << 31)
 105 #define DDESC_RDES0_FL_MASK             0x3fff
 106 #define DDESC_RDES0_FL_SHIFT            16      /* Frame Length */
 107 #define DDESC_RDES1_CHAINED             (1U << 14)
 108
 109 /* Alt descriptor bits. */
 110 #define DDESC_CNTL_TXINT                (1U << 31)
 111 #define DDESC_CNTL_TXLAST               (1U << 30)
 112 #define DDESC_CNTL_TXFIRST              (1U << 29)
 113 #define DDESC_CNTL_TXCRCDIS             (1U << 26)
 114 #define DDESC_CNTL_TXRINGEND            (1U << 25)
 115 #define DDESC_CNTL_TXCHAIN              (1U << 24)
 116
 117 #define DDESC_CNTL_CHAINED              (1U << 24)
 118
 119 /*
 120  * A hardware buffer descriptor.  Rx and Tx buffers have the same descriptor
 121  * layout, but the bits in the fields have different meanings.
 122  */
 123 struct dwc_hwdesc
 124 {
 125         uint32_t tdes0;         /* status for alt layout */
 126         uint32_t tdes1;         /* cntl for alt layout */
 127         uint32_t addr;          /* pointer to buffer data */
 128         uint32_t addr_next;     /* link to next descriptor */
 129 };
 130
 131 /*
 132  * The hardware imposes alignment restrictions on various objects involved in
 133  * DMA transfers.  These values are expressed in bytes (not bits).
 134  */
 135 #define DWC_DESC_RING_ALIGN             2048
 136
 137 static struct resource_spec dwc_spec[] = {
 138         { SYS_RES_MEMORY,       0,      RF_ACTIVE },
 139         { SYS_RES_IRQ,          0,      RF_ACTIVE },
 140         { -1, 0 }
 141 };
 142
 143 static void dwc_txfinish_locked(struct dwc_softc *sc);
 144 static void dwc_rxfinish_locked(struct dwc_softc *sc);
 145 static void dwc_stop_locked(struct dwc_softc *sc);
 146 static void dwc_setup_rxfilter(struct dwc_softc *sc);
 147
 148 static inline uint32_t
 149 next_rxidx(struct dwc_softc *sc, uint32_t curidx)
 150 {
 151
 152         return ((curidx + 1) % RX_DESC_COUNT);
 153 }
 154
 155 static inline uint32_t
 156 next_txidx(struct dwc_softc *sc, uint32_t curidx)
 157 {
 158
 159         return ((curidx + 1) % TX_DESC_COUNT);
 160 }
 161
 162 static void
 163 dwc_get1paddr(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
 164 {
 165
 166         if (error != 0)
 167                 return;
 168         *(bus_addr_t *)arg = segs[0].ds_addr;
 169 }
 170
 171 inline static uint32_t
 172 dwc_setup_txdesc(struct dwc_softc *sc, int idx, bus_addr_t paddr,
 173     uint32_t len)
 174 {
 175         uint32_t flags;
 176         uint32_t nidx;
 177
 178         nidx = next_txidx(sc, idx);
 179
 180         /* Addr/len 0 means we're clearing the descriptor after xmit done. */
 181         if (paddr == 0 || len == 0) {
 182                 flags = 0;
 183                 --sc->txcount;
 184         } else {
 185                 if (sc->mactype == DWC_GMAC_ALT_DESC)
 186                         flags = DDESC_CNTL_TXCHAIN | DDESC_CNTL_TXFIRST
 187                             | DDESC_CNTL_TXLAST | DDESC_CNTL_TXINT;
 188                 else
 189                         flags = DDESC_TDES0_TXCHAIN | DDESC_TDES0_TXFIRST
 190                             | DDESC_TDES0_TXLAST | DDESC_TDES0_TXINT;
 191                 ++sc->txcount;
 192         }
 193
 194         sc->txdesc_ring[idx].addr = (uint32_t)(paddr);
 195         if (sc->mactype == DWC_GMAC_ALT_DESC) {
 196                 sc->txdesc_ring[idx].tdes0 = 0;
 197                 sc->txdesc_ring[idx].tdes1 = flags | len;
 198         } else {
 199                 sc->txdesc_ring[idx].tdes0 = flags;
 200                 sc->txdesc_ring[idx].tdes1 = len;
 201         }
 202
 203         if (paddr && len) {
 204                 wmb();
 205                 sc->txdesc_ring[idx].tdes0 |= DDESC_TDES0_OWN;
 206                 wmb();
 207         }
 208
 209         return (nidx);
 210 }
 211
 212 static int
 213 dwc_setup_txbuf(struct dwc_softc *sc, int idx, struct mbuf **mp)
 214 {
 215         struct bus_dma_segment seg;
 216         int error, nsegs;
 217         struct mbuf * m;
 218
 219         if ((m = m_defrag(*mp, M_NOWAIT)) == NULL)
 220                 return (ENOMEM);
 221         *mp = m;
 222
 223         error = bus_dmamap_load_mbuf_sg(sc->txbuf_tag, sc->txbuf_map[idx].map,
 224             m, &seg, &nsegs, 0);
 225         if (error != 0) {
 226                 return (ENOMEM);
 227         }
 228
 229         KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
 230
 231         bus_dmamap_sync(sc->txbuf_tag, sc->txbuf_map[idx].map,
 232             BUS_DMASYNC_PREWRITE);
 233
 234         sc->txbuf_map[idx].mbuf = m;
 235
 236         dwc_setup_txdesc(sc, idx, seg.ds_addr, seg.ds_len);
 237
 238         return (0);
 239 }
 240
 241 static void
 242 dwc_txstart_locked(struct dwc_softc *sc)
 243 {
 244         struct ifnet *ifp;
 245         struct mbuf *m;
 246         int enqueued;
 247
 248         DWC_ASSERT_LOCKED(sc);
 249
 250         if (!sc->link_is_up)
 251                 return;
 252
 253         ifp = sc->ifp;
 254
 255         if (ifp->if_drv_flags & IFF_DRV_OACTIVE) {
 256                 return;
 257         }
 258
 259         enqueued = 0;
 260
 261         for (;;) {
 262                 if (sc->txcount == (TX_DESC_COUNT-1)) {
 263                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 264                         break;
 265                 }
 266
 267                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
 268                 if (m == NULL)
 269                         break;
 270                 if (dwc_setup_txbuf(sc, sc->tx_idx_head, &m) != 0) {
 271                         IFQ_DRV_PREPEND(&ifp->if_snd, m);
 272                         break;
 273                 }
 274                 BPF_MTAP(ifp, m);
 275                 sc->tx_idx_head = next_txidx(sc, sc->tx_idx_head);
 276                 ++enqueued;
 277         }
 278
 279         if (enqueued != 0) {
 280                 WRITE4(sc, TRANSMIT_POLL_DEMAND, 0x1);
 281                 sc->tx_watchdog_count = WATCHDOG_TIMEOUT_SECS;
 282         }
 283 }
 284
 285 static void
 286 dwc_txstart(struct ifnet *ifp)
 287 {
 288         struct dwc_softc *sc = ifp->if_softc;
 289
 290         DWC_LOCK(sc);
 291         dwc_txstart_locked(sc);
 292         DWC_UNLOCK(sc);
 293 }
 294
 295 static void
 296 dwc_stop_locked(struct dwc_softc *sc)
 297 {
 298         struct ifnet *ifp;
 299         uint32_t reg;
 300
 301         DWC_ASSERT_LOCKED(sc);
 302
 303         ifp = sc->ifp;
 304         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 305         sc->tx_watchdog_count = 0;
 306         sc->stats_harvest_count = 0;
 307
 308         callout_stop(&sc->dwc_callout);
 309
 310         /* Stop DMA TX */
 311         reg = READ4(sc, OPERATION_MODE);
 312         reg &= ~(MODE_ST);
 313         WRITE4(sc, OPERATION_MODE, reg);
 314
 315         /* Flush TX */
 316         reg = READ4(sc, OPERATION_MODE);
 317         reg |= (MODE_FTF);
 318         WRITE4(sc, OPERATION_MODE, reg);
 319
 320         /* Stop transmitters */
 321         reg = READ4(sc, MAC_CONFIGURATION);
 322         reg &= ~(CONF_TE | CONF_RE);
 323         WRITE4(sc, MAC_CONFIGURATION, reg);
 324
 325         /* Stop DMA RX */
 326         reg = READ4(sc, OPERATION_MODE);
 327         reg &= ~(MODE_SR);
 328         WRITE4(sc, OPERATION_MODE, reg);
 329 }
 330
 331 static void dwc_clear_stats(struct dwc_softc *sc)
 332 {
 333         uint32_t reg;
 334
 335         reg = READ4(sc, MMC_CONTROL);
 336         reg |= (MMC_CONTROL_CNTRST);
 337         WRITE4(sc, MMC_CONTROL, reg);
 338 }
 339
 340 static void
 341 dwc_harvest_stats(struct dwc_softc *sc)
 342 {
 343         struct ifnet *ifp;
 344
 345         /* We don't need to harvest too often. */
 346         if (++sc->stats_harvest_count < STATS_HARVEST_INTERVAL)
 347                 return;
 348
 349         sc->stats_harvest_count = 0;
 350         ifp = sc->ifp;
 351
 352         if_inc_counter(ifp, IFCOUNTER_IPACKETS, READ4(sc, RXFRAMECOUNT_GB));
 353         if_inc_counter(ifp, IFCOUNTER_IMCASTS, READ4(sc, RXMULTICASTFRAMES_G));
 354         if_inc_counter(ifp, IFCOUNTER_IERRORS,
 355             READ4(sc, RXOVERSIZE_G) + READ4(sc, RXUNDERSIZE_G) +
 356             READ4(sc, RXCRCERROR) + READ4(sc, RXALIGNMENTERROR) +
 357             READ4(sc, RXRUNTERROR) + READ4(sc, RXJABBERERROR) +
 358             READ4(sc, RXLENGTHERROR));
 359
 360         if_inc_counter(ifp, IFCOUNTER_OPACKETS, READ4(sc, TXFRAMECOUNT_G));
 361         if_inc_counter(ifp, IFCOUNTER_OMCASTS, READ4(sc, TXMULTICASTFRAMES_G));
 362         if_inc_counter(ifp, IFCOUNTER_OERRORS,
 363             READ4(sc, TXOVERSIZE_G) + READ4(sc, TXEXCESSDEF) +
 364             READ4(sc, TXCARRIERERR) + READ4(sc, TXUNDERFLOWERROR));
 365
 366         if_inc_counter(ifp, IFCOUNTER_COLLISIONS,
 367             READ4(sc, TXEXESSCOL) + READ4(sc, TXLATECOL));
 368
 369         dwc_clear_stats(sc);
 370 }
 371
 372 static void
 373 dwc_tick(void *arg)
 374 {
 375         struct dwc_softc *sc;
 376         struct ifnet *ifp;
 377         int link_was_up;
 378
 379         sc = arg;
 380
 381         DWC_ASSERT_LOCKED(sc);
 382
 383         ifp = sc->ifp;
 384
 385         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
 386             return;
 387
 388         /*
 389          * Typical tx watchdog.  If this fires it indicates that we enqueued
 390          * packets for output and never got a txdone interrupt for them.  Maybe
 391          * it's a missed interrupt somehow, just pretend we got one.
 392          */
 393         if (sc->tx_watchdog_count > 0) {
 394                 if (--sc->tx_watchdog_count == 0) {
 395                         dwc_txfinish_locked(sc);
 396                 }
 397         }
 398
 399         /* Gather stats from hardware counters. */
 400         dwc_harvest_stats(sc);
 401
 402         /* Check the media status. */
 403         link_was_up = sc->link_is_up;
 404         mii_tick(sc->mii_softc);
 405         if (sc->link_is_up && !link_was_up)
 406                 dwc_txstart_locked(sc);
 407
 408         /* Schedule another check one second from now. */
 409         callout_reset(&sc->dwc_callout, hz, dwc_tick, sc);
 410 }
 411
 412 static void
 413 dwc_init_locked(struct dwc_softc *sc)
 414 {
 415         struct ifnet *ifp = sc->ifp;
 416         uint32_t reg;
 417
 418         DWC_ASSERT_LOCKED(sc);
 419
 420         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 421                 return;
 422
 423         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 424
 425         dwc_setup_rxfilter(sc);
 426
 427         /* Initializa DMA and enable transmitters */
 428         reg = READ4(sc, OPERATION_MODE);
 429         reg |= (MODE_TSF | MODE_OSF | MODE_FUF);
 430         reg &= ~(MODE_RSF);
 431         reg |= (MODE_RTC_LEV32 << MODE_RTC_SHIFT);
 432         WRITE4(sc, OPERATION_MODE, reg);
 433
 434         WRITE4(sc, INTERRUPT_ENABLE, INT_EN_DEFAULT);
 435
 436         /* Start DMA */
 437         reg = READ4(sc, OPERATION_MODE);
 438         reg |= (MODE_ST | MODE_SR);
 439         WRITE4(sc, OPERATION_MODE, reg);
 440
 441         /* Enable transmitters */
 442         reg = READ4(sc, MAC_CONFIGURATION);
 443         reg |= (CONF_JD | CONF_ACS | CONF_BE);
 444         reg |= (CONF_TE | CONF_RE);
 445         WRITE4(sc, MAC_CONFIGURATION, reg);
 446
 447         /*
 448          * Call mii_mediachg() which will call back into dwc_miibus_statchg()
 449          * to set up the remaining config registers based on current media.
 450          */
 451         mii_mediachg(sc->mii_softc);
 452         callout_reset(&sc->dwc_callout, hz, dwc_tick, sc);
 453 }
 454
 455 static void
 456 dwc_init(void *if_softc)
 457 {
 458         struct dwc_softc *sc = if_softc;
 459
 460         DWC_LOCK(sc);
 461         dwc_init_locked(sc);
 462         DWC_UNLOCK(sc);
 463 }
 464
 465 inline static uint32_t
 466 dwc_setup_rxdesc(struct dwc_softc *sc, int idx, bus_addr_t paddr)
 467 {
 468         uint32_t nidx;
 469
 470         sc->rxdesc_ring[idx].addr = (uint32_t)paddr;
 471         nidx = next_rxidx(sc, idx);
 472         sc->rxdesc_ring[idx].addr_next = sc->rxdesc_ring_paddr +        \
 473             (nidx * sizeof(struct dwc_hwdesc));
 474         if (sc->mactype == DWC_GMAC_ALT_DESC)
 475                 sc->rxdesc_ring[idx].tdes1 = DDESC_CNTL_CHAINED | RX_MAX_PACKET;
 476         else
 477                 sc->rxdesc_ring[idx].tdes1 = DDESC_RDES1_CHAINED | MCLBYTES;
 478
 479         wmb();
 480         sc->rxdesc_ring[idx].tdes0 = DDESC_RDES0_OWN;
 481         wmb();
 482
 483         return (nidx);
 484 }
 485
 486 static int
 487 dwc_setup_rxbuf(struct dwc_softc *sc, int idx, struct mbuf *m)
 488 {
 489         struct bus_dma_segment seg;
 490         int error, nsegs;
 491
 492         m_adj(m, ETHER_ALIGN);
 493
 494         error = bus_dmamap_load_mbuf_sg(sc->rxbuf_tag, sc->rxbuf_map[idx].map,
 495             m, &seg, &nsegs, 0);
 496         if (error != 0) {
 497                 return (error);
 498         }
 499
 500         KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
 501
 502         bus_dmamap_sync(sc->rxbuf_tag, sc->rxbuf_map[idx].map,
 503             BUS_DMASYNC_PREREAD);
 504
 505         sc->rxbuf_map[idx].mbuf = m;
 506         dwc_setup_rxdesc(sc, idx, seg.ds_addr);
 507
 508         return (0);
 509 }
 510
 511 static struct mbuf *
 512 dwc_alloc_mbufcl(struct dwc_softc *sc)
 513 {
 514         struct mbuf *m;
 515
 516         m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
 517         if (m != NULL)
 518                 m->m_pkthdr.len = m->m_len = m->m_ext.ext_size;
 519
 520         return (m);
 521 }
 522
 523 static void
 524 dwc_media_status(struct ifnet * ifp, struct ifmediareq *ifmr)
 525 {
 526         struct dwc_softc *sc;
 527         struct mii_data *mii;
 528
 529         sc = ifp->if_softc;
 530         mii = sc->mii_softc;
 531         DWC_LOCK(sc);
 532         mii_pollstat(mii);
 533         ifmr->ifm_active = mii->mii_media_active;
 534         ifmr->ifm_status = mii->mii_media_status;
 535         DWC_UNLOCK(sc);
 536 }
 537
 538 static int
 539 dwc_media_change_locked(struct dwc_softc *sc)
 540 {
 541
 542         return (mii_mediachg(sc->mii_softc));
 543 }
 544
 545 static int
 546 dwc_media_change(struct ifnet * ifp)
 547 {
 548         struct dwc_softc *sc;
 549         int error;
 550
 551         sc = ifp->if_softc;
 552
 553         DWC_LOCK(sc);
 554         error = dwc_media_change_locked(sc);
 555         DWC_UNLOCK(sc);
 556         return (error);
 557 }
 558
 559 static const uint8_t nibbletab[] = {
 560         /* 0x0 0000 -> 0000 */  0x0,
 561         /* 0x1 0001 -> 1000 */  0x8,
 562         /* 0x2 0010 -> 0100 */  0x4,
 563         /* 0x3 0011 -> 1100 */  0xc,
 564         /* 0x4 0100 -> 0010 */  0x2,
 565         /* 0x5 0101 -> 1010 */  0xa,
 566         /* 0x6 0110 -> 0110 */  0x6,
 567         /* 0x7 0111 -> 1110 */  0xe,
 568         /* 0x8 1000 -> 0001 */  0x1,
 569         /* 0x9 1001 -> 1001 */  0x9,
 570         /* 0xa 1010 -> 0101 */  0x5,
 571         /* 0xb 1011 -> 1101 */  0xd,
 572         /* 0xc 1100 -> 0011 */  0x3,
 573         /* 0xd 1101 -> 1011 */  0xb,
 574         /* 0xe 1110 -> 0111 */  0x7,
 575         /* 0xf 1111 -> 1111 */  0xf, };
 576
 577 static uint8_t
 578 bitreverse(uint8_t x)
 579 {
 580
 581         return (nibbletab[x & 0xf] << 4) | nibbletab[x >> 4];
 582 }
 583
 584 static void
 585 dwc_setup_rxfilter(struct dwc_softc *sc)
 586 {
 587         struct ifmultiaddr *ifma;
 588         struct ifnet *ifp;
 589         uint8_t *eaddr, val;
 590         uint32_t crc, ffval, hashbit, hashreg, hi, lo, hash[8];
 591         int nhash, i;
 592
 593         DWC_ASSERT_LOCKED(sc);
 594
 595         ifp = sc->ifp;
 596         nhash = sc->mactype == DWC_GMAC_ALT_DESC ? 2 : 8;
 597
 598         /*
 599          * Set the multicast (group) filter hash.
 600          */
 601         if ((ifp->if_flags & IFF_ALLMULTI) != 0) {
 602                 ffval = (FRAME_FILTER_PM);
 603                 for (i = 0; i < nhash; i++)
 604                         hash[i] = ~0;
 605         } else {
 606                 ffval = (FRAME_FILTER_HMC);
 607                 for (i = 0; i < nhash; i++)
 608                         hash[i] = 0;
 609                 if_maddr_rlock(ifp);
 610                 CK_STAILQ_FOREACH(ifma, &sc->ifp->if_multiaddrs, ifma_link) {
 611                         if (ifma->ifma_addr->sa_family != AF_LINK)
 612                                 continue;
 613                         crc = ether_crc32_le(LLADDR((struct sockaddr_dl *)
 614                                 ifma->ifma_addr), ETHER_ADDR_LEN);
 615
 616                         /* Take lower 8 bits and reverse it */
 617                         val = bitreverse(~crc & 0xff);
 618                         if (sc->mactype == DWC_GMAC_ALT_DESC)
 619                                 val >>= nhash; /* Only need lower 6 bits */
 620                         hashreg = (val >> 5);
 621                         hashbit = (val & 31);
 622                         hash[hashreg] |= (1 << hashbit);
 623                 }
 624                 if_maddr_runlock(ifp);
 625         }
 626
 627         /*
 628          * Set the individual address filter hash.
 629          */
 630         if (ifp->if_flags & IFF_PROMISC)
 631                 ffval |= (FRAME_FILTER_PR);
 632
 633         /*
 634          * Set the primary address.
 635          */
 636         eaddr = IF_LLADDR(ifp);
 637         lo = eaddr[0] | (eaddr[1] << 8) | (eaddr[2] << 16) |
 638             (eaddr[3] << 24);
 639         hi = eaddr[4] | (eaddr[5] << 8);
 640         WRITE4(sc, MAC_ADDRESS_LOW(0), lo);
 641         WRITE4(sc, MAC_ADDRESS_HIGH(0), hi);
 642         WRITE4(sc, MAC_FRAME_FILTER, ffval);
 643         if (sc->mactype == DWC_GMAC_ALT_DESC) {
 644                 WRITE4(sc, GMAC_MAC_HTLOW, hash[0]);
 645                 WRITE4(sc, GMAC_MAC_HTHIGH, hash[1]);
 646         } else {
 647                 for (i = 0; i < nhash; i++)
 648                         WRITE4(sc, HASH_TABLE_REG(i), hash[i]);
 649         }
 650 }
 651
 652 static int
 653 dwc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 654 {
 655         struct dwc_softc *sc;
 656         struct mii_data *mii;
 657         struct ifreq *ifr;
 658         int mask, error;
 659
 660         sc = ifp->if_softc;
 661         ifr = (struct ifreq *)data;
 662
 663         error = 0;
 664         switch (cmd) {
 665         case SIOCSIFFLAGS:
 666                 DWC_LOCK(sc);
 667                 if (ifp->if_flags & IFF_UP) {
 668                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 669                                 if ((ifp->if_flags ^ sc->if_flags) &
 670                                     (IFF_PROMISC | IFF_ALLMULTI))
 671                                         dwc_setup_rxfilter(sc);
 672                         } else {
 673                                 if (!sc->is_detaching)
 674                                         dwc_init_locked(sc);
 675                         }
 676                 } else {
 677                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 678                                 dwc_stop_locked(sc);
 679                 }
 680                 sc->if_flags = ifp->if_flags;
 681                 DWC_UNLOCK(sc);
 682                 break;
 683         case SIOCADDMULTI:
 684         case SIOCDELMULTI:
 685                 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 686                         DWC_LOCK(sc);
 687                         dwc_setup_rxfilter(sc);
 688                         DWC_UNLOCK(sc);
 689                 }
 690                 break;
 691         case SIOCSIFMEDIA:
 692         case SIOCGIFMEDIA:
 693                 mii = sc->mii_softc;
 694                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
 695                 break;
 696         case SIOCSIFCAP:
 697                 mask = ifp->if_capenable ^ ifr->ifr_reqcap;
 698                 if (mask & IFCAP_VLAN_MTU) {
 699                         /* No work to do except acknowledge the change took */
 700                         ifp->if_capenable ^= IFCAP_VLAN_MTU;
 701                 }
 702                 break;
 703
 704         default:
 705                 error = ether_ioctl(ifp, cmd, data);
 706                 break;
 707         }
 708
 709         return (error);
 710 }
 711
 712 static void
 713 dwc_txfinish_locked(struct dwc_softc *sc)
 714 {
 715         struct dwc_bufmap *bmap;
 716         struct dwc_hwdesc *desc;
 717         struct ifnet *ifp;
 718
 719         DWC_ASSERT_LOCKED(sc);
 720
 721         ifp = sc->ifp;
 722         while (sc->tx_idx_tail != sc->tx_idx_head) {
 723                 desc = &sc->txdesc_ring[sc->tx_idx_tail];
 724                 if ((desc->tdes0 & DDESC_TDES0_OWN) != 0)
 725                         break;
 726                 bmap = &sc->txbuf_map[sc->tx_idx_tail];
 727                 bus_dmamap_sync(sc->txbuf_tag, bmap->map,
 728                     BUS_DMASYNC_POSTWRITE);
 729                 bus_dmamap_unload(sc->txbuf_tag, bmap->map);
 730                 m_freem(bmap->mbuf);
 731                 bmap->mbuf = NULL;
 732                 dwc_setup_txdesc(sc, sc->tx_idx_tail, 0, 0);
 733                 sc->tx_idx_tail = next_txidx(sc, sc->tx_idx_tail);
 734                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 735                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
 736         }
 737
 738         /* If there are no buffers outstanding, muzzle the watchdog. */
 739         if (sc->tx_idx_tail == sc->tx_idx_head) {
 740                 sc->tx_watchdog_count = 0;
 741         }
 742 }
 743
 744 static void
 745 dwc_rxfinish_locked(struct dwc_softc *sc)
 746 {
 747         struct ifnet *ifp;
 748         struct mbuf *m0;
 749         struct mbuf *m;
 750         int error, idx, len;
 751         uint32_t rdes0;
 752
 753         ifp = sc->ifp;
 754
 755         for (;;) {
 756                 idx = sc->rx_idx;
 757
 758                 rdes0 = sc->rxdesc_ring[idx].tdes0;
 759                 if ((rdes0 & DDESC_RDES0_OWN) != 0)
 760                         break;
 761
 762                 bus_dmamap_sync(sc->rxbuf_tag, sc->rxbuf_map[idx].map,
 763                     BUS_DMASYNC_POSTREAD);
 764                 bus_dmamap_unload(sc->rxbuf_tag, sc->rxbuf_map[idx].map);
 765
 766                 len = (rdes0 >> DDESC_RDES0_FL_SHIFT) & DDESC_RDES0_FL_MASK;
 767                 if (len != 0) {
 768                         m = sc->rxbuf_map[idx].mbuf;
 769                         m->m_pkthdr.rcvif = ifp;
 770                         m->m_pkthdr.len = len;
 771                         m->m_len = len;
 772                         if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
 773
 774                         /* Remove trailing FCS */
 775                         m_adj(m, -ETHER_CRC_LEN);
 776
 777                         DWC_UNLOCK(sc);
 778                         (*ifp->if_input)(ifp, m);
 779                         DWC_LOCK(sc);
 780                 } else {
 781                         /* XXX Zero-length packet ? */
 782                 }
 783
 784                 if ((m0 = dwc_alloc_mbufcl(sc)) != NULL) {
 785                         if ((error = dwc_setup_rxbuf(sc, idx, m0)) != 0) {
 786                                 /*
 787                                  * XXX Now what?
 788                                  * We've got a hole in the rx ring.
 789                                  */
 790                         }
 791                 } else
 792                         if_inc_counter(sc->ifp, IFCOUNTER_IQDROPS, 1);
 793
 794                 sc->rx_idx = next_rxidx(sc, sc->rx_idx);
 795         }
 796 }
 797
 798 static void
 799 dwc_intr(void *arg)
 800 {
 801         struct dwc_softc *sc;
 802         uint32_t reg;
 803
 804         sc = arg;
 805
 806         DWC_LOCK(sc);
 807
 808         reg = READ4(sc, INTERRUPT_STATUS);
 809         if (reg)
 810                 READ4(sc, SGMII_RGMII_SMII_CTRL_STATUS);
 811
 812         reg = READ4(sc, DMA_STATUS);
 813         if (reg & DMA_STATUS_NIS) {
 814                 if (reg & DMA_STATUS_RI)
 815                         dwc_rxfinish_locked(sc);
 816
 817                 if (reg & DMA_STATUS_TI) {
 818                         dwc_txfinish_locked(sc);
 819                         dwc_txstart_locked(sc);
 820                 }
 821         }
 822
 823         if (reg & DMA_STATUS_AIS) {
 824                 if (reg & DMA_STATUS_FBI) {
 825                         /* Fatal bus error */
 826                         device_printf(sc->dev,
 827                             "Ethernet DMA error, restarting controller.\n");
 828                         dwc_stop_locked(sc);
 829                         dwc_init_locked(sc);
 830                 }
 831         }
 832
 833         WRITE4(sc, DMA_STATUS, reg & DMA_STATUS_INTR_MASK);
 834         DWC_UNLOCK(sc);
 835 }
 836
 837 static int
 838 setup_dma(struct dwc_softc *sc)
 839 {
 840         struct mbuf *m;
 841         int error;
 842         int nidx;
 843         int idx;
 844
 845         /*
 846          * Set up TX descriptor ring, descriptors, and dma maps.
 847          */
 848         error = bus_dma_tag_create(
 849             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 850             DWC_DESC_RING_ALIGN, 0,     /* alignment, boundary */
 851             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 852             BUS_SPACE_MAXADDR,          /* highaddr */
 853             NULL, NULL,                 /* filter, filterarg */
 854             TX_DESC_SIZE, 1,            /* maxsize, nsegments */
 855             TX_DESC_SIZE,               /* maxsegsize */
 856             0,                          /* flags */
 857             NULL, NULL,                 /* lockfunc, lockarg */
 858             &sc->txdesc_tag);
 859         if (error != 0) {
 860                 device_printf(sc->dev,
 861                     "could not create TX ring DMA tag.\n");
 862                 goto out;
 863         }
 864
 865         error = bus_dmamem_alloc(sc->txdesc_tag, (void**)&sc->txdesc_ring,
 866             BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO,
 867             &sc->txdesc_map);
 868         if (error != 0) {
 869                 device_printf(sc->dev,
 870                     "could not allocate TX descriptor ring.\n");
 871                 goto out;
 872         }
 873
 874         error = bus_dmamap_load(sc->txdesc_tag, sc->txdesc_map,
 875             sc->txdesc_ring, TX_DESC_SIZE, dwc_get1paddr,
 876             &sc->txdesc_ring_paddr, 0);
 877         if (error != 0) {
 878                 device_printf(sc->dev,
 879                     "could not load TX descriptor ring map.\n");
 880                 goto out;
 881         }
 882
 883         for (idx = 0; idx < TX_DESC_COUNT; idx++) {
 884                 nidx = next_txidx(sc, idx);
 885                 sc->txdesc_ring[idx].addr_next = sc->txdesc_ring_paddr +
 886                     (nidx * sizeof(struct dwc_hwdesc));
 887         }
 888
 889         error = bus_dma_tag_create(
 890             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 891             1, 0,                       /* alignment, boundary */
 892             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 893             BUS_SPACE_MAXADDR,          /* highaddr */
 894             NULL, NULL,                 /* filter, filterarg */
 895             MCLBYTES, 1,                /* maxsize, nsegments */
 896             MCLBYTES,                   /* maxsegsize */
 897             0,                          /* flags */
 898             NULL, NULL,                 /* lockfunc, lockarg */
 899             &sc->txbuf_tag);
 900         if (error != 0) {
 901                 device_printf(sc->dev,
 902                     "could not create TX ring DMA tag.\n");
 903                 goto out;
 904         }
 905
 906         for (idx = 0; idx < TX_DESC_COUNT; idx++) {
 907                 error = bus_dmamap_create(sc->txbuf_tag, BUS_DMA_COHERENT,
 908                     &sc->txbuf_map[idx].map);
 909                 if (error != 0) {
 910                         device_printf(sc->dev,
 911                             "could not create TX buffer DMA map.\n");
 912                         goto out;
 913                 }
 914                 dwc_setup_txdesc(sc, idx, 0, 0);
 915         }
 916
 917         /*
 918          * Set up RX descriptor ring, descriptors, dma maps, and mbufs.
 919          */
 920         error = bus_dma_tag_create(
 921             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 922             DWC_DESC_RING_ALIGN, 0,     /* alignment, boundary */
 923             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 924             BUS_SPACE_MAXADDR,          /* highaddr */
 925             NULL, NULL,                 /* filter, filterarg */
 926             RX_DESC_SIZE, 1,            /* maxsize, nsegments */
 927             RX_DESC_SIZE,               /* maxsegsize */
 928             0,                          /* flags */
 929             NULL, NULL,                 /* lockfunc, lockarg */
 930             &sc->rxdesc_tag);
 931         if (error != 0) {
 932                 device_printf(sc->dev,
 933                     "could not create RX ring DMA tag.\n");
 934                 goto out;
 935         }
 936
 937         error = bus_dmamem_alloc(sc->rxdesc_tag, (void **)&sc->rxdesc_ring,
 938             BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO,
 939             &sc->rxdesc_map);
 940         if (error != 0) {
 941                 device_printf(sc->dev,
 942                     "could not allocate RX descriptor ring.\n");
 943                 goto out;
 944         }
 945
 946         error = bus_dmamap_load(sc->rxdesc_tag, sc->rxdesc_map,
 947             sc->rxdesc_ring, RX_DESC_SIZE, dwc_get1paddr,
 948             &sc->rxdesc_ring_paddr, 0);
 949         if (error != 0) {
 950                 device_printf(sc->dev,
 951                     "could not load RX descriptor ring map.\n");
 952                 goto out;
 953         }
 954
 955         error = bus_dma_tag_create(
 956             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 957             1, 0,                       /* alignment, boundary */
 958             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 959             BUS_SPACE_MAXADDR,          /* highaddr */
 960             NULL, NULL,                 /* filter, filterarg */
 961             MCLBYTES, 1,                /* maxsize, nsegments */
 962             MCLBYTES,                   /* maxsegsize */
 963             0,                          /* flags */
 964             NULL, NULL,                 /* lockfunc, lockarg */
 965             &sc->rxbuf_tag);
 966         if (error != 0) {
 967                 device_printf(sc->dev,
 968                     "could not create RX buf DMA tag.\n");
 969                 goto out;
 970         }
 971
 972         for (idx = 0; idx < RX_DESC_COUNT; idx++) {
 973                 error = bus_dmamap_create(sc->rxbuf_tag, BUS_DMA_COHERENT,
 974                     &sc->rxbuf_map[idx].map);
 975                 if (error != 0) {
 976                         device_printf(sc->dev,
 977                             "could not create RX buffer DMA map.\n");
 978                         goto out;
 979                 }
 980                 if ((m = dwc_alloc_mbufcl(sc)) == NULL) {
 981                         device_printf(sc->dev, "Could not alloc mbuf\n");
 982                         error = ENOMEM;
 983                         goto out;
 984                 }
 985                 if ((error = dwc_setup_rxbuf(sc, idx, m)) != 0) {
 986                         device_printf(sc->dev,
 987                             "could not create new RX buffer.\n");
 988                         goto out;
 989                 }
 990         }
 991
 992 out:
 993         if (error != 0)
 994                 return (ENXIO);
 995
 996         return (0);
 997 }
 998
 999 static int
1000 dwc_get_hwaddr(struct dwc_softc *sc, uint8_t *hwaddr)
1001 {
1002         uint32_t hi, lo, rnd;
1003
1004         /*
1005          * Try to recover a MAC address from the running hardware. If there's
1006          * something non-zero there, assume the bootloader did the right thing
1007          * and just use it.
1008          *
1009          * Otherwise, set the address to a convenient locally assigned address,
1010          * 'bsd' + random 24 low-order bits.  'b' is 0x62, which has the locally
1011          * assigned bit set, and the broadcast/multicast bit clear.
1012          */
1013         lo = READ4(sc, MAC_ADDRESS_LOW(0));
1014         hi = READ4(sc, MAC_ADDRESS_HIGH(0)) & 0xffff;
1015         if ((lo != 0xffffffff) || (hi != 0xffff)) {
1016                 hwaddr[0] = (lo >>  0) & 0xff;
1017                 hwaddr[1] = (lo >>  8) & 0xff;
1018                 hwaddr[2] = (lo >> 16) & 0xff;
1019                 hwaddr[3] = (lo >> 24) & 0xff;
1020                 hwaddr[4] = (hi >>  0) & 0xff;
1021                 hwaddr[5] = (hi >>  8) & 0xff;
1022         } else {
1023                 rnd = arc4random() & 0x00ffffff;
1024                 hwaddr[0] = 'b';
1025                 hwaddr[1] = 's';
1026                 hwaddr[2] = 'd';
1027                 hwaddr[3] = rnd >> 16;
1028                 hwaddr[4] = rnd >>  8;
1029                 hwaddr[5] = rnd >>  0;
1030         }
1031
1032         return (0);
1033 }
1034
1035 #define GPIO_ACTIVE_LOW 1
1036
1037 static int
1038 dwc_reset(device_t dev)
1039 {
1040         pcell_t gpio_prop[4];
1041         pcell_t delay_prop[3];
1042         phandle_t node, gpio_node;
1043         device_t gpio;
1044         uint32_t pin, flags;
1045         uint32_t pin_value;
1046
1047         node = ofw_bus_get_node(dev);
1048         if (OF_getencprop(node, "snps,reset-gpio",
1049             gpio_prop, sizeof(gpio_prop)) <= 0)
1050                 return (0);
1051
1052         if (OF_getencprop(node, "snps,reset-delays-us",
1053             delay_prop, sizeof(delay_prop)) <= 0) {
1054                 device_printf(dev,
1055                     "Wrong property for snps,reset-delays-us");
1056                 return (ENXIO);
1057         }
1058
1059         gpio_node = OF_node_from_xref(gpio_prop[0]);
1060         if ((gpio = OF_device_from_xref(gpio_prop[0])) == NULL) {
1061                 device_printf(dev,
1062                     "Can't find gpio controller for phy reset\n");
1063                 return (ENXIO);
1064         }
1065
1066         if (GPIO_MAP_GPIOS(gpio, node, gpio_node,
1067             nitems(gpio_prop) - 1,
1068             gpio_prop + 1, &pin, &flags) != 0) {
1069                 device_printf(dev, "Can't map gpio for phy reset\n");
1070                 return (ENXIO);
1071         }
1072
1073         pin_value = GPIO_PIN_LOW;
1074         if (OF_hasprop(node, "snps,reset-active-low"))
1075                 pin_value = GPIO_PIN_HIGH;
1076
1077         GPIO_PIN_SETFLAGS(gpio, pin, GPIO_PIN_OUTPUT);
1078         GPIO_PIN_SET(gpio, pin, pin_value);
1079         DELAY(delay_prop[0] * 5);
1080         GPIO_PIN_SET(gpio, pin, !pin_value);
1081         DELAY(delay_prop[1] * 5);
1082         GPIO_PIN_SET(gpio, pin, pin_value);
1083         DELAY(delay_prop[2] * 5);
1084
1085         return (0);
1086 }
1087
1088 #ifdef EXT_RESOURCES
1089 static int
1090 dwc_clock_init(device_t dev)
1091 {
1092         hwreset_t rst;
1093         clk_t clk;
1094         int error;
1095
1096         /* Enable clock */
1097         if (clk_get_by_ofw_name(dev, 0, "stmmaceth", &clk) == 0) {
1098                 error = clk_enable(clk);
1099                 if (error != 0) {
1100                         device_printf(dev, "could not enable main clock\n");
1101                         return (error);
1102                 }
1103         }
1104
1105         /* De-assert reset */
1106         if (hwreset_get_by_ofw_name(dev, 0, "stmmaceth", &rst) == 0) {
1107                 error = hwreset_deassert(rst);
1108                 if (error != 0) {
1109                         device_printf(dev, "could not de-assert reset\n");
1110                         return (error);
1111                 }
1112         }
1113
1114         return (0);
1115 }
1116 #endif
1117
1118 static int
1119 dwc_probe(device_t dev)
1120 {
1121
1122         if (!ofw_bus_status_okay(dev))
1123                 return (ENXIO);
1124
1125         if (!ofw_bus_is_compatible(dev, "snps,dwmac"))
1126                 return (ENXIO);
1127
1128         device_set_desc(dev, "Gigabit Ethernet Controller");
1129         return (BUS_PROBE_DEFAULT);
1130 }
1131
1132 static int
1133 dwc_attach(device_t dev)
1134 {
1135         uint8_t macaddr[ETHER_ADDR_LEN];
1136         struct dwc_softc *sc;
1137         struct ifnet *ifp;
1138         int error, i;
1139         uint32_t reg;
1140
1141         sc = device_get_softc(dev);
1142         sc->dev = dev;
1143         sc->rx_idx = 0;
1144         sc->txcount = TX_DESC_COUNT;
1145         sc->mii_clk = IF_DWC_MII_CLK(dev);
1146         sc->mactype = IF_DWC_MAC_TYPE(dev);
1147
1148         if (IF_DWC_INIT(dev) != 0)
1149                 return (ENXIO);
1150
1151 #ifdef EXT_RESOURCES
1152         if (dwc_clock_init(dev) != 0)
1153                 return (ENXIO);
1154 #endif
1155
1156         if (bus_alloc_resources(dev, dwc_spec, sc->res)) {
1157                 device_printf(dev, "could not allocate resources\n");
1158                 return (ENXIO);
1159         }
1160
1161         /* Memory interface */
1162         sc->bst = rman_get_bustag(sc->res[0]);
1163         sc->bsh = rman_get_bushandle(sc->res[0]);
1164
1165         /* Read MAC before reset */
1166         if (dwc_get_hwaddr(sc, macaddr)) {
1167                 device_printf(sc->dev, "can't get mac\n");
1168                 return (ENXIO);
1169         }
1170
1171         /* Reset the PHY if needed */
1172         if (dwc_reset(dev) != 0) {
1173                 device_printf(dev, "Can't reset the PHY\n");
1174                 return (ENXIO);
1175         }
1176
1177         /* Reset */
1178         reg = READ4(sc, BUS_MODE);
1179         reg |= (BUS_MODE_SWR);
1180         WRITE4(sc, BUS_MODE, reg);
1181
1182         for (i = 0; i < MAC_RESET_TIMEOUT; i++) {
1183                 if ((READ4(sc, BUS_MODE) & BUS_MODE_SWR) == 0)
1184                         break;
1185                 DELAY(10);
1186         }
1187         if (i >= MAC_RESET_TIMEOUT) {
1188                 device_printf(sc->dev, "Can't reset DWC.\n");
1189                 return (ENXIO);
1190         }
1191
1192         if (sc->mactype == DWC_GMAC_ALT_DESC) {
1193                 reg = BUS_MODE_FIXEDBURST;
1194                 reg |= (BUS_MODE_PRIORXTX_41 << BUS_MODE_PRIORXTX_SHIFT);
1195         } else
1196                 reg = (BUS_MODE_EIGHTXPBL);
1197         reg |= (BUS_MODE_PBL_BEATS_8 << BUS_MODE_PBL_SHIFT);
1198         WRITE4(sc, BUS_MODE, reg);
1199
1200         /*
1201          * DMA must be stop while changing descriptor list addresses.
1202          */
1203         reg = READ4(sc, OPERATION_MODE);
1204         reg &= ~(MODE_ST | MODE_SR);
1205         WRITE4(sc, OPERATION_MODE, reg);
1206
1207         if (setup_dma(sc))
1208                 return (ENXIO);
1209
1210         /* Setup addresses */
1211         WRITE4(sc, RX_DESCR_LIST_ADDR, sc->rxdesc_ring_paddr);
1212         WRITE4(sc, TX_DESCR_LIST_ADDR, sc->txdesc_ring_paddr);
1213
1214         mtx_init(&sc->mtx, device_get_nameunit(sc->dev),
1215             MTX_NETWORK_LOCK, MTX_DEF);
1216
1217         callout_init_mtx(&sc->dwc_callout, &sc->mtx, 0);
1218
1219         /* Setup interrupt handler. */
1220         error = bus_setup_intr(dev, sc->res[1], INTR_TYPE_NET | INTR_MPSAFE,
1221             NULL, dwc_intr, sc, &sc->intr_cookie);
1222         if (error != 0) {
1223                 device_printf(dev, "could not setup interrupt handler.\n");
1224                 return (ENXIO);
1225         }
1226
1227         /* Set up the ethernet interface. */
1228         sc->ifp = ifp = if_alloc(IFT_ETHER);
1229
1230         ifp->if_softc = sc;
1231         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1232         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1233         ifp->if_capabilities = IFCAP_VLAN_MTU;
1234         ifp->if_capenable = ifp->if_capabilities;
1235         ifp->if_start = dwc_txstart;
1236         ifp->if_ioctl = dwc_ioctl;
1237         ifp->if_init = dwc_init;
1238         IFQ_SET_MAXLEN(&ifp->if_snd, TX_DESC_COUNT - 1);
1239         ifp->if_snd.ifq_drv_maxlen = TX_DESC_COUNT - 1;
1240         IFQ_SET_READY(&ifp->if_snd);
1241
1242         /* Attach the mii driver. */
1243         error = mii_attach(dev, &sc->miibus, ifp, dwc_media_change,
1244             dwc_media_status, BMSR_DEFCAPMASK, MII_PHY_ANY,
1245             MII_OFFSET_ANY, 0);
1246
1247         if (error != 0) {
1248                 device_printf(dev, "PHY attach failed\n");
1249                 return (ENXIO);
1250         }
1251         sc->mii_softc = device_get_softc(sc->miibus);
1252
1253         /* All ready to run, attach the ethernet interface. */
1254         ether_ifattach(ifp, macaddr);
1255         sc->is_attached = true;
1256
1257         return (0);
1258 }
1259
1260 static int
1261 dwc_miibus_read_reg(device_t dev, int phy, int reg)
1262 {
1263         struct dwc_softc *sc;
1264         uint16_t mii;
1265         size_t cnt;
1266         int rv = 0;
1267
1268         sc = device_get_softc(dev);
1269
1270         mii = ((phy & GMII_ADDRESS_PA_MASK) << GMII_ADDRESS_PA_SHIFT)
1271             | ((reg & GMII_ADDRESS_GR_MASK) << GMII_ADDRESS_GR_SHIFT)
1272             | (sc->mii_clk << GMII_ADDRESS_CR_SHIFT)
1273             | GMII_ADDRESS_GB; /* Busy flag */
1274
1275         WRITE4(sc, GMII_ADDRESS, mii);
1276
1277         for (cnt = 0; cnt < 1000; cnt++) {
1278                 if (!(READ4(sc, GMII_ADDRESS) & GMII_ADDRESS_GB)) {
1279                         rv = READ4(sc, GMII_DATA);
1280                         break;
1281                 }
1282                 DELAY(10);
1283         }
1284
1285         return rv;
1286 }
1287
1288 static int
1289 dwc_miibus_write_reg(device_t dev, int phy, int reg, int val)
1290 {
1291         struct dwc_softc *sc;
1292         uint16_t mii;
1293         size_t cnt;
1294
1295         sc = device_get_softc(dev);
1296
1297         mii = ((phy & GMII_ADDRESS_PA_MASK) << GMII_ADDRESS_PA_SHIFT)
1298             | ((reg & GMII_ADDRESS_GR_MASK) << GMII_ADDRESS_GR_SHIFT)
1299             | (sc->mii_clk << GMII_ADDRESS_CR_SHIFT)
1300             | GMII_ADDRESS_GB | GMII_ADDRESS_GW;
1301
1302         WRITE4(sc, GMII_DATA, val);
1303         WRITE4(sc, GMII_ADDRESS, mii);
1304
1305         for (cnt = 0; cnt < 1000; cnt++) {
1306                 if (!(READ4(sc, GMII_ADDRESS) & GMII_ADDRESS_GB)) {
1307                         break;
1308                 }
1309                 DELAY(10);
1310         }
1311
1312         return (0);
1313 }
1314
1315 static void
1316 dwc_miibus_statchg(device_t dev)
1317 {
1318         struct dwc_softc *sc;
1319         struct mii_data *mii;
1320         uint32_t reg;
1321
1322         /*
1323          * Called by the MII bus driver when the PHY establishes
1324          * link to set the MAC interface registers.
1325          */
1326
1327         sc = device_get_softc(dev);
1328
1329         DWC_ASSERT_LOCKED(sc);
1330
1331         mii = sc->mii_softc;
1332
1333         if (mii->mii_media_status & IFM_ACTIVE)
1334                 sc->link_is_up = true;
1335         else
1336                 sc->link_is_up = false;
1337
1338         reg = READ4(sc, MAC_CONFIGURATION);
1339         switch (IFM_SUBTYPE(mii->mii_media_active)) {
1340         case IFM_1000_T:
1341         case IFM_1000_SX:
1342                 reg &= ~(CONF_FES | CONF_PS);
1343                 break;
1344         case IFM_100_TX:
1345                 reg |= (CONF_FES | CONF_PS);
1346                 break;
1347         case IFM_10_T:
1348                 reg &= ~(CONF_FES);
1349                 reg |= (CONF_PS);
1350                 break;
1351         case IFM_NONE:
1352                 sc->link_is_up = false;
1353                 return;
1354         default:
1355                 sc->link_is_up = false;
1356                 device_printf(dev, "Unsupported media %u\n",
1357                     IFM_SUBTYPE(mii->mii_media_active));
1358                 return;
1359         }
1360         if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
1361                 reg |= (CONF_DM);
1362         else
1363                 reg &= ~(CONF_DM);
1364         WRITE4(sc, MAC_CONFIGURATION, reg);
1365 }
1366
1367 static device_method_t dwc_methods[] = {
1368         DEVMETHOD(device_probe,         dwc_probe),
1369         DEVMETHOD(device_attach,        dwc_attach),
1370
1371         /* MII Interface */
1372         DEVMETHOD(miibus_readreg,       dwc_miibus_read_reg),
1373         DEVMETHOD(miibus_writereg,      dwc_miibus_write_reg),
1374         DEVMETHOD(miibus_statchg,       dwc_miibus_statchg),
1375
1376         { 0, 0 }
1377 };
1378
1379 driver_t dwc_driver = {
1380         "dwc",
1381         dwc_methods,
1382         sizeof(struct dwc_softc),
1383 };
1384
1385 static devclass_t dwc_devclass;
1386
1387 DRIVER_MODULE(dwc, simplebus, dwc_driver, dwc_devclass, 0, 0);
1388 DRIVER_MODULE(miibus, dwc, miibus_driver, miibus_devclass, 0, 0);
1389
1390 MODULE_DEPEND(dwc, ether, 1, 1, 1);
1391 MODULE_DEPEND(dwc, miibus, 1, 1, 1);