sys/dev/ixgbe/if_ixv.c

   1 /******************************************************************************
   2
   3   Copyright (c) 2001-2017, Intel Corporation
   4   All rights reserved.
   5
   6   Redistribution and use in source and binary forms, with or without
   7   modification, are permitted provided that the following conditions are met:
   8
   9    1. Redistributions of source code must retain the above copyright notice,
  10       this list of conditions and the following disclaimer.
  11
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    3. Neither the name of the Intel Corporation nor the names of its
  17       contributors may be used to endorse or promote products derived from
  18       this software without specific prior written permission.
  19
  20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30   POSSIBILITY OF SUCH DAMAGE.
  31
  32 ******************************************************************************/
  33 /*$FreeBSD$*/
  34
  35
  36 #include "opt_inet.h"
  37 #include "opt_inet6.h"
  38 #include "opt_rss.h"
  39
  40 #include "ixgbe.h"
  41 #include "ifdi_if.h"
  42
  43 #include <net/netmap.h>
  44 #include <dev/netmap/netmap_kern.h>
  45
  46 /************************************************************************
  47  * Driver version
  48  ************************************************************************/
  49 char ixv_driver_version[] = "2.0.1-k";
  50
  51 /************************************************************************
  52  * PCI Device ID Table
  53  *
  54  *   Used by probe to select devices to load on
  55  *   Last field stores an index into ixv_strings
  56  *   Last entry must be all 0s
  57  *
  58  *   { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
  59  ************************************************************************/
  60 static pci_vendor_info_t ixv_vendor_info_array[] =
  61 {
  62         PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, "Intel(R) X520 82599 Virtual Function"),
  63         PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, "Intel(R) X540 Virtual Function"),
  64         PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, "Intel(R) X550 Virtual Function"),
  65         PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, "Intel(R) X552 Virtual Function"),
  66         PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, "Intel(R) X553 Virtual Function"),
  67         /* required last entry */
  68 PVID_END
  69 };
  70
  71 /************************************************************************
  72  * Function prototypes
  73  ************************************************************************/
  74 static void     *ixv_register(device_t);
  75 static int      ixv_if_attach_pre(if_ctx_t);
  76 static int      ixv_if_attach_post(if_ctx_t);
  77 static int      ixv_if_detach(if_ctx_t);
  78
  79 static int      ixv_if_rx_queue_intr_enable(if_ctx_t, uint16_t);
  80 static int      ixv_if_tx_queues_alloc(if_ctx_t, caddr_t *, uint64_t *, int, int);
  81 static int      ixv_if_rx_queues_alloc(if_ctx_t, caddr_t *, uint64_t *, int, int);
  82 static void     ixv_if_queues_free(if_ctx_t);
  83 static void     ixv_identify_hardware(if_ctx_t);
  84 static void     ixv_init_device_features(struct ixgbe_softc *);
  85 static int      ixv_allocate_pci_resources(if_ctx_t);
  86 static void     ixv_free_pci_resources(if_ctx_t);
  87 static int      ixv_setup_interface(if_ctx_t);
  88 static void     ixv_if_media_status(if_ctx_t, struct ifmediareq *);
  89 static int      ixv_if_media_change(if_ctx_t);
  90 static void     ixv_if_update_admin_status(if_ctx_t);
  91 static int      ixv_if_msix_intr_assign(if_ctx_t, int);
  92
  93 static int      ixv_if_mtu_set(if_ctx_t, uint32_t);
  94 static void     ixv_if_init(if_ctx_t);
  95 static void     ixv_if_local_timer(if_ctx_t, uint16_t);
  96 static void     ixv_if_stop(if_ctx_t);
  97 static int      ixv_negotiate_api(struct ixgbe_softc *);
  98
  99 static void     ixv_initialize_transmit_units(if_ctx_t);
 100 static void     ixv_initialize_receive_units(if_ctx_t);
 101 static void     ixv_initialize_rss_mapping(struct ixgbe_softc *);
 102
 103 static void     ixv_setup_vlan_support(if_ctx_t);
 104 static void     ixv_configure_ivars(struct ixgbe_softc *);
 105 static void     ixv_if_enable_intr(if_ctx_t);
 106 static void     ixv_if_disable_intr(if_ctx_t);
 107 static void     ixv_if_multi_set(if_ctx_t);
 108
 109 static void     ixv_if_register_vlan(if_ctx_t, u16);
 110 static void     ixv_if_unregister_vlan(if_ctx_t, u16);
 111
 112 static uint64_t ixv_if_get_counter(if_ctx_t, ift_counter);
 113 static bool     ixv_if_needs_restart(if_ctx_t, enum iflib_restart_event);
 114
 115 static void     ixv_save_stats(struct ixgbe_softc *);
 116 static void     ixv_init_stats(struct ixgbe_softc *);
 117 static void     ixv_update_stats(struct ixgbe_softc *);
 118 static void     ixv_add_stats_sysctls(struct ixgbe_softc *);
 119
 120 static int      ixv_sysctl_debug(SYSCTL_HANDLER_ARGS);
 121 static void     ixv_set_ivar(struct ixgbe_softc *, u8, u8, s8);
 122
 123 static u8       *ixv_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *);
 124
 125 /* The MSI-X Interrupt handlers */
 126 static int      ixv_msix_que(void *);
 127 static int      ixv_msix_mbx(void *);
 128
 129 /************************************************************************
 130  * FreeBSD Device Interface Entry Points
 131  ************************************************************************/
 132 static device_method_t ixv_methods[] = {
 133         /* Device interface */
 134         DEVMETHOD(device_register, ixv_register),
 135         DEVMETHOD(device_probe, iflib_device_probe),
 136         DEVMETHOD(device_attach, iflib_device_attach),
 137         DEVMETHOD(device_detach, iflib_device_detach),
 138         DEVMETHOD(device_shutdown, iflib_device_shutdown),
 139         DEVMETHOD_END
 140 };
 141
 142 static driver_t ixv_driver = {
 143         "ixv", ixv_methods, sizeof(struct ixgbe_softc),
 144 };
 145
 146 devclass_t ixv_devclass;
 147 DRIVER_MODULE(ixv, pci, ixv_driver, ixv_devclass, 0, 0);
 148 IFLIB_PNP_INFO(pci, ixv_driver, ixv_vendor_info_array);
 149 MODULE_DEPEND(ixv, iflib, 1, 1, 1);
 150 MODULE_DEPEND(ixv, pci, 1, 1, 1);
 151 MODULE_DEPEND(ixv, ether, 1, 1, 1);
 152
 153 static device_method_t ixv_if_methods[] = {
 154         DEVMETHOD(ifdi_attach_pre, ixv_if_attach_pre),
 155         DEVMETHOD(ifdi_attach_post, ixv_if_attach_post),
 156         DEVMETHOD(ifdi_detach, ixv_if_detach),
 157         DEVMETHOD(ifdi_init, ixv_if_init),
 158         DEVMETHOD(ifdi_stop, ixv_if_stop),
 159         DEVMETHOD(ifdi_msix_intr_assign, ixv_if_msix_intr_assign),
 160         DEVMETHOD(ifdi_intr_enable, ixv_if_enable_intr),
 161         DEVMETHOD(ifdi_intr_disable, ixv_if_disable_intr),
 162         DEVMETHOD(ifdi_tx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
 163         DEVMETHOD(ifdi_rx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
 164         DEVMETHOD(ifdi_tx_queues_alloc, ixv_if_tx_queues_alloc),
 165         DEVMETHOD(ifdi_rx_queues_alloc, ixv_if_rx_queues_alloc),
 166         DEVMETHOD(ifdi_queues_free, ixv_if_queues_free),
 167         DEVMETHOD(ifdi_update_admin_status, ixv_if_update_admin_status),
 168         DEVMETHOD(ifdi_multi_set, ixv_if_multi_set),
 169         DEVMETHOD(ifdi_mtu_set, ixv_if_mtu_set),
 170         DEVMETHOD(ifdi_media_status, ixv_if_media_status),
 171         DEVMETHOD(ifdi_media_change, ixv_if_media_change),
 172         DEVMETHOD(ifdi_timer, ixv_if_local_timer),
 173         DEVMETHOD(ifdi_vlan_register, ixv_if_register_vlan),
 174         DEVMETHOD(ifdi_vlan_unregister, ixv_if_unregister_vlan),
 175         DEVMETHOD(ifdi_get_counter, ixv_if_get_counter),
 176         DEVMETHOD(ifdi_needs_restart, ixv_if_needs_restart),
 177         DEVMETHOD_END
 178 };
 179
 180 static driver_t ixv_if_driver = {
 181   "ixv_if", ixv_if_methods, sizeof(struct ixgbe_softc)
 182 };
 183
 184 /*
 185  * TUNEABLE PARAMETERS:
 186  */
 187
 188 /* Flow control setting, default to full */
 189 static int ixv_flow_control = ixgbe_fc_full;
 190 TUNABLE_INT("hw.ixv.flow_control", &ixv_flow_control);
 191
 192 /*
 193  * Header split: this causes the hardware to DMA
 194  * the header into a separate mbuf from the payload,
 195  * it can be a performance win in some workloads, but
 196  * in others it actually hurts, its off by default.
 197  */
 198 static int ixv_header_split = false;
 199 TUNABLE_INT("hw.ixv.hdr_split", &ixv_header_split);
 200
 201 /*
 202  * Shadow VFTA table, this is needed because
 203  * the real filter table gets cleared during
 204  * a soft reset and we need to repopulate it.
 205  */
 206 static u32 ixv_shadow_vfta[IXGBE_VFTA_SIZE];
 207 extern struct if_txrx ixgbe_txrx;
 208
 209 static struct if_shared_ctx ixv_sctx_init = {
 210         .isc_magic = IFLIB_MAGIC,
 211         .isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */
 212         .isc_tx_maxsize = IXGBE_TSO_SIZE + sizeof(struct ether_vlan_header),
 213         .isc_tx_maxsegsize = PAGE_SIZE,
 214         .isc_tso_maxsize = IXGBE_TSO_SIZE + sizeof(struct ether_vlan_header),
 215         .isc_tso_maxsegsize = PAGE_SIZE,
 216         .isc_rx_maxsize = MJUM16BYTES,
 217         .isc_rx_nsegments = 1,
 218         .isc_rx_maxsegsize = MJUM16BYTES,
 219         .isc_nfl = 1,
 220         .isc_ntxqs = 1,
 221         .isc_nrxqs = 1,
 222         .isc_admin_intrcnt = 1,
 223         .isc_vendor_info = ixv_vendor_info_array,
 224         .isc_driver_version = ixv_driver_version,
 225         .isc_driver = &ixv_if_driver,
 226         .isc_flags = IFLIB_IS_VF | IFLIB_TSO_INIT_IP,
 227
 228         .isc_nrxd_min = {MIN_RXD},
 229         .isc_ntxd_min = {MIN_TXD},
 230         .isc_nrxd_max = {MAX_RXD},
 231         .isc_ntxd_max = {MAX_TXD},
 232         .isc_nrxd_default = {DEFAULT_RXD},
 233         .isc_ntxd_default = {DEFAULT_TXD},
 234 };
 235
 236 static void *
 237 ixv_register(device_t dev)
 238 {
 239         return (&ixv_sctx_init);
 240 }
 241
 242 /************************************************************************
 243  * ixv_if_tx_queues_alloc
 244  ************************************************************************/
 245 static int
 246 ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs,
 247     int ntxqs, int ntxqsets)
 248 {
 249         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 250         if_softc_ctx_t     scctx = sc->shared;
 251         struct ix_tx_queue *que;
 252         int                i, j, error;
 253
 254         MPASS(sc->num_tx_queues == ntxqsets);
 255         MPASS(ntxqs == 1);
 256
 257         /* Allocate queue structure memory */
 258         sc->tx_queues =
 259             (struct ix_tx_queue *)malloc(sizeof(struct ix_tx_queue) * ntxqsets,
 260                                          M_DEVBUF, M_NOWAIT | M_ZERO);
 261         if (!sc->tx_queues) {
 262                 device_printf(iflib_get_dev(ctx),
 263                     "Unable to allocate TX ring memory\n");
 264                 return (ENOMEM);
 265         }
 266
 267         for (i = 0, que = sc->tx_queues; i < ntxqsets; i++, que++) {
 268                 struct tx_ring *txr = &que->txr;
 269
 270                 txr->me = i;
 271                 txr->sc =  que->sc = sc;
 272
 273                 /* Allocate report status array */
 274                 if (!(txr->tx_rsq = (qidx_t *)malloc(sizeof(qidx_t) * scctx->isc_ntxd[0], M_DEVBUF, M_NOWAIT | M_ZERO))) {
 275                         error = ENOMEM;
 276                         goto fail;
 277                 }
 278                 for (j = 0; j < scctx->isc_ntxd[0]; j++)
 279                         txr->tx_rsq[j] = QIDX_INVALID;
 280                 /* get the virtual and physical address of the hardware queues */
 281                 txr->tail = IXGBE_VFTDT(txr->me);
 282                 txr->tx_base = (union ixgbe_adv_tx_desc *)vaddrs[i*ntxqs];
 283                 txr->tx_paddr = paddrs[i*ntxqs];
 284
 285                 txr->bytes = 0;
 286                 txr->total_packets = 0;
 287
 288         }
 289
 290         device_printf(iflib_get_dev(ctx), "allocated for %d queues\n",
 291             sc->num_tx_queues);
 292
 293         return (0);
 294
 295  fail:
 296         ixv_if_queues_free(ctx);
 297
 298         return (error);
 299 } /* ixv_if_tx_queues_alloc */
 300
 301 /************************************************************************
 302  * ixv_if_rx_queues_alloc
 303  ************************************************************************/
 304 static int
 305 ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs,
 306     int nrxqs, int nrxqsets)
 307 {
 308         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 309         struct ix_rx_queue *que;
 310         int                i, error;
 311
 312         MPASS(sc->num_rx_queues == nrxqsets);
 313         MPASS(nrxqs == 1);
 314
 315         /* Allocate queue structure memory */
 316         sc->rx_queues =
 317             (struct ix_rx_queue *)malloc(sizeof(struct ix_rx_queue) * nrxqsets,
 318                                          M_DEVBUF, M_NOWAIT | M_ZERO);
 319         if (!sc->rx_queues) {
 320                 device_printf(iflib_get_dev(ctx),
 321                     "Unable to allocate TX ring memory\n");
 322                 error = ENOMEM;
 323                 goto fail;
 324         }
 325
 326         for (i = 0, que = sc->rx_queues; i < nrxqsets; i++, que++) {
 327                 struct rx_ring *rxr = &que->rxr;
 328                 rxr->me = i;
 329                 rxr->sc = que->sc = sc;
 330
 331
 332                 /* get the virtual and physical address of the hw queues */
 333                 rxr->tail = IXGBE_VFRDT(rxr->me);
 334                 rxr->rx_base = (union ixgbe_adv_rx_desc *)vaddrs[i];
 335                 rxr->rx_paddr = paddrs[i*nrxqs];
 336                 rxr->bytes = 0;
 337                 rxr->que = que;
 338         }
 339
 340         device_printf(iflib_get_dev(ctx), "allocated for %d rx queues\n",
 341             sc->num_rx_queues);
 342
 343         return (0);
 344
 345 fail:
 346         ixv_if_queues_free(ctx);
 347
 348         return (error);
 349 } /* ixv_if_rx_queues_alloc */
 350
 351 /************************************************************************
 352  * ixv_if_queues_free
 353  ************************************************************************/
 354 static void
 355 ixv_if_queues_free(if_ctx_t ctx)
 356 {
 357         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 358         struct ix_tx_queue *que = sc->tx_queues;
 359         int                i;
 360
 361         if (que == NULL)
 362                 goto free;
 363
 364         for (i = 0; i < sc->num_tx_queues; i++, que++) {
 365                 struct tx_ring *txr = &que->txr;
 366                 if (txr->tx_rsq == NULL)
 367                         break;
 368
 369                 free(txr->tx_rsq, M_DEVBUF);
 370                 txr->tx_rsq = NULL;
 371         }
 372         if (sc->tx_queues != NULL)
 373                 free(sc->tx_queues, M_DEVBUF);
 374 free:
 375         if (sc->rx_queues != NULL)
 376                 free(sc->rx_queues, M_DEVBUF);
 377         sc->tx_queues = NULL;
 378         sc->rx_queues = NULL;
 379 } /* ixv_if_queues_free */
 380
 381 /************************************************************************
 382  * ixv_if_attach_pre - Device initialization routine
 383  *
 384  *   Called when the driver is being loaded.
 385  *   Identifies the type of hardware, allocates all resources
 386  *   and initializes the hardware.
 387  *
 388  *   return 0 on success, positive on failure
 389  ************************************************************************/
 390 static int
 391 ixv_if_attach_pre(if_ctx_t ctx)
 392 {
 393         struct ixgbe_softc  *sc;
 394         device_t        dev;
 395         if_softc_ctx_t  scctx;
 396         struct ixgbe_hw *hw;
 397         int             error = 0;
 398
 399         INIT_DEBUGOUT("ixv_attach: begin");
 400
 401         /* Allocate, clear, and link in our sc structure */
 402         dev = iflib_get_dev(ctx);
 403         sc = iflib_get_softc(ctx);
 404         sc->dev = dev;
 405         sc->ctx = ctx;
 406         sc->hw.back = sc;
 407         scctx = sc->shared = iflib_get_softc_ctx(ctx);
 408         sc->media = iflib_get_media(ctx);
 409         hw = &sc->hw;
 410
 411         /* Do base PCI setup - map BAR0 */
 412         if (ixv_allocate_pci_resources(ctx)) {
 413                 device_printf(dev, "ixv_allocate_pci_resources() failed!\n");
 414                 error = ENXIO;
 415                 goto err_out;
 416         }
 417
 418         /* SYSCTL APIs */
 419         SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
 420             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "debug",
 421             CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
 422             sc, 0, ixv_sysctl_debug, "I", "Debug Info");
 423
 424         /* Determine hardware revision */
 425         ixv_identify_hardware(ctx);
 426         ixv_init_device_features(sc);
 427
 428         /* Initialize the shared code */
 429         error = ixgbe_init_ops_vf(hw);
 430         if (error) {
 431                 device_printf(dev, "ixgbe_init_ops_vf() failed!\n");
 432                 error = EIO;
 433                 goto err_out;
 434         }
 435
 436         /* Setup the mailbox */
 437         ixgbe_init_mbx_params_vf(hw);
 438
 439         error = hw->mac.ops.reset_hw(hw);
 440         if (error == IXGBE_ERR_RESET_FAILED)
 441                 device_printf(dev, "...reset_hw() failure: Reset Failed!\n");
 442         else if (error)
 443                 device_printf(dev, "...reset_hw() failed with error %d\n",
 444                     error);
 445         if (error) {
 446                 error = EIO;
 447                 goto err_out;
 448         }
 449
 450         error = hw->mac.ops.init_hw(hw);
 451         if (error) {
 452                 device_printf(dev, "...init_hw() failed with error %d\n",
 453                     error);
 454                 error = EIO;
 455                 goto err_out;
 456         }
 457
 458         /* Negotiate mailbox API version */
 459         error = ixv_negotiate_api(sc);
 460         if (error) {
 461                 device_printf(dev,
 462                     "Mailbox API negotiation failed during attach!\n");
 463                 goto err_out;
 464         }
 465
 466         /* If no mac address was assigned, make a random one */
 467         if (!ixv_check_ether_addr(hw->mac.addr)) {
 468                 ether_gen_addr(iflib_get_ifp(ctx),
 469                     (struct ether_addr *)hw->mac.addr);
 470                 bcopy(hw->mac.addr, hw->mac.perm_addr,
 471                     sizeof(hw->mac.perm_addr));
 472         }
 473
 474         /* Most of the iflib initialization... */
 475
 476         iflib_set_mac(ctx, hw->mac.addr);
 477         switch (sc->hw.mac.type) {
 478         case ixgbe_mac_X550_vf:
 479         case ixgbe_mac_X550EM_x_vf:
 480         case ixgbe_mac_X550EM_a_vf:
 481                 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 2;
 482                 break;
 483         default:
 484                 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 1;
 485         }
 486         scctx->isc_txqsizes[0] =
 487             roundup2(scctx->isc_ntxd[0] * sizeof(union ixgbe_adv_tx_desc) +
 488             sizeof(u32), DBA_ALIGN);
 489         scctx->isc_rxqsizes[0] =
 490             roundup2(scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc),
 491             DBA_ALIGN);
 492         /* XXX */
 493         scctx->isc_tx_csum_flags = CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_TSO |
 494             CSUM_IP6_TCP | CSUM_IP6_UDP | CSUM_IP6_TSO;
 495         scctx->isc_tx_nsegments = IXGBE_82599_SCATTER;
 496         scctx->isc_msix_bar = pci_msix_table_bar(dev);
 497         scctx->isc_tx_tso_segments_max = scctx->isc_tx_nsegments;
 498         scctx->isc_tx_tso_size_max = IXGBE_TSO_SIZE;
 499         scctx->isc_tx_tso_segsize_max = PAGE_SIZE;
 500
 501         scctx->isc_txrx = &ixgbe_txrx;
 502
 503         /*
 504          * Tell the upper layer(s) we support everything the PF
 505          * driver does except...
 506          *   Wake-on-LAN
 507          */
 508         scctx->isc_capabilities = IXGBE_CAPS;
 509         scctx->isc_capabilities ^= IFCAP_WOL;
 510         scctx->isc_capenable = scctx->isc_capabilities;
 511
 512         INIT_DEBUGOUT("ixv_if_attach_pre: end");
 513
 514         return (0);
 515
 516 err_out:
 517         ixv_free_pci_resources(ctx);
 518
 519         return (error);
 520 } /* ixv_if_attach_pre */
 521
 522 static int
 523 ixv_if_attach_post(if_ctx_t ctx)
 524 {
 525         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 526         device_t       dev = iflib_get_dev(ctx);
 527         int            error = 0;
 528
 529         /* Setup OS specific network interface */
 530         error = ixv_setup_interface(ctx);
 531         if (error) {
 532                 device_printf(dev, "Interface setup failed: %d\n", error);
 533                 goto end;
 534         }
 535
 536         /* Do the stats setup */
 537         ixv_save_stats(sc);
 538         ixv_init_stats(sc);
 539         ixv_add_stats_sysctls(sc);
 540
 541 end:
 542         return error;
 543 } /* ixv_if_attach_post */
 544
 545 /************************************************************************
 546  * ixv_detach - Device removal routine
 547  *
 548  *   Called when the driver is being removed.
 549  *   Stops the adapter and deallocates all the resources
 550  *   that were allocated for driver operation.
 551  *
 552  *   return 0 on success, positive on failure
 553  ************************************************************************/
 554 static int
 555 ixv_if_detach(if_ctx_t ctx)
 556 {
 557         INIT_DEBUGOUT("ixv_detach: begin");
 558
 559         ixv_free_pci_resources(ctx);
 560
 561         return (0);
 562 } /* ixv_if_detach */
 563
 564 /************************************************************************
 565  * ixv_if_mtu_set
 566  ************************************************************************/
 567 static int
 568 ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
 569 {
 570         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 571         struct ifnet   *ifp = iflib_get_ifp(ctx);
 572         int            error = 0;
 573
 574         IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
 575         if (mtu > IXGBE_MAX_FRAME_SIZE - IXGBE_MTU_HDR) {
 576                 error = EINVAL;
 577         } else {
 578                 ifp->if_mtu = mtu;
 579                 sc->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
 580         }
 581
 582         return error;
 583 } /* ixv_if_mtu_set */
 584
 585 /************************************************************************
 586  * ixv_if_init - Init entry point
 587  *
 588  *   Used in two ways: It is used by the stack as an init entry
 589  *   point in network interface structure. It is also used
 590  *   by the driver as a hw/sw initialization routine to get
 591  *   to a consistent state.
 592  *
 593  *   return 0 on success, positive on failure
 594  ************************************************************************/
 595 static void
 596 ixv_if_init(if_ctx_t ctx)
 597 {
 598         struct ixgbe_softc  *sc = iflib_get_softc(ctx);
 599         struct ifnet    *ifp = iflib_get_ifp(ctx);
 600         device_t        dev = iflib_get_dev(ctx);
 601         struct ixgbe_hw *hw = &sc->hw;
 602         int             error = 0;
 603
 604         INIT_DEBUGOUT("ixv_if_init: begin");
 605         hw->adapter_stopped = false;
 606         hw->mac.ops.stop_adapter(hw);
 607
 608         /* reprogram the RAR[0] in case user changed it. */
 609         hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
 610
 611         /* Get the latest mac address, User can use a LAA */
 612         bcopy(IF_LLADDR(ifp), hw->mac.addr, IXGBE_ETH_LENGTH_OF_ADDRESS);
 613         hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1);
 614
 615         /* Reset VF and renegotiate mailbox API version */
 616         hw->mac.ops.reset_hw(hw);
 617         hw->mac.ops.start_hw(hw);
 618         error = ixv_negotiate_api(sc);
 619         if (error) {
 620                 device_printf(dev,
 621                     "Mailbox API negotiation failed in if_init!\n");
 622                 return;
 623         }
 624
 625         ixv_initialize_transmit_units(ctx);
 626
 627         /* Setup Multicast table */
 628         ixv_if_multi_set(ctx);
 629
 630         sc->rx_mbuf_sz = iflib_get_rx_mbuf_sz(ctx);
 631
 632         /* Configure RX settings */
 633         ixv_initialize_receive_units(ctx);
 634
 635         /* Set up VLAN offload and filter */
 636         ixv_setup_vlan_support(ctx);
 637
 638         /* Set up MSI-X routing */
 639         ixv_configure_ivars(sc);
 640
 641         /* Set up auto-mask */
 642         IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, IXGBE_EICS_RTX_QUEUE);
 643
 644         /* Set moderation on the Link interrupt */
 645         IXGBE_WRITE_REG(hw, IXGBE_VTEITR(sc->vector), IXGBE_LINK_ITR);
 646
 647         /* Stats init */
 648         ixv_init_stats(sc);
 649
 650         /* Config/Enable Link */
 651         hw->mac.ops.check_link(hw, &sc->link_speed, &sc->link_up,
 652             false);
 653
 654         /* And now turn on interrupts */
 655         ixv_if_enable_intr(ctx);
 656
 657         return;
 658 } /* ixv_if_init */
 659
 660 /************************************************************************
 661  * ixv_enable_queue
 662  ************************************************************************/
 663 static inline void
 664 ixv_enable_queue(struct ixgbe_softc *sc, u32 vector)
 665 {
 666         struct ixgbe_hw *hw = &sc->hw;
 667         u32             queue = 1 << vector;
 668         u32             mask;
 669
 670         mask = (IXGBE_EIMS_RTX_QUEUE & queue);
 671         IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);
 672 } /* ixv_enable_queue */
 673
 674 /************************************************************************
 675  * ixv_disable_queue
 676  ************************************************************************/
 677 static inline void
 678 ixv_disable_queue(struct ixgbe_softc *sc, u32 vector)
 679 {
 680         struct ixgbe_hw *hw = &sc->hw;
 681         u64             queue = (u64)(1 << vector);
 682         u32             mask;
 683
 684         mask = (IXGBE_EIMS_RTX_QUEUE & queue);
 685         IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask);
 686 } /* ixv_disable_queue */
 687
 688
 689 /************************************************************************
 690  * ixv_msix_que - MSI-X Queue Interrupt Service routine
 691  ************************************************************************/
 692 static int
 693 ixv_msix_que(void *arg)
 694 {
 695         struct ix_rx_queue *que = arg;
 696         struct ixgbe_softc     *sc = que->sc;
 697
 698         ixv_disable_queue(sc, que->msix);
 699         ++que->irqs;
 700
 701         return (FILTER_SCHEDULE_THREAD);
 702 } /* ixv_msix_que */
 703
 704 /************************************************************************
 705  * ixv_msix_mbx
 706  ************************************************************************/
 707 static int
 708 ixv_msix_mbx(void *arg)
 709 {
 710         struct ixgbe_softc  *sc = arg;
 711         struct ixgbe_hw *hw = &sc->hw;
 712         u32             reg;
 713
 714         ++sc->link_irq;
 715
 716         /* First get the cause */
 717         reg = IXGBE_READ_REG(hw, IXGBE_VTEICS);
 718         /* Clear interrupt with write */
 719         IXGBE_WRITE_REG(hw, IXGBE_VTEICR, reg);
 720
 721         /* Link status change */
 722         if (reg & IXGBE_EICR_LSC)
 723                 iflib_admin_intr_deferred(sc->ctx);
 724
 725         IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, IXGBE_EIMS_OTHER);
 726
 727         return (FILTER_HANDLED);
 728 } /* ixv_msix_mbx */
 729
 730 /************************************************************************
 731  * ixv_media_status - Media Ioctl callback
 732  *
 733  *   Called whenever the user queries the status of
 734  *   the interface using ifconfig.
 735  ************************************************************************/
 736 static void
 737 ixv_if_media_status(if_ctx_t ctx, struct ifmediareq * ifmr)
 738 {
 739         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 740
 741         INIT_DEBUGOUT("ixv_media_status: begin");
 742
 743         iflib_admin_intr_deferred(ctx);
 744
 745         ifmr->ifm_status = IFM_AVALID;
 746         ifmr->ifm_active = IFM_ETHER;
 747
 748         if (!sc->link_active)
 749                 return;
 750
 751         ifmr->ifm_status |= IFM_ACTIVE;
 752
 753         switch (sc->link_speed) {
 754                 case IXGBE_LINK_SPEED_1GB_FULL:
 755                         ifmr->ifm_active |= IFM_1000_T | IFM_FDX;
 756                         break;
 757                 case IXGBE_LINK_SPEED_10GB_FULL:
 758                         ifmr->ifm_active |= IFM_10G_T | IFM_FDX;
 759                         break;
 760                 case IXGBE_LINK_SPEED_100_FULL:
 761                         ifmr->ifm_active |= IFM_100_TX | IFM_FDX;
 762                         break;
 763                 case IXGBE_LINK_SPEED_10_FULL:
 764                         ifmr->ifm_active |= IFM_10_T | IFM_FDX;
 765                         break;
 766         }
 767 } /* ixv_if_media_status */
 768
 769 /************************************************************************
 770  * ixv_if_media_change - Media Ioctl callback
 771  *
 772  *   Called when the user changes speed/duplex using
 773  *   media/mediopt option with ifconfig.
 774  ************************************************************************/
 775 static int
 776 ixv_if_media_change(if_ctx_t ctx)
 777 {
 778         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 779         struct ifmedia *ifm = iflib_get_media(ctx);
 780
 781         INIT_DEBUGOUT("ixv_media_change: begin");
 782
 783         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
 784                 return (EINVAL);
 785
 786         switch (IFM_SUBTYPE(ifm->ifm_media)) {
 787         case IFM_AUTO:
 788                 break;
 789         default:
 790                 device_printf(sc->dev, "Only auto media type\n");
 791                 return (EINVAL);
 792         }
 793
 794         return (0);
 795 } /* ixv_if_media_change */
 796
 797
 798 /************************************************************************
 799  * ixv_negotiate_api
 800  *
 801  *   Negotiate the Mailbox API with the PF;
 802  *   start with the most featured API first.
 803  ************************************************************************/
 804 static int
 805 ixv_negotiate_api(struct ixgbe_softc *sc)
 806 {
 807         struct ixgbe_hw *hw = &sc->hw;
 808         int             mbx_api[] = { ixgbe_mbox_api_11,
 809                                       ixgbe_mbox_api_10,
 810                                       ixgbe_mbox_api_unknown };
 811         int             i = 0;
 812
 813         while (mbx_api[i] != ixgbe_mbox_api_unknown) {
 814                 if (ixgbevf_negotiate_api_version(hw, mbx_api[i]) == 0)
 815                         return (0);
 816                 i++;
 817         }
 818
 819         return (EINVAL);
 820 } /* ixv_negotiate_api */
 821
 822
 823 /************************************************************************
 824  * ixv_if_multi_set - Multicast Update
 825  *
 826  *   Called whenever multicast address list is updated.
 827  ************************************************************************/
 828 static void
 829 ixv_if_multi_set(if_ctx_t ctx)
 830 {
 831         u8       mta[MAX_NUM_MULTICAST_ADDRESSES * IXGBE_ETH_LENGTH_OF_ADDRESS];
 832         struct ixgbe_softc     *sc = iflib_get_softc(ctx);
 833         u8                 *update_ptr;
 834         struct ifmultiaddr *ifma;
 835         if_t               ifp = iflib_get_ifp(ctx);
 836         int                mcnt = 0;
 837
 838         IOCTL_DEBUGOUT("ixv_if_multi_set: begin");
 839
 840         CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 841                 if (ifma->ifma_addr->sa_family != AF_LINK)
 842                         continue;
 843                 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
 844                     &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS],
 845                     IXGBE_ETH_LENGTH_OF_ADDRESS);
 846                 mcnt++;
 847         }
 848
 849         update_ptr = mta;
 850
 851         sc->hw.mac.ops.update_mc_addr_list(&sc->hw, update_ptr, mcnt,
 852             ixv_mc_array_itr, true);
 853 } /* ixv_if_multi_set */
 854
 855 /************************************************************************
 856  * ixv_mc_array_itr
 857  *
 858  *   An iterator function needed by the multicast shared code.
 859  *   It feeds the shared code routine the addresses in the
 860  *   array of ixv_set_multi() one by one.
 861  ************************************************************************/
 862 static u8 *
 863 ixv_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq)
 864 {
 865         u8 *addr = *update_ptr;
 866         u8 *newptr;
 867
 868         *vmdq = 0;
 869
 870         newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS;
 871         *update_ptr = newptr;
 872
 873         return addr;
 874 } /* ixv_mc_array_itr */
 875
 876 /************************************************************************
 877  * ixv_if_local_timer - Timer routine
 878  *
 879  *   Checks for link status, updates statistics,
 880  *   and runs the watchdog check.
 881  ************************************************************************/
 882 static void
 883 ixv_if_local_timer(if_ctx_t ctx, uint16_t qid)
 884 {
 885         if (qid != 0)
 886                 return;
 887
 888         /* Fire off the adminq task */
 889         iflib_admin_intr_deferred(ctx);
 890 } /* ixv_if_local_timer */
 891
 892 /************************************************************************
 893  * ixv_if_update_admin_status - Update OS on link state
 894  *
 895  * Note: Only updates the OS on the cached link state.
 896  *       The real check of the hardware only happens with
 897  *       a link interrupt.
 898  ************************************************************************/
 899 static void
 900 ixv_if_update_admin_status(if_ctx_t ctx)
 901 {
 902         struct ixgbe_softc *sc = iflib_get_softc(ctx);
 903         device_t       dev = iflib_get_dev(ctx);
 904         s32            status;
 905
 906         sc->hw.mac.get_link_status = true;
 907
 908         status = ixgbe_check_link(&sc->hw, &sc->link_speed,
 909             &sc->link_up, false);
 910
 911         if (status != IXGBE_SUCCESS && sc->hw.adapter_stopped == false) {
 912                 /* Mailbox's Clear To Send status is lost or timeout occurred.
 913                  * We need reinitialization. */
 914                 iflib_get_ifp(ctx)->if_init(ctx);
 915         }
 916
 917         if (sc->link_up) {
 918                 if (sc->link_active == false) {
 919                         if (bootverbose)
 920                                 device_printf(dev, "Link is up %d Gbps %s \n",
 921                                     ((sc->link_speed == 128) ? 10 : 1),
 922                                     "Full Duplex");
 923                         sc->link_active = true;
 924                         iflib_link_state_change(ctx, LINK_STATE_UP,
 925                             IF_Gbps(10));
 926                 }
 927         } else { /* Link down */
 928                 if (sc->link_active == true) {
 929                         if (bootverbose)
 930                                 device_printf(dev, "Link is Down\n");
 931                         iflib_link_state_change(ctx, LINK_STATE_DOWN,  0);
 932                         sc->link_active = false;
 933                 }
 934         }
 935
 936         /* Stats Update */
 937         ixv_update_stats(sc);
 938 } /* ixv_if_update_admin_status */
 939
 940
 941 /************************************************************************
 942  * ixv_if_stop - Stop the hardware
 943  *
 944  *   Disables all traffic on the adapter by issuing a
 945  *   global reset on the MAC and deallocates TX/RX buffers.
 946  ************************************************************************/
 947 static void
 948 ixv_if_stop(if_ctx_t ctx)
 949 {
 950         struct ixgbe_softc  *sc = iflib_get_softc(ctx);
 951         struct ixgbe_hw *hw = &sc->hw;
 952
 953         INIT_DEBUGOUT("ixv_stop: begin\n");
 954
 955         ixv_if_disable_intr(ctx);
 956
 957         hw->mac.ops.reset_hw(hw);
 958         sc->hw.adapter_stopped = false;
 959         hw->mac.ops.stop_adapter(hw);
 960
 961         /* Update the stack */
 962         sc->link_up = false;
 963         ixv_if_update_admin_status(ctx);
 964
 965         /* reprogram the RAR[0] in case user changed it. */
 966         hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
 967 } /* ixv_if_stop */
 968
 969
 970 /************************************************************************
 971  * ixv_identify_hardware - Determine hardware revision.
 972  ************************************************************************/
 973 static void
 974 ixv_identify_hardware(if_ctx_t ctx)
 975 {
 976         struct ixgbe_softc  *sc = iflib_get_softc(ctx);
 977         device_t        dev = iflib_get_dev(ctx);
 978         struct ixgbe_hw *hw = &sc->hw;
 979
 980         /* Save off the information about this board */
 981         hw->vendor_id = pci_get_vendor(dev);
 982         hw->device_id = pci_get_device(dev);
 983         hw->revision_id = pci_get_revid(dev);
 984         hw->subsystem_vendor_id = pci_get_subvendor(dev);
 985         hw->subsystem_device_id = pci_get_subdevice(dev);
 986
 987         /* A subset of set_mac_type */
 988         switch (hw->device_id) {
 989         case IXGBE_DEV_ID_82599_VF:
 990                 hw->mac.type = ixgbe_mac_82599_vf;
 991                 break;
 992         case IXGBE_DEV_ID_X540_VF:
 993                 hw->mac.type = ixgbe_mac_X540_vf;
 994                 break;
 995         case IXGBE_DEV_ID_X550_VF:
 996                 hw->mac.type = ixgbe_mac_X550_vf;
 997                 break;
 998         case IXGBE_DEV_ID_X550EM_X_VF:
 999                 hw->mac.type = ixgbe_mac_X550EM_x_vf;
1000                 break;
1001         case IXGBE_DEV_ID_X550EM_A_VF:
1002                 hw->mac.type = ixgbe_mac_X550EM_a_vf;
1003                 break;
1004         default:
1005                 device_printf(dev, "unknown mac type\n");
1006                 hw->mac.type = ixgbe_mac_unknown;
1007                 break;
1008         }
1009 } /* ixv_identify_hardware */
1010
1011 /************************************************************************
1012  * ixv_if_msix_intr_assign - Setup MSI-X Interrupt resources and handlers
1013  ************************************************************************/
1014 static int
1015 ixv_if_msix_intr_assign(if_ctx_t ctx, int msix)
1016 {
1017         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1018         device_t           dev = iflib_get_dev(ctx);
1019         struct ix_rx_queue *rx_que = sc->rx_queues;
1020         struct ix_tx_queue *tx_que;
1021         int                error, rid, vector = 0;
1022         char               buf[16];
1023
1024         for (int i = 0; i < sc->num_rx_queues; i++, vector++, rx_que++) {
1025                 rid = vector + 1;
1026
1027                 snprintf(buf, sizeof(buf), "rxq%d", i);
1028                 error = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
1029                     IFLIB_INTR_RXTX, ixv_msix_que, rx_que, rx_que->rxr.me, buf);
1030
1031                 if (error) {
1032                         device_printf(iflib_get_dev(ctx),
1033                             "Failed to allocate que int %d err: %d", i, error);
1034                         sc->num_rx_queues = i + 1;
1035                         goto fail;
1036                 }
1037
1038                 rx_que->msix = vector;
1039         }
1040
1041         for (int i = 0; i < sc->num_tx_queues; i++) {
1042                 snprintf(buf, sizeof(buf), "txq%d", i);
1043                 tx_que = &sc->tx_queues[i];
1044                 tx_que->msix = i % sc->num_rx_queues;
1045                 iflib_softirq_alloc_generic(ctx,
1046                     &sc->rx_queues[tx_que->msix].que_irq,
1047                     IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
1048         }
1049         rid = vector + 1;
1050         error = iflib_irq_alloc_generic(ctx, &sc->irq, rid,
1051             IFLIB_INTR_ADMIN, ixv_msix_mbx, sc, 0, "aq");
1052         if (error) {
1053                 device_printf(iflib_get_dev(ctx),
1054                     "Failed to register admin handler");
1055                 return (error);
1056         }
1057
1058         sc->vector = vector;
1059         /*
1060          * Due to a broken design QEMU will fail to properly
1061          * enable the guest for MSIX unless the vectors in
1062          * the table are all set up, so we must rewrite the
1063          * ENABLE in the MSIX control register again at this
1064          * point to cause it to successfully initialize us.
1065          */
1066         if (sc->hw.mac.type == ixgbe_mac_82599_vf) {
1067                 int msix_ctrl;
1068                 pci_find_cap(dev, PCIY_MSIX, &rid);
1069                 rid += PCIR_MSIX_CTRL;
1070                 msix_ctrl = pci_read_config(dev, rid, 2);
1071                 msix_ctrl |= PCIM_MSIXCTRL_MSIX_ENABLE;
1072                 pci_write_config(dev, rid, msix_ctrl, 2);
1073         }
1074
1075         return (0);
1076
1077 fail:
1078         iflib_irq_free(ctx, &sc->irq);
1079         rx_que = sc->rx_queues;
1080         for (int i = 0; i < sc->num_rx_queues; i++, rx_que++)
1081                 iflib_irq_free(ctx, &rx_que->que_irq);
1082
1083         return (error);
1084 } /* ixv_if_msix_intr_assign */
1085
1086 /************************************************************************
1087  * ixv_allocate_pci_resources
1088  ************************************************************************/
1089 static int
1090 ixv_allocate_pci_resources(if_ctx_t ctx)
1091 {
1092         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1093         device_t       dev = iflib_get_dev(ctx);
1094         int            rid;
1095
1096         rid = PCIR_BAR(0);
1097         sc->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
1098             RF_ACTIVE);
1099
1100         if (!(sc->pci_mem)) {
1101                 device_printf(dev, "Unable to allocate bus resource: memory\n");
1102                 return (ENXIO);
1103         }
1104
1105         sc->osdep.mem_bus_space_tag = rman_get_bustag(sc->pci_mem);
1106         sc->osdep.mem_bus_space_handle =
1107             rman_get_bushandle(sc->pci_mem);
1108         sc->hw.hw_addr = (u8 *)&sc->osdep.mem_bus_space_handle;
1109
1110         return (0);
1111 } /* ixv_allocate_pci_resources */
1112
1113 /************************************************************************
1114  * ixv_free_pci_resources
1115  ************************************************************************/
1116 static void
1117 ixv_free_pci_resources(if_ctx_t ctx)
1118 {
1119         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1120         struct ix_rx_queue *que = sc->rx_queues;
1121         device_t           dev = iflib_get_dev(ctx);
1122
1123         /* Release all MSI-X queue resources */
1124         if (sc->intr_type == IFLIB_INTR_MSIX)
1125                 iflib_irq_free(ctx, &sc->irq);
1126
1127         if (que != NULL) {
1128                 for (int i = 0; i < sc->num_rx_queues; i++, que++) {
1129                         iflib_irq_free(ctx, &que->que_irq);
1130                 }
1131         }
1132
1133         if (sc->pci_mem != NULL)
1134                 bus_release_resource(dev, SYS_RES_MEMORY,
1135                     rman_get_rid(sc->pci_mem), sc->pci_mem);
1136 } /* ixv_free_pci_resources */
1137
1138 /************************************************************************
1139  * ixv_setup_interface
1140  *
1141  *   Setup networking device structure and register an interface.
1142  ************************************************************************/
1143 static int
1144 ixv_setup_interface(if_ctx_t ctx)
1145 {
1146         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1147         if_softc_ctx_t scctx = sc->shared;
1148         struct ifnet   *ifp = iflib_get_ifp(ctx);
1149
1150         INIT_DEBUGOUT("ixv_setup_interface: begin");
1151
1152         if_setbaudrate(ifp, IF_Gbps(10));
1153         ifp->if_snd.ifq_maxlen = scctx->isc_ntxd[0] - 2;
1154
1155
1156         sc->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
1157         ifmedia_add(sc->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1158         ifmedia_set(sc->media, IFM_ETHER | IFM_AUTO);
1159
1160         return 0;
1161 } /* ixv_setup_interface */
1162
1163 /************************************************************************
1164  * ixv_if_get_counter
1165  ************************************************************************/
1166 static uint64_t
1167 ixv_if_get_counter(if_ctx_t ctx, ift_counter cnt)
1168 {
1169         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1170         if_t           ifp = iflib_get_ifp(ctx);
1171
1172         switch (cnt) {
1173         case IFCOUNTER_IPACKETS:
1174                 return (sc->ipackets);
1175         case IFCOUNTER_OPACKETS:
1176                 return (sc->opackets);
1177         case IFCOUNTER_IBYTES:
1178                 return (sc->ibytes);
1179         case IFCOUNTER_OBYTES:
1180                 return (sc->obytes);
1181         case IFCOUNTER_IMCASTS:
1182                 return (sc->imcasts);
1183         default:
1184                 return (if_get_counter_default(ifp, cnt));
1185         }
1186 } /* ixv_if_get_counter */
1187
1188 /* ixv_if_needs_restart - Tell iflib when the driver needs to be reinitialized
1189  * @ctx: iflib context
1190  * @event: event code to check
1191  *
1192  * Defaults to returning true for every event.
1193  *
1194  * @returns true if iflib needs to reinit the interface
1195  */
1196 static bool
1197 ixv_if_needs_restart(if_ctx_t ctx __unused, enum iflib_restart_event event)
1198 {
1199         switch (event) {
1200         case IFLIB_RESTART_VLAN_CONFIG:
1201                 /* XXX: This may not need to return true */
1202         default:
1203                 return (true);
1204         }
1205 }
1206
1207 /************************************************************************
1208  * ixv_initialize_transmit_units - Enable transmit unit.
1209  ************************************************************************/
1210 static void
1211 ixv_initialize_transmit_units(if_ctx_t ctx)
1212 {
1213         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1214         struct ixgbe_hw    *hw = &sc->hw;
1215         if_softc_ctx_t     scctx = sc->shared;
1216         struct ix_tx_queue *que = sc->tx_queues;
1217         int                i;
1218
1219         for (i = 0; i < sc->num_tx_queues; i++, que++) {
1220                 struct tx_ring *txr = &que->txr;
1221                 u64            tdba = txr->tx_paddr;
1222                 u32            txctrl, txdctl;
1223                 int            j = txr->me;
1224
1225                 /* Set WTHRESH to 8, burst writeback */
1226                 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
1227                 txdctl |= (8 << 16);
1228                 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);
1229
1230                 /* Set the HW Tx Head and Tail indices */
1231                 IXGBE_WRITE_REG(&sc->hw, IXGBE_VFTDH(j), 0);
1232                 IXGBE_WRITE_REG(&sc->hw, IXGBE_VFTDT(j), 0);
1233
1234                 /* Set Tx Tail register */
1235                 txr->tail = IXGBE_VFTDT(j);
1236
1237                 txr->tx_rs_cidx = txr->tx_rs_pidx;
1238                 /* Initialize the last processed descriptor to be the end of
1239                  * the ring, rather than the start, so that we avoid an
1240                  * off-by-one error when calculating how many descriptors are
1241                  * done in the credits_update function.
1242                  */
1243                 txr->tx_cidx_processed = scctx->isc_ntxd[0] - 1;
1244                 for (int k = 0; k < scctx->isc_ntxd[0]; k++)
1245                         txr->tx_rsq[k] = QIDX_INVALID;
1246
1247                 /* Set Ring parameters */
1248                 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j),
1249                     (tdba & 0x00000000ffffffffULL));
1250                 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32));
1251                 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j),
1252                     scctx->isc_ntxd[0] * sizeof(struct ixgbe_legacy_tx_desc));
1253                 txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j));
1254                 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
1255                 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl);
1256
1257                 /* Now enable */
1258                 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
1259                 txdctl |= IXGBE_TXDCTL_ENABLE;
1260                 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);
1261         }
1262
1263         return;
1264 } /* ixv_initialize_transmit_units */
1265
1266 /************************************************************************
1267  * ixv_initialize_rss_mapping
1268  ************************************************************************/
1269 static void
1270 ixv_initialize_rss_mapping(struct ixgbe_softc *sc)
1271 {
1272         struct ixgbe_hw *hw = &sc->hw;
1273         u32             reta = 0, mrqc, rss_key[10];
1274         int             queue_id;
1275         int             i, j;
1276         u32             rss_hash_config;
1277
1278         if (sc->feat_en & IXGBE_FEATURE_RSS) {
1279                 /* Fetch the configured RSS key */
1280                 rss_getkey((uint8_t *)&rss_key);
1281         } else {
1282                 /* set up random bits */
1283                 arc4rand(&rss_key, sizeof(rss_key), 0);
1284         }
1285
1286         /* Now fill out hash function seeds */
1287         for (i = 0; i < 10; i++)
1288                 IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]);
1289
1290         /* Set up the redirection table */
1291         for (i = 0, j = 0; i < 64; i++, j++) {
1292                 if (j == sc->num_rx_queues)
1293                         j = 0;
1294
1295                 if (sc->feat_en & IXGBE_FEATURE_RSS) {
1296                         /*
1297                          * Fetch the RSS bucket id for the given indirection
1298                          * entry. Cap it at the number of configured buckets
1299                          * (which is num_rx_queues.)
1300                          */
1301                         queue_id = rss_get_indirection_to_bucket(i);
1302                         queue_id = queue_id % sc->num_rx_queues;
1303                 } else
1304                         queue_id = j;
1305
1306                 /*
1307                  * The low 8 bits are for hash value (n+0);
1308                  * The next 8 bits are for hash value (n+1), etc.
1309                  */
1310                 reta >>= 8;
1311                 reta |= ((uint32_t)queue_id) << 24;
1312                 if ((i & 3) == 3) {
1313                         IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), reta);
1314                         reta = 0;
1315                 }
1316         }
1317
1318         /* Perform hash on these packet types */
1319         if (sc->feat_en & IXGBE_FEATURE_RSS)
1320                 rss_hash_config = rss_gethashconfig();
1321         else {
1322                 /*
1323                  * Disable UDP - IP fragments aren't currently being handled
1324                  * and so we end up with a mix of 2-tuple and 4-tuple
1325                  * traffic.
1326                  */
1327                 rss_hash_config = RSS_HASHTYPE_RSS_IPV4
1328                                 | RSS_HASHTYPE_RSS_TCP_IPV4
1329                                 | RSS_HASHTYPE_RSS_IPV6
1330                                 | RSS_HASHTYPE_RSS_TCP_IPV6;
1331         }
1332
1333         mrqc = IXGBE_MRQC_RSSEN;
1334         if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4)
1335                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4;
1336         if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4)
1337                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP;
1338         if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6)
1339                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6;
1340         if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6)
1341                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP;
1342         if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX)
1343                 device_printf(sc->dev, "%s: RSS_HASHTYPE_RSS_IPV6_EX defined, but not supported\n",
1344                     __func__);
1345         if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX)
1346                 device_printf(sc->dev, "%s: RSS_HASHTYPE_RSS_TCP_IPV6_EX defined, but not supported\n",
1347                     __func__);
1348         if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4)
1349                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP;
1350         if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6)
1351                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP;
1352         if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX)
1353                 device_printf(sc->dev, "%s: RSS_HASHTYPE_RSS_UDP_IPV6_EX defined, but not supported\n",
1354                     __func__);
1355         IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, mrqc);
1356 } /* ixv_initialize_rss_mapping */
1357
1358
1359 /************************************************************************
1360  * ixv_initialize_receive_units - Setup receive registers and features.
1361  ************************************************************************/
1362 static void
1363 ixv_initialize_receive_units(if_ctx_t ctx)
1364 {
1365         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1366         if_softc_ctx_t     scctx;
1367         struct ixgbe_hw    *hw = &sc->hw;
1368         struct ifnet       *ifp = iflib_get_ifp(ctx);
1369         struct ix_rx_queue *que = sc->rx_queues;
1370         u32                bufsz, psrtype;
1371
1372         if (ifp->if_mtu > ETHERMTU)
1373                 bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
1374         else
1375                 bufsz = 2048 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
1376
1377         psrtype = IXGBE_PSRTYPE_TCPHDR
1378                 | IXGBE_PSRTYPE_UDPHDR
1379                 | IXGBE_PSRTYPE_IPV4HDR
1380                 | IXGBE_PSRTYPE_IPV6HDR
1381                 | IXGBE_PSRTYPE_L2HDR;
1382
1383         if (sc->num_rx_queues > 1)
1384                 psrtype |= 1 << 29;
1385
1386         IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype);
1387
1388         /* Tell PF our max_frame size */
1389         if (ixgbevf_rlpml_set_vf(hw, sc->max_frame_size) != 0) {
1390                 device_printf(sc->dev, "There is a problem with the PF setup.  It is likely the receive unit for this VF will not function correctly.\n");
1391         }
1392         scctx = sc->shared;
1393
1394         for (int i = 0; i < sc->num_rx_queues; i++, que++) {
1395                 struct rx_ring *rxr = &que->rxr;
1396                 u64            rdba = rxr->rx_paddr;
1397                 u32            reg, rxdctl;
1398                 int            j = rxr->me;
1399
1400                 /* Disable the queue */
1401                 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j));
1402                 rxdctl &= ~IXGBE_RXDCTL_ENABLE;
1403                 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
1404                 for (int k = 0; k < 10; k++) {
1405                         if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
1406                             IXGBE_RXDCTL_ENABLE)
1407                                 msec_delay(1);
1408                         else
1409                                 break;
1410                 }
1411                 wmb();
1412                 /* Setup the Base and Length of the Rx Descriptor Ring */
1413                 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j),
1414                     (rdba & 0x00000000ffffffffULL));
1415                 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32));
1416                 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j),
1417                     scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc));
1418
1419                 /* Reset the ring indices */
1420                 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0);
1421                 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0);
1422
1423                 /* Set up the SRRCTL register */
1424                 reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j));
1425                 reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK;
1426                 reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK;
1427                 reg |= bufsz;
1428                 reg |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
1429                 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg);
1430
1431                 /* Capture Rx Tail index */
1432                 rxr->tail = IXGBE_VFRDT(rxr->me);
1433
1434                 /* Do the queue enabling last */
1435                 rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME;
1436                 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
1437                 for (int l = 0; l < 10; l++) {
1438                         if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
1439                             IXGBE_RXDCTL_ENABLE)
1440                                 break;
1441                         msec_delay(1);
1442                 }
1443                 wmb();
1444
1445                 /* Set the Tail Pointer */
1446 #ifdef DEV_NETMAP
1447                 /*
1448                  * In netmap mode, we must preserve the buffers made
1449                  * available to userspace before the if_init()
1450                  * (this is true by default on the TX side, because
1451                  * init makes all buffers available to userspace).
1452                  *
1453                  * netmap_reset() and the device specific routines
1454                  * (e.g. ixgbe_setup_receive_rings()) map these
1455                  * buffers at the end of the NIC ring, so here we
1456                  * must set the RDT (tail) register to make sure
1457                  * they are not overwritten.
1458                  *
1459                  * In this driver the NIC ring starts at RDH = 0,
1460                  * RDT points to the last slot available for reception (?),
1461                  * so RDT = num_rx_desc - 1 means the whole ring is available.
1462                  */
1463                 if (ifp->if_capenable & IFCAP_NETMAP) {
1464                         struct netmap_adapter *na = NA(ifp);
1465                         struct netmap_kring *kring = na->rx_rings[j];
1466                         int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring);
1467
1468                         IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t);
1469                 } else
1470 #endif /* DEV_NETMAP */
1471                         IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me),
1472                             scctx->isc_nrxd[0] - 1);
1473         }
1474
1475         /*
1476          * Do not touch RSS and RETA settings for older hardware
1477          * as those are shared among PF and all VF.
1478          */
1479         if (sc->hw.mac.type >= ixgbe_mac_X550_vf)
1480                 ixv_initialize_rss_mapping(sc);
1481 } /* ixv_initialize_receive_units */
1482
1483 /************************************************************************
1484  * ixv_setup_vlan_support
1485  ************************************************************************/
1486 static void
1487 ixv_setup_vlan_support(if_ctx_t ctx)
1488 {
1489         struct ifnet    *ifp = iflib_get_ifp(ctx);
1490         struct ixgbe_softc  *sc = iflib_get_softc(ctx);
1491         struct ixgbe_hw *hw = &sc->hw;
1492         u32             ctrl, vid, vfta, retry;
1493
1494         /*
1495          * We get here thru if_init, meaning
1496          * a soft reset, this has already cleared
1497          * the VFTA and other state, so if there
1498          * have been no vlan's registered do nothing.
1499          */
1500         if (sc->num_vlans == 0)
1501                 return;
1502
1503         if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) {
1504                 /* Enable the queues */
1505                 for (int i = 0; i < sc->num_rx_queues; i++) {
1506                         ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
1507                         ctrl |= IXGBE_RXDCTL_VME;
1508                         IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), ctrl);
1509                         /*
1510                          * Let Rx path know that it needs to store VLAN tag
1511                          * as part of extra mbuf info.
1512                          */
1513                         sc->rx_queues[i].rxr.vtag_strip = true;
1514                 }
1515         }
1516
1517         /*
1518          * If filtering VLAN tags is disabled,
1519          * there is no need to fill VLAN Filter Table Array (VFTA).
1520          */
1521         if ((ifp->if_capenable & IFCAP_VLAN_HWFILTER) == 0)
1522                 return;
1523
1524         /*
1525          * A soft reset zero's out the VFTA, so
1526          * we need to repopulate it now.
1527          */
1528         for (int i = 0; i < IXGBE_VFTA_SIZE; i++) {
1529                 if (ixv_shadow_vfta[i] == 0)
1530                         continue;
1531                 vfta = ixv_shadow_vfta[i];
1532                 /*
1533                  * Reconstruct the vlan id's
1534                  * based on the bits set in each
1535                  * of the array ints.
1536                  */
1537                 for (int j = 0; j < 32; j++) {
1538                         retry = 0;
1539                         if ((vfta & (1 << j)) == 0)
1540                                 continue;
1541                         vid = (i * 32) + j;
1542                         /* Call the shared code mailbox routine */
1543                         while (hw->mac.ops.set_vfta(hw, vid, 0, true, false)) {
1544                                 if (++retry > 5)
1545                                         break;
1546                         }
1547                 }
1548         }
1549 } /* ixv_setup_vlan_support */
1550
1551 /************************************************************************
1552  * ixv_if_register_vlan
1553  *
1554  *   Run via a vlan config EVENT, it enables us to use the
1555  *   HW Filter table since we can get the vlan id. This just
1556  *   creates the entry in the soft version of the VFTA, init
1557  *   will repopulate the real table.
1558  ************************************************************************/
1559 static void
1560 ixv_if_register_vlan(if_ctx_t ctx, u16 vtag)
1561 {
1562         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1563         u16            index, bit;
1564
1565         index = (vtag >> 5) & 0x7F;
1566         bit = vtag & 0x1F;
1567         ixv_shadow_vfta[index] |= (1 << bit);
1568         ++sc->num_vlans;
1569 } /* ixv_if_register_vlan */
1570
1571 /************************************************************************
1572  * ixv_if_unregister_vlan
1573  *
1574  *   Run via a vlan unconfig EVENT, remove our entry
1575  *   in the soft vfta.
1576  ************************************************************************/
1577 static void
1578 ixv_if_unregister_vlan(if_ctx_t ctx, u16 vtag)
1579 {
1580         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1581         u16            index, bit;
1582
1583         index = (vtag >> 5) & 0x7F;
1584         bit = vtag & 0x1F;
1585         ixv_shadow_vfta[index] &= ~(1 << bit);
1586         --sc->num_vlans;
1587 } /* ixv_if_unregister_vlan */
1588
1589 /************************************************************************
1590  * ixv_if_enable_intr
1591  ************************************************************************/
1592 static void
1593 ixv_if_enable_intr(if_ctx_t ctx)
1594 {
1595         struct ixgbe_softc  *sc = iflib_get_softc(ctx);
1596         struct ixgbe_hw *hw = &sc->hw;
1597         struct ix_rx_queue *que = sc->rx_queues;
1598         u32             mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE);
1599
1600         IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);
1601
1602         mask = IXGBE_EIMS_ENABLE_MASK;
1603         mask &= ~(IXGBE_EIMS_OTHER | IXGBE_EIMS_LSC);
1604         IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask);
1605
1606         for (int i = 0; i < sc->num_rx_queues; i++, que++)
1607                 ixv_enable_queue(sc, que->msix);
1608
1609         IXGBE_WRITE_FLUSH(hw);
1610 } /* ixv_if_enable_intr */
1611
1612 /************************************************************************
1613  * ixv_if_disable_intr
1614  ************************************************************************/
1615 static void
1616 ixv_if_disable_intr(if_ctx_t ctx)
1617 {
1618         struct ixgbe_softc *sc = iflib_get_softc(ctx);
1619         IXGBE_WRITE_REG(&sc->hw, IXGBE_VTEIAC, 0);
1620         IXGBE_WRITE_REG(&sc->hw, IXGBE_VTEIMC, ~0);
1621         IXGBE_WRITE_FLUSH(&sc->hw);
1622 } /* ixv_if_disable_intr */
1623
1624 /************************************************************************
1625  * ixv_if_rx_queue_intr_enable
1626  ************************************************************************/
1627 static int
1628 ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
1629 {
1630         struct ixgbe_softc      *sc = iflib_get_softc(ctx);
1631         struct ix_rx_queue *que = &sc->rx_queues[rxqid];
1632
1633         ixv_enable_queue(sc, que->rxr.me);
1634
1635         return (0);
1636 } /* ixv_if_rx_queue_intr_enable */
1637
1638 /************************************************************************
1639  * ixv_set_ivar
1640  *
1641  *   Setup the correct IVAR register for a particular MSI-X interrupt
1642  *    - entry is the register array entry
1643  *    - vector is the MSI-X vector for this queue
1644  *    - type is RX/TX/MISC
1645  ************************************************************************/
1646 static void
1647 ixv_set_ivar(struct ixgbe_softc *sc, u8 entry, u8 vector, s8 type)
1648 {
1649         struct ixgbe_hw *hw = &sc->hw;
1650         u32             ivar, index;
1651
1652         vector |= IXGBE_IVAR_ALLOC_VAL;
1653
1654         if (type == -1) { /* MISC IVAR */
1655                 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC);
1656                 ivar &= ~0xFF;
1657                 ivar |= vector;
1658                 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar);
1659         } else {          /* RX/TX IVARS */
1660                 index = (16 * (entry & 1)) + (8 * type);
1661                 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(entry >> 1));
1662                 ivar &= ~(0xFF << index);
1663                 ivar |= (vector << index);
1664                 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(entry >> 1), ivar);
1665         }
1666 } /* ixv_set_ivar */
1667
1668 /************************************************************************
1669  * ixv_configure_ivars
1670  ************************************************************************/
1671 static void
1672 ixv_configure_ivars(struct ixgbe_softc *sc)
1673 {
1674         struct ix_rx_queue *que = sc->rx_queues;
1675
1676         MPASS(sc->num_rx_queues == sc->num_tx_queues);
1677
1678         for (int i = 0; i < sc->num_rx_queues; i++, que++) {
1679                 /* First the RX queue entry */
1680                 ixv_set_ivar(sc, i, que->msix, 0);
1681                 /* ... and the TX */
1682                 ixv_set_ivar(sc, i, que->msix, 1);
1683                 /* Set an initial value in EITR */
1684                 IXGBE_WRITE_REG(&sc->hw, IXGBE_VTEITR(que->msix),
1685                     IXGBE_EITR_DEFAULT);
1686         }
1687
1688         /* For the mailbox interrupt */
1689         ixv_set_ivar(sc, 1, sc->vector, -1);
1690 } /* ixv_configure_ivars */
1691
1692 /************************************************************************
1693  * ixv_save_stats
1694  *
1695  *   The VF stats registers never have a truly virgin
1696  *   starting point, so this routine tries to make an
1697  *   artificial one, marking ground zero on attach as
1698  *   it were.
1699  ************************************************************************/
1700 static void
1701 ixv_save_stats(struct ixgbe_softc *sc)
1702 {
1703         if (sc->stats.vf.vfgprc || sc->stats.vf.vfgptc) {
1704                 sc->stats.vf.saved_reset_vfgprc +=
1705                     sc->stats.vf.vfgprc - sc->stats.vf.base_vfgprc;
1706                 sc->stats.vf.saved_reset_vfgptc +=
1707                     sc->stats.vf.vfgptc - sc->stats.vf.base_vfgptc;
1708                 sc->stats.vf.saved_reset_vfgorc +=
1709                     sc->stats.vf.vfgorc - sc->stats.vf.base_vfgorc;
1710                 sc->stats.vf.saved_reset_vfgotc +=
1711                     sc->stats.vf.vfgotc - sc->stats.vf.base_vfgotc;
1712                 sc->stats.vf.saved_reset_vfmprc +=
1713                     sc->stats.vf.vfmprc - sc->stats.vf.base_vfmprc;
1714         }
1715 } /* ixv_save_stats */
1716
1717 /************************************************************************
1718  * ixv_init_stats
1719  ************************************************************************/
1720 static void
1721 ixv_init_stats(struct ixgbe_softc *sc)
1722 {
1723         struct ixgbe_hw *hw = &sc->hw;
1724
1725         sc->stats.vf.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC);
1726         sc->stats.vf.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB);
1727         sc->stats.vf.last_vfgorc |=
1728             (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32);
1729
1730         sc->stats.vf.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC);
1731         sc->stats.vf.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB);
1732         sc->stats.vf.last_vfgotc |=
1733             (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32);
1734
1735         sc->stats.vf.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC);
1736
1737         sc->stats.vf.base_vfgprc = sc->stats.vf.last_vfgprc;
1738         sc->stats.vf.base_vfgorc = sc->stats.vf.last_vfgorc;
1739         sc->stats.vf.base_vfgptc = sc->stats.vf.last_vfgptc;
1740         sc->stats.vf.base_vfgotc = sc->stats.vf.last_vfgotc;
1741         sc->stats.vf.base_vfmprc = sc->stats.vf.last_vfmprc;
1742 } /* ixv_init_stats */
1743
1744 #define UPDATE_STAT_32(reg, last, count)                \
1745 {                                                       \
1746         u32 current = IXGBE_READ_REG(hw, reg);          \
1747         if (current < last)                             \
1748                 count += 0x100000000LL;                 \
1749         last = current;                                 \
1750         count &= 0xFFFFFFFF00000000LL;                  \
1751         count |= current;                               \
1752 }
1753
1754 #define UPDATE_STAT_36(lsb, msb, last, count)           \
1755 {                                                       \
1756         u64 cur_lsb = IXGBE_READ_REG(hw, lsb);          \
1757         u64 cur_msb = IXGBE_READ_REG(hw, msb);          \
1758         u64 current = ((cur_msb << 32) | cur_lsb);      \
1759         if (current < last)                             \
1760                 count += 0x1000000000LL;                \
1761         last = current;                                 \
1762         count &= 0xFFFFFFF000000000LL;                  \
1763         count |= current;                               \
1764 }
1765
1766 /************************************************************************
1767  * ixv_update_stats - Update the board statistics counters.
1768  ************************************************************************/
1769 void
1770 ixv_update_stats(struct ixgbe_softc *sc)
1771 {
1772         struct ixgbe_hw *hw = &sc->hw;
1773         struct ixgbevf_hw_stats *stats = &sc->stats.vf;
1774
1775         UPDATE_STAT_32(IXGBE_VFGPRC, sc->stats.vf.last_vfgprc,
1776             sc->stats.vf.vfgprc);
1777         UPDATE_STAT_32(IXGBE_VFGPTC, sc->stats.vf.last_vfgptc,
1778             sc->stats.vf.vfgptc);
1779         UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB,
1780             sc->stats.vf.last_vfgorc, sc->stats.vf.vfgorc);
1781         UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB,
1782             sc->stats.vf.last_vfgotc, sc->stats.vf.vfgotc);
1783         UPDATE_STAT_32(IXGBE_VFMPRC, sc->stats.vf.last_vfmprc,
1784             sc->stats.vf.vfmprc);
1785
1786         /* Fill out the OS statistics structure */
1787         IXGBE_SET_IPACKETS(sc, stats->vfgprc);
1788         IXGBE_SET_OPACKETS(sc, stats->vfgptc);
1789         IXGBE_SET_IBYTES(sc, stats->vfgorc);
1790         IXGBE_SET_OBYTES(sc, stats->vfgotc);
1791         IXGBE_SET_IMCASTS(sc, stats->vfmprc);
1792 } /* ixv_update_stats */
1793
1794 /************************************************************************
1795  * ixv_add_stats_sysctls - Add statistic sysctls for the VF.
1796  ************************************************************************/
1797 static void
1798 ixv_add_stats_sysctls(struct ixgbe_softc *sc)
1799 {
1800         device_t                dev = sc->dev;
1801         struct ix_tx_queue      *tx_que = sc->tx_queues;
1802         struct ix_rx_queue      *rx_que = sc->rx_queues;
1803         struct sysctl_ctx_list  *ctx = device_get_sysctl_ctx(dev);
1804         struct sysctl_oid       *tree = device_get_sysctl_tree(dev);
1805         struct sysctl_oid_list  *child = SYSCTL_CHILDREN(tree);
1806         struct ixgbevf_hw_stats *stats = &sc->stats.vf;
1807         struct sysctl_oid       *stat_node, *queue_node;
1808         struct sysctl_oid_list  *stat_list, *queue_list;
1809
1810 #define QUEUE_NAME_LEN 32
1811         char                    namebuf[QUEUE_NAME_LEN];
1812
1813         /* Driver Statistics */
1814         SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "watchdog_events",
1815             CTLFLAG_RD, &sc->watchdog_events, "Watchdog timeouts");
1816         SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq",
1817             CTLFLAG_RD, &sc->link_irq, "Link MSI-X IRQ Handled");
1818
1819         for (int i = 0; i < sc->num_tx_queues; i++, tx_que++) {
1820                 struct tx_ring *txr = &tx_que->txr;
1821                 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
1822                 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
1823                     CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
1824                 queue_list = SYSCTL_CHILDREN(queue_node);
1825
1826                 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
1827                     CTLFLAG_RD, &(txr->tso_tx), "TSO Packets");
1828                 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_packets",
1829                     CTLFLAG_RD, &(txr->total_packets), "TX Packets");
1830         }
1831
1832         for (int i = 0; i < sc->num_rx_queues; i++, rx_que++) {
1833                 struct rx_ring *rxr = &rx_que->rxr;
1834                 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
1835                 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
1836                     CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "Queue Name");
1837                 queue_list = SYSCTL_CHILDREN(queue_node);
1838
1839                 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
1840                     CTLFLAG_RD, &(rx_que->irqs), "IRQs on queue");
1841                 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets",
1842                     CTLFLAG_RD, &(rxr->rx_packets), "RX packets");
1843                 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_bytes",
1844                     CTLFLAG_RD, &(rxr->rx_bytes), "RX bytes");
1845                 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_discarded",
1846                     CTLFLAG_RD, &(rxr->rx_discarded), "Discarded RX packets");
1847         }
1848
1849         stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac",
1850             CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
1851             "VF Statistics (read from HW registers)");
1852         stat_list = SYSCTL_CHILDREN(stat_node);
1853
1854         SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_rcvd",
1855             CTLFLAG_RD, &stats->vfgprc, "Good Packets Received");
1856         SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_rcvd",
1857             CTLFLAG_RD, &stats->vfgorc, "Good Octets Received");
1858         SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "mcast_pkts_rcvd",
1859             CTLFLAG_RD, &stats->vfmprc, "Multicast Packets Received");
1860         SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_txd",
1861             CTLFLAG_RD, &stats->vfgptc, "Good Packets Transmitted");
1862         SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_txd",
1863             CTLFLAG_RD, &stats->vfgotc, "Good Octets Transmitted");
1864 } /* ixv_add_stats_sysctls */
1865
1866 /************************************************************************
1867  * ixv_print_debug_info
1868  *
1869  *   Called only when em_display_debug_stats is enabled.
1870  *   Provides a way to take a look at important statistics
1871  *   maintained by the driver and hardware.
1872  ************************************************************************/
1873 static void
1874 ixv_print_debug_info(struct ixgbe_softc *sc)
1875 {
1876         device_t dev = sc->dev;
1877         struct ixgbe_hw *hw = &sc->hw;
1878
1879         device_printf(dev, "Error Byte Count = %u \n",
1880             IXGBE_READ_REG(hw, IXGBE_ERRBC));
1881
1882         device_printf(dev, "MBX IRQ Handled: %lu\n", (long)sc->link_irq);
1883 } /* ixv_print_debug_info */
1884
1885 /************************************************************************
1886  * ixv_sysctl_debug
1887  ************************************************************************/
1888 static int
1889 ixv_sysctl_debug(SYSCTL_HANDLER_ARGS)
1890 {
1891         struct ixgbe_softc *sc;
1892         int error, result;
1893
1894         result = -1;
1895         error = sysctl_handle_int(oidp, &result, 0, req);
1896
1897         if (error || !req->newptr)
1898                 return (error);
1899
1900         if (result == 1) {
1901                 sc = (struct ixgbe_softc *)arg1;
1902                 ixv_print_debug_info(sc);
1903         }
1904
1905         return error;
1906 } /* ixv_sysctl_debug */
1907
1908 /************************************************************************
1909  * ixv_init_device_features
1910  ************************************************************************/
1911 static void
1912 ixv_init_device_features(struct ixgbe_softc *sc)
1913 {
1914         sc->feat_cap = IXGBE_FEATURE_NETMAP
1915                                     | IXGBE_FEATURE_VF
1916                                     | IXGBE_FEATURE_LEGACY_TX;
1917
1918         /* A tad short on feature flags for VFs, atm. */
1919         switch (sc->hw.mac.type) {
1920         case ixgbe_mac_82599_vf:
1921                 break;
1922         case ixgbe_mac_X540_vf:
1923                 break;
1924         case ixgbe_mac_X550_vf:
1925         case ixgbe_mac_X550EM_x_vf:
1926         case ixgbe_mac_X550EM_a_vf:
1927                 sc->feat_cap |= IXGBE_FEATURE_NEEDS_CTXD;
1928                 sc->feat_cap |= IXGBE_FEATURE_RSS;
1929                 break;
1930         default:
1931                 break;
1932         }
1933
1934         /* Enabled by default... */
1935         /* Is a virtual function (VF) */
1936         if (sc->feat_cap & IXGBE_FEATURE_VF)
1937                 sc->feat_en |= IXGBE_FEATURE_VF;
1938         /* Netmap */
1939         if (sc->feat_cap & IXGBE_FEATURE_NETMAP)
1940                 sc->feat_en |= IXGBE_FEATURE_NETMAP;
1941         /* Receive-Side Scaling (RSS) */
1942         if (sc->feat_cap & IXGBE_FEATURE_RSS)
1943                 sc->feat_en |= IXGBE_FEATURE_RSS;
1944         /* Needs advanced context descriptor regardless of offloads req'd */
1945         if (sc->feat_cap & IXGBE_FEATURE_NEEDS_CTXD)
1946                 sc->feat_en |= IXGBE_FEATURE_NEEDS_CTXD;
1947 } /* ixv_init_device_features */
1948