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"
43 #include <net/netmap.h>
44 #include <dev/netmap/netmap_kern.h>
46 /************************************************************************
48 ************************************************************************/
49 char ixv_driver_version[] = "2.0.1-k";
51 /************************************************************************
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
58 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
59 ************************************************************************/
60 static pci_vendor_info_t ixv_vendor_info_array[] =
62 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_82599_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
63 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X540_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
64 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
65 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_X_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
66 PVID(IXGBE_INTEL_VENDOR_ID, IXGBE_DEV_ID_X550EM_A_VF, "Intel(R) PRO/10GbE Virtual Function Network Driver"),
67 /* required last entry */
71 /************************************************************************
73 ************************************************************************/
74 static void *ixv_register(device_t dev);
75 static int ixv_if_attach_pre(if_ctx_t ctx);
76 static int ixv_if_attach_post(if_ctx_t ctx);
77 static int ixv_if_detach(if_ctx_t ctx);
79 static int ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid);
80 static int ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
81 static int ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs, int nqs, int nqsets);
82 static void ixv_if_queues_free(if_ctx_t ctx);
83 static void ixv_identify_hardware(if_ctx_t ctx);
84 static void ixv_init_device_features(struct adapter *);
85 static int ixv_allocate_pci_resources(if_ctx_t ctx);
86 static void ixv_free_pci_resources(if_ctx_t ctx);
87 static int ixv_setup_interface(if_ctx_t ctx);
88 static void ixv_if_media_status(if_ctx_t , struct ifmediareq *);
89 static int ixv_if_media_change(if_ctx_t ctx);
90 static void ixv_if_update_admin_status(if_ctx_t ctx);
91 static int ixv_if_msix_intr_assign(if_ctx_t ctx, int msix);
93 static int ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu);
94 static void ixv_if_init(if_ctx_t ctx);
95 static void ixv_if_local_timer(if_ctx_t ctx, uint16_t qid);
96 static void ixv_if_stop(if_ctx_t ctx);
97 static int ixv_negotiate_api(struct adapter *);
99 static void ixv_initialize_transmit_units(if_ctx_t ctx);
100 static void ixv_initialize_receive_units(if_ctx_t ctx);
101 static void ixv_initialize_rss_mapping(struct adapter *);
103 static void ixv_setup_vlan_support(if_ctx_t ctx);
104 static void ixv_configure_ivars(struct adapter *);
105 static void ixv_if_enable_intr(if_ctx_t ctx);
106 static void ixv_if_disable_intr(if_ctx_t ctx);
107 static void ixv_if_multi_set(if_ctx_t ctx);
109 static void ixv_if_register_vlan(if_ctx_t, u16);
110 static void ixv_if_unregister_vlan(if_ctx_t, u16);
112 static uint64_t ixv_if_get_counter(if_ctx_t, ift_counter);
114 static void ixv_save_stats(struct adapter *);
115 static void ixv_init_stats(struct adapter *);
116 static void ixv_update_stats(struct adapter *);
117 static void ixv_add_stats_sysctls(struct adapter *adapter);
119 static int ixv_sysctl_debug(SYSCTL_HANDLER_ARGS);
120 static void ixv_set_ivar(struct adapter *, u8, u8, s8);
122 static u8 *ixv_mc_array_itr(struct ixgbe_hw *, u8 **, u32 *);
124 /* The MSI-X Interrupt handlers */
125 static int ixv_msix_que(void *);
126 static int ixv_msix_mbx(void *);
128 /************************************************************************
129 * FreeBSD Device Interface Entry Points
130 ************************************************************************/
131 static device_method_t ixv_methods[] = {
132 /* Device interface */
133 DEVMETHOD(device_register, ixv_register),
134 DEVMETHOD(device_probe, iflib_device_probe),
135 DEVMETHOD(device_attach, iflib_device_attach),
136 DEVMETHOD(device_detach, iflib_device_detach),
137 DEVMETHOD(device_shutdown, iflib_device_shutdown),
141 static driver_t ixv_driver = {
142 "ixv", ixv_methods, sizeof(struct adapter),
145 devclass_t ixv_devclass;
146 DRIVER_MODULE(ixv, pci, ixv_driver, ixv_devclass, 0, 0);
147 IFLIB_PNP_INFO(pci, ixv_driver, ixv_vendor_info_array);
148 MODULE_DEPEND(ixv, iflib, 1, 1, 1);
149 MODULE_DEPEND(ixv, pci, 1, 1, 1);
150 MODULE_DEPEND(ixv, ether, 1, 1, 1);
152 static device_method_t ixv_if_methods[] = {
153 DEVMETHOD(ifdi_attach_pre, ixv_if_attach_pre),
154 DEVMETHOD(ifdi_attach_post, ixv_if_attach_post),
155 DEVMETHOD(ifdi_detach, ixv_if_detach),
156 DEVMETHOD(ifdi_init, ixv_if_init),
157 DEVMETHOD(ifdi_stop, ixv_if_stop),
158 DEVMETHOD(ifdi_msix_intr_assign, ixv_if_msix_intr_assign),
159 DEVMETHOD(ifdi_intr_enable, ixv_if_enable_intr),
160 DEVMETHOD(ifdi_intr_disable, ixv_if_disable_intr),
161 DEVMETHOD(ifdi_tx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
162 DEVMETHOD(ifdi_rx_queue_intr_enable, ixv_if_rx_queue_intr_enable),
163 DEVMETHOD(ifdi_tx_queues_alloc, ixv_if_tx_queues_alloc),
164 DEVMETHOD(ifdi_rx_queues_alloc, ixv_if_rx_queues_alloc),
165 DEVMETHOD(ifdi_queues_free, ixv_if_queues_free),
166 DEVMETHOD(ifdi_update_admin_status, ixv_if_update_admin_status),
167 DEVMETHOD(ifdi_multi_set, ixv_if_multi_set),
168 DEVMETHOD(ifdi_mtu_set, ixv_if_mtu_set),
169 DEVMETHOD(ifdi_media_status, ixv_if_media_status),
170 DEVMETHOD(ifdi_media_change, ixv_if_media_change),
171 DEVMETHOD(ifdi_timer, ixv_if_local_timer),
172 DEVMETHOD(ifdi_vlan_register, ixv_if_register_vlan),
173 DEVMETHOD(ifdi_vlan_unregister, ixv_if_unregister_vlan),
174 DEVMETHOD(ifdi_get_counter, ixv_if_get_counter),
178 static driver_t ixv_if_driver = {
179 "ixv_if", ixv_if_methods, sizeof(struct adapter)
183 * TUNEABLE PARAMETERS:
186 /* Flow control setting, default to full */
187 static int ixv_flow_control = ixgbe_fc_full;
188 TUNABLE_INT("hw.ixv.flow_control", &ixv_flow_control);
191 * Header split: this causes the hardware to DMA
192 * the header into a separate mbuf from the payload,
193 * it can be a performance win in some workloads, but
194 * in others it actually hurts, its off by default.
196 static int ixv_header_split = FALSE;
197 TUNABLE_INT("hw.ixv.hdr_split", &ixv_header_split);
200 * Shadow VFTA table, this is needed because
201 * the real filter table gets cleared during
202 * a soft reset and we need to repopulate it.
204 static u32 ixv_shadow_vfta[IXGBE_VFTA_SIZE];
205 extern struct if_txrx ixgbe_txrx;
207 static struct if_shared_ctx ixv_sctx_init = {
208 .isc_magic = IFLIB_MAGIC,
209 .isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */
210 .isc_tx_maxsize = IXGBE_TSO_SIZE + sizeof(struct ether_vlan_header),
211 .isc_tx_maxsegsize = PAGE_SIZE,
212 .isc_tso_maxsize = IXGBE_TSO_SIZE + sizeof(struct ether_vlan_header),
213 .isc_tso_maxsegsize = PAGE_SIZE,
214 .isc_rx_maxsize = MJUM16BYTES,
215 .isc_rx_nsegments = 1,
216 .isc_rx_maxsegsize = MJUM16BYTES,
220 .isc_admin_intrcnt = 1,
221 .isc_vendor_info = ixv_vendor_info_array,
222 .isc_driver_version = ixv_driver_version,
223 .isc_driver = &ixv_if_driver,
224 .isc_flags = IFLIB_IS_VF | IFLIB_TSO_INIT_IP,
226 .isc_nrxd_min = {MIN_RXD},
227 .isc_ntxd_min = {MIN_TXD},
228 .isc_nrxd_max = {MAX_RXD},
229 .isc_ntxd_max = {MAX_TXD},
230 .isc_nrxd_default = {DEFAULT_RXD},
231 .isc_ntxd_default = {DEFAULT_TXD},
234 if_shared_ctx_t ixv_sctx = &ixv_sctx_init;
237 ixv_register(device_t dev)
242 /************************************************************************
243 * ixv_if_tx_queues_alloc
244 ************************************************************************/
246 ixv_if_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs,
247 int ntxqs, int ntxqsets)
249 struct adapter *adapter = iflib_get_softc(ctx);
250 if_softc_ctx_t scctx = adapter->shared;
251 struct ix_tx_queue *que;
254 MPASS(adapter->num_tx_queues == ntxqsets);
257 /* Allocate queue structure memory */
259 (struct ix_tx_queue *)malloc(sizeof(struct ix_tx_queue) * ntxqsets,
260 M_DEVBUF, M_NOWAIT | M_ZERO);
261 if (!adapter->tx_queues) {
262 device_printf(iflib_get_dev(ctx),
263 "Unable to allocate TX ring memory\n");
267 for (i = 0, que = adapter->tx_queues; i < ntxqsets; i++, que++) {
268 struct tx_ring *txr = &que->txr;
271 txr->adapter = que->adapter = adapter;
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))) {
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];
286 txr->total_packets = 0;
290 device_printf(iflib_get_dev(ctx), "allocated for %d queues\n",
291 adapter->num_tx_queues);
296 ixv_if_queues_free(ctx);
299 } /* ixv_if_tx_queues_alloc */
301 /************************************************************************
302 * ixv_if_rx_queues_alloc
303 ************************************************************************/
305 ixv_if_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs, uint64_t *paddrs,
306 int nrxqs, int nrxqsets)
308 struct adapter *adapter = iflib_get_softc(ctx);
309 struct ix_rx_queue *que;
312 MPASS(adapter->num_rx_queues == nrxqsets);
315 /* Allocate queue structure memory */
317 (struct ix_rx_queue *)malloc(sizeof(struct ix_rx_queue) * nrxqsets,
318 M_DEVBUF, M_NOWAIT | M_ZERO);
319 if (!adapter->rx_queues) {
320 device_printf(iflib_get_dev(ctx),
321 "Unable to allocate TX ring memory\n");
326 for (i = 0, que = adapter->rx_queues; i < nrxqsets; i++, que++) {
327 struct rx_ring *rxr = &que->rxr;
329 rxr->adapter = que->adapter = adapter;
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];
340 device_printf(iflib_get_dev(ctx), "allocated for %d rx queues\n",
341 adapter->num_rx_queues);
346 ixv_if_queues_free(ctx);
349 } /* ixv_if_rx_queues_alloc */
351 /************************************************************************
353 ************************************************************************/
355 ixv_if_queues_free(if_ctx_t ctx)
357 struct adapter *adapter = iflib_get_softc(ctx);
358 struct ix_tx_queue *que = adapter->tx_queues;
364 for (i = 0; i < adapter->num_tx_queues; i++, que++) {
365 struct tx_ring *txr = &que->txr;
366 if (txr->tx_rsq == NULL)
369 free(txr->tx_rsq, M_DEVBUF);
372 if (adapter->tx_queues != NULL)
373 free(adapter->tx_queues, M_DEVBUF);
375 if (adapter->rx_queues != NULL)
376 free(adapter->rx_queues, M_DEVBUF);
377 adapter->tx_queues = NULL;
378 adapter->rx_queues = NULL;
379 } /* ixv_if_queues_free */
381 /************************************************************************
382 * ixv_if_attach_pre - Device initialization routine
384 * Called when the driver is being loaded.
385 * Identifies the type of hardware, allocates all resources
386 * and initializes the hardware.
388 * return 0 on success, positive on failure
389 ************************************************************************/
391 ixv_if_attach_pre(if_ctx_t ctx)
393 struct adapter *adapter;
395 if_softc_ctx_t scctx;
399 INIT_DEBUGOUT("ixv_attach: begin");
401 /* Allocate, clear, and link in our adapter structure */
402 dev = iflib_get_dev(ctx);
403 adapter = iflib_get_softc(ctx);
406 adapter->hw.back = adapter;
407 scctx = adapter->shared = iflib_get_softc_ctx(ctx);
408 adapter->media = iflib_get_media(ctx);
411 /* Do base PCI setup - map BAR0 */
412 if (ixv_allocate_pci_resources(ctx)) {
413 device_printf(dev, "ixv_allocate_pci_resources() failed!\n");
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, adapter, 0, ixv_sysctl_debug, "I",
424 /* Determine hardware revision */
425 ixv_identify_hardware(ctx);
426 ixv_init_device_features(adapter);
428 /* Initialize the shared code */
429 error = ixgbe_init_ops_vf(hw);
431 device_printf(dev, "ixgbe_init_ops_vf() failed!\n");
436 /* Setup the mailbox */
437 ixgbe_init_mbx_params_vf(hw);
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");
443 device_printf(dev, "...reset_hw() failed with error %d\n",
450 error = hw->mac.ops.init_hw(hw);
452 device_printf(dev, "...init_hw() failed with error %d\n",
458 /* Negotiate mailbox API version */
459 error = ixv_negotiate_api(adapter);
462 "Mailbox API negotiation failed during attach!\n");
466 /* If no mac address was assigned, make a random one */
467 if (!ixv_check_ether_addr(hw->mac.addr)) {
468 u8 addr[ETHER_ADDR_LEN];
469 arc4rand(&addr, sizeof(addr), 0);
472 bcopy(addr, hw->mac.addr, sizeof(addr));
473 bcopy(addr, hw->mac.perm_addr, sizeof(addr));
476 /* Most of the iflib initialization... */
478 iflib_set_mac(ctx, hw->mac.addr);
479 switch (adapter->hw.mac.type) {
480 case ixgbe_mac_X550_vf:
481 case ixgbe_mac_X550EM_x_vf:
482 case ixgbe_mac_X550EM_a_vf:
483 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 2;
486 scctx->isc_ntxqsets_max = scctx->isc_nrxqsets_max = 1;
488 scctx->isc_txqsizes[0] =
489 roundup2(scctx->isc_ntxd[0] * sizeof(union ixgbe_adv_tx_desc) +
490 sizeof(u32), DBA_ALIGN);
491 scctx->isc_rxqsizes[0] =
492 roundup2(scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc),
495 scctx->isc_tx_csum_flags = CSUM_IP | CSUM_TCP | CSUM_UDP | CSUM_TSO |
496 CSUM_IP6_TCP | CSUM_IP6_UDP | CSUM_IP6_TSO;
497 scctx->isc_tx_nsegments = IXGBE_82599_SCATTER;
498 scctx->isc_msix_bar = pci_msix_table_bar(dev);
499 scctx->isc_tx_tso_segments_max = scctx->isc_tx_nsegments;
500 scctx->isc_tx_tso_size_max = IXGBE_TSO_SIZE;
501 scctx->isc_tx_tso_segsize_max = PAGE_SIZE;
503 scctx->isc_txrx = &ixgbe_txrx;
506 * Tell the upper layer(s) we support everything the PF
507 * driver does except...
510 scctx->isc_capabilities = IXGBE_CAPS;
511 scctx->isc_capabilities ^= IFCAP_WOL;
512 scctx->isc_capenable = scctx->isc_capabilities;
514 INIT_DEBUGOUT("ixv_if_attach_pre: end");
519 ixv_free_pci_resources(ctx);
522 } /* ixv_if_attach_pre */
525 ixv_if_attach_post(if_ctx_t ctx)
527 struct adapter *adapter = iflib_get_softc(ctx);
528 device_t dev = iflib_get_dev(ctx);
531 /* Setup OS specific network interface */
532 error = ixv_setup_interface(ctx);
534 device_printf(dev, "Interface setup failed: %d\n", error);
538 /* Do the stats setup */
539 ixv_save_stats(adapter);
540 ixv_init_stats(adapter);
541 ixv_add_stats_sysctls(adapter);
545 } /* ixv_if_attach_post */
547 /************************************************************************
548 * ixv_detach - Device removal routine
550 * Called when the driver is being removed.
551 * Stops the adapter and deallocates all the resources
552 * that were allocated for driver operation.
554 * return 0 on success, positive on failure
555 ************************************************************************/
557 ixv_if_detach(if_ctx_t ctx)
559 INIT_DEBUGOUT("ixv_detach: begin");
561 ixv_free_pci_resources(ctx);
564 } /* ixv_if_detach */
566 /************************************************************************
568 ************************************************************************/
570 ixv_if_mtu_set(if_ctx_t ctx, uint32_t mtu)
572 struct adapter *adapter = iflib_get_softc(ctx);
573 struct ifnet *ifp = iflib_get_ifp(ctx);
576 IOCTL_DEBUGOUT("ioctl: SIOCSIFMTU (Set Interface MTU)");
577 if (mtu > IXGBE_MAX_FRAME_SIZE - IXGBE_MTU_HDR) {
581 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
585 } /* ixv_if_mtu_set */
587 /************************************************************************
588 * ixv_if_init - Init entry point
590 * Used in two ways: It is used by the stack as an init entry
591 * point in network interface structure. It is also used
592 * by the driver as a hw/sw initialization routine to get
593 * to a consistent state.
595 * return 0 on success, positive on failure
596 ************************************************************************/
598 ixv_if_init(if_ctx_t ctx)
600 struct adapter *adapter = iflib_get_softc(ctx);
601 struct ifnet *ifp = iflib_get_ifp(ctx);
602 device_t dev = iflib_get_dev(ctx);
603 struct ixgbe_hw *hw = &adapter->hw;
606 INIT_DEBUGOUT("ixv_if_init: begin");
607 hw->adapter_stopped = FALSE;
608 hw->mac.ops.stop_adapter(hw);
610 /* reprogram the RAR[0] in case user changed it. */
611 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
613 /* Get the latest mac address, User can use a LAA */
614 bcopy(IF_LLADDR(ifp), hw->mac.addr, IXGBE_ETH_LENGTH_OF_ADDRESS);
615 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, 1);
617 /* Reset VF and renegotiate mailbox API version */
618 hw->mac.ops.reset_hw(hw);
619 hw->mac.ops.start_hw(hw);
620 error = ixv_negotiate_api(adapter);
623 "Mailbox API negotiation failed in if_init!\n");
627 ixv_initialize_transmit_units(ctx);
629 /* Setup Multicast table */
630 ixv_if_multi_set(ctx);
632 adapter->rx_mbuf_sz = iflib_get_rx_mbuf_sz(ctx);
634 /* Configure RX settings */
635 ixv_initialize_receive_units(ctx);
637 /* Set up VLAN offload and filter */
638 ixv_setup_vlan_support(ctx);
640 /* Set up MSI-X routing */
641 ixv_configure_ivars(adapter);
643 /* Set up auto-mask */
644 IXGBE_WRITE_REG(hw, IXGBE_VTEIAM, IXGBE_EICS_RTX_QUEUE);
646 /* Set moderation on the Link interrupt */
647 IXGBE_WRITE_REG(hw, IXGBE_VTEITR(adapter->vector), IXGBE_LINK_ITR);
650 ixv_init_stats(adapter);
652 /* Config/Enable Link */
653 hw->mac.ops.check_link(hw, &adapter->link_speed, &adapter->link_up,
656 /* And now turn on interrupts */
657 ixv_if_enable_intr(ctx);
662 /************************************************************************
664 ************************************************************************/
666 ixv_enable_queue(struct adapter *adapter, u32 vector)
668 struct ixgbe_hw *hw = &adapter->hw;
669 u32 queue = 1 << vector;
672 mask = (IXGBE_EIMS_RTX_QUEUE & queue);
673 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);
674 } /* ixv_enable_queue */
676 /************************************************************************
678 ************************************************************************/
680 ixv_disable_queue(struct adapter *adapter, u32 vector)
682 struct ixgbe_hw *hw = &adapter->hw;
683 u64 queue = (u64)(1 << vector);
686 mask = (IXGBE_EIMS_RTX_QUEUE & queue);
687 IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, mask);
688 } /* ixv_disable_queue */
691 /************************************************************************
692 * ixv_msix_que - MSI-X Queue Interrupt Service routine
693 ************************************************************************/
695 ixv_msix_que(void *arg)
697 struct ix_rx_queue *que = arg;
698 struct adapter *adapter = que->adapter;
700 ixv_disable_queue(adapter, que->msix);
703 return (FILTER_SCHEDULE_THREAD);
706 /************************************************************************
708 ************************************************************************/
710 ixv_msix_mbx(void *arg)
712 struct adapter *adapter = arg;
713 struct ixgbe_hw *hw = &adapter->hw;
718 /* First get the cause */
719 reg = IXGBE_READ_REG(hw, IXGBE_VTEICS);
720 /* Clear interrupt with write */
721 IXGBE_WRITE_REG(hw, IXGBE_VTEICR, reg);
723 /* Link status change */
724 if (reg & IXGBE_EICR_LSC)
725 iflib_admin_intr_deferred(adapter->ctx);
727 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, IXGBE_EIMS_OTHER);
729 return (FILTER_HANDLED);
732 /************************************************************************
733 * ixv_media_status - Media Ioctl callback
735 * Called whenever the user queries the status of
736 * the interface using ifconfig.
737 ************************************************************************/
739 ixv_if_media_status(if_ctx_t ctx, struct ifmediareq * ifmr)
741 struct adapter *adapter = iflib_get_softc(ctx);
743 INIT_DEBUGOUT("ixv_media_status: begin");
745 iflib_admin_intr_deferred(ctx);
747 ifmr->ifm_status = IFM_AVALID;
748 ifmr->ifm_active = IFM_ETHER;
750 if (!adapter->link_active)
753 ifmr->ifm_status |= IFM_ACTIVE;
755 switch (adapter->link_speed) {
756 case IXGBE_LINK_SPEED_1GB_FULL:
757 ifmr->ifm_active |= IFM_1000_T | IFM_FDX;
759 case IXGBE_LINK_SPEED_10GB_FULL:
760 ifmr->ifm_active |= IFM_10G_T | IFM_FDX;
762 case IXGBE_LINK_SPEED_100_FULL:
763 ifmr->ifm_active |= IFM_100_TX | IFM_FDX;
765 case IXGBE_LINK_SPEED_10_FULL:
766 ifmr->ifm_active |= IFM_10_T | IFM_FDX;
769 } /* ixv_if_media_status */
771 /************************************************************************
772 * ixv_if_media_change - Media Ioctl callback
774 * Called when the user changes speed/duplex using
775 * media/mediopt option with ifconfig.
776 ************************************************************************/
778 ixv_if_media_change(if_ctx_t ctx)
780 struct adapter *adapter = iflib_get_softc(ctx);
781 struct ifmedia *ifm = iflib_get_media(ctx);
783 INIT_DEBUGOUT("ixv_media_change: begin");
785 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
788 switch (IFM_SUBTYPE(ifm->ifm_media)) {
792 device_printf(adapter->dev, "Only auto media type\n");
797 } /* ixv_if_media_change */
800 /************************************************************************
803 * Negotiate the Mailbox API with the PF;
804 * start with the most featured API first.
805 ************************************************************************/
807 ixv_negotiate_api(struct adapter *adapter)
809 struct ixgbe_hw *hw = &adapter->hw;
810 int mbx_api[] = { ixgbe_mbox_api_11,
812 ixgbe_mbox_api_unknown };
815 while (mbx_api[i] != ixgbe_mbox_api_unknown) {
816 if (ixgbevf_negotiate_api_version(hw, mbx_api[i]) == 0)
822 } /* ixv_negotiate_api */
825 /************************************************************************
826 * ixv_if_multi_set - Multicast Update
828 * Called whenever multicast address list is updated.
829 ************************************************************************/
831 ixv_if_multi_set(if_ctx_t ctx)
833 u8 mta[MAX_NUM_MULTICAST_ADDRESSES * IXGBE_ETH_LENGTH_OF_ADDRESS];
834 struct adapter *adapter = iflib_get_softc(ctx);
836 struct ifmultiaddr *ifma;
837 if_t ifp = iflib_get_ifp(ctx);
840 IOCTL_DEBUGOUT("ixv_if_multi_set: begin");
842 CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
843 if (ifma->ifma_addr->sa_family != AF_LINK)
845 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
846 &mta[mcnt * IXGBE_ETH_LENGTH_OF_ADDRESS],
847 IXGBE_ETH_LENGTH_OF_ADDRESS);
853 adapter->hw.mac.ops.update_mc_addr_list(&adapter->hw, update_ptr, mcnt,
854 ixv_mc_array_itr, TRUE);
855 } /* ixv_if_multi_set */
857 /************************************************************************
860 * An iterator function needed by the multicast shared code.
861 * It feeds the shared code routine the addresses in the
862 * array of ixv_set_multi() one by one.
863 ************************************************************************/
865 ixv_mc_array_itr(struct ixgbe_hw *hw, u8 **update_ptr, u32 *vmdq)
867 u8 *addr = *update_ptr;
872 newptr = addr + IXGBE_ETH_LENGTH_OF_ADDRESS;
873 *update_ptr = newptr;
876 } /* ixv_mc_array_itr */
878 /************************************************************************
879 * ixv_if_local_timer - Timer routine
881 * Checks for link status, updates statistics,
882 * and runs the watchdog check.
883 ************************************************************************/
885 ixv_if_local_timer(if_ctx_t ctx, uint16_t qid)
890 /* Fire off the adminq task */
891 iflib_admin_intr_deferred(ctx);
892 } /* ixv_if_local_timer */
894 /************************************************************************
895 * ixv_if_update_admin_status - Update OS on link state
897 * Note: Only updates the OS on the cached link state.
898 * The real check of the hardware only happens with
900 ************************************************************************/
902 ixv_if_update_admin_status(if_ctx_t ctx)
904 struct adapter *adapter = iflib_get_softc(ctx);
905 device_t dev = iflib_get_dev(ctx);
908 adapter->hw.mac.get_link_status = TRUE;
910 status = ixgbe_check_link(&adapter->hw, &adapter->link_speed,
911 &adapter->link_up, FALSE);
913 if (status != IXGBE_SUCCESS && adapter->hw.adapter_stopped == FALSE) {
914 /* Mailbox's Clear To Send status is lost or timeout occurred.
915 * We need reinitialization. */
916 iflib_get_ifp(ctx)->if_init(ctx);
919 if (adapter->link_up) {
920 if (adapter->link_active == FALSE) {
922 device_printf(dev, "Link is up %d Gbps %s \n",
923 ((adapter->link_speed == 128) ? 10 : 1),
925 adapter->link_active = TRUE;
926 iflib_link_state_change(ctx, LINK_STATE_UP,
929 } else { /* Link down */
930 if (adapter->link_active == TRUE) {
932 device_printf(dev, "Link is Down\n");
933 iflib_link_state_change(ctx, LINK_STATE_DOWN, 0);
934 adapter->link_active = FALSE;
939 ixv_update_stats(adapter);
940 } /* ixv_if_update_admin_status */
943 /************************************************************************
944 * ixv_if_stop - Stop the hardware
946 * Disables all traffic on the adapter by issuing a
947 * global reset on the MAC and deallocates TX/RX buffers.
948 ************************************************************************/
950 ixv_if_stop(if_ctx_t ctx)
952 struct adapter *adapter = iflib_get_softc(ctx);
953 struct ixgbe_hw *hw = &adapter->hw;
955 INIT_DEBUGOUT("ixv_stop: begin\n");
957 ixv_if_disable_intr(ctx);
959 hw->mac.ops.reset_hw(hw);
960 adapter->hw.adapter_stopped = FALSE;
961 hw->mac.ops.stop_adapter(hw);
963 /* Update the stack */
964 adapter->link_up = FALSE;
965 ixv_if_update_admin_status(ctx);
967 /* reprogram the RAR[0] in case user changed it. */
968 hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0, IXGBE_RAH_AV);
972 /************************************************************************
973 * ixv_identify_hardware - Determine hardware revision.
974 ************************************************************************/
976 ixv_identify_hardware(if_ctx_t ctx)
978 struct adapter *adapter = iflib_get_softc(ctx);
979 device_t dev = iflib_get_dev(ctx);
980 struct ixgbe_hw *hw = &adapter->hw;
982 /* Save off the information about this board */
983 hw->vendor_id = pci_get_vendor(dev);
984 hw->device_id = pci_get_device(dev);
985 hw->revision_id = pci_get_revid(dev);
986 hw->subsystem_vendor_id = pci_get_subvendor(dev);
987 hw->subsystem_device_id = pci_get_subdevice(dev);
989 /* A subset of set_mac_type */
990 switch (hw->device_id) {
991 case IXGBE_DEV_ID_82599_VF:
992 hw->mac.type = ixgbe_mac_82599_vf;
994 case IXGBE_DEV_ID_X540_VF:
995 hw->mac.type = ixgbe_mac_X540_vf;
997 case IXGBE_DEV_ID_X550_VF:
998 hw->mac.type = ixgbe_mac_X550_vf;
1000 case IXGBE_DEV_ID_X550EM_X_VF:
1001 hw->mac.type = ixgbe_mac_X550EM_x_vf;
1003 case IXGBE_DEV_ID_X550EM_A_VF:
1004 hw->mac.type = ixgbe_mac_X550EM_a_vf;
1007 device_printf(dev, "unknown mac type\n");
1008 hw->mac.type = ixgbe_mac_unknown;
1011 } /* ixv_identify_hardware */
1013 /************************************************************************
1014 * ixv_if_msix_intr_assign - Setup MSI-X Interrupt resources and handlers
1015 ************************************************************************/
1017 ixv_if_msix_intr_assign(if_ctx_t ctx, int msix)
1019 struct adapter *adapter = iflib_get_softc(ctx);
1020 device_t dev = iflib_get_dev(ctx);
1021 struct ix_rx_queue *rx_que = adapter->rx_queues;
1022 struct ix_tx_queue *tx_que;
1023 int error, rid, vector = 0;
1026 for (int i = 0; i < adapter->num_rx_queues; i++, vector++, rx_que++) {
1029 snprintf(buf, sizeof(buf), "rxq%d", i);
1030 error = iflib_irq_alloc_generic(ctx, &rx_que->que_irq, rid,
1031 IFLIB_INTR_RX, ixv_msix_que, rx_que, rx_que->rxr.me, buf);
1034 device_printf(iflib_get_dev(ctx),
1035 "Failed to allocate que int %d err: %d", i, error);
1036 adapter->num_rx_queues = i + 1;
1040 rx_que->msix = vector;
1043 for (int i = 0; i < adapter->num_tx_queues; i++) {
1044 snprintf(buf, sizeof(buf), "txq%d", i);
1045 tx_que = &adapter->tx_queues[i];
1046 tx_que->msix = i % adapter->num_rx_queues;
1047 iflib_softirq_alloc_generic(ctx,
1048 &adapter->rx_queues[tx_que->msix].que_irq,
1049 IFLIB_INTR_TX, tx_que, tx_que->txr.me, buf);
1052 error = iflib_irq_alloc_generic(ctx, &adapter->irq, rid,
1053 IFLIB_INTR_ADMIN, ixv_msix_mbx, adapter, 0, "aq");
1055 device_printf(iflib_get_dev(ctx),
1056 "Failed to register admin handler");
1060 adapter->vector = vector;
1062 * Due to a broken design QEMU will fail to properly
1063 * enable the guest for MSIX unless the vectors in
1064 * the table are all set up, so we must rewrite the
1065 * ENABLE in the MSIX control register again at this
1066 * point to cause it to successfully initialize us.
1068 if (adapter->hw.mac.type == ixgbe_mac_82599_vf) {
1070 pci_find_cap(dev, PCIY_MSIX, &rid);
1071 rid += PCIR_MSIX_CTRL;
1072 msix_ctrl = pci_read_config(dev, rid, 2);
1073 msix_ctrl |= PCIM_MSIXCTRL_MSIX_ENABLE;
1074 pci_write_config(dev, rid, msix_ctrl, 2);
1080 iflib_irq_free(ctx, &adapter->irq);
1081 rx_que = adapter->rx_queues;
1082 for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++)
1083 iflib_irq_free(ctx, &rx_que->que_irq);
1086 } /* ixv_if_msix_intr_assign */
1088 /************************************************************************
1089 * ixv_allocate_pci_resources
1090 ************************************************************************/
1092 ixv_allocate_pci_resources(if_ctx_t ctx)
1094 struct adapter *adapter = iflib_get_softc(ctx);
1095 device_t dev = iflib_get_dev(ctx);
1099 adapter->pci_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
1102 if (!(adapter->pci_mem)) {
1103 device_printf(dev, "Unable to allocate bus resource: memory\n");
1107 adapter->osdep.mem_bus_space_tag = rman_get_bustag(adapter->pci_mem);
1108 adapter->osdep.mem_bus_space_handle =
1109 rman_get_bushandle(adapter->pci_mem);
1110 adapter->hw.hw_addr = (u8 *)&adapter->osdep.mem_bus_space_handle;
1113 } /* ixv_allocate_pci_resources */
1115 /************************************************************************
1116 * ixv_free_pci_resources
1117 ************************************************************************/
1119 ixv_free_pci_resources(if_ctx_t ctx)
1121 struct adapter *adapter = iflib_get_softc(ctx);
1122 struct ix_rx_queue *que = adapter->rx_queues;
1123 device_t dev = iflib_get_dev(ctx);
1125 /* Release all MSI-X queue resources */
1126 if (adapter->intr_type == IFLIB_INTR_MSIX)
1127 iflib_irq_free(ctx, &adapter->irq);
1130 for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
1131 iflib_irq_free(ctx, &que->que_irq);
1135 if (adapter->pci_mem != NULL)
1136 bus_release_resource(dev, SYS_RES_MEMORY,
1137 rman_get_rid(adapter->pci_mem), adapter->pci_mem);
1138 } /* ixv_free_pci_resources */
1140 /************************************************************************
1141 * ixv_setup_interface
1143 * Setup networking device structure and register an interface.
1144 ************************************************************************/
1146 ixv_setup_interface(if_ctx_t ctx)
1148 struct adapter *adapter = iflib_get_softc(ctx);
1149 if_softc_ctx_t scctx = adapter->shared;
1150 struct ifnet *ifp = iflib_get_ifp(ctx);
1152 INIT_DEBUGOUT("ixv_setup_interface: begin");
1154 if_setbaudrate(ifp, IF_Gbps(10));
1155 ifp->if_snd.ifq_maxlen = scctx->isc_ntxd[0] - 2;
1158 adapter->max_frame_size = ifp->if_mtu + IXGBE_MTU_HDR;
1159 ifmedia_add(adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1160 ifmedia_set(adapter->media, IFM_ETHER | IFM_AUTO);
1163 } /* ixv_setup_interface */
1165 /************************************************************************
1166 * ixv_if_get_counter
1167 ************************************************************************/
1169 ixv_if_get_counter(if_ctx_t ctx, ift_counter cnt)
1171 struct adapter *adapter = iflib_get_softc(ctx);
1172 if_t ifp = iflib_get_ifp(ctx);
1175 case IFCOUNTER_IPACKETS:
1176 return (adapter->ipackets);
1177 case IFCOUNTER_OPACKETS:
1178 return (adapter->opackets);
1179 case IFCOUNTER_IBYTES:
1180 return (adapter->ibytes);
1181 case IFCOUNTER_OBYTES:
1182 return (adapter->obytes);
1183 case IFCOUNTER_IMCASTS:
1184 return (adapter->imcasts);
1186 return (if_get_counter_default(ifp, cnt));
1188 } /* ixv_if_get_counter */
1190 /************************************************************************
1191 * ixv_initialize_transmit_units - Enable transmit unit.
1192 ************************************************************************/
1194 ixv_initialize_transmit_units(if_ctx_t ctx)
1196 struct adapter *adapter = iflib_get_softc(ctx);
1197 struct ixgbe_hw *hw = &adapter->hw;
1198 if_softc_ctx_t scctx = adapter->shared;
1199 struct ix_tx_queue *que = adapter->tx_queues;
1202 for (i = 0; i < adapter->num_tx_queues; i++, que++) {
1203 struct tx_ring *txr = &que->txr;
1204 u64 tdba = txr->tx_paddr;
1208 /* Set WTHRESH to 8, burst writeback */
1209 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
1210 txdctl |= (8 << 16);
1211 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);
1213 /* Set the HW Tx Head and Tail indices */
1214 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDH(j), 0);
1215 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VFTDT(j), 0);
1217 /* Set Tx Tail register */
1218 txr->tail = IXGBE_VFTDT(j);
1220 txr->tx_rs_cidx = txr->tx_rs_pidx;
1221 /* Initialize the last processed descriptor to be the end of
1222 * the ring, rather than the start, so that we avoid an
1223 * off-by-one error when calculating how many descriptors are
1224 * done in the credits_update function.
1226 txr->tx_cidx_processed = scctx->isc_ntxd[0] - 1;
1227 for (int k = 0; k < scctx->isc_ntxd[0]; k++)
1228 txr->tx_rsq[k] = QIDX_INVALID;
1230 /* Set Ring parameters */
1231 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(j),
1232 (tdba & 0x00000000ffffffffULL));
1233 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(j), (tdba >> 32));
1234 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(j),
1235 scctx->isc_ntxd[0] * sizeof(struct ixgbe_legacy_tx_desc));
1236 txctrl = IXGBE_READ_REG(hw, IXGBE_VFDCA_TXCTRL(j));
1237 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
1238 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(j), txctrl);
1241 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(j));
1242 txdctl |= IXGBE_TXDCTL_ENABLE;
1243 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(j), txdctl);
1247 } /* ixv_initialize_transmit_units */
1249 /************************************************************************
1250 * ixv_initialize_rss_mapping
1251 ************************************************************************/
1253 ixv_initialize_rss_mapping(struct adapter *adapter)
1255 struct ixgbe_hw *hw = &adapter->hw;
1256 u32 reta = 0, mrqc, rss_key[10];
1259 u32 rss_hash_config;
1261 if (adapter->feat_en & IXGBE_FEATURE_RSS) {
1262 /* Fetch the configured RSS key */
1263 rss_getkey((uint8_t *)&rss_key);
1265 /* set up random bits */
1266 arc4rand(&rss_key, sizeof(rss_key), 0);
1269 /* Now fill out hash function seeds */
1270 for (i = 0; i < 10; i++)
1271 IXGBE_WRITE_REG(hw, IXGBE_VFRSSRK(i), rss_key[i]);
1273 /* Set up the redirection table */
1274 for (i = 0, j = 0; i < 64; i++, j++) {
1275 if (j == adapter->num_rx_queues)
1278 if (adapter->feat_en & IXGBE_FEATURE_RSS) {
1280 * Fetch the RSS bucket id for the given indirection
1281 * entry. Cap it at the number of configured buckets
1282 * (which is num_rx_queues.)
1284 queue_id = rss_get_indirection_to_bucket(i);
1285 queue_id = queue_id % adapter->num_rx_queues;
1290 * The low 8 bits are for hash value (n+0);
1291 * The next 8 bits are for hash value (n+1), etc.
1294 reta |= ((uint32_t)queue_id) << 24;
1296 IXGBE_WRITE_REG(hw, IXGBE_VFRETA(i >> 2), reta);
1301 /* Perform hash on these packet types */
1302 if (adapter->feat_en & IXGBE_FEATURE_RSS)
1303 rss_hash_config = rss_gethashconfig();
1306 * Disable UDP - IP fragments aren't currently being handled
1307 * and so we end up with a mix of 2-tuple and 4-tuple
1310 rss_hash_config = RSS_HASHTYPE_RSS_IPV4
1311 | RSS_HASHTYPE_RSS_TCP_IPV4
1312 | RSS_HASHTYPE_RSS_IPV6
1313 | RSS_HASHTYPE_RSS_TCP_IPV6;
1316 mrqc = IXGBE_MRQC_RSSEN;
1317 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4)
1318 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4;
1319 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4)
1320 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP;
1321 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6)
1322 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6;
1323 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6)
1324 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP;
1325 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV6_EX)
1326 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_IPV6_EX defined, but not supported\n",
1328 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6_EX)
1329 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_TCP_IPV6_EX defined, but not supported\n",
1331 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4)
1332 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP;
1333 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6)
1334 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP;
1335 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6_EX)
1336 device_printf(adapter->dev, "%s: RSS_HASHTYPE_RSS_UDP_IPV6_EX defined, but not supported\n",
1338 IXGBE_WRITE_REG(hw, IXGBE_VFMRQC, mrqc);
1339 } /* ixv_initialize_rss_mapping */
1342 /************************************************************************
1343 * ixv_initialize_receive_units - Setup receive registers and features.
1344 ************************************************************************/
1346 ixv_initialize_receive_units(if_ctx_t ctx)
1348 struct adapter *adapter = iflib_get_softc(ctx);
1349 if_softc_ctx_t scctx;
1350 struct ixgbe_hw *hw = &adapter->hw;
1351 struct ifnet *ifp = iflib_get_ifp(ctx);
1352 struct ix_rx_queue *que = adapter->rx_queues;
1355 if (ifp->if_mtu > ETHERMTU)
1356 bufsz = 4096 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
1358 bufsz = 2048 >> IXGBE_SRRCTL_BSIZEPKT_SHIFT;
1360 psrtype = IXGBE_PSRTYPE_TCPHDR
1361 | IXGBE_PSRTYPE_UDPHDR
1362 | IXGBE_PSRTYPE_IPV4HDR
1363 | IXGBE_PSRTYPE_IPV6HDR
1364 | IXGBE_PSRTYPE_L2HDR;
1366 if (adapter->num_rx_queues > 1)
1369 IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype);
1371 /* Tell PF our max_frame size */
1372 if (ixgbevf_rlpml_set_vf(hw, adapter->max_frame_size) != 0) {
1373 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");
1375 scctx = adapter->shared;
1377 for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
1378 struct rx_ring *rxr = &que->rxr;
1379 u64 rdba = rxr->rx_paddr;
1383 /* Disable the queue */
1384 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j));
1385 rxdctl &= ~IXGBE_RXDCTL_ENABLE;
1386 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
1387 for (int k = 0; k < 10; k++) {
1388 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
1389 IXGBE_RXDCTL_ENABLE)
1395 /* Setup the Base and Length of the Rx Descriptor Ring */
1396 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(j),
1397 (rdba & 0x00000000ffffffffULL));
1398 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(j), (rdba >> 32));
1399 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(j),
1400 scctx->isc_nrxd[0] * sizeof(union ixgbe_adv_rx_desc));
1402 /* Reset the ring indices */
1403 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(rxr->me), 0);
1404 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), 0);
1406 /* Set up the SRRCTL register */
1407 reg = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(j));
1408 reg &= ~IXGBE_SRRCTL_BSIZEHDR_MASK;
1409 reg &= ~IXGBE_SRRCTL_BSIZEPKT_MASK;
1411 reg |= IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
1412 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(j), reg);
1414 /* Capture Rx Tail index */
1415 rxr->tail = IXGBE_VFRDT(rxr->me);
1417 /* Do the queue enabling last */
1418 rxdctl |= IXGBE_RXDCTL_ENABLE | IXGBE_RXDCTL_VME;
1419 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(j), rxdctl);
1420 for (int l = 0; l < 10; l++) {
1421 if (IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(j)) &
1422 IXGBE_RXDCTL_ENABLE)
1428 /* Set the Tail Pointer */
1431 * In netmap mode, we must preserve the buffers made
1432 * available to userspace before the if_init()
1433 * (this is true by default on the TX side, because
1434 * init makes all buffers available to userspace).
1436 * netmap_reset() and the device specific routines
1437 * (e.g. ixgbe_setup_receive_rings()) map these
1438 * buffers at the end of the NIC ring, so here we
1439 * must set the RDT (tail) register to make sure
1440 * they are not overwritten.
1442 * In this driver the NIC ring starts at RDH = 0,
1443 * RDT points to the last slot available for reception (?),
1444 * so RDT = num_rx_desc - 1 means the whole ring is available.
1446 if (ifp->if_capenable & IFCAP_NETMAP) {
1447 struct netmap_adapter *na = NA(ifp);
1448 struct netmap_kring *kring = na->rx_rings[j];
1449 int t = na->num_rx_desc - 1 - nm_kr_rxspace(kring);
1451 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me), t);
1453 #endif /* DEV_NETMAP */
1454 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(rxr->me),
1455 scctx->isc_nrxd[0] - 1);
1459 * Do not touch RSS and RETA settings for older hardware
1460 * as those are shared among PF and all VF.
1462 if (adapter->hw.mac.type >= ixgbe_mac_X550_vf)
1463 ixv_initialize_rss_mapping(adapter);
1464 } /* ixv_initialize_receive_units */
1466 /************************************************************************
1467 * ixv_setup_vlan_support
1468 ************************************************************************/
1470 ixv_setup_vlan_support(if_ctx_t ctx)
1472 struct ifnet *ifp = iflib_get_ifp(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 if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) {
1487 /* Enable the queues */
1488 for (int i = 0; i < adapter->num_rx_queues; i++) {
1489 ctrl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
1490 ctrl |= IXGBE_RXDCTL_VME;
1491 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), ctrl);
1493 * Let Rx path know that it needs to store VLAN tag
1494 * as part of extra mbuf info.
1496 adapter->rx_queues[i].rxr.vtag_strip = TRUE;
1501 * If filtering VLAN tags is disabled,
1502 * there is no need to fill VLAN Filter Table Array (VFTA).
1504 if ((ifp->if_capenable & IFCAP_VLAN_HWFILTER) == 0)
1508 * A soft reset zero's out the VFTA, so
1509 * we need to repopulate it now.
1511 for (int i = 0; i < IXGBE_VFTA_SIZE; i++) {
1512 if (ixv_shadow_vfta[i] == 0)
1514 vfta = ixv_shadow_vfta[i];
1516 * Reconstruct the vlan id's
1517 * based on the bits set in each
1518 * of the array ints.
1520 for (int j = 0; j < 32; j++) {
1522 if ((vfta & (1 << j)) == 0)
1525 /* Call the shared code mailbox routine */
1526 while (hw->mac.ops.set_vfta(hw, vid, 0, TRUE, FALSE)) {
1532 } /* ixv_setup_vlan_support */
1534 /************************************************************************
1535 * ixv_if_register_vlan
1537 * Run via a vlan config EVENT, it enables us to use the
1538 * HW Filter table since we can get the vlan id. This just
1539 * creates the entry in the soft version of the VFTA, init
1540 * will repopulate the real table.
1541 ************************************************************************/
1543 ixv_if_register_vlan(if_ctx_t ctx, u16 vtag)
1545 struct adapter *adapter = iflib_get_softc(ctx);
1548 index = (vtag >> 5) & 0x7F;
1550 ixv_shadow_vfta[index] |= (1 << bit);
1551 ++adapter->num_vlans;
1552 } /* ixv_if_register_vlan */
1554 /************************************************************************
1555 * ixv_if_unregister_vlan
1557 * Run via a vlan unconfig EVENT, remove our entry
1559 ************************************************************************/
1561 ixv_if_unregister_vlan(if_ctx_t ctx, u16 vtag)
1563 struct adapter *adapter = iflib_get_softc(ctx);
1566 index = (vtag >> 5) & 0x7F;
1568 ixv_shadow_vfta[index] &= ~(1 << bit);
1569 --adapter->num_vlans;
1570 } /* ixv_if_unregister_vlan */
1572 /************************************************************************
1573 * ixv_if_enable_intr
1574 ************************************************************************/
1576 ixv_if_enable_intr(if_ctx_t ctx)
1578 struct adapter *adapter = iflib_get_softc(ctx);
1579 struct ixgbe_hw *hw = &adapter->hw;
1580 struct ix_rx_queue *que = adapter->rx_queues;
1581 u32 mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE);
1583 IXGBE_WRITE_REG(hw, IXGBE_VTEIMS, mask);
1585 mask = IXGBE_EIMS_ENABLE_MASK;
1586 mask &= ~(IXGBE_EIMS_OTHER | IXGBE_EIMS_LSC);
1587 IXGBE_WRITE_REG(hw, IXGBE_VTEIAC, mask);
1589 for (int i = 0; i < adapter->num_rx_queues; i++, que++)
1590 ixv_enable_queue(adapter, que->msix);
1592 IXGBE_WRITE_FLUSH(hw);
1593 } /* ixv_if_enable_intr */
1595 /************************************************************************
1596 * ixv_if_disable_intr
1597 ************************************************************************/
1599 ixv_if_disable_intr(if_ctx_t ctx)
1601 struct adapter *adapter = iflib_get_softc(ctx);
1602 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIAC, 0);
1603 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEIMC, ~0);
1604 IXGBE_WRITE_FLUSH(&adapter->hw);
1605 } /* ixv_if_disable_intr */
1607 /************************************************************************
1608 * ixv_if_rx_queue_intr_enable
1609 ************************************************************************/
1611 ixv_if_rx_queue_intr_enable(if_ctx_t ctx, uint16_t rxqid)
1613 struct adapter *adapter = iflib_get_softc(ctx);
1614 struct ix_rx_queue *que = &adapter->rx_queues[rxqid];
1616 ixv_enable_queue(adapter, que->rxr.me);
1619 } /* ixv_if_rx_queue_intr_enable */
1621 /************************************************************************
1624 * Setup the correct IVAR register for a particular MSI-X interrupt
1625 * - entry is the register array entry
1626 * - vector is the MSI-X vector for this queue
1627 * - type is RX/TX/MISC
1628 ************************************************************************/
1630 ixv_set_ivar(struct adapter *adapter, u8 entry, u8 vector, s8 type)
1632 struct ixgbe_hw *hw = &adapter->hw;
1635 vector |= IXGBE_IVAR_ALLOC_VAL;
1637 if (type == -1) { /* MISC IVAR */
1638 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC);
1641 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR_MISC, ivar);
1642 } else { /* RX/TX IVARS */
1643 index = (16 * (entry & 1)) + (8 * type);
1644 ivar = IXGBE_READ_REG(hw, IXGBE_VTIVAR(entry >> 1));
1645 ivar &= ~(0xFF << index);
1646 ivar |= (vector << index);
1647 IXGBE_WRITE_REG(hw, IXGBE_VTIVAR(entry >> 1), ivar);
1649 } /* ixv_set_ivar */
1651 /************************************************************************
1652 * ixv_configure_ivars
1653 ************************************************************************/
1655 ixv_configure_ivars(struct adapter *adapter)
1657 struct ix_rx_queue *que = adapter->rx_queues;
1659 MPASS(adapter->num_rx_queues == adapter->num_tx_queues);
1661 for (int i = 0; i < adapter->num_rx_queues; i++, que++) {
1662 /* First the RX queue entry */
1663 ixv_set_ivar(adapter, i, que->msix, 0);
1664 /* ... and the TX */
1665 ixv_set_ivar(adapter, i, que->msix, 1);
1666 /* Set an initial value in EITR */
1667 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VTEITR(que->msix),
1668 IXGBE_EITR_DEFAULT);
1671 /* For the mailbox interrupt */
1672 ixv_set_ivar(adapter, 1, adapter->vector, -1);
1673 } /* ixv_configure_ivars */
1675 /************************************************************************
1678 * The VF stats registers never have a truly virgin
1679 * starting point, so this routine tries to make an
1680 * artificial one, marking ground zero on attach as
1682 ************************************************************************/
1684 ixv_save_stats(struct adapter *adapter)
1686 if (adapter->stats.vf.vfgprc || adapter->stats.vf.vfgptc) {
1687 adapter->stats.vf.saved_reset_vfgprc +=
1688 adapter->stats.vf.vfgprc - adapter->stats.vf.base_vfgprc;
1689 adapter->stats.vf.saved_reset_vfgptc +=
1690 adapter->stats.vf.vfgptc - adapter->stats.vf.base_vfgptc;
1691 adapter->stats.vf.saved_reset_vfgorc +=
1692 adapter->stats.vf.vfgorc - adapter->stats.vf.base_vfgorc;
1693 adapter->stats.vf.saved_reset_vfgotc +=
1694 adapter->stats.vf.vfgotc - adapter->stats.vf.base_vfgotc;
1695 adapter->stats.vf.saved_reset_vfmprc +=
1696 adapter->stats.vf.vfmprc - adapter->stats.vf.base_vfmprc;
1698 } /* ixv_save_stats */
1700 /************************************************************************
1702 ************************************************************************/
1704 ixv_init_stats(struct adapter *adapter)
1706 struct ixgbe_hw *hw = &adapter->hw;
1708 adapter->stats.vf.last_vfgprc = IXGBE_READ_REG(hw, IXGBE_VFGPRC);
1709 adapter->stats.vf.last_vfgorc = IXGBE_READ_REG(hw, IXGBE_VFGORC_LSB);
1710 adapter->stats.vf.last_vfgorc |=
1711 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGORC_MSB))) << 32);
1713 adapter->stats.vf.last_vfgptc = IXGBE_READ_REG(hw, IXGBE_VFGPTC);
1714 adapter->stats.vf.last_vfgotc = IXGBE_READ_REG(hw, IXGBE_VFGOTC_LSB);
1715 adapter->stats.vf.last_vfgotc |=
1716 (((u64)(IXGBE_READ_REG(hw, IXGBE_VFGOTC_MSB))) << 32);
1718 adapter->stats.vf.last_vfmprc = IXGBE_READ_REG(hw, IXGBE_VFMPRC);
1720 adapter->stats.vf.base_vfgprc = adapter->stats.vf.last_vfgprc;
1721 adapter->stats.vf.base_vfgorc = adapter->stats.vf.last_vfgorc;
1722 adapter->stats.vf.base_vfgptc = adapter->stats.vf.last_vfgptc;
1723 adapter->stats.vf.base_vfgotc = adapter->stats.vf.last_vfgotc;
1724 adapter->stats.vf.base_vfmprc = adapter->stats.vf.last_vfmprc;
1725 } /* ixv_init_stats */
1727 #define UPDATE_STAT_32(reg, last, count) \
1729 u32 current = IXGBE_READ_REG(hw, reg); \
1730 if (current < last) \
1731 count += 0x100000000LL; \
1733 count &= 0xFFFFFFFF00000000LL; \
1737 #define UPDATE_STAT_36(lsb, msb, last, count) \
1739 u64 cur_lsb = IXGBE_READ_REG(hw, lsb); \
1740 u64 cur_msb = IXGBE_READ_REG(hw, msb); \
1741 u64 current = ((cur_msb << 32) | cur_lsb); \
1742 if (current < last) \
1743 count += 0x1000000000LL; \
1745 count &= 0xFFFFFFF000000000LL; \
1749 /************************************************************************
1750 * ixv_update_stats - Update the board statistics counters.
1751 ************************************************************************/
1753 ixv_update_stats(struct adapter *adapter)
1755 struct ixgbe_hw *hw = &adapter->hw;
1756 struct ixgbevf_hw_stats *stats = &adapter->stats.vf;
1758 UPDATE_STAT_32(IXGBE_VFGPRC, adapter->stats.vf.last_vfgprc,
1759 adapter->stats.vf.vfgprc);
1760 UPDATE_STAT_32(IXGBE_VFGPTC, adapter->stats.vf.last_vfgptc,
1761 adapter->stats.vf.vfgptc);
1762 UPDATE_STAT_36(IXGBE_VFGORC_LSB, IXGBE_VFGORC_MSB,
1763 adapter->stats.vf.last_vfgorc, adapter->stats.vf.vfgorc);
1764 UPDATE_STAT_36(IXGBE_VFGOTC_LSB, IXGBE_VFGOTC_MSB,
1765 adapter->stats.vf.last_vfgotc, adapter->stats.vf.vfgotc);
1766 UPDATE_STAT_32(IXGBE_VFMPRC, adapter->stats.vf.last_vfmprc,
1767 adapter->stats.vf.vfmprc);
1769 /* Fill out the OS statistics structure */
1770 IXGBE_SET_IPACKETS(adapter, stats->vfgprc);
1771 IXGBE_SET_OPACKETS(adapter, stats->vfgptc);
1772 IXGBE_SET_IBYTES(adapter, stats->vfgorc);
1773 IXGBE_SET_OBYTES(adapter, stats->vfgotc);
1774 IXGBE_SET_IMCASTS(adapter, stats->vfmprc);
1775 } /* ixv_update_stats */
1777 /************************************************************************
1778 * ixv_add_stats_sysctls - Add statistic sysctls for the VF.
1779 ************************************************************************/
1781 ixv_add_stats_sysctls(struct adapter *adapter)
1783 device_t dev = adapter->dev;
1784 struct ix_tx_queue *tx_que = adapter->tx_queues;
1785 struct ix_rx_queue *rx_que = adapter->rx_queues;
1786 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
1787 struct sysctl_oid *tree = device_get_sysctl_tree(dev);
1788 struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
1789 struct ixgbevf_hw_stats *stats = &adapter->stats.vf;
1790 struct sysctl_oid *stat_node, *queue_node;
1791 struct sysctl_oid_list *stat_list, *queue_list;
1793 #define QUEUE_NAME_LEN 32
1794 char namebuf[QUEUE_NAME_LEN];
1796 /* Driver Statistics */
1797 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "watchdog_events",
1798 CTLFLAG_RD, &adapter->watchdog_events, "Watchdog timeouts");
1799 SYSCTL_ADD_ULONG(ctx, child, OID_AUTO, "link_irq",
1800 CTLFLAG_RD, &adapter->link_irq, "Link MSI-X IRQ Handled");
1802 for (int i = 0; i < adapter->num_tx_queues; i++, tx_que++) {
1803 struct tx_ring *txr = &tx_que->txr;
1804 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
1805 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
1806 CTLFLAG_RD, NULL, "Queue Name");
1807 queue_list = SYSCTL_CHILDREN(queue_node);
1809 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tso_tx",
1810 CTLFLAG_RD, &(txr->tso_tx), "TSO Packets");
1811 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "tx_packets",
1812 CTLFLAG_RD, &(txr->total_packets), "TX Packets");
1815 for (int i = 0; i < adapter->num_rx_queues; i++, rx_que++) {
1816 struct rx_ring *rxr = &rx_que->rxr;
1817 snprintf(namebuf, QUEUE_NAME_LEN, "queue%d", i);
1818 queue_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, namebuf,
1819 CTLFLAG_RD, NULL, "Queue Name");
1820 queue_list = SYSCTL_CHILDREN(queue_node);
1822 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "irqs",
1823 CTLFLAG_RD, &(rx_que->irqs), "IRQs on queue");
1824 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_packets",
1825 CTLFLAG_RD, &(rxr->rx_packets), "RX packets");
1826 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_bytes",
1827 CTLFLAG_RD, &(rxr->rx_bytes), "RX bytes");
1828 SYSCTL_ADD_UQUAD(ctx, queue_list, OID_AUTO, "rx_discarded",
1829 CTLFLAG_RD, &(rxr->rx_discarded), "Discarded RX packets");
1832 stat_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "mac",
1833 CTLFLAG_RD, NULL, "VF Statistics (read from HW registers)");
1834 stat_list = SYSCTL_CHILDREN(stat_node);
1836 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_rcvd",
1837 CTLFLAG_RD, &stats->vfgprc, "Good Packets Received");
1838 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_rcvd",
1839 CTLFLAG_RD, &stats->vfgorc, "Good Octets Received");
1840 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "mcast_pkts_rcvd",
1841 CTLFLAG_RD, &stats->vfmprc, "Multicast Packets Received");
1842 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_pkts_txd",
1843 CTLFLAG_RD, &stats->vfgptc, "Good Packets Transmitted");
1844 SYSCTL_ADD_UQUAD(ctx, stat_list, OID_AUTO, "good_octets_txd",
1845 CTLFLAG_RD, &stats->vfgotc, "Good Octets Transmitted");
1846 } /* ixv_add_stats_sysctls */
1848 /************************************************************************
1849 * ixv_print_debug_info
1851 * Called only when em_display_debug_stats is enabled.
1852 * Provides a way to take a look at important statistics
1853 * maintained by the driver and hardware.
1854 ************************************************************************/
1856 ixv_print_debug_info(struct adapter *adapter)
1858 device_t dev = adapter->dev;
1859 struct ixgbe_hw *hw = &adapter->hw;
1861 device_printf(dev, "Error Byte Count = %u \n",
1862 IXGBE_READ_REG(hw, IXGBE_ERRBC));
1864 device_printf(dev, "MBX IRQ Handled: %lu\n", (long)adapter->link_irq);
1865 } /* ixv_print_debug_info */
1867 /************************************************************************
1869 ************************************************************************/
1871 ixv_sysctl_debug(SYSCTL_HANDLER_ARGS)
1873 struct adapter *adapter;
1877 error = sysctl_handle_int(oidp, &result, 0, req);
1879 if (error || !req->newptr)
1883 adapter = (struct adapter *)arg1;
1884 ixv_print_debug_info(adapter);
1888 } /* ixv_sysctl_debug */
1890 /************************************************************************
1891 * ixv_init_device_features
1892 ************************************************************************/
1894 ixv_init_device_features(struct adapter *adapter)
1896 adapter->feat_cap = IXGBE_FEATURE_NETMAP
1898 | IXGBE_FEATURE_LEGACY_TX;
1900 /* A tad short on feature flags for VFs, atm. */
1901 switch (adapter->hw.mac.type) {
1902 case ixgbe_mac_82599_vf:
1904 case ixgbe_mac_X540_vf:
1906 case ixgbe_mac_X550_vf:
1907 case ixgbe_mac_X550EM_x_vf:
1908 case ixgbe_mac_X550EM_a_vf:
1909 adapter->feat_cap |= IXGBE_FEATURE_NEEDS_CTXD;
1910 adapter->feat_cap |= IXGBE_FEATURE_RSS;
1916 /* Enabled by default... */
1917 /* Is a virtual function (VF) */
1918 if (adapter->feat_cap & IXGBE_FEATURE_VF)
1919 adapter->feat_en |= IXGBE_FEATURE_VF;
1921 if (adapter->feat_cap & IXGBE_FEATURE_NETMAP)
1922 adapter->feat_en |= IXGBE_FEATURE_NETMAP;
1923 /* Receive-Side Scaling (RSS) */
1924 if (adapter->feat_cap & IXGBE_FEATURE_RSS)
1925 adapter->feat_en |= IXGBE_FEATURE_RSS;
1926 /* Needs advanced context descriptor regardless of offloads req'd */
1927 if (adapter->feat_cap & IXGBE_FEATURE_NEEDS_CTXD)
1928 adapter->feat_en |= IXGBE_FEATURE_NEEDS_CTXD;
1929 } /* ixv_init_device_features */