1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2010, Pyun YongHyeon <yongari@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice unmodified, this list of conditions, and the following 12 * disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /* Driver for DM&P Electronics, Inc, Vortex86 RDC R6040 FastEthernet. */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/bus.h> 38 #include <sys/endian.h> 39 #include <sys/kernel.h> 40 #include <sys/lock.h> 41 #include <sys/malloc.h> 42 #include <sys/mbuf.h> 43 #include <sys/module.h> 44 #include <sys/mutex.h> 45 #include <sys/rman.h> 46 #include <sys/socket.h> 47 #include <sys/sockio.h> 48 #include <sys/sysctl.h> 49 50 #include <net/bpf.h> 51 #include <net/if.h> 52 #include <net/if_var.h> 53 #include <net/if_arp.h> 54 #include <net/ethernet.h> 55 #include <net/if_dl.h> 56 #include <net/if_llc.h> 57 #include <net/if_media.h> 58 #include <net/if_types.h> 59 #include <net/if_vlan_var.h> 60 61 #include <netinet/in.h> 62 #include <netinet/in_systm.h> 63 64 #include <dev/mii/mii.h> 65 #include <dev/mii/miivar.h> 66 67 #include <dev/pci/pcireg.h> 68 #include <dev/pci/pcivar.h> 69 70 #include <machine/bus.h> 71 72 #include <dev/vte/if_vtereg.h> 73 #include <dev/vte/if_vtevar.h> 74 75 /* "device miibus" required. See GENERIC if you get errors here. */ 76 #include "miibus_if.h" 77 78 MODULE_DEPEND(vte, pci, 1, 1, 1); 79 MODULE_DEPEND(vte, ether, 1, 1, 1); 80 MODULE_DEPEND(vte, miibus, 1, 1, 1); 81 82 /* Tunables. */ 83 static int tx_deep_copy = 1; 84 TUNABLE_INT("hw.vte.tx_deep_copy", &tx_deep_copy); 85 86 /* 87 * Devices supported by this driver. 88 */ 89 static const struct vte_ident vte_ident_table[] = { 90 { VENDORID_RDC, DEVICEID_RDC_R6040, "RDC R6040 FastEthernet"}, 91 { 0, 0, NULL} 92 }; 93 94 static int vte_attach(device_t); 95 static int vte_detach(device_t); 96 static int vte_dma_alloc(struct vte_softc *); 97 static void vte_dma_free(struct vte_softc *); 98 static void vte_dmamap_cb(void *, bus_dma_segment_t *, int, int); 99 static struct vte_txdesc * 100 vte_encap(struct vte_softc *, struct mbuf **); 101 static const struct vte_ident * 102 vte_find_ident(device_t); 103 #ifndef __NO_STRICT_ALIGNMENT 104 static struct mbuf * 105 vte_fixup_rx(struct ifnet *, struct mbuf *); 106 #endif 107 static void vte_get_macaddr(struct vte_softc *); 108 static void vte_init(void *); 109 static void vte_init_locked(struct vte_softc *); 110 static int vte_init_rx_ring(struct vte_softc *); 111 static int vte_init_tx_ring(struct vte_softc *); 112 static void vte_intr(void *); 113 static int vte_ioctl(struct ifnet *, u_long, caddr_t); 114 static uint64_t vte_get_counter(struct ifnet *, ift_counter); 115 static void vte_mac_config(struct vte_softc *); 116 static int vte_miibus_readreg(device_t, int, int); 117 static void vte_miibus_statchg(device_t); 118 static int vte_miibus_writereg(device_t, int, int, int); 119 static int vte_mediachange(struct ifnet *); 120 static int vte_mediachange_locked(struct ifnet *); 121 static void vte_mediastatus(struct ifnet *, struct ifmediareq *); 122 static int vte_newbuf(struct vte_softc *, struct vte_rxdesc *); 123 static int vte_probe(device_t); 124 static void vte_reset(struct vte_softc *); 125 static int vte_resume(device_t); 126 static void vte_rxeof(struct vte_softc *); 127 static void vte_rxfilter(struct vte_softc *); 128 static int vte_shutdown(device_t); 129 static void vte_start(struct ifnet *); 130 static void vte_start_locked(struct vte_softc *); 131 static void vte_start_mac(struct vte_softc *); 132 static void vte_stats_clear(struct vte_softc *); 133 static void vte_stats_update(struct vte_softc *); 134 static void vte_stop(struct vte_softc *); 135 static void vte_stop_mac(struct vte_softc *); 136 static int vte_suspend(device_t); 137 static void vte_sysctl_node(struct vte_softc *); 138 static void vte_tick(void *); 139 static void vte_txeof(struct vte_softc *); 140 static void vte_watchdog(struct vte_softc *); 141 static int sysctl_int_range(SYSCTL_HANDLER_ARGS, int, int); 142 static int sysctl_hw_vte_int_mod(SYSCTL_HANDLER_ARGS); 143 144 static device_method_t vte_methods[] = { 145 /* Device interface. */ 146 DEVMETHOD(device_probe, vte_probe), 147 DEVMETHOD(device_attach, vte_attach), 148 DEVMETHOD(device_detach, vte_detach), 149 DEVMETHOD(device_shutdown, vte_shutdown), 150 DEVMETHOD(device_suspend, vte_suspend), 151 DEVMETHOD(device_resume, vte_resume), 152 153 /* MII interface. */ 154 DEVMETHOD(miibus_readreg, vte_miibus_readreg), 155 DEVMETHOD(miibus_writereg, vte_miibus_writereg), 156 DEVMETHOD(miibus_statchg, vte_miibus_statchg), 157 158 DEVMETHOD_END 159 }; 160 161 static driver_t vte_driver = { 162 "vte", 163 vte_methods, 164 sizeof(struct vte_softc) 165 }; 166 167 static devclass_t vte_devclass; 168 169 DRIVER_MODULE(vte, pci, vte_driver, vte_devclass, 0, 0); 170 DRIVER_MODULE(miibus, vte, miibus_driver, miibus_devclass, 0, 0); 171 172 static int 173 vte_miibus_readreg(device_t dev, int phy, int reg) 174 { 175 struct vte_softc *sc; 176 int i; 177 178 sc = device_get_softc(dev); 179 180 CSR_WRITE_2(sc, VTE_MMDIO, MMDIO_READ | 181 (phy << MMDIO_PHY_ADDR_SHIFT) | (reg << MMDIO_REG_ADDR_SHIFT)); 182 for (i = VTE_PHY_TIMEOUT; i > 0; i--) { 183 DELAY(5); 184 if ((CSR_READ_2(sc, VTE_MMDIO) & MMDIO_READ) == 0) 185 break; 186 } 187 188 if (i == 0) { 189 device_printf(sc->vte_dev, "phy read timeout : %d\n", reg); 190 return (0); 191 } 192 193 return (CSR_READ_2(sc, VTE_MMRD)); 194 } 195 196 static int 197 vte_miibus_writereg(device_t dev, int phy, int reg, int val) 198 { 199 struct vte_softc *sc; 200 int i; 201 202 sc = device_get_softc(dev); 203 204 CSR_WRITE_2(sc, VTE_MMWD, val); 205 CSR_WRITE_2(sc, VTE_MMDIO, MMDIO_WRITE | 206 (phy << MMDIO_PHY_ADDR_SHIFT) | (reg << MMDIO_REG_ADDR_SHIFT)); 207 for (i = VTE_PHY_TIMEOUT; i > 0; i--) { 208 DELAY(5); 209 if ((CSR_READ_2(sc, VTE_MMDIO) & MMDIO_WRITE) == 0) 210 break; 211 } 212 213 if (i == 0) 214 device_printf(sc->vte_dev, "phy write timeout : %d\n", reg); 215 216 return (0); 217 } 218 219 static void 220 vte_miibus_statchg(device_t dev) 221 { 222 struct vte_softc *sc; 223 struct mii_data *mii; 224 struct ifnet *ifp; 225 uint16_t val; 226 227 sc = device_get_softc(dev); 228 229 mii = device_get_softc(sc->vte_miibus); 230 ifp = sc->vte_ifp; 231 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 232 return; 233 234 sc->vte_flags &= ~VTE_FLAG_LINK; 235 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) == 236 (IFM_ACTIVE | IFM_AVALID)) { 237 switch (IFM_SUBTYPE(mii->mii_media_active)) { 238 case IFM_10_T: 239 case IFM_100_TX: 240 sc->vte_flags |= VTE_FLAG_LINK; 241 break; 242 default: 243 break; 244 } 245 } 246 247 /* Stop RX/TX MACs. */ 248 vte_stop_mac(sc); 249 /* Program MACs with resolved duplex and flow control. */ 250 if ((sc->vte_flags & VTE_FLAG_LINK) != 0) { 251 /* 252 * Timer waiting time : (63 + TIMER * 64) MII clock. 253 * MII clock : 25MHz(100Mbps) or 2.5MHz(10Mbps). 254 */ 255 if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) 256 val = 18 << VTE_IM_TIMER_SHIFT; 257 else 258 val = 1 << VTE_IM_TIMER_SHIFT; 259 val |= sc->vte_int_rx_mod << VTE_IM_BUNDLE_SHIFT; 260 /* 48.6us for 100Mbps, 50.8us for 10Mbps */ 261 CSR_WRITE_2(sc, VTE_MRICR, val); 262 263 if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) 264 val = 18 << VTE_IM_TIMER_SHIFT; 265 else 266 val = 1 << VTE_IM_TIMER_SHIFT; 267 val |= sc->vte_int_tx_mod << VTE_IM_BUNDLE_SHIFT; 268 /* 48.6us for 100Mbps, 50.8us for 10Mbps */ 269 CSR_WRITE_2(sc, VTE_MTICR, val); 270 271 vte_mac_config(sc); 272 vte_start_mac(sc); 273 } 274 } 275 276 static void 277 vte_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr) 278 { 279 struct vte_softc *sc; 280 struct mii_data *mii; 281 282 sc = ifp->if_softc; 283 VTE_LOCK(sc); 284 if ((ifp->if_flags & IFF_UP) == 0) { 285 VTE_UNLOCK(sc); 286 return; 287 } 288 mii = device_get_softc(sc->vte_miibus); 289 290 mii_pollstat(mii); 291 ifmr->ifm_status = mii->mii_media_status; 292 ifmr->ifm_active = mii->mii_media_active; 293 VTE_UNLOCK(sc); 294 } 295 296 static int 297 vte_mediachange(struct ifnet *ifp) 298 { 299 struct vte_softc *sc; 300 int error; 301 302 sc = ifp->if_softc; 303 VTE_LOCK(sc); 304 error = vte_mediachange_locked(ifp); 305 VTE_UNLOCK(sc); 306 return (error); 307 } 308 309 static int 310 vte_mediachange_locked(struct ifnet *ifp) 311 { 312 struct vte_softc *sc; 313 struct mii_data *mii; 314 struct mii_softc *miisc; 315 int error; 316 317 sc = ifp->if_softc; 318 mii = device_get_softc(sc->vte_miibus); 319 LIST_FOREACH(miisc, &mii->mii_phys, mii_list) 320 PHY_RESET(miisc); 321 error = mii_mediachg(mii); 322 323 return (error); 324 } 325 326 static const struct vte_ident * 327 vte_find_ident(device_t dev) 328 { 329 const struct vte_ident *ident; 330 uint16_t vendor, devid; 331 332 vendor = pci_get_vendor(dev); 333 devid = pci_get_device(dev); 334 for (ident = vte_ident_table; ident->name != NULL; ident++) { 335 if (vendor == ident->vendorid && devid == ident->deviceid) 336 return (ident); 337 } 338 339 return (NULL); 340 } 341 342 static int 343 vte_probe(device_t dev) 344 { 345 const struct vte_ident *ident; 346 347 ident = vte_find_ident(dev); 348 if (ident != NULL) { 349 device_set_desc(dev, ident->name); 350 return (BUS_PROBE_DEFAULT); 351 } 352 353 return (ENXIO); 354 } 355 356 static void 357 vte_get_macaddr(struct vte_softc *sc) 358 { 359 uint16_t mid; 360 361 /* 362 * It seems there is no way to reload station address and 363 * it is supposed to be set by BIOS. 364 */ 365 mid = CSR_READ_2(sc, VTE_MID0L); 366 sc->vte_eaddr[0] = (mid >> 0) & 0xFF; 367 sc->vte_eaddr[1] = (mid >> 8) & 0xFF; 368 mid = CSR_READ_2(sc, VTE_MID0M); 369 sc->vte_eaddr[2] = (mid >> 0) & 0xFF; 370 sc->vte_eaddr[3] = (mid >> 8) & 0xFF; 371 mid = CSR_READ_2(sc, VTE_MID0H); 372 sc->vte_eaddr[4] = (mid >> 0) & 0xFF; 373 sc->vte_eaddr[5] = (mid >> 8) & 0xFF; 374 } 375 376 static int 377 vte_attach(device_t dev) 378 { 379 struct vte_softc *sc; 380 struct ifnet *ifp; 381 uint16_t macid; 382 int error, rid; 383 384 error = 0; 385 sc = device_get_softc(dev); 386 sc->vte_dev = dev; 387 388 mtx_init(&sc->vte_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK, 389 MTX_DEF); 390 callout_init_mtx(&sc->vte_tick_ch, &sc->vte_mtx, 0); 391 sc->vte_ident = vte_find_ident(dev); 392 393 /* Map the device. */ 394 pci_enable_busmaster(dev); 395 sc->vte_res_id = PCIR_BAR(1); 396 sc->vte_res_type = SYS_RES_MEMORY; 397 sc->vte_res = bus_alloc_resource_any(dev, sc->vte_res_type, 398 &sc->vte_res_id, RF_ACTIVE); 399 if (sc->vte_res == NULL) { 400 sc->vte_res_id = PCIR_BAR(0); 401 sc->vte_res_type = SYS_RES_IOPORT; 402 sc->vte_res = bus_alloc_resource_any(dev, sc->vte_res_type, 403 &sc->vte_res_id, RF_ACTIVE); 404 if (sc->vte_res == NULL) { 405 device_printf(dev, "cannot map memory/ports.\n"); 406 mtx_destroy(&sc->vte_mtx); 407 return (ENXIO); 408 } 409 } 410 if (bootverbose) { 411 device_printf(dev, "using %s space register mapping\n", 412 sc->vte_res_type == SYS_RES_MEMORY ? "memory" : "I/O"); 413 device_printf(dev, "MAC Identifier : 0x%04x\n", 414 CSR_READ_2(sc, VTE_MACID)); 415 macid = CSR_READ_2(sc, VTE_MACID_REV); 416 device_printf(dev, "MAC Id. 0x%02x, Rev. 0x%02x\n", 417 (macid & VTE_MACID_MASK) >> VTE_MACID_SHIFT, 418 (macid & VTE_MACID_REV_MASK) >> VTE_MACID_REV_SHIFT); 419 } 420 421 rid = 0; 422 sc->vte_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 423 RF_SHAREABLE | RF_ACTIVE); 424 if (sc->vte_irq == NULL) { 425 device_printf(dev, "cannot allocate IRQ resources.\n"); 426 error = ENXIO; 427 goto fail; 428 } 429 430 /* Reset the ethernet controller. */ 431 vte_reset(sc); 432 433 if ((error = vte_dma_alloc(sc)) != 0) 434 goto fail; 435 436 /* Create device sysctl node. */ 437 vte_sysctl_node(sc); 438 439 /* Load station address. */ 440 vte_get_macaddr(sc); 441 442 ifp = sc->vte_ifp = if_alloc(IFT_ETHER); 443 if (ifp == NULL) { 444 device_printf(dev, "cannot allocate ifnet structure.\n"); 445 error = ENXIO; 446 goto fail; 447 } 448 449 ifp->if_softc = sc; 450 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 451 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 452 ifp->if_ioctl = vte_ioctl; 453 ifp->if_start = vte_start; 454 ifp->if_init = vte_init; 455 ifp->if_get_counter = vte_get_counter; 456 ifp->if_snd.ifq_drv_maxlen = VTE_TX_RING_CNT - 1; 457 IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen); 458 IFQ_SET_READY(&ifp->if_snd); 459 460 /* 461 * Set up MII bus. 462 * BIOS would have initialized VTE_MPSCCR to catch PHY 463 * status changes so driver may be able to extract 464 * configured PHY address. Since it's common to see BIOS 465 * fails to initialize the register(including the sample 466 * board I have), let mii(4) probe it. This is more 467 * reliable than relying on BIOS's initialization. 468 * 469 * Advertising flow control capability to mii(4) was 470 * intentionally disabled due to severe problems in TX 471 * pause frame generation. See vte_rxeof() for more 472 * details. 473 */ 474 error = mii_attach(dev, &sc->vte_miibus, ifp, vte_mediachange, 475 vte_mediastatus, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0); 476 if (error != 0) { 477 device_printf(dev, "attaching PHYs failed\n"); 478 goto fail; 479 } 480 481 ether_ifattach(ifp, sc->vte_eaddr); 482 483 /* VLAN capability setup. */ 484 ifp->if_capabilities |= IFCAP_VLAN_MTU; 485 ifp->if_capenable = ifp->if_capabilities; 486 /* Tell the upper layer we support VLAN over-sized frames. */ 487 ifp->if_hdrlen = sizeof(struct ether_vlan_header); 488 489 error = bus_setup_intr(dev, sc->vte_irq, INTR_TYPE_NET | INTR_MPSAFE, 490 NULL, vte_intr, sc, &sc->vte_intrhand); 491 if (error != 0) { 492 device_printf(dev, "could not set up interrupt handler.\n"); 493 ether_ifdetach(ifp); 494 goto fail; 495 } 496 497 fail: 498 if (error != 0) 499 vte_detach(dev); 500 501 return (error); 502 } 503 504 static int 505 vte_detach(device_t dev) 506 { 507 struct vte_softc *sc; 508 struct ifnet *ifp; 509 510 sc = device_get_softc(dev); 511 512 ifp = sc->vte_ifp; 513 if (device_is_attached(dev)) { 514 VTE_LOCK(sc); 515 vte_stop(sc); 516 VTE_UNLOCK(sc); 517 callout_drain(&sc->vte_tick_ch); 518 ether_ifdetach(ifp); 519 } 520 521 if (sc->vte_miibus != NULL) { 522 device_delete_child(dev, sc->vte_miibus); 523 sc->vte_miibus = NULL; 524 } 525 bus_generic_detach(dev); 526 527 if (sc->vte_intrhand != NULL) { 528 bus_teardown_intr(dev, sc->vte_irq, sc->vte_intrhand); 529 sc->vte_intrhand = NULL; 530 } 531 if (sc->vte_irq != NULL) { 532 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->vte_irq); 533 sc->vte_irq = NULL; 534 } 535 if (sc->vte_res != NULL) { 536 bus_release_resource(dev, sc->vte_res_type, sc->vte_res_id, 537 sc->vte_res); 538 sc->vte_res = NULL; 539 } 540 if (ifp != NULL) { 541 if_free(ifp); 542 sc->vte_ifp = NULL; 543 } 544 vte_dma_free(sc); 545 mtx_destroy(&sc->vte_mtx); 546 547 return (0); 548 } 549 550 #define VTE_SYSCTL_STAT_ADD32(c, h, n, p, d) \ 551 SYSCTL_ADD_UINT(c, h, OID_AUTO, n, CTLFLAG_RD, p, 0, d) 552 553 static void 554 vte_sysctl_node(struct vte_softc *sc) 555 { 556 struct sysctl_ctx_list *ctx; 557 struct sysctl_oid_list *child, *parent; 558 struct sysctl_oid *tree; 559 struct vte_hw_stats *stats; 560 int error; 561 562 stats = &sc->vte_stats; 563 ctx = device_get_sysctl_ctx(sc->vte_dev); 564 child = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->vte_dev)); 565 566 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_rx_mod", 567 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 568 &sc->vte_int_rx_mod, 0, sysctl_hw_vte_int_mod, "I", 569 "vte RX interrupt moderation"); 570 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "int_tx_mod", 571 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, 572 &sc->vte_int_tx_mod, 0, sysctl_hw_vte_int_mod, "I", 573 "vte TX interrupt moderation"); 574 /* Pull in device tunables. */ 575 sc->vte_int_rx_mod = VTE_IM_RX_BUNDLE_DEFAULT; 576 error = resource_int_value(device_get_name(sc->vte_dev), 577 device_get_unit(sc->vte_dev), "int_rx_mod", &sc->vte_int_rx_mod); 578 if (error == 0) { 579 if (sc->vte_int_rx_mod < VTE_IM_BUNDLE_MIN || 580 sc->vte_int_rx_mod > VTE_IM_BUNDLE_MAX) { 581 device_printf(sc->vte_dev, "int_rx_mod value out of " 582 "range; using default: %d\n", 583 VTE_IM_RX_BUNDLE_DEFAULT); 584 sc->vte_int_rx_mod = VTE_IM_RX_BUNDLE_DEFAULT; 585 } 586 } 587 588 sc->vte_int_tx_mod = VTE_IM_TX_BUNDLE_DEFAULT; 589 error = resource_int_value(device_get_name(sc->vte_dev), 590 device_get_unit(sc->vte_dev), "int_tx_mod", &sc->vte_int_tx_mod); 591 if (error == 0) { 592 if (sc->vte_int_tx_mod < VTE_IM_BUNDLE_MIN || 593 sc->vte_int_tx_mod > VTE_IM_BUNDLE_MAX) { 594 device_printf(sc->vte_dev, "int_tx_mod value out of " 595 "range; using default: %d\n", 596 VTE_IM_TX_BUNDLE_DEFAULT); 597 sc->vte_int_tx_mod = VTE_IM_TX_BUNDLE_DEFAULT; 598 } 599 } 600 601 tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", 602 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "VTE statistics"); 603 parent = SYSCTL_CHILDREN(tree); 604 605 /* RX statistics. */ 606 tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx", 607 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "RX MAC statistics"); 608 child = SYSCTL_CHILDREN(tree); 609 VTE_SYSCTL_STAT_ADD32(ctx, child, "good_frames", 610 &stats->rx_frames, "Good frames"); 611 VTE_SYSCTL_STAT_ADD32(ctx, child, "good_bcast_frames", 612 &stats->rx_bcast_frames, "Good broadcast frames"); 613 VTE_SYSCTL_STAT_ADD32(ctx, child, "good_mcast_frames", 614 &stats->rx_mcast_frames, "Good multicast frames"); 615 VTE_SYSCTL_STAT_ADD32(ctx, child, "runt", 616 &stats->rx_runts, "Too short frames"); 617 VTE_SYSCTL_STAT_ADD32(ctx, child, "crc_errs", 618 &stats->rx_crcerrs, "CRC errors"); 619 VTE_SYSCTL_STAT_ADD32(ctx, child, "long_frames", 620 &stats->rx_long_frames, 621 "Frames that have longer length than maximum packet length"); 622 VTE_SYSCTL_STAT_ADD32(ctx, child, "fifo_full", 623 &stats->rx_fifo_full, "FIFO full"); 624 VTE_SYSCTL_STAT_ADD32(ctx, child, "desc_unavail", 625 &stats->rx_desc_unavail, "Descriptor unavailable frames"); 626 VTE_SYSCTL_STAT_ADD32(ctx, child, "pause_frames", 627 &stats->rx_pause_frames, "Pause control frames"); 628 629 /* TX statistics. */ 630 tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "tx", 631 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "TX MAC statistics"); 632 child = SYSCTL_CHILDREN(tree); 633 VTE_SYSCTL_STAT_ADD32(ctx, child, "good_frames", 634 &stats->tx_frames, "Good frames"); 635 VTE_SYSCTL_STAT_ADD32(ctx, child, "underruns", 636 &stats->tx_underruns, "FIFO underruns"); 637 VTE_SYSCTL_STAT_ADD32(ctx, child, "late_colls", 638 &stats->tx_late_colls, "Late collisions"); 639 VTE_SYSCTL_STAT_ADD32(ctx, child, "pause_frames", 640 &stats->tx_pause_frames, "Pause control frames"); 641 } 642 643 #undef VTE_SYSCTL_STAT_ADD32 644 645 struct vte_dmamap_arg { 646 bus_addr_t vte_busaddr; 647 }; 648 649 static void 650 vte_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 651 { 652 struct vte_dmamap_arg *ctx; 653 654 if (error != 0) 655 return; 656 657 KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs)); 658 659 ctx = (struct vte_dmamap_arg *)arg; 660 ctx->vte_busaddr = segs[0].ds_addr; 661 } 662 663 static int 664 vte_dma_alloc(struct vte_softc *sc) 665 { 666 struct vte_txdesc *txd; 667 struct vte_rxdesc *rxd; 668 struct vte_dmamap_arg ctx; 669 int error, i; 670 671 /* Create parent DMA tag. */ 672 error = bus_dma_tag_create( 673 bus_get_dma_tag(sc->vte_dev), /* parent */ 674 1, 0, /* alignment, boundary */ 675 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 676 BUS_SPACE_MAXADDR, /* highaddr */ 677 NULL, NULL, /* filter, filterarg */ 678 BUS_SPACE_MAXSIZE_32BIT, /* maxsize */ 679 0, /* nsegments */ 680 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 681 0, /* flags */ 682 NULL, NULL, /* lockfunc, lockarg */ 683 &sc->vte_cdata.vte_parent_tag); 684 if (error != 0) { 685 device_printf(sc->vte_dev, 686 "could not create parent DMA tag.\n"); 687 goto fail; 688 } 689 690 /* Create DMA tag for TX descriptor ring. */ 691 error = bus_dma_tag_create( 692 sc->vte_cdata.vte_parent_tag, /* parent */ 693 VTE_TX_RING_ALIGN, 0, /* alignment, boundary */ 694 BUS_SPACE_MAXADDR, /* lowaddr */ 695 BUS_SPACE_MAXADDR, /* highaddr */ 696 NULL, NULL, /* filter, filterarg */ 697 VTE_TX_RING_SZ, /* maxsize */ 698 1, /* nsegments */ 699 VTE_TX_RING_SZ, /* maxsegsize */ 700 0, /* flags */ 701 NULL, NULL, /* lockfunc, lockarg */ 702 &sc->vte_cdata.vte_tx_ring_tag); 703 if (error != 0) { 704 device_printf(sc->vte_dev, 705 "could not create TX ring DMA tag.\n"); 706 goto fail; 707 } 708 709 /* Create DMA tag for RX free descriptor ring. */ 710 error = bus_dma_tag_create( 711 sc->vte_cdata.vte_parent_tag, /* parent */ 712 VTE_RX_RING_ALIGN, 0, /* alignment, boundary */ 713 BUS_SPACE_MAXADDR, /* lowaddr */ 714 BUS_SPACE_MAXADDR, /* highaddr */ 715 NULL, NULL, /* filter, filterarg */ 716 VTE_RX_RING_SZ, /* maxsize */ 717 1, /* nsegments */ 718 VTE_RX_RING_SZ, /* maxsegsize */ 719 0, /* flags */ 720 NULL, NULL, /* lockfunc, lockarg */ 721 &sc->vte_cdata.vte_rx_ring_tag); 722 if (error != 0) { 723 device_printf(sc->vte_dev, 724 "could not create RX ring DMA tag.\n"); 725 goto fail; 726 } 727 728 /* Allocate DMA'able memory and load the DMA map for TX ring. */ 729 error = bus_dmamem_alloc(sc->vte_cdata.vte_tx_ring_tag, 730 (void **)&sc->vte_cdata.vte_tx_ring, 731 BUS_DMA_WAITOK | BUS_DMA_ZERO | BUS_DMA_COHERENT, 732 &sc->vte_cdata.vte_tx_ring_map); 733 if (error != 0) { 734 device_printf(sc->vte_dev, 735 "could not allocate DMA'able memory for TX ring.\n"); 736 goto fail; 737 } 738 ctx.vte_busaddr = 0; 739 error = bus_dmamap_load(sc->vte_cdata.vte_tx_ring_tag, 740 sc->vte_cdata.vte_tx_ring_map, sc->vte_cdata.vte_tx_ring, 741 VTE_TX_RING_SZ, vte_dmamap_cb, &ctx, 0); 742 if (error != 0 || ctx.vte_busaddr == 0) { 743 device_printf(sc->vte_dev, 744 "could not load DMA'able memory for TX ring.\n"); 745 goto fail; 746 } 747 sc->vte_cdata.vte_tx_ring_paddr = ctx.vte_busaddr; 748 749 /* Allocate DMA'able memory and load the DMA map for RX ring. */ 750 error = bus_dmamem_alloc(sc->vte_cdata.vte_rx_ring_tag, 751 (void **)&sc->vte_cdata.vte_rx_ring, 752 BUS_DMA_WAITOK | BUS_DMA_ZERO | BUS_DMA_COHERENT, 753 &sc->vte_cdata.vte_rx_ring_map); 754 if (error != 0) { 755 device_printf(sc->vte_dev, 756 "could not allocate DMA'able memory for RX ring.\n"); 757 goto fail; 758 } 759 ctx.vte_busaddr = 0; 760 error = bus_dmamap_load(sc->vte_cdata.vte_rx_ring_tag, 761 sc->vte_cdata.vte_rx_ring_map, sc->vte_cdata.vte_rx_ring, 762 VTE_RX_RING_SZ, vte_dmamap_cb, &ctx, 0); 763 if (error != 0 || ctx.vte_busaddr == 0) { 764 device_printf(sc->vte_dev, 765 "could not load DMA'able memory for RX ring.\n"); 766 goto fail; 767 } 768 sc->vte_cdata.vte_rx_ring_paddr = ctx.vte_busaddr; 769 770 /* Create TX buffer parent tag. */ 771 error = bus_dma_tag_create( 772 bus_get_dma_tag(sc->vte_dev), /* parent */ 773 1, 0, /* alignment, boundary */ 774 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 775 BUS_SPACE_MAXADDR, /* highaddr */ 776 NULL, NULL, /* filter, filterarg */ 777 BUS_SPACE_MAXSIZE_32BIT, /* maxsize */ 778 0, /* nsegments */ 779 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 780 0, /* flags */ 781 NULL, NULL, /* lockfunc, lockarg */ 782 &sc->vte_cdata.vte_buffer_tag); 783 if (error != 0) { 784 device_printf(sc->vte_dev, 785 "could not create parent buffer DMA tag.\n"); 786 goto fail; 787 } 788 789 /* Create DMA tag for TX buffers. */ 790 error = bus_dma_tag_create( 791 sc->vte_cdata.vte_buffer_tag, /* parent */ 792 1, 0, /* alignment, boundary */ 793 BUS_SPACE_MAXADDR, /* lowaddr */ 794 BUS_SPACE_MAXADDR, /* highaddr */ 795 NULL, NULL, /* filter, filterarg */ 796 MCLBYTES, /* maxsize */ 797 1, /* nsegments */ 798 MCLBYTES, /* maxsegsize */ 799 0, /* flags */ 800 NULL, NULL, /* lockfunc, lockarg */ 801 &sc->vte_cdata.vte_tx_tag); 802 if (error != 0) { 803 device_printf(sc->vte_dev, "could not create TX DMA tag.\n"); 804 goto fail; 805 } 806 807 /* Create DMA tag for RX buffers. */ 808 error = bus_dma_tag_create( 809 sc->vte_cdata.vte_buffer_tag, /* parent */ 810 VTE_RX_BUF_ALIGN, 0, /* alignment, boundary */ 811 BUS_SPACE_MAXADDR, /* lowaddr */ 812 BUS_SPACE_MAXADDR, /* highaddr */ 813 NULL, NULL, /* filter, filterarg */ 814 MCLBYTES, /* maxsize */ 815 1, /* nsegments */ 816 MCLBYTES, /* maxsegsize */ 817 0, /* flags */ 818 NULL, NULL, /* lockfunc, lockarg */ 819 &sc->vte_cdata.vte_rx_tag); 820 if (error != 0) { 821 device_printf(sc->vte_dev, "could not create RX DMA tag.\n"); 822 goto fail; 823 } 824 /* Create DMA maps for TX buffers. */ 825 for (i = 0; i < VTE_TX_RING_CNT; i++) { 826 txd = &sc->vte_cdata.vte_txdesc[i]; 827 txd->tx_m = NULL; 828 txd->tx_dmamap = NULL; 829 error = bus_dmamap_create(sc->vte_cdata.vte_tx_tag, 0, 830 &txd->tx_dmamap); 831 if (error != 0) { 832 device_printf(sc->vte_dev, 833 "could not create TX dmamap.\n"); 834 goto fail; 835 } 836 } 837 /* Create DMA maps for RX buffers. */ 838 if ((error = bus_dmamap_create(sc->vte_cdata.vte_rx_tag, 0, 839 &sc->vte_cdata.vte_rx_sparemap)) != 0) { 840 device_printf(sc->vte_dev, 841 "could not create spare RX dmamap.\n"); 842 goto fail; 843 } 844 for (i = 0; i < VTE_RX_RING_CNT; i++) { 845 rxd = &sc->vte_cdata.vte_rxdesc[i]; 846 rxd->rx_m = NULL; 847 rxd->rx_dmamap = NULL; 848 error = bus_dmamap_create(sc->vte_cdata.vte_rx_tag, 0, 849 &rxd->rx_dmamap); 850 if (error != 0) { 851 device_printf(sc->vte_dev, 852 "could not create RX dmamap.\n"); 853 goto fail; 854 } 855 } 856 857 fail: 858 return (error); 859 } 860 861 static void 862 vte_dma_free(struct vte_softc *sc) 863 { 864 struct vte_txdesc *txd; 865 struct vte_rxdesc *rxd; 866 int i; 867 868 /* TX buffers. */ 869 if (sc->vte_cdata.vte_tx_tag != NULL) { 870 for (i = 0; i < VTE_TX_RING_CNT; i++) { 871 txd = &sc->vte_cdata.vte_txdesc[i]; 872 if (txd->tx_dmamap != NULL) { 873 bus_dmamap_destroy(sc->vte_cdata.vte_tx_tag, 874 txd->tx_dmamap); 875 txd->tx_dmamap = NULL; 876 } 877 } 878 bus_dma_tag_destroy(sc->vte_cdata.vte_tx_tag); 879 sc->vte_cdata.vte_tx_tag = NULL; 880 } 881 /* RX buffers */ 882 if (sc->vte_cdata.vte_rx_tag != NULL) { 883 for (i = 0; i < VTE_RX_RING_CNT; i++) { 884 rxd = &sc->vte_cdata.vte_rxdesc[i]; 885 if (rxd->rx_dmamap != NULL) { 886 bus_dmamap_destroy(sc->vte_cdata.vte_rx_tag, 887 rxd->rx_dmamap); 888 rxd->rx_dmamap = NULL; 889 } 890 } 891 if (sc->vte_cdata.vte_rx_sparemap != NULL) { 892 bus_dmamap_destroy(sc->vte_cdata.vte_rx_tag, 893 sc->vte_cdata.vte_rx_sparemap); 894 sc->vte_cdata.vte_rx_sparemap = NULL; 895 } 896 bus_dma_tag_destroy(sc->vte_cdata.vte_rx_tag); 897 sc->vte_cdata.vte_rx_tag = NULL; 898 } 899 /* TX descriptor ring. */ 900 if (sc->vte_cdata.vte_tx_ring_tag != NULL) { 901 if (sc->vte_cdata.vte_tx_ring_paddr != 0) 902 bus_dmamap_unload(sc->vte_cdata.vte_tx_ring_tag, 903 sc->vte_cdata.vte_tx_ring_map); 904 if (sc->vte_cdata.vte_tx_ring != NULL) 905 bus_dmamem_free(sc->vte_cdata.vte_tx_ring_tag, 906 sc->vte_cdata.vte_tx_ring, 907 sc->vte_cdata.vte_tx_ring_map); 908 sc->vte_cdata.vte_tx_ring = NULL; 909 sc->vte_cdata.vte_tx_ring_paddr = 0; 910 bus_dma_tag_destroy(sc->vte_cdata.vte_tx_ring_tag); 911 sc->vte_cdata.vte_tx_ring_tag = NULL; 912 } 913 /* RX ring. */ 914 if (sc->vte_cdata.vte_rx_ring_tag != NULL) { 915 if (sc->vte_cdata.vte_rx_ring_paddr != 0) 916 bus_dmamap_unload(sc->vte_cdata.vte_rx_ring_tag, 917 sc->vte_cdata.vte_rx_ring_map); 918 if (sc->vte_cdata.vte_rx_ring != NULL) 919 bus_dmamem_free(sc->vte_cdata.vte_rx_ring_tag, 920 sc->vte_cdata.vte_rx_ring, 921 sc->vte_cdata.vte_rx_ring_map); 922 sc->vte_cdata.vte_rx_ring = NULL; 923 sc->vte_cdata.vte_rx_ring_paddr = 0; 924 bus_dma_tag_destroy(sc->vte_cdata.vte_rx_ring_tag); 925 sc->vte_cdata.vte_rx_ring_tag = NULL; 926 } 927 if (sc->vte_cdata.vte_buffer_tag != NULL) { 928 bus_dma_tag_destroy(sc->vte_cdata.vte_buffer_tag); 929 sc->vte_cdata.vte_buffer_tag = NULL; 930 } 931 if (sc->vte_cdata.vte_parent_tag != NULL) { 932 bus_dma_tag_destroy(sc->vte_cdata.vte_parent_tag); 933 sc->vte_cdata.vte_parent_tag = NULL; 934 } 935 } 936 937 static int 938 vte_shutdown(device_t dev) 939 { 940 941 return (vte_suspend(dev)); 942 } 943 944 static int 945 vte_suspend(device_t dev) 946 { 947 struct vte_softc *sc; 948 struct ifnet *ifp; 949 950 sc = device_get_softc(dev); 951 952 VTE_LOCK(sc); 953 ifp = sc->vte_ifp; 954 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) 955 vte_stop(sc); 956 VTE_UNLOCK(sc); 957 958 return (0); 959 } 960 961 static int 962 vte_resume(device_t dev) 963 { 964 struct vte_softc *sc; 965 struct ifnet *ifp; 966 967 sc = device_get_softc(dev); 968 969 VTE_LOCK(sc); 970 ifp = sc->vte_ifp; 971 if ((ifp->if_flags & IFF_UP) != 0) { 972 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 973 vte_init_locked(sc); 974 } 975 VTE_UNLOCK(sc); 976 977 return (0); 978 } 979 980 static struct vte_txdesc * 981 vte_encap(struct vte_softc *sc, struct mbuf **m_head) 982 { 983 struct vte_txdesc *txd; 984 struct mbuf *m, *n; 985 bus_dma_segment_t txsegs[1]; 986 int copy, error, nsegs, padlen; 987 988 VTE_LOCK_ASSERT(sc); 989 990 M_ASSERTPKTHDR((*m_head)); 991 992 txd = &sc->vte_cdata.vte_txdesc[sc->vte_cdata.vte_tx_prod]; 993 m = *m_head; 994 /* 995 * Controller doesn't auto-pad, so we have to make sure pad 996 * short frames out to the minimum frame length. 997 */ 998 if (m->m_pkthdr.len < VTE_MIN_FRAMELEN) 999 padlen = VTE_MIN_FRAMELEN - m->m_pkthdr.len; 1000 else 1001 padlen = 0; 1002 1003 /* 1004 * Controller does not support multi-fragmented TX buffers. 1005 * Controller spends most of its TX processing time in 1006 * de-fragmenting TX buffers. Either faster CPU or more 1007 * advanced controller DMA engine is required to speed up 1008 * TX path processing. 1009 * To mitigate the de-fragmenting issue, perform deep copy 1010 * from fragmented mbuf chains to a pre-allocated mbuf 1011 * cluster with extra cost of kernel memory. For frames 1012 * that is composed of single TX buffer, the deep copy is 1013 * bypassed. 1014 */ 1015 if (tx_deep_copy != 0) { 1016 copy = 0; 1017 if (m->m_next != NULL) 1018 copy++; 1019 if (padlen > 0 && (M_WRITABLE(m) == 0 || 1020 padlen > M_TRAILINGSPACE(m))) 1021 copy++; 1022 if (copy != 0) { 1023 /* Avoid expensive m_defrag(9) and do deep copy. */ 1024 n = sc->vte_cdata.vte_txmbufs[sc->vte_cdata.vte_tx_prod]; 1025 m_copydata(m, 0, m->m_pkthdr.len, mtod(n, char *)); 1026 n->m_pkthdr.len = m->m_pkthdr.len; 1027 n->m_len = m->m_pkthdr.len; 1028 m = n; 1029 txd->tx_flags |= VTE_TXMBUF; 1030 } 1031 1032 if (padlen > 0) { 1033 /* Zero out the bytes in the pad area. */ 1034 bzero(mtod(m, char *) + m->m_pkthdr.len, padlen); 1035 m->m_pkthdr.len += padlen; 1036 m->m_len = m->m_pkthdr.len; 1037 } 1038 } else { 1039 if (M_WRITABLE(m) == 0) { 1040 if (m->m_next != NULL || padlen > 0) { 1041 /* Get a writable copy. */ 1042 m = m_dup(*m_head, M_NOWAIT); 1043 /* Release original mbuf chains. */ 1044 m_freem(*m_head); 1045 if (m == NULL) { 1046 *m_head = NULL; 1047 return (NULL); 1048 } 1049 *m_head = m; 1050 } 1051 } 1052 1053 if (m->m_next != NULL) { 1054 m = m_defrag(*m_head, M_NOWAIT); 1055 if (m == NULL) { 1056 m_freem(*m_head); 1057 *m_head = NULL; 1058 return (NULL); 1059 } 1060 *m_head = m; 1061 } 1062 1063 if (padlen > 0) { 1064 if (M_TRAILINGSPACE(m) < padlen) { 1065 m = m_defrag(*m_head, M_NOWAIT); 1066 if (m == NULL) { 1067 m_freem(*m_head); 1068 *m_head = NULL; 1069 return (NULL); 1070 } 1071 *m_head = m; 1072 } 1073 /* Zero out the bytes in the pad area. */ 1074 bzero(mtod(m, char *) + m->m_pkthdr.len, padlen); 1075 m->m_pkthdr.len += padlen; 1076 m->m_len = m->m_pkthdr.len; 1077 } 1078 } 1079 1080 error = bus_dmamap_load_mbuf_sg(sc->vte_cdata.vte_tx_tag, 1081 txd->tx_dmamap, m, txsegs, &nsegs, 0); 1082 if (error != 0) { 1083 txd->tx_flags &= ~VTE_TXMBUF; 1084 return (NULL); 1085 } 1086 KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs)); 1087 bus_dmamap_sync(sc->vte_cdata.vte_tx_tag, txd->tx_dmamap, 1088 BUS_DMASYNC_PREWRITE); 1089 1090 txd->tx_desc->dtlen = htole16(VTE_TX_LEN(txsegs[0].ds_len)); 1091 txd->tx_desc->dtbp = htole32(txsegs[0].ds_addr); 1092 sc->vte_cdata.vte_tx_cnt++; 1093 /* Update producer index. */ 1094 VTE_DESC_INC(sc->vte_cdata.vte_tx_prod, VTE_TX_RING_CNT); 1095 1096 /* Finally hand over ownership to controller. */ 1097 txd->tx_desc->dtst = htole16(VTE_DTST_TX_OWN); 1098 txd->tx_m = m; 1099 1100 return (txd); 1101 } 1102 1103 static void 1104 vte_start(struct ifnet *ifp) 1105 { 1106 struct vte_softc *sc; 1107 1108 sc = ifp->if_softc; 1109 VTE_LOCK(sc); 1110 vte_start_locked(sc); 1111 VTE_UNLOCK(sc); 1112 } 1113 1114 static void 1115 vte_start_locked(struct vte_softc *sc) 1116 { 1117 struct ifnet *ifp; 1118 struct vte_txdesc *txd; 1119 struct mbuf *m_head; 1120 int enq; 1121 1122 ifp = sc->vte_ifp; 1123 1124 if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) != 1125 IFF_DRV_RUNNING || (sc->vte_flags & VTE_FLAG_LINK) == 0) 1126 return; 1127 1128 for (enq = 0; !IFQ_DRV_IS_EMPTY(&ifp->if_snd); ) { 1129 /* Reserve one free TX descriptor. */ 1130 if (sc->vte_cdata.vte_tx_cnt >= VTE_TX_RING_CNT - 1) { 1131 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 1132 break; 1133 } 1134 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head); 1135 if (m_head == NULL) 1136 break; 1137 /* 1138 * Pack the data into the transmit ring. If we 1139 * don't have room, set the OACTIVE flag and wait 1140 * for the NIC to drain the ring. 1141 */ 1142 if ((txd = vte_encap(sc, &m_head)) == NULL) { 1143 if (m_head != NULL) 1144 IFQ_DRV_PREPEND(&ifp->if_snd, m_head); 1145 break; 1146 } 1147 1148 enq++; 1149 /* 1150 * If there's a BPF listener, bounce a copy of this frame 1151 * to him. 1152 */ 1153 ETHER_BPF_MTAP(ifp, m_head); 1154 /* Free consumed TX frame. */ 1155 if ((txd->tx_flags & VTE_TXMBUF) != 0) 1156 m_freem(m_head); 1157 } 1158 1159 if (enq > 0) { 1160 bus_dmamap_sync(sc->vte_cdata.vte_tx_ring_tag, 1161 sc->vte_cdata.vte_tx_ring_map, BUS_DMASYNC_PREREAD | 1162 BUS_DMASYNC_PREWRITE); 1163 CSR_WRITE_2(sc, VTE_TX_POLL, TX_POLL_START); 1164 sc->vte_watchdog_timer = VTE_TX_TIMEOUT; 1165 } 1166 } 1167 1168 static void 1169 vte_watchdog(struct vte_softc *sc) 1170 { 1171 struct ifnet *ifp; 1172 1173 VTE_LOCK_ASSERT(sc); 1174 1175 if (sc->vte_watchdog_timer == 0 || --sc->vte_watchdog_timer) 1176 return; 1177 1178 ifp = sc->vte_ifp; 1179 if_printf(sc->vte_ifp, "watchdog timeout -- resetting\n"); 1180 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 1181 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 1182 vte_init_locked(sc); 1183 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) 1184 vte_start_locked(sc); 1185 } 1186 1187 static int 1188 vte_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 1189 { 1190 struct vte_softc *sc; 1191 struct ifreq *ifr; 1192 struct mii_data *mii; 1193 int error; 1194 1195 sc = ifp->if_softc; 1196 ifr = (struct ifreq *)data; 1197 error = 0; 1198 switch (cmd) { 1199 case SIOCSIFFLAGS: 1200 VTE_LOCK(sc); 1201 if ((ifp->if_flags & IFF_UP) != 0) { 1202 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0 && 1203 ((ifp->if_flags ^ sc->vte_if_flags) & 1204 (IFF_PROMISC | IFF_ALLMULTI)) != 0) 1205 vte_rxfilter(sc); 1206 else 1207 vte_init_locked(sc); 1208 } else if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) 1209 vte_stop(sc); 1210 sc->vte_if_flags = ifp->if_flags; 1211 VTE_UNLOCK(sc); 1212 break; 1213 case SIOCADDMULTI: 1214 case SIOCDELMULTI: 1215 VTE_LOCK(sc); 1216 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) 1217 vte_rxfilter(sc); 1218 VTE_UNLOCK(sc); 1219 break; 1220 case SIOCSIFMEDIA: 1221 case SIOCGIFMEDIA: 1222 mii = device_get_softc(sc->vte_miibus); 1223 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd); 1224 break; 1225 default: 1226 error = ether_ioctl(ifp, cmd, data); 1227 break; 1228 } 1229 1230 return (error); 1231 } 1232 1233 static void 1234 vte_mac_config(struct vte_softc *sc) 1235 { 1236 struct mii_data *mii; 1237 uint16_t mcr; 1238 1239 VTE_LOCK_ASSERT(sc); 1240 1241 mii = device_get_softc(sc->vte_miibus); 1242 mcr = CSR_READ_2(sc, VTE_MCR0); 1243 mcr &= ~(MCR0_FC_ENB | MCR0_FULL_DUPLEX); 1244 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0) { 1245 mcr |= MCR0_FULL_DUPLEX; 1246 #ifdef notyet 1247 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0) 1248 mcr |= MCR0_FC_ENB; 1249 /* 1250 * The data sheet is not clear whether the controller 1251 * honors received pause frames or not. The is no 1252 * separate control bit for RX pause frame so just 1253 * enable MCR0_FC_ENB bit. 1254 */ 1255 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0) 1256 mcr |= MCR0_FC_ENB; 1257 #endif 1258 } 1259 CSR_WRITE_2(sc, VTE_MCR0, mcr); 1260 } 1261 1262 static void 1263 vte_stats_clear(struct vte_softc *sc) 1264 { 1265 1266 /* Reading counter registers clears its contents. */ 1267 CSR_READ_2(sc, VTE_CNT_RX_DONE); 1268 CSR_READ_2(sc, VTE_CNT_MECNT0); 1269 CSR_READ_2(sc, VTE_CNT_MECNT1); 1270 CSR_READ_2(sc, VTE_CNT_MECNT2); 1271 CSR_READ_2(sc, VTE_CNT_MECNT3); 1272 CSR_READ_2(sc, VTE_CNT_TX_DONE); 1273 CSR_READ_2(sc, VTE_CNT_MECNT4); 1274 CSR_READ_2(sc, VTE_CNT_PAUSE); 1275 } 1276 1277 static void 1278 vte_stats_update(struct vte_softc *sc) 1279 { 1280 struct vte_hw_stats *stat; 1281 uint16_t value; 1282 1283 VTE_LOCK_ASSERT(sc); 1284 1285 stat = &sc->vte_stats; 1286 1287 CSR_READ_2(sc, VTE_MECISR); 1288 /* RX stats. */ 1289 stat->rx_frames += CSR_READ_2(sc, VTE_CNT_RX_DONE); 1290 value = CSR_READ_2(sc, VTE_CNT_MECNT0); 1291 stat->rx_bcast_frames += (value >> 8); 1292 stat->rx_mcast_frames += (value & 0xFF); 1293 value = CSR_READ_2(sc, VTE_CNT_MECNT1); 1294 stat->rx_runts += (value >> 8); 1295 stat->rx_crcerrs += (value & 0xFF); 1296 value = CSR_READ_2(sc, VTE_CNT_MECNT2); 1297 stat->rx_long_frames += (value & 0xFF); 1298 value = CSR_READ_2(sc, VTE_CNT_MECNT3); 1299 stat->rx_fifo_full += (value >> 8); 1300 stat->rx_desc_unavail += (value & 0xFF); 1301 1302 /* TX stats. */ 1303 stat->tx_frames += CSR_READ_2(sc, VTE_CNT_TX_DONE); 1304 value = CSR_READ_2(sc, VTE_CNT_MECNT4); 1305 stat->tx_underruns += (value >> 8); 1306 stat->tx_late_colls += (value & 0xFF); 1307 1308 value = CSR_READ_2(sc, VTE_CNT_PAUSE); 1309 stat->tx_pause_frames += (value >> 8); 1310 stat->rx_pause_frames += (value & 0xFF); 1311 } 1312 1313 static uint64_t 1314 vte_get_counter(struct ifnet *ifp, ift_counter cnt) 1315 { 1316 struct vte_softc *sc; 1317 struct vte_hw_stats *stat; 1318 1319 sc = if_getsoftc(ifp); 1320 stat = &sc->vte_stats; 1321 1322 switch (cnt) { 1323 case IFCOUNTER_OPACKETS: 1324 return (stat->tx_frames); 1325 case IFCOUNTER_COLLISIONS: 1326 return (stat->tx_late_colls); 1327 case IFCOUNTER_OERRORS: 1328 return (stat->tx_late_colls + stat->tx_underruns); 1329 case IFCOUNTER_IPACKETS: 1330 return (stat->rx_frames); 1331 case IFCOUNTER_IERRORS: 1332 return (stat->rx_crcerrs + stat->rx_runts + 1333 stat->rx_long_frames + stat->rx_fifo_full); 1334 default: 1335 return (if_get_counter_default(ifp, cnt)); 1336 } 1337 } 1338 1339 static void 1340 vte_intr(void *arg) 1341 { 1342 struct vte_softc *sc; 1343 struct ifnet *ifp; 1344 uint16_t status; 1345 int n; 1346 1347 sc = (struct vte_softc *)arg; 1348 VTE_LOCK(sc); 1349 1350 ifp = sc->vte_ifp; 1351 /* Reading VTE_MISR acknowledges interrupts. */ 1352 status = CSR_READ_2(sc, VTE_MISR); 1353 if ((status & VTE_INTRS) == 0) { 1354 /* Not ours. */ 1355 VTE_UNLOCK(sc); 1356 return; 1357 } 1358 1359 /* Disable interrupts. */ 1360 CSR_WRITE_2(sc, VTE_MIER, 0); 1361 for (n = 8; (status & VTE_INTRS) != 0;) { 1362 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 1363 break; 1364 if ((status & (MISR_RX_DONE | MISR_RX_DESC_UNAVAIL | 1365 MISR_RX_FIFO_FULL)) != 0) 1366 vte_rxeof(sc); 1367 if ((status & MISR_TX_DONE) != 0) 1368 vte_txeof(sc); 1369 if ((status & MISR_EVENT_CNT_OFLOW) != 0) 1370 vte_stats_update(sc); 1371 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) 1372 vte_start_locked(sc); 1373 if (--n > 0) 1374 status = CSR_READ_2(sc, VTE_MISR); 1375 else 1376 break; 1377 } 1378 1379 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) { 1380 /* Re-enable interrupts. */ 1381 CSR_WRITE_2(sc, VTE_MIER, VTE_INTRS); 1382 } 1383 VTE_UNLOCK(sc); 1384 } 1385 1386 static void 1387 vte_txeof(struct vte_softc *sc) 1388 { 1389 struct ifnet *ifp; 1390 struct vte_txdesc *txd; 1391 uint16_t status; 1392 int cons, prog; 1393 1394 VTE_LOCK_ASSERT(sc); 1395 1396 ifp = sc->vte_ifp; 1397 1398 if (sc->vte_cdata.vte_tx_cnt == 0) 1399 return; 1400 bus_dmamap_sync(sc->vte_cdata.vte_tx_ring_tag, 1401 sc->vte_cdata.vte_tx_ring_map, BUS_DMASYNC_POSTREAD | 1402 BUS_DMASYNC_POSTWRITE); 1403 cons = sc->vte_cdata.vte_tx_cons; 1404 /* 1405 * Go through our TX list and free mbufs for those 1406 * frames which have been transmitted. 1407 */ 1408 for (prog = 0; sc->vte_cdata.vte_tx_cnt > 0; prog++) { 1409 txd = &sc->vte_cdata.vte_txdesc[cons]; 1410 status = le16toh(txd->tx_desc->dtst); 1411 if ((status & VTE_DTST_TX_OWN) != 0) 1412 break; 1413 sc->vte_cdata.vte_tx_cnt--; 1414 /* Reclaim transmitted mbufs. */ 1415 bus_dmamap_sync(sc->vte_cdata.vte_tx_tag, txd->tx_dmamap, 1416 BUS_DMASYNC_POSTWRITE); 1417 bus_dmamap_unload(sc->vte_cdata.vte_tx_tag, txd->tx_dmamap); 1418 if ((txd->tx_flags & VTE_TXMBUF) == 0) 1419 m_freem(txd->tx_m); 1420 txd->tx_flags &= ~VTE_TXMBUF; 1421 txd->tx_m = NULL; 1422 prog++; 1423 VTE_DESC_INC(cons, VTE_TX_RING_CNT); 1424 } 1425 1426 if (prog > 0) { 1427 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1428 sc->vte_cdata.vte_tx_cons = cons; 1429 /* 1430 * Unarm watchdog timer only when there is no pending 1431 * frames in TX queue. 1432 */ 1433 if (sc->vte_cdata.vte_tx_cnt == 0) 1434 sc->vte_watchdog_timer = 0; 1435 } 1436 } 1437 1438 static int 1439 vte_newbuf(struct vte_softc *sc, struct vte_rxdesc *rxd) 1440 { 1441 struct mbuf *m; 1442 bus_dma_segment_t segs[1]; 1443 bus_dmamap_t map; 1444 int nsegs; 1445 1446 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 1447 if (m == NULL) 1448 return (ENOBUFS); 1449 m->m_len = m->m_pkthdr.len = MCLBYTES; 1450 m_adj(m, sizeof(uint32_t)); 1451 1452 if (bus_dmamap_load_mbuf_sg(sc->vte_cdata.vte_rx_tag, 1453 sc->vte_cdata.vte_rx_sparemap, m, segs, &nsegs, 0) != 0) { 1454 m_freem(m); 1455 return (ENOBUFS); 1456 } 1457 KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs)); 1458 1459 if (rxd->rx_m != NULL) { 1460 bus_dmamap_sync(sc->vte_cdata.vte_rx_tag, rxd->rx_dmamap, 1461 BUS_DMASYNC_POSTREAD); 1462 bus_dmamap_unload(sc->vte_cdata.vte_rx_tag, rxd->rx_dmamap); 1463 } 1464 map = rxd->rx_dmamap; 1465 rxd->rx_dmamap = sc->vte_cdata.vte_rx_sparemap; 1466 sc->vte_cdata.vte_rx_sparemap = map; 1467 bus_dmamap_sync(sc->vte_cdata.vte_rx_tag, rxd->rx_dmamap, 1468 BUS_DMASYNC_PREREAD); 1469 rxd->rx_m = m; 1470 rxd->rx_desc->drbp = htole32(segs[0].ds_addr); 1471 rxd->rx_desc->drlen = htole16(VTE_RX_LEN(segs[0].ds_len)); 1472 rxd->rx_desc->drst = htole16(VTE_DRST_RX_OWN); 1473 1474 return (0); 1475 } 1476 1477 /* 1478 * It's not supposed to see this controller on strict-alignment 1479 * architectures but make it work for completeness. 1480 */ 1481 #ifndef __NO_STRICT_ALIGNMENT 1482 static struct mbuf * 1483 vte_fixup_rx(struct ifnet *ifp, struct mbuf *m) 1484 { 1485 uint16_t *src, *dst; 1486 int i; 1487 1488 src = mtod(m, uint16_t *); 1489 dst = src - 1; 1490 1491 for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++) 1492 *dst++ = *src++; 1493 m->m_data -= ETHER_ALIGN; 1494 return (m); 1495 } 1496 #endif 1497 1498 static void 1499 vte_rxeof(struct vte_softc *sc) 1500 { 1501 struct ifnet *ifp; 1502 struct vte_rxdesc *rxd; 1503 struct mbuf *m; 1504 uint16_t status, total_len; 1505 int cons, prog; 1506 1507 bus_dmamap_sync(sc->vte_cdata.vte_rx_ring_tag, 1508 sc->vte_cdata.vte_rx_ring_map, BUS_DMASYNC_POSTREAD | 1509 BUS_DMASYNC_POSTWRITE); 1510 cons = sc->vte_cdata.vte_rx_cons; 1511 ifp = sc->vte_ifp; 1512 for (prog = 0; (ifp->if_drv_flags & IFF_DRV_RUNNING) != 0; prog++, 1513 VTE_DESC_INC(cons, VTE_RX_RING_CNT)) { 1514 rxd = &sc->vte_cdata.vte_rxdesc[cons]; 1515 status = le16toh(rxd->rx_desc->drst); 1516 if ((status & VTE_DRST_RX_OWN) != 0) 1517 break; 1518 total_len = VTE_RX_LEN(le16toh(rxd->rx_desc->drlen)); 1519 m = rxd->rx_m; 1520 if ((status & VTE_DRST_RX_OK) == 0) { 1521 /* Discard errored frame. */ 1522 rxd->rx_desc->drlen = 1523 htole16(MCLBYTES - sizeof(uint32_t)); 1524 rxd->rx_desc->drst = htole16(VTE_DRST_RX_OWN); 1525 continue; 1526 } 1527 if (vte_newbuf(sc, rxd) != 0) { 1528 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); 1529 rxd->rx_desc->drlen = 1530 htole16(MCLBYTES - sizeof(uint32_t)); 1531 rxd->rx_desc->drst = htole16(VTE_DRST_RX_OWN); 1532 continue; 1533 } 1534 1535 /* 1536 * It seems there is no way to strip FCS bytes. 1537 */ 1538 m->m_pkthdr.len = m->m_len = total_len - ETHER_CRC_LEN; 1539 m->m_pkthdr.rcvif = ifp; 1540 #ifndef __NO_STRICT_ALIGNMENT 1541 vte_fixup_rx(ifp, m); 1542 #endif 1543 VTE_UNLOCK(sc); 1544 (*ifp->if_input)(ifp, m); 1545 VTE_LOCK(sc); 1546 } 1547 1548 if (prog > 0) { 1549 /* Update the consumer index. */ 1550 sc->vte_cdata.vte_rx_cons = cons; 1551 /* 1552 * Sync updated RX descriptors such that controller see 1553 * modified RX buffer addresses. 1554 */ 1555 bus_dmamap_sync(sc->vte_cdata.vte_rx_ring_tag, 1556 sc->vte_cdata.vte_rx_ring_map, 1557 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 1558 #ifdef notyet 1559 /* 1560 * Update residue counter. Controller does not 1561 * keep track of number of available RX descriptors 1562 * such that driver should have to update VTE_MRDCR 1563 * to make controller know how many free RX 1564 * descriptors were added to controller. This is 1565 * a similar mechanism used in VIA velocity 1566 * controllers and it indicates controller just 1567 * polls OWN bit of current RX descriptor pointer. 1568 * A couple of severe issues were seen on sample 1569 * board where the controller continuously emits TX 1570 * pause frames once RX pause threshold crossed. 1571 * Once triggered it never recovered form that 1572 * state, I couldn't find a way to make it back to 1573 * work at least. This issue effectively 1574 * disconnected the system from network. Also, the 1575 * controller used 00:00:00:00:00:00 as source 1576 * station address of TX pause frame. Probably this 1577 * is one of reason why vendor recommends not to 1578 * enable flow control on R6040 controller. 1579 */ 1580 CSR_WRITE_2(sc, VTE_MRDCR, prog | 1581 (((VTE_RX_RING_CNT * 2) / 10) << 1582 VTE_MRDCR_RX_PAUSE_THRESH_SHIFT)); 1583 #endif 1584 } 1585 } 1586 1587 static void 1588 vte_tick(void *arg) 1589 { 1590 struct vte_softc *sc; 1591 struct mii_data *mii; 1592 1593 sc = (struct vte_softc *)arg; 1594 1595 VTE_LOCK_ASSERT(sc); 1596 1597 mii = device_get_softc(sc->vte_miibus); 1598 mii_tick(mii); 1599 vte_stats_update(sc); 1600 vte_txeof(sc); 1601 vte_watchdog(sc); 1602 callout_reset(&sc->vte_tick_ch, hz, vte_tick, sc); 1603 } 1604 1605 static void 1606 vte_reset(struct vte_softc *sc) 1607 { 1608 uint16_t mcr; 1609 int i; 1610 1611 mcr = CSR_READ_2(sc, VTE_MCR1); 1612 CSR_WRITE_2(sc, VTE_MCR1, mcr | MCR1_MAC_RESET); 1613 for (i = VTE_RESET_TIMEOUT; i > 0; i--) { 1614 DELAY(10); 1615 if ((CSR_READ_2(sc, VTE_MCR1) & MCR1_MAC_RESET) == 0) 1616 break; 1617 } 1618 if (i == 0) 1619 device_printf(sc->vte_dev, "reset timeout(0x%04x)!\n", mcr); 1620 /* 1621 * Follow the guide of vendor recommended way to reset MAC. 1622 * Vendor confirms relying on MCR1_MAC_RESET of VTE_MCR1 is 1623 * not reliable so manually reset internal state machine. 1624 */ 1625 CSR_WRITE_2(sc, VTE_MACSM, 0x0002); 1626 CSR_WRITE_2(sc, VTE_MACSM, 0); 1627 DELAY(5000); 1628 } 1629 1630 static void 1631 vte_init(void *xsc) 1632 { 1633 struct vte_softc *sc; 1634 1635 sc = (struct vte_softc *)xsc; 1636 VTE_LOCK(sc); 1637 vte_init_locked(sc); 1638 VTE_UNLOCK(sc); 1639 } 1640 1641 static void 1642 vte_init_locked(struct vte_softc *sc) 1643 { 1644 struct ifnet *ifp; 1645 bus_addr_t paddr; 1646 uint8_t *eaddr; 1647 1648 VTE_LOCK_ASSERT(sc); 1649 1650 ifp = sc->vte_ifp; 1651 1652 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) 1653 return; 1654 /* 1655 * Cancel any pending I/O. 1656 */ 1657 vte_stop(sc); 1658 /* 1659 * Reset the chip to a known state. 1660 */ 1661 vte_reset(sc); 1662 1663 /* Initialize RX descriptors. */ 1664 if (vte_init_rx_ring(sc) != 0) { 1665 device_printf(sc->vte_dev, "no memory for RX buffers.\n"); 1666 vte_stop(sc); 1667 return; 1668 } 1669 if (vte_init_tx_ring(sc) != 0) { 1670 device_printf(sc->vte_dev, "no memory for TX buffers.\n"); 1671 vte_stop(sc); 1672 return; 1673 } 1674 1675 /* 1676 * Reprogram the station address. Controller supports up 1677 * to 4 different station addresses so driver programs the 1678 * first station address as its own ethernet address and 1679 * configure the remaining three addresses as perfect 1680 * multicast addresses. 1681 */ 1682 eaddr = IF_LLADDR(sc->vte_ifp); 1683 CSR_WRITE_2(sc, VTE_MID0L, eaddr[1] << 8 | eaddr[0]); 1684 CSR_WRITE_2(sc, VTE_MID0M, eaddr[3] << 8 | eaddr[2]); 1685 CSR_WRITE_2(sc, VTE_MID0H, eaddr[5] << 8 | eaddr[4]); 1686 1687 /* Set TX descriptor base addresses. */ 1688 paddr = sc->vte_cdata.vte_tx_ring_paddr; 1689 CSR_WRITE_2(sc, VTE_MTDSA1, paddr >> 16); 1690 CSR_WRITE_2(sc, VTE_MTDSA0, paddr & 0xFFFF); 1691 /* Set RX descriptor base addresses. */ 1692 paddr = sc->vte_cdata.vte_rx_ring_paddr; 1693 CSR_WRITE_2(sc, VTE_MRDSA1, paddr >> 16); 1694 CSR_WRITE_2(sc, VTE_MRDSA0, paddr & 0xFFFF); 1695 /* 1696 * Initialize RX descriptor residue counter and set RX 1697 * pause threshold to 20% of available RX descriptors. 1698 * See comments on vte_rxeof() for details on flow control 1699 * issues. 1700 */ 1701 CSR_WRITE_2(sc, VTE_MRDCR, (VTE_RX_RING_CNT & VTE_MRDCR_RESIDUE_MASK) | 1702 (((VTE_RX_RING_CNT * 2) / 10) << VTE_MRDCR_RX_PAUSE_THRESH_SHIFT)); 1703 1704 /* 1705 * Always use maximum frame size that controller can 1706 * support. Otherwise received frames that has longer 1707 * frame length than vte(4) MTU would be silently dropped 1708 * in controller. This would break path-MTU discovery as 1709 * sender wouldn't get any responses from receiver. The 1710 * RX buffer size should be multiple of 4. 1711 * Note, jumbo frames are silently ignored by controller 1712 * and even MAC counters do not detect them. 1713 */ 1714 CSR_WRITE_2(sc, VTE_MRBSR, VTE_RX_BUF_SIZE_MAX); 1715 1716 /* Configure FIFO. */ 1717 CSR_WRITE_2(sc, VTE_MBCR, MBCR_FIFO_XFER_LENGTH_16 | 1718 MBCR_TX_FIFO_THRESH_64 | MBCR_RX_FIFO_THRESH_16 | 1719 MBCR_SDRAM_BUS_REQ_TIMER_DEFAULT); 1720 1721 /* 1722 * Configure TX/RX MACs. Actual resolved duplex and flow 1723 * control configuration is done after detecting a valid 1724 * link. Note, we don't generate early interrupt here 1725 * as well since FreeBSD does not have interrupt latency 1726 * problems like Windows. 1727 */ 1728 CSR_WRITE_2(sc, VTE_MCR0, MCR0_ACCPT_LONG_PKT); 1729 /* 1730 * We manually keep track of PHY status changes to 1731 * configure resolved duplex and flow control since only 1732 * duplex configuration can be automatically reflected to 1733 * MCR0. 1734 */ 1735 CSR_WRITE_2(sc, VTE_MCR1, MCR1_PKT_LENGTH_1537 | 1736 MCR1_EXCESS_COL_RETRY_16); 1737 1738 /* Initialize RX filter. */ 1739 vte_rxfilter(sc); 1740 1741 /* Disable TX/RX interrupt moderation control. */ 1742 CSR_WRITE_2(sc, VTE_MRICR, 0); 1743 CSR_WRITE_2(sc, VTE_MTICR, 0); 1744 1745 /* Enable MAC event counter interrupts. */ 1746 CSR_WRITE_2(sc, VTE_MECIER, VTE_MECIER_INTRS); 1747 /* Clear MAC statistics. */ 1748 vte_stats_clear(sc); 1749 1750 /* Acknowledge all pending interrupts and clear it. */ 1751 CSR_WRITE_2(sc, VTE_MIER, VTE_INTRS); 1752 CSR_WRITE_2(sc, VTE_MISR, 0); 1753 1754 sc->vte_flags &= ~VTE_FLAG_LINK; 1755 /* Switch to the current media. */ 1756 vte_mediachange_locked(ifp); 1757 1758 callout_reset(&sc->vte_tick_ch, hz, vte_tick, sc); 1759 1760 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1761 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1762 } 1763 1764 static void 1765 vte_stop(struct vte_softc *sc) 1766 { 1767 struct ifnet *ifp; 1768 struct vte_txdesc *txd; 1769 struct vte_rxdesc *rxd; 1770 int i; 1771 1772 VTE_LOCK_ASSERT(sc); 1773 /* 1774 * Mark the interface down and cancel the watchdog timer. 1775 */ 1776 ifp = sc->vte_ifp; 1777 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 1778 sc->vte_flags &= ~VTE_FLAG_LINK; 1779 callout_stop(&sc->vte_tick_ch); 1780 sc->vte_watchdog_timer = 0; 1781 vte_stats_update(sc); 1782 /* Disable interrupts. */ 1783 CSR_WRITE_2(sc, VTE_MIER, 0); 1784 CSR_WRITE_2(sc, VTE_MECIER, 0); 1785 /* Stop RX/TX MACs. */ 1786 vte_stop_mac(sc); 1787 /* Clear interrupts. */ 1788 CSR_READ_2(sc, VTE_MISR); 1789 /* 1790 * Free TX/RX mbufs still in the queues. 1791 */ 1792 for (i = 0; i < VTE_RX_RING_CNT; i++) { 1793 rxd = &sc->vte_cdata.vte_rxdesc[i]; 1794 if (rxd->rx_m != NULL) { 1795 bus_dmamap_sync(sc->vte_cdata.vte_rx_tag, 1796 rxd->rx_dmamap, BUS_DMASYNC_POSTREAD); 1797 bus_dmamap_unload(sc->vte_cdata.vte_rx_tag, 1798 rxd->rx_dmamap); 1799 m_freem(rxd->rx_m); 1800 rxd->rx_m = NULL; 1801 } 1802 } 1803 for (i = 0; i < VTE_TX_RING_CNT; i++) { 1804 txd = &sc->vte_cdata.vte_txdesc[i]; 1805 if (txd->tx_m != NULL) { 1806 bus_dmamap_sync(sc->vte_cdata.vte_tx_tag, 1807 txd->tx_dmamap, BUS_DMASYNC_POSTWRITE); 1808 bus_dmamap_unload(sc->vte_cdata.vte_tx_tag, 1809 txd->tx_dmamap); 1810 if ((txd->tx_flags & VTE_TXMBUF) == 0) 1811 m_freem(txd->tx_m); 1812 txd->tx_m = NULL; 1813 txd->tx_flags &= ~VTE_TXMBUF; 1814 } 1815 } 1816 /* Free TX mbuf pools used for deep copy. */ 1817 for (i = 0; i < VTE_TX_RING_CNT; i++) { 1818 if (sc->vte_cdata.vte_txmbufs[i] != NULL) { 1819 m_freem(sc->vte_cdata.vte_txmbufs[i]); 1820 sc->vte_cdata.vte_txmbufs[i] = NULL; 1821 } 1822 } 1823 } 1824 1825 static void 1826 vte_start_mac(struct vte_softc *sc) 1827 { 1828 uint16_t mcr; 1829 int i; 1830 1831 VTE_LOCK_ASSERT(sc); 1832 1833 /* Enable RX/TX MACs. */ 1834 mcr = CSR_READ_2(sc, VTE_MCR0); 1835 if ((mcr & (MCR0_RX_ENB | MCR0_TX_ENB)) != 1836 (MCR0_RX_ENB | MCR0_TX_ENB)) { 1837 mcr |= MCR0_RX_ENB | MCR0_TX_ENB; 1838 CSR_WRITE_2(sc, VTE_MCR0, mcr); 1839 for (i = VTE_TIMEOUT; i > 0; i--) { 1840 mcr = CSR_READ_2(sc, VTE_MCR0); 1841 if ((mcr & (MCR0_RX_ENB | MCR0_TX_ENB)) == 1842 (MCR0_RX_ENB | MCR0_TX_ENB)) 1843 break; 1844 DELAY(10); 1845 } 1846 if (i == 0) 1847 device_printf(sc->vte_dev, 1848 "could not enable RX/TX MAC(0x%04x)!\n", mcr); 1849 } 1850 } 1851 1852 static void 1853 vte_stop_mac(struct vte_softc *sc) 1854 { 1855 uint16_t mcr; 1856 int i; 1857 1858 VTE_LOCK_ASSERT(sc); 1859 1860 /* Disable RX/TX MACs. */ 1861 mcr = CSR_READ_2(sc, VTE_MCR0); 1862 if ((mcr & (MCR0_RX_ENB | MCR0_TX_ENB)) != 0) { 1863 mcr &= ~(MCR0_RX_ENB | MCR0_TX_ENB); 1864 CSR_WRITE_2(sc, VTE_MCR0, mcr); 1865 for (i = VTE_TIMEOUT; i > 0; i--) { 1866 mcr = CSR_READ_2(sc, VTE_MCR0); 1867 if ((mcr & (MCR0_RX_ENB | MCR0_TX_ENB)) == 0) 1868 break; 1869 DELAY(10); 1870 } 1871 if (i == 0) 1872 device_printf(sc->vte_dev, 1873 "could not disable RX/TX MAC(0x%04x)!\n", mcr); 1874 } 1875 } 1876 1877 static int 1878 vte_init_tx_ring(struct vte_softc *sc) 1879 { 1880 struct vte_tx_desc *desc; 1881 struct vte_txdesc *txd; 1882 bus_addr_t addr; 1883 int i; 1884 1885 VTE_LOCK_ASSERT(sc); 1886 1887 sc->vte_cdata.vte_tx_prod = 0; 1888 sc->vte_cdata.vte_tx_cons = 0; 1889 sc->vte_cdata.vte_tx_cnt = 0; 1890 1891 /* Pre-allocate TX mbufs for deep copy. */ 1892 if (tx_deep_copy != 0) { 1893 for (i = 0; i < VTE_TX_RING_CNT; i++) { 1894 sc->vte_cdata.vte_txmbufs[i] = m_getcl(M_NOWAIT, 1895 MT_DATA, M_PKTHDR); 1896 if (sc->vte_cdata.vte_txmbufs[i] == NULL) 1897 return (ENOBUFS); 1898 sc->vte_cdata.vte_txmbufs[i]->m_pkthdr.len = MCLBYTES; 1899 sc->vte_cdata.vte_txmbufs[i]->m_len = MCLBYTES; 1900 } 1901 } 1902 desc = sc->vte_cdata.vte_tx_ring; 1903 bzero(desc, VTE_TX_RING_SZ); 1904 for (i = 0; i < VTE_TX_RING_CNT; i++) { 1905 txd = &sc->vte_cdata.vte_txdesc[i]; 1906 txd->tx_m = NULL; 1907 if (i != VTE_TX_RING_CNT - 1) 1908 addr = sc->vte_cdata.vte_tx_ring_paddr + 1909 sizeof(struct vte_tx_desc) * (i + 1); 1910 else 1911 addr = sc->vte_cdata.vte_tx_ring_paddr + 1912 sizeof(struct vte_tx_desc) * 0; 1913 desc = &sc->vte_cdata.vte_tx_ring[i]; 1914 desc->dtnp = htole32(addr); 1915 txd->tx_desc = desc; 1916 } 1917 1918 bus_dmamap_sync(sc->vte_cdata.vte_tx_ring_tag, 1919 sc->vte_cdata.vte_tx_ring_map, BUS_DMASYNC_PREREAD | 1920 BUS_DMASYNC_PREWRITE); 1921 return (0); 1922 } 1923 1924 static int 1925 vte_init_rx_ring(struct vte_softc *sc) 1926 { 1927 struct vte_rx_desc *desc; 1928 struct vte_rxdesc *rxd; 1929 bus_addr_t addr; 1930 int i; 1931 1932 VTE_LOCK_ASSERT(sc); 1933 1934 sc->vte_cdata.vte_rx_cons = 0; 1935 desc = sc->vte_cdata.vte_rx_ring; 1936 bzero(desc, VTE_RX_RING_SZ); 1937 for (i = 0; i < VTE_RX_RING_CNT; i++) { 1938 rxd = &sc->vte_cdata.vte_rxdesc[i]; 1939 rxd->rx_m = NULL; 1940 if (i != VTE_RX_RING_CNT - 1) 1941 addr = sc->vte_cdata.vte_rx_ring_paddr + 1942 sizeof(struct vte_rx_desc) * (i + 1); 1943 else 1944 addr = sc->vte_cdata.vte_rx_ring_paddr + 1945 sizeof(struct vte_rx_desc) * 0; 1946 desc = &sc->vte_cdata.vte_rx_ring[i]; 1947 desc->drnp = htole32(addr); 1948 rxd->rx_desc = desc; 1949 if (vte_newbuf(sc, rxd) != 0) 1950 return (ENOBUFS); 1951 } 1952 1953 bus_dmamap_sync(sc->vte_cdata.vte_rx_ring_tag, 1954 sc->vte_cdata.vte_rx_ring_map, BUS_DMASYNC_PREREAD | 1955 BUS_DMASYNC_PREWRITE); 1956 1957 return (0); 1958 } 1959 1960 struct vte_maddr_ctx { 1961 uint16_t rxfilt_perf[VTE_RXFILT_PERFECT_CNT][3]; 1962 uint16_t mchash[4]; 1963 u_int nperf; 1964 }; 1965 1966 static u_int 1967 vte_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt) 1968 { 1969 struct vte_maddr_ctx *ctx = arg; 1970 uint8_t *eaddr; 1971 uint32_t crc; 1972 1973 /* 1974 * Program the first 3 multicast groups into the perfect filter. 1975 * For all others, use the hash table. 1976 */ 1977 if (ctx->nperf < VTE_RXFILT_PERFECT_CNT) { 1978 eaddr = LLADDR(sdl); 1979 ctx->rxfilt_perf[ctx->nperf][0] = eaddr[1] << 8 | eaddr[0]; 1980 ctx->rxfilt_perf[ctx->nperf][1] = eaddr[3] << 8 | eaddr[2]; 1981 ctx->rxfilt_perf[ctx->nperf][2] = eaddr[5] << 8 | eaddr[4]; 1982 ctx->nperf++; 1983 1984 return (1); 1985 } 1986 crc = ether_crc32_be(LLADDR(sdl), ETHER_ADDR_LEN); 1987 ctx->mchash[crc >> 30] |= 1 << ((crc >> 26) & 0x0F); 1988 1989 return (1); 1990 } 1991 1992 static void 1993 vte_rxfilter(struct vte_softc *sc) 1994 { 1995 struct ifnet *ifp; 1996 struct vte_maddr_ctx ctx; 1997 uint16_t mcr; 1998 int i; 1999 2000 VTE_LOCK_ASSERT(sc); 2001 2002 ifp = sc->vte_ifp; 2003 2004 bzero(ctx.mchash, sizeof(ctx.mchash)); 2005 for (i = 0; i < VTE_RXFILT_PERFECT_CNT; i++) { 2006 ctx.rxfilt_perf[i][0] = 0xFFFF; 2007 ctx.rxfilt_perf[i][1] = 0xFFFF; 2008 ctx.rxfilt_perf[i][2] = 0xFFFF; 2009 } 2010 ctx.nperf = 0; 2011 2012 mcr = CSR_READ_2(sc, VTE_MCR0); 2013 mcr &= ~(MCR0_PROMISC | MCR0_MULTICAST); 2014 mcr |= MCR0_BROADCAST_DIS; 2015 if ((ifp->if_flags & IFF_BROADCAST) != 0) 2016 mcr &= ~MCR0_BROADCAST_DIS; 2017 if ((ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI)) != 0) { 2018 if ((ifp->if_flags & IFF_PROMISC) != 0) 2019 mcr |= MCR0_PROMISC; 2020 if ((ifp->if_flags & IFF_ALLMULTI) != 0) 2021 mcr |= MCR0_MULTICAST; 2022 ctx.mchash[0] = 0xFFFF; 2023 ctx.mchash[1] = 0xFFFF; 2024 ctx.mchash[2] = 0xFFFF; 2025 ctx.mchash[3] = 0xFFFF; 2026 goto chipit; 2027 } 2028 2029 if_foreach_llmaddr(ifp, vte_hash_maddr, &ctx); 2030 if (ctx.mchash[0] != 0 || ctx.mchash[1] != 0 || 2031 ctx.mchash[2] != 0 || ctx.mchash[3] != 0) 2032 mcr |= MCR0_MULTICAST; 2033 2034 chipit: 2035 /* Program multicast hash table. */ 2036 CSR_WRITE_2(sc, VTE_MAR0, ctx.mchash[0]); 2037 CSR_WRITE_2(sc, VTE_MAR1, ctx.mchash[1]); 2038 CSR_WRITE_2(sc, VTE_MAR2, ctx.mchash[2]); 2039 CSR_WRITE_2(sc, VTE_MAR3, ctx.mchash[3]); 2040 /* Program perfect filter table. */ 2041 for (i = 0; i < VTE_RXFILT_PERFECT_CNT; i++) { 2042 CSR_WRITE_2(sc, VTE_RXFILTER_PEEFECT_BASE + 8 * i + 0, 2043 ctx.rxfilt_perf[i][0]); 2044 CSR_WRITE_2(sc, VTE_RXFILTER_PEEFECT_BASE + 8 * i + 2, 2045 ctx.rxfilt_perf[i][1]); 2046 CSR_WRITE_2(sc, VTE_RXFILTER_PEEFECT_BASE + 8 * i + 4, 2047 ctx.rxfilt_perf[i][2]); 2048 } 2049 CSR_WRITE_2(sc, VTE_MCR0, mcr); 2050 CSR_READ_2(sc, VTE_MCR0); 2051 } 2052 2053 static int 2054 sysctl_int_range(SYSCTL_HANDLER_ARGS, int low, int high) 2055 { 2056 int error, value; 2057 2058 if (arg1 == NULL) 2059 return (EINVAL); 2060 value = *(int *)arg1; 2061 error = sysctl_handle_int(oidp, &value, 0, req); 2062 if (error || req->newptr == NULL) 2063 return (error); 2064 if (value < low || value > high) 2065 return (EINVAL); 2066 *(int *)arg1 = value; 2067 2068 return (0); 2069 } 2070 2071 static int 2072 sysctl_hw_vte_int_mod(SYSCTL_HANDLER_ARGS) 2073 { 2074 2075 return (sysctl_int_range(oidp, arg1, arg2, req, 2076 VTE_IM_BUNDLE_MIN, VTE_IM_BUNDLE_MAX)); 2077 } 2078