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