2 * Broadcom NetXtreme-C/E network driver.
4 * Copyright (c) 2016 Broadcom, All Rights Reserved.
5 * The term Broadcom refers to Broadcom Limited and/or its subsidiaries
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS'
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26 * THE POSSIBILITY OF SUCH DAMAGE.
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/socket.h>
34 #include <sys/kernel.h>
36 #include <sys/module.h>
38 #include <sys/endian.h>
39 #include <sys/sockio.h>
42 #include <machine/bus.h>
43 #include <machine/resource.h>
45 #include <dev/pci/pcireg.h>
46 #include <dev/pci/pcivar.h>
49 #include <net/if_dl.h>
50 #include <net/if_media.h>
51 #include <net/if_var.h>
52 #include <net/ethernet.h>
53 #include <net/iflib.h>
56 #include "opt_inet6.h"
62 #include "bnxt_hwrm.h"
63 #include "bnxt_ioctl.h"
64 #include "bnxt_sysctl.h"
65 #include "hsi_struct_def.h"
71 static pci_vendor_info_t bnxt_vendor_info_array[] =
73 PVID(BROADCOM_VENDOR_ID, BCM57301,
74 "Broadcom BCM57301 NetXtreme-C 10Gb Ethernet Controller"),
75 PVID(BROADCOM_VENDOR_ID, BCM57302,
76 "Broadcom BCM57302 NetXtreme-C 10Gb/25Gb Ethernet Controller"),
77 PVID(BROADCOM_VENDOR_ID, BCM57304,
78 "Broadcom BCM57304 NetXtreme-C 10Gb/25Gb/40Gb/50Gb Ethernet Controller"),
79 PVID(BROADCOM_VENDOR_ID, BCM57311,
80 "Broadcom BCM57311 NetXtreme-C 10Gb Ethernet"),
81 PVID(BROADCOM_VENDOR_ID, BCM57312,
82 "Broadcom BCM57312 NetXtreme-C 10Gb/25Gb Ethernet"),
83 PVID(BROADCOM_VENDOR_ID, BCM57314,
84 "Broadcom BCM57314 NetXtreme-C 10Gb/25Gb/40Gb/50Gb Ethernet"),
85 PVID(BROADCOM_VENDOR_ID, BCM57402,
86 "Broadcom BCM57402 NetXtreme-E 10Gb Ethernet Controller"),
87 PVID(BROADCOM_VENDOR_ID, BCM57402_NPAR,
88 "Broadcom BCM57402 NetXtreme-E Partition"),
89 PVID(BROADCOM_VENDOR_ID, BCM57404,
90 "Broadcom BCM57404 NetXtreme-E 10Gb/25Gb Ethernet Controller"),
91 PVID(BROADCOM_VENDOR_ID, BCM57404_NPAR,
92 "Broadcom BCM57404 NetXtreme-E Partition"),
93 PVID(BROADCOM_VENDOR_ID, BCM57406,
94 "Broadcom BCM57406 NetXtreme-E 10GBase-T Ethernet Controller"),
95 PVID(BROADCOM_VENDOR_ID, BCM57406_NPAR,
96 "Broadcom BCM57406 NetXtreme-E Partition"),
97 PVID(BROADCOM_VENDOR_ID, BCM57407,
98 "Broadcom BCM57407 NetXtreme-E 10GBase-T Ethernet Controller"),
99 PVID(BROADCOM_VENDOR_ID, BCM57407_NPAR,
100 "Broadcom BCM57407 NetXtreme-E Ethernet Partition"),
101 PVID(BROADCOM_VENDOR_ID, BCM57407_SFP,
102 "Broadcom BCM57407 NetXtreme-E 25Gb Ethernet Controller"),
103 PVID(BROADCOM_VENDOR_ID, BCM57412,
104 "Broadcom BCM57412 NetXtreme-E 10Gb Ethernet"),
105 PVID(BROADCOM_VENDOR_ID, BCM57412_NPAR1,
106 "Broadcom BCM57412 NetXtreme-E Ethernet Partition"),
107 PVID(BROADCOM_VENDOR_ID, BCM57412_NPAR2,
108 "Broadcom BCM57412 NetXtreme-E Ethernet Partition"),
109 PVID(BROADCOM_VENDOR_ID, BCM57414,
110 "Broadcom BCM57414 NetXtreme-E 10Gb/25Gb Ethernet"),
111 PVID(BROADCOM_VENDOR_ID, BCM57414_NPAR1,
112 "Broadcom BCM57414 NetXtreme-E Ethernet Partition"),
113 PVID(BROADCOM_VENDOR_ID, BCM57414_NPAR2,
114 "Broadcom BCM57414 NetXtreme-E Ethernet Partition"),
115 PVID(BROADCOM_VENDOR_ID, BCM57416,
116 "Broadcom BCM57416 NetXtreme-E 10GBase-T Ethernet"),
117 PVID(BROADCOM_VENDOR_ID, BCM57416_NPAR1,
118 "Broadcom BCM57416 NetXtreme-E Ethernet Partition"),
119 PVID(BROADCOM_VENDOR_ID, BCM57416_NPAR2,
120 "Broadcom BCM57416 NetXtreme-E Ethernet Partition"),
121 PVID(BROADCOM_VENDOR_ID, BCM57416_SFP,
122 "Broadcom BCM57416 NetXtreme-E 10Gb Ethernet"),
123 PVID(BROADCOM_VENDOR_ID, BCM57417,
124 "Broadcom BCM57417 NetXtreme-E 10GBase-T Ethernet"),
125 PVID(BROADCOM_VENDOR_ID, BCM57417_NPAR1,
126 "Broadcom BCM57417 NetXtreme-E Ethernet Partition"),
127 PVID(BROADCOM_VENDOR_ID, BCM57417_NPAR2,
128 "Broadcom BCM57417 NetXtreme-E Ethernet Partition"),
129 PVID(BROADCOM_VENDOR_ID, BCM57417_SFP,
130 "Broadcom BCM57417 NetXtreme-E 10Gb/25Gb Ethernet"),
131 PVID(BROADCOM_VENDOR_ID, BCM57454,
132 "Broadcom BCM57454 NetXtreme-E 10Gb/25Gb/40Gb/50Gb/100Gb Ethernet"),
133 PVID(BROADCOM_VENDOR_ID, BCM58700,
134 "Broadcom BCM58700 Nitro 1Gb/2.5Gb/10Gb Ethernet"),
135 PVID(BROADCOM_VENDOR_ID, NETXTREME_C_VF1,
136 "Broadcom NetXtreme-C Ethernet Virtual Function"),
137 PVID(BROADCOM_VENDOR_ID, NETXTREME_C_VF2,
138 "Broadcom NetXtreme-C Ethernet Virtual Function"),
139 PVID(BROADCOM_VENDOR_ID, NETXTREME_C_VF3,
140 "Broadcom NetXtreme-C Ethernet Virtual Function"),
141 PVID(BROADCOM_VENDOR_ID, NETXTREME_E_VF1,
142 "Broadcom NetXtreme-E Ethernet Virtual Function"),
143 PVID(BROADCOM_VENDOR_ID, NETXTREME_E_VF2,
144 "Broadcom NetXtreme-E Ethernet Virtual Function"),
145 PVID(BROADCOM_VENDOR_ID, NETXTREME_E_VF3,
146 "Broadcom NetXtreme-E Ethernet Virtual Function"),
147 /* required last entry */
153 * Function prototypes
156 static void *bnxt_register(device_t dev);
158 /* Soft queue setup and teardown */
159 static int bnxt_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
160 uint64_t *paddrs, int ntxqs, int ntxqsets);
161 static int bnxt_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
162 uint64_t *paddrs, int nrxqs, int nrxqsets);
163 static void bnxt_queues_free(if_ctx_t ctx);
165 /* Device setup and teardown */
166 static int bnxt_attach_pre(if_ctx_t ctx);
167 static int bnxt_attach_post(if_ctx_t ctx);
168 static int bnxt_detach(if_ctx_t ctx);
170 /* Device configuration */
171 static void bnxt_init(if_ctx_t ctx);
172 static void bnxt_stop(if_ctx_t ctx);
173 static void bnxt_multi_set(if_ctx_t ctx);
174 static int bnxt_mtu_set(if_ctx_t ctx, uint32_t mtu);
175 static void bnxt_media_status(if_ctx_t ctx, struct ifmediareq * ifmr);
176 static int bnxt_media_change(if_ctx_t ctx);
177 static int bnxt_promisc_set(if_ctx_t ctx, int flags);
178 static uint64_t bnxt_get_counter(if_ctx_t, ift_counter);
179 static void bnxt_update_admin_status(if_ctx_t ctx);
180 static void bnxt_if_timer(if_ctx_t ctx, uint16_t qid);
182 /* Interrupt enable / disable */
183 static void bnxt_intr_enable(if_ctx_t ctx);
184 static int bnxt_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid);
185 static int bnxt_tx_queue_intr_enable(if_ctx_t ctx, uint16_t qid);
186 static void bnxt_disable_intr(if_ctx_t ctx);
187 static int bnxt_msix_intr_assign(if_ctx_t ctx, int msix);
190 static void bnxt_vlan_register(if_ctx_t ctx, uint16_t vtag);
191 static void bnxt_vlan_unregister(if_ctx_t ctx, uint16_t vtag);
194 static int bnxt_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data);
196 static int bnxt_shutdown(if_ctx_t ctx);
197 static int bnxt_suspend(if_ctx_t ctx);
198 static int bnxt_resume(if_ctx_t ctx);
200 /* Internal support functions */
201 static int bnxt_probe_phy(struct bnxt_softc *softc);
202 static void bnxt_add_media_types(struct bnxt_softc *softc);
203 static int bnxt_pci_mapping(struct bnxt_softc *softc);
204 static void bnxt_pci_mapping_free(struct bnxt_softc *softc);
205 static int bnxt_update_link(struct bnxt_softc *softc, bool chng_link_state);
206 static int bnxt_handle_def_cp(void *arg);
207 static int bnxt_handle_rx_cp(void *arg);
208 static void bnxt_clear_ids(struct bnxt_softc *softc);
209 static void inline bnxt_do_enable_intr(struct bnxt_cp_ring *cpr);
210 static void inline bnxt_do_disable_intr(struct bnxt_cp_ring *cpr);
211 static void bnxt_mark_cpr_invalid(struct bnxt_cp_ring *cpr);
212 static void bnxt_def_cp_task(void *context);
213 static void bnxt_handle_async_event(struct bnxt_softc *softc,
214 struct cmpl_base *cmpl);
215 static uint8_t get_phy_type(struct bnxt_softc *softc);
216 static uint64_t bnxt_get_baudrate(struct bnxt_link_info *link);
217 static void bnxt_get_wol_settings(struct bnxt_softc *softc);
218 static int bnxt_wol_config(if_ctx_t ctx);
221 * Device Interface Declaration
224 static device_method_t bnxt_methods[] = {
225 /* Device interface */
226 DEVMETHOD(device_register, bnxt_register),
227 DEVMETHOD(device_probe, iflib_device_probe),
228 DEVMETHOD(device_attach, iflib_device_attach),
229 DEVMETHOD(device_detach, iflib_device_detach),
230 DEVMETHOD(device_shutdown, iflib_device_shutdown),
231 DEVMETHOD(device_suspend, iflib_device_suspend),
232 DEVMETHOD(device_resume, iflib_device_resume),
236 static driver_t bnxt_driver = {
237 "bnxt", bnxt_methods, sizeof(struct bnxt_softc),
240 devclass_t bnxt_devclass;
241 DRIVER_MODULE(bnxt, pci, bnxt_driver, bnxt_devclass, 0, 0);
243 MODULE_DEPEND(bnxt, pci, 1, 1, 1);
244 MODULE_DEPEND(bnxt, ether, 1, 1, 1);
245 MODULE_DEPEND(bnxt, iflib, 1, 1, 1);
247 IFLIB_PNP_INFO(pci, bnxt, bnxt_vendor_info_array);
249 static device_method_t bnxt_iflib_methods[] = {
250 DEVMETHOD(ifdi_tx_queues_alloc, bnxt_tx_queues_alloc),
251 DEVMETHOD(ifdi_rx_queues_alloc, bnxt_rx_queues_alloc),
252 DEVMETHOD(ifdi_queues_free, bnxt_queues_free),
254 DEVMETHOD(ifdi_attach_pre, bnxt_attach_pre),
255 DEVMETHOD(ifdi_attach_post, bnxt_attach_post),
256 DEVMETHOD(ifdi_detach, bnxt_detach),
258 DEVMETHOD(ifdi_init, bnxt_init),
259 DEVMETHOD(ifdi_stop, bnxt_stop),
260 DEVMETHOD(ifdi_multi_set, bnxt_multi_set),
261 DEVMETHOD(ifdi_mtu_set, bnxt_mtu_set),
262 DEVMETHOD(ifdi_media_status, bnxt_media_status),
263 DEVMETHOD(ifdi_media_change, bnxt_media_change),
264 DEVMETHOD(ifdi_promisc_set, bnxt_promisc_set),
265 DEVMETHOD(ifdi_get_counter, bnxt_get_counter),
266 DEVMETHOD(ifdi_update_admin_status, bnxt_update_admin_status),
267 DEVMETHOD(ifdi_timer, bnxt_if_timer),
269 DEVMETHOD(ifdi_intr_enable, bnxt_intr_enable),
270 DEVMETHOD(ifdi_tx_queue_intr_enable, bnxt_tx_queue_intr_enable),
271 DEVMETHOD(ifdi_rx_queue_intr_enable, bnxt_rx_queue_intr_enable),
272 DEVMETHOD(ifdi_intr_disable, bnxt_disable_intr),
273 DEVMETHOD(ifdi_msix_intr_assign, bnxt_msix_intr_assign),
275 DEVMETHOD(ifdi_vlan_register, bnxt_vlan_register),
276 DEVMETHOD(ifdi_vlan_unregister, bnxt_vlan_unregister),
278 DEVMETHOD(ifdi_priv_ioctl, bnxt_priv_ioctl),
280 DEVMETHOD(ifdi_suspend, bnxt_suspend),
281 DEVMETHOD(ifdi_shutdown, bnxt_shutdown),
282 DEVMETHOD(ifdi_resume, bnxt_resume),
287 static driver_t bnxt_iflib_driver = {
288 "bnxt", bnxt_iflib_methods, sizeof(struct bnxt_softc)
292 * iflib shared context
295 #define BNXT_DRIVER_VERSION "1.0.0.2"
296 char bnxt_driver_version[] = BNXT_DRIVER_VERSION;
297 extern struct if_txrx bnxt_txrx;
298 static struct if_shared_ctx bnxt_sctx_init = {
299 .isc_magic = IFLIB_MAGIC,
300 .isc_driver = &bnxt_iflib_driver,
301 .isc_nfl = 2, // Number of Free Lists
302 .isc_flags = IFLIB_HAS_RXCQ | IFLIB_HAS_TXCQ | IFLIB_NEED_ETHER_PAD,
303 .isc_q_align = PAGE_SIZE,
304 .isc_tx_maxsize = BNXT_TSO_SIZE + sizeof(struct ether_vlan_header),
305 .isc_tx_maxsegsize = BNXT_TSO_SIZE + sizeof(struct ether_vlan_header),
306 .isc_tso_maxsize = BNXT_TSO_SIZE + sizeof(struct ether_vlan_header),
307 .isc_tso_maxsegsize = BNXT_TSO_SIZE + sizeof(struct ether_vlan_header),
308 .isc_rx_maxsize = BNXT_TSO_SIZE + sizeof(struct ether_vlan_header),
309 .isc_rx_maxsegsize = BNXT_TSO_SIZE + sizeof(struct ether_vlan_header),
311 // Only use a single segment to avoid page size constraints
312 .isc_rx_nsegments = 1,
315 .isc_nrxd_min = {16, 16, 16},
316 .isc_nrxd_default = {PAGE_SIZE / sizeof(struct cmpl_base) * 8,
317 PAGE_SIZE / sizeof(struct rx_prod_pkt_bd),
318 PAGE_SIZE / sizeof(struct rx_prod_pkt_bd)},
319 .isc_nrxd_max = {INT32_MAX, INT32_MAX, INT32_MAX},
320 .isc_ntxd_min = {16, 16, 16},
321 .isc_ntxd_default = {PAGE_SIZE / sizeof(struct cmpl_base) * 2,
322 PAGE_SIZE / sizeof(struct tx_bd_short)},
323 .isc_ntxd_max = {INT32_MAX, INT32_MAX, INT32_MAX},
325 .isc_admin_intrcnt = 1,
326 .isc_vendor_info = bnxt_vendor_info_array,
327 .isc_driver_version = bnxt_driver_version,
330 if_shared_ctx_t bnxt_sctx = &bnxt_sctx_init;
337 bnxt_register(device_t dev)
343 * Device Dependent Configuration Functions
346 /* Soft queue setup and teardown */
348 bnxt_tx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
349 uint64_t *paddrs, int ntxqs, int ntxqsets)
351 struct bnxt_softc *softc;
355 softc = iflib_get_softc(ctx);
357 softc->tx_cp_rings = malloc(sizeof(struct bnxt_cp_ring) * ntxqsets,
358 M_DEVBUF, M_NOWAIT | M_ZERO);
359 if (!softc->tx_cp_rings) {
360 device_printf(iflib_get_dev(ctx),
361 "unable to allocate TX completion rings\n");
365 softc->tx_rings = malloc(sizeof(struct bnxt_ring) * ntxqsets,
366 M_DEVBUF, M_NOWAIT | M_ZERO);
367 if (!softc->tx_rings) {
368 device_printf(iflib_get_dev(ctx),
369 "unable to allocate TX rings\n");
371 goto ring_alloc_fail;
373 rc = iflib_dma_alloc(ctx, sizeof(struct ctx_hw_stats) * ntxqsets,
374 &softc->tx_stats, 0);
377 bus_dmamap_sync(softc->tx_stats.idi_tag, softc->tx_stats.idi_map,
378 BUS_DMASYNC_PREREAD);
380 for (i = 0; i < ntxqsets; i++) {
381 /* Set up the completion ring */
382 softc->tx_cp_rings[i].stats_ctx_id = HWRM_NA_SIGNATURE;
383 softc->tx_cp_rings[i].ring.phys_id =
384 (uint16_t)HWRM_NA_SIGNATURE;
385 softc->tx_cp_rings[i].ring.softc = softc;
386 softc->tx_cp_rings[i].ring.id =
387 (softc->scctx->isc_nrxqsets * 2) + 1 + i;
388 softc->tx_cp_rings[i].ring.doorbell =
389 softc->tx_cp_rings[i].ring.id * 0x80;
390 softc->tx_cp_rings[i].ring.ring_size =
391 softc->scctx->isc_ntxd[0];
392 softc->tx_cp_rings[i].ring.vaddr = vaddrs[i * ntxqs];
393 softc->tx_cp_rings[i].ring.paddr = paddrs[i * ntxqs];
395 /* Set up the TX ring */
396 softc->tx_rings[i].phys_id = (uint16_t)HWRM_NA_SIGNATURE;
397 softc->tx_rings[i].softc = softc;
398 softc->tx_rings[i].id =
399 (softc->scctx->isc_nrxqsets * 2) + 1 + i;
400 softc->tx_rings[i].doorbell = softc->tx_rings[i].id * 0x80;
401 softc->tx_rings[i].ring_size = softc->scctx->isc_ntxd[1];
402 softc->tx_rings[i].vaddr = vaddrs[i * ntxqs + 1];
403 softc->tx_rings[i].paddr = paddrs[i * ntxqs + 1];
405 bnxt_create_tx_sysctls(softc, i);
408 softc->ntxqsets = ntxqsets;
412 free(softc->tx_rings, M_DEVBUF);
414 free(softc->tx_cp_rings, M_DEVBUF);
420 bnxt_queues_free(if_ctx_t ctx)
422 struct bnxt_softc *softc = iflib_get_softc(ctx);
425 iflib_dma_free(&softc->tx_stats);
426 free(softc->tx_rings, M_DEVBUF);
427 softc->tx_rings = NULL;
428 free(softc->tx_cp_rings, M_DEVBUF);
429 softc->tx_cp_rings = NULL;
433 iflib_dma_free(&softc->rx_stats);
434 iflib_dma_free(&softc->hw_tx_port_stats);
435 iflib_dma_free(&softc->hw_rx_port_stats);
436 free(softc->grp_info, M_DEVBUF);
437 free(softc->ag_rings, M_DEVBUF);
438 free(softc->rx_rings, M_DEVBUF);
439 free(softc->rx_cp_rings, M_DEVBUF);
443 bnxt_rx_queues_alloc(if_ctx_t ctx, caddr_t *vaddrs,
444 uint64_t *paddrs, int nrxqs, int nrxqsets)
446 struct bnxt_softc *softc;
450 softc = iflib_get_softc(ctx);
452 softc->rx_cp_rings = malloc(sizeof(struct bnxt_cp_ring) * nrxqsets,
453 M_DEVBUF, M_NOWAIT | M_ZERO);
454 if (!softc->rx_cp_rings) {
455 device_printf(iflib_get_dev(ctx),
456 "unable to allocate RX completion rings\n");
460 softc->rx_rings = malloc(sizeof(struct bnxt_ring) * nrxqsets,
461 M_DEVBUF, M_NOWAIT | M_ZERO);
462 if (!softc->rx_rings) {
463 device_printf(iflib_get_dev(ctx),
464 "unable to allocate RX rings\n");
466 goto ring_alloc_fail;
468 softc->ag_rings = malloc(sizeof(struct bnxt_ring) * nrxqsets,
469 M_DEVBUF, M_NOWAIT | M_ZERO);
470 if (!softc->ag_rings) {
471 device_printf(iflib_get_dev(ctx),
472 "unable to allocate aggregation rings\n");
476 softc->grp_info = malloc(sizeof(struct bnxt_grp_info) * nrxqsets,
477 M_DEVBUF, M_NOWAIT | M_ZERO);
478 if (!softc->grp_info) {
479 device_printf(iflib_get_dev(ctx),
480 "unable to allocate ring groups\n");
485 rc = iflib_dma_alloc(ctx, sizeof(struct ctx_hw_stats) * nrxqsets,
486 &softc->rx_stats, 0);
488 goto hw_stats_alloc_fail;
489 bus_dmamap_sync(softc->rx_stats.idi_tag, softc->rx_stats.idi_map,
490 BUS_DMASYNC_PREREAD);
493 * Additional 512 bytes for future expansion.
494 * To prevent corruption when loaded with newer firmwares with added counters.
495 * This can be deleted when there will be no further additions of counters.
497 #define BNXT_PORT_STAT_PADDING 512
499 rc = iflib_dma_alloc(ctx, sizeof(struct rx_port_stats) + BNXT_PORT_STAT_PADDING,
500 &softc->hw_rx_port_stats, 0);
502 goto hw_port_rx_stats_alloc_fail;
504 bus_dmamap_sync(softc->hw_rx_port_stats.idi_tag,
505 softc->hw_rx_port_stats.idi_map, BUS_DMASYNC_PREREAD);
507 rc = iflib_dma_alloc(ctx, sizeof(struct tx_port_stats) + BNXT_PORT_STAT_PADDING,
508 &softc->hw_tx_port_stats, 0);
511 goto hw_port_tx_stats_alloc_fail;
513 bus_dmamap_sync(softc->hw_tx_port_stats.idi_tag,
514 softc->hw_tx_port_stats.idi_map, BUS_DMASYNC_PREREAD);
516 softc->rx_port_stats = (void *) softc->hw_rx_port_stats.idi_vaddr;
517 softc->tx_port_stats = (void *) softc->hw_tx_port_stats.idi_vaddr;
519 for (i = 0; i < nrxqsets; i++) {
520 /* Allocation the completion ring */
521 softc->rx_cp_rings[i].stats_ctx_id = HWRM_NA_SIGNATURE;
522 softc->rx_cp_rings[i].ring.phys_id =
523 (uint16_t)HWRM_NA_SIGNATURE;
524 softc->rx_cp_rings[i].ring.softc = softc;
525 softc->rx_cp_rings[i].ring.id = i + 1;
526 softc->rx_cp_rings[i].ring.doorbell =
527 softc->rx_cp_rings[i].ring.id * 0x80;
529 * If this ring overflows, RX stops working.
531 softc->rx_cp_rings[i].ring.ring_size =
532 softc->scctx->isc_nrxd[0];
533 softc->rx_cp_rings[i].ring.vaddr = vaddrs[i * nrxqs];
534 softc->rx_cp_rings[i].ring.paddr = paddrs[i * nrxqs];
536 /* Allocate the RX ring */
537 softc->rx_rings[i].phys_id = (uint16_t)HWRM_NA_SIGNATURE;
538 softc->rx_rings[i].softc = softc;
539 softc->rx_rings[i].id = i + 1;
540 softc->rx_rings[i].doorbell = softc->rx_rings[i].id * 0x80;
541 softc->rx_rings[i].ring_size = softc->scctx->isc_nrxd[1];
542 softc->rx_rings[i].vaddr = vaddrs[i * nrxqs + 1];
543 softc->rx_rings[i].paddr = paddrs[i * nrxqs + 1];
545 /* Allocate the TPA start buffer */
546 softc->rx_rings[i].tpa_start = malloc(sizeof(struct bnxt_full_tpa_start) *
547 (RX_TPA_START_CMPL_AGG_ID_MASK >> RX_TPA_START_CMPL_AGG_ID_SFT),
548 M_DEVBUF, M_NOWAIT | M_ZERO);
549 if (softc->rx_rings[i].tpa_start == NULL) {
551 device_printf(softc->dev,
552 "Unable to allocate space for TPA\n");
556 /* Allocate the AG ring */
557 softc->ag_rings[i].phys_id = (uint16_t)HWRM_NA_SIGNATURE;
558 softc->ag_rings[i].softc = softc;
559 softc->ag_rings[i].id = nrxqsets + i + 1;
560 softc->ag_rings[i].doorbell = softc->ag_rings[i].id * 0x80;
561 softc->ag_rings[i].ring_size = softc->scctx->isc_nrxd[2];
562 softc->ag_rings[i].vaddr = vaddrs[i * nrxqs + 2];
563 softc->ag_rings[i].paddr = paddrs[i * nrxqs + 2];
565 /* Allocate the ring group */
566 softc->grp_info[i].grp_id = (uint16_t)HWRM_NA_SIGNATURE;
567 softc->grp_info[i].stats_ctx =
568 softc->rx_cp_rings[i].stats_ctx_id;
569 softc->grp_info[i].rx_ring_id = softc->rx_rings[i].phys_id;
570 softc->grp_info[i].ag_ring_id = softc->ag_rings[i].phys_id;
571 softc->grp_info[i].cp_ring_id =
572 softc->rx_cp_rings[i].ring.phys_id;
574 bnxt_create_rx_sysctls(softc, i);
578 * When SR-IOV is enabled, avoid each VF sending PORT_QSTATS
579 * HWRM every sec with which firmware timeouts can happen
582 bnxt_create_port_stats_sysctls(softc);
584 /* And finally, the VNIC */
585 softc->vnic_info.id = (uint16_t)HWRM_NA_SIGNATURE;
586 softc->vnic_info.flow_id = (uint16_t)HWRM_NA_SIGNATURE;
587 softc->vnic_info.filter_id = -1;
588 softc->vnic_info.def_ring_grp = (uint16_t)HWRM_NA_SIGNATURE;
589 softc->vnic_info.cos_rule = (uint16_t)HWRM_NA_SIGNATURE;
590 softc->vnic_info.lb_rule = (uint16_t)HWRM_NA_SIGNATURE;
591 softc->vnic_info.rx_mask = HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_BCAST;
592 softc->vnic_info.mc_list_count = 0;
593 softc->vnic_info.flags = BNXT_VNIC_FLAG_DEFAULT;
594 rc = iflib_dma_alloc(ctx, BNXT_MAX_MC_ADDRS * ETHER_ADDR_LEN,
595 &softc->vnic_info.mc_list, 0);
597 goto mc_list_alloc_fail;
599 /* The VNIC RSS Hash Key */
600 rc = iflib_dma_alloc(ctx, HW_HASH_KEY_SIZE,
601 &softc->vnic_info.rss_hash_key_tbl, 0);
603 goto rss_hash_alloc_fail;
604 bus_dmamap_sync(softc->vnic_info.rss_hash_key_tbl.idi_tag,
605 softc->vnic_info.rss_hash_key_tbl.idi_map,
606 BUS_DMASYNC_PREWRITE);
607 memcpy(softc->vnic_info.rss_hash_key_tbl.idi_vaddr,
608 softc->vnic_info.rss_hash_key, HW_HASH_KEY_SIZE);
610 /* Allocate the RSS tables */
611 rc = iflib_dma_alloc(ctx, HW_HASH_INDEX_SIZE * sizeof(uint16_t),
612 &softc->vnic_info.rss_grp_tbl, 0);
614 goto rss_grp_alloc_fail;
615 bus_dmamap_sync(softc->vnic_info.rss_grp_tbl.idi_tag,
616 softc->vnic_info.rss_grp_tbl.idi_map,
617 BUS_DMASYNC_PREWRITE);
618 memset(softc->vnic_info.rss_grp_tbl.idi_vaddr, 0xff,
619 softc->vnic_info.rss_grp_tbl.idi_size);
621 softc->nrxqsets = nrxqsets;
625 iflib_dma_free(&softc->vnic_info.rss_hash_key_tbl);
627 iflib_dma_free(&softc->vnic_info.mc_list);
630 for (i = i - 1; i >= 0; i--)
631 free(softc->rx_rings[i].tpa_start, M_DEVBUF);
632 iflib_dma_free(&softc->hw_tx_port_stats);
633 hw_port_tx_stats_alloc_fail:
634 iflib_dma_free(&softc->hw_rx_port_stats);
635 hw_port_rx_stats_alloc_fail:
636 iflib_dma_free(&softc->rx_stats);
638 free(softc->grp_info, M_DEVBUF);
640 free(softc->ag_rings, M_DEVBUF);
642 free(softc->rx_rings, M_DEVBUF);
644 free(softc->rx_cp_rings, M_DEVBUF);
649 static void bnxt_free_hwrm_short_cmd_req(struct bnxt_softc *softc)
651 if (softc->hwrm_short_cmd_req_addr.idi_vaddr)
652 iflib_dma_free(&softc->hwrm_short_cmd_req_addr);
653 softc->hwrm_short_cmd_req_addr.idi_vaddr = NULL;
656 static int bnxt_alloc_hwrm_short_cmd_req(struct bnxt_softc *softc)
660 rc = iflib_dma_alloc(softc->ctx, softc->hwrm_max_req_len,
661 &softc->hwrm_short_cmd_req_addr, BUS_DMA_NOWAIT);
666 /* Device setup and teardown */
668 bnxt_attach_pre(if_ctx_t ctx)
670 struct bnxt_softc *softc = iflib_get_softc(ctx);
671 if_softc_ctx_t scctx;
675 softc->dev = iflib_get_dev(ctx);
676 softc->media = iflib_get_media(ctx);
677 softc->scctx = iflib_get_softc_ctx(ctx);
678 softc->sctx = iflib_get_sctx(ctx);
679 scctx = softc->scctx;
681 /* TODO: Better way of detecting NPAR/VF is needed */
682 switch (pci_get_device(softc->dev)) {
693 softc->flags |= BNXT_FLAG_NPAR;
695 case NETXTREME_C_VF1:
696 case NETXTREME_C_VF2:
697 case NETXTREME_C_VF3:
698 case NETXTREME_E_VF1:
699 case NETXTREME_E_VF2:
700 case NETXTREME_E_VF3:
701 softc->flags |= BNXT_FLAG_VF;
705 pci_enable_busmaster(softc->dev);
707 if (bnxt_pci_mapping(softc))
710 /* HWRM setup/init */
711 BNXT_HWRM_LOCK_INIT(softc, device_get_nameunit(softc->dev));
712 rc = bnxt_alloc_hwrm_dma_mem(softc);
717 /* Get firmware version and compare with driver */
718 softc->ver_info = malloc(sizeof(struct bnxt_ver_info),
719 M_DEVBUF, M_NOWAIT | M_ZERO);
720 if (softc->ver_info == NULL) {
722 device_printf(softc->dev,
723 "Unable to allocate space for version info\n");
726 /* Default minimum required HWRM version */
727 softc->ver_info->hwrm_min_major = 1;
728 softc->ver_info->hwrm_min_minor = 2;
729 softc->ver_info->hwrm_min_update = 2;
731 rc = bnxt_hwrm_ver_get(softc);
733 device_printf(softc->dev, "attach: hwrm ver get failed\n");
737 if (softc->flags & BNXT_FLAG_SHORT_CMD) {
738 rc = bnxt_alloc_hwrm_short_cmd_req(softc);
740 goto hwrm_short_cmd_alloc_fail;
744 if (BNXT_PF(softc)) {
745 softc->nvm_info = malloc(sizeof(struct bnxt_nvram_info),
746 M_DEVBUF, M_NOWAIT | M_ZERO);
747 if (softc->nvm_info == NULL) {
749 device_printf(softc->dev,
750 "Unable to allocate space for NVRAM info\n");
754 rc = bnxt_hwrm_nvm_get_dev_info(softc, &softc->nvm_info->mfg_id,
755 &softc->nvm_info->device_id, &softc->nvm_info->sector_size,
756 &softc->nvm_info->size, &softc->nvm_info->reserved_size,
757 &softc->nvm_info->available_size);
760 /* Register the driver with the FW */
761 rc = bnxt_hwrm_func_drv_rgtr(softc);
763 device_printf(softc->dev, "attach: hwrm drv rgtr failed\n");
767 rc = bnxt_hwrm_func_rgtr_async_events(softc, NULL, 0);
769 device_printf(softc->dev, "attach: hwrm rgtr async evts failed\n");
773 /* Get the HW capabilities */
774 rc = bnxt_hwrm_func_qcaps(softc);
778 /* Get the current configuration of this function */
779 rc = bnxt_hwrm_func_qcfg(softc);
781 device_printf(softc->dev, "attach: hwrm func qcfg failed\n");
785 iflib_set_mac(ctx, softc->func.mac_addr);
787 scctx->isc_txrx = &bnxt_txrx;
788 scctx->isc_tx_csum_flags = (CSUM_IP | CSUM_TCP | CSUM_UDP |
789 CSUM_TCP_IPV6 | CSUM_UDP_IPV6 | CSUM_TSO);
790 scctx->isc_capabilities = scctx->isc_capenable =
791 /* These are translated to hwassit bits */
792 IFCAP_TXCSUM | IFCAP_TXCSUM_IPV6 | IFCAP_TSO4 | IFCAP_TSO6 |
793 /* These are checked by iflib */
794 IFCAP_LRO | IFCAP_VLAN_HWFILTER |
795 /* These are part of the iflib mask */
796 IFCAP_RXCSUM | IFCAP_RXCSUM_IPV6 | IFCAP_VLAN_MTU |
797 IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWTSO |
798 /* These likely get lost... */
799 IFCAP_VLAN_HWCSUM | IFCAP_JUMBO_MTU;
801 if (bnxt_wol_supported(softc))
802 scctx->isc_capenable |= IFCAP_WOL_MAGIC;
804 /* Get the queue config */
805 rc = bnxt_hwrm_queue_qportcfg(softc);
807 device_printf(softc->dev, "attach: hwrm qportcfg failed\n");
811 bnxt_get_wol_settings(softc);
813 /* Now perform a function reset */
814 rc = bnxt_hwrm_func_reset(softc);
815 bnxt_clear_ids(softc);
819 /* Now set up iflib sc */
820 scctx->isc_tx_nsegments = 31,
821 scctx->isc_tx_tso_segments_max = 31;
822 scctx->isc_tx_tso_size_max = BNXT_TSO_SIZE;
823 scctx->isc_tx_tso_segsize_max = BNXT_TSO_SIZE;
824 scctx->isc_vectors = softc->func.max_cp_rings;
825 scctx->isc_min_frame_size = BNXT_MIN_FRAME_SIZE;
826 scctx->isc_txrx = &bnxt_txrx;
828 if (scctx->isc_nrxd[0] <
829 ((scctx->isc_nrxd[1] * 4) + scctx->isc_nrxd[2]))
830 device_printf(softc->dev,
831 "WARNING: nrxd0 (%d) should be at least 4 * nrxd1 (%d) + nrxd2 (%d). Driver may be unstable\n",
832 scctx->isc_nrxd[0], scctx->isc_nrxd[1], scctx->isc_nrxd[2]);
833 if (scctx->isc_ntxd[0] < scctx->isc_ntxd[1] * 2)
834 device_printf(softc->dev,
835 "WARNING: ntxd0 (%d) should be at least 2 * ntxd1 (%d). Driver may be unstable\n",
836 scctx->isc_ntxd[0], scctx->isc_ntxd[1]);
837 scctx->isc_txqsizes[0] = sizeof(struct cmpl_base) * scctx->isc_ntxd[0];
838 scctx->isc_txqsizes[1] = sizeof(struct tx_bd_short) *
840 scctx->isc_rxqsizes[0] = sizeof(struct cmpl_base) * scctx->isc_nrxd[0];
841 scctx->isc_rxqsizes[1] = sizeof(struct rx_prod_pkt_bd) *
843 scctx->isc_rxqsizes[2] = sizeof(struct rx_prod_pkt_bd) *
846 scctx->isc_nrxqsets_max = min(pci_msix_count(softc->dev)-1,
847 softc->fn_qcfg.alloc_completion_rings - 1);
848 scctx->isc_nrxqsets_max = min(scctx->isc_nrxqsets_max,
849 softc->fn_qcfg.alloc_rx_rings);
850 scctx->isc_nrxqsets_max = min(scctx->isc_nrxqsets_max,
851 softc->fn_qcfg.alloc_vnics);
852 scctx->isc_ntxqsets_max = min(softc->fn_qcfg.alloc_tx_rings,
853 softc->fn_qcfg.alloc_completion_rings - scctx->isc_nrxqsets_max - 1);
855 scctx->isc_rss_table_size = HW_HASH_INDEX_SIZE;
856 scctx->isc_rss_table_mask = scctx->isc_rss_table_size - 1;
858 /* iflib will map and release this bar */
859 scctx->isc_msix_bar = pci_msix_table_bar(softc->dev);
862 * Default settings for HW LRO (TPA):
863 * Disable HW LRO by default
864 * Can be enabled after taking care of 'packet forwarding'
866 softc->hw_lro.enable = 0;
867 softc->hw_lro.is_mode_gro = 0;
868 softc->hw_lro.max_agg_segs = 5; /* 2^5 = 32 segs */
869 softc->hw_lro.max_aggs = HWRM_VNIC_TPA_CFG_INPUT_MAX_AGGS_MAX;
870 softc->hw_lro.min_agg_len = 512;
872 /* Allocate the default completion ring */
873 softc->def_cp_ring.stats_ctx_id = HWRM_NA_SIGNATURE;
874 softc->def_cp_ring.ring.phys_id = (uint16_t)HWRM_NA_SIGNATURE;
875 softc->def_cp_ring.ring.softc = softc;
876 softc->def_cp_ring.ring.id = 0;
877 softc->def_cp_ring.ring.doorbell = softc->def_cp_ring.ring.id * 0x80;
878 softc->def_cp_ring.ring.ring_size = PAGE_SIZE /
879 sizeof(struct cmpl_base);
880 rc = iflib_dma_alloc(ctx,
881 sizeof(struct cmpl_base) * softc->def_cp_ring.ring.ring_size,
882 &softc->def_cp_ring_mem, 0);
883 softc->def_cp_ring.ring.vaddr = softc->def_cp_ring_mem.idi_vaddr;
884 softc->def_cp_ring.ring.paddr = softc->def_cp_ring_mem.idi_paddr;
885 iflib_config_gtask_init(ctx, &softc->def_cp_task, bnxt_def_cp_task,
888 rc = bnxt_init_sysctl_ctx(softc);
890 goto init_sysctl_failed;
891 if (BNXT_PF(softc)) {
892 rc = bnxt_create_nvram_sysctls(softc->nvm_info);
897 arc4rand(softc->vnic_info.rss_hash_key, HW_HASH_KEY_SIZE, 0);
898 softc->vnic_info.rss_hash_type =
899 HWRM_VNIC_RSS_CFG_INPUT_HASH_TYPE_IPV4 |
900 HWRM_VNIC_RSS_CFG_INPUT_HASH_TYPE_TCP_IPV4 |
901 HWRM_VNIC_RSS_CFG_INPUT_HASH_TYPE_UDP_IPV4 |
902 HWRM_VNIC_RSS_CFG_INPUT_HASH_TYPE_IPV6 |
903 HWRM_VNIC_RSS_CFG_INPUT_HASH_TYPE_TCP_IPV6 |
904 HWRM_VNIC_RSS_CFG_INPUT_HASH_TYPE_UDP_IPV6;
905 rc = bnxt_create_config_sysctls_pre(softc);
909 rc = bnxt_create_hw_lro_sysctls(softc);
913 rc = bnxt_create_pause_fc_sysctls(softc);
917 /* Initialize the vlan list */
918 SLIST_INIT(&softc->vnic_info.vlan_tags);
919 softc->vnic_info.vlan_tag_list.idi_vaddr = NULL;
924 bnxt_free_sysctl_ctx(softc);
926 bnxt_hwrm_func_drv_unrgtr(softc, false);
929 free(softc->nvm_info, M_DEVBUF);
931 bnxt_free_hwrm_short_cmd_req(softc);
932 hwrm_short_cmd_alloc_fail:
934 free(softc->ver_info, M_DEVBUF);
936 bnxt_free_hwrm_dma_mem(softc);
938 BNXT_HWRM_LOCK_DESTROY(softc);
939 bnxt_pci_mapping_free(softc);
940 pci_disable_busmaster(softc->dev);
945 bnxt_attach_post(if_ctx_t ctx)
947 struct bnxt_softc *softc = iflib_get_softc(ctx);
948 if_t ifp = iflib_get_ifp(ctx);
951 bnxt_create_config_sysctls_post(softc);
953 /* Update link state etc... */
954 rc = bnxt_probe_phy(softc);
958 /* Needs to be done after probing the phy */
959 bnxt_create_ver_sysctls(softc);
960 bnxt_add_media_types(softc);
961 ifmedia_set(softc->media, IFM_ETHER | IFM_AUTO);
963 softc->scctx->isc_max_frame_size = ifp->if_mtu + ETHER_HDR_LEN +
971 bnxt_detach(if_ctx_t ctx)
973 struct bnxt_softc *softc = iflib_get_softc(ctx);
974 struct bnxt_vlan_tag *tag;
975 struct bnxt_vlan_tag *tmp;
978 bnxt_wol_config(ctx);
979 bnxt_do_disable_intr(&softc->def_cp_ring);
980 bnxt_free_sysctl_ctx(softc);
981 bnxt_hwrm_func_reset(softc);
982 bnxt_clear_ids(softc);
983 iflib_irq_free(ctx, &softc->def_cp_ring.irq);
984 iflib_config_gtask_deinit(&softc->def_cp_task);
985 /* We need to free() these here... */
986 for (i = softc->nrxqsets-1; i>=0; i--) {
987 iflib_irq_free(ctx, &softc->rx_cp_rings[i].irq);
989 iflib_dma_free(&softc->vnic_info.mc_list);
990 iflib_dma_free(&softc->vnic_info.rss_hash_key_tbl);
991 iflib_dma_free(&softc->vnic_info.rss_grp_tbl);
992 if (softc->vnic_info.vlan_tag_list.idi_vaddr)
993 iflib_dma_free(&softc->vnic_info.vlan_tag_list);
994 SLIST_FOREACH_SAFE(tag, &softc->vnic_info.vlan_tags, next, tmp)
996 iflib_dma_free(&softc->def_cp_ring_mem);
997 for (i = 0; i < softc->nrxqsets; i++)
998 free(softc->rx_rings[i].tpa_start, M_DEVBUF);
999 free(softc->ver_info, M_DEVBUF);
1001 free(softc->nvm_info, M_DEVBUF);
1003 bnxt_hwrm_func_drv_unrgtr(softc, false);
1004 bnxt_free_hwrm_dma_mem(softc);
1005 bnxt_free_hwrm_short_cmd_req(softc);
1006 BNXT_HWRM_LOCK_DESTROY(softc);
1008 pci_disable_busmaster(softc->dev);
1009 bnxt_pci_mapping_free(softc);
1014 /* Device configuration */
1016 bnxt_init(if_ctx_t ctx)
1018 struct bnxt_softc *softc = iflib_get_softc(ctx);
1019 struct ifmediareq ifmr;
1023 rc = bnxt_hwrm_func_reset(softc);
1026 bnxt_clear_ids(softc);
1028 /* Allocate the default completion ring */
1029 softc->def_cp_ring.cons = UINT32_MAX;
1030 softc->def_cp_ring.v_bit = 1;
1031 bnxt_mark_cpr_invalid(&softc->def_cp_ring);
1032 rc = bnxt_hwrm_ring_alloc(softc,
1033 HWRM_RING_ALLOC_INPUT_RING_TYPE_L2_CMPL,
1034 &softc->def_cp_ring.ring,
1035 (uint16_t)HWRM_NA_SIGNATURE,
1036 HWRM_NA_SIGNATURE, true);
1040 /* And now set the default CP ring as the async CP ring */
1041 rc = bnxt_cfg_async_cr(softc);
1045 for (i = 0; i < softc->nrxqsets; i++) {
1046 /* Allocate the statistics context */
1047 rc = bnxt_hwrm_stat_ctx_alloc(softc, &softc->rx_cp_rings[i],
1048 softc->rx_stats.idi_paddr +
1049 (sizeof(struct ctx_hw_stats) * i));
1053 /* Allocate the completion ring */
1054 softc->rx_cp_rings[i].cons = UINT32_MAX;
1055 softc->rx_cp_rings[i].v_bit = 1;
1056 softc->rx_cp_rings[i].last_idx = UINT32_MAX;
1057 bnxt_mark_cpr_invalid(&softc->rx_cp_rings[i]);
1058 rc = bnxt_hwrm_ring_alloc(softc,
1059 HWRM_RING_ALLOC_INPUT_RING_TYPE_L2_CMPL,
1060 &softc->rx_cp_rings[i].ring, (uint16_t)HWRM_NA_SIGNATURE,
1061 HWRM_NA_SIGNATURE, true);
1065 /* Allocate the RX ring */
1066 rc = bnxt_hwrm_ring_alloc(softc,
1067 HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
1068 &softc->rx_rings[i], (uint16_t)HWRM_NA_SIGNATURE,
1069 HWRM_NA_SIGNATURE, false);
1072 BNXT_RX_DB(&softc->rx_rings[i], 0);
1073 /* TODO: Cumulus+ doesn't need the double doorbell */
1074 BNXT_RX_DB(&softc->rx_rings[i], 0);
1076 /* Allocate the AG ring */
1077 rc = bnxt_hwrm_ring_alloc(softc,
1078 HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
1079 &softc->ag_rings[i], (uint16_t)HWRM_NA_SIGNATURE,
1080 HWRM_NA_SIGNATURE, false);
1083 BNXT_RX_DB(&softc->rx_rings[i], 0);
1084 /* TODO: Cumulus+ doesn't need the double doorbell */
1085 BNXT_RX_DB(&softc->ag_rings[i], 0);
1087 /* Allocate the ring group */
1088 softc->grp_info[i].stats_ctx =
1089 softc->rx_cp_rings[i].stats_ctx_id;
1090 softc->grp_info[i].rx_ring_id = softc->rx_rings[i].phys_id;
1091 softc->grp_info[i].ag_ring_id = softc->ag_rings[i].phys_id;
1092 softc->grp_info[i].cp_ring_id =
1093 softc->rx_cp_rings[i].ring.phys_id;
1094 rc = bnxt_hwrm_ring_grp_alloc(softc, &softc->grp_info[i]);
1100 /* Allocate the VNIC RSS context */
1101 rc = bnxt_hwrm_vnic_ctx_alloc(softc, &softc->vnic_info.rss_id);
1105 /* Allocate the vnic */
1106 softc->vnic_info.def_ring_grp = softc->grp_info[0].grp_id;
1107 softc->vnic_info.mru = softc->scctx->isc_max_frame_size;
1108 rc = bnxt_hwrm_vnic_alloc(softc, &softc->vnic_info);
1111 rc = bnxt_hwrm_vnic_cfg(softc, &softc->vnic_info);
1114 rc = bnxt_hwrm_set_filter(softc, &softc->vnic_info);
1118 /* Enable RSS on the VNICs */
1119 for (i = 0, j = 0; i < HW_HASH_INDEX_SIZE; i++) {
1121 softc->vnic_info.rss_grp_tbl.idi_vaddr)[i] =
1122 htole16(softc->grp_info[j].grp_id);
1123 if (++j == softc->nrxqsets)
1127 rc = bnxt_hwrm_rss_cfg(softc, &softc->vnic_info,
1128 softc->vnic_info.rss_hash_type);
1132 rc = bnxt_hwrm_vnic_tpa_cfg(softc);
1136 for (i = 0; i < softc->ntxqsets; i++) {
1137 /* Allocate the statistics context */
1138 rc = bnxt_hwrm_stat_ctx_alloc(softc, &softc->tx_cp_rings[i],
1139 softc->tx_stats.idi_paddr +
1140 (sizeof(struct ctx_hw_stats) * i));
1144 /* Allocate the completion ring */
1145 softc->tx_cp_rings[i].cons = UINT32_MAX;
1146 softc->tx_cp_rings[i].v_bit = 1;
1147 bnxt_mark_cpr_invalid(&softc->tx_cp_rings[i]);
1148 rc = bnxt_hwrm_ring_alloc(softc,
1149 HWRM_RING_ALLOC_INPUT_RING_TYPE_L2_CMPL,
1150 &softc->tx_cp_rings[i].ring, (uint16_t)HWRM_NA_SIGNATURE,
1151 HWRM_NA_SIGNATURE, false);
1155 /* Allocate the TX ring */
1156 rc = bnxt_hwrm_ring_alloc(softc,
1157 HWRM_RING_ALLOC_INPUT_RING_TYPE_TX,
1158 &softc->tx_rings[i], softc->tx_cp_rings[i].ring.phys_id,
1159 softc->tx_cp_rings[i].stats_ctx_id, false);
1162 BNXT_TX_DB(&softc->tx_rings[i], 0);
1163 /* TODO: Cumulus+ doesn't need the double doorbell */
1164 BNXT_TX_DB(&softc->tx_rings[i], 0);
1167 bnxt_do_enable_intr(&softc->def_cp_ring);
1168 bnxt_media_status(softc->ctx, &ifmr);
1169 bnxt_hwrm_cfa_l2_set_rx_mask(softc, &softc->vnic_info);
1173 bnxt_hwrm_func_reset(softc);
1174 bnxt_clear_ids(softc);
1179 bnxt_stop(if_ctx_t ctx)
1181 struct bnxt_softc *softc = iflib_get_softc(ctx);
1183 bnxt_do_disable_intr(&softc->def_cp_ring);
1184 bnxt_hwrm_func_reset(softc);
1185 bnxt_clear_ids(softc);
1190 bnxt_copy_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
1194 if (cnt == BNXT_MAX_MC_ADDRS)
1197 bcopy(LLADDR(sdl), &mta[cnt * ETHER_ADDR_LEN], ETHER_ADDR_LEN);
1203 bnxt_multi_set(if_ctx_t ctx)
1205 struct bnxt_softc *softc = iflib_get_softc(ctx);
1206 if_t ifp = iflib_get_ifp(ctx);
1210 mta = softc->vnic_info.mc_list.idi_vaddr;
1211 bzero(mta, softc->vnic_info.mc_list.idi_size);
1212 mcnt = if_foreach_llmaddr(ifp, bnxt_copy_maddr, mta);
1214 if (mcnt > BNXT_MAX_MC_ADDRS) {
1215 softc->vnic_info.rx_mask |=
1216 HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;
1217 bnxt_hwrm_cfa_l2_set_rx_mask(softc, &softc->vnic_info);
1219 softc->vnic_info.rx_mask &=
1220 ~HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;
1221 bus_dmamap_sync(softc->vnic_info.mc_list.idi_tag,
1222 softc->vnic_info.mc_list.idi_map, BUS_DMASYNC_PREWRITE);
1223 softc->vnic_info.mc_list_count = mcnt;
1224 softc->vnic_info.rx_mask |=
1225 HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_MCAST;
1226 if (bnxt_hwrm_cfa_l2_set_rx_mask(softc, &softc->vnic_info))
1227 device_printf(softc->dev,
1228 "set_multi: rx_mask set failed\n");
1233 bnxt_mtu_set(if_ctx_t ctx, uint32_t mtu)
1235 struct bnxt_softc *softc = iflib_get_softc(ctx);
1237 if (mtu > BNXT_MAX_MTU)
1240 softc->scctx->isc_max_frame_size = mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
1245 bnxt_media_status(if_ctx_t ctx, struct ifmediareq * ifmr)
1247 struct bnxt_softc *softc = iflib_get_softc(ctx);
1248 struct bnxt_link_info *link_info = &softc->link_info;
1249 struct ifmedia_entry *next;
1250 uint64_t target_baudrate = bnxt_get_baudrate(link_info);
1251 int active_media = IFM_UNKNOWN;
1254 bnxt_update_link(softc, true);
1256 ifmr->ifm_status = IFM_AVALID;
1257 ifmr->ifm_active = IFM_ETHER;
1259 if (link_info->link_up)
1260 ifmr->ifm_status |= IFM_ACTIVE;
1262 ifmr->ifm_status &= ~IFM_ACTIVE;
1264 if (link_info->duplex == HWRM_PORT_PHY_QCFG_OUTPUT_DUPLEX_CFG_FULL)
1265 ifmr->ifm_active |= IFM_FDX;
1267 ifmr->ifm_active |= IFM_HDX;
1270 * Go through the list of supported media which got prepared
1271 * as part of bnxt_add_media_types() using api ifmedia_add().
1273 LIST_FOREACH(next, &(iflib_get_media(ctx)->ifm_list), ifm_list) {
1274 if (ifmedia_baudrate(next->ifm_media) == target_baudrate) {
1275 active_media = next->ifm_media;
1279 ifmr->ifm_active |= active_media;
1281 if (link_info->flow_ctrl.rx)
1282 ifmr->ifm_active |= IFM_ETH_RXPAUSE;
1283 if (link_info->flow_ctrl.tx)
1284 ifmr->ifm_active |= IFM_ETH_TXPAUSE;
1286 bnxt_report_link(softc);
1291 bnxt_media_change(if_ctx_t ctx)
1293 struct bnxt_softc *softc = iflib_get_softc(ctx);
1294 struct ifmedia *ifm = iflib_get_media(ctx);
1295 struct ifmediareq ifmr;
1298 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1301 switch (IFM_SUBTYPE(ifm->ifm_media)) {
1303 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1304 softc->link_info.req_link_speed =
1305 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_100MB;
1309 case IFM_1000_SGMII:
1310 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1311 softc->link_info.req_link_speed =
1312 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_1GB;
1316 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1317 softc->link_info.req_link_speed =
1318 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_2_5GB;
1325 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1326 softc->link_info.req_link_speed =
1327 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_10GB;
1330 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1331 softc->link_info.req_link_speed =
1332 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_20GB;
1337 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1338 softc->link_info.req_link_speed =
1339 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_25GB;
1345 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1346 softc->link_info.req_link_speed =
1347 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_40GB;
1351 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1352 softc->link_info.req_link_speed =
1353 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_50GB;
1359 softc->link_info.autoneg &= ~BNXT_AUTONEG_SPEED;
1360 softc->link_info.req_link_speed =
1361 HWRM_PORT_PHY_CFG_INPUT_FORCE_LINK_SPEED_100GB;
1364 device_printf(softc->dev,
1365 "Unsupported media type! Using auto\n");
1369 softc->link_info.autoneg |= BNXT_AUTONEG_SPEED;
1372 rc = bnxt_hwrm_set_link_setting(softc, true, true, true);
1373 bnxt_media_status(softc->ctx, &ifmr);
1378 bnxt_promisc_set(if_ctx_t ctx, int flags)
1380 struct bnxt_softc *softc = iflib_get_softc(ctx);
1381 if_t ifp = iflib_get_ifp(ctx);
1384 if (ifp->if_flags & IFF_ALLMULTI ||
1385 if_llmaddr_count(ifp) > BNXT_MAX_MC_ADDRS)
1386 softc->vnic_info.rx_mask |=
1387 HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;
1389 softc->vnic_info.rx_mask &=
1390 ~HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;
1392 if (ifp->if_flags & IFF_PROMISC)
1393 softc->vnic_info.rx_mask |=
1394 HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_PROMISCUOUS |
1395 HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN;
1397 softc->vnic_info.rx_mask &=
1398 ~(HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_PROMISCUOUS |
1399 HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN);
1401 rc = bnxt_hwrm_cfa_l2_set_rx_mask(softc, &softc->vnic_info);
1407 bnxt_get_counter(if_ctx_t ctx, ift_counter cnt)
1409 if_t ifp = iflib_get_ifp(ctx);
1411 if (cnt < IFCOUNTERS)
1412 return if_get_counter_default(ifp, cnt);
1418 bnxt_update_admin_status(if_ctx_t ctx)
1420 struct bnxt_softc *softc = iflib_get_softc(ctx);
1423 * When SR-IOV is enabled, avoid each VF sending this HWRM
1424 * request every sec with which firmware timeouts can happen
1426 if (BNXT_PF(softc)) {
1427 bnxt_hwrm_port_qstats(softc);
1434 bnxt_if_timer(if_ctx_t ctx, uint16_t qid)
1437 struct bnxt_softc *softc = iflib_get_softc(ctx);
1438 uint64_t ticks_now = ticks;
1440 /* Schedule bnxt_update_admin_status() once per sec */
1441 if (ticks_now - softc->admin_ticks >= hz) {
1442 softc->admin_ticks = ticks_now;
1443 iflib_admin_intr_deferred(ctx);
1450 bnxt_do_enable_intr(struct bnxt_cp_ring *cpr)
1452 if (cpr->ring.phys_id != (uint16_t)HWRM_NA_SIGNATURE) {
1453 /* First time enabling, do not set index */
1454 if (cpr->cons == UINT32_MAX)
1455 BNXT_CP_ENABLE_DB(&cpr->ring);
1457 BNXT_CP_IDX_ENABLE_DB(&cpr->ring, cpr->cons);
1462 bnxt_do_disable_intr(struct bnxt_cp_ring *cpr)
1464 if (cpr->ring.phys_id != (uint16_t)HWRM_NA_SIGNATURE)
1465 BNXT_CP_DISABLE_DB(&cpr->ring);
1468 /* Enable all interrupts */
1470 bnxt_intr_enable(if_ctx_t ctx)
1472 struct bnxt_softc *softc = iflib_get_softc(ctx);
1475 bnxt_do_enable_intr(&softc->def_cp_ring);
1476 for (i = 0; i < softc->nrxqsets; i++)
1477 bnxt_do_enable_intr(&softc->rx_cp_rings[i]);
1482 /* Enable interrupt for a single queue */
1484 bnxt_tx_queue_intr_enable(if_ctx_t ctx, uint16_t qid)
1486 struct bnxt_softc *softc = iflib_get_softc(ctx);
1488 bnxt_do_enable_intr(&softc->tx_cp_rings[qid]);
1493 bnxt_rx_queue_intr_enable(if_ctx_t ctx, uint16_t qid)
1495 struct bnxt_softc *softc = iflib_get_softc(ctx);
1497 bnxt_do_enable_intr(&softc->rx_cp_rings[qid]);
1501 /* Disable all interrupts */
1503 bnxt_disable_intr(if_ctx_t ctx)
1505 struct bnxt_softc *softc = iflib_get_softc(ctx);
1509 * NOTE: These TX interrupts should never get enabled, so don't
1512 for (i = 0; i < softc->ntxqsets; i++)
1513 bnxt_do_disable_intr(&softc->tx_cp_rings[i]);
1514 for (i = 0; i < softc->nrxqsets; i++)
1515 bnxt_do_disable_intr(&softc->rx_cp_rings[i]);
1521 bnxt_msix_intr_assign(if_ctx_t ctx, int msix)
1523 struct bnxt_softc *softc = iflib_get_softc(ctx);
1528 rc = iflib_irq_alloc_generic(ctx, &softc->def_cp_ring.irq,
1529 softc->def_cp_ring.ring.id + 1, IFLIB_INTR_ADMIN,
1530 bnxt_handle_def_cp, softc, 0, "def_cp");
1532 device_printf(iflib_get_dev(ctx),
1533 "Failed to register default completion ring handler\n");
1537 for (i=0; i<softc->scctx->isc_nrxqsets; i++) {
1538 snprintf(irq_name, sizeof(irq_name), "rxq%d", i);
1539 rc = iflib_irq_alloc_generic(ctx, &softc->rx_cp_rings[i].irq,
1540 softc->rx_cp_rings[i].ring.id + 1, IFLIB_INTR_RX,
1541 bnxt_handle_rx_cp, &softc->rx_cp_rings[i], i, irq_name);
1543 device_printf(iflib_get_dev(ctx),
1544 "Failed to register RX completion ring handler\n");
1550 for (i=0; i<softc->scctx->isc_ntxqsets; i++)
1551 iflib_softirq_alloc_generic(ctx, NULL, IFLIB_INTR_TX, NULL, i, "tx_cp");
1557 iflib_irq_free(ctx, &softc->rx_cp_rings[i].irq);
1558 iflib_irq_free(ctx, &softc->def_cp_ring.irq);
1563 * We're explicitly allowing duplicates here. They will need to be
1564 * removed as many times as they are added.
1567 bnxt_vlan_register(if_ctx_t ctx, uint16_t vtag)
1569 struct bnxt_softc *softc = iflib_get_softc(ctx);
1570 struct bnxt_vlan_tag *new_tag;
1572 new_tag = malloc(sizeof(struct bnxt_vlan_tag), M_DEVBUF, M_NOWAIT);
1573 if (new_tag == NULL)
1575 new_tag->tag = vtag;
1576 new_tag->tpid = 8100;
1577 SLIST_INSERT_HEAD(&softc->vnic_info.vlan_tags, new_tag, next);
1581 bnxt_vlan_unregister(if_ctx_t ctx, uint16_t vtag)
1583 struct bnxt_softc *softc = iflib_get_softc(ctx);
1584 struct bnxt_vlan_tag *vlan_tag;
1586 SLIST_FOREACH(vlan_tag, &softc->vnic_info.vlan_tags, next) {
1587 if (vlan_tag->tag == vtag) {
1588 SLIST_REMOVE(&softc->vnic_info.vlan_tags, vlan_tag,
1589 bnxt_vlan_tag, next);
1590 free(vlan_tag, M_DEVBUF);
1597 bnxt_wol_config(if_ctx_t ctx)
1599 struct bnxt_softc *softc = iflib_get_softc(ctx);
1600 if_t ifp = iflib_get_ifp(ctx);
1605 if (!bnxt_wol_supported(softc))
1608 if (if_getcapabilities(ifp) & IFCAP_WOL_MAGIC) {
1610 if (bnxt_hwrm_alloc_wol_fltr(softc))
1616 if (bnxt_hwrm_free_wol_fltr(softc))
1626 bnxt_shutdown(if_ctx_t ctx)
1628 bnxt_wol_config(ctx);
1633 bnxt_suspend(if_ctx_t ctx)
1635 bnxt_wol_config(ctx);
1640 bnxt_resume(if_ctx_t ctx)
1642 struct bnxt_softc *softc = iflib_get_softc(ctx);
1644 bnxt_get_wol_settings(softc);
1649 bnxt_priv_ioctl(if_ctx_t ctx, u_long command, caddr_t data)
1651 struct bnxt_softc *softc = iflib_get_softc(ctx);
1652 struct ifreq *ifr = (struct ifreq *)data;
1653 struct bnxt_ioctl_header *ioh;
1656 struct bnxt_ioctl_data iod_storage, *iod = &iod_storage;
1660 case SIOCGPRIVATE_0:
1661 if ((rc = priv_check(curthread, PRIV_DRIVER)) != 0)
1664 ioh = ifr_buffer_get_buffer(ifr);
1665 iol = ifr_buffer_get_length(ifr);
1666 if (iol > sizeof(iod_storage))
1669 if ((rc = copyin(ioh, iod, iol)) != 0)
1672 switch (iod->hdr.type) {
1673 case BNXT_HWRM_NVM_FIND_DIR_ENTRY:
1675 struct bnxt_ioctl_hwrm_nvm_find_dir_entry *find =
1678 rc = bnxt_hwrm_nvm_find_dir_entry(softc, find->type,
1679 &find->ordinal, find->ext, &find->index,
1680 find->use_index, find->search_opt,
1681 &find->data_length, &find->item_length,
1685 copyout(&iod->hdr.rc, &ioh->rc,
1690 copyout(iod, ioh, iol);
1696 case BNXT_HWRM_NVM_READ:
1698 struct bnxt_ioctl_hwrm_nvm_read *rd = &iod->read;
1699 struct iflib_dma_info dma_data;
1705 * Some HWRM versions can't read more than 0x8000 bytes
1707 rc = iflib_dma_alloc(softc->ctx,
1708 min(rd->length, 0x8000), &dma_data, BUS_DMA_NOWAIT);
1711 for (remain = rd->length, offset = 0;
1712 remain && offset < rd->length; offset += 0x8000) {
1713 csize = min(remain, 0x8000);
1714 rc = bnxt_hwrm_nvm_read(softc, rd->index,
1715 rd->offset + offset, csize, &dma_data);
1718 copyout(&iod->hdr.rc, &ioh->rc,
1723 copyout(dma_data.idi_vaddr,
1724 rd->data + offset, csize);
1729 if (iod->hdr.rc == 0)
1730 copyout(iod, ioh, iol);
1732 iflib_dma_free(&dma_data);
1736 case BNXT_HWRM_FW_RESET:
1738 struct bnxt_ioctl_hwrm_fw_reset *rst =
1741 rc = bnxt_hwrm_fw_reset(softc, rst->processor,
1745 copyout(&iod->hdr.rc, &ioh->rc,
1750 copyout(iod, ioh, iol);
1756 case BNXT_HWRM_FW_QSTATUS:
1758 struct bnxt_ioctl_hwrm_fw_qstatus *qstat =
1761 rc = bnxt_hwrm_fw_qstatus(softc, qstat->processor,
1765 copyout(&iod->hdr.rc, &ioh->rc,
1770 copyout(iod, ioh, iol);
1776 case BNXT_HWRM_NVM_WRITE:
1778 struct bnxt_ioctl_hwrm_nvm_write *wr =
1781 rc = bnxt_hwrm_nvm_write(softc, wr->data, true,
1782 wr->type, wr->ordinal, wr->ext, wr->attr,
1783 wr->option, wr->data_length, wr->keep,
1784 &wr->item_length, &wr->index);
1787 copyout(&iod->hdr.rc, &ioh->rc,
1792 copyout(iod, ioh, iol);
1798 case BNXT_HWRM_NVM_ERASE_DIR_ENTRY:
1800 struct bnxt_ioctl_hwrm_nvm_erase_dir_entry *erase =
1803 rc = bnxt_hwrm_nvm_erase_dir_entry(softc, erase->index);
1806 copyout(&iod->hdr.rc, &ioh->rc,
1811 copyout(iod, ioh, iol);
1817 case BNXT_HWRM_NVM_GET_DIR_INFO:
1819 struct bnxt_ioctl_hwrm_nvm_get_dir_info *info =
1822 rc = bnxt_hwrm_nvm_get_dir_info(softc, &info->entries,
1823 &info->entry_length);
1826 copyout(&iod->hdr.rc, &ioh->rc,
1831 copyout(iod, ioh, iol);
1837 case BNXT_HWRM_NVM_GET_DIR_ENTRIES:
1839 struct bnxt_ioctl_hwrm_nvm_get_dir_entries *get =
1841 struct iflib_dma_info dma_data;
1843 rc = iflib_dma_alloc(softc->ctx, get->max_size,
1844 &dma_data, BUS_DMA_NOWAIT);
1847 rc = bnxt_hwrm_nvm_get_dir_entries(softc, &get->entries,
1848 &get->entry_length, &dma_data);
1851 copyout(&iod->hdr.rc, &ioh->rc,
1855 copyout(dma_data.idi_vaddr, get->data,
1856 get->entry_length * get->entries);
1858 copyout(iod, ioh, iol);
1860 iflib_dma_free(&dma_data);
1865 case BNXT_HWRM_NVM_VERIFY_UPDATE:
1867 struct bnxt_ioctl_hwrm_nvm_verify_update *vrfy =
1870 rc = bnxt_hwrm_nvm_verify_update(softc, vrfy->type,
1871 vrfy->ordinal, vrfy->ext);
1874 copyout(&iod->hdr.rc, &ioh->rc,
1879 copyout(iod, ioh, iol);
1885 case BNXT_HWRM_NVM_INSTALL_UPDATE:
1887 struct bnxt_ioctl_hwrm_nvm_install_update *inst =
1890 rc = bnxt_hwrm_nvm_install_update(softc,
1891 inst->install_type, &inst->installed_items,
1892 &inst->result, &inst->problem_item,
1893 &inst->reset_required);
1896 copyout(&iod->hdr.rc, &ioh->rc,
1901 copyout(iod, ioh, iol);
1907 case BNXT_HWRM_NVM_MODIFY:
1909 struct bnxt_ioctl_hwrm_nvm_modify *mod = &iod->modify;
1911 rc = bnxt_hwrm_nvm_modify(softc, mod->index,
1912 mod->offset, mod->data, true, mod->length);
1915 copyout(&iod->hdr.rc, &ioh->rc,
1920 copyout(iod, ioh, iol);
1926 case BNXT_HWRM_FW_GET_TIME:
1928 struct bnxt_ioctl_hwrm_fw_get_time *gtm =
1931 rc = bnxt_hwrm_fw_get_time(softc, >m->year,
1932 >m->month, >m->day, >m->hour, >m->minute,
1933 >m->second, >m->millisecond, >m->zone);
1936 copyout(&iod->hdr.rc, &ioh->rc,
1941 copyout(iod, ioh, iol);
1947 case BNXT_HWRM_FW_SET_TIME:
1949 struct bnxt_ioctl_hwrm_fw_set_time *stm =
1952 rc = bnxt_hwrm_fw_set_time(softc, stm->year,
1953 stm->month, stm->day, stm->hour, stm->minute,
1954 stm->second, stm->millisecond, stm->zone);
1957 copyout(&iod->hdr.rc, &ioh->rc,
1962 copyout(iod, ioh, iol);
1980 bnxt_probe_phy(struct bnxt_softc *softc)
1982 struct bnxt_link_info *link_info = &softc->link_info;
1985 rc = bnxt_update_link(softc, false);
1987 device_printf(softc->dev,
1988 "Probe phy can't update link (rc: %x)\n", rc);
1992 /*initialize the ethool setting copy with NVM settings */
1993 if (link_info->auto_mode != HWRM_PORT_PHY_QCFG_OUTPUT_AUTO_MODE_NONE)
1994 link_info->autoneg |= BNXT_AUTONEG_SPEED;
1996 link_info->req_duplex = link_info->duplex_setting;
1997 if (link_info->autoneg & BNXT_AUTONEG_SPEED)
1998 link_info->req_link_speed = link_info->auto_link_speed;
2000 link_info->req_link_speed = link_info->force_link_speed;
2005 bnxt_add_media_types(struct bnxt_softc *softc)
2007 struct bnxt_link_info *link_info = &softc->link_info;
2009 uint8_t phy_type = get_phy_type(softc);
2011 supported = link_info->support_speeds;
2013 /* Auto is always supported */
2014 ifmedia_add(softc->media, IFM_ETHER | IFM_AUTO, 0, NULL);
2016 if (softc->flags & BNXT_FLAG_NPAR)
2020 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_100G_BASECR4:
2021 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_40G_BASECR4:
2022 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_25G_BASECR_CA_L:
2023 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_25G_BASECR_CA_S:
2024 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_25G_BASECR_CA_N:
2025 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASECR:
2026 BNXT_IFMEDIA_ADD(supported, SPEEDS_100GB, IFM_100G_CR4);
2027 BNXT_IFMEDIA_ADD(supported, SPEEDS_50GB, IFM_50G_CR2);
2028 BNXT_IFMEDIA_ADD(supported, SPEEDS_40GB, IFM_40G_CR4);
2029 BNXT_IFMEDIA_ADD(supported, SPEEDS_25GB, IFM_25G_CR);
2030 BNXT_IFMEDIA_ADD(supported, SPEEDS_10GB, IFM_10G_CR1);
2031 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GB, IFM_1000_T);
2034 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_100G_BASELR4:
2035 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_40G_BASELR4:
2036 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASELR:
2037 BNXT_IFMEDIA_ADD(supported, SPEEDS_100GB, IFM_100G_LR4);
2038 BNXT_IFMEDIA_ADD(supported, SPEEDS_40GB, IFM_40G_LR4);
2039 BNXT_IFMEDIA_ADD(supported, SPEEDS_25GB, IFM_25G_LR);
2040 BNXT_IFMEDIA_ADD(supported, SPEEDS_10GB, IFM_10G_LR);
2041 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GB, IFM_1000_LX);
2044 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_100G_BASESR10:
2045 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_100G_BASESR4:
2046 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_40G_BASESR4:
2047 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASESR:
2048 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_40G_BASEER4:
2049 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_100G_BASEER4:
2050 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_25G_BASESR:
2051 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_1G_BASESX:
2052 BNXT_IFMEDIA_ADD(supported, SPEEDS_100GB, IFM_100G_SR4);
2053 BNXT_IFMEDIA_ADD(supported, SPEEDS_40GB, IFM_40G_SR4);
2054 BNXT_IFMEDIA_ADD(supported, SPEEDS_25GB, IFM_25G_SR);
2055 BNXT_IFMEDIA_ADD(supported, SPEEDS_10GB, IFM_10G_SR);
2056 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GB, IFM_1000_SX);
2059 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASEKR4:
2060 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASEKR2:
2061 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASEKR:
2062 BNXT_IFMEDIA_ADD(supported, SPEEDS_100GB, IFM_100G_KR4);
2063 BNXT_IFMEDIA_ADD(supported, SPEEDS_50GB, IFM_50G_KR2);
2064 BNXT_IFMEDIA_ADD(supported, SPEEDS_40GB, IFM_40G_KR4);
2065 BNXT_IFMEDIA_ADD(supported, SPEEDS_25GB, IFM_25G_KR);
2066 BNXT_IFMEDIA_ADD(supported, SPEEDS_20GB, IFM_20G_KR2);
2067 BNXT_IFMEDIA_ADD(supported, SPEEDS_10GB, IFM_10G_KR);
2068 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GB, IFM_1000_KX);
2071 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_40G_ACTIVE_CABLE:
2072 BNXT_IFMEDIA_ADD(supported, SPEEDS_25GB, IFM_25G_ACC);
2073 BNXT_IFMEDIA_ADD(supported, SPEEDS_10GB, IFM_10G_AOC);
2076 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_1G_BASECX:
2077 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GBHD, IFM_1000_CX);
2080 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_1G_BASET:
2081 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASET:
2082 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASETE:
2083 BNXT_IFMEDIA_ADD(supported, SPEEDS_10GB, IFM_10G_T);
2084 BNXT_IFMEDIA_ADD(supported, SPEEDS_2_5GB, IFM_2500_T);
2085 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GB, IFM_1000_T);
2086 BNXT_IFMEDIA_ADD(supported, SPEEDS_100MB, IFM_100_T);
2087 BNXT_IFMEDIA_ADD(supported, SPEEDS_10MB, IFM_10_T);
2090 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASEKX:
2091 BNXT_IFMEDIA_ADD(supported, SPEEDS_10GB, IFM_10G_KR);
2092 BNXT_IFMEDIA_ADD(supported, SPEEDS_2_5GB, IFM_2500_KX);
2093 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GB, IFM_1000_KX);
2096 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_SGMIIEXTPHY:
2097 BNXT_IFMEDIA_ADD(supported, SPEEDS_1GB, IFM_1000_SGMII);
2100 case HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_UNKNOWN:
2101 /* Only Autoneg is supported for TYPE_UNKNOWN */
2102 device_printf(softc->dev, "Unknown phy type\n");
2106 /* Only Autoneg is supported for new phy type values */
2107 device_printf(softc->dev, "phy type %d not supported by driver\n", phy_type);
2115 bnxt_map_bar(struct bnxt_softc *softc, struct bnxt_bar_info *bar, int bar_num, bool shareable)
2119 if (bar->res != NULL) {
2120 device_printf(softc->dev, "Bar %d already mapped\n", bar_num);
2124 bar->rid = PCIR_BAR(bar_num);
2127 flag |= RF_SHAREABLE;
2130 bus_alloc_resource_any(softc->dev,
2134 device_printf(softc->dev,
2135 "PCI BAR%d mapping failure\n", bar_num);
2138 bar->tag = rman_get_bustag(bar->res);
2139 bar->handle = rman_get_bushandle(bar->res);
2140 bar->size = rman_get_size(bar->res);
2146 bnxt_pci_mapping(struct bnxt_softc *softc)
2150 rc = bnxt_map_bar(softc, &softc->hwrm_bar, 0, true);
2154 rc = bnxt_map_bar(softc, &softc->doorbell_bar, 2, false);
2160 bnxt_pci_mapping_free(struct bnxt_softc *softc)
2162 if (softc->hwrm_bar.res != NULL)
2163 bus_release_resource(softc->dev, SYS_RES_MEMORY,
2164 softc->hwrm_bar.rid, softc->hwrm_bar.res);
2165 softc->hwrm_bar.res = NULL;
2167 if (softc->doorbell_bar.res != NULL)
2168 bus_release_resource(softc->dev, SYS_RES_MEMORY,
2169 softc->doorbell_bar.rid, softc->doorbell_bar.res);
2170 softc->doorbell_bar.res = NULL;
2174 bnxt_update_link(struct bnxt_softc *softc, bool chng_link_state)
2176 struct bnxt_link_info *link_info = &softc->link_info;
2177 uint8_t link_up = link_info->link_up;
2180 rc = bnxt_hwrm_port_phy_qcfg(softc);
2184 /* TODO: need to add more logic to report VF link */
2185 if (chng_link_state) {
2186 if (link_info->phy_link_status ==
2187 HWRM_PORT_PHY_QCFG_OUTPUT_LINK_LINK)
2188 link_info->link_up = 1;
2190 link_info->link_up = 0;
2191 if (link_up != link_info->link_up)
2192 bnxt_report_link(softc);
2194 /* always link down if not require to update link state */
2195 link_info->link_up = 0;
2203 bnxt_report_link(struct bnxt_softc *softc)
2205 struct bnxt_link_info *link_info = &softc->link_info;
2206 const char *duplex = NULL, *flow_ctrl = NULL;
2208 if (link_info->link_up == link_info->last_link_up) {
2209 if (!link_info->link_up)
2211 if ((link_info->duplex == link_info->last_duplex) &&
2212 (!(BNXT_IS_FLOW_CTRL_CHANGED(link_info))))
2216 if (link_info->link_up) {
2217 if (link_info->duplex ==
2218 HWRM_PORT_PHY_QCFG_OUTPUT_DUPLEX_CFG_FULL)
2219 duplex = "full duplex";
2221 duplex = "half duplex";
2222 if (link_info->flow_ctrl.tx & link_info->flow_ctrl.rx)
2223 flow_ctrl = "FC - receive & transmit";
2224 else if (link_info->flow_ctrl.tx)
2225 flow_ctrl = "FC - transmit";
2226 else if (link_info->flow_ctrl.rx)
2227 flow_ctrl = "FC - receive";
2229 flow_ctrl = "FC - none";
2230 iflib_link_state_change(softc->ctx, LINK_STATE_UP,
2232 device_printf(softc->dev, "Link is UP %s, %s - %d Mbps \n", duplex,
2233 flow_ctrl, (link_info->link_speed * 100));
2235 iflib_link_state_change(softc->ctx, LINK_STATE_DOWN,
2236 bnxt_get_baudrate(&softc->link_info));
2237 device_printf(softc->dev, "Link is Down\n");
2240 link_info->last_link_up = link_info->link_up;
2241 link_info->last_duplex = link_info->duplex;
2242 link_info->last_flow_ctrl.tx = link_info->flow_ctrl.tx;
2243 link_info->last_flow_ctrl.rx = link_info->flow_ctrl.rx;
2244 link_info->last_flow_ctrl.autoneg = link_info->flow_ctrl.autoneg;
2245 /* update media types */
2246 ifmedia_removeall(softc->media);
2247 bnxt_add_media_types(softc);
2248 ifmedia_set(softc->media, IFM_ETHER | IFM_AUTO);
2252 bnxt_handle_rx_cp(void *arg)
2254 struct bnxt_cp_ring *cpr = arg;
2256 /* Disable further interrupts for this queue */
2257 BNXT_CP_DISABLE_DB(&cpr->ring);
2258 return FILTER_SCHEDULE_THREAD;
2262 bnxt_handle_def_cp(void *arg)
2264 struct bnxt_softc *softc = arg;
2266 BNXT_CP_DISABLE_DB(&softc->def_cp_ring.ring);
2267 GROUPTASK_ENQUEUE(&softc->def_cp_task);
2268 return FILTER_HANDLED;
2272 bnxt_clear_ids(struct bnxt_softc *softc)
2276 softc->def_cp_ring.stats_ctx_id = HWRM_NA_SIGNATURE;
2277 softc->def_cp_ring.ring.phys_id = (uint16_t)HWRM_NA_SIGNATURE;
2278 for (i = 0; i < softc->ntxqsets; i++) {
2279 softc->tx_cp_rings[i].stats_ctx_id = HWRM_NA_SIGNATURE;
2280 softc->tx_cp_rings[i].ring.phys_id =
2281 (uint16_t)HWRM_NA_SIGNATURE;
2282 softc->tx_rings[i].phys_id = (uint16_t)HWRM_NA_SIGNATURE;
2284 for (i = 0; i < softc->nrxqsets; i++) {
2285 softc->rx_cp_rings[i].stats_ctx_id = HWRM_NA_SIGNATURE;
2286 softc->rx_cp_rings[i].ring.phys_id =
2287 (uint16_t)HWRM_NA_SIGNATURE;
2288 softc->rx_rings[i].phys_id = (uint16_t)HWRM_NA_SIGNATURE;
2289 softc->ag_rings[i].phys_id = (uint16_t)HWRM_NA_SIGNATURE;
2290 softc->grp_info[i].grp_id = (uint16_t)HWRM_NA_SIGNATURE;
2292 softc->vnic_info.filter_id = -1;
2293 softc->vnic_info.id = (uint16_t)HWRM_NA_SIGNATURE;
2294 softc->vnic_info.rss_id = (uint16_t)HWRM_NA_SIGNATURE;
2295 memset(softc->vnic_info.rss_grp_tbl.idi_vaddr, 0xff,
2296 softc->vnic_info.rss_grp_tbl.idi_size);
2300 bnxt_mark_cpr_invalid(struct bnxt_cp_ring *cpr)
2302 struct cmpl_base *cmp = (void *)cpr->ring.vaddr;
2305 for (i = 0; i < cpr->ring.ring_size; i++)
2306 cmp[i].info3_v = !cpr->v_bit;
2310 bnxt_handle_async_event(struct bnxt_softc *softc, struct cmpl_base *cmpl)
2312 struct hwrm_async_event_cmpl *ae = (void *)cmpl;
2313 uint16_t async_id = le16toh(ae->event_id);
2314 struct ifmediareq ifmr;
2317 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE:
2318 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CHANGE:
2319 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_CHANGE:
2320 bnxt_media_status(softc->ctx, &ifmr);
2322 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_MTU_CHANGE:
2323 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_DCB_CONFIG_CHANGE:
2324 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PORT_CONN_NOT_ALLOWED:
2325 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_NOT_ALLOWED:
2326 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_FUNC_DRVR_UNLOAD:
2327 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_FUNC_DRVR_LOAD:
2328 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD:
2329 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_LOAD:
2330 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_FLR:
2331 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_MAC_ADDR_CHANGE:
2332 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_VF_COMM_STATUS_CHANGE:
2333 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_CFG_CHANGE:
2334 case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_HWRM_ERROR:
2335 device_printf(softc->dev,
2336 "Unhandled async completion type %u\n", async_id);
2339 device_printf(softc->dev,
2340 "Unknown async completion type %u\n", async_id);
2346 bnxt_def_cp_task(void *context)
2348 if_ctx_t ctx = context;
2349 struct bnxt_softc *softc = iflib_get_softc(ctx);
2350 struct bnxt_cp_ring *cpr = &softc->def_cp_ring;
2352 /* Handle completions on the default completion ring */
2353 struct cmpl_base *cmpl;
2354 uint32_t cons = cpr->cons;
2355 bool v_bit = cpr->v_bit;
2363 NEXT_CP_CONS_V(&cpr->ring, cons, v_bit);
2364 cmpl = &((struct cmpl_base *)cpr->ring.vaddr)[cons];
2366 if (!CMP_VALID(cmpl, v_bit))
2369 type = le16toh(cmpl->type) & CMPL_BASE_TYPE_MASK;
2371 case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
2372 bnxt_handle_async_event(softc, cmpl);
2374 case CMPL_BASE_TYPE_TX_L2:
2375 case CMPL_BASE_TYPE_RX_L2:
2376 case CMPL_BASE_TYPE_RX_AGG:
2377 case CMPL_BASE_TYPE_RX_TPA_START:
2378 case CMPL_BASE_TYPE_RX_TPA_END:
2379 case CMPL_BASE_TYPE_STAT_EJECT:
2380 case CMPL_BASE_TYPE_HWRM_DONE:
2381 case CMPL_BASE_TYPE_HWRM_FWD_REQ:
2382 case CMPL_BASE_TYPE_HWRM_FWD_RESP:
2383 case CMPL_BASE_TYPE_CQ_NOTIFICATION:
2384 case CMPL_BASE_TYPE_SRQ_EVENT:
2385 case CMPL_BASE_TYPE_DBQ_EVENT:
2386 case CMPL_BASE_TYPE_QP_EVENT:
2387 case CMPL_BASE_TYPE_FUNC_EVENT:
2388 device_printf(softc->dev,
2389 "Unhandled completion type %u\n", type);
2392 device_printf(softc->dev,
2393 "Unknown completion type %u\n", type);
2398 cpr->cons = last_cons;
2399 cpr->v_bit = last_v_bit;
2400 BNXT_CP_IDX_ENABLE_DB(&cpr->ring, cpr->cons);
2404 get_phy_type(struct bnxt_softc *softc)
2406 struct bnxt_link_info *link_info = &softc->link_info;
2407 uint8_t phy_type = link_info->phy_type;
2410 if (phy_type != HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_UNKNOWN)
2413 /* Deduce the phy type from the media type and supported speeds */
2414 supported = link_info->support_speeds;
2416 if (link_info->media_type ==
2417 HWRM_PORT_PHY_QCFG_OUTPUT_MEDIA_TYPE_TP)
2418 return HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASET;
2419 if (link_info->media_type ==
2420 HWRM_PORT_PHY_QCFG_OUTPUT_MEDIA_TYPE_DAC) {
2421 if (supported & HWRM_PORT_PHY_QCFG_OUTPUT_SUPPORT_SPEEDS_2_5GB)
2422 return HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASEKX;
2423 if (supported & HWRM_PORT_PHY_QCFG_OUTPUT_SUPPORT_SPEEDS_20GB)
2424 return HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASEKR;
2425 return HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASECR;
2427 if (link_info->media_type ==
2428 HWRM_PORT_PHY_QCFG_OUTPUT_MEDIA_TYPE_FIBRE)
2429 return HWRM_PORT_PHY_QCFG_OUTPUT_PHY_TYPE_BASESR;
2435 bnxt_check_hwrm_version(struct bnxt_softc *softc)
2439 sprintf(buf, "%hhu.%hhu.%hhu", softc->ver_info->hwrm_min_major,
2440 softc->ver_info->hwrm_min_minor, softc->ver_info->hwrm_min_update);
2441 if (softc->ver_info->hwrm_min_major > softc->ver_info->hwrm_if_major) {
2442 device_printf(softc->dev,
2443 "WARNING: HWRM version %s is too old (older than %s)\n",
2444 softc->ver_info->hwrm_if_ver, buf);
2447 else if(softc->ver_info->hwrm_min_major ==
2448 softc->ver_info->hwrm_if_major) {
2449 if (softc->ver_info->hwrm_min_minor >
2450 softc->ver_info->hwrm_if_minor) {
2451 device_printf(softc->dev,
2452 "WARNING: HWRM version %s is too old (older than %s)\n",
2453 softc->ver_info->hwrm_if_ver, buf);
2456 else if (softc->ver_info->hwrm_min_minor ==
2457 softc->ver_info->hwrm_if_minor) {
2458 if (softc->ver_info->hwrm_min_update >
2459 softc->ver_info->hwrm_if_update) {
2460 device_printf(softc->dev,
2461 "WARNING: HWRM version %s is too old (older than %s)\n",
2462 softc->ver_info->hwrm_if_ver, buf);
2471 bnxt_get_baudrate(struct bnxt_link_info *link)
2473 switch (link->link_speed) {
2474 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_100MB:
2475 return IF_Mbps(100);
2476 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_1GB:
2478 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_2GB:
2480 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_2_5GB:
2481 return IF_Mbps(2500);
2482 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_10GB:
2484 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_20GB:
2486 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_25GB:
2488 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_40GB:
2490 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_50GB:
2492 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_100GB:
2493 return IF_Gbps(100);
2494 case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_10MB:
2497 return IF_Gbps(100);
2501 bnxt_get_wol_settings(struct bnxt_softc *softc)
2503 uint16_t wol_handle = 0;
2505 if (!bnxt_wol_supported(softc))
2509 wol_handle = bnxt_hwrm_get_wol_fltrs(softc, wol_handle);
2510 } while (wol_handle && wol_handle != BNXT_NO_MORE_WOL_FILTERS);