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 if (flags & GPIO_ACTIVE_LOW) 1078 pin_value = !pin_value; 1079 1080 GPIO_PIN_SETFLAGS(gpio, pin, GPIO_PIN_OUTPUT); 1081 GPIO_PIN_SET(gpio, pin, pin_value); 1082 DELAY(delay_prop[0]); 1083 GPIO_PIN_SET(gpio, pin, !pin_value); 1084 DELAY(delay_prop[1]); 1085 GPIO_PIN_SET(gpio, pin, pin_value); 1086 DELAY(delay_prop[2]); 1087 1088 return (0); 1089 } 1090 1091 #ifdef EXT_RESOURCES 1092 static int 1093 dwc_clock_init(device_t dev) 1094 { 1095 hwreset_t rst; 1096 clk_t clk; 1097 int error; 1098 1099 /* Enable clock */ 1100 if (clk_get_by_ofw_name(dev, 0, "stmmaceth", &clk) == 0) { 1101 error = clk_enable(clk); 1102 if (error != 0) { 1103 device_printf(dev, "could not enable main clock\n"); 1104 return (error); 1105 } 1106 } 1107 1108 /* De-assert reset */ 1109 if (hwreset_get_by_ofw_name(dev, 0, "stmmaceth", &rst) == 0) { 1110 error = hwreset_deassert(rst); 1111 if (error != 0) { 1112 device_printf(dev, "could not de-assert reset\n"); 1113 return (error); 1114 } 1115 } 1116 1117 return (0); 1118 } 1119 #endif 1120 1121 static int 1122 dwc_probe(device_t dev) 1123 { 1124 1125 if (!ofw_bus_status_okay(dev)) 1126 return (ENXIO); 1127 1128 if (!ofw_bus_is_compatible(dev, "snps,dwmac")) 1129 return (ENXIO); 1130 1131 device_set_desc(dev, "Gigabit Ethernet Controller"); 1132 return (BUS_PROBE_DEFAULT); 1133 } 1134 1135 static int 1136 dwc_attach(device_t dev) 1137 { 1138 uint8_t macaddr[ETHER_ADDR_LEN]; 1139 struct dwc_softc *sc; 1140 struct ifnet *ifp; 1141 int error, i; 1142 uint32_t reg; 1143 1144 sc = device_get_softc(dev); 1145 sc->dev = dev; 1146 sc->rx_idx = 0; 1147 sc->txcount = TX_DESC_COUNT; 1148 sc->mii_clk = IF_DWC_MII_CLK(dev); 1149 sc->mactype = IF_DWC_MAC_TYPE(dev); 1150 1151 if (IF_DWC_INIT(dev) != 0) 1152 return (ENXIO); 1153 1154 #ifdef EXT_RESOURCES 1155 if (dwc_clock_init(dev) != 0) 1156 return (ENXIO); 1157 #endif 1158 1159 if (bus_alloc_resources(dev, dwc_spec, sc->res)) { 1160 device_printf(dev, "could not allocate resources\n"); 1161 return (ENXIO); 1162 } 1163 1164 /* Memory interface */ 1165 sc->bst = rman_get_bustag(sc->res[0]); 1166 sc->bsh = rman_get_bushandle(sc->res[0]); 1167 1168 /* Read MAC before reset */ 1169 if (dwc_get_hwaddr(sc, macaddr)) { 1170 device_printf(sc->dev, "can't get mac\n"); 1171 return (ENXIO); 1172 } 1173 1174 /* Reset the PHY if needed */ 1175 if (dwc_reset(dev) != 0) { 1176 device_printf(dev, "Can't reset the PHY\n"); 1177 return (ENXIO); 1178 } 1179 1180 /* Reset */ 1181 reg = READ4(sc, BUS_MODE); 1182 reg |= (BUS_MODE_SWR); 1183 WRITE4(sc, BUS_MODE, reg); 1184 1185 for (i = 0; i < MAC_RESET_TIMEOUT; i++) { 1186 if ((READ4(sc, BUS_MODE) & BUS_MODE_SWR) == 0) 1187 break; 1188 DELAY(10); 1189 } 1190 if (i >= MAC_RESET_TIMEOUT) { 1191 device_printf(sc->dev, "Can't reset DWC.\n"); 1192 return (ENXIO); 1193 } 1194 1195 if (sc->mactype == DWC_GMAC_ALT_DESC) { 1196 reg = BUS_MODE_FIXEDBURST; 1197 reg |= (BUS_MODE_PRIORXTX_41 << BUS_MODE_PRIORXTX_SHIFT); 1198 } else 1199 reg = (BUS_MODE_EIGHTXPBL); 1200 reg |= (BUS_MODE_PBL_BEATS_8 << BUS_MODE_PBL_SHIFT); 1201 WRITE4(sc, BUS_MODE, reg); 1202 1203 /* 1204 * DMA must be stop while changing descriptor list addresses. 1205 */ 1206 reg = READ4(sc, OPERATION_MODE); 1207 reg &= ~(MODE_ST | MODE_SR); 1208 WRITE4(sc, OPERATION_MODE, reg); 1209 1210 if (setup_dma(sc)) 1211 return (ENXIO); 1212 1213 /* Setup addresses */ 1214 WRITE4(sc, RX_DESCR_LIST_ADDR, sc->rxdesc_ring_paddr); 1215 WRITE4(sc, TX_DESCR_LIST_ADDR, sc->txdesc_ring_paddr); 1216 1217 mtx_init(&sc->mtx, device_get_nameunit(sc->dev), 1218 MTX_NETWORK_LOCK, MTX_DEF); 1219 1220 callout_init_mtx(&sc->dwc_callout, &sc->mtx, 0); 1221 1222 /* Setup interrupt handler. */ 1223 error = bus_setup_intr(dev, sc->res[1], INTR_TYPE_NET | INTR_MPSAFE, 1224 NULL, dwc_intr, sc, &sc->intr_cookie); 1225 if (error != 0) { 1226 device_printf(dev, "could not setup interrupt handler.\n"); 1227 return (ENXIO); 1228 } 1229 1230 /* Set up the ethernet interface. */ 1231 sc->ifp = ifp = if_alloc(IFT_ETHER); 1232 1233 ifp->if_softc = sc; 1234 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 1235 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1236 ifp->if_capabilities = IFCAP_VLAN_MTU; 1237 ifp->if_capenable = ifp->if_capabilities; 1238 ifp->if_start = dwc_txstart; 1239 ifp->if_ioctl = dwc_ioctl; 1240 ifp->if_init = dwc_init; 1241 IFQ_SET_MAXLEN(&ifp->if_snd, TX_DESC_COUNT - 1); 1242 ifp->if_snd.ifq_drv_maxlen = TX_DESC_COUNT - 1; 1243 IFQ_SET_READY(&ifp->if_snd); 1244 1245 /* Attach the mii driver. */ 1246 error = mii_attach(dev, &sc->miibus, ifp, dwc_media_change, 1247 dwc_media_status, BMSR_DEFCAPMASK, MII_PHY_ANY, 1248 MII_OFFSET_ANY, 0); 1249 1250 if (error != 0) { 1251 device_printf(dev, "PHY attach failed\n"); 1252 return (ENXIO); 1253 } 1254 sc->mii_softc = device_get_softc(sc->miibus); 1255 1256 /* All ready to run, attach the ethernet interface. */ 1257 ether_ifattach(ifp, macaddr); 1258 sc->is_attached = true; 1259 1260 return (0); 1261 } 1262 1263 static int 1264 dwc_miibus_read_reg(device_t dev, int phy, int reg) 1265 { 1266 struct dwc_softc *sc; 1267 uint16_t mii; 1268 size_t cnt; 1269 int rv = 0; 1270 1271 sc = device_get_softc(dev); 1272 1273 mii = ((phy & GMII_ADDRESS_PA_MASK) << GMII_ADDRESS_PA_SHIFT) 1274 | ((reg & GMII_ADDRESS_GR_MASK) << GMII_ADDRESS_GR_SHIFT) 1275 | (sc->mii_clk << GMII_ADDRESS_CR_SHIFT) 1276 | GMII_ADDRESS_GB; /* Busy flag */ 1277 1278 WRITE4(sc, GMII_ADDRESS, mii); 1279 1280 for (cnt = 0; cnt < 1000; cnt++) { 1281 if (!(READ4(sc, GMII_ADDRESS) & GMII_ADDRESS_GB)) { 1282 rv = READ4(sc, GMII_DATA); 1283 break; 1284 } 1285 DELAY(10); 1286 } 1287 1288 return rv; 1289 } 1290 1291 static int 1292 dwc_miibus_write_reg(device_t dev, int phy, int reg, int val) 1293 { 1294 struct dwc_softc *sc; 1295 uint16_t mii; 1296 size_t cnt; 1297 1298 sc = device_get_softc(dev); 1299 1300 mii = ((phy & GMII_ADDRESS_PA_MASK) << GMII_ADDRESS_PA_SHIFT) 1301 | ((reg & GMII_ADDRESS_GR_MASK) << GMII_ADDRESS_GR_SHIFT) 1302 | (sc->mii_clk << GMII_ADDRESS_CR_SHIFT) 1303 | GMII_ADDRESS_GB | GMII_ADDRESS_GW; 1304 1305 WRITE4(sc, GMII_DATA, val); 1306 WRITE4(sc, GMII_ADDRESS, mii); 1307 1308 for (cnt = 0; cnt < 1000; cnt++) { 1309 if (!(READ4(sc, GMII_ADDRESS) & GMII_ADDRESS_GB)) { 1310 break; 1311 } 1312 DELAY(10); 1313 } 1314 1315 return (0); 1316 } 1317 1318 static void 1319 dwc_miibus_statchg(device_t dev) 1320 { 1321 struct dwc_softc *sc; 1322 struct mii_data *mii; 1323 uint32_t reg; 1324 1325 /* 1326 * Called by the MII bus driver when the PHY establishes 1327 * link to set the MAC interface registers. 1328 */ 1329 1330 sc = device_get_softc(dev); 1331 1332 DWC_ASSERT_LOCKED(sc); 1333 1334 mii = sc->mii_softc; 1335 1336 if (mii->mii_media_status & IFM_ACTIVE) 1337 sc->link_is_up = true; 1338 else 1339 sc->link_is_up = false; 1340 1341 reg = READ4(sc, MAC_CONFIGURATION); 1342 switch (IFM_SUBTYPE(mii->mii_media_active)) { 1343 case IFM_1000_T: 1344 case IFM_1000_SX: 1345 reg &= ~(CONF_FES | CONF_PS); 1346 break; 1347 case IFM_100_TX: 1348 reg |= (CONF_FES | CONF_PS); 1349 break; 1350 case IFM_10_T: 1351 reg &= ~(CONF_FES); 1352 reg |= (CONF_PS); 1353 break; 1354 case IFM_NONE: 1355 sc->link_is_up = false; 1356 return; 1357 default: 1358 sc->link_is_up = false; 1359 device_printf(dev, "Unsupported media %u\n", 1360 IFM_SUBTYPE(mii->mii_media_active)); 1361 return; 1362 } 1363 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) 1364 reg |= (CONF_DM); 1365 else 1366 reg &= ~(CONF_DM); 1367 WRITE4(sc, MAC_CONFIGURATION, reg); 1368 } 1369 1370 static device_method_t dwc_methods[] = { 1371 DEVMETHOD(device_probe, dwc_probe), 1372 DEVMETHOD(device_attach, dwc_attach), 1373 1374 /* MII Interface */ 1375 DEVMETHOD(miibus_readreg, dwc_miibus_read_reg), 1376 DEVMETHOD(miibus_writereg, dwc_miibus_write_reg), 1377 DEVMETHOD(miibus_statchg, dwc_miibus_statchg), 1378 1379 { 0, 0 } 1380 }; 1381 1382 driver_t dwc_driver = { 1383 "dwc", 1384 dwc_methods, 1385 sizeof(struct dwc_softc), 1386 }; 1387 1388 static devclass_t dwc_devclass; 1389 1390 DRIVER_MODULE(dwc, simplebus, dwc_driver, dwc_devclass, 0, 0); 1391 DRIVER_MODULE(miibus, dwc, miibus_driver, miibus_devclass, 0, 0); 1392 1393 MODULE_DEPEND(dwc, ether, 1, 1, 1); 1394 MODULE_DEPEND(dwc, miibus, 1, 1, 1); 1395