1 /******************************************************************************
3 Copyright (c) 2001-2017, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
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.
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.
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.
32 ******************************************************************************/
37 #include "opt_inet6.h"
42 #include <net/netmap.h>
43 #include <dev/netmap/netmap_kern.h>
45 /************************************************************************
47 ************************************************************************/
48 char ixv_driver_version[] = "2.0.1-k";
50 /************************************************************************
53 * Used by probe to select devices to load on
54 * Last field stores an index into ixv_strings
55 * Last entry must be all 0s
57 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
58 ************************************************************************/
59 static pci_vendor_info_t ixv_vendor_info_array[] =
61 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
62 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
63 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
64 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
65 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
66 /* required last entry */
70 /************************************************************************
72 ************************************************************************/
73 static void *ixv_register(device_t dev);
74 static int ixv_if_attach_pre(if_ctx_t ctx);
75 static int ixv_if_attach_post(if_ctx_t ctx);
76 static int ixv_if_detach(if_ctx_t ctx);
78 static int ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid);
79 static int ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
80 static int ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
81 static void ixv_if_queues_free(if_ctx_t ctx);
82 static void ixv_identify_hardware(if_ctx_t ctx);
83 static void ixv_init_device_features(struct adapter *);
84 static int ixv_allocate_pci_resources(if_ctx_t ctx);
85 static void ixv_free_pci_resources(if_ctx_t ctx);
86 static int ixv_setup_interface(if_ctx_t ctx);
87 static void ixv_if_media_status(if_ctx_t , struct ifmediareq *);
88 static int ixv_if_media_change(if_ctx_t ctx);
89 static void ixv_if_update_admin_status(if_ctx_t ctx);
90 static int ixv_if_msix_intr_assign(if_ctx_t ctx, int msix);
92 static int ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
93 static void ixv_if_init(if_ctx_t ctx);
94 static void ixv_if_local_timer(if_ctx_t ctx, uint16_t qid);
95 static void ixv_if_stop(if_ctx_t ctx);
96 static int ixv_negotiate_api(struct adapter *);
98 static void ixv_initialize_transmit_units(if_ctx_t ctx);
99 static void ixv_initialize_receive_units(if_ctx_t ctx);
100 static void ixv_initialize_rss_mapping(struct adapter *);
102 static void ixv_setup_vlan_support(if_ctx_t ctx);
103 static void ixv_configure_ivars(struct adapter *);
104 static void ixv_if_enable_intr(if_ctx_t ctx);
105 static void ixv_if_disable_intr(if_ctx_t ctx);
106 static void ixv_if_multi_set(if_ctx_t ctx);
108 static void ixv_if_register_vlan(if_ctx_t, u16);
109 static void ixv_if_unregister_vlan(if_ctx_t, u16);
111 static uint64_t ixv_if_get_counter(if_ctx_t, ift_counter);
113 static void ixv_save_stats(struct adapter *);
114 static void ixv_init_stats(struct adapter *);
115 static void ixv_update_stats(struct adapter *);
116 static void ixv_add_stats_sysctls(struct adapter *adapter);
118 static int ixv_sysctl_debug(SYSCTL_HANDLER_ARGS);
119 static void ixv_set_ivar(struct adapter *, u8, u8, s8);
121 static u8 *ixv_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *);
123 /* The MSI-X Interrupt handlers */
124 static int ixv_msix_que(void *);
125 static int ixv_msix_mbx(void *);
127 /************************************************************************
128 * FreeBSD Device Interface Entry Points
129 ************************************************************************/
130 static device_method_t ixv_methods[] = {
131 /* Device interface */
132 DEVMETHOD(device_register, ixv_register),
133 DEVMETHOD(device_probe, iflib_device_probe),
134 DEVMETHOD(device_attach, iflib_device_attach),
135 DEVMETHOD(device_detach, iflib_device_detach),
136 DEVMETHOD(device_shutdown, iflib_device_shutdown),
140 static driver_t ixv_driver = {
141 "ixv", ixv_methods, sizeof(struct adapter),
144 devclass_t ixv_devclass;
145 DRIVER_MODULE(ixv, pci, ixv_driver, ixv_devclass, 0, 0);
146 MODULE_PNP_INFO("U16:vendor;U16:device", pci, ixv, ixv_vendor_info_array,
147 sizeof(ixv_vendor_info_array[0]), nitems(ixv_vendor_info_array) - 1);
148 MODULE_DEPEND(ixv, pci, 1, 1, 1);
149 MODULE_DEPEND(ixv, ether, 1, 1, 1);
151 MODULE_DEPEND(ixv, netmap, 1, 1, 1);
152 #endif /* DEV_NETMAP */
154 static device_method_t ixv_if_methods[] = {
155 DEVMETHOD(ifdi_attach_pre, ixv_if_attach_pre),
156 DEVMETHOD(ifdi_attach_post, ixv_if_attach_post),
157 DEVMETHOD(ifdi_detach, ixv_if_detach),
158 DEVMETHOD(ifdi_init, ixv_if_init),
159 DEVMETHOD(ifdi_stop, ixv_if_stop),
160 DEVMETHOD(ifdi_msix_intr_assign, ixv_if_msix_intr_assign),
161 DEVMETHOD(ifdi_intr_enable, ixv_if_enable_intr),
162 DEVMETHOD(ifdi_intr_disable, ixv_if_disable_intr),
163 DEVMETHOD(ifdi_tx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
164 DEVMETHOD(ifdi_rx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
165 DEVMETHOD(ifdi_tx_queues_alloc, ixv_if_tx_queues_alloc),
166 DEVMETHOD(ifdi_rx_queues_alloc, ixv_if_rx_queues_alloc),
167 DEVMETHOD(ifdi_queues_free, ixv_if_queues_free),
168 DEVMETHOD(ifdi_update_admin_status, ixv_if_update_admin_status),
169 DEVMETHOD(ifdi_multi_set, ixv_if_multi_set),
170 DEVMETHOD(ifdi_mtu_set, ixv_if_mtu_set),
171 DEVMETHOD(ifdi_media_status, ixv_if_media_status),
172 DEVMETHOD(ifdi_media_change, ixv_if_media_change),
173 DEVMETHOD(ifdi_timer, ixv_if_local_timer),
174 DEVMETHOD(ifdi_vlan_register, ixv_if_register_vlan),
175 DEVMETHOD(ifdi_vlan_unregister, ixv_if_unregister_vlan),
176 DEVMETHOD(ifdi_get_counter, ixv_if_get_counter),
180 static driver_t ixv_if_driver = {
181 "ixv_if", ixv_if_methods, sizeof(struct adapter)
185 * TUNEABLE PARAMETERS:
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);
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.
198 static int ixv_header_split = FALSE;
199 TUNABLE_INT("hw.ixv.hdr_split", &ixv_header_split);
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.
206 static u32 ixv_shadow_vfta[IXGBE_VFTA_SIZE];
207 extern struct if_txrx ixgbe_txrx;
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,
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,
227 .isc_nrxd_min = {MIN_RXD},
228 .isc_ntxd_min = {MIN_TXD},
229 .isc_nrxd_max = {MAX_RXD},
230 .isc_ntxd_max = {MAX_TXD},
231 .isc_nrxd_default = {DEFAULT_RXD},
232 .isc_ntxd_default = {DEFAULT_TXD},
235 if_shared_ctx_t ixv_sctx = &ixv_sctx_init;
238 ixv_register(device_t dev)
243 /************************************************************************
244 * ixv_if_tx_queues_alloc
245 ************************************************************************/
247 ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs,
248 int ntxqs, int ntxqsets)
250 struct adapter *adapter = iflib_get_softc(ctx);
251 if_softc_ctx_t scctx = adapter->shared;
252 struct ix_tx_queue *que;
255 MPASS(adapter->num_tx_queues == ntxqsets);
258 /* Allocate queue structure memory */
260 (struct ix_tx_queue *)malloc(sizeof(struct ix_tx_queue) * ntxqsets,
261 M_DEVBUF, M_NOWAIT | M_ZERO);
262 if (!adapter->tx_queues) {
263 device_printf(iflib_get_dev(ctx),
264 "Unable to allocate TX ring memory\n");
268 for (i = 0, que = adapter->tx_queues; i < ntxqsets; i++, que++) {
269 struct tx_ring *txr = &que->txr;
272 txr->adapter = que->adapter = adapter;
273 adapter->active_queues |= (u64)1 << txr->me;
275 /* Allocate report status array */
276 if (!(txr->tx_rsq = (qidx_t *)malloc(sizeof(qidx_t) * scctx->isc_ntxd[0], M_DEVBUF, M_NOWAIT | M_ZERO))) {
280 for (j = 0; j < scctx->isc_ntxd[0]; j++)
281 txr->tx_rsq[j] = QIDX_INVALID;
282 /* get the virtual and physical address of the hardware queues */
283 txr->tail = IXGBE_VFTDT(txr->me);
284 txr->tx_base = (union ixgbe_adv_tx_desc *)vaddrs[i*ntxqs];
285 txr->tx_paddr = paddrs[i*ntxqs];
288 txr->total_packets = 0;
292 device_printf(iflib_get_dev(ctx), "allocated for %d queues\n",
293 adapter->num_tx_queues);
298 ixv_if_queues_free(ctx);
301 } /* ixv_if_tx_queues_alloc */
303 /************************************************************************
304 * ixv_if_rx_queues_alloc
305 ************************************************************************/
307 ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs,
308 int nrxqs, int nrxqsets)
310 struct adapter *adapter = iflib_get_softc(ctx);
311 struct ix_rx_queue *que;
314 MPASS(adapter->num_rx_queues == nrxqsets);
317 /* Allocate queue structure memory */
319 (struct ix_rx_queue *)malloc(sizeof(struct ix_rx_queue) * nrxqsets,
320 M_DEVBUF, M_NOWAIT | M_ZERO);
321 if (!adapter->rx_queues) {
322 device_printf(iflib_get_dev(ctx),
323 "Unable to allocate TX ring memory\n");
328 for (i = 0, que = adapter->rx_queues; i < nrxqsets; i++, que++) {
329 struct rx_ring *rxr = &que->rxr;
331 rxr->adapter = que->adapter = adapter;
334 /* get the virtual and physical address of the hw queues */
335 rxr->tail = IXGBE_VFRDT(rxr->me);
336 rxr->rx_base = (union ixgbe_adv_rx_desc *)vaddrs[i];
337 rxr->rx_paddr = paddrs[i*nrxqs];
342 device_printf(iflib_get_dev(ctx), "allocated for %d rx queues\n",
343 adapter->num_rx_queues);
348 ixv_if_queues_free(ctx);
351 } /* ixv_if_rx_queues_alloc */
353 /************************************************************************
355 ************************************************************************/
357 ixv_if_queues_free(if_ctx_t ctx)
359 struct adapter *adapter = iflib_get_softc(ctx);
360 struct ix_tx_queue *que = adapter->tx_queues;
366 for (i = 0; i < adapter->num_tx_queues; i++, que++) {
367 struct tx_ring *txr = &que->txr;
368 if (txr->tx_rsq == NULL)
371 free(txr->tx_rsq, M_DEVBUF);
374 if (adapter->tx_queues != NULL)
375 free(adapter->tx_queues, M_DEVBUF);
377 if (adapter->rx_queues != NULL)
378 free(adapter->rx_queues, M_DEVBUF);
379 adapter->tx_queues = NULL;
380 adapter->rx_queues = NULL;
381 } /* ixv_if_queues_free */
383 /************************************************************************
384 * ixv_if_attach_pre - Device initialization routine
386 * Called when the driver is being loaded.
387 * Identifies the type of hardware, allocates all resources
388 * and initializes the hardware.
390 * return 0 on success, positive on failure
391 ************************************************************************/
393 ixv_if_attach_pre(if_ctx_t ctx)
395 struct adapter *adapter;
397 if_softc_ctx_t scctx;
401 INIT_DEBUGOUT("ixv_attach: begin");
403 /* Allocate, clear, and link in our adapter structure */
404 dev = iflib_get_dev(ctx);
405 adapter = iflib_get_softc(ctx);
408 adapter->hw.back = adapter;
409 scctx = adapter->shared = iflib_get_softc_ctx(ctx);
410 adapter->media = iflib_get_media(ctx);
413 /* Do base PCI setup - map BAR0 */
414 if (ixv_allocate_pci_resources(ctx)) {
415 device_printf(dev, "ixv_allocate_pci_resources() failed!\n");
421 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
422 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "debug",
423 CTLTYPE_INT | CTLFLAG_RW, adapter, 0, ixv_sysctl_debug, "I",
426 /* Determine hardware revision */
427 ixv_identify_hardware(ctx);
428 ixv_init_device_features(adapter);
430 /* Initialize the shared code */
431 error = ixgbe_init_ops_vf(hw);
433 device_printf(dev, "ixgbe_init_ops_vf() failed!\n");
438 /* Setup the mailbox */
439 ixgbe_init_mbx_params_vf(hw);
441 error = hw->mac.ops.reset_hw(hw);
442 if (error == IXGBE_ERR_RESET_FAILED)
443 device_printf(dev, "...reset_hw() failure: Reset Failed!\n");
445 device_printf(dev, "...reset_hw() failed with error %d\n",
452 error = hw->mac.ops.init_hw(hw);
454 device_printf(dev, "...init_hw() failed with error %d\n",
460 /* Negotiate mailbox API version */
461 error = ixv_negotiate_api(adapter);
464 "Mailbox API negotiation failed during attach!\n");
468 /* If no mac address was assigned, make a random one */
469 if (!ixv_check_ether_addr(hw->mac.addr)) {
470 u8 addr[ETHER_ADDR_LEN];
471 arc4rand(&addr, sizeof(addr), 0);
474 bcopy(addr, hw->mac.addr, sizeof(addr));
475 bcopy(addr, hw->mac.perm_addr, sizeof(addr));
478 /* Most of the iflib initialization... */
480 iflib_set_mac(ctx, hw->mac.addr);
481 switch (adapter->hw.mac.type) {
482 case ixgbe_mac_X550_vf:
483 case ixgbe_mac_X550EM_x_vf:
484 case ixgbe_mac_X550EM_a_vf:
485 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 2;
488 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 1;
490 scctx->isc_txqsizes[0] =
491 roundup2(scctx->isc_ntxd[0] * sizeof(union ixgbe_adv_tx_desc) +
492 sizeof(u32), DBA_ALIGN);
493 scctx->isc_rxqsizes[0] =
494 roundup2(scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc),
497 scctx->isc_tx_csum_flags = CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_TSO |
498 CSUM_IP6_TCP | CSUM_IP6_UDP | CSUM_IP6_TSO;
499 scctx->isc_tx_nsegments = IXGBE_82599_SCATTER;
500 scctx->isc_msix_bar = PCIR_BAR(MSIX_82598_BAR);
501 scctx->isc_tx_tso_segments_max = scctx->isc_tx_nsegments;
502 scctx->isc_tx_tso_size_max = IXGBE_TSO_SIZE;
503 scctx->isc_tx_tso_segsize_max = PAGE_SIZE;
505 scctx->isc_txrx = &ixgbe_txrx;
508 * Tell the upper layer(s) we support everything the PF
509 * driver does except...
512 scctx->isc_capabilities = IXGBE_CAPS;
513 scctx->isc_capabilities ^= IFCAP_WOL;
514 scctx->isc_capenable = scctx->isc_capabilities;
516 INIT_DEBUGOUT("ixv_if_attach_pre: end");
521 ixv_free_pci_resources(ctx);
524 } /* ixv_if_attach_pre */
527 ixv_if_attach_post(if_ctx_t ctx)
529 struct adapter *adapter = iflib_get_softc(ctx);
530 device_t dev = iflib_get_dev(ctx);
533 /* Setup OS specific network interface */
534 error = ixv_setup_interface(ctx);
536 device_printf(dev, "Interface setup failed: %d\n", error);
540 /* Do the stats setup */
541 ixv_save_stats(adapter);
542 ixv_init_stats(adapter);
543 ixv_add_stats_sysctls(adapter);
547 } /* ixv_if_attach_post */
549 /************************************************************************
550 * ixv_detach - Device removal routine
552 * Called when the driver is being removed.
553 * Stops the adapter and deallocates all the resources
554 * that were allocated for driver operation.
556 * return 0 on success, positive on failure
557 ************************************************************************/
559 ixv_if_detach(if_ctx_t ctx)
561 INIT_DEBUGOUT("ixv_detach: begin");
563 ixv_free_pci_resources(ctx);
566 } /* ixv_if_detach */
568 /************************************************************************
570 ************************************************************************/
572 ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
574 struct adapter *adapter = iflib_get_softc(ctx);
575 struct ifnet *ifp = iflib_get_ifp(ctx);
578 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
579 if (mtu > IXGBE_MAX_FRAME_SIZE - IXGBE_MTU_HDR) {
583 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
587 } /* ixv_if_mtu_set */
589 /************************************************************************
590 * ixv_if_init - Init entry point
592 * Used in two ways: It is used by the stack as an init entry
593 * point in network interface structure. It is also used
594 * by the driver as a hw/sw initialization routine to get
595 * to a consistent state.
597 * return 0 on success, positive on failure
598 ************************************************************************/
600 ixv_if_init(if_ctx_t ctx)
602 struct adapter *adapter = iflib_get_softc(ctx);
603 struct ifnet *ifp = iflib_get_ifp(ctx);
604 device_t dev = iflib_get_dev(ctx);
605 struct ixgbe_hw *hw = &adapter->hw;
608 INIT_DEBUGOUT("ixv_if_init: begin");
609 hw->adapter_stopped = FALSE;
610 hw->mac.ops.stop_adapter(hw);
612 /* reprogram the RAR[0] in case user changed it. */
613 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
615 /* Get the latest mac address, User can use a LAA */
616 bcopy(IF_LLADDR(ifp), hw->mac.addr, IXGBE_ETH_LENGTH_OF_ADDRESS);
617 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1);
619 /* Reset VF and renegotiate mailbox API version */
620 hw->mac.ops.reset_hw(hw);
621 hw->mac.ops.start_hw(hw);
622 error = ixv_negotiate_api(adapter);
625 "Mailbox API negotiation failed in if_init!\n");
629 ixv_initialize_transmit_units(ctx);
631 /* Setup Multicast table */
632 ixv_if_multi_set(ctx);
635 * Determine the correct mbuf pool
636 * for doing jumbo/headersplit
638 if (ifp->if_mtu > ETHERMTU)
639 adapter->rx_mbuf_sz = MJUMPAGESIZE;
641 adapter->rx_mbuf_sz = MCLBYTES;
643 /* Configure RX settings */
644 ixv_initialize_receive_units(ctx);
646 /* Set up VLAN offload and filter */
647 ixv_setup_vlan_support(ctx);
649 /* Set up MSI-X routing */
650 ixv_configure_ivars(adapter);
652 /* Set up auto-mask */
653 IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, IXGBE_EICS_RTX_QUEUE);
655 /* Set moderation on the Link interrupt */
656 IXGBE_WRITE_REG(hw, IXGBE_VTEITR(adapter->vector), IXGBE_LINK_ITR);
659 ixv_init_stats(adapter);
661 /* Config/Enable Link */
662 hw->mac.ops.check_link(hw, &adapter->link_speed, &adapter->link_up,
665 /* And now turn on interrupts */
666 ixv_if_enable_intr(ctx);
671 /************************************************************************
673 ************************************************************************/
675 ixv_enable_queue(struct adapter *adapter, u32 vector)
677 struct ixgbe_hw *hw = &adapter->hw;
678 u32 queue = 1 << vector;
681 mask = (IXGBE_EIMS_RTX_QUEUE & queue);
682 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);
683 } /* ixv_enable_queue */
685 /************************************************************************
687 ************************************************************************/
689 ixv_disable_queue(struct adapter *adapter, u32 vector)
691 struct ixgbe_hw *hw = &adapter->hw;
692 u64 queue = (u64)(1 << vector);
695 mask = (IXGBE_EIMS_RTX_QUEUE & queue);
696 IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask);
697 } /* ixv_disable_queue */
700 /************************************************************************
701 * ixv_msix_que - MSI-X Queue Interrupt Service routine
702 ************************************************************************/
704 ixv_msix_que(void *arg)
706 struct ix_rx_queue *que = arg;
707 struct adapter *adapter = que->adapter;
709 ixv_disable_queue(adapter, que->msix);
712 return (FILTER_SCHEDULE_THREAD);
715 /************************************************************************
717 ************************************************************************/
719 ixv_msix_mbx(void *arg)
721 struct adapter *adapter = arg;
722 struct ixgbe_hw *hw = &adapter->hw;
727 /* First get the cause */
728 reg = IXGBE_READ_REG(hw, IXGBE_VTEICS);
729 /* Clear interrupt with write */
730 IXGBE_WRITE_REG(hw, IXGBE_VTEICR, reg);
732 /* Link status change */
733 if (reg & IXGBE_EICR_LSC)
734 iflib_admin_intr_deferred(adapter->ctx);
736 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, IXGBE_EIMS_OTHER);
738 return (FILTER_HANDLED);
741 /************************************************************************
742 * ixv_media_status - Media Ioctl callback
744 * Called whenever the user queries the status of
745 * the interface using ifconfig.
746 ************************************************************************/
748 ixv_if_media_status(if_ctx_t ctx, struct ifmediareq * ifmr)
750 struct adapter *adapter = iflib_get_softc(ctx);
752 INIT_DEBUGOUT("ixv_media_status: begin");
754 iflib_admin_intr_deferred(ctx);
756 ifmr->ifm_status = IFM_AVALID;
757 ifmr->ifm_active = IFM_ETHER;
759 if (!adapter->link_active)
762 ifmr->ifm_status |= IFM_ACTIVE;
764 switch (adapter->link_speed) {
765 case IXGBE_LINK_SPEED_1GB_FULL:
766 ifmr->ifm_active |= IFM_1000_T | IFM_FDX;
768 case IXGBE_LINK_SPEED_10GB_FULL:
769 ifmr->ifm_active |= IFM_10G_T | IFM_FDX;
771 case IXGBE_LINK_SPEED_100_FULL:
772 ifmr->ifm_active |= IFM_100_TX | IFM_FDX;
774 case IXGBE_LINK_SPEED_10_FULL:
775 ifmr->ifm_active |= IFM_10_T | IFM_FDX;
778 } /* ixv_if_media_status */
780 /************************************************************************
781 * ixv_if_media_change - Media Ioctl callback
783 * Called when the user changes speed/duplex using
784 * media/mediopt option with ifconfig.
785 ************************************************************************/
787 ixv_if_media_change(if_ctx_t ctx)
789 struct adapter *adapter = iflib_get_softc(ctx);
790 struct ifmedia *ifm = iflib_get_media(ctx);
792 INIT_DEBUGOUT("ixv_media_change: begin");
794 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
797 switch (IFM_SUBTYPE(ifm->ifm_media)) {
801 device_printf(adapter->dev, "Only auto media type\n");
806 } /* ixv_if_media_change */
809 /************************************************************************
812 * Negotiate the Mailbox API with the PF;
813 * start with the most featured API first.
814 ************************************************************************/
816 ixv_negotiate_api(struct adapter *adapter)
818 struct ixgbe_hw *hw = &adapter->hw;
819 int mbx_api[] = { ixgbe_mbox_api_11,
821 ixgbe_mbox_api_unknown };
824 while (mbx_api[i] != ixgbe_mbox_api_unknown) {
825 if (ixgbevf_negotiate_api_version(hw, mbx_api[i]) == 0)
831 } /* ixv_negotiate_api */
834 /************************************************************************
835 * ixv_if_multi_set - Multicast Update
837 * Called whenever multicast address list is updated.
838 ************************************************************************/
840 ixv_if_multi_set(if_ctx_t ctx)
842 u8 mta[MAX_NUM_MULTICAST_ADDRESSES * IXGBE_ETH_LENGTH_OF_ADDRESS];
843 struct adapter *adapter = iflib_get_softc(ctx);
845 struct ifmultiaddr *ifma;
846 if_t ifp = iflib_get_ifp(ctx);
849 IOCTL_DEBUGOUT("ixv_if_multi_set: begin");
851 CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
852 if (ifma->ifma_addr->sa_family != AF_LINK)
854 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
855 &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS],
856 IXGBE_ETH_LENGTH_OF_ADDRESS);
862 adapter->hw.mac.ops.update_mc_addr_list(&adapter->hw, update_ptr, mcnt,
863 ixv_mc_array_itr, TRUE);
864 } /* ixv_if_multi_set */
866 /************************************************************************
869 * An iterator function needed by the multicast shared code.
870 * It feeds the shared code routine the addresses in the
871 * array of ixv_set_multi() one by one.
872 ************************************************************************/
874 ixv_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq)
876 u8 *addr = *update_ptr;
881 newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS;
882 *update_ptr = newptr;
885 } /* ixv_mc_array_itr */
887 /************************************************************************
888 * ixv_if_local_timer - Timer routine
890 * Checks for link status, updates statistics,
891 * and runs the watchdog check.
892 ************************************************************************/
894 ixv_if_local_timer(if_ctx_t ctx, uint16_t qid)
899 /* Fire off the adminq task */
900 iflib_admin_intr_deferred(ctx);
901 } /* ixv_if_local_timer */
903 /************************************************************************
904 * ixv_if_update_admin_status - Update OS on link state
906 * Note: Only updates the OS on the cached link state.
907 * The real check of the hardware only happens with
909 ************************************************************************/
911 ixv_if_update_admin_status(if_ctx_t ctx)
913 struct adapter *adapter = iflib_get_softc(ctx);
914 device_t dev = iflib_get_dev(ctx);
917 adapter->hw.mac.get_link_status = TRUE;
919 status = ixgbe_check_link(&adapter->hw, &adapter->link_speed,
920 &adapter->link_up, FALSE);
922 if (status != IXGBE_SUCCESS && adapter->hw.adapter_stopped == FALSE) {
923 /* Mailbox's Clear To Send status is lost or timeout occurred.
924 * We need reinitialization. */
925 iflib_get_ifp(ctx)->if_init(ctx);
928 if (adapter->link_up) {
929 if (adapter->link_active == FALSE) {
931 device_printf(dev, "Link is up %d Gbps %s \n",
932 ((adapter->link_speed == 128) ? 10 : 1),
934 adapter->link_active = TRUE;
935 iflib_link_state_change(ctx, LINK_STATE_UP,
938 } else { /* Link down */
939 if (adapter->link_active == TRUE) {
941 device_printf(dev, "Link is Down\n");
942 iflib_link_state_change(ctx, LINK_STATE_DOWN, 0);
943 adapter->link_active = FALSE;
948 ixv_update_stats(adapter);
949 } /* ixv_if_update_admin_status */
952 /************************************************************************
953 * ixv_if_stop - Stop the hardware
955 * Disables all traffic on the adapter by issuing a
956 * global reset on the MAC and deallocates TX/RX buffers.
957 ************************************************************************/
959 ixv_if_stop(if_ctx_t ctx)
961 struct adapter *adapter = iflib_get_softc(ctx);
962 struct ixgbe_hw *hw = &adapter->hw;
964 INIT_DEBUGOUT("ixv_stop: begin\n");
966 ixv_if_disable_intr(ctx);
968 hw->mac.ops.reset_hw(hw);
969 adapter->hw.adapter_stopped = FALSE;
970 hw->mac.ops.stop_adapter(hw);
972 /* Update the stack */
973 adapter->link_up = FALSE;
974 ixv_if_update_admin_status(ctx);
976 /* reprogram the RAR[0] in case user changed it. */
977 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
981 /************************************************************************
982 * ixv_identify_hardware - Determine hardware revision.
983 ************************************************************************/
985 ixv_identify_hardware(if_ctx_t ctx)
987 struct adapter *adapter = iflib_get_softc(ctx);
988 device_t dev = iflib_get_dev(ctx);
989 struct ixgbe_hw *hw = &adapter->hw;
991 /* Save off the information about this board */
992 hw->vendor_id = pci_get_vendor(dev);
993 hw->device_id = pci_get_device(dev);
994 hw->revision_id = pci_get_revid(dev);
995 hw->subsystem_vendor_id = pci_get_subvendor(dev);
996 hw->subsystem_device_id = pci_get_subdevice(dev);
998 /* A subset of set_mac_type */
999 switch (hw->device_id) {
1000 case IXGBE_DEV_ID_82599_VF:
1001 hw->mac.type = ixgbe_mac_82599_vf;
1003 case IXGBE_DEV_ID_X540_VF:
1004 hw->mac.type = ixgbe_mac_X540_vf;
1006 case IXGBE_DEV_ID_X550_VF:
1007 hw->mac.type = ixgbe_mac_X550_vf;
1009 case IXGBE_DEV_ID_X550EM_X_VF:
1010 hw->mac.type = ixgbe_mac_X550EM_x_vf;
1012 case IXGBE_DEV_ID_X550EM_A_VF:
1013 hw->mac.type = ixgbe_mac_X550EM_a_vf;
1016 device_printf(dev, "unknown mac type\n");
1017 hw->mac.type = ixgbe_mac_unknown;
1020 } /* ixv_identify_hardware */
1022 /************************************************************************
1023 * ixv_if_msix_intr_assign - Setup MSI-X Interrupt resources and handlers
1024 ************************************************************************/
1026 ixv_if_msix_intr_assign(if_ctx_t ctx, int msix)
1028 struct adapter *adapter = iflib_get_softc(ctx);
1029 device_t dev = iflib_get_dev(ctx);
1030 struct ix_rx_queue *rx_que = adapter->rx_queues;
1031 struct ix_tx_queue *tx_que;
1032 int error, rid, vector = 0;
1035 for (int i = 0; i < adapter->num_rx_queues; i++, vector++, rx_que++) {
1038 snprintf(buf, sizeof(buf), "rxq%d", i);
1039 error = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
1040 IFLIB_INTR_RX, ixv_msix_que, rx_que, rx_que->rxr.me, buf);
1043 device_printf(iflib_get_dev(ctx),
1044 "Failed to allocate que int %d err: %d", i, error);
1045 adapter->num_rx_queues = i + 1;
1049 rx_que->msix = vector;
1050 adapter->active_queues |= (u64)(1 << rx_que->msix);
1054 for (int i = 0; i < adapter->num_tx_queues; i++) {
1055 snprintf(buf, sizeof(buf), "txq%d", i);
1056 tx_que = &adapter->tx_queues[i];
1057 tx_que->msix = i % adapter->num_rx_queues;
1058 iflib_softirq_alloc_generic(ctx,
1059 &adapter->rx_queues[tx_que->msix].que_irq,
1060 IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
1063 error = iflib_irq_alloc_generic(ctx, &adapter->irq, rid,
1064 IFLIB_INTR_ADMIN, ixv_msix_mbx, adapter, 0, "aq");
1066 device_printf(iflib_get_dev(ctx),
1067 "Failed to register admin handler");
1071 adapter->vector = vector;
1073 * Due to a broken design QEMU will fail to properly
1074 * enable the guest for MSIX unless the vectors in
1075 * the table are all set up, so we must rewrite the
1076 * ENABLE in the MSIX control register again at this
1077 * point to cause it to successfully initialize us.
1079 if (adapter->hw.mac.type == ixgbe_mac_82599_vf) {
1081 pci_find_cap(dev, PCIY_MSIX, &rid);
1082 rid += PCIR_MSIX_CTRL;
1083 msix_ctrl = pci_read_config(dev, rid, 2);
1084 msix_ctrl |= PCIM_MSIXCTRL_MSIX_ENABLE;
1085 pci_write_config(dev, rid, msix_ctrl, 2);
1091 iflib_irq_free(ctx, &adapter->irq);
1092 rx_que = adapter->rx_queues;
1093 for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++)
1094 iflib_irq_free(ctx, &rx_que->que_irq);
1097 } /* ixv_if_msix_intr_assign */
1099 /************************************************************************
1100 * ixv_allocate_pci_resources
1101 ************************************************************************/
1103 ixv_allocate_pci_resources(if_ctx_t ctx)
1105 struct adapter *adapter = iflib_get_softc(ctx);
1106 device_t dev = iflib_get_dev(ctx);
1110 adapter->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
1113 if (!(adapter->pci_mem)) {
1114 device_printf(dev, "Unable to allocate bus resource: memory\n");
1118 adapter->osdep.mem_bus_space_tag = rman_get_bustag(adapter->pci_mem);
1119 adapter->osdep.mem_bus_space_handle =
1120 rman_get_bushandle(adapter->pci_mem);
1121 adapter->hw.hw_addr = (u8 *)&adapter->osdep.mem_bus_space_handle;
1124 } /* ixv_allocate_pci_resources */
1126 /************************************************************************
1127 * ixv_free_pci_resources
1128 ************************************************************************/
1130 ixv_free_pci_resources(if_ctx_t ctx)
1132 struct adapter *adapter = iflib_get_softc(ctx);
1133 struct ix_rx_queue *que = adapter->rx_queues;
1134 device_t dev = iflib_get_dev(ctx);
1136 /* Release all msix queue resources */
1137 if (adapter->intr_type == IFLIB_INTR_MSIX)
1138 iflib_irq_free(ctx, &adapter->irq);
1141 for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
1142 iflib_irq_free(ctx, &que->que_irq);
1146 /* Clean the Legacy or Link interrupt last */
1147 if (adapter->pci_mem != NULL)
1148 bus_release_resource(dev, SYS_RES_MEMORY,
1149 PCIR_BAR(0), adapter->pci_mem);
1150 } /* ixv_free_pci_resources */
1152 /************************************************************************
1153 * ixv_setup_interface
1155 * Setup networking device structure and register an interface.
1156 ************************************************************************/
1158 ixv_setup_interface(if_ctx_t ctx)
1160 struct adapter *adapter = iflib_get_softc(ctx);
1161 if_softc_ctx_t scctx = adapter->shared;
1162 struct ifnet *ifp = iflib_get_ifp(ctx);
1164 INIT_DEBUGOUT("ixv_setup_interface: begin");
1166 if_setbaudrate(ifp, IF_Gbps(10));
1167 ifp->if_snd.ifq_maxlen = scctx->isc_ntxd[0] - 2;
1170 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
1171 ifmedia_add(adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1172 ifmedia_set(adapter->media, IFM_ETHER | IFM_AUTO);
1175 } /* ixv_setup_interface */
1177 /************************************************************************
1178 * ixv_if_get_counter
1179 ************************************************************************/
1181 ixv_if_get_counter(if_ctx_t ctx, ift_counter cnt)
1183 struct adapter *adapter = iflib_get_softc(ctx);
1184 if_t ifp = iflib_get_ifp(ctx);
1187 case IFCOUNTER_IPACKETS:
1188 return (adapter->ipackets);
1189 case IFCOUNTER_OPACKETS:
1190 return (adapter->opackets);
1191 case IFCOUNTER_IBYTES:
1192 return (adapter->ibytes);
1193 case IFCOUNTER_OBYTES:
1194 return (adapter->obytes);
1195 case IFCOUNTER_IMCASTS:
1196 return (adapter->imcasts);
1198 return (if_get_counter_default(ifp, cnt));
1200 } /* ixv_if_get_counter */
1202 /************************************************************************
1203 * ixv_initialize_transmit_units - Enable transmit unit.
1204 ************************************************************************/
1206 ixv_initialize_transmit_units(if_ctx_t ctx)
1208 struct adapter *adapter = iflib_get_softc(ctx);
1209 struct ixgbe_hw *hw = &adapter->hw;
1210 if_softc_ctx_t scctx = adapter->shared;
1211 struct ix_tx_queue *que = adapter->tx_queues;
1214 for (i = 0; i < adapter->num_tx_queues; i++, que++) {
1215 struct tx_ring *txr = &que->txr;
1216 u64 tdba = txr->tx_paddr;
1220 /* Set WTHRESH to 8, burst writeback */
1221 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
1222 txdctl |= (8 << 16);
1223 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);
1225 /* Set the HW Tx Head and Tail indices */
1226 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(j), 0);
1227 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(j), 0);
1229 /* Set Tx Tail register */
1230 txr->tail = IXGBE_VFTDT(j);
1232 txr->tx_rs_cidx = txr->tx_rs_pidx = txr->tx_cidx_processed = 0;
1233 for (int k = 0; k < scctx->isc_ntxd[0]; k++)
1234 txr->tx_rsq[k] = QIDX_INVALID;
1236 /* Set Ring parameters */
1237 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j),
1238 (tdba & 0x00000000ffffffffULL));
1239 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32));
1240 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j),
1241 scctx->isc_ntxd[0] * sizeof(struct ixgbe_legacy_tx_desc));
1242 txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j));
1243 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
1244 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl);
1247 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
1248 txdctl |= IXGBE_TXDCTL_ENABLE;
1249 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);
1253 } /* ixv_initialize_transmit_units */
1255 /************************************************************************
1256 * ixv_initialize_rss_mapping
1257 ************************************************************************/
1259 ixv_initialize_rss_mapping(struct adapter *adapter)
1261 struct ixgbe_hw *hw = &adapter->hw;
1262 u32 reta = 0, mrqc, rss_key[10];
1265 u32 rss_hash_config;
1267 if (adapter->feat_en & IXGBE_FEATURE_RSS) {
1268 /* Fetch the configured RSS key */
1269 rss_getkey((uint8_t *)&rss_key);
1271 /* set up random bits */
1272 arc4rand(&rss_key, sizeof(rss_key), 0);
1275 /* Now fill out hash function seeds */
1276 for (i = 0; i < 10; i++)
1277 IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]);
1279 /* Set up the redirection table */
1280 for (i = 0, j = 0; i < 64; i++, j++) {
1281 if (j == adapter->num_rx_queues)
1284 if (adapter->feat_en & IXGBE_FEATURE_RSS) {
1286 * Fetch the RSS bucket id for the given indirection
1287 * entry. Cap it at the number of configured buckets
1288 * (which is num_rx_queues.)
1290 queue_id = rss_get_indirection_to_bucket(i);
1291 queue_id = queue_id % adapter->num_rx_queues;
1296 * The low 8 bits are for hash value (n+0);
1297 * The next 8 bits are for hash value (n+1), etc.
1300 reta |= ((uint32_t)queue_id) << 24;
1302 IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), reta);
1307 /* Perform hash on these packet types */
1308 if (adapter->feat_en & IXGBE_FEATURE_RSS)
1309 rss_hash_config = rss_gethashconfig();
1312 * Disable UDP - IP fragments aren't currently being handled
1313 * and so we end up with a mix of 2-tuple and 4-tuple
1316 rss_hash_config = RSS_HASHTYPE_RSS_IPV4
1317 | RSS_HASHTYPE_RSS_TCP_IPV4
1318 | RSS_HASHTYPE_RSS_IPV6
1319 | RSS_HASHTYPE_RSS_TCP_IPV6;
1322 mrqc = IXGBE_MRQC_RSSEN;
1323 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4)
1324 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4;
1325 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4)
1326 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP;
1327 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6)
1328 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6;
1329 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6)
1330 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP;
1331 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX)
1332 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_IPV6_EX defined, but not supported\n",
1334 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX)
1335 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_TCP_IPV6_EX defined, but not supported\n",
1337 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4)
1338 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP;
1339 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6)
1340 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP;
1341 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX)
1342 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_UDP_IPV6_EX defined, but not supported\n",
1344 IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, mrqc);
1345 } /* ixv_initialize_rss_mapping */
1348 /************************************************************************
1349 * ixv_initialize_receive_units - Setup receive registers and features.
1350 ************************************************************************/
1352 ixv_initialize_receive_units(if_ctx_t ctx)
1354 struct adapter *adapter = iflib_get_softc(ctx);
1355 if_softc_ctx_t scctx;
1356 struct ixgbe_hw *hw = &adapter->hw;
1357 struct ifnet *ifp = iflib_get_ifp(ctx);
1358 struct ix_rx_queue *que = adapter->rx_queues;
1361 if (ifp->if_mtu > ETHERMTU)
1362 bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
1364 bufsz = 2048 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
1366 psrtype = IXGBE_PSRTYPE_TCPHDR
1367 | IXGBE_PSRTYPE_UDPHDR
1368 | IXGBE_PSRTYPE_IPV4HDR
1369 | IXGBE_PSRTYPE_IPV6HDR
1370 | IXGBE_PSRTYPE_L2HDR;
1372 if (adapter->num_rx_queues > 1)
1375 IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype);
1377 /* Tell PF our max_frame size */
1378 if (ixgbevf_rlpml_set_vf(hw, adapter->max_frame_size) != 0) {
1379 device_printf(adapter->dev, "There is a problem with the PF setup. It is likely the receive unit for this VF will not function correctly.\n");
1381 scctx = adapter->shared;
1383 for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
1384 struct rx_ring *rxr = &que->rxr;
1385 u64 rdba = rxr->rx_paddr;
1389 /* Disable the queue */
1390 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j));
1391 rxdctl &= ~IXGBE_RXDCTL_ENABLE;
1392 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
1393 for (int k = 0; k < 10; k++) {
1394 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
1395 IXGBE_RXDCTL_ENABLE)
1401 /* Setup the Base and Length of the Rx Descriptor Ring */
1402 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j),
1403 (rdba & 0x00000000ffffffffULL));
1404 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32));
1405 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j),
1406 scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc));
1408 /* Reset the ring indices */
1409 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0);
1410 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0);
1412 /* Set up the SRRCTL register */
1413 reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j));
1414 reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK;
1415 reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK;
1417 reg |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
1418 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg);
1420 /* Capture Rx Tail index */
1421 rxr->tail = IXGBE_VFRDT(rxr->me);
1423 /* Do the queue enabling last */
1424 rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME;
1425 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
1426 for (int l = 0; l < 10; l++) {
1427 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
1428 IXGBE_RXDCTL_ENABLE)
1434 /* Set the Tail Pointer */
1437 * In netmap mode, we must preserve the buffers made
1438 * available to userspace before the if_init()
1439 * (this is true by default on the TX side, because
1440 * init makes all buffers available to userspace).
1442 * netmap_reset() and the device specific routines
1443 * (e.g. ixgbe_setup_receive_rings()) map these
1444 * buffers at the end of the NIC ring, so here we
1445 * must set the RDT (tail) register to make sure
1446 * they are not overwritten.
1448 * In this driver the NIC ring starts at RDH = 0,
1449 * RDT points to the last slot available for reception (?),
1450 * so RDT = num_rx_desc - 1 means the whole ring is available.
1452 if (ifp->if_capenable & IFCAP_NETMAP) {
1453 struct netmap_adapter *na = NA(ifp);
1454 struct netmap_kring *kring = na->rx_rings[j];
1455 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring);
1457 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t);
1459 #endif /* DEV_NETMAP */
1460 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me),
1461 scctx->isc_nrxd[0] - 1);
1464 ixv_initialize_rss_mapping(adapter);
1465 } /* ixv_initialize_receive_units */
1467 /************************************************************************
1468 * ixv_setup_vlan_support
1469 ************************************************************************/
1471 ixv_setup_vlan_support(if_ctx_t ctx)
1473 struct adapter *adapter = iflib_get_softc(ctx);
1474 struct ixgbe_hw *hw = &adapter->hw;
1475 u32 ctrl, vid, vfta, retry;
1478 * We get here thru if_init, meaning
1479 * a soft reset, this has already cleared
1480 * the VFTA and other state, so if there
1481 * have been no vlan's registered do nothing.
1483 if (adapter->num_vlans == 0)
1486 /* Enable the queues */
1487 for (int i = 0; i < adapter->num_rx_queues; i++) {
1488 ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
1489 ctrl |= IXGBE_RXDCTL_VME;
1490 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), ctrl);
1492 * Let Rx path know that it needs to store VLAN tag
1493 * as part of extra mbuf info.
1495 adapter->rx_queues[i].rxr.vtag_strip = TRUE;
1499 * A soft reset zero's out the VFTA, so
1500 * we need to repopulate it now.
1502 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) {
1503 if (ixv_shadow_vfta[i] == 0)
1505 vfta = ixv_shadow_vfta[i];
1507 * Reconstruct the vlan id's
1508 * based on the bits set in each
1509 * of the array ints.
1511 for (int j = 0; j < 32; j++) {
1513 if ((vfta & (1 << j)) == 0)
1516 /* Call the shared code mailbox routine */
1517 while (hw->mac.ops.set_vfta(hw, vid, 0, TRUE, FALSE)) {
1523 } /* ixv_setup_vlan_support */
1525 /************************************************************************
1526 * ixv_if_register_vlan
1528 * Run via a vlan config EVENT, it enables us to use the
1529 * HW Filter table since we can get the vlan id. This just
1530 * creates the entry in the soft version of the VFTA, init
1531 * will repopulate the real table.
1532 ************************************************************************/
1534 ixv_if_register_vlan(if_ctx_t ctx, u16 vtag)
1536 struct adapter *adapter = iflib_get_softc(ctx);
1539 index = (vtag >> 5) & 0x7F;
1541 ixv_shadow_vfta[index] |= (1 << bit);
1542 ++adapter->num_vlans;
1543 } /* ixv_if_register_vlan */
1545 /************************************************************************
1546 * ixv_if_unregister_vlan
1548 * Run via a vlan unconfig EVENT, remove our entry
1550 ************************************************************************/
1552 ixv_if_unregister_vlan(if_ctx_t ctx, u16 vtag)
1554 struct adapter *adapter = iflib_get_softc(ctx);
1557 index = (vtag >> 5) & 0x7F;
1559 ixv_shadow_vfta[index] &= ~(1 << bit);
1560 --adapter->num_vlans;
1561 } /* ixv_if_unregister_vlan */
1563 /************************************************************************
1564 * ixv_if_enable_intr
1565 ************************************************************************/
1567 ixv_if_enable_intr(if_ctx_t ctx)
1569 struct adapter *adapter = iflib_get_softc(ctx);
1570 struct ixgbe_hw *hw = &adapter->hw;
1571 struct ix_rx_queue *que = adapter->rx_queues;
1572 u32 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE);
1574 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);
1576 mask = IXGBE_EIMS_ENABLE_MASK;
1577 mask &= ~(IXGBE_EIMS_OTHER | IXGBE_EIMS_LSC);
1578 IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask);
1580 for (int i = 0; i < adapter->num_rx_queues; i++, que++)
1581 ixv_enable_queue(adapter, que->msix);
1583 IXGBE_WRITE_FLUSH(hw);
1584 } /* ixv_if_enable_intr */
1586 /************************************************************************
1587 * ixv_if_disable_intr
1588 ************************************************************************/
1590 ixv_if_disable_intr(if_ctx_t ctx)
1592 struct adapter *adapter = iflib_get_softc(ctx);
1593 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIAC, 0);
1594 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIMC, ~0);
1595 IXGBE_WRITE_FLUSH(&adapter->hw);
1596 } /* ixv_if_disable_intr */
1598 /************************************************************************
1599 * ixv_if_rx_queue_intr_enable
1600 ************************************************************************/
1602 ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
1604 struct adapter *adapter = iflib_get_softc(ctx);
1605 struct ix_rx_queue *que = &adapter->rx_queues[rxqid];
1607 ixv_enable_queue(adapter, que->rxr.me);
1610 } /* ixv_if_rx_queue_intr_enable */
1612 /************************************************************************
1615 * Setup the correct IVAR register for a particular MSI-X interrupt
1616 * - entry is the register array entry
1617 * - vector is the MSI-X vector for this queue
1618 * - type is RX/TX/MISC
1619 ************************************************************************/
1621 ixv_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type)
1623 struct ixgbe_hw *hw = &adapter->hw;
1626 vector |= IXGBE_IVAR_ALLOC_VAL;
1628 if (type == -1) { /* MISC IVAR */
1629 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC);
1632 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar);
1633 } else { /* RX/TX IVARS */
1634 index = (16 * (entry & 1)) + (8 * type);
1635 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(entry >> 1));
1636 ivar &= ~(0xFF << index);
1637 ivar |= (vector << index);
1638 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(entry >> 1), ivar);
1640 } /* ixv_set_ivar */
1642 /************************************************************************
1643 * ixv_configure_ivars
1644 ************************************************************************/
1646 ixv_configure_ivars(struct adapter *adapter)
1648 struct ix_rx_queue *que = adapter->rx_queues;
1650 MPASS(adapter->num_rx_queues == adapter->num_tx_queues);
1652 for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
1653 /* First the RX queue entry */
1654 ixv_set_ivar(adapter, i, que->msix, 0);
1655 /* ... and the TX */
1656 ixv_set_ivar(adapter, i, que->msix, 1);
1657 /* Set an initial value in EITR */
1658 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEITR(que->msix),
1659 IXGBE_EITR_DEFAULT);
1662 /* For the mailbox interrupt */
1663 ixv_set_ivar(adapter, 1, adapter->vector, -1);
1664 } /* ixv_configure_ivars */
1666 /************************************************************************
1669 * The VF stats registers never have a truly virgin
1670 * starting point, so this routine tries to make an
1671 * artificial one, marking ground zero on attach as
1673 ************************************************************************/
1675 ixv_save_stats(struct adapter *adapter)
1677 if (adapter->stats.vf.vfgprc || adapter->stats.vf.vfgptc) {
1678 adapter->stats.vf.saved_reset_vfgprc +=
1679 adapter->stats.vf.vfgprc - adapter->stats.vf.base_vfgprc;
1680 adapter->stats.vf.saved_reset_vfgptc +=
1681 adapter->stats.vf.vfgptc - adapter->stats.vf.base_vfgptc;
1682 adapter->stats.vf.saved_reset_vfgorc +=
1683 adapter->stats.vf.vfgorc - adapter->stats.vf.base_vfgorc;
1684 adapter->stats.vf.saved_reset_vfgotc +=
1685 adapter->stats.vf.vfgotc - adapter->stats.vf.base_vfgotc;
1686 adapter->stats.vf.saved_reset_vfmprc +=
1687 adapter->stats.vf.vfmprc - adapter->stats.vf.base_vfmprc;
1689 } /* ixv_save_stats */
1691 /************************************************************************
1693 ************************************************************************/
1695 ixv_init_stats(struct adapter *adapter)
1697 struct ixgbe_hw *hw = &adapter->hw;
1699 adapter->stats.vf.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC);
1700 adapter->stats.vf.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB);
1701 adapter->stats.vf.last_vfgorc |=
1702 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32);
1704 adapter->stats.vf.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC);
1705 adapter->stats.vf.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB);
1706 adapter->stats.vf.last_vfgotc |=
1707 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32);
1709 adapter->stats.vf.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC);
1711 adapter->stats.vf.base_vfgprc = adapter->stats.vf.last_vfgprc;
1712 adapter->stats.vf.base_vfgorc = adapter->stats.vf.last_vfgorc;
1713 adapter->stats.vf.base_vfgptc = adapter->stats.vf.last_vfgptc;
1714 adapter->stats.vf.base_vfgotc = adapter->stats.vf.last_vfgotc;
1715 adapter->stats.vf.base_vfmprc = adapter->stats.vf.last_vfmprc;
1716 } /* ixv_init_stats */
1718 #define UPDATE_STAT_32(reg, last, count) \
1720 u32 current = IXGBE_READ_REG(hw, reg); \
1721 if (current < last) \
1722 count += 0x100000000LL; \
1724 count &= 0xFFFFFFFF00000000LL; \
1728 #define UPDATE_STAT_36(lsb, msb, last, count) \
1730 u64 cur_lsb = IXGBE_READ_REG(hw, lsb); \
1731 u64 cur_msb = IXGBE_READ_REG(hw, msb); \
1732 u64 current = ((cur_msb << 32) | cur_lsb); \
1733 if (current < last) \
1734 count += 0x1000000000LL; \
1736 count &= 0xFFFFFFF000000000LL; \
1740 /************************************************************************
1741 * ixv_update_stats - Update the board statistics counters.
1742 ************************************************************************/
1744 ixv_update_stats(struct adapter *adapter)
1746 struct ixgbe_hw *hw = &adapter->hw;
1747 struct ixgbevf_hw_stats *stats = &adapter->stats.vf;
1749 UPDATE_STAT_32(IXGBE_VFGPRC, adapter->stats.vf.last_vfgprc,
1750 adapter->stats.vf.vfgprc);
1751 UPDATE_STAT_32(IXGBE_VFGPTC, adapter->stats.vf.last_vfgptc,
1752 adapter->stats.vf.vfgptc);
1753 UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB,
1754 adapter->stats.vf.last_vfgorc, adapter->stats.vf.vfgorc);
1755 UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB,
1756 adapter->stats.vf.last_vfgotc, adapter->stats.vf.vfgotc);
1757 UPDATE_STAT_32(IXGBE_VFMPRC, adapter->stats.vf.last_vfmprc,
1758 adapter->stats.vf.vfmprc);
1760 /* Fill out the OS statistics structure */
1761 IXGBE_SET_IPACKETS(adapter, stats->vfgprc);
1762 IXGBE_SET_OPACKETS(adapter, stats->vfgptc);
1763 IXGBE_SET_IBYTES(adapter, stats->vfgorc);
1764 IXGBE_SET_OBYTES(adapter, stats->vfgotc);
1765 IXGBE_SET_IMCASTS(adapter, stats->vfmprc);
1766 } /* ixv_update_stats */
1768 /************************************************************************
1769 * ixv_add_stats_sysctls - Add statistic sysctls for the VF.
1770 ************************************************************************/
1772 ixv_add_stats_sysctls(struct adapter *adapter)
1774 device_t dev = adapter->dev;
1775 struct ix_tx_queue *tx_que = adapter->tx_queues;
1776 struct ix_rx_queue *rx_que = adapter->rx_queues;
1777 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
1778 struct sysctl_oid *tree = device_get_sysctl_tree(dev);
1779 struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
1780 struct ixgbevf_hw_stats *stats = &adapter->stats.vf;
1781 struct sysctl_oid *stat_node, *queue_node;
1782 struct sysctl_oid_list *stat_list, *queue_list;
1784 #define QUEUE_NAME_LEN 32
1785 char namebuf[QUEUE_NAME_LEN];
1787 /* Driver Statistics */
1788 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "watchdog_events",
1789 CTLFLAG_RD, &adapter->watchdog_events, "Watchdog timeouts");
1790 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq",
1791 CTLFLAG_RD, &adapter->link_irq, "Link MSI-X IRQ Handled");
1793 for (int i = 0; i < adapter->num_tx_queues; i++, tx_que++) {
1794 struct tx_ring *txr = &tx_que->txr;
1795 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
1796 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
1797 CTLFLAG_RD, NULL, "Queue Name");
1798 queue_list = SYSCTL_CHILDREN(queue_node);
1800 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
1801 CTLFLAG_RD, &(txr->tso_tx), "TSO Packets");
1802 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_packets",
1803 CTLFLAG_RD, &(txr->total_packets), "TX Packets");
1806 for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++) {
1807 struct rx_ring *rxr = &rx_que->rxr;
1808 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
1809 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
1810 CTLFLAG_RD, NULL, "Queue Name");
1811 queue_list = SYSCTL_CHILDREN(queue_node);
1813 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
1814 CTLFLAG_RD, &(rx_que->irqs), "IRQs on queue");
1815 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets",
1816 CTLFLAG_RD, &(rxr->rx_packets), "RX packets");
1817 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_bytes",
1818 CTLFLAG_RD, &(rxr->rx_bytes), "RX bytes");
1819 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_discarded",
1820 CTLFLAG_RD, &(rxr->rx_discarded), "Discarded RX packets");
1823 stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac",
1824 CTLFLAG_RD, NULL, "VF Statistics (read from HW registers)");
1825 stat_list = SYSCTL_CHILDREN(stat_node);
1827 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_rcvd",
1828 CTLFLAG_RD, &stats->vfgprc, "Good Packets Received");
1829 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_rcvd",
1830 CTLFLAG_RD, &stats->vfgorc, "Good Octets Received");
1831 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "mcast_pkts_rcvd",
1832 CTLFLAG_RD, &stats->vfmprc, "Multicast Packets Received");
1833 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_txd",
1834 CTLFLAG_RD, &stats->vfgptc, "Good Packets Transmitted");
1835 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_txd",
1836 CTLFLAG_RD, &stats->vfgotc, "Good Octets Transmitted");
1837 } /* ixv_add_stats_sysctls */
1839 /************************************************************************
1840 * ixv_print_debug_info
1842 * Called only when em_display_debug_stats is enabled.
1843 * Provides a way to take a look at important statistics
1844 * maintained by the driver and hardware.
1845 ************************************************************************/
1847 ixv_print_debug_info(struct adapter *adapter)
1849 device_t dev = adapter->dev;
1850 struct ixgbe_hw *hw = &adapter->hw;
1852 device_printf(dev, "Error Byte Count = %u \n",
1853 IXGBE_READ_REG(hw, IXGBE_ERRBC));
1855 device_printf(dev, "MBX IRQ Handled: %lu\n", (long)adapter->link_irq);
1856 } /* ixv_print_debug_info */
1858 /************************************************************************
1860 ************************************************************************/
1862 ixv_sysctl_debug(SYSCTL_HANDLER_ARGS)
1864 struct adapter *adapter;
1868 error = sysctl_handle_int(oidp, &result, 0, req);
1870 if (error || !req->newptr)
1874 adapter = (struct adapter *)arg1;
1875 ixv_print_debug_info(adapter);
1879 } /* ixv_sysctl_debug */
1881 /************************************************************************
1882 * ixv_init_device_features
1883 ************************************************************************/
1885 ixv_init_device_features(struct adapter *adapter)
1887 adapter->feat_cap = IXGBE_FEATURE_NETMAP
1890 | IXGBE_FEATURE_LEGACY_TX;
1892 /* A tad short on feature flags for VFs, atm. */
1893 switch (adapter->hw.mac.type) {
1894 case ixgbe_mac_82599_vf:
1896 case ixgbe_mac_X540_vf:
1898 case ixgbe_mac_X550_vf:
1899 case ixgbe_mac_X550EM_x_vf:
1900 case ixgbe_mac_X550EM_a_vf:
1901 adapter->feat_cap |= IXGBE_FEATURE_NEEDS_CTXD;
1907 /* Enabled by default... */
1908 /* Is a virtual function (VF) */
1909 if (adapter->feat_cap & IXGBE_FEATURE_VF)
1910 adapter->feat_en |= IXGBE_FEATURE_VF;
1912 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP)
1913 adapter->feat_en |= IXGBE_FEATURE_NETMAP;
1914 /* Receive-Side Scaling (RSS) */
1915 if (adapter->feat_cap & IXGBE_FEATURE_RSS)
1916 adapter->feat_en |= IXGBE_FEATURE_RSS;
1917 /* Needs advanced context descriptor regardless of offloads req'd */
1918 if (adapter->feat_cap & IXGBE_FEATURE_NEEDS_CTXD)
1919 adapter->feat_en |= IXGBE_FEATURE_NEEDS_CTXD;
1920 } /* ixv_init_device_features */