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