sys/dev/mgb/if_mgb.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2019 The FreeBSD Foundation, Inc.
   5  *
   6  * This driver was written by Gerald ND Aryeetey <gndaryee@uwaterloo.ca>
   7  * under sponsorship from the FreeBSD Foundation.
   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 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 /*
  34  * Microchip LAN7430/LAN7431 PCIe to Gigabit Ethernet Controller driver.
  35  *
  36  * Product information:
  37  * LAN7430 https://www.microchip.com/wwwproducts/en/LAN7430
  38  *   - Integrated IEEE 802.3 compliant PHY
  39  * LAN7431 https://www.microchip.com/wwwproducts/en/LAN7431
  40  *   - RGMII Interface
  41  *
  42  * This driver uses the iflib interface and the default 'ukphy' PHY driver.
  43  *
  44  * UNIMPLEMENTED FEATURES
  45  * ----------------------
  46  * A number of features supported by LAN743X device are not yet implemented in
  47  * this driver:
  48  *
  49  * - Multiple (up to 4) RX queues support
  50  *   - Just needs to remove asserts and malloc multiple `rx_ring_data`
  51  *     structs based on ncpus.
  52  * - RX/TX Checksum Offloading support
  53  * - VLAN support
  54  * - Receive Packet Filtering (Multicast Perfect/Hash Address) support
  55  * - Wake on LAN (WoL) support
  56  * - TX LSO support
  57  * - Receive Side Scaling (RSS) support
  58  * - Debugging Capabilities:
  59  *   - Could include MAC statistics and
  60  *     error status registers in sysctl.
  61  */
  62
  63 #include <sys/param.h>
  64 #include <sys/bus.h>
  65 #include <sys/endian.h>
  66 #include <sys/kdb.h>
  67 #include <sys/kernel.h>
  68 #include <sys/module.h>
  69 #include <sys/rman.h>
  70 #include <sys/socket.h>
  71 #include <sys/sockio.h>
  72 #include <machine/bus.h>
  73 #include <machine/resource.h>
  74
  75 #include <net/ethernet.h>
  76 #include <net/if.h>
  77 #include <net/if_var.h>
  78 #include <net/if_types.h>
  79 #include <net/if_media.h>
  80 #include <net/iflib.h>
  81
  82 #include <dev/mgb/if_mgb.h>
  83 #include <dev/mii/mii.h>
  84 #include <dev/mii/miivar.h>
  85 #include <dev/pci/pcireg.h>
  86 #include <dev/pci/pcivar.h>
  87
  88 #include "ifdi_if.h"
  89 #include "miibus_if.h"
  90
  91 static pci_vendor_info_t mgb_vendor_info_array[] = {
  92         PVID(MGB_MICROCHIP_VENDOR_ID, MGB_LAN7430_DEVICE_ID,
  93             "Microchip LAN7430 PCIe Gigabit Ethernet Controller"),
  94         PVID(MGB_MICROCHIP_VENDOR_ID, MGB_LAN7431_DEVICE_ID,
  95             "Microchip LAN7431 PCIe Gigabit Ethernet Controller"),
  96         PVID_END
  97 };
  98
  99 /* Device methods */
 100 static device_register_t                mgb_register;
 101
 102 /* IFLIB methods */
 103 static ifdi_attach_pre_t                mgb_attach_pre;
 104 static ifdi_attach_post_t               mgb_attach_post;
 105 static ifdi_detach_t                    mgb_detach;
 106
 107 static ifdi_tx_queues_alloc_t           mgb_tx_queues_alloc;
 108 static ifdi_rx_queues_alloc_t           mgb_rx_queues_alloc;
 109 static ifdi_queues_free_t               mgb_queues_free;
 110
 111 static ifdi_init_t                      mgb_init;
 112 static ifdi_stop_t                      mgb_stop;
 113
 114 static ifdi_msix_intr_assign_t          mgb_msix_intr_assign;
 115 static ifdi_tx_queue_intr_enable_t      mgb_tx_queue_intr_enable;
 116 static ifdi_rx_queue_intr_enable_t      mgb_rx_queue_intr_enable;
 117 static ifdi_intr_enable_t               mgb_intr_enable_all;
 118 static ifdi_intr_disable_t              mgb_intr_disable_all;
 119
 120 /* IFLIB_TXRX methods */
 121 static int                              mgb_isc_txd_encap(void *,
 122                                             if_pkt_info_t);
 123 static void                             mgb_isc_txd_flush(void *,
 124                                             uint16_t, qidx_t);
 125 static int                              mgb_isc_txd_credits_update(void *,
 126                                             uint16_t, bool);
 127 static int                              mgb_isc_rxd_available(void *,
 128                                             uint16_t, qidx_t, qidx_t);
 129 static int                              mgb_isc_rxd_pkt_get(void *,
 130                                             if_rxd_info_t);
 131 static void                             mgb_isc_rxd_refill(void *,
 132                                             if_rxd_update_t);
 133 static void                             mgb_isc_rxd_flush(void *,
 134                                             uint16_t, uint8_t, qidx_t);
 135
 136 /* Interrupts */
 137 static driver_filter_t                  mgb_legacy_intr;
 138 static driver_filter_t                  mgb_admin_intr;
 139 static driver_filter_t                  mgb_rxq_intr;
 140 static bool                             mgb_intr_test(struct mgb_softc *);
 141
 142 /* MII methods */
 143 static miibus_readreg_t                 mgb_miibus_readreg;
 144 static miibus_writereg_t                mgb_miibus_writereg;
 145 static miibus_linkchg_t                 mgb_miibus_linkchg;
 146 static miibus_statchg_t                 mgb_miibus_statchg;
 147
 148 static int                              mgb_media_change(if_t);
 149 static void                             mgb_media_status(if_t,
 150                                             struct ifmediareq *);
 151
 152 /* Helper/Test functions */
 153 static int                              mgb_test_bar(struct mgb_softc *);
 154 static int                              mgb_alloc_regs(struct mgb_softc *);
 155 static int                              mgb_release_regs(struct mgb_softc *);
 156
 157 static void                             mgb_get_ethaddr(struct mgb_softc *,
 158                                             struct ether_addr *);
 159
 160 static int                              mgb_wait_for_bits(struct mgb_softc *,
 161                                             int, int, int);
 162
 163 /* H/W init, reset and teardown helpers */
 164 static int                              mgb_hw_init(struct mgb_softc *);
 165 static int                              mgb_hw_teardown(struct mgb_softc *);
 166 static int                              mgb_hw_reset(struct mgb_softc *);
 167 static int                              mgb_mac_init(struct mgb_softc *);
 168 static int                              mgb_dmac_reset(struct mgb_softc *);
 169 static int                              mgb_phy_reset(struct mgb_softc *);
 170
 171 static int                              mgb_dma_init(struct mgb_softc *);
 172 static int                              mgb_dma_tx_ring_init(struct mgb_softc *,
 173                                             int);
 174 static int                              mgb_dma_rx_ring_init(struct mgb_softc *,
 175                                             int);
 176
 177 static int                              mgb_dmac_control(struct mgb_softc *,
 178                                             int, int, enum mgb_dmac_cmd);
 179 static int                              mgb_fct_control(struct mgb_softc *,
 180                                             int, int, enum mgb_fct_cmd);
 181
 182 /*********************************************************************
 183  *  FreeBSD Device Interface Entry Points
 184  *********************************************************************/
 185
 186 static device_method_t mgb_methods[] = {
 187         /* Device interface */
 188         DEVMETHOD(device_register,      mgb_register),
 189         DEVMETHOD(device_probe,         iflib_device_probe),
 190         DEVMETHOD(device_attach,        iflib_device_attach),
 191         DEVMETHOD(device_detach,        iflib_device_detach),
 192         DEVMETHOD(device_shutdown,      iflib_device_shutdown),
 193         DEVMETHOD(device_suspend,       iflib_device_suspend),
 194         DEVMETHOD(device_resume,        iflib_device_resume),
 195
 196         /* MII Interface */
 197         DEVMETHOD(miibus_readreg,       mgb_miibus_readreg),
 198         DEVMETHOD(miibus_writereg,      mgb_miibus_writereg),
 199         DEVMETHOD(miibus_linkchg,       mgb_miibus_linkchg),
 200         DEVMETHOD(miibus_statchg,       mgb_miibus_statchg),
 201
 202         DEVMETHOD_END
 203 };
 204
 205 static driver_t mgb_driver = {
 206         "mgb", mgb_methods, sizeof(struct mgb_softc)
 207 };
 208
 209 devclass_t mgb_devclass;
 210 DRIVER_MODULE(mgb, pci, mgb_driver, mgb_devclass, NULL, NULL);
 211 IFLIB_PNP_INFO(pci, mgb, mgb_vendor_info_array);
 212 MODULE_VERSION(mgb, 1);
 213
 214 #if 0 /* MIIBUS_DEBUG */
 215 /* If MIIBUS debug stuff is in attach then order matters. Use below instead. */
 216 DRIVER_MODULE_ORDERED(miibus, mgb, miibus_driver, miibus_devclass, NULL, NULL,
 217     SI_ORDER_ANY);
 218 #endif /* MIIBUS_DEBUG */
 219 DRIVER_MODULE(miibus, mgb, miibus_driver, miibus_devclass, NULL, NULL);
 220
 221 MODULE_DEPEND(mgb, pci, 1, 1, 1);
 222 MODULE_DEPEND(mgb, ether, 1, 1, 1);
 223 MODULE_DEPEND(mgb, miibus, 1, 1, 1);
 224 MODULE_DEPEND(mgb, iflib, 1, 1, 1);
 225
 226 static device_method_t mgb_iflib_methods[] = {
 227         DEVMETHOD(ifdi_attach_pre, mgb_attach_pre),
 228         DEVMETHOD(ifdi_attach_post, mgb_attach_post),
 229         DEVMETHOD(ifdi_detach, mgb_detach),
 230
 231         DEVMETHOD(ifdi_init, mgb_init),
 232         DEVMETHOD(ifdi_stop, mgb_stop),
 233
 234         DEVMETHOD(ifdi_tx_queues_alloc, mgb_tx_queues_alloc),
 235         DEVMETHOD(ifdi_rx_queues_alloc, mgb_rx_queues_alloc),
 236         DEVMETHOD(ifdi_queues_free, mgb_queues_free),
 237
 238         DEVMETHOD(ifdi_msix_intr_assign, mgb_msix_intr_assign),
 239         DEVMETHOD(ifdi_tx_queue_intr_enable, mgb_tx_queue_intr_enable),
 240         DEVMETHOD(ifdi_rx_queue_intr_enable, mgb_rx_queue_intr_enable),
 241         DEVMETHOD(ifdi_intr_enable, mgb_intr_enable_all),
 242         DEVMETHOD(ifdi_intr_disable, mgb_intr_disable_all),
 243
 244
 245 #if 0 /* Not yet implemented IFLIB methods */
 246         /*
 247          * Set multicast addresses, mtu and promiscuous mode
 248          */
 249         DEVMETHOD(ifdi_multi_set, mgb_multi_set),
 250         DEVMETHOD(ifdi_mtu_set, mgb_mtu_set),
 251         DEVMETHOD(ifdi_promisc_set, mgb_promisc_set),
 252
 253         /*
 254          * Needed for VLAN support
 255          */
 256         DEVMETHOD(ifdi_vlan_register, mgb_vlan_register),
 257         DEVMETHOD(ifdi_vlan_unregister, mgb_vlan_unregister),
 258
 259         /*
 260          * Needed for WOL support
 261          * at the very least.
 262          */
 263         DEVMETHOD(ifdi_shutdown, mgb_shutdown),
 264         DEVMETHOD(ifdi_suspend, mgb_suspend),
 265         DEVMETHOD(ifdi_resume, mgb_resume),
 266 #endif /* UNUSED_IFLIB_METHODS */
 267         DEVMETHOD_END
 268 };
 269
 270 static driver_t mgb_iflib_driver = {
 271         "mgb", mgb_iflib_methods, sizeof(struct mgb_softc)
 272 };
 273
 274 struct if_txrx mgb_txrx  = {
 275         .ift_txd_encap = mgb_isc_txd_encap,
 276         .ift_txd_flush = mgb_isc_txd_flush,
 277         .ift_txd_credits_update = mgb_isc_txd_credits_update,
 278         .ift_rxd_available = mgb_isc_rxd_available,
 279         .ift_rxd_pkt_get = mgb_isc_rxd_pkt_get,
 280         .ift_rxd_refill = mgb_isc_rxd_refill,
 281         .ift_rxd_flush = mgb_isc_rxd_flush,
 282
 283         .ift_legacy_intr = mgb_legacy_intr
 284 };
 285
 286 struct if_shared_ctx mgb_sctx_init = {
 287         .isc_magic = IFLIB_MAGIC,
 288
 289         .isc_q_align = PAGE_SIZE,
 290         .isc_admin_intrcnt = 1,
 291         .isc_flags = IFLIB_DRIVER_MEDIA /* | IFLIB_HAS_RXCQ | IFLIB_HAS_TXCQ*/,
 292
 293         .isc_vendor_info = mgb_vendor_info_array,
 294         .isc_driver_version = "1",
 295         .isc_driver = &mgb_iflib_driver,
 296         /* 2 queues per set for TX and RX (ring queue, head writeback queue) */
 297         .isc_ntxqs = 2,
 298
 299         .isc_tx_maxsize = MGB_DMA_MAXSEGS  * MCLBYTES,
 300         /* .isc_tx_nsegments = MGB_DMA_MAXSEGS, */
 301         .isc_tx_maxsegsize = MCLBYTES,
 302
 303         .isc_ntxd_min = {1, 1}, /* Will want to make this bigger */
 304         .isc_ntxd_max = {MGB_DMA_RING_SIZE, 1},
 305         .isc_ntxd_default = {MGB_DMA_RING_SIZE, 1},
 306
 307         .isc_nrxqs = 2,
 308
 309         .isc_rx_maxsize = MCLBYTES,
 310         .isc_rx_nsegments = 1,
 311         .isc_rx_maxsegsize = MCLBYTES,
 312
 313         .isc_nrxd_min = {1, 1}, /* Will want to make this bigger */
 314         .isc_nrxd_max = {MGB_DMA_RING_SIZE, 1},
 315         .isc_nrxd_default = {MGB_DMA_RING_SIZE, 1},
 316
 317         .isc_nfl = 1, /*one free list since there is only one queue */
 318 #if 0 /* UNUSED_CTX */
 319
 320         .isc_tso_maxsize = MGB_TSO_MAXSIZE + sizeof(struct ether_vlan_header),
 321         .isc_tso_maxsegsize = MGB_TX_MAXSEGSIZE,
 322 #endif /* UNUSED_CTX */
 323 };
 324
 325 /*********************************************************************/
 326
 327
 328 static void *
 329 mgb_register(device_t dev)
 330 {
 331
 332         return (&mgb_sctx_init);
 333 }
 334
 335 static int
 336 mgb_attach_pre(if_ctx_t ctx)
 337 {
 338         struct mgb_softc *sc;
 339         if_softc_ctx_t scctx;
 340         int error, phyaddr, rid;
 341         struct ether_addr hwaddr;
 342         struct mii_data *miid;
 343
 344         sc = iflib_get_softc(ctx);
 345         sc->ctx = ctx;
 346         sc->dev = iflib_get_dev(ctx);
 347         scctx = iflib_get_softc_ctx(ctx);
 348
 349         /* IFLIB required setup */
 350         scctx->isc_txrx = &mgb_txrx;
 351         scctx->isc_tx_nsegments = MGB_DMA_MAXSEGS;
 352         /* Ring desc queues */
 353         scctx->isc_txqsizes[0] = sizeof(struct mgb_ring_desc) *
 354             scctx->isc_ntxd[0];
 355         scctx->isc_rxqsizes[0] = sizeof(struct mgb_ring_desc) *
 356             scctx->isc_nrxd[0];
 357
 358         /* Head WB queues */
 359         scctx->isc_txqsizes[1] = sizeof(uint32_t) * scctx->isc_ntxd[1];
 360         scctx->isc_rxqsizes[1] = sizeof(uint32_t) * scctx->isc_nrxd[1];
 361
 362         /* XXX: Must have 1 txqset, but can have up to 4 rxqsets */
 363         scctx->isc_nrxqsets = 1;
 364         scctx->isc_ntxqsets = 1;
 365
 366         /* scctx->isc_tx_csum_flags = (CSUM_TCP | CSUM_UDP) |
 367             (CSUM_TCP_IPV6 | CSUM_UDP_IPV6) | CSUM_TSO */
 368         scctx->isc_tx_csum_flags = 0;
 369         scctx->isc_capabilities = scctx->isc_capenable = 0;
 370 #if 0
 371         /*
 372          * CSUM, TSO and VLAN support are TBD
 373          */
 374             IFCAP_TXCSUM | IFCAP_TXCSUM_IPV6 |
 375             IFCAP_TSO4 | IFCAP_TSO6 |
 376             IFCAP_RXCSUM | IFCAP_RXCSUM_IPV6 |
 377             IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING |
 378             IFCAP_VLAN_HWCSUM | IFCAP_VLAN_HWTSO |
 379             IFCAP_JUMBO_MTU;
 380         scctx->isc_capabilities |= IFCAP_LRO | IFCAP_VLAN_HWFILTER;
 381 #endif
 382
 383         /* get the BAR */
 384         error = mgb_alloc_regs(sc);
 385         if (error != 0) {
 386                 device_printf(sc->dev,
 387                     "Unable to allocate bus resource: registers.\n");
 388                 goto fail;
 389         }
 390
 391         error = mgb_test_bar(sc);
 392         if (error != 0)
 393                 goto fail;
 394
 395         error = mgb_hw_init(sc);
 396         if (error != 0) {
 397                 device_printf(sc->dev,
 398                     "MGB device init failed. (err: %d)\n", error);
 399                 goto fail;
 400         }
 401
 402         switch (pci_get_device(sc->dev))
 403         {
 404         case MGB_LAN7430_DEVICE_ID:
 405                 phyaddr = 1;
 406                 break;
 407         case MGB_LAN7431_DEVICE_ID:
 408         default:
 409                 phyaddr = MII_PHY_ANY;
 410                 break;
 411         }
 412
 413         /* XXX: Would be nice(r) if locked methods were here */
 414         error = mii_attach(sc->dev, &sc->miibus, iflib_get_ifp(ctx),
 415             mgb_media_change, mgb_media_status,
 416             BMSR_DEFCAPMASK, phyaddr, MII_OFFSET_ANY, MIIF_DOPAUSE);
 417         if (error != 0) {
 418                 device_printf(sc->dev, "Failed to attach MII interface\n");
 419                 goto fail;
 420         }
 421
 422         miid = device_get_softc(sc->miibus);
 423         scctx->isc_media = &miid->mii_media;
 424
 425         scctx->isc_msix_bar = pci_msix_table_bar(sc->dev);
 426         /** Setup PBA BAR **/
 427         rid = pci_msix_pba_bar(sc->dev);
 428         if (rid != scctx->isc_msix_bar) {
 429                 sc->pba = bus_alloc_resource_any(sc->dev, SYS_RES_MEMORY,
 430                     &rid, RF_ACTIVE);
 431                 if (sc->pba == NULL) {
 432                         error = ENXIO;
 433                         device_printf(sc->dev, "Failed to setup PBA BAR\n");
 434                         goto fail;
 435                 }
 436         }
 437
 438         mgb_get_ethaddr(sc, &hwaddr);
 439         if (ETHER_IS_BROADCAST(hwaddr.octet) ||
 440             ETHER_IS_MULTICAST(hwaddr.octet) ||
 441             ETHER_IS_ZERO(hwaddr.octet))
 442                 ether_gen_addr(iflib_get_ifp(ctx), &hwaddr);
 443
 444         /*
 445          * XXX: if the MAC address was generated the linux driver
 446          * writes it back to the device.
 447          */
 448         iflib_set_mac(ctx, hwaddr.octet);
 449
 450         /* Map all vectors to vector 0 (admin interrupts) by default. */
 451         CSR_WRITE_REG(sc, MGB_INTR_VEC_RX_MAP, 0);
 452         CSR_WRITE_REG(sc, MGB_INTR_VEC_TX_MAP, 0);
 453         CSR_WRITE_REG(sc, MGB_INTR_VEC_OTHER_MAP, 0);
 454
 455         return (0);
 456
 457 fail:
 458         mgb_detach(ctx);
 459         return (error);
 460 }
 461
 462 static int
 463 mgb_attach_post(if_ctx_t ctx)
 464 {
 465         struct mgb_softc *sc;
 466
 467         sc = iflib_get_softc(ctx);
 468
 469         device_printf(sc->dev, "Interrupt test: %s\n",
 470             (mgb_intr_test(sc) ? "PASS" : "FAIL"));
 471
 472         return (0);
 473 }
 474
 475 static int
 476 mgb_detach(if_ctx_t ctx)
 477 {
 478         struct mgb_softc *sc;
 479         int error;
 480
 481         sc = iflib_get_softc(ctx);
 482
 483         /* XXX: Should report errors but still detach everything. */
 484         error = mgb_hw_teardown(sc);
 485
 486         /* Release IRQs */
 487         iflib_irq_free(ctx, &sc->rx_irq);
 488         iflib_irq_free(ctx, &sc->admin_irq);
 489
 490         if (sc->miibus != NULL)
 491                 device_delete_child(sc->dev, sc->miibus);
 492
 493         if (sc->pba != NULL)
 494                 error = bus_release_resource(sc->dev, SYS_RES_MEMORY,
 495                     rman_get_rid(sc->pba), sc->pba);
 496         sc->pba = NULL;
 497
 498         error = mgb_release_regs(sc);
 499
 500         return (error);
 501 }
 502
 503 static int
 504 mgb_media_change(if_t ifp)
 505 {
 506         struct mii_data *miid;
 507         struct mii_softc *miisc;
 508         struct mgb_softc *sc;
 509         if_ctx_t ctx;
 510         int needs_reset;
 511
 512         ctx = if_getsoftc(ifp);
 513         sc = iflib_get_softc(ctx);
 514         miid = device_get_softc(sc->miibus);
 515         LIST_FOREACH(miisc, &miid->mii_phys, mii_list)
 516                 PHY_RESET(miisc);
 517
 518         needs_reset = mii_mediachg(miid);
 519         if (needs_reset != 0)
 520                 ifp->if_init(ctx);
 521         return (needs_reset);
 522 }
 523
 524 static void
 525 mgb_media_status(if_t ifp, struct ifmediareq *ifmr)
 526 {
 527         struct mgb_softc *sc;
 528         struct mii_data *miid;
 529
 530         sc = iflib_get_softc(if_getsoftc(ifp));
 531         miid = device_get_softc(sc->miibus);
 532         if ((if_getflags(ifp) & IFF_UP) == 0)
 533                 return;
 534
 535         mii_pollstat(miid);
 536         ifmr->ifm_active = miid->mii_media_active;
 537         ifmr->ifm_status = miid->mii_media_status;
 538 }
 539
 540 static int
 541 mgb_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int ntxqs,
 542     int ntxqsets)
 543 {
 544         struct mgb_softc *sc;
 545         struct mgb_ring_data *rdata;
 546         int q;
 547
 548         sc = iflib_get_softc(ctx);
 549         KASSERT(ntxqsets == 1, ("ntxqsets = %d", ntxqsets));
 550         rdata = &sc->tx_ring_data;
 551         for (q = 0; q < ntxqsets; q++) {
 552                 KASSERT(ntxqs == 2, ("ntxqs = %d", ntxqs));
 553                 /* Ring */
 554                 rdata->ring = (struct mgb_ring_desc *) vaddrs[q * ntxqs + 0];
 555                 rdata->ring_bus_addr = paddrs[q * ntxqs + 0];
 556
 557                 /* Head WB */
 558                 rdata->head_wb = (uint32_t *) vaddrs[q * ntxqs + 1];
 559                 rdata->head_wb_bus_addr = paddrs[q * ntxqs + 1];
 560         }
 561         return 0;
 562 }
 563
 564 static int
 565 mgb_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nrxqs,
 566     int nrxqsets)
 567 {
 568         struct mgb_softc *sc;
 569         struct mgb_ring_data *rdata;
 570         int q;
 571
 572         sc = iflib_get_softc(ctx);
 573         KASSERT(nrxqsets == 1, ("nrxqsets = %d", nrxqsets));
 574         rdata = &sc->rx_ring_data;
 575         for (q = 0; q < nrxqsets; q++) {
 576                 KASSERT(nrxqs == 2, ("nrxqs = %d", nrxqs));
 577                 /* Ring */
 578                 rdata->ring = (struct mgb_ring_desc *) vaddrs[q * nrxqs + 0];
 579                 rdata->ring_bus_addr = paddrs[q * nrxqs + 0];
 580
 581                 /* Head WB */
 582                 rdata->head_wb = (uint32_t *) vaddrs[q * nrxqs + 1];
 583                 rdata->head_wb_bus_addr = paddrs[q * nrxqs + 1];
 584         }
 585         return 0;
 586 }
 587
 588 static void
 589 mgb_queues_free(if_ctx_t ctx)
 590 {
 591         struct mgb_softc *sc;
 592
 593         sc = iflib_get_softc(ctx);
 594
 595         memset(&sc->rx_ring_data, 0, sizeof(struct mgb_ring_data));
 596         memset(&sc->tx_ring_data, 0, sizeof(struct mgb_ring_data));
 597 }
 598
 599 static void
 600 mgb_init(if_ctx_t ctx)
 601 {
 602         struct mgb_softc *sc;
 603         struct mii_data *miid;
 604         int error;
 605
 606         sc = iflib_get_softc(ctx);
 607         miid = device_get_softc(sc->miibus);
 608         device_printf(sc->dev, "running init ...\n");
 609
 610         mgb_dma_init(sc);
 611
 612         /* XXX: Turn off perfect filtering, turn on (broad|multi|uni)cast rx */
 613         CSR_CLEAR_REG(sc, MGB_RFE_CTL, MGB_RFE_ALLOW_PERFECT_FILTER);
 614         CSR_UPDATE_REG(sc, MGB_RFE_CTL,
 615             MGB_RFE_ALLOW_BROADCAST |
 616             MGB_RFE_ALLOW_UNICAST |
 617             MGB_RFE_ALLOW_UNICAST);
 618
 619         error = mii_mediachg(miid);
 620         KASSERT(!error, ("mii_mediachg returned: %d", error));
 621 }
 622
 623 #ifdef DEBUG
 624 static void
 625 mgb_dump_some_stats(struct mgb_softc *sc)
 626 {
 627         int i;
 628         int first_stat = 0x1200;
 629         int last_stat = 0x12FC;
 630
 631         for (i = first_stat; i <= last_stat; i += 4)
 632                 if (CSR_READ_REG(sc, i) != 0)
 633                         device_printf(sc->dev, "0x%04x: 0x%08x\n", i,
 634                             CSR_READ_REG(sc, i));
 635         char *stat_names[] = {
 636                 "MAC_ERR_STS ",
 637                 "FCT_INT_STS ",
 638                 "DMAC_CFG ",
 639                 "DMAC_CMD ",
 640                 "DMAC_INT_STS ",
 641                 "DMAC_INT_EN ",
 642                 "DMAC_RX_ERR_STS0 ",
 643                 "DMAC_RX_ERR_STS1 ",
 644                 "DMAC_RX_ERR_STS2 ",
 645                 "DMAC_RX_ERR_STS3 ",
 646                 "INT_STS ",
 647                 "INT_EN ",
 648                 "INT_VEC_EN ",
 649                 "INT_VEC_MAP0 ",
 650                 "INT_VEC_MAP1 ",
 651                 "INT_VEC_MAP2 ",
 652                 "TX_HEAD0",
 653                 "TX_TAIL0",
 654                 "DMAC_TX_ERR_STS0 ",
 655                 NULL
 656         };
 657         int stats[] = {
 658                 0x114,
 659                 0xA0,
 660                 0xC00,
 661                 0xC0C,
 662                 0xC10,
 663                 0xC14,
 664                 0xC60,
 665                 0xCA0,
 666                 0xCE0,
 667                 0xD20,
 668                 0x780,
 669                 0x788,
 670                 0x794,
 671                 0x7A0,
 672                 0x7A4,
 673                 0x780,
 674                 0xD58,
 675                 0xD5C,
 676                 0xD60,
 677                 0x0
 678         };
 679         i = 0;
 680         printf("==============================\n");
 681         while (stats[i++])
 682                 device_printf(sc->dev, "%s at offset 0x%04x = 0x%08x\n",
 683                     stat_names[i - 1], stats[i - 1],
 684                     CSR_READ_REG(sc, stats[i - 1]));
 685         printf("==== TX RING DESCS ====\n");
 686         for (i = 0; i < MGB_DMA_RING_SIZE; i++)
 687                 device_printf(sc->dev, "ring[%d].data0=0x%08x\n"
 688                     "ring[%d].data1=0x%08x\n"
 689                     "ring[%d].data2=0x%08x\n"
 690                     "ring[%d].data3=0x%08x\n",
 691                     i, sc->tx_ring_data.ring[i].ctl,
 692                     i, sc->tx_ring_data.ring[i].addr.low,
 693                     i, sc->tx_ring_data.ring[i].addr.high,
 694                     i, sc->tx_ring_data.ring[i].sts);
 695         device_printf(sc->dev, "==== DUMP_TX_DMA_RAM ====\n");
 696         int i;
 697         CSR_WRITE_REG(sc, 0x24, 0xF); // DP_SEL & TX_RAM_0
 698         for (i = 0; i < 128; i++) {
 699                 CSR_WRITE_REG(sc, 0x2C, i); // DP_ADDR
 700
 701                 CSR_WRITE_REG(sc, 0x28, 0); // DP_CMD
 702
 703                 while ((CSR_READ_REG(sc, 0x24) & 0x80000000) == 0) // DP_SEL & READY
 704                         DELAY(1000);
 705
 706                 device_printf(sc->dev, "DMAC_TX_RAM_0[%u]=%08x\n", i,
 707                     CSR_READ_REG(sc, 0x30)); // DP_DATA
 708         }
 709 }
 710 #endif
 711
 712 static void
 713 mgb_stop(if_ctx_t ctx)
 714 {
 715         struct mgb_softc *sc ;
 716         if_softc_ctx_t scctx;
 717         int i;
 718
 719         sc = iflib_get_softc(ctx);
 720         scctx = iflib_get_softc_ctx(ctx);
 721
 722         /* XXX: Could potentially timeout */
 723         for (i = 0; i < scctx->isc_nrxqsets; i++) {
 724                 mgb_dmac_control(sc, MGB_DMAC_RX_START, 0, DMAC_STOP);
 725                 mgb_fct_control(sc, MGB_FCT_RX_CTL, 0, FCT_DISABLE);
 726         }
 727         for (i = 0; i < scctx->isc_ntxqsets; i++) {
 728                 mgb_dmac_control(sc, MGB_DMAC_TX_START, 0, DMAC_STOP);
 729                 mgb_fct_control(sc, MGB_FCT_TX_CTL, 0, FCT_DISABLE);
 730         }
 731 }
 732
 733 static int
 734 mgb_legacy_intr(void *xsc)
 735 {
 736         struct mgb_softc *sc;
 737
 738         sc = xsc;
 739         iflib_admin_intr_deferred(sc->ctx);
 740         return (FILTER_HANDLED);
 741 }
 742
 743 static int
 744 mgb_rxq_intr(void *xsc)
 745 {
 746         struct mgb_softc *sc;
 747         if_softc_ctx_t scctx;
 748         uint32_t intr_sts, intr_en;
 749         int qidx;
 750
 751         sc = xsc;
 752         scctx = iflib_get_softc_ctx(sc->ctx);
 753
 754         intr_sts = CSR_READ_REG(sc, MGB_INTR_STS);
 755         intr_en = CSR_READ_REG(sc, MGB_INTR_ENBL_SET);
 756         intr_sts &= intr_en;
 757
 758         for (qidx = 0; qidx < scctx->isc_nrxqsets; qidx++) {
 759                 if ((intr_sts & MGB_INTR_STS_RX(qidx))){
 760                         CSR_WRITE_REG(sc, MGB_INTR_ENBL_CLR,
 761                             MGB_INTR_STS_RX(qidx));
 762                         CSR_WRITE_REG(sc, MGB_INTR_STS, MGB_INTR_STS_RX(qidx));
 763                 }
 764         }
 765         return (FILTER_SCHEDULE_THREAD);
 766 }
 767
 768 static int
 769 mgb_admin_intr(void *xsc)
 770 {
 771         struct mgb_softc *sc;
 772         if_softc_ctx_t scctx;
 773         uint32_t intr_sts, intr_en;
 774         int qidx;
 775
 776         sc = xsc;
 777         scctx = iflib_get_softc_ctx(sc->ctx);
 778
 779         intr_sts = CSR_READ_REG(sc, MGB_INTR_STS);
 780         intr_en = CSR_READ_REG(sc, MGB_INTR_ENBL_SET);
 781         intr_sts &= intr_en;
 782
 783         /*
 784          * NOTE: Debugging printfs here
 785          * will likely cause interrupt test failure.
 786          */
 787
 788         /* TODO: shouldn't continue if suspended */
 789         if ((intr_sts & MGB_INTR_STS_ANY) == 0)
 790         {
 791                 device_printf(sc->dev, "non-mgb interrupt triggered.\n");
 792                 return (FILTER_SCHEDULE_THREAD);
 793         }
 794         if ((intr_sts &  MGB_INTR_STS_TEST) != 0)
 795         {
 796                 sc->isr_test_flag = true;
 797                 CSR_WRITE_REG(sc, MGB_INTR_STS, MGB_INTR_STS_TEST);
 798                 return (FILTER_HANDLED);
 799         }
 800         if ((intr_sts & MGB_INTR_STS_RX_ANY) != 0)
 801         {
 802                 for (qidx = 0; qidx < scctx->isc_nrxqsets; qidx++) {
 803                         if ((intr_sts & MGB_INTR_STS_RX(qidx))){
 804                                 iflib_rx_intr_deferred(sc->ctx, qidx);
 805                         }
 806                 }
 807                 return (FILTER_HANDLED);
 808         }
 809         /* XXX: TX interrupts should not occur */
 810         if ((intr_sts & MGB_INTR_STS_TX_ANY) != 0)
 811         {
 812                 for (qidx = 0; qidx < scctx->isc_ntxqsets; qidx++) {
 813                         if ((intr_sts & MGB_INTR_STS_RX(qidx))) {
 814                                 /* clear the interrupt sts and run handler */
 815                                 CSR_WRITE_REG(sc, MGB_INTR_ENBL_CLR,
 816                                     MGB_INTR_STS_TX(qidx));
 817                                 CSR_WRITE_REG(sc, MGB_INTR_STS,
 818                                     MGB_INTR_STS_TX(qidx));
 819                                 iflib_tx_intr_deferred(sc->ctx, qidx);
 820                         }
 821                 }
 822                 return (FILTER_HANDLED);
 823         }
 824
 825         return (FILTER_SCHEDULE_THREAD);
 826 }
 827
 828 static int
 829 mgb_msix_intr_assign(if_ctx_t ctx, int msix)
 830 {
 831         struct mgb_softc *sc;
 832         if_softc_ctx_t scctx;
 833         int error, i, vectorid;
 834         char irq_name[16];
 835
 836         sc = iflib_get_softc(ctx);
 837         scctx = iflib_get_softc_ctx(ctx);
 838
 839         KASSERT(scctx->isc_nrxqsets == 1 && scctx->isc_ntxqsets == 1,
 840             ("num rxqsets/txqsets != 1 "));
 841
 842         /*
 843          * First vector should be admin interrupts, others vectors are TX/RX
 844          *
 845          * RIDs start at 1, and vector ids start at 0.
 846          */
 847         vectorid = 0;
 848         error = iflib_irq_alloc_generic(ctx, &sc->admin_irq, vectorid + 1,
 849             IFLIB_INTR_ADMIN, mgb_admin_intr, sc, 0, "admin");
 850         if (error) {
 851                 device_printf(sc->dev,
 852                     "Failed to register admin interrupt handler\n");
 853                 return (error);
 854         }
 855
 856         for (i = 0; i < scctx->isc_nrxqsets; i++) {
 857                 vectorid++;
 858                 snprintf(irq_name, sizeof(irq_name), "rxq%d", i);
 859                 error = iflib_irq_alloc_generic(ctx, &sc->rx_irq, vectorid + 1,
 860                     IFLIB_INTR_RX, mgb_rxq_intr, sc, i, irq_name);
 861                 if (error) {
 862                         device_printf(sc->dev,
 863                             "Failed to register rxq %d interrupt handler\n", i);
 864                         return (error);
 865                 }
 866                 CSR_UPDATE_REG(sc, MGB_INTR_VEC_RX_MAP,
 867                     MGB_INTR_VEC_MAP(vectorid, i));
 868         }
 869
 870         /* Not actually mapping hw TX interrupts ... */
 871         for (i = 0; i < scctx->isc_ntxqsets; i++) {
 872                 snprintf(irq_name, sizeof(irq_name), "txq%d", i);
 873                 iflib_softirq_alloc_generic(ctx, NULL, IFLIB_INTR_TX, NULL, i,
 874                     irq_name);
 875         }
 876
 877         return (0);
 878 }
 879
 880 static void
 881 mgb_intr_enable_all(if_ctx_t ctx)
 882 {
 883         struct mgb_softc *sc;
 884         if_softc_ctx_t scctx;
 885         int i, dmac_enable = 0, intr_sts = 0, vec_en = 0;
 886
 887         sc = iflib_get_softc(ctx);
 888         scctx = iflib_get_softc_ctx(ctx);
 889         intr_sts |= MGB_INTR_STS_ANY;
 890         vec_en |= MGB_INTR_STS_ANY;
 891
 892         for (i = 0; i < scctx->isc_nrxqsets; i++) {
 893                 intr_sts |= MGB_INTR_STS_RX(i);
 894                 dmac_enable |= MGB_DMAC_RX_INTR_ENBL(i);
 895                 vec_en |= MGB_INTR_RX_VEC_STS(i);
 896         }
 897
 898         /* TX interrupts aren't needed ... */
 899
 900         CSR_WRITE_REG(sc, MGB_INTR_ENBL_SET, intr_sts);
 901         CSR_WRITE_REG(sc, MGB_INTR_VEC_ENBL_SET, vec_en);
 902         CSR_WRITE_REG(sc, MGB_DMAC_INTR_STS, dmac_enable);
 903         CSR_WRITE_REG(sc, MGB_DMAC_INTR_ENBL_SET, dmac_enable);
 904 }
 905
 906 static void
 907 mgb_intr_disable_all(if_ctx_t ctx)
 908 {
 909         struct mgb_softc *sc;
 910
 911         sc = iflib_get_softc(ctx);
 912         CSR_WRITE_REG(sc, MGB_INTR_ENBL_CLR, UINT32_MAX);
 913         CSR_WRITE_REG(sc, MGB_INTR_VEC_ENBL_CLR, UINT32_MAX);
 914         CSR_WRITE_REG(sc, MGB_INTR_STS, UINT32_MAX);
 915
 916         CSR_WRITE_REG(sc, MGB_DMAC_INTR_ENBL_CLR, UINT32_MAX);
 917         CSR_WRITE_REG(sc, MGB_DMAC_INTR_STS, UINT32_MAX);
 918 }
 919
 920 static int
 921 mgb_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid)
 922 {
 923         /* called after successful rx isr */
 924         struct mgb_softc *sc;
 925
 926         sc = iflib_get_softc(ctx);
 927         CSR_WRITE_REG(sc, MGB_INTR_VEC_ENBL_SET, MGB_INTR_RX_VEC_STS(qid));
 928         CSR_WRITE_REG(sc, MGB_INTR_ENBL_SET, MGB_INTR_STS_RX(qid));
 929
 930         CSR_WRITE_REG(sc, MGB_DMAC_INTR_STS, MGB_DMAC_RX_INTR_ENBL(qid));
 931         CSR_WRITE_REG(sc, MGB_DMAC_INTR_ENBL_SET, MGB_DMAC_RX_INTR_ENBL(qid));
 932         return (0);
 933 }
 934
 935 static int
 936 mgb_tx_queue_intr_enable(if_ctx_t ctx, uint16_t qid)
 937 {
 938         /* XXX: not called (since tx interrupts not used) */
 939         struct mgb_softc *sc;
 940
 941         sc = iflib_get_softc(ctx);
 942
 943         CSR_WRITE_REG(sc, MGB_INTR_ENBL_SET, MGB_INTR_STS_TX(qid));
 944
 945         CSR_WRITE_REG(sc, MGB_DMAC_INTR_STS, MGB_DMAC_TX_INTR_ENBL(qid));
 946         CSR_WRITE_REG(sc, MGB_DMAC_INTR_ENBL_SET, MGB_DMAC_TX_INTR_ENBL(qid));
 947         return (0);
 948 }
 949
 950 static bool
 951 mgb_intr_test(struct mgb_softc *sc)
 952 {
 953         int i;
 954
 955         sc->isr_test_flag = false;
 956         CSR_WRITE_REG(sc, MGB_INTR_STS, MGB_INTR_STS_TEST);
 957         CSR_WRITE_REG(sc, MGB_INTR_VEC_ENBL_SET, MGB_INTR_STS_ANY);
 958         CSR_WRITE_REG(sc, MGB_INTR_ENBL_SET,
 959             MGB_INTR_STS_ANY | MGB_INTR_STS_TEST);
 960         CSR_WRITE_REG(sc, MGB_INTR_SET, MGB_INTR_STS_TEST);
 961         if (sc->isr_test_flag)
 962                 return true;
 963         for (i = 0; i < MGB_TIMEOUT; i++) {
 964                 DELAY(10);
 965                 if (sc->isr_test_flag)
 966                         break;
 967         }
 968         CSR_WRITE_REG(sc, MGB_INTR_ENBL_CLR, MGB_INTR_STS_TEST);
 969         CSR_WRITE_REG(sc, MGB_INTR_STS, MGB_INTR_STS_TEST);
 970         return sc->isr_test_flag;
 971 }
 972
 973 static int
 974 mgb_isc_txd_encap(void *xsc , if_pkt_info_t ipi)
 975 {
 976         struct mgb_softc *sc;
 977         if_softc_ctx_t scctx;
 978         struct mgb_ring_data *rdata;
 979         struct mgb_ring_desc *txd;
 980         bus_dma_segment_t *segs;
 981         qidx_t pidx, nsegs;
 982         int i;
 983
 984         KASSERT(ipi->ipi_qsidx == 0,
 985             ("tried to refill TX Channel %d.\n", ipi->ipi_qsidx));
 986         sc = xsc;
 987         scctx = iflib_get_softc_ctx(sc->ctx);
 988         rdata = &sc->tx_ring_data;
 989
 990         pidx = ipi->ipi_pidx;
 991         segs = ipi->ipi_segs;
 992         nsegs = ipi->ipi_nsegs;
 993
 994         /* For each seg, create a descriptor */
 995         for (i = 0; i < nsegs; ++i) {
 996                 KASSERT(nsegs == 1, ("Multisegment packet !!!!!\n"));
 997                 txd = &rdata->ring[pidx];
 998                 txd->ctl = htole32(
 999                     (segs[i].ds_len & MGB_DESC_CTL_BUFLEN_MASK ) |
1000                     /*
1001                      * XXX: This will be wrong in the multipacket case
1002                      * I suspect FS should be for the first packet and
1003                      * LS should be for the last packet
1004                      */
1005                     MGB_TX_DESC_CTL_FS | MGB_TX_DESC_CTL_LS |
1006                     MGB_DESC_CTL_FCS);
1007                 txd->addr.low = htole32(CSR_TRANSLATE_ADDR_LOW32(
1008                     segs[i].ds_addr));
1009                 txd->addr.high = htole32(CSR_TRANSLATE_ADDR_HIGH32(
1010                     segs[i].ds_addr));
1011                 txd->sts = htole32(
1012                     (segs[i].ds_len << 16) & MGB_DESC_FRAME_LEN_MASK);
1013                 pidx = MGB_NEXT_RING_IDX(pidx);
1014         }
1015         ipi->ipi_new_pidx = pidx;
1016         return (0);
1017 }
1018
1019 static void
1020 mgb_isc_txd_flush(void *xsc, uint16_t txqid, qidx_t pidx)
1021 {
1022         struct mgb_softc *sc;
1023         struct mgb_ring_data *rdata;
1024
1025         KASSERT(txqid == 0, ("tried to flush TX Channel %d.\n", txqid));
1026         sc = xsc;
1027         rdata = &sc->tx_ring_data;
1028
1029         if (rdata->last_tail != pidx) {
1030                 rdata->last_tail = pidx;
1031                 CSR_WRITE_REG(sc, MGB_DMA_TX_TAIL(txqid), rdata->last_tail);
1032         }
1033 }
1034
1035 static int
1036 mgb_isc_txd_credits_update(void *xsc, uint16_t txqid, bool clear)
1037 {
1038         struct mgb_softc *sc;
1039         struct mgb_ring_desc *txd;
1040         struct mgb_ring_data *rdata;
1041         int processed = 0;
1042
1043         /*
1044          * > If clear is true, we need to report the number of TX command ring
1045          * > descriptors that have been processed by the device.  If clear is
1046          * > false, we just need to report whether or not at least one TX
1047          * > command ring descriptor has been processed by the device.
1048          * - vmx driver
1049          */
1050         KASSERT(txqid == 0, ("tried to credits_update TX Channel %d.\n",
1051             txqid));
1052         sc = xsc;
1053         rdata = &sc->tx_ring_data;
1054
1055         while (*(rdata->head_wb) != rdata->last_head) {
1056                 if (!clear)
1057                         return 1;
1058
1059                 txd = &rdata->ring[rdata->last_head];
1060                 memset(txd, 0, sizeof(struct mgb_ring_desc));
1061                 rdata->last_head = MGB_NEXT_RING_IDX(rdata->last_head);
1062                 processed++;
1063         }
1064
1065         return (processed);
1066 }
1067
1068 static int
1069 mgb_isc_rxd_available(void *xsc, uint16_t rxqid, qidx_t idx, qidx_t budget)
1070 {
1071         struct mgb_softc *sc;
1072         if_softc_ctx_t scctx;
1073         struct mgb_ring_data *rdata;
1074         int avail = 0;
1075
1076         sc = xsc;
1077         KASSERT(rxqid == 0, ("tried to check availability in RX Channel %d.\n",
1078             rxqid));
1079
1080         rdata = &sc->rx_ring_data;
1081         scctx = iflib_get_softc_ctx(sc->ctx);
1082         for (; idx != *(rdata->head_wb);
1083             idx = MGB_NEXT_RING_IDX(idx)) {
1084                 avail++;
1085                 /* XXX: Could verify desc is device owned here */
1086                 if (avail == budget)
1087                         break;
1088         }
1089         return (avail);
1090 }
1091
1092 static int
1093 mgb_isc_rxd_pkt_get(void *xsc, if_rxd_info_t ri)
1094 {
1095         struct mgb_softc *sc;
1096         struct mgb_ring_data *rdata;
1097         struct mgb_ring_desc rxd;
1098         int total_len;
1099
1100         KASSERT(ri->iri_qsidx == 0,
1101             ("tried to check availability in RX Channel %d\n", ri->iri_qsidx));
1102         sc = xsc;
1103         total_len = 0;
1104         rdata = &sc->rx_ring_data;
1105
1106         while (*(rdata->head_wb) != rdata->last_head) {
1107                 /* copy ring desc and do swapping */
1108                 rxd = rdata->ring[rdata->last_head];
1109                 rxd.ctl = le32toh(rxd.ctl);
1110                 rxd.addr.low = le32toh(rxd.ctl);
1111                 rxd.addr.high = le32toh(rxd.ctl);
1112                 rxd.sts = le32toh(rxd.ctl);
1113
1114                 if ((rxd.ctl & MGB_DESC_CTL_OWN) != 0) {
1115                         device_printf(sc->dev,
1116                             "Tried to read descriptor ... "
1117                             "found that it's owned by the driver\n");
1118                         return EINVAL;
1119                 }
1120                 if ((rxd.ctl & MGB_RX_DESC_CTL_FS) == 0) {
1121                         device_printf(sc->dev,
1122                             "Tried to read descriptor ... "
1123                             "found that FS is not set.\n");
1124                         device_printf(sc->dev, "Tried to read descriptor ... that it FS is not set.\n");
1125                         return EINVAL;
1126                 }
1127                 /* XXX: Multi-packet support */
1128                 if ((rxd.ctl & MGB_RX_DESC_CTL_LS) == 0) {
1129                         device_printf(sc->dev,
1130                             "Tried to read descriptor ... "
1131                             "found that LS is not set. (Multi-buffer packets not yet supported)\n");
1132                         return EINVAL;
1133                 }
1134                 ri->iri_frags[0].irf_flid = 0;
1135                 ri->iri_frags[0].irf_idx = rdata->last_head;
1136                 ri->iri_frags[0].irf_len = MGB_DESC_GET_FRAME_LEN(&rxd);
1137                 total_len += ri->iri_frags[0].irf_len;
1138
1139                 rdata->last_head = MGB_NEXT_RING_IDX(rdata->last_head);
1140                 break;
1141         }
1142         ri->iri_nfrags = 1;
1143         ri->iri_len = total_len;
1144
1145         return (0);
1146 }
1147
1148 static void
1149 mgb_isc_rxd_refill(void *xsc, if_rxd_update_t iru)
1150 {
1151         if_softc_ctx_t scctx;
1152         struct mgb_softc *sc;
1153         struct mgb_ring_data *rdata;
1154         struct mgb_ring_desc *rxd;
1155         uint64_t *paddrs;
1156         qidx_t *idxs;
1157         qidx_t idx;
1158         int count, len;
1159
1160         count = iru->iru_count;
1161         len = iru->iru_buf_size;
1162         idxs = iru->iru_idxs;
1163         paddrs = iru->iru_paddrs;
1164         KASSERT(iru->iru_qsidx == 0,
1165             ("tried to refill RX Channel %d.\n", iru->iru_qsidx));
1166
1167         sc = xsc;
1168         scctx = iflib_get_softc_ctx(sc->ctx);
1169         rdata = &sc->rx_ring_data;
1170
1171         while (count > 0) {
1172                 idx = idxs[--count];
1173                 rxd = &rdata->ring[idx];
1174
1175                 rxd->sts = 0;
1176                 rxd->addr.low =
1177                     htole32(CSR_TRANSLATE_ADDR_LOW32(paddrs[count]));
1178                 rxd->addr.high =
1179                     htole32(CSR_TRANSLATE_ADDR_HIGH32(paddrs[count]));
1180                 rxd->ctl = htole32(MGB_DESC_CTL_OWN |
1181                     (len & MGB_DESC_CTL_BUFLEN_MASK));
1182         }
1183         return;
1184 }
1185
1186 static void
1187 mgb_isc_rxd_flush(void *xsc, uint16_t rxqid, uint8_t flid, qidx_t pidx)
1188 {
1189         struct mgb_softc *sc;
1190
1191         sc = xsc;
1192
1193         KASSERT(rxqid == 0, ("tried to flush RX Channel %d.\n", rxqid));
1194         /*
1195          * According to the programming guide, last_tail must be set to
1196          * the last valid RX descriptor, rather than to the one past that.
1197          * Note that this is not true for the TX ring!
1198          */
1199         sc->rx_ring_data.last_tail = MGB_PREV_RING_IDX(pidx);
1200         CSR_WRITE_REG(sc, MGB_DMA_RX_TAIL(rxqid), sc->rx_ring_data.last_tail);
1201         return;
1202 }
1203
1204 static int
1205 mgb_test_bar(struct mgb_softc *sc)
1206 {
1207         uint32_t id_rev, dev_id, rev;
1208
1209         id_rev = CSR_READ_REG(sc, 0);
1210         dev_id = id_rev >> 16;
1211         rev = id_rev & 0xFFFF;
1212         if (dev_id == MGB_LAN7430_DEVICE_ID ||
1213             dev_id == MGB_LAN7431_DEVICE_ID) {
1214                 return 0;
1215         } else {
1216                 device_printf(sc->dev, "ID check failed.\n");
1217                 return ENXIO;
1218         }
1219 }
1220
1221 static int
1222 mgb_alloc_regs(struct mgb_softc *sc)
1223 {
1224         int rid;
1225
1226         rid = PCIR_BAR(MGB_BAR);
1227         pci_enable_busmaster(sc->dev);
1228         sc->regs = bus_alloc_resource_any(sc->dev, SYS_RES_MEMORY,
1229             &rid, RF_ACTIVE);
1230         if (sc->regs == NULL)
1231                  return ENXIO;
1232
1233         return (0);
1234 }
1235
1236 static int
1237 mgb_release_regs(struct mgb_softc *sc)
1238 {
1239         int error = 0;
1240
1241         if (sc->regs != NULL)
1242                 error = bus_release_resource(sc->dev, SYS_RES_MEMORY,
1243                     rman_get_rid(sc->regs), sc->regs);
1244         sc->regs = NULL;
1245         pci_disable_busmaster(sc->dev);
1246         return error;
1247 }
1248
1249 static int
1250 mgb_dma_init(struct mgb_softc *sc)
1251 {
1252         if_softc_ctx_t scctx;
1253         int ch, error = 0;
1254
1255         scctx = iflib_get_softc_ctx(sc->ctx);
1256
1257         for (ch = 0; ch < scctx->isc_nrxqsets; ch++)
1258                 if ((error = mgb_dma_rx_ring_init(sc, ch)))
1259                         goto fail;
1260
1261         for (ch = 0; ch < scctx->isc_nrxqsets; ch++)
1262                 if ((error = mgb_dma_tx_ring_init(sc, ch)))
1263                         goto fail;
1264
1265 fail:
1266         return error;
1267 }
1268
1269 static int
1270 mgb_dma_rx_ring_init(struct mgb_softc *sc, int channel)
1271 {
1272         struct mgb_ring_data *rdata;
1273         int ring_config, error = 0;
1274
1275         rdata = &sc->rx_ring_data;
1276         mgb_dmac_control(sc, MGB_DMAC_RX_START, 0, DMAC_RESET);
1277         KASSERT(MGB_DMAC_STATE_IS_INITIAL(sc, MGB_DMAC_RX_START, channel),
1278             ("Trying to init channels when not in init state\n"));
1279
1280         /* write ring address */
1281         if (rdata->ring_bus_addr == 0) {
1282                 device_printf(sc->dev, "Invalid ring bus addr.\n");
1283                 goto fail;
1284         }
1285
1286         CSR_WRITE_REG(sc, MGB_DMA_RX_BASE_H(channel),
1287             CSR_TRANSLATE_ADDR_HIGH32(rdata->ring_bus_addr));
1288         CSR_WRITE_REG(sc, MGB_DMA_RX_BASE_L(channel),
1289             CSR_TRANSLATE_ADDR_LOW32(rdata->ring_bus_addr));
1290
1291         /* write head pointer writeback address */
1292         if (rdata->head_wb_bus_addr == 0) {
1293                 device_printf(sc->dev, "Invalid head wb bus addr.\n");
1294                 goto fail;
1295         }
1296         CSR_WRITE_REG(sc, MGB_DMA_RX_HEAD_WB_H(channel),
1297             CSR_TRANSLATE_ADDR_HIGH32(rdata->head_wb_bus_addr));
1298         CSR_WRITE_REG(sc, MGB_DMA_RX_HEAD_WB_L(channel),
1299             CSR_TRANSLATE_ADDR_LOW32(rdata->head_wb_bus_addr));
1300
1301         /* Enable head pointer writeback */
1302         CSR_WRITE_REG(sc, MGB_DMA_RX_CONFIG0(channel), MGB_DMA_HEAD_WB_ENBL);
1303
1304         ring_config = CSR_READ_REG(sc, MGB_DMA_RX_CONFIG1(channel));
1305         /*  ring size */
1306         ring_config &= ~MGB_DMA_RING_LEN_MASK;
1307         ring_config |= (MGB_DMA_RING_SIZE & MGB_DMA_RING_LEN_MASK);
1308         /* packet padding  (PAD_2 is better for IP header alignment ...) */
1309         ring_config &= ~MGB_DMA_RING_PAD_MASK;
1310         ring_config |= (MGB_DMA_RING_PAD_0 & MGB_DMA_RING_PAD_MASK);
1311
1312         CSR_WRITE_REG(sc, MGB_DMA_RX_CONFIG1(channel), ring_config);
1313
1314         rdata->last_head = CSR_READ_REG(sc, MGB_DMA_RX_HEAD(channel));
1315
1316         mgb_fct_control(sc, MGB_FCT_RX_CTL, channel, FCT_RESET);
1317         if (error != 0) {
1318                 device_printf(sc->dev, "Failed to reset RX FCT.\n");
1319                 goto fail;
1320         }
1321         mgb_fct_control(sc, MGB_FCT_RX_CTL, channel, FCT_ENABLE);
1322         if (error != 0) {
1323                 device_printf(sc->dev, "Failed to enable RX FCT.\n");
1324                 goto fail;
1325         }
1326         mgb_dmac_control(sc, MGB_DMAC_RX_START, channel, DMAC_START);
1327         if (error != 0)
1328                 device_printf(sc->dev, "Failed to start RX DMAC.\n");
1329 fail:
1330         return (error);
1331 }
1332
1333 static int
1334 mgb_dma_tx_ring_init(struct mgb_softc *sc, int channel)
1335 {
1336         struct mgb_ring_data *rdata;
1337         int ring_config, error = 0;
1338
1339         rdata = &sc->tx_ring_data;
1340         if ((error = mgb_fct_control(sc, MGB_FCT_TX_CTL, channel, FCT_RESET))) {
1341                 device_printf(sc->dev, "Failed to reset TX FCT.\n");
1342                 goto fail;
1343         }
1344         if ((error = mgb_fct_control(sc, MGB_FCT_TX_CTL, channel,
1345             FCT_ENABLE))) {
1346                 device_printf(sc->dev, "Failed to enable TX FCT.\n");
1347                 goto fail;
1348         }
1349         if ((error = mgb_dmac_control(sc, MGB_DMAC_TX_START, channel,
1350             DMAC_RESET))) {
1351                 device_printf(sc->dev, "Failed to reset TX DMAC.\n");
1352                 goto fail;
1353         }
1354         KASSERT(MGB_DMAC_STATE_IS_INITIAL(sc, MGB_DMAC_TX_START, channel),
1355             ("Trying to init channels in not init state\n"));
1356
1357         /* write ring address */
1358         if (rdata->ring_bus_addr == 0) {
1359                 device_printf(sc->dev, "Invalid ring bus addr.\n");
1360                 goto fail;
1361         }
1362         CSR_WRITE_REG(sc, MGB_DMA_TX_BASE_H(channel),
1363             CSR_TRANSLATE_ADDR_HIGH32(rdata->ring_bus_addr));
1364         CSR_WRITE_REG(sc, MGB_DMA_TX_BASE_L(channel),
1365             CSR_TRANSLATE_ADDR_LOW32(rdata->ring_bus_addr));
1366
1367         /* write ring size */
1368         ring_config = CSR_READ_REG(sc, MGB_DMA_TX_CONFIG1(channel));
1369         ring_config &= ~MGB_DMA_RING_LEN_MASK;
1370         ring_config |= (MGB_DMA_RING_SIZE & MGB_DMA_RING_LEN_MASK);
1371         CSR_WRITE_REG(sc, MGB_DMA_TX_CONFIG1(channel), ring_config);
1372
1373         /* Enable interrupt on completion and head pointer writeback */
1374         ring_config = (MGB_DMA_HEAD_WB_LS_ENBL | MGB_DMA_HEAD_WB_ENBL);
1375         CSR_WRITE_REG(sc, MGB_DMA_TX_CONFIG0(channel), ring_config);
1376
1377         /* write head pointer writeback address */
1378         if (rdata->head_wb_bus_addr == 0) {
1379                 device_printf(sc->dev, "Invalid head wb bus addr.\n");
1380                 goto fail;
1381         }
1382         CSR_WRITE_REG(sc, MGB_DMA_TX_HEAD_WB_H(channel),
1383             CSR_TRANSLATE_ADDR_HIGH32(rdata->head_wb_bus_addr));
1384         CSR_WRITE_REG(sc, MGB_DMA_TX_HEAD_WB_L(channel),
1385             CSR_TRANSLATE_ADDR_LOW32(rdata->head_wb_bus_addr));
1386
1387         rdata->last_head = CSR_READ_REG(sc, MGB_DMA_TX_HEAD(channel));
1388         KASSERT(rdata->last_head == 0, ("MGB_DMA_TX_HEAD was not reset.\n"));
1389         rdata->last_tail = 0;
1390         CSR_WRITE_REG(sc, MGB_DMA_TX_TAIL(channel), rdata->last_tail);
1391
1392         if ((error = mgb_dmac_control(sc, MGB_DMAC_TX_START, channel,
1393             DMAC_START)))
1394                 device_printf(sc->dev, "Failed to start TX DMAC.\n");
1395 fail:
1396         return error;
1397 }
1398
1399 static int
1400 mgb_dmac_control(struct mgb_softc *sc, int start, int channel,
1401     enum mgb_dmac_cmd cmd)
1402 {
1403         int error = 0;
1404
1405         switch (cmd) {
1406         case DMAC_RESET:
1407                 CSR_WRITE_REG(sc, MGB_DMAC_CMD,
1408                     MGB_DMAC_CMD_RESET(start, channel));
1409                 error = mgb_wait_for_bits(sc, MGB_DMAC_CMD, 0,
1410                     MGB_DMAC_CMD_RESET(start, channel));
1411                 break;
1412
1413         case DMAC_START:
1414                 /*
1415                  * NOTE: this simplifies the logic, since it will never
1416                  * try to start in STOP_PENDING, but it also increases work.
1417                  */
1418                 error = mgb_dmac_control(sc, start, channel, DMAC_STOP);
1419                 if (error != 0)
1420                         return error;
1421                 CSR_WRITE_REG(sc, MGB_DMAC_CMD,
1422                     MGB_DMAC_CMD_START(start, channel));
1423                 break;
1424
1425         case DMAC_STOP:
1426                 CSR_WRITE_REG(sc, MGB_DMAC_CMD,
1427                     MGB_DMAC_CMD_STOP(start, channel));
1428                 error = mgb_wait_for_bits(sc, MGB_DMAC_CMD,
1429                     MGB_DMAC_CMD_STOP(start, channel),
1430                     MGB_DMAC_CMD_START(start, channel));
1431                 break;
1432         }
1433         return error;
1434 }
1435
1436 static int
1437 mgb_fct_control(struct mgb_softc *sc, int reg, int channel,
1438     enum mgb_fct_cmd cmd)
1439 {
1440
1441         switch (cmd) {
1442         case FCT_RESET:
1443                 CSR_WRITE_REG(sc, reg, MGB_FCT_RESET(channel));
1444                 return mgb_wait_for_bits(sc, reg, 0, MGB_FCT_RESET(channel));
1445         case FCT_ENABLE:
1446                 CSR_WRITE_REG(sc, reg, MGB_FCT_ENBL(channel));
1447                 return (0);
1448         case FCT_DISABLE:
1449                 CSR_WRITE_REG(sc, reg, MGB_FCT_DSBL(channel));
1450                 return mgb_wait_for_bits(sc, reg, 0, MGB_FCT_ENBL(channel));
1451         }
1452 }
1453
1454 static int
1455 mgb_hw_teardown(struct mgb_softc *sc)
1456 {
1457         int err = 0;
1458
1459         /* Stop MAC */
1460         CSR_CLEAR_REG(sc, MGB_MAC_RX, MGB_MAC_ENBL);
1461         CSR_WRITE_REG(sc, MGB_MAC_TX, MGB_MAC_ENBL);
1462         if ((err = mgb_wait_for_bits(sc, MGB_MAC_RX, MGB_MAC_DSBL, 0)))
1463                 return (err);
1464         if ((err = mgb_wait_for_bits(sc, MGB_MAC_TX, MGB_MAC_DSBL, 0)))
1465                 return (err);
1466         return (err);
1467 }
1468
1469 static int
1470 mgb_hw_init(struct mgb_softc *sc)
1471 {
1472         int error = 0;
1473
1474         error = mgb_hw_reset(sc);
1475         if (error != 0)
1476                 goto fail;
1477
1478         mgb_mac_init(sc);
1479
1480         error = mgb_phy_reset(sc);
1481         if (error != 0)
1482                 goto fail;
1483
1484         error = mgb_dmac_reset(sc);
1485         if (error != 0)
1486                 goto fail;
1487
1488 fail:
1489         return error;
1490 }
1491
1492 static int
1493 mgb_hw_reset(struct mgb_softc *sc)
1494 {
1495
1496         CSR_UPDATE_REG(sc, MGB_HW_CFG, MGB_LITE_RESET);
1497         return (mgb_wait_for_bits(sc, MGB_HW_CFG, 0, MGB_LITE_RESET));
1498 }
1499
1500 static int
1501 mgb_mac_init(struct mgb_softc *sc)
1502 {
1503
1504         /**
1505          * enable automatic duplex detection and
1506          * automatic speed detection
1507          */
1508         CSR_UPDATE_REG(sc, MGB_MAC_CR, MGB_MAC_ADD_ENBL | MGB_MAC_ASD_ENBL);
1509         CSR_UPDATE_REG(sc, MGB_MAC_TX, MGB_MAC_ENBL);
1510         CSR_UPDATE_REG(sc, MGB_MAC_RX, MGB_MAC_ENBL);
1511
1512         return MGB_STS_OK;
1513 }
1514
1515 static int
1516 mgb_phy_reset(struct mgb_softc *sc)
1517 {
1518
1519         CSR_UPDATE_BYTE(sc, MGB_PMT_CTL, MGB_PHY_RESET);
1520         if (mgb_wait_for_bits(sc, MGB_PMT_CTL, 0, MGB_PHY_RESET) ==
1521             MGB_STS_TIMEOUT)
1522                 return MGB_STS_TIMEOUT;
1523         return (mgb_wait_for_bits(sc, MGB_PMT_CTL, MGB_PHY_READY, 0));
1524 }
1525
1526 static int
1527 mgb_dmac_reset(struct mgb_softc *sc)
1528 {
1529
1530         CSR_WRITE_REG(sc, MGB_DMAC_CMD, MGB_DMAC_RESET);
1531         return (mgb_wait_for_bits(sc, MGB_DMAC_CMD, 0, MGB_DMAC_RESET));
1532 }
1533
1534 static int
1535 mgb_wait_for_bits(struct mgb_softc *sc, int reg, int set_bits, int clear_bits)
1536 {
1537         int i, val;
1538
1539         i = 0;
1540         do {
1541                 /*
1542                  * XXX: Datasheets states delay should be > 5 microseconds
1543                  * for device reset.
1544                  */
1545                 DELAY(100);
1546                 val = CSR_READ_REG(sc, reg);
1547                 if ((val & set_bits) == set_bits &&
1548                     (val & clear_bits) == 0)
1549                         return MGB_STS_OK;
1550         } while (i++ < MGB_TIMEOUT);
1551
1552         return MGB_STS_TIMEOUT;
1553 }
1554
1555 static void
1556 mgb_get_ethaddr(struct mgb_softc *sc, struct ether_addr *dest)
1557 {
1558
1559         CSR_READ_REG_BYTES(sc, MGB_MAC_ADDR_BASE_L, &dest->octet[0], 4);
1560         CSR_READ_REG_BYTES(sc, MGB_MAC_ADDR_BASE_H, &dest->octet[4], 2);
1561 }
1562
1563 static int
1564 mgb_miibus_readreg(device_t dev, int phy, int reg)
1565 {
1566         struct mgb_softc *sc;
1567         int mii_access;
1568
1569         sc = iflib_get_softc(device_get_softc(dev));
1570
1571         if (mgb_wait_for_bits(sc, MGB_MII_ACCESS, 0, MGB_MII_BUSY) ==
1572             MGB_STS_TIMEOUT)
1573                 return EIO;
1574         mii_access = (phy & MGB_MII_PHY_ADDR_MASK) << MGB_MII_PHY_ADDR_SHIFT;
1575         mii_access |= (reg & MGB_MII_REG_ADDR_MASK) << MGB_MII_REG_ADDR_SHIFT;
1576         mii_access |= MGB_MII_BUSY | MGB_MII_READ;
1577         CSR_WRITE_REG(sc, MGB_MII_ACCESS, mii_access);
1578         if (mgb_wait_for_bits(sc, MGB_MII_ACCESS, 0, MGB_MII_BUSY) ==
1579             MGB_STS_TIMEOUT)
1580                 return EIO;
1581         return (CSR_READ_2_BYTES(sc, MGB_MII_DATA));
1582 }
1583
1584 static int
1585 mgb_miibus_writereg(device_t dev, int phy, int reg, int data)
1586 {
1587         struct mgb_softc *sc;
1588         int mii_access;
1589
1590         sc = iflib_get_softc(device_get_softc(dev));
1591
1592         if (mgb_wait_for_bits(sc, MGB_MII_ACCESS,
1593             0, MGB_MII_BUSY) == MGB_STS_TIMEOUT)
1594                 return EIO;
1595         mii_access = (phy & MGB_MII_PHY_ADDR_MASK) << MGB_MII_PHY_ADDR_SHIFT;
1596         mii_access |= (reg & MGB_MII_REG_ADDR_MASK) << MGB_MII_REG_ADDR_SHIFT;
1597         mii_access |= MGB_MII_BUSY | MGB_MII_WRITE;
1598         CSR_WRITE_REG(sc, MGB_MII_DATA, data);
1599         CSR_WRITE_REG(sc, MGB_MII_ACCESS, mii_access);
1600         if (mgb_wait_for_bits(sc, MGB_MII_ACCESS, 0, MGB_MII_BUSY) ==
1601             MGB_STS_TIMEOUT)
1602                 return EIO;
1603         return 0;
1604 }
1605
1606 /* XXX: May need to lock these up */
1607 static void
1608 mgb_miibus_statchg(device_t dev)
1609 {
1610         struct mgb_softc *sc;
1611         struct mii_data *miid;
1612
1613         sc = iflib_get_softc(device_get_softc(dev));
1614         miid = device_get_softc(sc->miibus);
1615         /* Update baudrate in iflib */
1616         sc->baudrate = ifmedia_baudrate(miid->mii_media_active);
1617         iflib_link_state_change(sc->ctx, sc->link_state, sc->baudrate);
1618 }
1619
1620 static void
1621 mgb_miibus_linkchg(device_t dev)
1622 {
1623         struct mgb_softc *sc;
1624         struct mii_data *miid;
1625         int link_state;
1626
1627         sc = iflib_get_softc(device_get_softc(dev));
1628         miid = device_get_softc(sc->miibus);
1629         /* XXX: copied from miibus_linkchg **/
1630         if (miid->mii_media_status & IFM_AVALID) {
1631                 if (miid->mii_media_status & IFM_ACTIVE)
1632                         link_state = LINK_STATE_UP;
1633                 else
1634                         link_state = LINK_STATE_DOWN;
1635         } else
1636                 link_state = LINK_STATE_UNKNOWN;
1637         sc->link_state = link_state;
1638         iflib_link_state_change(sc->ctx, sc->link_state, sc->baudrate);
1639 }